Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    code mapper

    1

    Automated repository mapping for dependency analysis, route inventory, and data flow tracking.

    $8

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    code mapper

    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

    CategoryCountStatus
    Routes423 missed (dynamic registration)
    Tables12Matches schema.sql
    Folders82 circular dependencies found
    Entries45Includes 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 / JobMiddlewareHandlerTables Reached
    POST /api/v1/ordersauth, validatecreateOrderorders, inventory (w)
    GET /api/v1/user/:idauthgetUserProfileusers (r)
    order_cleanup_jobN/ApurgeOldOrdersorders (w)
    PUT /api/v1/inventoryauth, adminupdateStockinventory (w)

    Observations:

    • Circular Dependency: src/services and src/models depend on each other.
    • Multi-Writer Table: The inventory table is written to by both the orders handler and the inventory handler.
    • Middleware Gaps: 2 routes were identified with no router-level middleware.

    Next steps

    1. Review docs/remediation/code-map/modules.md to inspect the specific import cycles.
    2. Run python3 scripts/codemap.py impact docs/remediation/code-map/ src/services/inventory.ts to see side effects of changes.
    3. Verify the 3 missing routes manually in src/routes/dynamic_loader.py.
    Matches schema.sql

    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

    1. Initialize by targeting a repository root and identifying the active branch and commit to ensure the map is tied to a specific state.
    2. Execute build using a Python script that runs either a fast builtin scanner for JS/TS/Python or the cgr engine for deep class and method graphs.
    3. Verify coverage by comparing map counts for routes and tables against raw repository greps to identify registration patterns the scanner missed.
    4. Inspect findings through generated Markdown files in docs/remediation/code-map/ covering modules, data, and entry points.
    5. 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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Read Files
    Write Files
    Listed12 days ago

    What's inside

    Frequently Asked Questions

    The skill generates a persistent `graph.json` and a series of Markdown reports that categorize every route, middleware chain, and database interaction, providing a structural 'source of truth' that standard LLMs cannot maintain on their own.

    It natively supports TypeScript, JavaScript, and Python, with specific optimizations for popular frameworks like Express, NestJS, Flask, and FastAPI.

    Yes, the skill includes a dedicated CLI that allows you to perform impact analysis and trace call hierarchies directly from your terminal or within your agent's workspace.

    The skill includes the automated scanner, the `cgr` engine for deep class graphing, the CLI tool, and templates for generating the documentation in your `docs/remediation/` folder.

    The tool uses mechanical scanning to ensure 1:1 parity with your source text, though it may not capture routes registered in dynamic loops or SQL built from fragmented strings.

    The skill is designed to work with Python-based AI agents and can be integrated into any workflow where the agent has file system access to your repository.

    New in Agents & Orchestration