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

package/dist/src/help.js

@@ -5,28 +5,22 @@ function printHelp(command) {
     switch (command) {
         case 'rag-index':
         case 'index':
-            console.log('Usage: rag-index [path] [options]');
-            console.log('       rag-index backfill');
+            console.log('Usage: rag-index [options]');
             console.log('');
             console.log('Index a workspace of JS/TS projects into the vector database.');
-            console.log('');
-            console.log('Arguments:');
-            console.log('  path              Path to workspace (defaults to WORKSPACE_ROOT env var)');
+            console.log('Workspace is read from workspaceRoot (set via rag-setup or rag-config).');
             console.log('');
             console.log('Options:');
             console.log('  --reindex         Force re-index all files (ignores cached mtimes)');
             console.log('  --select          Interactively select which projects to index');
             console.log('  -h, --help        Show this help message');
-            console.log('');
-            console.log('Subcommands:');
-            console.log('  backfill          Populate symbol index (code_symbol) for already-indexed files');
             break;
         case 'rag-mcp':
         case 'mcp':
             console.log('Usage: rag-mcp');
             console.log('');
             console.log('Start the MCP server for semantic code search.');
-            console.log('Requires WORKSPACE_ROOT to be set (run rag-setup first).');
+            console.log('Requires workspaceRoot to be set (run rag-setup first).');
             console.log('');
             console.log('Options:');
             console.log('  -h, --help        Show this help message');
@@ -35,17 +29,39 @@ function printHelp(command) {
         case 'setup':
             console.log('Usage: rag-setup');
             console.log('');
-            console.log('Interactive setup: configure DB, Ollama, and WORKSPACE_ROOT.');
+            console.log('Interactive setup: configure DB, Ollama, and workspaceRoot.');
             console.log('Run once before using rag-index or rag-mcp.');
             console.log('');
             console.log('Options:');
             console.log('  -h, --help        Show this help message');
             break;
+        case 'rag-config':
+        case 'config':
+            console.log('Usage: rag-config <subcommand>');
+            console.log('');
+            console.log('Manage settings stored in ~/.config/codesearch-mcp/config.json');
+            console.log('');
+            console.log('Subcommands:');
+            console.log('  show                    Print current config (password redacted)');
+            console.log('  get <key>               Print a single value');
+            console.log('  set <key> <value>       Set a value');
+            console.log('  reset <key>             Remove key (falls back to built-in default)');
+            console.log('');
+            console.log('Keys:');
+            console.log('  db.host, db.port, db.user, db.password, db.name');
+            console.log('  ollama.host, ollama.model');
+            console.log('  indexing.chunkSize, indexing.chunkOverlap, indexing.embedBatchSize');
+            console.log('  search.similarityThreshold, search.defaultLimit, search.maxLimit');
+            console.log('  search.autoTranslate, search.translateModel');
+            console.log('  reranker.enabled, reranker.model, reranker.url, reranker.overfetch');
+            console.log('  logging.level, logging.dir');
+            console.log('  workspaceRoot');
+            break;
         default:
-            console.log('Usage: rag-index [path] [--reindex] [--select]');
-            console.log('       rag-index backfill');
+            console.log('Usage: rag-index [--reindex] [--select]');
             console.log('       rag-mcp');
             console.log('       rag-setup');
+            console.log('       rag-config <show|get|set|reset>');
             console.log('');
             console.log('Run any command with -h or --help for details.');
     }

package/dist/src/interfaces/IAstParser.d.ts

@@ -16,15 +16,28 @@ export interface SymbolEntry {
     endLine: number | null;
     col: number | null;
 }
+export interface CallEdge {
+    project: string;
+    fromFile: string;
+    fromSymbol: string | null;
+    calleeName: string;
+    calleeFile: string;
+    calleeSymbol: string | null;
+    line: number | null;
+    col: number | null;
+}
 export interface FileAnalysis {
     edges: DepEdge[];
     symbols: SymbolEntry[];
+    calls: CallEdge[];
 }
 export interface IAstParser {
     /**
      * @deprecated Use analyzeProject instead for project-wide context.
      */
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
-    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string): Promise<Map<string, FileAnalysis>>;
+    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: {
+        skipDependencyResolution?: boolean;
+    }): Promise<Map<string, FileAnalysis>>;
     clearCache(projectRoot?: string): void;
 }

package/dist/src/interfaces/IEmbedder.d.ts

