codesearch-mcp 0.0.17-alpha.1 → 0.1.0-alpha

package/dist/src/services/McpServer.js

@@ -39,15 +39,15 @@ const path = __importStar(require("path"));
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const LoggerService_1 = require("./LoggerService");
-const PKG_VERSION = (() => {
+const tools_1 = require("../tools");
+function readPackageVersion() {
     try {
         return JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8')).version ?? '0.0.0';
     }
     catch {
         return '0.0.0';
     }
-})();
+}
 function buildInstructions(t) {
     return `
 You have access to a local code intelligence server. Use these tools to search codebases by meaning, navigate import graphs, look up symbol definitions, and read source files.
@@ -124,402 +124,89 @@ If \`get_dependents\` returns 0 results, add \`symbol\` (the exported name you c
 Lower score = better match (cosine distance). Results above the configured threshold are filtered out automatically. Treat scores above 0.50 as weak hints — verify with \`read_file_range\` or \`Grep\`. Pass \`threshold\` to \`search_codebase\` to override per-query: \`0.40–0.45\` for precise technical queries (known term, exact concept); \`${t}\` default (broad but reliable). Avoid \`0.35\` — too strict for DSL files (GraphQL, Prisma) and infrastructure code.
 `.trim();
 }
+/**
+ * McpServer — thin orchestration layer that delegates tool handling
+ * to individual IMcpToolHandler implementations (Open/Closed Principle).
+ *
+ * To add a new tool: implement IMcpToolHandler and register it in createTools().
+ */
 class McpServer {
     searcher;
     config;
     logger;
-    constructor(searcher, config, logger = LoggerService_1.LoggerService.silent()) {
+    version;
+    tools;
+    constructor(searcher, config, logger) {
         this.searcher = searcher;
         this.config = config;
         this.logger = logger;
+        this.version = readPackageVersion();
+        this.tools = this.createTools();
     }
     async start(startupError) {
         if (startupError) {
             this.logger.error('McpServer: startup failed, server will report error on every tool call', { reason: startupError.message });
         }
-        const server = new index_js_1.Server({ name: 'local-rag', version: PKG_VERSION }, { capabilities: { tools: {} }, instructions: buildInstructions(this.config.search.similarityThreshold) });
+        const server = new index_js_1.Server({ name: 'local-rag', version: this.version }, { capabilities: { tools: {} }, instructions: buildInstructions(this.config.search.similarityThreshold) });
         server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'search_codebase',
-                    description: 'Search local project codebase by semantic similarity',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string' },
-                            limit: { type: 'number', description: `Max results (default ${this.config.search.defaultLimit}, max ${this.config.search.maxLimit})` },
-                            project: { type: 'string', description: 'Filter by project name (optional). Use list_projects to see available names.' },
-                            include_neighbors: { type: 'boolean', description: 'Also include the chunk before and after each result from the same file (Small-to-Big retrieval). Useful when results look truncated.' },
-                            include_graph_context: { type: 'boolean', description: 'Append direct imports and dependents list to each result. Shows "Imports: X · Y" and "Used by: Z" without extra tool calls.' },
-                            threshold: { type: 'number', description: `Max cosine distance (0–1). Lower = stricter. Default: ${this.config.search.similarityThreshold}. Use 0.40–0.45 for precise technical queries, 0.55–0.60 for broad exploration.` },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'list_projects',
-                    description: 'List all indexed projects with their chunk counts and metadata (description, stack, notes, relations from .ragmeta.json).',
-                    inputSchema: { type: 'object', properties: {} },
-                },
-                {
-                    name: 'read_file_range',
-                    description: 'Read a specific line range from an indexed source file. Use this when a search result looks incomplete — read the surrounding lines to get full context.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            file_path: { type: 'string', description: 'File path as returned by search_codebase' },
-                            start_line: { type: 'number', description: 'First line to read (1-based). Use the **Line** number from search_codebase results. Default: 1.' },
-                            end_line: { type: 'number', description: 'Last line to read (1-based, inclusive). Default: start_line + 99.' },
-                        },
-                        required: ['file_path'],
-                    },
-                },
-                {
-                    name: 'get_dependencies',
-                    description: 'Show what files a given file imports (direct or transitive). Use to understand what a file depends on before modifying it. depType values: import | import-default | import-namespace | reexport | reexport-namespace.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            file_path: { type: 'string', description: 'File path as returned by search_codebase' },
-                            project: { type: 'string', description: 'Project name (use list_projects to find it)' },
-                            symbol: { type: 'string', description: 'Filter to a specific imported symbol name (optional)' },
-                            transitive: { type: 'boolean', description: 'Include transitive (indirect) dependencies. Default: false.' },
-                        },
-                        required: ['file_path', 'project'],
-                    },
-                },
-                {
-                    name: 'get_dependents',
-                    description: 'Show which files import a given file (reverse graph). Use before refactoring to find all callers and avoid breaking changes. depType values: import | import-default | import-namespace | reexport | reexport-namespace.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            file_path: { type: 'string', description: 'File path as returned by search_codebase' },
-                            project: { type: 'string', description: 'Project name (use list_projects to find it)' },
-                            symbol: { type: 'string', description: 'Exported symbol name. Two behaviors: (1) if graph dependents exist, narrows them to imports of this symbol; (2) if the import graph returns zero results, triggers a whole-word text-search fallback (grep -F -w) across all .ts/.tsx/.js/.jsx files in the project to find runtime usages — DI containers, singletons, dynamic lookups, string references. Capped at 200 matches.' },
-                            transitive: { type: 'boolean', description: 'Include transitive (indirect) dependents. Default: false.' },
-                        },
-                        required: ['file_path', 'project'],
-                    },
-                },
-                {
-                    name: 'find_symbol',
-                    description: 'Find TypeScript/JavaScript symbol definitions (functions, classes, types, interfaces, variables, methods) by exact name. Use when you know the symbol name and want its definition location fast.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Exact symbol name (case-sensitive, whole-word match)' },
-                            project: { type: 'string', description: 'Limit search to this project (optional). Use list_projects to find names.' },
-                            kind: { type: 'string', enum: ['function', 'class', 'type', 'interface', 'variable', 'method', 'all'], description: 'Symbol kind filter. Default: all.' },
-                        },
-                        required: ['name'],
-                    },
-                },
-                {
-                    name: 'get_callers',
-                    description: 'Find all call sites of a function or method by exact name. Uses the call graph index — faster and more precise than grep. Use after find_symbol to trace where a symbol is actually called. Returns empty if rag-index backfill --calls has not been run.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            symbol: { type: 'string', description: 'Exact function or method name (case-sensitive)' },
-                            project: { type: 'string', description: 'Project name (from list_projects)' },
-                            callee_file: { type: 'string', description: 'Optional: filter by definition file path (as returned by find_symbol) to disambiguate overloaded names' },
-                        },
-                        required: ['symbol', 'project'],
-                    },
-                },
-                {
-                    name: 'list_files',
-                    description: 'List files and directories in a project path as an indented tree. Use to understand project structure before reading files.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string', description: 'Directory path relative to the project root (e.g. "src/components" or "." for root)' },
-                            project: { type: 'string', description: 'Project name (from list_projects)' },
-                            depth: { type: 'number', description: 'Tree depth: 1 = immediate children only, up to 5. Default: 2.' },
-                            pattern: { type: 'string', description: 'Optional filename filter (substring or extension like ".ts"). Only matching files are shown.' },
-                        },
-                        required: ['path', 'project'],
-                    },
-                },
-                {
-                    name: 'read_file',
-                    description: 'Read a file by absolute path. Returns contents with line numbers. Truncates at max_lines with a hint to continue with read_file_range.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            file_path: { type: 'string', description: 'Absolute path to the file. Note: search_codebase returns relative paths — construct the absolute path from your workspace root.' },
-                            max_lines: { type: 'number', description: 'Maximum lines to return (default 300, max 1000)' },
-                        },
-                        required: ['file_path'],
-                    },
-                },
-            ],
+            tools: [...this.tools.values()].map(t => t.definition()),
         }));
         server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
             if (startupError) {
                 return {
+                    isError: true,
                     content: [{
                             type: 'text',
                             text: `MCP server is unavailable: ${startupError.message}\n\nCheck the log file and fix the issue, then restart the MCP server.`,
                         }],
                 };
             }
