Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Test Gap Hunter

    1

    Identify untested code and high-risk gaps via static analysis of source symbols and test references.

    $2.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Test Gap Hunter

    Test Gap Hunter

    Example session with this skill installed

    Analyze the gap between src/auth and tests/auth in this TypeScript repo. Rank the top gaps by risk and git churn.

    • Read your context and instructions
    • Compiled the test gap hunter

    I have analyzed the src/auth module and compared it against tests/auth. The analysis identified 4 public exports with no test references and ranked them based on a high churn rate in the git history.

    Test Gap Analysis: src/auth

    SymbolLocationRisk ScoreChurn (30d)Status
    validateMfaTokensrc/auth/mfa.ts8.412 commitsCritical Gap
    refreshSessionsrc/auth/session.ts6.28 commitsMissing Test
    parseJwtMetadatasrc/auth/utils.ts4.12 commitsUntested
    auditLogFailedLoginsrc/auth/logger.ts2.51 commitUntested

    Detailed Findings

    High Risk: validateMfaToken in mfa.ts has a high cyclomatic complexity (12) and has been modified frequently this month, yet no references were found in tests/auth/mfa.test.ts.

    Orphaned Symbols: refreshSession is a public export used by the frontend but is completely absent from the current test suite.

    Coverage Estimate: Based on static mapping, approximately 65% of the public API in the auth module is covered by reference-based tests.

    Next steps

    1. Generate a test scaffold for validateMfaToken to cover edge cases in the MFA logic.
    2. Verify if refreshSession is covered by an integration test in a different directory.
    3. Add a unit test for parseJwtMetadata to ensure claims are handled correctly.

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

    About this skill

    Codebases often lack clear visibility into test coverage without the overhead of instrumenting code or running slow CI pipelines. This skill identifies untested code by mapping source files to test files using naming conventions, imports, and symbol references.

    What it does

    • Source mapping maps functions and classes to corresponding test files across Python, JavaScript, TypeScript, Go, Java, and Ruby.
    • Symbol tracking identifies public symbols and exported functions that have zero references in the test suite.
    • Risk ranking prioritizes gaps by evaluating cyclomatic complexity and git change frequency.
    • Orphan detection lists modules that completely lack a corresponding test file or folder.

    How it works

    1. Source Scan analyzes the src directory to catalog public APIs and complex logic blocks.
    2. Test Analysis scans the tests directory to trace references back to the source code.
    3. Gap Identification flags symbols found in source but missing from the test trace.
    4. Prioritization applies risk weights based on git churn and complexity to rank the top 20 most critical gaps.

    Frameworks & tools

    This skill utilizes AST parsing for Python and heuristic pattern matching for JavaScript, TypeScript, Go, Java, and Ruby. It integrates with git to extract churn data for risk scoring.

    Why this beats prompting it yourself

    Generic prompts often miss cross-file references or fail to account for co-located test patterns. This skill uses specific logic to bridge source symbols and test files, ensuring high-risk logic is caught even when naming conventions vary.

    Use cases

    • Legacy code audits to map out testing debt in inherited repositories.
    • Test planning for new features by identifying which public exports are currently exposed.
    • PR reviews to verify that new complex functions have corresponding test references.

    Known limitations

    This is a static analysis tool; a symbol being referenced in a test does not guarantee a functional assertion exists. Accuracy for non-Python languages relies on heuristics.

    Static analysis only; cannot verify if assertions are meaningful. Non-Python language support relies on naming heuristics rather than full AST resolution.

    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 1 month ago

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill uses static analysis to map source code symbols to test references without requiring you to run slow, instrumented coverage pipelines. It solves the 'blind spot' problem by identifying high-complexity code that lacks any corresponding test presence.

    The skill supports Python, JavaScript, TypeScript, Go, Java, and Ruby. While it uses deep AST parsing for Python, it employs sophisticated heuristic pattern matching for other languages to identify relationships between source and test files.

    Yes, the skill integrates with Git to analyze change frequency (churn). It combines this data with cyclomatic complexity scores to rank gaps, ensuring you prioritize testing code that is both complex and frequently modified.

    This skill is designed for AI agents with file system access, such as AutoGPT, Open Interpreter, or custom IDE-based agents. It requires read-only access to your source and test directories to perform the analysis.

    Since it uses static analysis (symbol tracking), a test might reference a function without actually asserting its behavior. The skill identifies if a link exists, but it does not evaluate the quality or logic of the assertions within those tests.

    New in Code Quality & Review