@supermodeltools/mcp-server 0.7.0 → 0.7.2

package/README.md

@@ -366,6 +366,71 @@ Generate an AST-level parse graph with fine-grained code structure.
 | `directory` | string | Yes | Path to repository directory |
 | `jq_filter` | string | No | jq filter for custom data extraction |
 
+### Task-Specific Query Tools
+
+After generating a graph with any of the tools above, use these lightweight tools for focused queries. They run against the cached graph and return small, targeted results (<10KB, <5s).
+
+#### `find_call_sites`
+
+Find all locations where a specific function is called.
+
+**Parameters:**
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `path` | string | Yes | Path that was previously analyzed |
+| `function_name` | string | Yes | Name of the function to find call sites for |
+| `include_context` | boolean | No | Include surrounding code context |
+| `max_results` | number | No | Maximum number of results to return |
+
+#### `trace_call_chain`
+
+Find the shortest call path from function A to function B using BFS.
+
+**Parameters:**
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `path` | string | Yes | Path that was previously analyzed |
+| `from_function` | string | Yes | Starting function name |
+| `to_function` | string | Yes | Target function name |
+| `max_depth` | number | No | Maximum search depth |
+
+#### `find_definition`
+
+Locate where a symbol (function, class, variable, type) is defined.
+
+**Parameters:**
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `path` | string | Yes | Path that was previously analyzed |
+| `name` | string | Yes | Symbol name to find |
+| `type` | string | No | Symbol type: function, class, variable, or type |
+
+#### `trace_data_flow`
+
+Track how data flows through function parameters and variables.
+
+**Parameters:**
+
+| Argument | Type | Required | Description |
+|----------|------|----------|-------------|
+| `path` | string | Yes | Path that was previously analyzed |
+| `variable` | string | Yes | Variable or parameter name to trace |
+| `function_name` | string | No | Starting function for the trace |
+| `max_depth` | number | No | Maximum trace depth |
+
+### Feedback Tools
+
+#### `request_feature`
+
+Open a feature request issue on the supermodeltools/mcp GitHub repository. Requires a `GITHUB_TOKEN` environment variable with `public_repo` scope.
+
+#### `report_bug`
+
+Report a bug or unexpected behavior by opening an issue on the supermodeltools/mcp GitHub repository. Requires a `GITHUB_TOKEN` environment variable with `public_repo` scope.
+
 ### Choosing the Right Tool
 
 | Tool | Best For | Output Size |
@@ -375,10 +440,14 @@ Generate an AST-level parse graph with fine-grained code structure.
 | `get_dependency_graph` | Module refactoring, circular deps | Small - modules only |
 | `get_domain_graph` | Architecture overview | Smallest - domains only |
 | `get_parse_graph` | AST analysis, precise refactoring | Large - full AST |
+| `find_call_sites` | Where is function X called? | Small (<10KB) |
+| `trace_call_chain` | Path from function A to B | Small (<10KB) |
+| `find_definition` | Where is symbol X defined? | Small (<10KB) |
+| `trace_data_flow` | How does data flow through params? | Small (<10KB) |
 
-**Tip:** Start with `get_domain_graph` for a quick architecture overview, then drill down with `get_call_graph` or `get_dependency_graph` for specific areas.
+**Tip:** Start with `get_domain_graph` for a quick architecture overview, then use task-specific query tools (`find_call_sites`, `trace_call_chain`, etc.) for focused questions. Drill down with `get_call_graph` or `get_dependency_graph` for broader analysis.
 
-> **Note:** All graph tools accept a `directory` parameter and an optional `jq_filter`. If you start the server with a default working directory (`node dist/index.js /path/to/repo`), the `directory` argument can be omitted from tool calls.
+> **Note:** All graph tools accept a `directory` parameter and an optional `jq_filter`. Task-specific query tools use `path` instead. If you start the server with a default working directory (`node dist/index.js /path/to/repo`), directory arguments can be omitted from tool calls.
 
 ## Tool Performance & Timeout Requirements
 

package/dist/server.js

