codesearch-mcp 0.0.6-alpha → 0.0.8-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

@@ -36,6 +36,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 require("./src/env-loader");
 const path = __importStar(require("path"));
+const help_1 = require("./src/help");
+function formatEta(sec) {
+    if (sec < 60)
+        return `${sec}s`;
+    const m = Math.floor(sec / 60);
+    const s = sec % 60;
+    return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
 function printSummary(allStats) {
     const cols = { name: 30, num: 8 };
     const line = '─'.repeat(cols.name + cols.num * 5 + 5);
@@ -54,13 +62,29 @@ function printSummary(allStats) {
         elapsedSec: acc.elapsedSec + s.elapsedSec,
     }), { indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0 });
     console.log('TOTAL'.padEnd(cols.name), String(total.indexed).padStart(cols.num), String(total.skipped).padStart(cols.num), String(total.failed).padStart(cols.num), String(total.chunks).padStart(cols.num), String(total.elapsedSec.toFixed(1)).padStart(cols.num));
+    // Reprint warnings at the end — progress bar activity scrolls per-project warnings out of
+    // view, so we collect them on IndexStats and surface them here as an explicit section.
+    const projectsWithWarnings = allStats.filter(s => s.warnings.length > 0);
+    if (projectsWithWarnings.length > 0) {
+        console.log('\n=== Warnings ===');
+        for (const s of projectsWithWarnings) {
+            console.log(`\n${s.serviceName}:`);
+            for (const w of s.warnings)
+                console.log(`  ⚠ ${w}`);
+        }
+    }
 }
 async function main() {
     const argv1 = path.basename(process.argv[1] ?? '');
     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 (process.argv.includes('--help') || process.argv.includes('-h')) {
+        (0, help_1.printHelp)(argv1 !== 'app.js' ? argv1 : mode);
+        process.exit(0);
+    }
     if (mode === 'index') {
         const { initDbWithSchema } = await Promise.resolve().then(() => __importStar(require('./src/db')));
         const { discoverProjects, scanAndIndex } = await Promise.resolve().then(() => __importStar(require('./src/indexer')));
@@ -81,27 +105,41 @@ async function main() {
         process.env.WORKSPACE_ROOT ??= workspacePath;
         await initDbWithSchema();
         setupInterrupt();
-        const discovered = discoverProjects(workspacePath);
-        const projects = await selectProjects(discovered, workspacePath, forceSelect);
-        if (projects.length === 0) {
-            teardownInterrupt();
-            process.exit(0);
-        }
-        const allStats = [];
-        if (force)
-            console.log('Reindex mode: all files will be re-indexed.');
-        for (const proj of projects) {
+        try {
+            const { collectFiles, loadIgnore } = await Promise.resolve().then(() => __importStar(require('./src/file-utils')));
+            const discovered = discoverProjects(workspacePath);
+            const projects = await selectProjects(discovered, workspacePath, forceSelect);
+            if (projects.length === 0)
+                process.exit(0);
+            const filesPerProject = projects.map(p => collectFiles(p.path, loadIgnore(p.path), p.path));
+            const totalFiles = filesPerProject.reduce((sum, f) => sum + f.length, 0);
+            console.log(`\n${projects.length} projects — ${totalFiles} files total`);
+            if (force)
+                console.log('Reindex mode: all files will be re-indexed.');
+            const allStats = [];
+            for (let i = 0; i < projects.length; i++) {
+                if (signal.aborted)
+                    break;
+                const stats = await scanAndIndex(projects[i].path, projects[i].name, force, signal, filesPerProject[i]);
+                allStats.push(stats);
+                const remaining = projects.length - allStats.length;
+                if (remaining > 0 && !signal.aborted) {
+                    const doneFiles = allStats.reduce((s, r) => s + r.indexed + r.skipped + r.failed, 0);
+                    const elapsedSec = allStats.reduce((s, r) => s + r.elapsedSec, 0);
+                    const leftFiles = filesPerProject.slice(allStats.length).reduce((sum, f) => sum + f.length, 0);
+                    const eta = doneFiles > 0 ? formatEta(Math.round(elapsedSec / doneFiles * leftFiles)) : '?';
+                    console.log(`  ${allStats.length}/${projects.length} projects done — ${remaining} left (~${leftFiles} files) — ETA ~${eta}`);
+                }
+            }
             if (signal.aborted)
-                break;
-            const stats = await scanAndIndex(proj.path, proj.name, force, signal);
-            allStats.push(stats);
+                console.log('\nIndexing interrupted.');
+            printSummary(allStats);
+            if (!signal.aborted)
+                generateProjectGraph(projects, workspacePath);
+        }
+        finally {
+            teardownInterrupt();
         }
-        teardownInterrupt();
-        if (signal.aborted)
-            console.log('\nIndexing interrupted.');
-        printSummary(allStats);
-        if (!signal.aborted)
-            generateProjectGraph(projects, workspacePath);
         process.exit(0);
     }
     else if (mode === 'mcp') {
@@ -123,11 +161,42 @@ async function main() {
         const { runSetup } = await Promise.resolve().then(() => __importStar(require('./src/setup')));
         await runSetup();
     }
+    else if (mode === 'backfill') {
+        const { initDbWithSchema, db } = await Promise.resolve().then(() => __importStar(require('./src/db')));
+        const { collectDepEdges, writeDepEdges } = await Promise.resolve().then(() => __importStar(require('./src/indexer')));
+        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 edges = await collectDepEdges(absPath, serviceName, projectRoot);
+            await writeDepEdges(serviceName, filePath, edges);
+            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('       rag-mcp');
-        console.log('       rag-setup');
-        process.exit(1);
+        // No command → show help and exit cleanly. Unknown command → error + help + exit 1.
+        const hasUnknownArg = mode !== '';
+        const out = hasUnknownArg ? console.error : console.log;
+        if (hasUnknownArg)
+            out(`Unknown command: ${mode}\n`);
+        (0, help_1.printHelp)('default');
+        process.exit(hasUnknownArg ? 1 : 0);
     }
 }
 main().catch(err => { console.error(err); 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,75 @@
 "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 projectRoot. Each project gets its own instance so that
+// projects without a tsconfig (key previously shared as '') don't leak files into each other.
+// Loading the tsconfig gives ts-morph the compilerOptions.paths needed to resolve aliases like @core/*.
+const morphProjects = new Map();
+const FALLBACK_OPTS = { skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false, compilerOptions: { allowJs: true, noEmit: true } };
+function getMorphProject(projectRoot) {
+    if (!morphProjects.has(projectRoot)) {
+        const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+        const hasTsconfig = fs.existsSync(tsconfigPath);
+        let project;
+        try {
+            const opts = hasTsconfig
+                ? { tsConfigFilePath: tsconfigPath, 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(projectRoot, project);
+    }
+    return morphProjects.get(projectRoot);
+}
 // 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 +103,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/config.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = void 0;
 const zod_1 = require("zod");
+const constants_1 = require("./constants");
 const schema = zod_1.z.object({
     // required — no defaults, process exits if missing
     DB_HOST: zod_1.z.string(),
@@ -11,7 +12,7 @@ const schema = zod_1.z.object({
     DB_NAME: zod_1.z.string(),
     // optional with defaults
     OLLAMA_HOST: zod_1.z.string().url().default('http://localhost:11434'),
-    OLLAMA_MODEL: zod_1.z.string().default('bge-m3'),
+    OLLAMA_MODEL: zod_1.z.string().default(constants_1.DEFAULT_EMBED_MODEL),
     CHUNK_SIZE: zod_1.z.coerce.number().default(1500),
     CHUNK_OVERLAP: zod_1.z.coerce.number().default(200),
     EMBED_BATCH_SIZE: zod_1.z.coerce.number().default(5),

package/dist/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_EMBED_MODEL = "bge-m3";

package/dist/src/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EMBED_MODEL = void 0;
+// Embedding model is tied to the vector column dimension (bge-m3 → 1024).
+// Change both together: update this constant, drop/recreate the `embedding` column,
+// and re-run indexing.
+exports.DEFAULT_EMBED_MODEL = 'bge-m3';

package/dist/src/db/init.js

@@ -7,7 +7,8 @@ const data_source_1 = require("./data-source");
 async function initDb() {
     await data_source_1.db.initialize();
 }
-// For indexer — connect + create schema only if tables don't exist yet
+// For indexer — connect + create schema only if tables don't exist yet.
+// All secondary indexes use IF NOT EXISTS so existing installs pick up new indexes on re-run.
 async function initDbWithSchema() {
     await data_source_1.db.initialize();
     // code_chunk table
@@ -24,6 +25,9 @@ async function initDbWithSchema() {
       ON code_chunk USING hnsw (embedding vector_cosine_ops)
     `);
     }
+    // Composite btree for all per-service lookups (scanAndIndex stale-sweep, ingest upsert, search filter).
+    // Applied idempotently so existing installs pick it up on next indexing run.
+    await data_source_1.db.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
     // code_dependency table
     const [{ existsDep }] = await data_source_1.db.query(`
     SELECT EXISTS (
@@ -43,8 +47,16 @@ async function initDbWithSchema() {
         "depType"   TEXT NOT NULL
       )
     `);
-        await data_source_1.db.query(`CREATE INDEX idx_dep_from    ON code_dependency ("fromFile")`);
-        await data_source_1.db.query(`CREATE INDEX idx_dep_to      ON code_dependency ("toFile")`);
-        await data_source_1.db.query(`CREATE INDEX idx_dep_project ON code_dependency (project)`);
     }
+    // Composite indexes for the two query shapes used everywhere:
+    //   WHERE project = $1 AND "fromFile" = $2   (get_dependencies, ingest delete-by-from)
+    //   WHERE project = $1 AND "toFile"   = $2   (get_dependents, stale-file sweep)
+    // IF NOT EXISTS lets existing installs upgrade without a manual migration.
+    await data_source_1.db.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_from ON code_dependency (project, "fromFile")`);
+    await data_source_1.db.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_to   ON code_dependency (project, "toFile")`);
+    // Drop redundant legacy single-column indexes (covered by the composites above).
+    // Safe on fresh installs too — DROP IF EXISTS is a no-op when absent.
+    await data_source_1.db.query(`DROP INDEX IF EXISTS idx_dep_from`);
+    await data_source_1.db.query(`DROP INDEX IF EXISTS idx_dep_to`);
+    await data_source_1.db.query(`DROP INDEX IF EXISTS idx_dep_project`);
 }

package/dist/src/help.d.ts

@@ -0,0 +1 @@
+export declare function printHelp(command: string): void;

package/dist/src/help.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = printHelp;
+function printHelp(command) {
+    switch (command) {
+        case 'rag-index':
+        case 'index':
+            console.log('Usage: rag-index [path] [options]');
+            console.log('       rag-index backfill');
+            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('');
+            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 dependency graph 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('');
+            console.log('Options:');
+            console.log('  -h, --help        Show this help message');
+            break;
+        case 'rag-setup':
+        case 'setup':
+            console.log('Usage: rag-setup');
+            console.log('');
+            console.log('Interactive setup: configure DB, Ollama, and WORKSPACE_ROOT.');
+            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;
+        default:
+            console.log('Usage: rag-index [path] [--reindex] [--select]');
+            console.log('       rag-index backfill');
+            console.log('       rag-mcp');
+            console.log('       rag-setup');
+            console.log('');
+            console.log('Run any command with -h or --help for details.');
+    }
+}

package/dist/src/indexer.d.ts

@@ -1,3 +1,4 @@
+import { CodeDependency } from './db';
 export interface IndexStats {
     serviceName: string;
     indexed: number;
@@ -5,9 +6,12 @@ export interface IndexStats {
     failed: number;
     chunks: number;
     elapsedSec: number;
+    warnings: string[];
 }
 export declare function discoverProjects(rootDir: string): {
     name: string;
     path: string;
 }[];
-export declare function scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal): Promise<IndexStats>;
+export declare function collectDepEdges(absFilePath: string, serviceName: string, projectRoot: string): Promise<Omit<CodeDependency, 'id'>[]>;
+export declare function writeDepEdges(serviceName: string, relFilePath: string, edges: Omit<CodeDependency, 'id'>[], manager?: import('typeorm').EntityManager): Promise<void>;
+export declare function scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;

package/dist/src/indexer.js

@@ -34,17 +34,18 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.discoverProjects = discoverProjects;
+exports.collectDepEdges = collectDepEdges;
+exports.writeDepEdges = writeDepEdges;
 exports.scanAndIndex = scanAndIndex;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const textsplitters_1 = require("@langchain/textsplitters");
-const ollama_1 = require("ollama");
 const cli_progress_1 = require("cli-progress");
 const db_1 = require("./db");
 const ast_1 = require("./ast");
 const config_1 = require("./config");
+const ollama_1 = require("./ollama");
 const file_utils_1 = require("./file-utils");
-const ollama = new ollama_1.Ollama({ host: config_1.config.ollama.host });
 // JS/TS splitter uses language-aware separators (functions, classes, blocks)
 const jsSplitter = textsplitters_1.RecursiveCharacterTextSplitter.fromLanguage('js', {
     chunkSize: config_1.config.indexer.chunkSize,
@@ -69,12 +70,39 @@ function discoverProjects(rootDir) {
 }
 // Embed a pre-formatted prompt (caller is responsible for prefix and context)
 async function embedText(prompt) {
-    const { embedding } = await ollama.embeddings({
+    const { embedding } = await ollama_1.ollama.embeddings({
         model: config_1.config.ollama.model,
         prompt,
     });
     return embedding;
 }
+// Shared helpers for dependency edge writes — used by ingestFile (incremental) and backfill CLI.
+// Extract edges via ts-morph (disk I/O) and normalize to workspace-relative paths.
+// Call this OUTSIDE any DB transaction — disk/AST work must not hold a DB connection open.
+async function collectDepEdges(absFilePath, serviceName, projectRoot) {
+    const rawEdges = await (0, ast_1.extractImportEdges)(absFilePath, serviceName, projectRoot);
+    return rawEdges
+        .filter(e => e.toFile.startsWith(config_1.config.workspaceRoot))
+        .map(e => ({
+        ...e,
+        fromFile: path.relative(config_1.config.workspaceRoot, e.fromFile),
+        toFile: path.relative(config_1.config.workspaceRoot, e.toFile),
+    }));
+}
+// Replace edge rows for a file. When `manager` is provided, runs inside that transaction;
+// otherwise opens its own. Keeps delete + insert atomic either way.
+async function writeDepEdges(serviceName, relFilePath, edges, manager) {
+    const run = async (mgr) => {
+        await mgr.delete(db_1.CodeDependency, { project: serviceName, fromFile: relFilePath });
+        if (edges.length > 0) {
+            await mgr.createQueryBuilder().insert().into(db_1.CodeDependency).values(edges).execute();
+        }
+    };
+    if (manager)
+        await run(manager);
+    else
+        await db_1.db.transaction(run);
+}
 // Ingest a single file: skip if unchanged, otherwise delete old chunks and re-index.
 // Returns status and chunk count. Never throws — failures are caught and reported.
 async function ingestFile(filePath, serviceName, mtimeMs, projectRoot) {
@@ -90,14 +118,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 edges = rawEdges
-            .filter(e => e.toFile.startsWith(config_1.config.workspaceRoot))
-            .map(e => ({
-            ...e,
-            fromFile: path.relative(config_1.config.workspaceRoot, e.fromFile),
-            toFile: path.relative(config_1.config.workspaceRoot, e.toFile),
-        }));
+        const edges = await collectDepEdges(filePath, serviceName, projectRoot);
         // Read and embed outside the transaction — Ollama calls must not hold a DB transaction open
         const code = fs.readFileSync(filePath, 'utf-8');
         const chunks = await getSplitter(filePath).createDocuments([code]);
@@ -129,14 +150,7 @@ async function ingestFile(filePath, serviceName, mtimeMs, projectRoot) {
                     .values(records.slice(i, i + config_1.config.indexer.batchSize))
                     .execute();
             }
-            await manager.delete(db_1.CodeDependency, { project: serviceName, fromFile: relFilePath });
-            if (edges.length > 0) {
-                await manager.createQueryBuilder()
-                    .insert()
-                    .into(db_1.CodeDependency)
-                    .values(edges)
-                    .execute();
-            }
+            await writeDepEdges(serviceName, relFilePath, edges, manager);
         });
         return { status: 'indexed', chunks: chunks.length };
     }
@@ -149,48 +163,58 @@ async function ingestFile(filePath, serviceName, mtimeMs, projectRoot) {
 // Removes chunks for deleted files, skips unchanged files, re-indexes modified ones.
 // Pass force=true to invalidate all cached mtimes and force full re-index (e.g. after embedding strategy change).
 // Pass signal to support graceful interruption — stops between files, never mid-transaction.
-async function scanAndIndex(dir, serviceName, force = false, signal) {
+async function scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles) {
     const startTime = Date.now();
     const repo = db_1.db.getRepository(db_1.CodeChunk);
-    // Clean up chunks whose source files no longer exist on disk
+    // Force mode: wipe lastModified so all files are treated as changed
+    if (force) {
+        await db_1.db.query(`UPDATE code_chunk SET "lastModified" = NULL WHERE "serviceName" = $1`, [serviceName]);
+    }
+    const files = preCollectedFiles ?? (0, file_utils_1.collectFiles)(dir, (0, file_utils_1.loadIgnore)(dir), dir);
+    // Clean up chunks for files no longer in the collected set — covers both deleted files and
+    // files newly excluded by .ragignore (they exist on disk but should no longer be indexed).
+    const collectedRelPaths = new Set(files.map(f => path.relative(config_1.config.workspaceRoot, f)));
     const dbPaths = await db_1.db.query(`SELECT DISTINCT "filePath" FROM code_chunk WHERE "serviceName" = $1`, [serviceName]);
     for (const { filePath } of dbPaths) {
-        if (!fs.existsSync(path.join(config_1.config.workspaceRoot, filePath))) {
+        if (!collectedRelPaths.has(filePath)) {
             await repo.delete({ serviceName, filePath });
-            // Remove dependency edges on both sides — this file no longer exists as importer or target
             await db_1.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "fromFile" = $2`, [serviceName, filePath]);
             await db_1.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "toFile" = $2`, [serviceName, filePath]);
             console.log(`  Removed stale: ${path.basename(filePath)}`);
         }
     }
-    // Force mode: wipe lastModified so all files are treated as changed
-    if (force) {
-        await db_1.db.query(`UPDATE code_chunk SET "lastModified" = NULL WHERE "serviceName" = $1`, [serviceName]);
-    }
-    const ig = (0, file_utils_1.loadIgnore)(dir);
-    const files = (0, file_utils_1.collectFiles)(dir, ig, dir);
     const bar = new cli_progress_1.SingleBar({
-        format: `{serviceName} {bar} {percentage}% | {value}/{total} | {filename}`,
+        format: `{serviceName} {bar} {percentage}% | {value}/{total} | ETA {eta_formatted} | {filename}`,
         barCompleteChar: '█',
         barIncompleteChar: '░',
         hideCursor: true,
         clearOnComplete: false,
     }, cli_progress_1.Presets.shades_grey);
+    const warnings = [];
     console.log(`\nIndexing ${serviceName}: ${files.length} files`);
     const meta = (0, file_utils_1.readRagMeta)(dir);
     if (meta === null && fs.existsSync(path.join(dir, '.ragmeta.json'))) {
-        console.log(`  ⚠ .ragmeta.json found but invalid JSON`);
+        const msg = `.ragmeta.json found but invalid JSON`;
+        console.log(`  ⚠ ${msg}`);
+        warnings.push(msg);
     }
     else if (meta) {
         const parts = [meta.description, meta.stack && `[${meta.stack}]`].filter(Boolean).join(' ');
         console.log(`  ✓ .ragmeta.json: ${parts || '(no fields)'}`);
     }
     else {
-        console.log(`  ⚠ No .ragmeta.json — add {"description":"...","stack":"...","notes":"..."} so list_projects can describe this project`);
+        const msg = `No .ragmeta.json — add {"description":"...","stack":"...","notes":"..."} so list_projects can describe this project`;
+        console.log(`  ⚠ ${msg}`);
+        warnings.push(msg);
+    }
+    if (!fs.existsSync(path.join(dir, '.ragignore'))) {
+        const msg = `No .ragignore — create one to exclude generated/codegen files (e.g. src/gql/graphql.ts, **/__snapshots__/**)`;
+        console.log(`  ⚠ ${msg}`);
+        warnings.push(msg);
     }
     bar.start(files.length, 0, { serviceName, filename: '' });
     const stats = {
-        serviceName, indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0,
+        serviceName, indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0, warnings,
     };
     for (const filePath of files) {
         if (signal?.aborted) {

package/dist/src/mcp.js

@@ -1,11 +1,54 @@
 "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.startMCP = startMCP;
+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 config_1 = require("./config");
 const searcher_1 = require("./searcher");
+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.
 
@@ -14,6 +57,8 @@ You have access to a local semantic code search server. Use these tools to navig
 - **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.
 
 ## Recommended workflow
 
@@ -79,7 +124,7 @@ 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 });
+    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: [
             {
@@ -136,7 +181,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: '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'],
@@ -203,9 +248,9 @@ async function startMCP() {
                 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.`;
+                    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');
@@ -233,10 +278,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/ollama.d.ts

@@ -0,0 +1,2 @@
+import { Ollama } from 'ollama';
+export declare const ollama: Ollama;

package/dist/src/ollama.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ollama = void 0;
+const ollama_1 = require("ollama");
+const config_1 = require("./config");
+exports.ollama = new ollama_1.Ollama({ host: config_1.config.ollama.host });

package/dist/src/project-selector.js

@@ -45,8 +45,16 @@ function loadLines(filePath) {
         .map(l => l.trim())
         .filter(l => l && !l.startsWith('#')));
 }
+// Write the set if non-empty, otherwise delete the file so state is deterministic.
+// Previously .ragskip could be left stale (last entry removed but file not rewritten);
+// treating both files the same way avoids that drift.
 function saveLines(filePath, names) {
-    fs.writeFileSync(filePath, [...names].sort().join('\n') + '\n');
+    if (names.size > 0) {
+        fs.writeFileSync(filePath, [...names].sort().join('\n') + '\n');
+    }
+    else if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
 }
 function loadConfig(workspaceDir) {
     return {
@@ -56,8 +64,7 @@ function loadConfig(workspaceDir) {
 }
 function saveConfig(workspaceDir, config) {
     saveLines(path.join(workspaceDir, '.ragprojects'), config.included);
-    if (config.skipped.size > 0)
-        saveLines(path.join(workspaceDir, '.ragskip'), config.skipped);
+    saveLines(path.join(workspaceDir, '.ragskip'), config.skipped);
 }
 async function selectProjects(allProjects, workspaceDir, forceSelect) {
     const config = loadConfig(workspaceDir);

package/dist/src/searcher.d.ts

@@ -1,5 +1,4 @@
-export type { Relations } from './file-utils';
-export type { ProjectMeta } from './file-utils';
+import { type ProjectMeta } from './file-utils';
 export interface ChunkRow {
     serviceName: string;
     filePath: string;
@@ -22,7 +21,7 @@ export type FileRangeResult = {
     lines: string[];
 } | {
     ok: false;
-    reason: 'not_indexed' | 'not_on_disk';
+    reason: 'not_indexed' | 'not_on_disk' | 'invalid_path';
 };
 export interface DependencyRow {
     fromFile: string;
@@ -37,7 +36,6 @@ 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;
@@ -47,4 +45,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,21 +39,23 @@ 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 ollama_1 = require("ollama");
+const readline = __importStar(require("readline"));
+const child_process_1 = require("child_process");
 const db_1 = require("./db");
 const config_1 = require("./config");
+const ollama_1 = require("./ollama");
 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({
+    const response = await ollama_1.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}` }],
     });
@@ -79,7 +81,7 @@ async function listProjects() {
 }
 // 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 { embedding } = await ollama_1.ollama.embeddings({ model: config_1.config.ollama.model, prompt: query });
     const params = [`[${embedding}]`, config_1.config.search.similarityThreshold, limit];
     let projectFilter = '';
     if (project) {
@@ -95,20 +97,32 @@ async function searchChunks(query, limit, project) {
      ORDER BY embedding <=> $1
      LIMIT $3`, params);
 }
-// Fetch the chunk immediately before and after each result in the same file (Small-to-Big)
+// Fetch the chunk immediately before and after each result in the same file (Small-to-Big).
+// Single query with LATERAL joins — avoids 2N round-trips.
 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 };
+    if (results.length === 0)
+        return [];
+    const values = results.map((_, i) => `(${i}, $${i * 2 + 1}, $${i * 2 + 2}::int)`).join(',');
+    const params = results.flatMap(r => [r.filePath, r.startLine]);
+    const rows = await db_1.db.query(`SELECT r.idx,
+            prev."serviceName" AS prev_sn, prev."filePath" AS prev_fp, prev."startLine" AS prev_sl, prev.content AS prev_c,
+            next."serviceName" AS next_sn, next."filePath" AS next_fp, next."startLine" AS next_sl, next.content AS next_c
+     FROM (VALUES ${values}) r(idx, fp, sl)
+     LEFT JOIN LATERAL (
+       SELECT "serviceName", "filePath", "startLine", content
+       FROM code_chunk WHERE "filePath" = r.fp AND "startLine" < r.sl
+       ORDER BY "startLine" DESC LIMIT 1
+     ) prev ON true
+     LEFT JOIN LATERAL (
+       SELECT "serviceName", "filePath", "startLine", content
+       FROM code_chunk WHERE "filePath" = r.fp AND "startLine" > r.sl
+       ORDER BY "startLine" ASC LIMIT 1
+     ) next ON true
+     ORDER BY r.idx`, params);
+    return rows.map((row, i) => ({
+        result: results[i],
+        prevChunk: row.prev_fp ? { serviceName: row.prev_sn, filePath: row.prev_fp, startLine: row.prev_sl, content: row.prev_c } : null,
+        nextChunk: row.next_fp ? { serviceName: row.next_sn, filePath: row.next_fp, startLine: row.next_sl, content: row.next_c } : null,
     }));
 }
 // Return all files imported by filePath (direct or transitive)
@@ -191,15 +205,72 @@ 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) {
+    // Defensive: reject paths that escape the workspace root (e.g. "../../etc/passwd")
+    const resolvedRoot = path.resolve(config_1.config.workspaceRoot);
+    const absPath = path.resolve(resolvedRoot, filePath);
+    if (absPath !== resolvedRoot && !absPath.startsWith(resolvedRoot + path.sep)) {
+        return { ok: false, reason: 'invalid_path' };
+    }
     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 };
+    // Stream line-by-line — avoids loading entire file into memory.
+    // Stops reading as soon as we pass endLine.
+    const lines = [];
+    const stream = fs.createReadStream(absPath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let lineNo = 0;
+    let lastRead = 0;
+    for await (const line of rl) {
+        lineNo++;
+        lastRead = lineNo;
+        if (lineNo >= startLine && lineNo <= endLine)
+            lines.push(line);
+        if (lineNo >= endLine) {
+            rl.close();
+            stream.destroy();
+            break;
+        }
+    }
+    // If we broke out early, lastRead is endLine. If file was shorter, lastRead is file length.
+    return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines };
 }

package/dist/src/setup.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
+const constants_1 = require("./constants");
 const CONFIG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp');
 const CONFIG_FILE = path.join(CONFIG_DIR, '.env');
 const DOCKER_COMPOSE_SRC = path.join(__dirname, '..', '..', 'docker', 'docker-compose.yml');
@@ -133,8 +134,18 @@ async function setupLocalDocker(ollamaHost) {
     }
     await waitForDb('localhost', 5433, 'dev', 'dev', 'rag');
     await waitForOllama(ollamaHost);
-    console.log('Pulling bge-m3 model (this may take a while)...');
-    (0, child_process_1.spawnSync)('docker', ['exec', 'codesearch-mcp-ollama-1', 'ollama', 'pull', 'bge-m3'], { stdio: 'inherit' });
+    // Resolve the ollama container ID via compose — compose project name (and thus the
+    // default container name) depends on the parent directory, so hardcoding it breaks when
+    // users install via npm -g or move the compose file around.
+    const ollamaId = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'ps', '-q', 'ollama'], { encoding: 'utf-8' })
+        .stdout?.trim();
+    if (!ollamaId) {
+        console.error('Could not resolve ollama container ID from compose. Pull the model manually:');
+        console.error(`  docker exec <ollama-container> ollama pull ${constants_1.DEFAULT_EMBED_MODEL}`);
+        process.exit(1);
+    }
+    console.log(`Pulling ${constants_1.DEFAULT_EMBED_MODEL} model (this may take a while)...`);
+    (0, child_process_1.spawnSync)('docker', ['exec', ollamaId, 'ollama', 'pull', constants_1.DEFAULT_EMBED_MODEL], { stdio: 'inherit' });
     return {
         DB_HOST: 'localhost',
         DB_PORT: '5433',
@@ -166,13 +177,12 @@ async function setupRemoteDb(rl) {
 async function runSetup() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log('=== codesearch-mcp setup ===\n');
-    const dbChoice = await ask(rl, 'Database type:\n  1. Local Docker (auto-start)\n  2. Remote (Supabase, Railway, self-hosted)\n\nEnter choice (1): ');
+    const dbChoice = await ask(rl, 'Infrastructure:\n  1. Local Docker (auto-start PostgreSQL + Ollama)\n  2. Remote (Supabase, Railway, self-hosted DB + local Ollama)\n\nEnter choice (1): ');
     const useDocker = (dbChoice.trim() || '1') === '1';
     const defaultWorkspace = path.join(os.homedir(), 'Projects');
     const workspaceInput = await ask(rl, `\nWorkspace root — directory that contains all your projects\n  Example: ${os.homedir()}/WebstormProjects\n  Path (${defaultWorkspace}): `);
     const workspaceRoot = expandHome(workspaceInput.trim() || defaultWorkspace);
     const ollamaHost = await prompt(rl, 'Ollama API URL', 'http://localhost:11434');
-    const ollamaModel = await prompt(rl, 'Embedding model', 'bge-m3');
     const dbVars = useDocker
         ? await setupLocalDocker(ollamaHost)
         : await setupRemoteDb(rl);
@@ -180,7 +190,6 @@ async function runSetup() {
         ...dbVars,
         WORKSPACE_ROOT: workspaceRoot,
         OLLAMA_HOST: ollamaHost,
-        OLLAMA_MODEL: ollamaModel,
     });
     rl.close();
     console.log('\nInitializing database schema...');

package/docker/docker-compose.yml

@@ -7,6 +7,8 @@ services:
       POSTGRES_DB: rag
     ports:
       - "5433:5432"
+    volumes:
+      - ${HOME}/.local/share/codesearch-mcp/pgdata:/var/lib/postgresql/data
 
   ollama:
     image: ollama/ollama

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.6-alpha",
+  "version": "0.0.8-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",