@@ -1,4 +1,5 @@
 export interface IEmbedder {
     embed(text: string): Promise<number[]>;
     translate?(text: string, model: string): Promise<string>;
+    rerank?(query: string, documents: string[], topN: number): Promise<number[]>;
 }

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

@@ -1,7 +1,16 @@
-export declare function selectProjects(allProjects: {
+export interface Project {
     name: string;
     path: string;
-}[], workspaceDir: string, forceSelect: boolean): Promise<{
-    name: string;
-    path: string;
-}[]>;
+}
+export declare class ProjectSelector {
+    private readonly workspaceDir;
+    private included;
+    private skipped;
+    constructor(workspaceDir: string);
+    select(allProjects: Project[], forceSelect: boolean): Promise<Project[]>;
+    private printAlreadySelected;
+    private promptForSelection;
+    private promptForSkip;
+    private load;
+    private save;
+}

package/dist/src/project-selector.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectProjects = selectProjects;
+exports.ProjectSelector = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const prompts_1 = require("@inquirer/prompts");
@@ -65,76 +65,90 @@ async function saveLines(filePath, names) {
         }
     }
 }
-async function loadConfig(workspaceDir) {
-    const [included, skipped] = await Promise.all([
-        loadLines(path.join(workspaceDir, '.ragprojects')),
-        loadLines(path.join(workspaceDir, '.ragskip')),
-    ]);
-    return { included, skipped };
-}
-async function saveConfig(workspaceDir, config) {
-    await Promise.all([
-        saveLines(path.join(workspaceDir, '.ragprojects'), config.included),
-        saveLines(path.join(workspaceDir, '.ragskip'), config.skipped),
-    ]);
-}
-async function selectProjects(allProjects, workspaceDir, forceSelect) {
-    const config = await 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.');
+class ProjectSelector {
+    workspaceDir;
+    included = new Set();
+    skipped = new Set();
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async select(allProjects, forceSelect) {
+        await this.load();
+        const newProjects = allProjects.filter(p => !this.included.has(p.name) && !this.skipped.has(p.name));
+        const previouslySelected = allProjects.filter(p => this.included.has(p.name));
+        // Nothing new and something already selected — return silently
+        if (newProjects.length === 0 && !forceSelect && previouslySelected.length > 0) {
+            return previouslySelected;
         }
+        // No previous selection — treat as implicit --select so the user picks projects now
+        const autoSelect = !forceSelect && previouslySelected.length === 0;
+        // In --select / auto-select mode show all non-skipped projects; otherwise only new ones
+        const toShow = (forceSelect || autoSelect)
+            ? allProjects.filter(p => !this.skipped.has(p.name))
+            : newProjects;
+        if (toShow.length === 0) {
+            console.log('All discovered projects are marked as skipped. Run with --select to reconfigure.');
+            return [];
+        }
+        if (!forceSelect && !autoSelect)
+            this.printAlreadySelected(allProjects);
+        await this.promptForSelection(toShow, forceSelect || autoSelect, newProjects.length);
+        await this.promptForSkip(toShow);
+        await this.save();
+        const selected = allProjects.filter(p => this.included.has(p.name));
+        console.log(`\nSelected: ${selected.map(p => p.name).join(', ') || '(none)'}`);
         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 alreadyIncluded = allProjects.filter(p => config.included.has(p.name));
-    if (!forceSelect && alreadyIncluded.length > 0) {
-        console.log(`Already selected (will be re-indexed): ${alreadyIncluded.map(p => p.name).join(', ')}`);
-        console.log('Run with --select to change the full selection.\n');
-    }
-    const message = forceSelect
-        ? 'Select projects to index'
-        : `Found ${newProjects.length} new project(s) — select which to add`;
-    // 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);
+    printAlreadySelected(allProjects) {
+        const alreadyIncluded = allProjects.filter(p => this.included.has(p.name));
+        if (alreadyIncluded.length > 0) {
+            console.log(`Already selected (will be re-indexed): ${alreadyIncluded.map(p => p.name).join(', ')}`);
+            console.log('Run with --select to change the full selection.\n');
         }
-        else {
-            config.included.delete(p.name);
+    }
+    async promptForSelection(toShow, showAll, newCount) {
+        const message = showAll
+            ? 'Select projects to index'
+            : `Found ${newCount} new project(s) — select which to add`;
+        const chosen = await (0, prompts_1.checkbox)({
+            message,
+            choices: toShow.map(p => ({ name: p.name, value: p.name, checked: this.included.has(p.name) })),
+            pageSize: 15,
+        });
+        const chosenSet = new Set(chosen);
+        for (const p of toShow) {
+            if (chosenSet.has(p.name)) {
+                this.included.add(p.name);
+                this.skipped.delete(p.name);
+            }
+            else {
+                this.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) {
+    async promptForSkip(toShow) {
+        const unchecked = toShow.filter(p => !this.included.has(p.name) && !this.skipped.has(p.name));
+        if (unchecked.length === 0)
+            return;
         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);
+            this.skipped.add(name);
+    }
+    async load() {
+        [this.included, this.skipped] = await Promise.all([
+            loadLines(path.join(this.workspaceDir, '.ragprojects')),
+            loadLines(path.join(this.workspaceDir, '.ragskip')),
+        ]);
+    }
+    async save() {
+        await Promise.all([
+            saveLines(path.join(this.workspaceDir, '.ragprojects'), this.included),
+            saveLines(path.join(this.workspaceDir, '.ragskip'), this.skipped),
+        ]);
     }
-    await 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;
 }
+exports.ProjectSelector = ProjectSelector;

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

@@ -4,7 +4,9 @@ export declare class AstParserService implements IAstParser {
     private logger;
     private morphProjects;
     constructor(logger?: LoggerService);
-    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string): Promise<Map<string, FileAnalysis>>;
+    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: {
+        skipDependencyResolution?: boolean;
+    }): Promise<Map<string, FileAnalysis>>;
     clearCache(projectRoot?: string): void;
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
     extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<DepEdge[]>;
@@ -14,4 +16,6 @@ export declare class AstParserService implements IAstParser {
     private resolveFromSymbol;
     private buildUsageMap;
     private extractSymbols;
+    private extractCalls;
+    private getContainerName;
 }

package/dist/src/services/AstParserService.js

@@ -51,13 +51,15 @@ class AstParserService {
         this.logger = logger;
     }
     // ── public interface ────────────────────────────────────────────────────────
-    async analyzeProject(filePaths, serviceName, projectRoot = process.cwd()) {
+    async analyzeProject(filePaths, serviceName, projectRoot = process.cwd(), opts = {}) {
         const t0 = Date.now();
+        const skipDependencyResolution = opts.skipDependencyResolution ?? false;
+        this.logger.debug('AstParser: analyzeProject start', { serviceName, projectRoot, files: filePaths.length, skipDependencyResolution });
         const analysisMap = new Map();
-        const morphProject = this.createMorphProject(projectRoot);
+        const morphProject = this.createMorphProject(projectRoot, skipDependencyResolution);
         for (const filePath of filePaths) {
             if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
-                analysisMap.set(filePath, { edges: [], symbols: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
                 continue;
             }
             try {
@@ -65,7 +67,7 @@ class AstParserService {
             }
             catch (err) {
                 this.logger.warn('AstParser: failed to add source file', { filePath, reason: err.message });
-                analysisMap.set(filePath, { edges: [], symbols: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
             }
         }
         for (const sourceFile of morphProject.getSourceFiles()) {
@@ -73,11 +75,12 @@ class AstParserService {
             try {
                 const edges = this.extractEdges(sourceFile, filePath, serviceName);
                 const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
-                analysisMap.set(filePath, { edges, symbols });
+                const calls = this.extractCalls(sourceFile, filePath, serviceName);
+                analysisMap.set(filePath, { edges, symbols, calls });
             }
             catch (err) {
                 this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
-                analysisMap.set(filePath, { edges: [], symbols: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
             }
         }
         // Release source file memory before returning
@@ -85,7 +88,7 @@ class AstParserService {
             morphProject.removeSourceFile(sourceFile);
         }
         this.logger.debug('AstParser: analyzeProject done', {
-            projectRoot, total: filePaths.length, parsed: analysisMap.size, ms: Date.now() - t0,
+            serviceName, projectRoot, total: filePaths.length, parsed: analysisMap.size, skipDependencyResolution, ms: Date.now() - t0,
         });
         return analysisMap;
     }
@@ -101,8 +104,11 @@ class AstParserService {
         }
     }
     async analyzeFile(filePath, serviceName, projectRoot = path.dirname(filePath)) {
+        const t0 = Date.now();
+        this.logger.debug('AstParser: analyzeFile start', { filePath, serviceName, projectRoot });
         if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
-            return { edges: [], symbols: [] };
+            this.logger.debug('AstParser: analyzeFile skip (non-TS)', { filePath, ms: Date.now() - t0 });
+            return { edges: [], symbols: [], calls: [] };
         }
         const morphProject = this.getMorphProject(projectRoot);
         const existing = morphProject.getSourceFile(filePath);
@@ -112,13 +118,16 @@ class AstParserService {
         try {
             sourceFile = morphProject.addSourceFileAtPath(filePath);
         }
-        catch {
-            return { edges: [], symbols: [] };
+        catch (err) {
+            this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, reason: err.message, ms: Date.now() - t0 });
+            return { edges: [], symbols: [], calls: [] };
         }
         const edges = this.extractEdges(sourceFile, filePath, serviceName);
         const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
+        const calls = this.extractCalls(sourceFile, filePath, serviceName);
         morphProject.removeSourceFile(sourceFile);
-        return { edges, symbols };
+        this.logger.debug('AstParser: analyzeFile done', { filePath, edges: edges.length, symbols: symbols.length, calls: calls.length, ms: Date.now() - t0 });
+        return { edges, symbols, calls };
     }
     // Kept for test compatibility (extract-import-edges.test.ts).
     async extractImportEdges(filePath, serviceName, projectRoot) {
@@ -126,30 +135,35 @@ class AstParserService {
         return edges;
     }
     // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
-    createMorphProject(projectRoot) {
+    createMorphProject(projectRoot, skipFileDependencyResolution = false) {
+        const t0 = Date.now();
         const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
         const hasTsconfig = fs.existsSync(tsconfigPath);
-        this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig });
+        this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig, skipFileDependencyResolution });
         let project;
         try {
             const opts = hasTsconfig
-                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
-                : FALLBACK_OPTS;
+                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution }
+                : { ...FALLBACK_OPTS, skipFileDependencyResolution };
             project = new ts_morph_1.Project(opts);
             if (hasTsconfig) {
                 const co = project.getCompilerOptions();
                 const pathsMap = co.paths ?? {};
                 const pathCount = Object.keys(pathsMap).length;
-                this.logger.debug('AstParser: tsconfig loaded', { pathCount });
+                this.logger.debug('AstParser: tsconfig loaded', { pathCount, ms: Date.now() - t0 });
                 if (pathCount > 0) {
                     this.logger.debug('AstParser: path aliases', { aliases: Object.keys(pathsMap) });
                 }
             }
+            else {
+                this.logger.debug('AstParser: MorphProject created (fallback opts)', { ms: Date.now() - t0 });
+            }
         }
         catch (err) {
             this.logger.warn('AstParser: tsconfig load failed, using fallback', {
                 tsconfigPath,
                 reason: err.message,
+                ms: Date.now() - t0,
             });
             project = new ts_morph_1.Project(FALLBACK_OPTS);
         }
@@ -161,6 +175,7 @@ class AstParserService {
             const cached = this.morphProjects.get(projectRoot);
             this.morphProjects.delete(projectRoot);
             this.morphProjects.set(projectRoot, cached);
+            this.logger.debug('AstParser: getMorphProject cache hit', { projectRoot, cacheSize: this.morphProjects.size });
             return cached;
         }
         if (this.morphProjects.size >= MORPH_CACHE_MAX) {
@@ -169,6 +184,7 @@ class AstParserService {
             this.morphProjects.delete(lruKey);
             this.logger.debug('AstParser: evicted LRU project', { lruKey });
         }
+        this.logger.debug('AstParser: getMorphProject cache miss', { projectRoot, cacheSize: this.morphProjects.size });
         const project = this.createMorphProject(projectRoot);
         this.morphProjects.set(projectRoot, project);
         return project;
@@ -337,5 +353,80 @@ class AstParserService {
         }
         return symbols;
     }
+    // ── private: call graph extraction ────────────────────────────────────────
+    extractCalls(sourceFile, filePath, serviceName) {
+        const calls = [];
+        for (const callExpr of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
+            const expr = callExpr.getExpression();
+            let calleeName = null;
+            let calleeFile = null;
+            let calleeSymbol = null;
+            try {
+                if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+                    calleeName = expr.getName();
+                    const sym = expr.getNameNode().getSymbol();
+                    const decl = sym?.getDeclarations()?.[0];
+                    const declPath = decl?.getSourceFile().getFilePath();
+                    if (declPath && !declPath.includes('/node_modules/') && declPath !== filePath) {
+                        calleeFile = declPath;
+                        calleeSymbol = calleeName;
+                    }
+                }
+                else if (ts_morph_1.Node.isIdentifier(expr)) {
+                    calleeName = expr.getText();
+                    const sym = expr.getSymbol();
+                    if (sym) {
+                        // Imported identifiers resolve to ImportSpecifier (same file); follow the alias.
+                        const firstDecl = sym.getDeclarations()?.[0];
+                        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl)
+                            ? (sym.getAliasedSymbol() ?? sym)
+                            : sym;
+                        const decl = resolved.getDeclarations()?.[0];
+                        const declPath = decl?.getSourceFile().getFilePath();
+                        if (declPath && !declPath.includes('/node_modules/') && declPath !== filePath) {
+                            calleeFile = declPath;
+                            calleeSymbol = calleeName;
+                        }
+                    }
+                }
+            }
+            catch {
+                // type resolution failures are normal — skip this call
+            }
+            if (!calleeName || !calleeFile)
+                continue;
+            const fromSymbol = this.getContainerName(callExpr);
+            const pos = sourceFile.compilerNode
+                .getLineAndCharacterOfPosition(callExpr.getStart());
+            calls.push({
+                project: serviceName,
+                fromFile: filePath,
+                fromSymbol,
+                calleeName,
+                calleeFile,
+                calleeSymbol,
+                line: pos.line + 1,
+                col: pos.character + 1,
+            });
+        }
+        return calls;
+    }
+    getContainerName(node) {
+        let current = node.getParent();
+        while (current) {
+            if (ts_morph_1.Node.isMethodDeclaration(current) || ts_morph_1.Node.isFunctionDeclaration(current)) {
+                return current.getName() ?? null;
+            }
+            if (ts_morph_1.Node.isArrowFunction(current) || ts_morph_1.Node.isFunctionExpression(current)) {
+                const parent = current.getParent();
+                if (ts_morph_1.Node.isVariableDeclaration(parent))
+                    return parent.getName();
+                if (ts_morph_1.Node.isPropertyDeclaration(parent))
+                    return parent.getName();
+            }
+            current = current.getParent();
+        }
+        return null;
+    }
 }
 exports.AstParserService = AstParserService;

package/dist/src/services/DatabaseService.js

@@ -61,6 +61,7 @@ class DatabaseService {
         const { host, port, username, password, database } = this.config.db;
         this.pool = new pg_1.Pool({ host, port, user: username, password, database });
         this._db = (0, node_postgres_1.drizzle)(this.pool, { schema });
+        await this.pool.query('SELECT 1');
     }
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
@@ -141,6 +142,23 @@ class DatabaseService {
         await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name   ON code_symbol (name, project)`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file   ON code_symbol (project, "filePath")`);
         await this.query(`CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique ON code_symbol (project, "filePath", name, kind)`);
+        // code_call table
+        await this.query(`
+      CREATE TABLE IF NOT EXISTS code_call (
+        id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        project        TEXT NOT NULL,
+        "fromFile"     TEXT NOT NULL,
+        "fromSymbol"   TEXT,
+        "calleeName"   TEXT NOT NULL,
+        "calleeFile"   TEXT NOT NULL,
+        "calleeSymbol" TEXT,
+        line           INT,
+        col            INT
+      )
+    `);
+        await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee      ON code_call (project, "calleeName")`);
+        await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee_file ON code_call (project, "calleeFile")`);
+        await this.query(`CREATE INDEX IF NOT EXISTS idx_call_from        ON code_call (project, "fromFile")`);
     }
     async ensureDatabaseExists() {
         const { host, port, username, password, database } = this.config.db;

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

@@ -27,6 +27,12 @@ export declare class IndexerService {
         skipped: number;
         failed: number;
     }>;
+    backfillCalls(signal?: AbortSignal): Promise<{
+        total: number;
+        processed: number;
+        skipped: number;
+        failed: number;
+    }>;
     discoverProjects(rootDir: string): {
         name: string;
         path: string;
@@ -34,6 +40,7 @@ export declare class IndexerService {
     private writeDepEdges;
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;
     private getSplitter;
+    private static inferRole;
     private getEnrichedPrompt;
     private embedText;
     private static hashContent;