codesearch-mcp 0.0.9-alpha → 0.0.11-alpha

package/dist/src/services/McpServer.js

@@ -0,0 +1,411 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = void 0;
+const fs = __importStar(require("fs"));
+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 = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
+const SERVER_INSTRUCTIONS = `
+You have access to a local semantic code search server. Use these tools to navigate unfamiliar codebases.
+
+## Tools
+
+- **list_projects** — call this first to see what projects are indexed and their exact names.
+- **search_codebase** — semantic search across indexed source files. Returns file path, line number, and a code chunk.
+- **read_file_range** — read a specific line range from any indexed file. Use this to expand context around a search result.
+- **get_dependencies** — show what files a given file imports (direct or transitive). Use to understand what a file depends on.
+- **get_dependents** — show which files import a given file (reverse graph). Use before refactoring to find all callers.
+- **find_symbol** — find where a symbol (function, class, type, interface, variable) is defined by exact name. Faster than semantic search when you know the name.
+- **list_files** — browse the directory tree of a project path. Use to understand project structure before reading files.
+- **read_file** — read a complete file by absolute path with line numbers. Truncates at max_lines with a hint to continue.
+
+## Recommended workflow
+
+1. Use \`list_projects\` to discover available projects before filtering by \`project\`.
+2. Use \`search_codebase\` to find relevant code by meaning.
+3. If a result looks **truncated or incomplete** (e.g. you see only the middle of a function), call \`read_file_range\` with the returned \`file_path\` and \`start_line\` set to the **Line** number shown in the result. Example: if the result shows **Line:** 150, pass \`start_line: 150\`.
+4. For exploratory searches where you expect results to span chunk boundaries, pass \`include_neighbors: true\` to automatically include the chunk before and after each match.
+5. Use \`find_symbol\` when you know the exact name of a function or class and want its definition location immediately — faster than semantic search.
+6. Use \`list_files\` to explore project structure (src/, components/, etc.) before diving into files.
+7. Use \`read_file\` to read a complete file when you have its absolute path from \`search_codebase\` results.
+
+## When to use read_file_range vs include_neighbors
+
+- **include_neighbors: true** — good when you already know the context will be fragmented (e.g. searching for a class definition that's likely split across chunks).
+- **read_file_range** — better when you want to read a precise section, or when a result looks cut off and you want to expand just that one file.
+
+## Handling Code Structure
+- **Class/Function limits**: Chunks often end abruptly. Always use \`read_file_range\` to find the closing brace or the beginning of a method if you suspect you're seeing only a fragment.
+- **Cross-file references**: If you see a method call like \`this.validator.validate(data)\`, use \`search_codebase\` to find the definition of that \`validator\` service.
+
+## Relevance scores
+
+Lower score = better match (cosine distance). Results above the configured threshold are filtered out automatically.
+
+## Dependency graph
+
+\`get_dependencies\` and \`get_dependents\` require \`file_path\` (as returned by \`search_codebase\`) and \`project\` (from \`list_projects\`). Pass \`transitive: true\` for the full dependency chain. depType values: \`import\` | \`import-default\` | \`import-namespace\` | \`reexport\` | \`reexport-namespace\`. \`fromSymbol\` — the top-level class or function in the importing file that uses this import (null if ambiguous or not tracked).
+`.trim();
+class McpServer {
+    searcher;
+    config;
+    logger;
+    constructor(searcher, config, logger = LoggerService_1.LoggerService.silent()) {
+        this.searcher = searcher;
+        this.config = config;
+        this.logger = logger;
+    }
+    async start() {
+        const server = new index_js_1.Server({ name: 'local-rag', version: PKG_VERSION }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
+        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.' },
+                        },
+                        required: ['query'],
+                    },
+                },
+                {
+                    name: 'list_projects',
+                    description: 'List all indexed projects with their chunk counts',
+                    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) 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', 'all'], description: 'Symbol kind filter. Default: all.' },
+                        },
+                        required: ['name'],
+                    },
+                },
+                {
+                    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 from the workspace by absolute path (as returned by search_codebase). 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 (as returned in filePath by search_codebase)' },
+                            max_lines: { type: 'number', description: 'Maximum lines to return (default 300, max 1000)' },
+                        },
+                        required: ['file_path'],
+                    },
+                },
+            ],
+        }));
+        server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+            try {
+                if (req.params.name === 'list_projects') {
+                    const rows = await this.searcher.listProjects();
+                    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 { query, translated } = await this.searcher.prepareQuery(raw);
+                    const results = await this.searcher.searchChunks(query, limit, project);
+                    if (results.length === 0) {
+                        return { content: [{ type: 'text', text: 'No relevant results found.' }] };
+                    }
+                    const header = translated ? `> Query translated: "${raw}" → "${query}"\n\n` : '';
+                    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}`);
+                            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}`)
+                        .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);
+                    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);
+                    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);
+                    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', 'all'];
+                    const kind = validKinds.includes(rawKind) ? rawKind : 'all';
+                    const { hits, truncated } = await this.searcher.findSymbol(name, project, kind);
+                    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);
+                    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);
+                    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 }] };
+                }
+                throw new Error(`Unknown tool: ${req.params.name}`);
+            }
+            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}` }] };
+            }
+        });
+        await server.connect(new stdio_js_1.StdioServerTransport());
+    }
+    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})*`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+exports.McpServer = McpServer;

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

