Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    chanakya mcp

    1

    Navigate and refactor JS/TS codebases using structural symbol indexing instead of text search.

    Free

    Security scanned
    chanakya mcp

    chanakya mcp

    Example session with this skill installed

    Find where the calculateTax function is defined and show me every file that calls it so I can update the signature.

    • Read your context and instructions
    • Compiled the chanakya mcp

    I have located the calculateTax function and identified all call sites across the project.

    Symbol Analysis: calculateTax

    CategoryDetails
    Definition IDsrc/services/billing.ts#function:calculateTax
    Locationsrc/services/billing.ts [Lines 42-58]
    KindFunction
    LanguageTypeScript

    Callers and References

    File PathUsage KindLineContext
    src/routes/invoice.tsCall Expression112const tax = calculateTax(total, "EU");
    src/api/checkout.tsCall Expression89return calculateTax(amount, region);
    src/tests/tax.test.tsReference12expect(calculateTax).toBeDefined();
    src/utils/audit.tsCall Expression45logAction(calculateTax(val, r));

    Next steps

    1. Review the start_line and end_line in src/services/billing.ts to prepare the signature change.
    2. Use get_symbol_context for src/services/billing.ts#function:calculateTax to see if internal members are affected.
    3. Run rename_symbol if the signature change involves a name update to ensure all references stay synced.

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

    About this skill

    Codebase navigation in large JavaScript and TypeScript projects often degrades into a slow cycle of grepping and reading massive files. This skill replaces those expensive operations with structural analysis via the Chanakya MCP server. It provides immediate answers for symbol locations, dependencies, and call hierarchies without burning tokens on redundant file reads.

    What it does

    • Find definitions using exact or substring matching to locate where functions, classes, or types are declared.
    • Map call graphs by retrieving every caller and callee for a specific symbol.
    • Analyze dependencies to see what a file imports or which external files depend on it.
    • Provide symbol context to get definitions, members, and references in a single request.
    • Refactor safely with tools to rename symbols across multiple files or patch specific lines.

    How it works

    1. Index the project by verifying or installing the Chanakya MCP server using the provided npx command.
    2. Search for symbols to retrieve a unique ID for the specific code element you want to inspect.
    3. Query relationships by passing that ID to specialized tools like get_callers or find_references.
    4. Execute edits using structural replace or patch commands that automatically refresh the index.

    Frameworks & tools

    This tool uses Node.js, tree-sitter, and the Model Context Protocol (MCP). It supports JavaScript and TypeScript variants including .js, .jsx, .ts, .tsx, .mjs, and .cjs.

    Why this beats prompting it yourself

    Standard agents rely on raw text search which misses dynamic references and requires reading entire files to understand context. This skill uses a syntax-aware index to resolve imports and exports, providing 100% reliable results for typed symbols while using significantly fewer tokens.

    Use cases

    • Trace a complex bug through a deep call stack across multiple modules.
    • Perform a safe rename of a shared utility function across a large monorepo.
    • Identify every file that will break before changing a shared TypeScript interface.
    • Audit a legacy file to see exactly which external functions it depends on.

    Known limitations

    Does not resolve calls through untyped values, callbacks, or dynamic property access. Support is limited to JS/TS files; it ignores node_modules, gitignored files, and other languages.

    Only supports JS/TS. Does not resolve untyped calls or dynamic property access. Requires Node.js 18.18+ and local indexing. Does not search node_modules or gitignored files.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 18 days ago

    • Free with an Agensi account

    Requires

    @aravindh-arumugam/chanakya-mcp
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed18 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard agents that use basic text search, this skill uses structural indexing via tree-sitter. It understands code relationships like imports, exports, and call hierarchies, allowing it to navigate complex projects without wasting tokens reading irrelevant file content.

    The skill supports all JavaScript and TypeScript variants, including .js, .jsx, .ts, .tsx, .mjs, and .cjs. It is optimized for large-scale projects and monorepos where manual navigation typically becomes slow and error-prone.

    Setup is straightforward: you verify or install the Chanakya MCP server using a provided npx command. Once indexed, the agent can immediately begin querying your codebase using unique symbol IDs for precise navigation.

    This skill is designed for any AI agent or platform that supports the Model Context Protocol (MCP). It acts as a bridge between the LLM and your local development environment, providing the agent with specialized tools to 'see' code structure.

    Chanakya MCP cannot resolve calls made through untyped values, callbacks, or dynamic property access (e.g., calling a function via a string key). It also excludes 'node_modules' and gitignored files to ensure performance and focus on your source code.

    New in LLM Ops