+            const handler = this.tools.get(req.params.name);
+            if (!handler) {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `Unknown tool: ${req.params.name}` }],
+                };
+            }
             try {
                 const t0 = Date.now();
-                if (req.params.name === 'list_projects') {
-                    const rows = await this.searcher.listProjects();
-                    this.logger.debug('McpServer: list_projects', { count: rows.length, ms: Date.now() - t0 });
-                    if (rows.length === 0) {
-                        return { content: [{ type: 'text', text: 'No indexed projects found.' }] };
-                    }
-                    return { content: [{ type: 'text', text: rows.map(r => {
-                                    const lines = [`${r.serviceName}: ${r.chunks} chunks`];
-                                    if (r.description)
-                                        lines.push(`  description: ${r.description}`);
-                                    if (r.stack)
-                                        lines.push(`  stack: ${r.stack}`);
-                                    if (r.notes)
-                                        lines.push(`  notes: ${r.notes}`);
-                                    if (r.relations) {
-                                        for (const [key, val] of Object.entries(r.relations)) {
-                                            const list = Array.isArray(val) ? val.join(', ') : val;
-                                            lines.push(`  ${key}: ${list}`);
-                                        }
-                                    }
-                                    return lines.join('\n');
-                                }).join('\n\n') }] };
-                }
-                if (req.params.name === 'search_codebase') {
-                    const raw = String(req.params.arguments?.query);
-                    const limit = Math.min(Math.max(1, Number(req.params.arguments?.limit) || this.config.search.defaultLimit), this.config.search.maxLimit);
-                    const project = req.params.arguments?.project ? String(req.params.arguments.project) : null;
-                    const includeNeighbors = Boolean(req.params.arguments?.include_neighbors);
-                    const includeGraphContext = Boolean(req.params.arguments?.include_graph_context);
-                    const rawThreshold = req.params.arguments?.threshold;
-                    const parsedThreshold = Number(rawThreshold);
-                    const threshold = rawThreshold != null && !isNaN(parsedThreshold)
-                        ? Math.min(1, Math.max(0, parsedThreshold))
-                        : undefined;
-                    const { query, translated } = await this.searcher.prepareQuery(raw);
-                    const results = await this.searcher.searchChunks(query, limit, project, threshold);
-                    this.logger.debug('McpServer: search_codebase', {
-                        query: raw.slice(0, 120),
-                        project,
-                        threshold: threshold ?? this.config.search.similarityThreshold,
-                        limit,
-                        translated,
-                        count: results.length,
-                        ms: Date.now() - t0,
-                    });
-                    if (results.length === 0) {
-                        return { content: [{ type: 'text', text: 'No relevant results found.' }] };
-                    }
-                    const header = translated ? `> Query translated: "${raw}" → "${query}"\n\n` : '';
-                    let graphCtx = null;
-                    if (includeGraphContext) {
-                        graphCtx = await this.searcher.fetchGraphContext(results);
-                    }
-                    if (includeNeighbors) {
-                        const withNeighbors = await this.searcher.fetchNeighbors(results);
-                        const blocks = withNeighbors.map(({ result, prevChunk, nextChunk }) => {
-                            const parts = [];
-                            if (prevChunk)
-                                parts.push(this.formatChunk(prevChunk, 'prev chunk'));
-                            parts.push(`${this.formatChunk(result)}\n**Relevance:** ${result.score}${this.formatGraphContext(graphCtx?.get(result.filePath))}`);
-                            if (nextChunk)
-                                parts.push(this.formatChunk(nextChunk, 'next chunk'));
-                            return parts.join('\n\n');
-                        });
-                        return { content: [{ type: 'text', text: header + blocks.join('\n\n---\n\n') }] };
-                    }
-                    const text = results
-                        .map(r => `${this.formatChunk(r)}\n**Relevance:** ${r.score}${this.formatGraphContext(graphCtx?.get(r.filePath))}`)
-                        .join('\n\n---\n\n');
-                    return { content: [{ type: 'text', text: header + text }] };
-                }
-                if (req.params.name === 'read_file_range') {
-                    const filePath = String(req.params.arguments?.file_path);
-                    const startLine = Math.max(1, Number(req.params.arguments?.start_line) || 1);
-                    const endLine = Number(req.params.arguments?.end_line) || startLine + 99;
-                    const range = await this.searcher.readFileRange(filePath, startLine, endLine);
-                    this.logger.debug('McpServer: read_file_range', { file: filePath, startLine, endLine, ok: range.ok, ms: Date.now() - t0 });
-                    if (!range.ok) {
-                        const message = range.reason === 'invalid_path' ? `Invalid file path (outside workspace): ${filePath}` :
-                            range.reason === 'not_indexed' ? `File is not indexed: ${filePath}. Run indexing first.` :
-                                `File was deleted from disk after indexing: ${filePath}. Re-run indexing to update.`;
-                        return { content: [{ type: 'text', text: message }] };
-                    }
-                    const numbered = range.lines.map((line, i) => `${startLine + i}: ${line}`).join('\n');
-                    let text = `**File:** ${range.filePath}\n**Lines:** ${range.startLine}–${range.endLine}\n\`\`\`\n${numbered}\n\`\`\``;
-                    if (range.hasMore) {
-                        text += `\n\n[file has more lines — call read_file_range again with start_line: ${range.endLine + 1}]`;
-                    }
-                    return { content: [{ type: 'text', text }] };
-                }
-                if (req.params.name === 'get_dependencies') {
-                    const filePath = String(req.params.arguments?.file_path);
-                    const project = String(req.params.arguments?.project);
-                    const symbol = req.params.arguments?.symbol ? String(req.params.arguments.symbol) : null;
-                    const transitive = Boolean(req.params.arguments?.transitive);
-                    const rows = await this.searcher.getDependencies(filePath, project, symbol, transitive);
-                    this.logger.debug('McpServer: get_dependencies', { file: filePath, project, transitive, count: rows.length, ms: Date.now() - t0 });
-                    if (rows.length === 0) {
-                        return { content: [{ type: 'text', text: `No dependencies found for: ${filePath}` }] };
-                    }
-                    return { content: [{ type: 'text', text: this.formatDependencies(filePath, rows, transitive) }] };
-                }
-                if (req.params.name === 'get_dependents') {
-                    const filePath = String(req.params.arguments?.file_path);
-                    const project = String(req.params.arguments?.project);
-                    const symbol = req.params.arguments?.symbol ? String(req.params.arguments.symbol) : null;
-                    const transitive = Boolean(req.params.arguments?.transitive);
-                    const rows = await this.searcher.getDependents(filePath, project, symbol, transitive);
-                    this.logger.debug('McpServer: get_dependents', { file: filePath, project, symbol, transitive, count: rows.length, ms: Date.now() - t0 });
-                    if (rows.length > 0) {
-                        return { content: [{ type: 'text', text: this.formatDependents(filePath, rows, transitive) }] };
-                    }
-                    const header = `**Dependents of** \`${filePath}\`\n\n**Direct:** No direct import dependents found.`;
-                    if (!symbol) {
-                        return { content: [{ type: 'text', text: `${header}\n\nTip: pass \`symbol\` to trigger a text-search fallback for runtime usages (e.g. via singleton or container).` }] };
-                    }
-                    const { matches, truncated } = this.searcher.grepSymbol(symbol, project, filePath);
-                    if (matches.length === 0) {
-                        return { content: [{ type: 'text', text: `${header}\n\n**Fallback \`[text search]\` for \`${symbol}\`:** No results.` }] };
-                    }
-                    const grouped = new Map();
-                    for (const m of matches) {
-                        if (!grouped.has(m.filePath))
-                            grouped.set(m.filePath, []);
-                        grouped.get(m.filePath).push(m.line);
-                    }
-                    const fallbackLines = [`\n**Fallback \`[text search]\` for \`${symbol}\`:**${truncated ? ' *(truncated to 200 results)*' : ''}`];
-                    for (const [fp, lines] of grouped) {
-                        fallbackLines.push(`  ~ \`${fp}\`:${lines.join(', ')}`);
-                    }
-                    return { content: [{ type: 'text', text: header + fallbackLines.join('\n') }] };
-                }
-                if (req.params.name === 'find_symbol') {
-                    const name = String(req.params.arguments?.name ?? '');
-                    const project = req.params.arguments?.project ? String(req.params.arguments.project) : null;
-                    const rawKind = req.params.arguments?.kind;
-                    const validKinds = ['function', 'class', 'type', 'interface', 'variable', 'method', 'all'];
-                    const kind = validKinds.includes(rawKind) ? rawKind : 'all';
-                    const { hits, truncated } = await this.searcher.findSymbol(name, project, kind);
-                    this.logger.debug('McpServer: find_symbol', { name, kind, project, count: hits.length, ms: Date.now() - t0 });
-                    if (hits.length === 0) {
-                        return { content: [{ type: 'text', text: `No definitions found for symbol: ${name}` }] };
-                    }
-                    const lines = [];
-                    if (truncated)
-                        lines.push(`*(truncated to ${hits.length} results)*\n`);
-                    for (const h of hits) {
-                        lines.push(`**${h.kind}** \`${h.filePath}\` line ${h.line}, col ${h.column}`);
-                        lines.push(`\`\`\`\n${h.signature}\n\`\`\``);
-                    }
-                    return { content: [{ type: 'text', text: lines.join('\n') }] };
-                }
-                if (req.params.name === 'list_files') {
-                    const relPath = String(req.params.arguments?.path ?? '.');
-                    const project = String(req.params.arguments?.project ?? '');
-                    const rawDepth = Number(req.params.arguments?.depth);
-                    const depth = isNaN(rawDepth) || rawDepth < 1 ? 2 : Math.min(5, rawDepth);
-                    const pattern = req.params.arguments?.pattern ? String(req.params.arguments.pattern) : null;
-                    const { tree, error } = this.searcher.listFiles(relPath, project, depth, pattern);
-                    this.logger.debug('McpServer: list_files', { path: relPath, project, depth, ms: Date.now() - t0 });
-                    if (error) {
-                        return { content: [{ type: 'text', text: `list_files error: ${error}` }] };
-                    }
-                    return { content: [{ type: 'text', text: `**${project}/${relPath}**\n\`\`\`\n${tree}\n\`\`\`` }] };
-                }
-                if (req.params.name === 'read_file') {
-                    const filePath = String(req.params.arguments?.file_path ?? '');
-                    const rawMax = Number(req.params.arguments?.max_lines);
-                    const maxLines = isNaN(rawMax) || rawMax < 1 ? 300 : Math.min(1000, rawMax);
-                    const result = await this.searcher.readFileAbsolute(filePath, maxLines);
-                    this.logger.debug('McpServer: read_file', { file: filePath, maxLines, ok: result.ok, ms: Date.now() - t0 });
-                    if (!result.ok) {
-                        const message = result.reason === 'invalid_path' ? `Invalid path (outside workspace): ${filePath}` :
-                            `File not found on disk: ${filePath}`;
-                        return { content: [{ type: 'text', text: message }] };
-                    }
-                    const numbered = result.lines.map((line, i) => `${i + 1}: ${line}`).join('\n');
-                    let text = `**File:** ${result.filePath}\n**Lines:** 1–${result.endLine}\n\`\`\`\n${numbered}\n\`\`\``;
-                    if (result.hasMore) {
-                        text += `\n\n[truncated: file has more lines — use read_file_range with file_path: "${result.filePath}", start_line: ${result.endLine + 1} to continue]`;
-                    }
-                    return { content: [{ type: 'text', text }] };
-                }
-                if (req.params.name === 'get_callers') {
-                    const symbol = String(req.params.arguments?.symbol ?? '');
-                    const project = String(req.params.arguments?.project ?? '');
-                    const calleeFile = req.params.arguments?.callee_file ? String(req.params.arguments.callee_file) : null;
-                    const rows = await this.searcher.getCallers(symbol, project, calleeFile);
-                    this.logger.debug('McpServer: get_callers', { symbol, project, count: rows.length, ms: Date.now() - t0 });
-                    if (rows.length === 0) {
-                        return { content: [{ type: 'text', text: `No call sites found for \`${symbol}\` in project \`${project}\`. Run \`rag-index backfill --calls\` if the call graph has not been populated yet.` }] };
-                    }
-                    const lines = [`**Call sites of \`${symbol}\`** (${rows.length} found)\n`];
-                    for (const r of rows) {
-                        const loc = r.line != null ? ` line ${r.line}` : '';
-                        const ctx = r.fromSymbol ? `, in \`${r.fromSymbol}\`` : '';
-                        lines.push(`  → \`${r.fromFile}\`${loc}${ctx}`);
-                    }
-                    return { content: [{ type: 'text', text: lines.join('\n') }] };
-                }
-                throw new Error(`Unknown tool: ${req.params.name}`);
+                const result = await handler.handle((req.params.arguments ?? {}));
+                this.logger.debug('McpServer: tool handled', { tool: req.params.name, ms: Date.now() - t0 });
+                return result;
             }
             catch (err) {
-                this.logger.error('McpServer: tool handler error', { tool: req.params.name, reason: err.message });
-                return { content: [{ type: 'text', text: `Tool error: ${err.message}` }] };
+                const reason = err instanceof Error ? err.message : String(err);
+                this.logger.error('McpServer: tool handler error', { tool: req.params.name, reason });
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `Tool error: ${reason}` }],
+                };
             }
         });
         await server.connect(new stdio_js_1.StdioServerTransport());
