Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    commit guard

    1

    An uncompromising pre-commit auditor that enforces architectural integrity, security hygiene, and compliance.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    commit guard

    commit guard

    Example session with this skill installed

    "Review my uncommitted changes with commit-guard." or
    "Is my code ready to commit?" or
    "Run a pre-commit audit on branch feature/auth against main." or
    "Check for dead code and security flaws in my diff."

    • Read your context and instructions
    • Compiled the commit guard

    I have completed the pre-commit audit of your uncommitted changes. The scan identified one critical security blocker and two warnings regarding code bloat and performance.

    Commit Guard Audit Report

    Verdict: 🛑 BLOCK

    🛑 Critical Findings

    FileLinePillarIssue
    src/auth/provider.py42SecurityHardcoded API secret detected in constructor.
    src/utils/logger.py12Dead CodeLeftover print(token) statement used for debugging.

    ⚠️ Warnings

    FileLinePillarIssue
    src/db/queries.py88EfficiencyPotential N+1 query in get_user_posts loop.
    src/api/v1.ts104DocumentationMissing docstring for exported endpoint.

    Recommended Fixes

    
    # src/auth/provider.py
    # BEFORE: self.key = "sk-test-55512345"
    # AFTER:
    import os
    self.key = os.getenv("PROVIDER_API_KEY")
    
    
    # src/db/queries.py
    # BEFORE: [get_post(id) for id in user_post_ids]
    # AFTER:
    posts = db.session.query(Post).filter(Post.id.in_(user_post_ids)).all()
    

    Next steps

    1. Move the API secret to an environment variable or .env file.
    2. Remove the debug print statement in logger.py.
    3. Refactor the list comprehension in queries.py to use a single batch query.

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

    About this skill

    Catching architectural leaks and security flaws manually is a bottleneck. This skill acts as a deterministic pre-commit auditor that hunts down dead code, hardcoded secrets, and compliance violations before they hit your git history.

    What it does

    • Dead code elimination: Identifies unused imports, orphaned helpers, and leftover debug statements like console.log or print().
    • Security hygiene: Flags hardcoded credentials, injection vulnerabilities, and weak cryptographic primitives.
    • Architectural enforcement: Detects layer violations, circular dependencies, and boundary leaks.
    • Performance auditing: Spots $O(N^2)$ loops, N+1 query patterns, and unclosed resources.
    • Compliance checking: Validates changes against SemVer, OWASP Top 10, NIST, GDPR, and SOC 2 standards.
    • Context-aware scans: Specialized checks for AI/LLM systems, infrastructure/Docker, and accessibility (WCAG).

    How it works

    1. Scope selection: You trigger a scan for uncommitted changes, staged files, a specific branch, or the full codebase.
    2. Deterministic scan: The internal inspect_diff.py script extracts a unified diff and runs heuristic regex checks.
    3. Multi-pillar audit: The agent evaluates changes against a massive matrix of security, efficiency, and design rules.
    4. Structured verdict: You receive a BLOCK, WARN, or PASS report with line-specific fixes.

    Frameworks & tools

    Works with any Git-based workflow. Includes specific auditing logic for Python, TypeScript/JavaScript, Rust, Go, Docker, GitHub Actions, and OpenAPI/GraphQL schemas.

    Why this beats prompting it yourself

    Generic prompts often miss "silent" issues like N+1 queries or specific regulatory compliance requirements (PII in logs). This skill uses a structured 3-phase workflow and dedicated scripts to ensure no part of the diff is overlooked.

    Use cases

    • Pre-commit cleanup: Strip out debuggers and unused variables before staging.
    • PR readiness: Audit a feature branch against the main branch to ensure architectural integrity.
    • Security sweep: Scan the full codebase for hardcoded secrets or unpinned Docker tags.
    • Documentation sync: Verify that API changes match the OpenAPI schema and ADRs.

    Known limitations

    Requires a local Python3 environment to run the included inspection scripts. Scan depth is limited by the provided git diff context.

    Public repository available at github.com/h45sh/commit-guard.

    Requires Python3 for deterministic diff extraction. Effectiveness is tied to Git history availability. Does not perform runtime dynamic analysis.

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

    Requires

    Git
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Requires local shell access to execute `git diff` / `git status` and run the local diff inspection script. Performs zero external network calls, zero telemetry, and never transmits code outside your machine.

    Listed7 days ago

    What's inside

    Frequently Asked Questions

    Commit Guard acts as a deterministic auditor that scans your staged changes for security vulnerabilities, dead code, and architectural violations, preventing technical debt and leaks from ever reaching your repository history.

    The skill is compatible with any Git-based environment and includes specialized auditing logic for Python, TypeScript, Rust, Go, Docker, and OpenAPI schemas.

    You will receive the core AI agent logic, the `inspect_diff.py` inspection script, and a comprehensive suite of security and compliance rule sets for the auditor to follow.

    Yes, you can configure the agent to target uncommitted changes, staged files, specific branches, or perform a full-repository security sweep depending on your current workflow needs.

    Commit Guard requires a local Python 3 environment to execute its deterministic inspection scripts, which ensures high-precision scanning that simple LLM prompting cannot achieve alone.

    The skill provides a structured verdict—BLOCK, WARN, or PASS—alongside line-specific remediation steps, allowing you to fix issues immediately before finalizing your commit.

    New in Agents & Orchestration