codesearch-mcp 0.0.1-alpha

package/dist/src/mcp.d.ts

@@ -0,0 +1 @@
+export declare function startMCP(): Promise<void>;

package/dist/src/mcp.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMCP = startMCP;
+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 config_1 = require("./config");
+const searcher_1 = require("./searcher");
+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.
+
+## 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 lines around \`startLine\` to get the full picture.
+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.
+
+## 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 tools
+
+- **get_dependencies** — show what files a given file imports (direct or transitive). Use when you need 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 and avoid breaking changes.
+
+Both tools require \`file_path\` (as returned by \`search_codebase\`) and \`project\` (from \`list_projects\`). Pass \`transitive: true\` for the full dependency chain.
+`.trim();
+function 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');
+}
+function 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');
+}
+function formatChunk(r, label) {
+    return `${label ? `*(${label})*\n` : ''}**File:** ${r.filePath}\n**Project:** ${r.serviceName}\n**Line:** ${r.startLine}\n\`\`\`\n${r.content}\n\`\`\``;
+}
+async function startMCP() {
+    const server = new index_js_1.Server({ name: 'local-rag', version: '1.0.0' }, { 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 ${config_1.config.search.defaultLimit}, max ${config_1.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, inclusive). 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.',
+                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.',
+                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 exported symbol name (optional)' },
+                        transitive: { type: 'boolean', description: 'Include transitive (indirect) dependents. Default: false.' },
+                    },
+                    required: ['file_path', 'project'],
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+        try {
+            if (req.params.name === 'list_projects') {
+                const rows = await (0, searcher_1.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) || config_1.config.search.defaultLimit), config_1.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 (0, searcher_1.prepareQuery)(raw);
+                const results = await (0, searcher_1.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 (0, searcher_1.fetchNeighbors)(results);
+                    const blocks = withNeighbors.map(({ result, prevChunk, nextChunk }) => {
+                        const parts = [];
+                        if (prevChunk)
+                            parts.push(formatChunk(prevChunk, 'prev chunk'));
+                        parts.push(`${formatChunk(result)}\n**Relevance:** ${result.score}`);
+                        if (nextChunk)
+                            parts.push(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 => `${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 (0, searcher_1.readFileRange)(filePath, startLine, endLine);
+                if (!range.ok) {
+                    const message = 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');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `**File:** ${range.filePath}\n**Lines:** ${range.startLine}–${range.endLine}\n\`\`\`\n${numbered}\n\`\`\``,
+                        }],
+                };
+            }
+            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 (0, searcher_1.getDependencies)(filePath, project, symbol, transitive);
+                if (rows.length === 0) {
+                    return { content: [{ type: 'text', text: `No dependencies found for: ${filePath}` }] };
+                }
+                return { content: [{ type: 'text', text: 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 (0, searcher_1.getDependents)(filePath, project, symbol, transitive);
+                if (rows.length === 0) {
+                    return { content: [{ type: 'text', text: `No dependents found for: ${filePath}` }] };
+                }
+                return { content: [{ type: 'text', text: formatDependents(filePath, rows, transitive) }] };
+            }
+            throw new Error(`Unknown tool: ${req.params.name}`);
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Tool error: ${err.message}` }] };
+        }
+    });
+    await server.connect(new stdio_js_1.StdioServerTransport());
+}

package/dist/src/project-selector.d.ts

@@ -0,0 +1,7 @@
+export declare function selectProjects(allProjects: {
+    name: string;
+    path: string;
+}[], workspaceDir: string, forceSelect: boolean): Promise<{
+    name: string;
+    path: string;
+}[]>;

package/dist/src/project-selector.js

@@ -0,0 +1,116 @@
+"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.selectProjects = selectProjects;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const prompts_1 = require("@inquirer/prompts");
+function loadLines(filePath) {
+    if (!fs.existsSync(filePath))
+        return new Set();
+    return new Set(fs.readFileSync(filePath, 'utf-8')
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l && !l.startsWith('#')));
+}
+function saveLines(filePath, names) {
+    fs.writeFileSync(filePath, [...names].sort().join('\n') + '\n');
+}
+function loadConfig(workspaceDir) {
+    return {
+        included: loadLines(path.join(workspaceDir, '.ragprojects')),
+        skipped: loadLines(path.join(workspaceDir, '.ragskip')),
+    };
+}
+function saveConfig(workspaceDir, config) {
+    saveLines(path.join(workspaceDir, '.ragprojects'), config.included);
+    if (config.skipped.size > 0)
+        saveLines(path.join(workspaceDir, '.ragskip'), config.skipped);
+}
+async function selectProjects(allProjects, workspaceDir, forceSelect) {
+    const config = loadConfig(workspaceDir);
+    const newProjects = allProjects.filter(p => !config.included.has(p.name) && !config.skipped.has(p.name));
+    // Nothing to ask — return previously saved selection silently
+    if (newProjects.length === 0 && !forceSelect) {
+        const selected = allProjects.filter(p => config.included.has(p.name));
+        if (selected.length === 0) {
+            console.log('No projects selected. Run with --select to choose projects.');
+        }
+        return selected;
+    }
+    // In --select mode show all non-skipped projects; otherwise only new ones
+    const toShow = forceSelect
+        ? allProjects.filter(p => !config.skipped.has(p.name))
+        : newProjects;
+    const message = forceSelect
+        ? 'Select projects to index'
+        : `Found ${newProjects.length} new project(s) — select which to index`;
+    // Checkbox: pre-check previously included projects
+    const chosen = await (0, prompts_1.checkbox)({
+        message,
+        choices: toShow.map(p => ({
+            name: p.name,
+            value: p.name,
+            checked: config.included.has(p.name),
+        })),
+        pageSize: 15,
+    });
+    const chosenSet = new Set(chosen);
+    // Update included
+    for (const p of toShow) {
+        if (chosenSet.has(p.name)) {
+            config.included.add(p.name);
+            config.skipped.delete(p.name);
+        }
+        else {
+            config.included.delete(p.name);
+        }
+    }
+    // Ask which unchecked projects to always skip
+    const unchecked = toShow.filter(p => !chosenSet.has(p.name) && !config.skipped.has(p.name));
+    if (unchecked.length > 0) {
+        const toSkip = await (0, prompts_1.checkbox)({
+            message: 'Always skip (never ask again)?',
+            choices: unchecked.map(p => ({ name: p.name, value: p.name, checked: false })),
+            pageSize: 15,
+        });
+        for (const name of toSkip)
+            config.skipped.add(name);
+    }
+    saveConfig(workspaceDir, config);
+    const selected = allProjects.filter(p => config.included.has(p.name));
+    console.log(`\nSelected: ${selected.map(p => p.name).join(', ') || '(none)'}`);
+    return selected;
+}

package/dist/src/searcher.d.ts

@@ -0,0 +1,50 @@
+export type { Relations } from './file-utils';
+export type { ProjectMeta } from './file-utils';
+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[];
+} | {
+    ok: false;
+    reason: 'not_indexed' | 'not_on_disk';
+};
+export interface DependencyRow {
+    fromFile: string;
+    fromSymbol: string | null;
+    toFile: string;
+    toSymbol: string | null;
+    depType: string;
+    depth?: number;
+    via?: string;
+}
+export declare function prepareQuery(raw: string): Promise<{
+    query: string;
+    translated: boolean;
+}>;
+import type { ProjectMeta } from './file-utils';
+export interface ProjectRow extends ProjectMeta {
+    serviceName: string;
+    chunks: number;
+}
+export declare function listProjects(): Promise<ProjectRow[]>;
+export declare function searchChunks(query: string, limit: number, project: string | null): Promise<SearchResult[]>;
+export declare function fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
+export declare function getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+export declare function getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+export declare function readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;

package/dist/src/searcher.js

@@ -0,0 +1,205 @@
+"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.prepareQuery = prepareQuery;
+exports.listProjects = listProjects;
+exports.searchChunks = searchChunks;
+exports.fetchNeighbors = fetchNeighbors;
+exports.getDependencies = getDependencies;
+exports.getDependents = getDependents;
+exports.readFileRange = readFileRange;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ollama_1 = require("ollama");
+const db_1 = require("./db");
+const config_1 = require("./config");
+const file_utils_1 = require("./file-utils");
+const ollama = new ollama_1.Ollama({ host: config_1.config.ollama.host });
+// Detect non-English input by presence of non-ASCII characters (Cyrillic, etc.)
+function isNonEnglish(text) {
+    return /[^\x00-\x7F]/.test(text);
+}
+// Translate query to English using a local Ollama model
+async function translateToEnglish(text) {
+    const response = await ollama.chat({
+        model: config_1.config.search.translateModel,
+        messages: [{ role: 'user', content: `Translate the following text to English. Return only the translation, no explanations:\n${text}` }],
+    });
+    return response.message.content.trim();
+}
+// Translate if AUTO_TRANSLATE is enabled and input is non-English
+async function prepareQuery(raw) {
+    if (config_1.config.search.autoTranslate && isNonEnglish(raw)) {
+        return { query: await translateToEnglish(raw), translated: true };
+    }
+    return { query: raw, translated: false };
+}
+const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
+async function listProjects() {
+    const rows = await db_1.db.query(`SELECT "serviceName", COUNT(*)::int AS chunks
+     FROM code_chunk
+     GROUP BY "serviceName"
+     ORDER BY "serviceName"`);
+    return rows.map(r => ({
+        ...r,
+        ...((0, file_utils_1.readRagMeta)(path.join(config_1.config.workspaceRoot, r.serviceName)) ?? EMPTY_META),
+    }));
+}
+// Embed query and run vector similarity search
+async function searchChunks(query, limit, project) {
+    const { embedding } = await ollama.embeddings({ model: config_1.config.ollama.model, prompt: query });
+    const params = [`[${embedding}]`, config_1.config.search.similarityThreshold, limit];
+    let projectFilter = '';
+    if (project) {
+        params.push(project);
+        projectFilter = `AND "serviceName" = $${params.length}`;
+    }
+    // Cast score to float8 so TypeORM returns a number, not a string
+    return db_1.db.query(`SELECT "serviceName", "filePath", "startLine", content,
+            ROUND((embedding <=> $1)::numeric, 4)::float8 AS score
+     FROM code_chunk
+     WHERE embedding <=> $1 < $2
+     ${projectFilter}
+     ORDER BY embedding <=> $1
+     LIMIT $3`, params);
+}
+// Fetch the chunk immediately before and after each result in the same file (Small-to-Big)
+async function fetchNeighbors(results) {
+    return Promise.all(results.map(async (result) => {
+        const [prevRows, nextRows] = await Promise.all([
+            db_1.db.query(`SELECT "serviceName", "filePath", "startLine", content
+         FROM code_chunk
+         WHERE "filePath" = $1 AND "startLine" < $2
+         ORDER BY "startLine" DESC LIMIT 1`, [result.filePath, result.startLine]),
+            db_1.db.query(`SELECT "serviceName", "filePath", "startLine", content
+         FROM code_chunk
+         WHERE "filePath" = $1 AND "startLine" > $2
+         ORDER BY "startLine" ASC LIMIT 1`, [result.filePath, result.startLine]),
+        ]);
+        return { result, prevChunk: prevRows[0] ?? null, nextChunk: nextRows[0] ?? null };
+    }));
+}
+// Return all files imported by filePath (direct or transitive)
+async function getDependencies(filePath, project, symbol = null, transitive = false) {
+    const params = [filePath, project];
+    let symbolFilter = '';
+    if (symbol) {
+        params.push(symbol);
+        symbolFilter = `AND "toSymbol" = $${params.length}`;
+    }
+    const direct = await db_1.db.query(`SELECT "fromFile", "fromSymbol", "toFile", "toSymbol", "depType"
+     FROM code_dependency
+     WHERE "fromFile" = $1 AND project = $2
+     ${symbolFilter}
+     ORDER BY "toFile"`, params);
+    if (!transitive)
+        return direct;
+    // Indirect: depth>1 only, deduplicated by toFile (symbols dropped for clarity)
+    const indirect = await db_1.db.query(`WITH RECURSIVE deps AS (
+       SELECT "toFile", 1 AS depth, "toFile" AS via
+       FROM code_dependency
+       WHERE "fromFile" = $1 AND project = $2
+
+       UNION
+
+       SELECT d."toFile", deps.depth + 1, deps."toFile" AS via
+       FROM code_dependency d
+       JOIN deps ON deps."toFile" = d."fromFile"
+       WHERE d.project = $2
+         AND d."toFile" <> $1
+         AND deps.depth < 20
+     )
+     SELECT "toFile", MIN(depth) AS depth,
+            (array_agg(via ORDER BY depth))[1] AS via,
+            NULL::text AS "fromFile", NULL::text AS "fromSymbol",
+            NULL::text AS "toSymbol", NULL::text AS "depType"
+     FROM deps
+     WHERE depth > 1
+     GROUP BY "toFile"
+     ORDER BY MIN(depth), "toFile"`, [filePath, project]);
+    return [...direct, ...indirect];
+}
+// Return all files that import filePath (direct or transitive)
+async function getDependents(filePath, project, symbol = null, transitive = false) {
+    const params = [filePath, project];
+    let symbolFilter = '';
+    if (symbol) {
+        params.push(symbol);
+        symbolFilter = `AND "toSymbol" = $${params.length}`;
+    }
+    const direct = await db_1.db.query(`SELECT "fromFile", "fromSymbol", "toFile", "toSymbol", "depType"
+     FROM code_dependency
+     WHERE "toFile" = $1 AND project = $2
+     ${symbolFilter}
+     ORDER BY "fromFile"`, params);
+    if (!transitive)
+        return direct;
+    // Indirect: depth>1 only, deduplicated by fromFile
+    const indirect = await db_1.db.query(`WITH RECURSIVE rdeps AS (
+       SELECT "fromFile", 1 AS depth, "fromFile" AS via
+       FROM code_dependency
+       WHERE "toFile" = $1 AND project = $2
+
+       UNION
+
+       SELECT d."fromFile", rdeps.depth + 1, rdeps."fromFile" AS via
+       FROM code_dependency d
+       JOIN rdeps ON rdeps."fromFile" = d."toFile"
+       WHERE d.project = $2
+         AND d."fromFile" <> $1
+         AND rdeps.depth < 20
+     )
+     SELECT "fromFile", MIN(depth) AS depth,
+            (array_agg(via ORDER BY depth))[1] AS via,
+            NULL::text AS "toFile", NULL::text AS "fromSymbol",
+            NULL::text AS "toSymbol", NULL::text AS "depType"
+     FROM rdeps
+     WHERE depth > 1
+     GROUP BY "fromFile"
+     ORDER BY MIN(depth), "fromFile"`, [filePath, project]);
+    return [...direct, ...indirect];
+}
+// Read a line range from a file that is present in the index
+async function readFileRange(filePath, startLine, endLine) {
+    const [{ exists }] = await db_1.db.query(`SELECT EXISTS (SELECT 1 FROM code_chunk WHERE "filePath" = $1) AS exists`, [filePath]);
+    if (!exists)
+        return { ok: false, reason: 'not_indexed' };
+    const absPath = path.join(config_1.config.workspaceRoot, filePath);
+    if (!fs.existsSync(absPath))
+        return { ok: false, reason: 'not_on_disk' };
+    const all = fs.readFileSync(absPath, 'utf-8').split('\n');
+    const lines = all.slice(startLine - 1, endLine);
+    return { ok: true, filePath, startLine, endLine: Math.min(endLine, all.length), lines };
+}

package/dist/src/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetup(): Promise<void>;