-        this.logger.info('McpServer: started', { version: PKG_VERSION });
-    }
-    formatGraphContext(ctx) {
-        const parts = [];
-        if (ctx?.imports.length)
-            parts.push(`**Imports:** ${ctx.imports.join(' · ')}`);
-        if (ctx?.usedBy.length)
-            parts.push(`**Used by:** ${ctx.usedBy.join(' · ')}`);
-        return parts.length > 0 ? '\n' + parts.join('\n') : '';
+        this.logger.info('McpServer: started', { version: this.version });
     }
-    formatChunk(r, label) {
-        return `${label ? `*(${label})*\n` : ''}**File:** ${r.filePath}\n**Project:** ${r.serviceName}\n**Line:** ${r.startLine}\n\`\`\`\n${r.content}\n\`\`\``;
-    }
-    formatDependencies(filePath, rows, transitive) {
-        const direct = rows.filter(r => !transitive || (r.depth ?? 1) === 1);
-        const indirect = transitive ? rows.filter(r => (r.depth ?? 1) > 1) : [];
-        const lines = [`**Dependencies of** \`${filePath}\`\n`, '**Direct:**'];
-        for (const r of direct) {
-            const sym = r.toSymbol ? ` (${r.depType} \`${r.toSymbol}\`)` : ` (${r.depType})`;
-            lines.push(`  → \`${r.toFile}\`${sym}`);
-        }
-        if (indirect.length > 0) {
-            lines.push('\n**Transitive:**');
-            for (const r of indirect) {
-                const sym = r.toSymbol ? ` (\`${r.toSymbol}\`)` : '';
-                lines.push(`  → \`${r.toFile}\`${sym}  *(via ${r.via}, depth ${r.depth})*`);
-            }
-        }
-        return lines.join('\n');
-    }
-    formatDependents(filePath, rows, transitive) {
-        const direct = rows.filter(r => !transitive || (r.depth ?? 1) === 1);
-        const indirect = transitive ? rows.filter(r => (r.depth ?? 1) > 1) : [];
-        const lines = [`**Dependents of** \`${filePath}\`\n`, '**Direct:**'];
-        for (const r of direct) {
-            const sym = r.toSymbol ? ` (imports \`${r.toSymbol}\`)` : '';
-            lines.push(`  ← \`${r.fromFile}\`${sym}`);
-        }
-        if (indirect.length > 0) {
-            lines.push('\n**Transitive:**');
-            for (const r of indirect) {
-                lines.push(`  ← \`${r.fromFile}\`  *(via ${r.via}, depth ${r.depth})*`);
-            }
+    /**
+     * Factory method: creates and registers all tool handlers.
+     * New tools are added here without modifying the dispatch logic above.
+     */
+    createTools() {
+        const handlers = [
+            new tools_1.ListProjectsTool(this.searcher),
+            new tools_1.SearchCodebaseTool(this.searcher, this.config.search.defaultLimit, this.config.search.maxLimit, this.config.search.similarityThreshold, this.logger),
+            new tools_1.ReadFileRangeTool(this.searcher),
+            new tools_1.GetDependenciesTool(this.searcher),
+            new tools_1.GetDependentsTool(this.searcher),
+            new tools_1.FindSymbolTool(this.searcher),
+            new tools_1.GetCallersTool(this.searcher),
+            new tools_1.ListFilesTool(this.searcher),
+            new tools_1.ReadFileTool(this.searcher),
+        ];
+        const map = new Map();
+        for (const h of handlers) {
+            map.set(h.definition().name, h);
         }
-        return lines.join('\n');
+        return map;
     }
 }
 exports.McpServer = McpServer;

package/dist/src/services/MonorepoAwareDiscoveryService.d.ts

@@ -0,0 +1,62 @@
+import type { ILogger } from '../interfaces';
+import type { IMonorepoResolver } from '../interfaces/IMonorepoResolver';
+import type { DiscoveredProject, IProjectDiscovery } from '../interfaces';
+export interface WorkspaceInfo {
+    isMonorepo: boolean;
+    rootTsConfigPath: string | null;
+    projects: DiscoveredProject[];
+}
+/**
+ * Expand discovery units into the leaf projects to index: a nested monorepo
+ * unit (with `children`) becomes its sub-projects; an ordinary project stays
+ * itself. Shared by IndexCommand (indexing loop) and SearcherService (name→path
+ * resolution) so both agree on the leaf set.
+ */
+export declare function toLeafProjects(projects: DiscoveredProject[]): DiscoveredProject[];
+/**
+ * Project discovery that is monorepo-aware.
+ *
+ * When a monorepo is detected (via the resolver), it uses the resolver
+ * to discover projects. Otherwise, it falls back to the original
+ * flat-workspace discovery (directories with package.json). Cross-project
+ * import resolution relies on the tsconfig `paths` attached via
+ * `rootTsConfigPath` — no separate scope map is built.
+ *
+ * Single Responsibility: only discovers projects and workspace metadata.
+ * Does not index or search.
+ *
+ * Implements {@link IProjectDiscovery} so it can be wired as the default
+ * discovery in the container. `discover()` returns one entry per top-level
+ * project: when the root itself is a monorepo, each entry carries the
+ * workspace-wide `rootTsConfigPath`; under a flat root, an ordinary project
+ * gets `rootTsConfigPath: null`, while a top-level directory that is itself a
+ * nested monorepo is returned as a single unit with expanded `children` (see
+ * `toLeafProjects`). `analyzeWorkspace()` exposes the full workspace metadata
+ * (monorepo flag, root tsconfig, project list).
+ */
+export declare class MonorepoAwareDiscoveryService implements IProjectDiscovery {
+    private resolvers;
+    private logger;
+    /** Discovery used when no monorepo is detected. Defaults to flat package.json scan. */
+    private flatDiscovery;
+    constructor(resolvers: IMonorepoResolver[], logger: ILogger, 
+    /** Discovery used when no monorepo is detected. Defaults to flat package.json scan. */
+    flatDiscovery?: IProjectDiscovery);
+    /**
+     * IProjectDiscovery contract: enumerate projects in the workspace.
+     * Attaches the workspace-wide root tsconfig to every project so the
+     * indexer can resolve cross-project path aliases.
+     */
+    discover(rootDir: string): DiscoveredProject[];
+    /**
+     * If `project`'s directory is itself a monorepo (resolver detects it),
+     * return it with expanded `children` named `<repo>/<sub-project>`, each
+     * carrying the repo's workspace-wide tsconfig. Otherwise return it unchanged.
+     */
+    private expandIfNestedMonorepo;
+    /**
+     * Analyze the workspace root and return full workspace information:
+     * monorepo detection flag, root tsconfig path, and project list.
+     */
+    analyzeWorkspace(rootDir: string): WorkspaceInfo;
+}