droidmap
You can use this MCP server to analyze an Android project’s droidmap graph, inspect dependencies, and run Android-specific rules.
Run
droidmap_checkto list findings for Room, Navigation, Hilt/Koin, WorkManager, manifests, Gradle, DataStore, and related rules, optionally filtered by severity.Use
droidmap_impactto see everything transitively depending on a class, entity, route, ViewModel, or module before changing it.Use
droidmap_diffto see what changed since a git ref, what depends on those changes, and which tests cover them.Inspect one node’s attributes, direct dependencies, and users with
droidmap_show.Search graph nodes by id or name with
droidmap_find.Generate a Markdown project overview with
droidmap_report, covering modules, Room, navigation, Hilt, and findings.Get rule explanations and fix guidance with
droidmap_explainfor a specified droidmap rule.
Provides an Android-aware code graph and analysis for Android projects, reading Gradle, Room, Navigation, Hilt, Koin, manifests, and Kotlin/Java sources to detect migration, navigation, dependency-injection, permission, and module-rule issues, with impact analysis, PR diff summaries, and targeted test selection for AI coding agents.
droidmap
An Android-aware map of your project, for you, your pull requests and your AI coding agent.
Generic code graphs see classes and calls. They do not see that:
version 4 of your Room database has no migration to version 5, so users on 4 crash on update;
an entity gained a column but the database version was not bumped, which crashes on update too;
your migration test is named
migrationFrom1To4but runs 1→2→3→4, while users on version 1 getMIGRATION_1_4, which no test runs;a change removed
Status.PAUSED, but Room stored it by name in users' rows, which now crash when read;navigate("settings")points at a route noNavHostregisters;a screen gets its
@HiltViewModelwithviewModel()instead ofhiltViewModel(), and crashes when it opens;a ViewModel injects a repository that nothing binds, in Hilt or in Koin (a crash at runtime with Koin);
a library added
ACCESS_NETWORK_STATEto your merged manifest;a feature module gets
:core:datathrough a convention plugin inbuild-logic, which your module rules forbid.
droidmap reads the Android wiring directly (Gradle, Room, Navigation, Hilt, Koin, the manifest, in Kotlin and Java) and turns it into a graph. Run its rules in CI, get a comment on every pull request saying what the change touches, ask it what depends on a class before you change it, and hand it to an AI agent over MCP.
It reads source files only: it never runs Gradle, never compiles your code and never sends anything anywhere. (The GitHub Action runs one Gradle task, for the merged manifest, only when you ask it to.)
On a real app
Now in Android (35 modules, Hilt, Room, Navigation 3), on a laptop, in about 1.5 seconds each:
$ droidmap check
warning room-migration-untested core/database/src/main/kotlin/com/google/samples/apps/nowinandroid/core/database/NiaDatabase.kt:66
NiaDatabase: 13 of 13 migration steps have no MigrationTestHelper test (1->2, 2->3, 3->4,
4->5, 5->6, 6->7, 7->8, 8->9, 9->10, 10->11, 11->12, 12->13, 13->14)
1 warningAfter a one-line change to OfflineFirstTopicsRepository.syncWith (output shortened):
$ droidmap diff
Changed (1): OfflineFirstTopicsRepository (injectable)
Affected (what depends on the changed code):
Screens: ForYouScreen, InterestsScreen, TopicScreen
Navigation destinations: ForYouNavKey, InterestsNavKey, TopicNavKey
ViewModels: ForYouViewModel, InterestsViewModel, TopicViewModel
Dependency injection: DataModule.bindsTopicRepository, GetFollowableTopicsUseCase, SyncWorker
Modules: :app, :app-nia-catalog, :core:data, :core:data-test, :core:domain, ... and 12 more
Tests that cover it (1): OfflineFirstTopicsRepositoryTest
$ droidmap diff --format tests
:core:data:test --tests com.google.samples.apps.nowinandroid.core.data.repository.OfflineFirstTopicsRepositoryTestThe last line goes straight to ./gradlew in CI: one test class instead of the whole suite (see Run only the tests a change can break).
Install
macOS or Linux:
curl -fsSL https://raw.githubusercontent.com/hussainshirazi/droidmap/main/install.sh | shWindows (PowerShell):
irm https://raw.githubusercontent.com/hussainshirazi/droidmap/main/install.ps1 | iexHomebrew: brew tap hussainshirazi/droidmap https://github.com/hussainshirazi/droidmap then brew install droidmap. Scoop: scoop bucket add droidmap https://github.com/hussainshirazi/droidmap then scoop install droidmap/droidmap.
Docker, for CI systems other than GitHub Actions (GitLab, Bitbucket, Jenkins, Bitrise): docker run --rm -v "$PWD":/project ghcr.io/hussainshirazi/droidmap check (from version 0.2.0).
Gradle (from version 0.3.0), in the root build.gradle.kts; then ./gradlew droidmapCheck fails the build on errors:
plugins { id("io.github.hussainshirazi.droidmap") version "0.4.0" }
droidmap {
failOn.set("warning") // error (the default), warning, info or never
mergedManifest.set(true) // run each processReleaseMainManifest first: library permissions are checked too
}Or download droidmap.jar from the latest release and run java -jar droidmap.jar. droidmap needs Java 17 or newer. The droidmap command uses JAVA_HOME, the java on your PATH, or else the Java that Android Studio brings, so with Android Studio installed there is nothing to set up. The jar is about 65 MB because it carries the Kotlin compiler's parser.
Related MCP server: cg-mcp
Quick start
From anywhere inside your project:
droidmap init # once: the GitHub workflow and the MCP config for AI agents
droidmap check # run the rules; exit code 1 on errors
droidmap impact TopicEntity # what depends on it, transitively
droidmap diff # what your uncommitted changes touch
droidmap diff --base main # what your branch touches
droidmap report -o REPORT.md # an overview, with module and screen-flow diagramsOn pull requests (GitHub Action)
droidmap init writes this workflow to .github/workflows/droidmap.yml:
name: droidmap
on: [push, pull_request]
jobs:
droidmap:
runs-on: ubuntu-latest
permissions:
contents: read
security-events: write # findings as code scanning alerts
pull-requests: write # the comment that says what the pull request touches
steps:
- uses: actions/checkout@v7
- uses: hussainshirazi/droidmap@v0On each pull request the Action comments with what the change touches, and updates that one comment on every push:
droidmap: what this change touches
Compared with
origin/main: 1 changed file, 1 of them read by droidmap.Changed (1):
ItemEntityroom_entityAffected (what depends on the changed code):
Screens
HomeScreenViewModels
HomeViewModelRoom
AppDatabase,ItemDaoDependency injection
DataModule.bindItems,OfflineItemRepositoryModules
:app,:core:data,:core:database,:feature:detail-screen,:feature:home
When a change removes a declaration (a destination, a binding, a DAO method), the comment lists it under Removed, and what still depended on it under Affected.
Findings show up as code scanning alerts, as notes on the changed lines and in the job summary, and the step fails on errors. The Action needs no Java setup: it uses the JDK that GitHub's runners already have. To check the permissions that libraries add to the merged manifest as well, set merge-manifest: true: it runs ./gradlew processReleaseMainManifest first, so that job needs the JDK your build uses (actions/setup-java).
Input | Default | |
|
| the Android project's folder, when it is not the repository root |
|
|
|
|
|
|
|
|
|
| extra arguments for | |
|
| the git ref to compare with: |
| off |
|
| the pinned release | a droidmap release such as |
Run only the tests a change can break
droidmap diff --format tasks lists the test task of each module a change can break: the modules with a changed file and every module that depends on them (a module that uses them only in its tests gets its tests run, nothing more). A change to the build setup (settings, the root build file, gradle/, build-logic) lists every module. It reads only the Gradle files, so it takes a moment, without running Gradle:
- uses: actions/checkout@v7
with:
fetch-depth: 0 # the base branch, to compare with
- run: curl -fsSL https://raw.githubusercontent.com/hussainshirazi/droidmap/main/install.sh | sh
- run: |
tasks=$(~/.local/bin/droidmap diff --base origin/${{ github.base_ref }} --format tasks --task testDebugUnitTest)
if [ -n "$tasks" ]; then ./gradlew $tasks; else echo "No module affected"; fi--format modules prints the module paths instead, one per line.
--format tests goes further: only the test classes whose calls reach the changed functions, as Gradle arguments (:core:data:testDebugUnitTest --tests com.example.OfflineRepositoryTest ...), so ./gradlew $(droidmap diff --base origin/main --format tests --task testDebugUnitTest) runs just those. Calls are followed through what the code declares (a property's or parameter's type, a constructor, a function's return type), and a call on an interface reaches every implementation, so it errs towards running more tests. The text report and impact list the same tests under "Tests that cover it".
With an AI agent (MCP)
droidmap mcp is a Model Context Protocol server over stdio. It rebuilds the graph when a file changes (parsing only the changed files), so its answers follow the code as the agent edits it.
Claude Code plugin (the server plus a skill that tells Claude when to use it: impact before changing an entity, route or binding, checks and the tests to run after). It needs nothing installed but Java, and finds the one Android Studio brings: the first time, it downloads the droidmap release that matches the plugin and checks its SHA-256.
/plugin install droidmap --marketplace hussainshirazi/droidmapOn Claude Code before 2.1.275, add the marketplace first: /plugin marketplace add hussainshirazi/droidmap, then /plugin install droidmap@droidmap. The skill is a plain SKILL.md; other agents that read skills can use the same file.
The plugin also has two hooks (from droidmap 0.4.0). When a session starts, droidmap notes the project's findings. When Claude is about to finish, it checks again, and if Claude's changes added an error (a migration that is missing or fails, a route nothing registers, a binding nothing provides), it stops Claude from finishing and tells it which, so Claude fixes it first. Findings that were there before the session are left alone, and if Claude stops a second time, the errors are left to you. On Now in Android each check takes about 2 seconds.
Measured with claude plugin eval (the suite: three tasks on a small Room, Hilt and Compose app, three runs each, with and without the plugin, 2026-11-15). Adding a column to an entity users already have data in: with the plugin, 3 of 3 runs were fully correct (version bumped, a migration with a default, registered and tested, the shipped schema untouched); without it, 0 of 3 were (two runs left the migration unregistered or untested). Renaming a route argument the ViewModel reads, and adding a screen with a @HiltViewModel: correct in every run either way.
Any MCP client. droidmap init writes .mcp.json (Claude Code), and .cursor/mcp.json or .vscode/mcp.json when those folders exist; commit them and everyone on the team gets the server. It never changes a file that exists: it prints what to add instead. By hand:
claude mcp add droidmap -- droidmap mcp .{ "mcpServers": { "droidmap": { "command": "droidmap", "args": ["mcp", "."] } } }Without installing anything but Java: "command": "java", "args": ["-jar", "/path/to/droidmap.jar", "mcp", "."]. With Docker: "command": "docker", "args": ["run", "--rm", "-i", "-v", "/path/to/project:/project", "ghcr.io/hussainshirazi/droidmap", "mcp"]. droidmap is also listed in the MCP Registry as io.github.hussainshirazi/droidmap (from version 0.2.0).
Gemini in Android Studio connects to MCP servers over HTTP only. Start droidmap's HTTP server in the project (it listens on 127.0.0.1 only, and keeps running until you stop it):
droidmap mcp --http 3920then add it under Settings > Tools > AI > MCP Servers:
{ "mcpServers": { "droidmap": { "httpUrl": "http://127.0.0.1:3920/mcp" } } }Google's Android CLI gives agents Android Studio's inspections of one file at a time; droidmap adds what lies across files and modules (Room versions and migrations, routes and their arguments, bindings, the manifest), and needs no IDE running, so the same checks run in CI.
Tool | Use it to |
| see what depends on an entity, route, ViewModel, binding or module before changing it |
| see what the uncommitted changes (or a branch) touch, and which tests cover them |
| run the rules after a change |
| look at one node: its attributes, dependencies and users |
| search nodes by name |
| get a Markdown overview of the project |
| learn why a rule matters and how to fix what it found |
What droidmap understands
Area | What it reads |
Gradle | Modules from |
Room | Databases, entities, DAOs (the tables each |
Navigation | Compose Navigation with string routes (built from constants, templates and helper functions) or type-safe routes, Navigation 3 ( |
Hilt |
|
Koin | Modules and definitions ( |
Manifest | Permissions (including |
Kotlin and Java are read with the Kotlin compiler's own parser (the one detekt and ktlint use), on several threads.
Commands
droidmap init [path] # write the GitHub workflow and MCP config (never overwrites)
droidmap check [path] [--format text|json|sarif] [--fail-on error|warning|info|never] [--sarif FILE] [--base REF]
[--update-baseline] [--baseline FILE] [--no-baseline]
droidmap impact <node> [path] [--depth N] [--json] # what depends on a node
droidmap diff [path] [--base REF] [--depth N] [--format text|markdown|json|modules|tasks|tests] [--task NAME] # what a change touches
droidmap show <node> [path] [--json] # a node, its dependencies and its users
droidmap find <text> [path] [--limit N] [--json] # search nodes
droidmap report [path] [-o FILE] # the Markdown report, with Mermaid diagrams
droidmap build [path] [-o DIR] [--node-link] # write droidmap-out/graph.json and REPORT.md
droidmap rules # list the rules and their default severities
droidmap explain <rule> # why a rule matters and how to fix what it finds
droidmap mcp [path] # run the MCP server over stdioWithout [path], droidmap works on the Gradle project around the current folder (the nearest settings.gradle(.kts) at or above it). Output is in colour in a terminal; NO_COLOR=1 turns that off and FORCE_COLOR=1 on.
<node> can be an id, a name or part of a name: TopicEntity, :core:data, "editor?id={id}", HomeViewModel. check, impact, show, find and report also take --config FILE and --graph FILE (use a saved graph.json instead of scanning); build, diff and mcp take --config FILE.
Adopting droidmap on a project that already has findings
droidmap check --update-baseline writes today's findings to droidmap-baseline.json at the project root. Commit it: from then on, check (and the GitHub Action, the Gradle plugin, diff and the MCP server) report only findings that are not in it, and say how many known ones they left out. A finding stays known when code above it moves or its message gains a detail; it is matched by its rule, file and what it is about, not its line. When you fix known findings, check says so, and --update-baseline drops them. --baseline FILE uses another file, --no-baseline shows everything. SARIF results carry a stable fingerprint, so GitHub code scanning follows each alert across commits.
diff compares the working tree (committed or not, new files included) with the point where your branch left --base (default HEAD: the uncommitted changes). A changed line counts for the innermost declaration around it, so editing one function does not mark its whole class.
check --sarif FILE also writes the findings as SARIF. check --base REF also compares Room schema files with that commit; your last release tag is the most precise choice, since only a shipped schema must never change. Add droidmap-out/ to your .gitignore if you use build.
Exit codes: 0 when done, 1 when check finds something at --fail-on or above (or find matches nothing), 2 for a usage or config error, 3 for an internal error.
Rules
Rule | Default | Finds |
error | a known schema version with no migration path to the current version | |
error | a manual migration whose SQL, replayed on the schema files, fails (a | |
warning | no exported schema JSON for the current version or an earlier one | |
warning | entities that no longer match the schema JSON of the current version: a changed entity without a version bump crashes on update | |
warning | with | |
warning | migration steps no | |
warning | a manual | |
warning |
| |
off |
| |
error | with | |
warning | a Room database built in a DI provider that is not a singleton: each injection opens another instance, and their Flows miss each other's writes | |
error | two DataStores on one file (two delegates with one name, or one built in a provider that is not a singleton): "There are multiple DataStores active for the same file" | |
error |
| |
warning | a destination nothing navigates to, starts at or refers to, and that no deep link or menu item opens | |
warning | a ViewModel that reads | |
error | a type-safe route property Navigation has no NavType for (a data class, a | |
warning | a deep link ( | |
warning | an injected project type with no | |
error | the same type and qualifier bound twice in one source set | |
error |
| |
error | an | |
error | a | |
warning | a | |
warning | with | |
warning | a worker that reads an input key none of its work requests put: always null | |
warning | a type Koin is asked for ( | |
error | a project dependency on a module settings does not include | |
error | a dependency your | |
error | modules that depend on each other in a cycle | |
error | a permission not in your | |
error | an activity, service or receiver the code sends an explicit Intent to, but no manifest declares: | |
warning | a component that reads an Intent extra none of the Intents sent to it put: always null | |
warning | a notification built for a channel id the app never creates: not shown from Android 8, a crash in | |
warning | a class Gson reads by reflection ( | |
warning | the same for Moshi without code generation ( |
Configuration
Put a .droidmap.toml at the project root (all of it is optional):
[rules]
"room-migration-untested" = "error" # error | warning | info | off
"room-insert-replace" = "error"
[manifest]
allowed_permissions = ["android.permission.INTERNET", "android.permission.POST_NOTIFICATIONS"]
[[gradle.forbid]]
from = ":feature:*"
to = ":feature:*"
reason = "features talk to each other through :core modules"
[ignore]
paths = ["benchmarks/**"]An unknown rule name or severity is an error, so a typo never leaves a rule silently unchanged. from, to and ignore.paths are glob patterns where * also matches : and /. A forbid rule skips test dependencies unless it says tests = true, and allow_same_parent = true lets siblings such as :feature:a:impl and :feature:a:api depend on each other. With allowed_permissions, a permission a library adds to the merged manifest is reported with the library's name, so you can remove it (tools:node="remove") or allow it.
The graph
droidmap build writes droidmap-out/graph.json (schema droidmap/1) with three lists:
nodes: id, kind, label, file, line, module and attrs;edges: source, target, kind, file, line and attrs;unresolved: what static analysis could not follow, with the reason.
An edge always means source depends on target, so impact is a walk backwards. Paths are relative to the project root and the output is deterministic, so it diffs cleanly. --node-link also writes the networkx node-link shape that tools such as graphify read.
Node kinds: module, room_database, room_entity, room_dao, room_migration, room_schema, test, nav_destination, nav_route, screen, function, viewmodel, injectable, hilt_module, hilt_provider, koin_module, koin_definition, entry_point, component, permission, class.
Edge kinds: depends_on, contains_entity, contains_dao, queries, writes, has_schema, migrates, tests, registers, shows, navigates_to, starts_at, uses_viewmodel, injects, bound_by, requires, declared_in, uses_permission, declares.
Limits
droidmap reads the source and never runs Gradle. That is what makes it take seconds, work on a checkout nobody has built, and never run a project's build scripts; it also puts what only a build produces out of reach. And it is deliberately conservative: when it cannot resolve something (a route held in a variable, a version that is not a constant, a Koin definition whose type it cannot tell), it records it under unresolved instead of guessing, and the rules do not fire on it. A rule that guesses reports problems that are not there.
Code a build generates (KSP, kapt) is not read. Safe Args does not need it:
HomeFragmentDirections.actionHomeToDetail()is matched to its action by the names Safe Args gives the code it generates.The permissions libraries add come from the resolved dependencies, so the merged manifest is read only when a build has produced it (
<module>/build/intermediates/merged_manifests/, or the Action'smerge-manifestinput). A merged manifest older than the build files is flagged as such.Names resolve by Kotlin's and Java's rules (imports, the package, enclosing classes and their supertypes), but without type inference, which needs the compiler and every dependency. A call on a variable, such as
repo.load(), is traced when the variable's type is declared or comes from a constructor or a function's declared return type, not when it would have to be inferred (a lambda'sit, a generic's type argument, a chain of library calls).Values built at runtime are not followed: a route read from a
var, or built in a loop. Constants, string templates, functions that return them and helpers up to five levels deep are.
Contributing
./gradlew test fatJar runs the tests and builds build/libs/droidmap.jar. CONTRIBUTING.md has where the code lives, what a new rule or fix needs, and the real-project checks in CI. Report a wrong or missed finding with the False positive or missed problem issue form; security problems privately, as SECURITY.md says.
License
Apache-2.0. See LICENSE.
Available Tools
7 toolsdroidmap_checkCheck the Android wiringARead-onlyIdempotent
Run droidmap's rules on the whole project and list what compiles but would crash or lose data at runtime: Room (missing or failing migrations, schema files out of date, untested migration steps), navigation (routes nothing registers, missing arguments, route types without a NavType, deep links no intent filter accepts), Hilt and Koin bindings, WorkManager setup and inputs, manifest components, permissions, Intent extras and notification channels, DataStores and databases built more than once, Gson and Moshi models that R8 renames, and Gradle module rules and cycles. Use it after editing to confirm nothing new broke; use droidmap_diff for what a change touches and droidmap_explain for how to fix a finding. Read-only and local: it reads the source files, never runs Gradle or the app, and sends nothing anywhere. Findings recorded in the project's droidmap-baseline.json are left out, with a note saying how many. Returns plain text: each finding's severity, rule id and file:line, then the problem, and a count by severity at the end; or "No findings."
Inputs: min_severity.
droidmap_diffWhat a change touchesARead-onlyIdempotent
Map a code change onto the graph: the declarations whose lines changed since a git ref (by default the uncommitted changes, new files included), the ones removed, everything that depends on them (screens, destinations, ViewModels, Room, bindings, modules), the test classes whose calls reach the changed code, and the findings in the changed files, including those only a comparison shows (a shipped Room schema or a stored enum constant changed, a Worker renamed). Use it after editing, to see what else to update and which tests to run; use droidmap_impact before editing. Read-only: it runs git diff and reads the source files, never runs Gradle, and changes nothing; the project must be in a git repository. Returns plain text in sections: Changed, Removed, Affected (grouped by kind), Tests that cover it, and Findings in the changed files.
Inputs: base, depth.
droidmap_explainExplain a ruleARead-onlyIdempotent
Explain one droidmap rule: what it finds, why it matters (the crash or data loss it prevents) and how to fix what it found, with code examples, and its page online. Use it when droidmap_check or droidmap_diff reports a finding you do not know how to fix. It reads documentation bundled with droidmap, so it needs no project and changes nothing. Returns Markdown.
Inputs: rule (required).
droidmap_findFind nodes by nameARead-onlyIdempotent
Search the graph's nodes by id or name: modules, Room databases, entities, DAOs and migrations, navigation destinations and routes, screens, ViewModels, injectable classes, Hilt and Koin modules and bindings, components and permissions. Case is ignored; an exact name ranks first, then a name that starts with the text, then one that contains it. Use it to get the exact name or id that droidmap_impact and droidmap_show need when you know only part of it. Read-only and local: it reads the source files, never runs Gradle or the app, and sends nothing anywhere. Returns plain text, one node per line: name, kind and file:line (with the id when names repeat); or "No node matches".
Inputs: query (required), limit.
droidmap_impactWhat depends on thisARead-onlyIdempotent
List everything that depends on one node, transitively: who injects a class, which DAOs and databases use an entity, which screens use a ViewModel, which functions navigate to a destination, which modules depend on a module, and the test classes whose calls reach it. Use it before changing a class, entity, route, ViewModel, binding or module, to know what else to update and test; use droidmap_show for only the direct links in both directions, and droidmap_diff once the change is made. Read-only and local: it reads the source files, never runs Gradle or the app, and sends nothing anywhere. Returns plain text: the node and its file, then up to 200 dependents nearest first, each with its depth, kind, the edge it depends through and file:line, then the tests and modules affected; or "Nothing in the graph depends on it."
Inputs: node (required), depth.
droidmap_reportProject overviewARead-onlyIdempotent
Write a Markdown overview of the whole project: a summary, the modules and their dependencies, Room databases with their versions, migrations and test coverage, navigation destinations and how screens connect, dependency injection, permissions and the current findings, with Mermaid diagrams of the modules and the screen flow. Use it once to get oriented in an unfamiliar project; use droidmap_find, droidmap_show or droidmap_impact for one part. Read-only and local: it reads the source files, never runs Gradle or the app, and sends nothing anywhere. Takes no arguments. Returns Markdown, which can be long on a large project.
Inputs: no named parameters.
droidmap_showShow one nodeARead-onlyIdempotent
Show one node of the graph: its kind, file:line and attributes (a destination's route and arguments, a database's version, a binding's qualifier), then the nodes it depends on directly and the nodes that use it directly, each with the edge kind and file:line. Use it to look closely at one class, entity, route or module; use droidmap_impact for everything that depends on it transitively, and droidmap_find when you do not know its name. Read-only and local: it reads the source files, never runs Gradle or the app, and sends nothing anywhere. Returns plain text.
Inputs: node (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool targets a distinct action on the code graph: check (rule linting), diff (git change mapping), impact (transitive dependents), show (single-node detail), find (node search), report (project overview), explain (rule documentation). Descriptions even include explicit sibling disambiguation cues like 'use droidmap_diff for what a change touches' and 'use droidmap_impact for transitive, droidmap_show for direct links'.
Every tool is a single lowercase word appended to a uniform 'droidmap_' namespace prefix, forming a predictable droidmap_<action> pattern. No camelCase mixing or inconsistent verb styles; the naming reads like a coherent family of graph/analysis operations.
Seven tools is well within the ideal 3-15 range and each earns its place with a non-redundant role in a codebase-graph analysis workflow. Nothing feels padded or missing from the set.
The surface covers the full exploratory lifecycle: find a node, inspect it, map its dependents, diff changes, lint rules, understand findings, and get a whole-project report. The main minor gap is baseline handling: findings are excluded via droidmap-baseline.json, but no tool exists to create or update that baseline, leaving agents to work around it externally.
Maintenance
Related MCP Connectors
Ask who calls a route, what a change breaks or who reads a field, across a system's repos.
AI Agent with Architectural Memory. Impact analysis (free), tests and code from the graph (pro).
Hosted code graph over MCP: exact callers, dependencies, and cross-repo blast radius for AI agents.
Codebase intelligence for AI agents — dead code, blast radius, ownership.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceProvides a dependency graph of any local repository with tools for change impact, transitive dependents, health audits, and more, enabling AI coding agents to see structure and refactor safely.4,912 npm4MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents and reviewers to query a deterministic code dependency graph for callers, routes, pages, tables, and config with file:line evidence instead of grepping. One server can serve many indexed graphs, supporting cross-repository impact analysis.329 PyPI4MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI coding agents to query a local structural code graph, inspect relationships and impact, and retrieve focused project context before reading full files.24 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables coding agents to query a precise, local call/type/data graph so they can find who calls what, what breaks when code changes, and which tests to run, with every answer traced to file:line.99 PyPI1Functional Source , Version 1.1, ALv2 Future