Skip to main content
Glama

What a change touches

droidmap_diff
Read-onlyIdempotent

Maps code changes since a git ref onto the project graph to show changed and removed declarations, affected dependents, covering tests, and findings so you can update code and run the right tests.

Instructions

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.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "droidmap_diff"
  }
}

Input Schema

NameRequiredDescriptionDefault
baseNoThe git ref to compare with: a branch, tag or commit, such as 'main', 'origin/main' or 'v1.2.0'. The default, 'HEAD', compares the working tree with the last commit, so it shows the uncommitted changes. With a branch, droidmap compares with the point where the current branch left it.HEAD
depthNoHow many dependency steps to follow outwards: 1 lists only direct users; the default, 4, is enough for most changes.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed3 schema fields changedv0.1.1
    • addedInput schema / properties / base / default
      Added value: +"HEAD"
    • changedInput schema / properties / base / description
      Previous value: -"Git ref to compare with (default HEAD: the uncommitted changes)."New value: +"The git ref to compare with: a branch, tag or commit, such as 'main', 'origin/main' or 'v1.2.0'. The default, 'HEAD', compares the working tree with the last commit, so it shows the uncommitted changes. With a branch, droidmap compares with the point where the current branch left it."
    • addedInput schema / properties / depth / description
      Added value: +"How many dependency steps to follow outwards: 1 lists only direct users; the default, 4, is enough for most changes."
  2. First observedv0.1.0

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint/idempotentHint/non-destructive, yet the description still adds real context: it runs git diff and reads source files, never runs Gradle, changes nothing, and requires a git repository. The one gap is that it doesn't say how large diffs or deep graphs affect output size or runtime.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The core mapping is front-loaded, but it is one very long run-on sentence with stacked parentheticals that a reader must parse carefully. The final sentence about return sections could be split out cleanly rather than appended.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description takes on the burden and discharges it: it names the plain-text sections (Changed, Removed, Affected, Tests that cover it, Findings). Combined with the git-repository precondition and the read-only guarantee, an agent has everything needed to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by reinforcing the default 'HEAD = uncommitted changes' and adding that new files are included, a behavior the schema does not state. It does not add further detail on the depth parameter, which the schema already handles.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Opens with a specific verb+resource: 'Map a code change onto the graph', then enumerates exactly what is produced (changed declarations, removed ones, dependents by kind, covering tests, findings). This is clearly distinct from droidmap_impact, which is named as the pre-edit counterpart.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit timing and routing: 'Use it after editing, to see what else to update and which tests to run; use droidmap_impact before editing.' The when-to-use and the alternative are both stated without inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.