@@ -47,6 +47,9 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const sdk_1 = require("@supermodeltools/sdk");
 const create_supermodel_graph_1 = __importDefault(require("./tools/create-supermodel-graph"));
 const graph_tools_1 = require("./tools/graph-tools");
+const task_query_tools_1 = require("./tools/task-query-tools");
+const feature_request_1 = __importDefault(require("./tools/feature-request"));
+const report_bug_1 = __importDefault(require("./tools/report-bug"));
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const zip_repository_1 = require("./utils/zip-repository");
 const undici_1 = require("undici");
@@ -87,28 +90,85 @@ class Server {
 
 Generate code graphs to understand a codebase before making changes.
 
-## Recommended Workflow
+## Choosing a Tool
 
-1. Start with \`get_domain_graph\` to understand architecture
-2. Use \`get_call_graph\` or \`get_dependency_graph\` to drill into specific areas
-3. Use \`get_parse_graph\` only when you need full structural detail
+- **Need architecture overview?** → \`get_domain_graph\` (smallest output, fastest to read)
+- **Need to trace function calls?** → \`get_call_graph\` (function nodes + "calls" relationships)
+- **Need to understand imports/dependencies?** → \`get_dependency_graph\` (file nodes + "IMPORTS" relationships)
+- **Need full code structure (classes, types, functions)?** → \`get_parse_graph\` (all nodes + structural relationships)
+- **Need everything in one call?** → \`explore_codebase\` (complete graph with built-in query engine)
+- **Need a focused answer about a specific function/symbol?** → Task-specific query tools (see below)
 
-Node IDs are consistent across all graph types. A function ID from \`get_domain_graph\` can be looked up in \`get_call_graph\` results to find its callers.
+Node IDs are consistent across all graph types. A function ID from \`get_domain_graph\` works in \`get_call_graph\` results.
+
+## What Each Tool Returns
+
+- \`get_domain_graph\`: Domains → { name, description, responsibilities, subdomains, files, functions, classes }
+- \`get_call_graph\`: Functions → { name, filePath, startLine, endLine } with "calls" relationships
+- \`get_dependency_graph\`: Files → { name, filePath, language } with "IMPORTS" relationships
+- \`get_parse_graph\`: All node types (File, Directory, Class, Function, Type) with structural relationships (CONTAINS, DEFINES, DECLARES, IMPORTS)
+- \`explore_codebase\`: Full graph (all of the above combined) with a query engine for filtering
+
+## Parameters
+
+All graph tools accept \`directory\` and \`jq_filter\`. Both are optional:
+- \`directory\`: Path to analyze. **Omit this** if the MCP server was started with a default workdir — it will use that automatically. Pass a subdirectory (e.g. \`src/auth\`) for faster results.
+- \`jq_filter\`: Optional jq expression to extract specific data from the response.
+
+## Caching
+
+\`explore_codebase\` caches graphs in memory (1-hour TTL, LRU eviction). The first call hits the API (30+ seconds); subsequent queries on the same directory are instant. Use \`query: "graph_status"\` to check if a graph is cached before making API calls. Regenerate after code changes by calling without a query. The individual graph tools (\`get_call_graph\`, etc.) do not use the cache — each call hits the API.
+
+## Task-Specific Query Tools
+
+After generating a graph, use these lightweight tools for focused queries:
+
+- \`find_call_sites\`: Find where a function is called (<5s, <10KB)
+- \`trace_call_chain\`: Find path from function A to B (<5s, <10KB)
+- \`find_definition\`: Locate where a symbol is defined (<5s, <10KB)
+- \`trace_data_flow\`: Follow how data flows through parameters (<5s, <10KB)
+
+These tools require a graph to be cached first (via any graph generation tool).
 
 ## Performance
 
-- First call takes 30+ seconds (API processing time)
+- First API call takes 30+ seconds (complex repos can take 10+ minutes)
 - Analyze subdirectories for faster results: \`src/auth\` instead of full repo
 - Use \`jq_filter\` to extract only the data you need
+- With \`explore_codebase\`, use the query engine instead of re-fetching
+- Task query tools are fast (<5s) after initial graph generation
 
-## explore_codebase
+## Common Mistakes
 
-Returns the complete graph with all data combined. Useful for comprehensive exports or integration with external tools. For iterative analysis, prefer the individual graph tools above.
+- **Don't analyze the full repo when you only need one module.** Pass a subdirectory to \`directory\`.
+- **Don't use \`explore_codebase\` when you only need call or dependency data.** The individual tools return smaller, focused results.
+- **Don't re-fetch when the graph is cached.** Use \`explore_codebase\` with \`query: "graph_status"\` to check first.
+- **Don't forget \`jq_filter\`.** Large graphs can be megabytes — filter to what you need.
 
 ## Errors
 
-- \`error.recoverable: true\` → retry after brief wait
-- \`error.reportable: true\` → server bug, can be reported`,
+- \`error.recoverable: true\` → retry after a brief wait
+- \`error.reportable: true\` → likely a server bug, consider filing with \`report_bug\`
+
+## Feedback: Feature Requests & Bug Reports
+
+If you have an idea for a feature that would make the Supermodel MCP server more useful, or if you encounter a bug or unexpected behavior with any tool or with the underlying Supermodel API, you can open an issue directly on the supermodeltools/mcp GitHub repository using the \`request_feature\` and \`report_bug\` tools. The Supermodel team reviews and responds to all submitted issues.
+
+**Setup:** These tools require a \`GITHUB_TOKEN\` environment variable with permission to create issues on public repositories. To set this up:
+1. Create a GitHub personal access token at https://github.com/settings/tokens with the \`public_repo\` scope.
+2. Set the token as an environment variable: \`export GITHUB_TOKEN=ghp_your_token_here\`
+3. Restart the MCP server so it picks up the new environment variable.
+
+**When to use \`request_feature\`:**
+- You think a new tool or query type would be helpful
+- An existing tool is missing a capability you need
+- You have an idea to improve the developer experience
+
+**When to use \`report_bug\`:**
+- A tool returned an error that seems incorrect or unexpected
+- Results don't match what the tool description promises
+- You hit a crash, timeout, or other failure that seems like a server issue
+- The Supermodel API returned malformed or unexpected data`,
         });
         const config = new sdk_1.Configuration({
             basePath: process.env.SUPERMODEL_BASE_URL || 'https://api.supermodeltools.com',
@@ -128,10 +188,13 @@ Returns the complete graph with all data combined. Useful for comprehensive expo
         this.setupHandlers();
     }
     setupHandlers() {
-        // Collect all tools: the main explore_codebase tool plus individual graph tools
+        // Collect all tools: the main explore_codebase tool plus individual graph tools plus task query tools
         const allTools = [
             create_supermodel_graph_1.default,
             ...graph_tools_1.graphTools,
+            ...task_query_tools_1.taskQueryTools,
+            feature_request_1.default,
+            report_bug_1.default,
         ];
         // Create a map for quick handler lookup, checking for duplicates
         const toolMap = new Map();

package/dist/tools/feature-request.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Tool for agents to submit feature requests as GitHub issues.
+ * Creates issues on the supermodeltools/mcp repository.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.tool = exports.metadata = void 0;
+const types_1 = require("../types");
+const github_1 = require("../utils/github");
+exports.metadata = {
+    resource: 'issues',
+    operation: 'write',
+    tags: ['feature-request', 'github'],
+    httpMethod: 'post',
+    httpPath: '/repos/supermodeltools/mcp/issues',
+    operationId: 'createFeatureRequest',
+};
+exports.tool = {
+    name: 'request_feature',
+    description: `Submit a feature request to the Supermodel MCP server GitHub repository (${github_1.GITHUB_REPO}).
+
+Creates a GitHub issue on behalf of the agent. The Supermodel team actively monitors and responds to all submitted issues.
+
+Use this tool whenever you believe a new feature, improvement, or enhancement would be helpful for the Supermodel MCP server or its underlying API. Examples include:
+- Suggesting a new tool, query type, or graph capability
+- Requesting improvements to an existing tool (e.g. better filtering, new parameters, improved output format)
+- Proposing changes to error messages, documentation, or developer experience
+- Identifying a missing capability you needed while working on a task
+
+This tool requires a GITHUB_TOKEN environment variable. To set it up:
+1. Create a GitHub personal access token at https://github.com/settings/tokens with the "public_repo" scope
+2. Set it in your environment: export GITHUB_TOKEN=ghp_your_token_here
+3. Restart the MCP server`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            title: {
+                type: 'string',
+                description: 'Short, descriptive title for the feature request.',
+            },
+            description: {
+                type: 'string',
+                description: 'Detailed description of the feature. Include context, use cases, and expected behavior.',
+            },
+            labels: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional labels to categorize the issue (e.g. ["enhancement"]).',
+            },
+        },
+        required: ['title', 'description'],
+    },
+};
+const handler = async (_client, args) => {
+    const tokenError = (0, github_1.validateGitHubToken)();
+    if (tokenError)
+        return (0, types_1.asErrorResult)(tokenError);
+    if (!args) {
+        return (0, types_1.asErrorResult)({
+            type: 'validation_error',
+            message: 'Missing required parameters: title and description.',
+            code: 'MISSING_PARAMETERS',
+            recoverable: false,
+            suggestion: 'Provide both "title" and "description" parameters.',
+        });
+    }
+    const { title, description, labels } = args;
+    const titleError = (0, github_1.validateRequiredString)(title, 'title', 'INVALID_TITLE', 'Provide a short, descriptive title as a string.');
+    if (titleError)
+        return (0, types_1.asErrorResult)(titleError);
+    const descError = (0, github_1.validateRequiredString)(description, 'description', 'INVALID_DESCRIPTION', 'Provide a detailed description as a string.');
+    if (descError)
+        return (0, types_1.asErrorResult)(descError);
+    const labelsError = (0, github_1.validateLabels)(labels);
+    if (labelsError)
+        return (0, types_1.asErrorResult)(labelsError);
+    return (0, github_1.createGitHubIssue)('request_feature', {
+        title: title,
+        body: description,
+        labels: labels,
+    }, 'Feature request created successfully.');
+};
+exports.handler = handler;
+exports.default = { metadata: exports.metadata, tool: exports.tool, handler: exports.handler };