@@ -0,0 +1,9 @@
+import type { Config } from '../config';
+import type { IEmbedder } from '../interfaces/IEmbedder';
+export declare class OllamaEmbedder implements IEmbedder {
+    private config;
+    private client;
+    constructor(config: Config);
+    embed(text: string): Promise<number[]>;
+    translate(text: string, model: string): Promise<string>;
+}

package/dist/src/services/OllamaEmbedder.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaEmbedder = void 0;
+const ollama_1 = require("ollama");
+class OllamaEmbedder {
+    config;
+    client;
+    constructor(config) {
+        this.config = config;
+        this.client = new ollama_1.Ollama({ host: config.ollama.host });
+    }
+    async embed(text) {
+        const { embedding } = await this.client.embeddings({
+            model: this.config.ollama.model,
+            prompt: text,
+        });
+        return embedding;
+    }
+    async translate(text, model) {
+        const response = await this.client.chat({
+            model,
+            messages: [{ role: 'user', content: `Translate the following text to English. Return only the translation, no explanations:\n${text}` }],
+        });
+        return response.message.content.trim();
+    }
+}
+exports.OllamaEmbedder = OllamaEmbedder;

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

@@ -0,0 +1,91 @@
+import type { Config } from '../config';
+import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { DatabaseService } from './DatabaseService';
+import { type ProjectMeta } from '../file-utils';
+import { LoggerService } from './LoggerService';
+export interface ChunkRow {
+    serviceName: string;
+    filePath: string;
+    startLine: number;
+    content: string;
+}
+export interface SearchResult extends ChunkRow {
+    score: number;
+}
+export interface NeighborResult {
+    result: SearchResult;
+    prevChunk: ChunkRow | null;
+    nextChunk: ChunkRow | null;
+}
+export type FileRangeResult = {
+    ok: true;
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    lines: string[];
+    hasMore: boolean;
+} | {
+    ok: false;
+    reason: 'not_indexed' | 'not_on_disk' | 'invalid_path';
+};
+export interface DependencyRow {
+    fromFile: string;
+    fromSymbol: string | null;
+    toFile: string;
+    toSymbol: string | null;
+    depType: string;
+    depth?: number;
+    via?: string;
+}
+export interface ProjectRow extends ProjectMeta {
+    serviceName: string;
+    chunks: number;
+}
+export interface GrepMatch {
+    filePath: string;
+    line: number;
+}
+export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'all';
+export interface SymbolHit {
+    filePath: string;
+    line: number;
+    column: number;
+    kind: Exclude<SymbolKind, 'all'>;
+    signature: string;
+}
+export declare class SearcherService {
+    private db;
+    private embedder;
+    private config;
+    private logger;
+    constructor(db: DatabaseService, embedder: IEmbedder, config: Config, logger?: LoggerService);
+    prepareQuery(raw: string): Promise<{
+        query: string;
+        translated: boolean;
+    }>;
+    listProjects(): Promise<ProjectRow[]>;
+    searchChunks(query: string, limit: number, project: string | null): Promise<SearchResult[]>;
+    fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
+    getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    grepSymbol(symbol: string, project: string, excludeFile: string): {
+        matches: GrepMatch[];
+        truncated: boolean;
+    };
+    findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
+        hits: SymbolHit[];
+        truncated: boolean;
+    }>;
+    private findSymbolFromIndex;
+    private grepFindSymbol;
+    listFiles(relativePath: string, project: string, depth: number, pattern: string | null): {
+        tree: string;
+        error?: string;
+    };
+    readFileAbsolute(absPath: string, maxLines: number): Promise<FileRangeResult>;
+    readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
+    private isNonEnglish;
+    private walkDir;
+    private buildFindSymbolPattern;
+    private inferKind;
+}