huccanta

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+22 more

    huccanta

    1

    Static analysis and structural contract gate for JS/TS codebases via local MCP tools.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    huccanta

    Example session with this skill installed

    Analyze the impact of deleting the userService.validateToken function in the current repository and check for any HTTP contract drift.

    • Read your context and instructions
    • Compiled the huccanta

    I have performed a structural analysis of the repository using Huccanta's MCP tools. I first mapped the call graph for the specific function and then ran the contract radar to check for interface mismatches.

    Impact Analysis: userService.validateToken

    MetricResult
    Function IDsrc/services/user.ts#validateToken
    Direct Dependents4 files (AuthMiddleware, LoginController, SessionWorker, ApiGateway)
    Total Blast Radius12 unique call sites identified
    Unused Signalfalse (high confidence)
    Contract StatusDRIFT_DETECTED

    Structural Evidence

    Call Edges: The function is a critical path for src/middleware/auth.ts. Deletion will break the middleware chain.

    Contract Radar: Found a local consumer in the frontend api-client package that expects the TokenValidation interface provided by this backend path.

    Simulated Deletion: Removing this function results in 3 unresolved references in the auth module and 1 broken HTTP route in routes/v1/auth.ts.

    HTTP Contract Drift

    Found 1 drift instance where the backend implementation of the token payload no longer matches the expected interface in the frontend repository:

    • Endpoint: POST /api/v1/validate

    Issue: no-local-consumer flag is absent, but structural verification shows a missing expiry field in the current backend AST compared to the frontend type definition.

    Next steps

    • Refactor AuthMiddleware to use the new SessionValidator before attempting deletion.
    • Update the frontend TokenValidation interface to match the current backend payload.
    • Re-run verify_change once the replacement logic is staged.

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

    About this skill

    Manual codebase exploration is prone to missing hidden dependencies and breaking upstream contracts. Huccanta provides a local MCP interface for evidence-based static analysis, mapping code flow and simulating changes without touching your source files.

    What it does

    • Dependency mapping generates file graphs and identifies cycles within JS/TS projects.
    • Impact simulation models the blast radius of deleting specific functions or files before you commit.
    • Contract monitoring detects drift between frontend and backend HTTP interfaces to prevent breaking changes.
    • Structural verification compares code snapshots against policies to return deterministic pass/fail results.
    • Health auditing flags unused code and import issues using AST-based confidence signals.

    How it works

    1. Analyze the repository root using analyze_code to generate a structural map and identify hotspots.
    2. Inspect specific logic by retrieving detailed function data and call edges for relevant identifiers.
    3. Simulate refactors or deletions to view the calculated impact on the rest of the codebase.
    4. Verify patches by providing before and after snapshots for structural validation and fingerprinting.

    Frameworks & tools

    The skill requires a Node.js 22+ environment and the Huccanta MCP server. While basic analysis is language-agnostic, advanced features like contract_radar, import_health, and verify_change are optimized for JavaScript and TypeScript environments.

    Why this beats prompting it yourself

    Standard LLM prompts often hallucinate call graphs or miss deep dependency cycles in large repositories. This skill connects directly to a local AST-based static analyzer, ensuring every finding is backed by deterministic evidence rather than probabilistic guessing.

    Use cases

    • Auditing a legacy JS/TS codebase to identify dead code and circular imports.
    • Running a pre-merge impact analysis to see which components a deletion affects.
    • Checking for frontend/backend contract drift during API refactors.
    • Validating structural changes against specific architectural policies.

    Known limitations

    Does not support runtime tracing, formal verification, or rename simulations. Import health and contract radar are JS/TS only. Missing call edges may occur with dynamic dispatch or reflection.

    How to use

    Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed 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 scanned

    Verified clean 1 day ago

    • Passed all security checks, Safe to install

    Requires

    Node.js
    tsx
    Git

    Listed1 day ago

    What's inside

    Frequently Asked Questions