More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    🕸️ Codebase Graph

    2

    It parses your project's directory structure, imports, and configuration files to build a comprehensive dependency model.

    $25

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    🕸️ Codebase Graph

    🕸️ Codebase Graph

    Example session with this skill installed

    Analyze this repository's structure to identify the main entry points, check for circular dependencies, and find any unused files or core architectural modules.

    • Read your context and instructions
    • Compiled the codebase graph

    📦 Entry Points: src/main.ts
    🔄 Cycles Detected: src/auth.ts -> src/user.ts -> src/auth.ts
    ⚠️ Dead Code: src/utils/legacy-formatter.ts (0 inbound refs)
    🚀 Core Modules: src/app.ts (Centrality: 0.82)
    Refactor: Split 'auth.ts' types to break the circular dependency with 'user.ts'.

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

    About this skill

    What it does

    The Codebase Graph skill transforms complex, unfamiliar repositories into interactive visual maps and structured onboarding guides. It parses your project's directory structure, imports, and configuration files to build a comprehensive dependency model. Unlike manual inspection, it automatically identifies how data flows through your application, pinpointing where execution starts and where bottlenecks or technical debt reside.

    Why use this skill

    Onboarding a new developer or planning a major refactor can take days of manual code tracing. This skill automates that process by providing a high-fidelity graph that reveals hidden relationships between modules. It goes beyond simple file-tree views by detecting circular dependencies, identifying likely dead code, and ranking modules by their "centrality" to the architecture. It's an essential tool for developers who need to understand a large codebase quickly without getting lost in the weeds.

    Supported tools

    • Languages: Multi-language support including TypeScript, JavaScript, and Python.
    • Parsing: Uses AST-based analysis and framework-native metadata (like package.json) for high accuracy.
    • Visualization: Generates a standalone, interactive D3.js force-directed graph.
    • Reports: Produces detailed Markdown summaries including entry points and refactor suggestions.

    First run on large codebases (10k+ files) may take 30-60 seconds. Generated graph can be large; use filters to reduce complexity. Dynamic imports and reflection-based dependencies may be missed. Python's dynamic typing limits call graph accuracy.

    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 5 months ago

    Requires

    Python
    Node.js

    Permissions

    Write Files
    Read Files

    File Scopes

    ./code-graph/**/*
    **/*.js
    **/*.ts
    **/*.py
    **/*.go
    **/*.java
    **/*.rs

    Codebase Graph needs terminal access to run language parsers (esprima for JavaScript/TypeScript, tree-sitter for Python/Go/Java/Rust). These are read-only parsers that extract structural information from source files. File read access allows the skill to scan directories and read source code to analyze imports, exports, class inheritance, and function call dependencies. Only reads files with supported extensions; ignores binary files and node_modules. File write access creates HTML visualization files and markdown summaries in a `./code-graph/` directory. All output files are safe to gitignore. The skill never modifies source code. No browser, network, or environment variable access is required. The generated HTML graph is self-contained and runs locally.

    Listed5 months ago
    Updated1 month ago

    What's inside

    Frequently Asked Questions

    This skill creates an interactive 2D graph of your code's architecture, pinpointing entry points, module relationships, and circular dependencies that standard file trees ignore. It solves the 'blank slate' problem when onboarding new developers or planning major structural refactors.

    Codebase Graph currently supports TypeScript, JavaScript, and Python, using AST-based analysis to ensure it captures actual logic flows rather than just simple file names. Support for additional languages like Go and Java is planned for future updates.

    No complex setup is required; once the skill is enabled, you simply point it to a repository directory or provide a codebase zip file. It automatically scans your structure and configuration files to begin the mapping process.

    You receive the core graph-generation engine, the visualizer for interactive D3.js maps, and a reporting tool that exports structural summaries and refactoring suggestions in Markdown format.

    Your purchase includes access to all subsequent minor updates and bug fixes for this version of the skill through the marketplace. Major version upgrades featuring entire new language frameworks may be offered as separate modules or discounted updates.

    The skill is designed to work with most major LLMs that support tool-calling and file-system access, such as Claude 3.5 Sonnet or GPT-4o, ensuring high-quality reasoning about your code's architecture.

    New in Code Quality & Review