Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Repo Map (Context Saver)

    1

    Instantly generate an AST-based map of a Python codebase. Saves massive context tokens and stops the agent from hallucinating file paths.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Repo Map (Context Saver)

    Repo Map (Context Saver)

    Example session with this skill installed

    I just cloned a new Python backend. Run the mapper on "C:\dev\backend-service" so I can see how it's structured.

    • Read your context and instructions
    • Compiled the repo map context

    I have scanned the repository at C:\dev\backend-service using the AST mapper. Here is the structural map of the identified Python files, classes, and functions.

    Repository Map

    File: api/auth.py

    • class Authenticator (line 14)
    • def validate_token (line 32)
    • async def refresh_session (line 58)

    File: api/routes.py

    • def health_check (line 10)
    • async def get_user_profile (line 25)
    • async def update_settings (line 42)

    File: core/database.py

    • class DBConnection (line 8)
    • def connect (line 20)
    • def execute_query (line 45)

    File: core/models.py

    • class User (line 5)
    • class Permission (line 28)

    File: utils/helpers.py

    • def format_timestamp (line 12)
    • def sanitize_input (line 24)

    Next steps

    1. Identify which classes or functions listed above relate to your current task.
    2. Use the provided line numbers to jump directly to the code in your editor.
    3. Request a full file read for only the specific modules you need to modify.

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

    About this skill

    Python codebases quickly become too large for context windows, forcing developers to manually hunt through directories. This skill maps the entire repository structure using Abstract Syntax Trees to provide a high-level overview without consuming massive token counts.

    What it does AST Parsing scans Python files to identify structural elements without reading raw text. Class Mapping identifies every class definition and its exact line number. Function Discovery* lists all standard and asynchronous function definitions. Context Optimization* provides a complete repo overview while keeping the context window clear for actual coding tasks.

    How it works

    1. Initialize the process by providing the absolute path to your local Python repository. 2.Execute the mapper script to trigger the AST traversal across all subdirectories. 3.Review the generated Markdown map to identify the file locations of relevant logic. 4.Target specific files for deeper analysis based on the class and function coordinates provided.

    Frameworks & tools The tool uses Python and the ast standard library to parse source files into tree structures.

    Why this beats prompting it yourself Manual directory listing misses the internal structure of files, while asking an LLM to read every file is expensive and slow. This tool extracts specific metadata at the syntax level, giving you a precise map in seconds without the token overhead.

    Use cases

    • Map a new repository to understand where core logic resides.
    • Locate specific function definitions during a refactoring task.
    • Audit a codebase for class distribution and file density.
    • Onboard onto a complex Python project by visualizing the API surface.

    Known limitations This skill only supports Python files and does not scan non-Python assets or internal file contents.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Only supports Python files (.py). Does not read file contents, only AST nodes (classes and functions). Requires an absolute file path to the repository.

    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 buying a skill.

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

    Software
    Python

    The map is generated locally and printed to stdout — nothing is uploaded. For repos over ~50 files, use the AST version ($19) which adds call-graph edges and per-section token budgets. This $9 version is file-level only.

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed2 days ago
    Updatedtoday

    What's inside

    Frequently Asked Questions

    This skill uses Abstract Syntax Tree (AST) parsing to map the structure of a Python repository. It extracts class names, function definitions, and line numbers into a compact Markdown file, allowing you to navigate large codebases without hitting LLM context limits.

    The skill currently supports any local Python repository. It is designed to be compatible with AI agents that have local file system access, such as AutoGPT, BabyAGI, or custom LangChain implementations.

    Setup is straightforward: once integrated into your agent's toolkit, you simply provide the absolute path to your local Python project. The skill handles the traversal of subdirectories and AST analysis automatically.

    No, this skill is purpose-built for Python syntax. It uses the Python 'ast' library to identify logic structures, so it will ignore non-Python assets like JavaScript, HTML, or configuration files.

    The skill is lightweight and relies on Python's standard library, so it is highly stable. Buyers receive the core mapping logic and any future maintenance updates or performance optimizations released for the tool.

    Unlike a basic directory tree, this skill looks inside the files. It identifies the 'what' and 'where' of your logic (classes and functions) rather than just file names, providing the precise coordinates needed for targeted code editing.

    New in LLM Ops