- Home
- Skills
- Agents & Orchestration
- code mapper
Works with the AI Agents you already use
code mapper
Automated repository mapping for dependency analysis, route inventory, and data flow tracking.
$8
code mapper
Example session with this skill installed
Run the code map build on the current repository and show me the summary of entry points and data readers.
- Read your context and instructions
- Compiled the code mapper
I have completed the code map build for the repository at commit a1b2c3d. The builtin engine was used for scanning.
Code Map Summary
| Category | Count | Status |
|---|---|---|
| Routes | 42 | 3 missed (dynamic registration) |
| Tables | 12 | Matches schema.sql |
| Folders | 8 | 2 circular dependencies found |
| Entries | 45 | Includes 3 background jobs |
Entry Points and Data Access
The following table summarizes the primary entry points and the data they touch, as mapped in entry-points.md and data.md.
| Route / Job | Middleware | Handler | Tables Reached |
|---|---|---|---|
POST /api/v1/orders | auth, validate | createOrder | orders, inventory (w) |
GET /api/v1/user/:id | auth | getUserProfile | users (r) |
order_cleanup_job | N/A | purgeOldOrders | orders (w) |
PUT /api/v1/inventory | auth, admin | updateStock | inventory (w) |
Observations:
- Circular Dependency:
src/servicesandsrc/modelsdepend on each other. - Multi-Writer Table: The
inventorytable is written to by both theordershandler and theinventoryhandler. - Middleware Gaps: 2 routes were identified with no router-level middleware.
Next steps
- Review
docs/remediation/code-map/modules.mdto inspect the specific import cycles. - Run
python3 scripts/codemap.py impact docs/remediation/code-map/ src/services/inventory.tsto see side effects of changes. - Verify the 3 missing routes manually in
src/routes/dynamic_loader.py.
Connects securely to your tools. The creator never sees your data.
About this skill
Unfamiliar codebases often lead to fragmented understanding. Multiple developers spend hours grepping the same files to identify entry points, data flows, and dependencies, often missing critical connections. This skill automates the structural analysis of a repository, generating a queryable graph and Markdown views that act as a shared source of truth for the entire team.
What it does
- Map entry points by identifying routes, their middleware order, handlers, and the database tables they access.
- Trace data flows to pinpoint where specific tables are read or written, highlighting tables updated from multiple locations.
- Analyze dependencies to find import cycles, cross-dependent folders, and frequently used modules.
- Verify client-server alignment by matching client-side API calls to server-side routes and flagging orphans.
- Provide queryable insights through a dedicated CLI that finds impact zones, route details, and call hierarchies.
How it works
- Initialize by targeting a repository root and identifying the active branch and commit to ensure the map is tied to a specific state.
- Execute build using a Python script that runs either a fast builtin scanner for JS/TS/Python or the
cgrengine for deep class and method graphs. - Verify coverage by comparing map counts for routes and tables against raw repository greps to identify registration patterns the scanner missed.
- Inspect findings through generated Markdown files in
docs/remediation/code-map/covering modules, data, and entry points. - Query the graph using CLI commands to perform impact analysis or trace symbols across the codebase.
Frameworks & tools
The skill requires Python 3 and supports TypeScript, JavaScript, and Python repos. It natively recognizes Express, NestJS, Flask, and FastAPI for routing, along with SQL, Knex, and Prisma for data access.
Why this beats prompting it yourself
Manual prompts often hallucinate structural relationships or fail to handle the scale of a full repository's dependency tree. This skill uses mechanical scanning to ensure 1:1 parity with source text and provides a persistent, queryable graph.json that stays fresh as the code changes.
Use cases
- Onboard to a legacy repo by instantly generating a map of all routes and their associated database tables.
- Perform impact analysis before a refactor to see every file and route that depends on a specific module.
- Audit security middleware by reviewing a single list of all entry points and their guarding functions.
- Detect architectural debt by identifying circular dependencies between folders and shared data write sites.
Known limitations
Does not capture routes registered in dynamic loops or SQL built from fragments. Call edges through dependency injection or interfaces are generally not resolved.
Misses dynamic imports, routes registered in loops, and SQL fragments. Requires Python 3. Fallback engine is restricted to TS, JS, and Python at the file level.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 12 days ago