package/dist/tools/find-call-sites.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Task-specific tool: Find call sites for a function
+ * Lightweight, focused query without full graph overhead
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCallSitesTool = void 0;
+exports.findCallSites = findCallSites;
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const cache_1 = require("../cache");
+const FindCallSitesArgsSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('Repository path'),
+    function_name: zod_1.z.string().describe('Name of function to find call sites for'),
+    include_context: zod_1.z.boolean().optional().describe('Include surrounding code context'),
+    max_results: zod_1.z.number().optional().describe('Maximum number of results to return'),
+});
+/**
+ * Find all places where a function is called
+ */
+async function findCallSites(args) {
+    const { path, function_name, include_context = true, max_results = 10 } = args;
+    // Get cached graph
+    const cacheKey = getCacheKey(path);
+    const graph = cache_1.graphCache.get(cacheKey);
+    if (!graph) {
+        throw new Error('Graph not cached. Run explore_codebase first to analyze the repository.');
+    }
+    // Find function node by name (case-insensitive)
+    const functionNodes = findFunctionsByName(graph, function_name);
+    if (functionNodes.length === 0) {
+        return {
+            function_name,
+            total_call_sites: 0,
+            call_sites: [],
+            summary: `Function "${function_name}" not found in codebase.`,
+        };
+    }
+    // Use first match if multiple functions with same name
+    const targetNode = functionNodes[0];
+    const targetId = targetNode.id;
+    // Get incoming call edges
+    const callAdj = graph.callAdj.get(targetId);
+    if (!callAdj || callAdj.in.length === 0) {
+        return {
+            function_name,
+            total_call_sites: 0,
+            call_sites: [],
+            summary: `Function "${function_name}" is not called by any other functions.`,
+        };
+    }
+    // Build call site results
+    const callSites = [];
+    for (const callerId of callAdj.in) {
+        const callerNode = graph.nodeById.get(callerId);
+        if (!callerNode)
+            continue;
+        // Find edge details (if available)
+        const edge = findCallEdge(graph, callerId, targetId);
+        const result = {
+            caller: {
+                name: callerNode.properties?.name || 'unknown',
+                file: callerNode.properties?.filePath || 'unknown',
+                line: callerNode.properties?.startLine || 0,
+            },
+            call_site: {
+                line: edge?.properties?.lineNumber || 0,
+                column: edge?.properties?.columnNumber,
+                context: edge?.properties?.context,
+                code_snippet: include_context ? edge?.properties?.codeSnippet : undefined,
+            },
+        };
+        callSites.push(result);
+        if (callSites.length >= max_results) {
+            break;
+        }
+    }
+    // Generate summary
+    const summary = generateSummary(function_name, callSites, callAdj.in.length);
+    return {
+        function_name,
+        total_call_sites: callAdj.in.length,
+        call_sites: callSites,
+        summary,
+    };
+}
+/**
+ * Helper: Find function nodes by name
+ */
+function findFunctionsByName(graph, name) {
+    const lowerName = name.toLowerCase();
+    const nodeIds = graph.nameIndex.get(lowerName) || [];
+    return nodeIds
+        .map((id) => graph.nodeById.get(id))
+        .filter((node) => node && node.labels?.[0] === 'Function');
+}
+/**
+ * Helper: Find specific call edge between two functions
+ */
+function findCallEdge(graph, fromId, toId) {
+    // In original cache, edges aren't indexed by ID
+    // This is a limitation we'd fix in edge-aware cache
+    // For now, search through raw relationships
+    const relationships = graph.raw?.graph?.relationships || [];
+    return relationships.find((rel) => rel.type === 'calls' && rel.startNode === fromId && rel.endNode === toId);
+}
+/**
+ * Helper: Generate natural language summary
+ */
+function generateSummary(functionName, callSites, total) {
+    if (callSites.length === 0) {
+        return `Function "${functionName}" is not called by any functions.`;
+    }
+    const callerNames = callSites.map(cs => cs.caller.name);
+    const uniqueFiles = new Set(callSites.map(cs => cs.caller.file));
+    let summary = `Function "${functionName}" is called by ${total} function(s) in ${uniqueFiles.size} file(s).`;
+    if (callSites.length > 0) {
+        summary += ` Primary callers: ${callerNames.slice(0, 3).join(', ')}`;
+        if (total > 3) {
+            summary += ` and ${total - 3} more`;
+        }
+        summary += '.';
+    }
+    return summary;
+}
+/**
+ * Helper: Generate cache key (simplified - should match main implementation)
+ */
+function getCacheKey(path) {
+    // In real implementation, this would include git hash, etc.
+    return `cache_${path}`;
+}
+/**
+ * Tool metadata for MCP registration
+ */
+exports.findCallSitesTool = {
+    name: 'find_call_sites',
+    description: 'Find all places where a specific function is called, with line numbers and context',
+    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(FindCallSitesArgsSchema),
+    handler: findCallSites,
+};

