codesearch-mcp 0.0.6-alpha → 0.0.7-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aleks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/app.js

@@ -60,7 +60,8 @@ async function main() {
     const isIndex = argv1 === 'rag-index' || process.argv[2] === 'index';
     const isMcp = argv1 === 'rag-mcp' || process.argv[2] === 'mcp';
     const isSetup = argv1 === 'rag-setup' || process.argv[2] === 'setup';
-    const mode = isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : (process.argv[2] ?? '');
+    const isBackfill = argv1 === 'rag-index' && process.argv[2] === 'backfill';
+    const mode = isBackfill ? 'backfill' : isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : (process.argv[2] ?? '');
     if (mode === 'index') {
         const { initDbWithSchema } = await Promise.resolve().then(() => __importStar(require('./src/db')));
         const { discoverProjects, scanAndIndex } = await Promise.resolve().then(() => __importStar(require('./src/indexer')));
@@ -123,8 +124,45 @@ async function main() {
         const { runSetup } = await Promise.resolve().then(() => __importStar(require('./src/setup')));
         await runSetup();
     }
+    else if (mode === 'backfill') {
+        const { initDbWithSchema, db, CodeDependency } = await Promise.resolve().then(() => __importStar(require('./src/db')));
+        const { extractImportEdges } = await Promise.resolve().then(() => __importStar(require('./src/ast')));
+        const { config } = await Promise.resolve().then(() => __importStar(require('./src/config')));
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        await initDbWithSchema();
+        const rows = await db.query(`SELECT DISTINCT "serviceName", "filePath" FROM code_chunk ORDER BY "serviceName", "filePath"`);
+        console.log(`Backfilling dependency edges for ${rows.length} indexed files...\n`);
+        let processed = 0, skipped = 0, totalEdges = 0;
+        for (const { serviceName, filePath } of rows) {
+            const absPath = path.join(config.workspaceRoot, filePath);
+            const projectRoot = path.join(config.workspaceRoot, serviceName);
+            if (!fs.existsSync(absPath)) {
+                skipped++;
+                continue;
+            }
+            const rawEdges = await extractImportEdges(absPath, serviceName, projectRoot);
+            const edges = rawEdges
+                .filter(e => e.toFile.startsWith(config.workspaceRoot))
+                .map(e => ({ ...e, fromFile: path.relative(config.workspaceRoot, e.fromFile), toFile: path.relative(config.workspaceRoot, e.toFile) }));
+            await db.transaction(async (manager) => {
+                await manager.delete(CodeDependency, { project: serviceName, fromFile: filePath });
+                if (edges.length > 0) {
+                    await manager.createQueryBuilder().insert().into(CodeDependency).values(edges).execute();
+                }
+            });
+            totalEdges += edges.length;
+            processed++;
+            if (processed % 50 === 0)
+                process.stdout.write(`  ${processed}/${rows.length} processed, ${totalEdges} edges...\r`);
+        }
+        console.log(`\nDone. Processed: ${processed}, Skipped (not on disk): ${skipped}, Total edges: ${totalEdges}`);
+        await db.destroy();
+        process.exit(0);
+    }
     else {
-        console.log('Usage: rag-index <path> [--reindex] [--select]');
+        console.log('Usage: rag-index [path] [--reindex] [--select]');
+        console.log('       rag-index backfill');
         console.log('       rag-mcp');
         console.log('       rag-setup');
         process.exit(1);

package/dist/src/ast.d.ts

@@ -1,2 +1,2 @@
 import type { CodeDependency } from './db';
-export declare function extractImportEdges(filePath: string, serviceName: string): Promise<Omit<CodeDependency, 'id'>[]>;
+export declare function extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<Omit<CodeDependency, 'id'>[]>;

package/dist/src/ast.js

@@ -1,21 +1,79 @@
 "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.extractImportEdges = extractImportEdges;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const ts_morph_1 = require("ts-morph");
-// Single ts-morph Project instance for import graph extraction.
-// skipFileDependencyResolution: false is required so getModuleSpecifierSourceFile() resolves relative imports.
-const morphProject = new ts_morph_1.Project({
-    skipAddingFilesFromTsConfig: true,
-    skipFileDependencyResolution: false,
-    compilerOptions: { allowJs: true, noEmit: true },
-});
+// Per-project ts-morph instances keyed by tsconfig.json path ('' = no tsconfig fallback).
+// Loading the tsconfig gives ts-morph the compilerOptions.paths needed to resolve aliases like @core/*.
+const morphProjects = new Map();
+// Secondary cache: projectRoot → tsconfig key. Avoids one fs.existsSync per file after first lookup.
+const projectRootKeys = new Map();
+const FALLBACK_OPTS = { skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false, compilerOptions: { allowJs: true, noEmit: true } };
+function getMorphProject(projectRoot) {
+    if (!projectRootKeys.has(projectRoot)) {
+        const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+        projectRootKeys.set(projectRoot, fs.existsSync(tsconfigPath) ? tsconfigPath : '');
+    }
+    const key = projectRootKeys.get(projectRoot);
+    if (!morphProjects.has(key)) {
+        let project;
+        try {
+            const opts = key
+                ? { tsConfigFilePath: key, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
+                : FALLBACK_OPTS;
+            project = new ts_morph_1.Project(opts);
+        }
+        catch {
+            // tsconfig is invalid — fall back so other files in the project can still be processed
+            project = new ts_morph_1.Project(FALLBACK_OPTS);
+        }
+        morphProjects.set(key, project);
+    }
+    return morphProjects.get(key);
+}
 // Extract import edges from a TS/JS file using ts-morph.
-// Only resolves relative imports (external packages are skipped).
-// Removes the source file from morphProject after parsing to prevent memory accumulation.
-async function extractImportEdges(filePath, serviceName) {
+// projectRoot must be the project root (where tsconfig.json lives) for alias resolution to work.
+// Defaults to the file's directory — callers that need alias resolution must pass the project root explicitly.
+// Removes the source file from the morph project after parsing to prevent memory accumulation.
+async function extractImportEdges(filePath, serviceName, projectRoot = path.dirname(filePath)) {
     // Only process JS/TS files; skip declaration files
     if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath))
         return [];
+    const morphProject = getMorphProject(projectRoot);
     // Remove stale cached version before re-adding
     const existing = morphProject.getSourceFile(filePath);
     if (existing)
@@ -49,10 +107,6 @@ async function extractImportEdges(filePath, serviceName) {
         else if (namespaceImport) {
             edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import-namespace' });
         }
-        else {
-            // Side-effect import: import './foo'
-            edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import' });
-        }
     }
     // Remove from memory — prevents accumulation across large workspaces
     morphProject.removeSourceFile(sourceFile);

package/dist/src/indexer.js

@@ -90,7 +90,7 @@ async function ingestFile(filePath, serviceName, mtimeMs, projectRoot) {
             return { status: 'skipped', chunks: 0 };
         }
         // Extract import edges before the transaction — disk I/O must not hold a DB connection open
-        const rawEdges = await (0, ast_1.extractImportEdges)(filePath, serviceName);
+        const rawEdges = await (0, ast_1.extractImportEdges)(filePath, serviceName, projectRoot);
         const edges = rawEdges
             .filter(e => e.toFile.startsWith(config_1.config.workspaceRoot))
             .map(e => ({

package/dist/src/mcp.js

@@ -136,7 +136,7 @@ async function startMCP() {
                     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)' },
+                        symbol: { type: 'string', description: 'Filter to a specific exported symbol name. When the graph returns no results, also triggers a text-search fallback to find runtime usages (e.g. via singleton or container).' },
                         transitive: { type: 'boolean', description: 'Include transitive (indirect) dependents. Default: false.' },
                     },
                     required: ['file_path', 'project'],
@@ -233,10 +233,28 @@ async function startMCP() {
                 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}` }] };
+                if (rows.length > 0) {
+                    return { content: [{ type: 'text', text: 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 } = (0, searcher_1.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: formatDependents(filePath, rows, transitive) }] };
+                return { content: [{ type: 'text', text: header + fallbackLines.join('\n') }] };
             }
             throw new Error(`Unknown tool: ${req.params.name}`);
         }

package/dist/src/searcher.d.ts

@@ -47,4 +47,12 @@ export declare function searchChunks(query: string, limit: number, project: stri
 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 interface GrepMatch {
+    filePath: string;
+    line: number;
+}
+export declare function grepSymbol(symbol: string, project: string, excludeFile: string): {
+    matches: GrepMatch[];
+    truncated: boolean;
+};
 export declare function readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;

package/dist/src/searcher.js

@@ -39,9 +39,11 @@ exports.searchChunks = searchChunks;
 exports.fetchNeighbors = fetchNeighbors;
 exports.getDependencies = getDependencies;
 exports.getDependents = getDependents;
+exports.grepSymbol = grepSymbol;
 exports.readFileRange = readFileRange;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const ollama_1 = require("ollama");
 const db_1 = require("./db");
 const config_1 = require("./config");
@@ -191,6 +193,41 @@ async function getDependents(filePath, project, symbol = null, transitive = fals
      ORDER BY MIN(depth), "fromFile"`, [filePath, project]);
     return [...direct, ...indirect];
 }
+const GREP_MAX_RESULTS = 200;
+// Grep stops after this many raw lines; generous multiple of GREP_MAX_RESULTS to account for
+// the declaring file's own matches being excluded from the final count.
+const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
+const GREP_EXCLUDE_DIRS = [...file_utils_1.IGNORE_DIRS].map(d => `--exclude-dir=${d}`);
+// Text search for a symbol across all TS/JS files in the project directory.
+// Uses grep -F -w (literal whole-word match) via spawnSync to avoid shell injection.
+// Excludes the declaring file itself. Uses IGNORE_DIRS for consistency with the indexer.
+function grepSymbol(symbol, project, excludeFile) {
+    const projectDir = path.join(config_1.config.workspaceRoot, project);
+    const result = (0, child_process_1.spawnSync)('grep', [
+        '-rn', '-F', '-w',
+        '-m', String(GREP_RAW_LIMIT),
+        '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
+        ...GREP_EXCLUDE_DIRS,
+        symbol,
+        projectDir,
+    ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+    if (result.error || !result.stdout) {
+        if (result.error)
+            console.error(`[grepSymbol] grep failed: ${result.error.message}`);
+        return { matches: [], truncated: false };
+    }
+    const excludeAbsPath = path.join(config_1.config.workspaceRoot, excludeFile);
+    const all = result.stdout.split('\n').flatMap(line => {
+        const match = line.match(/^(.+?):(\d+):/);
+        if (!match)
+            return [];
+        const [, absFile, lineNum] = match;
+        if (absFile === excludeAbsPath)
+            return [];
+        return [{ filePath: path.relative(config_1.config.workspaceRoot, absFile), line: parseInt(lineNum, 10) }];
+    });
+    return { matches: all.slice(0, GREP_MAX_RESULTS), truncated: all.length > GREP_MAX_RESULTS };
+}
 // 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]);

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.6-alpha",
+  "version": "0.0.7-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
+  "license": "MIT",
   "main": "dist/app.js",
   "bin": {
     "rag-index": "dist/app.js",