codemap

    1

    - **Analyze blast radius** using impact analysis to see exactly which files and symbols break if you modify or delete a specific component.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    codemap

    Example session with this skill installed

    What is the blast radius of changing the validate_user function in this Python project? Is there anything I should be aware of from previous sessions?

    • Read your context and instructions
    • Compiled the codemap

    I have analyzed the code graph for validate_user and checked the persistent memory for any notes.

    Impact Analysis: validate_user

    I found 4 direct dependents and 1 architectural note. The index is up to date.

    Symbol / FileDepthRelationshipNote
    src/auth/service.py::validate_user0Target"Derived: Fails if Redis is down"
    src/auth/router.py::login_endpoint1Calls-
    src/middleware/auth.py::AuthMiddleware1Imports-
    src/api/v1/users.py::update_profile2Calls-
    tests/unit/test_auth.py1Calls-

    Analysis

    Changing the signature of validate_user will break the login_endpoint and the AuthMiddleware immediately. Note that a previous session observed this function fails silently if the Redis cache is unreachable. The update_profile route is affected indirectly via the auth service.

    Next steps

    1. Review the logic in src/auth/router.py at line 42 to ensure the new signature is handled.
    2. Update the unit tests in tests/unit/test_auth.py to match the new return type.
    3. Verify if the Redis failure mode mentioned in the notes needs to be addressed during this refactor.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop wasting time in grep-and-read loops when trying to map out a codebase. This skill provides a local, graph-based navigation layer for your agent to understand code structure, call chains, and the ripple effects of changes before you touch a single line of source.

    What it does

    • Map dependencies by finding all incoming and outgoing callers for any function or class across the entire repository.
    • Analyze blast radius using impact analysis to see exactly which files and symbols break if you modify or delete a specific component.
    • Trace connections by finding the shortest path between two distant symbols across multiple files and modules.
    • Navigate Vue templates by resolving bindings between component methods and their calls inside Vue single-file components.
    • Persist findings through a durable notes layer that stores architectural decisions or "traps" directly against symbols, surviving across re-indexes.

    How it works

    1. Index the repo by running codemap-index to build or update a local SQLite graph of your symbols and relationships.
    2. Search for symbols using keywords or exact names to get full unique IDs and see existing discovery notes.
    3. Query the graph for neighbors or paths when you need to understand how a specific module fits into the broader architecture.
    4. Check impact before refactoring to list every file and line number that depends on the code you are about to change.

    Frameworks & tools

    Built for the Model Context Protocol (MCP). Supports Python, TypeScript, JavaScript, Vue (including template bindings), and Go. Works with any MCP-compatible client like Claude Code or Cursor.

    Why this beats prompting it yourself

    Standard LLM prompts rely on the agent's limited context window and text-search tools, which often miss indirect imports or complex call chains. This skill uses a pre-computed local index to provide 100% accurate structural data that text search simply cannot resolve.

    Use cases

    • Refactoring a shared utility function where you need to verify every call site.
    • Onboarding to a massive, unfamiliar codebase by tracing how the entry point reaches the database.
    • Checking if a Vue component method is actually used in the template before deleting it.
    • Recording a "trap" in a specific module so future agent sessions don't repeat the same bug.

    Known limitations

    Does not support dynamic dispatch, reflection, or dependency-injection containers. Limited to Python, TS/JS, Vue, and Go. Cannot track impacts across separate repositories or database schema changes.

    Supports Python, TS/JS, Vue, and Go only. Cannot track dynamic dispatch, reflection, or cross-repo dependencies. Index requires manual refresh after code changes to remain accurate.

    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 3 days ago

    Requires

    Python

    Permissions

    Read Files
    Network Access
    Listed3 days ago

    What's inside

    Frequently Asked Questions

    codemap uses a local SQLite graph to track actual call chains and symbol relationships, whereas standard search tools only find text matches. This allows your agent to find indirect dependencies and "hidden" callers that simple grepping would miss.

    This skill is built for the Model Context Protocol (MCP) and is compatible with any MCP-compatible environment, including Claude Code, Cursor, and Windsurf. It acts as a specialized toolset that your agent can invoke whenever it needs structural code analysis.

    Setup is a two-step process: first, install the MCP server via your agent's configuration, and second, run the `codemap-index` command in your local repository. The tool will then build a local SQLite database that stores your project's architectural map.

    codemap currently provides deep support for Python, TypeScript, JavaScript, Go, and Vue (including template bindings). It is specifically optimized for these languages to ensure call graphs are accurate across imports and component boundaries.

    No, the index is stored entirely on your local machine and the analysis happens locally. Your source code is never uploaded to a third-party server; only the structural metadata extracted by the tool is provided to your AI agent's context.

    The "notes layer" allows you or your agent to attach durable architectural context or warnings to specific code symbols. These notes are stored in the local index and persist across sessions, ensuring your agent remembers "traps" or complex logic even after a re-index.

    New in LLM Ops