More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Repo-to-LLM Context Packager: Turn Any Codebase into Clean,

    1

    Sanitize codebases for LLM context and establish multi-agent governance rules for enterprise microservices. Perfect for NotebookLM and AI Coding Agents.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Repo-to-LLM Context Packager: Turn Any Codebase into Clean,

    Repo-to-LLM Context Packager: Turn Any Codebase into Clean,

    Example session with this skill installed

    Sanitize my Java backend repository located at ./services/order-service and generate the multi-agent governance files for a system named OrderManagement.

    • Read your context and instructions
    • Compiled the repo-to-llm context packager

    I have processed the ./services/order-service directory. The codebase has been sanitized of comments and sensitive strings, and the governance framework has been established.

    Sanitization and Governance Report

    ArtifactPathDescription
    Sanitized Contextfontes_consolidados_LM/consolidado_backend_20231027_143005.txtUnified code context with target/ and .env excluded.
    Security Auditfontes_consolidados_LM/exclusoes_seguranca_20231027_143005.log4 secrets (API keys) and 12 PII-like strings removed.
    Global Governance./AGENTS.mdMaster guide for OrderManagement defining service boundaries.
    Local Governance./services/order-service/AGENTS.mdLocal instructions for the order-service microservice.
    IDE Enforcement./.github/copilot-instructions.mdNon-negotiable rules for Layered Architecture and Data Isolation.

    Security Summary

    • Files Scanned: 142
    • Tokens Reduced: ~35% (via comment stripping and build artifact exclusion)
    • Sanitization Events: Found and masked spring.datasource.password and jwt.secret.

    Next steps

    1. Upload the consolidado_backend_*.txt file to your NotebookLM source library for domain analysis.
    2. Review the AGENTS.md master guide to ensure all microservice port mappings are correct.
    3. Open the repository in your IDE to verify that Copilot/Claude Code is respecting the new .github instructions.

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

    About this skill

    Enterprise codebases are often too bloated or sensitive for effective AI assistance. Token waste from build artifacts and the risk of leaking secrets prevent developers from getting clean, actionable context in tools like NotebookLM, Claude Code, or Cursor. This skill automates codebase sanitization and establishes a multi-agent governance framework to keep your LLM context focused and secure.

    What it does

    • Codebase Consolidation scans repositories to generate a unified, comment-stripped context file optimized for RAG and NotebookLM.
    • Secret Sanitization identifies and filters passwords, connection strings, JWT secrets, and PII using regex-based security profiles.
    • Agent Governance Setup generates root and subproject AGENTS.md files to map microservice architectures, ports, and domain boundaries.
    • IDE Enforcement configures .github/copilot-instructions.md to mandate architectural patterns like Data Isolation and Event-Driven communication.
    • Context Optimization automatically excludes build directories, binaries, and logs to prevent token overflow and hallucinations.

    How it works

    1. Run the consolidation script with a specific profile (e.g., java, python) to produce a sanitized .txt context file and an audit log of exclusions.
    2. Execute the setup script to detect project manifests and generate a global AGENTS.md master guide for the repository.
    3. Apply the 4-phase lifecycle (Entendimento, Design, Codificação, Validação) to transition from domain strategy to tactical code execution.

    Frameworks & tools

    The skill utilizes Python scripts for scanning and regex-based sanitization. It supports enterprise stacks including Java (Maven/Spring), Node.js, Python, and Go, and integrates with IDE agents like Claude Code, Cursor, and GitHub Copilot.

    Why this beats prompting it yourself

    Manual sanitization is error-prone and misses deep-nested secrets or massive build folders that blow through token limits. This skill provides a repeatable, script-driven workflow that ensures every AI agent in your stack follows the same non-negotiable architectural boundaries.

    Use cases

    • Preparing a legacy microservices repository for ingestion into NotebookLM.
    • Establishing architectural guardrails for a team of developers using IDE agents.
    • Sanitizing sensitive internal code before sharing context with external LLM providers.
    • Mapping complex port and service dependencies for a multi-agent developer environment.

    Known limitations

    Requires Python to run the consolidation and setup scripts. Sanitization relies on regex patterns and may require custom profiles for non-standard secret formats.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Prompt & Skill Engineering.

    Requires Python environment for scripts. Sanitization is regex-based and may not catch all obfuscated secrets. Architecture detection supports Maven, NPM, Poetry, and Go Modules.

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

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed16 days ago
    Updated1 day ago

    What's inside

    Frequently Asked Questions

    This skill automates the process of removing token-heavy noise (like build artifacts) and sensitive data (like hardcoded secrets) from your repository, providing a clean, 'AI-ready' context file that stays within LLM token limits while preventing data leaks.

    The skill is tool-agnostic and works with any LLM interface that accepts file uploads or directory context, including Cursor, Claude Code, GitHub Copilot, and NotebookLM.

    You will receive a set of Python-based consolidation and setup scripts, a library of regex security profiles, and a framework of template files (like AGENTS.md) to establish architectural guardrails across your microservices.

    Yes, while the skill includes pre-configured profiles for Java, Python, Node.js, and Go, you can easily extend the regex profiles to target custom secret formats or unique internal naming conventions specific to your enterprise.

    The setup is straightforward: ensure Python is installed, choose a profile that matches your tech stack, and run the script to scan your local repository and generate the sanitized context and governance files.

    The Agent Governance Setup identifies service boundaries and port mappings, creating a 'source of truth' file that prevents AI agents from hallucinating cross-service dependencies or violating data isolation rules.

    New in Prompt & Skill Engineering