package/dist/tools/find-definition.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Task-specific tool: Find definition of a symbol
+ * Fast lookup in cache indexes to locate where something is defined
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDefinitionTool = void 0;
+exports.findDefinition = findDefinition;
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const cache_1 = require("../cache");
+const FindDefinitionArgsSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('Repository path'),
+    name: zod_1.z.string().describe('Name of the symbol to find'),
+    type: zod_1.z.enum(['function', 'class', 'variable', 'type', 'any']).optional().describe('Type of symbol'),
+    max_results: zod_1.z.number().optional().describe('Maximum number of results if multiple matches'),
+});
+/**
+ * Find where a symbol is defined
+ */
+async function findDefinition(args) {
+    const { path, name, type = 'any', max_results = 5 } = args;
+    // Get cached graph
+    const cacheKey = getCacheKey(path);
+    const graph = cache_1.graphCache.get(cacheKey);
+    if (!graph) {
+        throw new Error('Graph not cached. Run explore_codebase first to analyze the repository.');
+    }
+    // Find nodes by name (case-insensitive)
+    const lowerName = name.toLowerCase();
+    const nodeIds = graph.nameIndex.get(lowerName) || [];
+    if (nodeIds.length === 0) {
+        return {
+            query_name: name,
+            query_type: type,
+            found: false,
+            results: [],
+            summary: `No definition found for "${name}".`,
+        };
+    }
+    // Filter by type if specified
+    const nodes = nodeIds
+        .map(id => graph.nodeById.get(id))
+        .filter((node) => node !== undefined && matchesType(node, type))
+        .slice(0, max_results);
+    if (nodes.length === 0) {
+        return {
+            query_name: name,
+            query_type: type,
+            found: false,
+            results: [],
+            summary: `No ${type} definition found for "${name}".`,
+        };
+    }
+    // Build results
+    const results = nodes.map(node => {
+        const props = node.properties || {};
+        return {
+            name: props.name || name,
+            type: node.labels?.[0] || 'unknown',
+            file: props.filePath || 'unknown',
+            line: props.startLine || 0,
+            end_line: props.endLine,
+            kind: props.kind,
+            context: buildContext(node),
+        };
+    });
+    // Generate summary
+    const summary = generateSummary(name, type, results);
+    return {
+        query_name: name,
+        query_type: type,
+        found: true,
+        results,
+        summary,
+    };
+}
+/**
+ * Check if node matches the requested type
+ */
+function matchesType(node, requestedType) {
+    if (requestedType === 'any') {
+        return true;
+    }
+    const primaryLabel = node.labels?.[0]?.toLowerCase() || '';
+    // Map requested type to node labels
+    const typeMap = {
+        function: ['function', 'method'],
+        class: ['class', 'interface', 'struct'],
+        variable: ['variable', 'constant', 'parameter', 'field'],
+        type: ['type', 'typedef', 'enum', 'interface'],
+    };
+    const acceptedLabels = typeMap[requestedType] || [requestedType];
+    return acceptedLabels.some(label => primaryLabel.includes(label));
+}
+/**
+ * Build context string for a definition
+ */
+function buildContext(node) {
+    const props = node.properties || {};
+    const label = node.labels?.[0] || 'symbol';
+    const parts = [];
+    // Add scope if available
+    if (props.scope) {
+        parts.push(`in ${props.scope}`);
+    }
+    // Add signature for functions
+    if (label === 'Function' && props.signature) {
+        parts.push(`signature: ${props.signature}`);
+    }
+    // Add modifiers
+    const modifiers = [];
+    if (props.isStatic)
+        modifiers.push('static');
+    if (props.isAsync)
+        modifiers.push('async');
+    if (props.isPublic)
+        modifiers.push('public');
+    if (props.isPrivate)
+        modifiers.push('private');
+    if (modifiers.length > 0) {
+        parts.push(modifiers.join(' '));
+    }
+    return parts.join(', ') || undefined;
+}
+/**
+ * Generate natural language summary
+ */
+function generateSummary(name, type, results) {
+    if (results.length === 0) {
+        return `No definition found for "${name}".`;
+    }
+    if (results.length === 1) {
+        const result = results[0];
+        return `${result.type} "${name}" defined in ${result.file}:${result.line}`;
+    }
+    // Multiple results
+    const typeCount = new Map();
+    for (const result of results) {
+        typeCount.set(result.type, (typeCount.get(result.type) || 0) + 1);
+    }
+    const typeSummary = Array.from(typeCount.entries())
+        .map(([t, count]) => `${count} ${t}${count > 1 ? 's' : ''}`)
+        .join(', ');
+    return `Found ${results.length} definitions for "${name}": ${typeSummary}`;
+}
+/**
+ * Helper: Generate cache key
+ */
+function getCacheKey(path) {
+    return `cache_${path}`;
+}
+/**
+ * Tool metadata for MCP registration
+ */
+exports.findDefinitionTool = {
+    name: 'find_definition',
+    description: 'Find where a symbol (function, class, variable, type) is defined in the codebase',
+    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(FindDefinitionArgsSchema),
+    handler: findDefinition,
+};