codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/help.js

@@ -16,7 +16,15 @@ function printHelp(command) {
             console.log('  --project [name]  Scope this run to one discovered project or monorepo unit');
             console.log('                    by exact name, bypassing selection and pruning; omit the');
             console.log('                    name for an interactive single-choice prompt');
+            console.log('  --require-cwd     Needs --project <name>; the run is refused unless the current');
+            console.log('                    directory is that project\'s directory');
             console.log('  -h, --help        Show this help message');
+            console.log('');
+            console.log('Exit codes:');
+            console.log('  0  No file failed and nothing else failed; includes an interrupted run,');
+            console.log('     which may have left files unindexed');
+            console.log('  2  The run finished with failed files and the rest of the index is usable');
+            console.log('  1  Any other failure');
             break;
         case 'rag-mcp':
         case 'mcp':
@@ -75,7 +83,7 @@ function printHelp(command) {
             console.log('  -h, --help        Show this help message');
             break;
         default:
-            console.log('Usage: rag-index [--reindex] [--select] [--project [name]]');
+            console.log('Usage: rag-index [--reindex] [--select] [--project [name]] [--require-cwd]');
             console.log('       rag-mcp');
             console.log('       rag-setup');
             console.log('       rag-config <show|get|set|reset|edit>');

package/dist/src/index-args.d.ts

@@ -0,0 +1,13 @@
+export declare function findUnexpectedIndexArg(args: string[]): string | undefined;
+export declare function unreadableCwdCause(args: string[]): string | undefined;
+export interface ProjectFlag {
+    present: boolean;
+    name?: string;
+}
+export interface IndexArgs {
+    force: boolean;
+    forceSelect: boolean;
+    projectFlag: ProjectFlag;
+    requireCwd: boolean;
+}
+export declare function parseIndexArgs(args: string[]): IndexArgs;

package/dist/src/index-args.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUnexpectedIndexArg = findUnexpectedIndexArg;
+exports.unreadableCwdCause = unreadableCwdCause;
+exports.parseIndexArgs = parseIndexArgs;
+const BOOL_FLAGS = new Set(['--reindex', '--select', '--require-cwd']);
+function findUnexpectedIndexArg(args) {
+    let projectSeen = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (BOOL_FLAGS.has(a))
+            continue;
+        if (a === '--project' && !projectSeen) {
+            projectSeen = true;
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith('-'))
+                i++;
+            continue;
+        }
+        return a;
+    }
+    return undefined;
+}
+function unreadableCwdCause(args) {
+    if (!args.includes('--require-cwd'))
+        return undefined;
+    try {
+        process.cwd();
+        return undefined;
+    }
+    catch (err) {
+        return err.message;
+    }
+}
+function parseProjectFlag(args) {
+    const i = args.indexOf('--project');
+    if (i === -1)
+        return { present: false };
+    const next = args[i + 1];
+    return next !== undefined && !next.startsWith('-') ? { present: true, name: next } : { present: true };
+}
+function parseIndexArgs(args) {
+    const force = args.includes('--reindex');
+    const forceSelect = args.includes('--select');
+    const projectFlag = parseProjectFlag(args);
+    const requireCwd = args.includes('--require-cwd');
+    return { force, forceSelect, projectFlag, requireCwd };
+}

package/dist/src/indexing/AnalysisBatcher.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from '../config';
+import type { IAstParser, FileAnalysis } from '../interfaces/IAstParser';
+export declare class AnalysisBatcher {
+    private ast;
+    private config;
+    constructor(ast: IAstParser, config: Config);
+    get batchSize(): number;
+    batches(files: string[], serviceName: string, dir: string, signal?: AbortSignal, rootTsConfigPath?: string): AsyncGenerator<{
+        batch: string[];
+        analysisMap: Map<string, FileAnalysis>;
+    }>;
+}

package/dist/src/indexing/AnalysisBatcher.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalysisBatcher = void 0;
+class AnalysisBatcher {
+    ast;
+    config;
+    constructor(ast, config) {
+        this.ast = ast;
+        this.config = config;
+    }
+    get batchSize() {
+        return this.config.indexer.astBatchSize;
+    }
+    async *batches(files, serviceName, dir, signal, rootTsConfigPath) {
+        const isLargeProject = files.length > this.config.indexer.astBatchSize;
+        for (let batchStart = 0; batchStart < files.length; batchStart += this.config.indexer.astBatchSize) {
+            if (signal?.aborted)
+                return;
+            const batch = files.slice(batchStart, batchStart + this.config.indexer.astBatchSize);
+            const analysisMap = await this.ast.analyzeProject(batch, serviceName, dir, {
+                skipDependencyResolution: isLargeProject,
+                rootTsConfigPath,
+            });
+            yield { batch, analysisMap };
+        }
+    }
+}
+exports.AnalysisBatcher = AnalysisBatcher;

package/dist/src/indexing/ChunkEmbedder.d.ts

@@ -0,0 +1,24 @@
+import type { Config } from '../config';
+import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { DepEdge, SymbolEntry } from '../interfaces/IAstParser';
+import type { ChunkPiece } from '../interfaces/IChunker';
+import type { DeclarationTree } from '../declarations/DeclarationTree';
+import type { SourceLines } from '../declarations/SourceLines';
+import type { CodeChunkInsert } from '../db';
+export interface ChunkRecordContext {
+    serviceName: string;
+    relFilePath: string;
+    relPath: string;
+    promptEdges: DepEdge[];
+    rawSymbols: SymbolEntry[];
+    mtimeMs: number;
+    hash: string;
+    ownerTree: DeclarationTree;
+    sourceLines: SourceLines;
+}
+export declare class ChunkEmbedder {
+    private embedder;
+    private config;
+    constructor(embedder: IEmbedder, config: Config);
+    records(chunks: ChunkPiece[], ctx: ChunkRecordContext): Promise<CodeChunkInsert[]>;
+}

package/dist/src/indexing/ChunkEmbedder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkEmbedder = void 0;
+const owner_path_1 = require("../owner-path");
+const enriched_prompt_1 = require("../enriched-prompt");
+class ChunkEmbedder {
+    embedder;
+    config;
+    constructor(embedder, config) {
+        this.embedder = embedder;
+        this.config = config;
+    }
+    async records(chunks, ctx) {
+        const { serviceName, relFilePath, relPath, promptEdges, rawSymbols, mtimeMs, hash, ownerTree, sourceLines } = ctx;
+        const records = [];
+        const embedBatchSize = this.config.embedding.batchSize;
+        for (let i = 0; i < chunks.length; i += embedBatchSize) {
+            const batch = chunks.slice(i, i + embedBatchSize);
+            const prompts = batch.map(piece => (0, enriched_prompt_1.getEnrichedPrompt)(piece, relPath, serviceName, promptEdges, rawSymbols));
+            const vectors = await this.embedder.embedBatch(prompts, 'document');
+            for (let j = 0; j < batch.length; j++) {
+                const piece = batch[j];
+                records.push({
+                    serviceName, filePath: relFilePath, startLine: piece.startLine,
+                    content: piece.content,
+                    embedding: `[${vectors[j]}]`,
+                    lastModified: mtimeMs,
+                    contentHash: hash,
+                    ownerPath: (0, owner_path_1.ownerOf)(piece, ownerTree, sourceLines),
+                    endLine: piece.startLine + (piece.content.match(/\n/g)?.length ?? 0),
+                });
+            }
+        }
+        return records;
+    }
+}
+exports.ChunkEmbedder = ChunkEmbedder;

package/dist/src/indexing/ConsoleScanReporter.d.ts

@@ -0,0 +1,10 @@
+import type { IScanReporter, ProjectNotice } from '../interfaces';
+export declare class ConsoleScanReporter implements IScanReporter {
+    private bar;
+    staleRemoved(relFile: string): void;
+    begin(serviceName: string, fileCount: number, notices: ProjectNotice[]): void;
+    file(relToDir: string): void;
+    advance(): void;
+    interrupted(serviceName: string): void;
+    end(): void;
+}

package/dist/src/indexing/ConsoleScanReporter.js

@@ -0,0 +1,73 @@
+"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.ConsoleScanReporter = void 0;
+const path = __importStar(require("path"));
+const cli_progress_1 = require("cli-progress");
+class ConsoleScanReporter {
+    bar;
+    staleRemoved(relFile) {
+        console.log(`  Removed stale: ${path.basename(relFile)}`);
+    }
+    begin(serviceName, fileCount, notices) {
+        this.bar = new cli_progress_1.SingleBar({
+            format: `{serviceName} {bar} {percentage}% | {value}/{total} | {duration_formatted} elapsed | ~{eta_formatted} left | {filename}`,
+            barCompleteChar: '█',
+            barIncompleteChar: '░',
+            hideCursor: true,
+            clearOnComplete: false,
+        }, cli_progress_1.Presets.shades_grey);
+        console.log(`\nIndexing ${serviceName}: ${fileCount} files`);
+        for (const { mark, message } of notices) {
+            console.log(`  ${mark} ${message}`);
+        }
+        this.bar.start(fileCount, 0, { serviceName, filename: '' });
+    }
+    file(relToDir) {
+        this.bar?.update({ filename: relToDir });
+    }
+    advance() {
+        this.bar?.increment();
+    }
+    interrupted(serviceName) {
+        this.bar?.stop();
+        console.log(`\n  Interrupted — ${serviceName}`);
+    }
+    end() {
+        this.bar?.stop();
+        process.stdout.write('\x1B[J');
+    }
+}
+exports.ConsoleScanReporter = ConsoleScanReporter;

package/dist/src/indexing/EmbeddingSchemaPreparer.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from '../config';
+import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { IDatabase, IndexMeta } from '../interfaces/IDatabase';
+import type { ILogger } from '../interfaces/ILogger';
+export declare class EmbeddingSchemaPreparer {
+    private db;
+    private embedder;
+    private config;
+    private logger;
+    constructor(db: IDatabase, embedder: IEmbedder, config: Config, logger: ILogger);
+    prepare(): Promise<IndexMeta>;
+    private reconcileIndex;
+    private countChunks;
+}

package/dist/src/indexing/EmbeddingSchemaPreparer.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingSchemaPreparer = void 0;
+const constants_1 = require("../constants");
+class EmbeddingSchemaPreparer {
+    db;
+    embedder;
+    config;
+    logger;
+    constructor(db, embedder, config, logger) {
+        this.db = db;
+        this.embedder = embedder;
+        this.config = config;
+        this.logger = logger;
+    }
+    async prepare() {
+        const { provider, model, dimensions: override } = this.config.embedding;
+        const next = {
+            provider,
+            model,
+            dimensions: await (0, constants_1.resolveDimension)(override, model, async () => {
+                const probe = await this.embedder.embed('probe', 'document');
+                return probe.length;
+            }),
+        };
+        const meta = await this.db.readIndexMeta();
+        if (!meta) {
+            const chunkCount = await this.countChunks();
+            if (chunkCount === 0) {
+                await this.db.recreateChunkTable(next.dimensions);
+                await this.db.writeIndexMeta(next);
+                this.logger.debug('IndexerService: prepared fresh index', { ...next });
+                return next;
+            }
+            await this.reconcileIndex({ provider: 'ollama', model: 'bge-m3', dimensions: 1024 }, next);
+            return next;
+        }
+        await this.reconcileIndex(meta, next);
+        return next;
+    }
+    async reconcileIndex(prev, next) {
+        if (prev.dimensions !== next.dimensions) {
+            console.log(`Embedding dimension changed (${prev.dimensions} → ${next.dimensions}) — recreating code_chunk.`);
+            this.logger.info('IndexerService: dimension change, recreating code_chunk', { prev, next });
+            await this.db.recreateChunkTable(next.dimensions);
+        }
+        else if (prev.provider !== next.provider || prev.model !== next.model) {
+            console.log(`Embedding model changed (${prev.provider}/${prev.model} → ${next.provider}/${next.model}) — clearing index.`);
+            this.logger.info('IndexerService: model change, clearing code_chunk', { prev, next });
+            await this.db.query(`DELETE FROM code_chunk`);
+        }
+        await this.db.writeIndexMeta(next);
+    }
+    async countChunks() {
+        try {
+            const rows = await this.db.query(`SELECT COUNT(*)::int AS n FROM code_chunk`);
+            return Number(rows[0]?.n ?? 0);
+        }
+        catch (err) {
+            if (/does not exist/i.test(err.message))
+                return 0;
+            throw err;
+        }
+    }
+}
+exports.EmbeddingSchemaPreparer = EmbeddingSchemaPreparer;

package/dist/src/indexing/FileIngestor.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../config';
+import type { FileAnalysis } from '../interfaces/IAstParser';
+import type { IChunker } from '../interfaces/IChunker';
+import type { ILogger } from '../interfaces/ILogger';
+import type { IndexStore } from './IndexStore';
+import type { ChunkEmbedder } from './ChunkEmbedder';
+export type IngestStatus = 'indexed' | 'skipped' | 'failed';
+export type IngestResult = {
+    status: IngestStatus;
+    chunks: number;
+    pendingMtimeRefresh?: string;
+};
+export declare class FileIngestor {
+    private store;
+    private chunkEmbedder;
+    private chunker;
+    private config;
+    private logger;
+    constructor(store: IndexStore, chunkEmbedder: ChunkEmbedder, chunker: IChunker, config: Config, logger: ILogger);
+    private static hashContent;
+    ingestFile(filePath: string, serviceName: string, mtimeMs: number, projectRoot: string, analysis?: FileAnalysis): Promise<IngestResult>;
+}

package/dist/src/indexing/FileIngestor.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIngestor = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const DeclarationTree_1 = require("../declarations/DeclarationTree");
+const SourceLines_1 = require("../declarations/SourceLines");
+const symbol_rows_1 = require("../symbol-rows");
+const error_record_1 = require("../error-record");
+const analysis_rows_1 = require("./analysis-rows");
+const SCHEMA_EXTENSIONS = /\.(prisma|graphql|gql)$/;
+const JSX_EXTENSIONS = /\.(tsx|jsx|js)$/;
+class FileIngestor {
+    store;
+    chunkEmbedder;
+    chunker;
+    config;
+    logger;
+    constructor(store, chunkEmbedder, chunker, config, logger) {
+        this.store = store;
+        this.chunkEmbedder = chunkEmbedder;
+        this.chunker = chunker;
+        this.config = config;
+        this.logger = logger;
+    }
+    static hashContent(content) {
+        return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    }
+    async ingestFile(filePath, serviceName, mtimeMs, projectRoot, analysis) {
+        try {
+            const relFilePath = path.relative(this.config.workspaceRoot, filePath);
+            const existing = await this.store.fileState(serviceName, relFilePath);
+            if (existing?.lastModified === mtimeMs) {
+                return { status: 'skipped', chunks: 0 };
+            }
+            const t0 = Date.now();
+            const code = fs.readFileSync(filePath, 'utf-8');
+            const hash = FileIngestor.hashContent(code);
+            if (existing !== undefined && existing.contentHash !== null && existing.contentHash === hash) {
+                return { status: 'skipped', chunks: 0, pendingMtimeRefresh: relFilePath };
+            }
+            const tAst = Date.now();
+            const { edges: rawEdges, symbols: rawSymbols, members: rawMembers = [], calls: rawCalls, graphqlNames: rawGraphqlNames = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
+            const edges = (0, analysis_rows_1.workspaceEdges)(rawEdges, this.config.workspaceRoot);
+            const calls = (0, analysis_rows_1.workspaceCalls)(rawCalls, serviceName, relFilePath, this.config.workspaceRoot);
+            const symbolRows = (0, symbol_rows_1.buildSymbolRows)(rawSymbols, rawMembers, rawGraphqlNames).map(s => ({ ...s, filePath: relFilePath }));
+            const promptEdges = (0, analysis_rows_1.toPromptEdges)(edges);
+            const astMs = Date.now() - tAst;
+            const jsx = JSX_EXTENSIONS.test(filePath);
+            const chunks = await this.chunker.chunk(code, {
+                strategy: this.config.indexer.chunkStrategy,
+                isSchemaFile: SCHEMA_EXTENSIONS.test(filePath),
+                declarations: analysis?.declarations,
+                jsx,
+            });
+            const relPath = path.relative(projectRoot, filePath);
+            const sourceLines = new SourceLines_1.SourceLines(code, { jsx });
+            const ownerTree = analysis?.declarations ?? DeclarationTree_1.DeclarationTree.EMPTY;
+            const t2 = Date.now();
+            const records = await this.chunkEmbedder.records(chunks, {
+                serviceName, relFilePath, relPath, promptEdges, rawSymbols, mtimeMs, hash, ownerTree, sourceLines,
+            });
+            const embedMs = Date.now() - t2;
+            const t3 = Date.now();
+            await this.store.writeFile(serviceName, relFilePath, records, edges, symbolRows, calls);
+            const dbMs = Date.now() - t3;
+            if (chunks.length > 0) {
+                this.logger.debug('IndexerService: file indexed', {
+                    file: relFilePath, chunks: chunks.length,
+                    astMs, embedMs, dbMs, totalMs: Date.now() - t0,
+                });
+            }
+            return { status: 'indexed', chunks: chunks.length };
+        }
+        catch (err) {
+            console.error(`\n[indexer] Failed: ${filePath} — ${(0, error_record_1.rootCauseMessage)(err)}`);
+            this.logger.error('IndexerService: failed to index file', { file: filePath, err });
+            return { status: 'failed', chunks: 0 };
+        }
+    }
+}
+exports.FileIngestor = FileIngestor;

package/dist/src/indexing/IndexStore.d.ts

@@ -0,0 +1,24 @@
+import type { Config } from '../config';
+import type { DepEdge } from '../interfaces/IAstParser';
+import type { IDatabase } from '../interfaces/IDatabase';
+import { codeSymbol, codeCall } from '../db';
+import type { CodeChunkInsert } from '../db';
+export type CodeSymbolInsert = typeof codeSymbol.$inferInsert;
+export type CodeCallInsert = typeof codeCall.$inferInsert;
+export declare class IndexStore {
+    private db;
+    private config;
+    constructor(db: IDatabase, config: Config);
+    resetProject(serviceName: string): Promise<void>;
+    fileState(serviceName: string, relFilePath: string): Promise<{
+        id: string;
+        lastModified: number | null;
+        contentHash: string | null;
+    }>;
+    writeFile(serviceName: string, relFilePath: string, records: CodeChunkInsert[], edges: DepEdge[], symbolRows: CodeSymbolInsert[], calls: CodeCallInsert[]): Promise<void>;
+    refreshMtimes(serviceName: string, batch: Array<{
+        relFilePath: string;
+        mtimeMs: number;
+    }>): Promise<void>;
+    private writeDepEdges;
+}

package/dist/src/indexing/IndexStore.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexStore = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const db_1 = require("../db");
+class IndexStore {
+    db;
+    config;
+    constructor(db, config) {
+        this.db = db;
+        this.config = config;
+    }
+    async resetProject(serviceName) {
+        await this.db.transaction(async (tx) => {
+            await tx.update(db_1.codeChunk)
+                .set({ lastModified: null, contentHash: null })
+                .where((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, serviceName));
+            await tx.delete(db_1.codeSymbol).where((0, drizzle_orm_1.eq)(db_1.codeSymbol.project, serviceName));
+            await tx.delete(db_1.codeCall).where((0, drizzle_orm_1.eq)(db_1.codeCall.project, serviceName));
+        });
+    }
+    async fileState(serviceName, relFilePath) {
+        const [existing] = await this.db.orm
+            .select({ id: db_1.codeChunk.id, lastModified: db_1.codeChunk.lastModified, contentHash: db_1.codeChunk.contentHash })
+            .from(db_1.codeChunk)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, serviceName), (0, drizzle_orm_1.eq)(db_1.codeChunk.filePath, relFilePath)))
+            .limit(1);
+        return existing;
+    }
+    async writeFile(serviceName, relFilePath, records, edges, symbolRows, calls) {
+        await this.db.transaction(async (tx) => {
+            await tx.delete(db_1.codeChunk).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, serviceName), (0, drizzle_orm_1.eq)(db_1.codeChunk.filePath, relFilePath)));
+            for (let i = 0; i < records.length; i += this.config.indexer.batchSize) {
+                await tx.insert(db_1.codeChunk).values(records.slice(i, i + this.config.indexer.batchSize));
+            }
+            await this.writeDepEdges(serviceName, relFilePath, edges, tx);
+            await tx.delete(db_1.codeSymbol).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeSymbol.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeSymbol.filePath, relFilePath)));
+            if (symbolRows.length > 0) {
+                await tx.insert(db_1.codeSymbol).values(symbolRows);
+            }
+            await tx.delete(db_1.codeCall).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeCall.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeCall.fromFile, relFilePath)));
+            if (calls.length > 0) {
+                await tx.insert(db_1.codeCall).values(calls);
+            }
+        });
+    }
+    async refreshMtimes(serviceName, batch) {
+        await this.db.query(`UPDATE code_chunk SET "lastModified" = t.mtime
+           FROM unnest($1::text[], $2::float8[]) AS t(fp, mtime)
+           WHERE "serviceName" = $3 AND "filePath" = t.fp`, [
+            batch.map(r => r.relFilePath),
+            batch.map(r => r.mtimeMs),
+            serviceName,
+        ]);
+    }
+    async writeDepEdges(serviceName, relFilePath, edges, tx) {
+        const run = async (t) => {
+            await t.delete(db_1.codeDependency).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeDependency.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeDependency.fromFile, relFilePath)));
+            if (edges.length > 0) {
+                await t.insert(db_1.codeDependency).values(edges);
+            }
+        };
+        if (tx)
+            await run(tx);
+        else
+            await this.db.transaction(run);
+    }
+}
+exports.IndexStore = IndexStore;

package/dist/src/indexing/StaleFilePruner.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../config';
+import type { IDatabase } from '../interfaces/IDatabase';
+export declare class StaleFilePruner {
+    private db;
+    private config;
+    constructor(db: IDatabase, config: Config);
+    prune(serviceName: string, files: string[]): Promise<string[]>;
+}

package/dist/src/indexing/StaleFilePruner.js

@@ -0,0 +1,55 @@
+"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.StaleFilePruner = void 0;
+const path = __importStar(require("path"));
+class StaleFilePruner {
+    db;
+    config;
+    constructor(db, config) {
+        this.db = db;
+        this.config = config;
+    }
+    async prune(serviceName, files) {
+        const collectedRelPaths = new Set(files.map(f => path.relative(this.config.workspaceRoot, f)));
+        const knownFiles = await this.db.listKnownFiles(serviceName);
+        const staleFiles = knownFiles.filter(f => !collectedRelPaths.has(f));
+        if (staleFiles.length > 0) {
+            await this.db.deleteFiles(serviceName, staleFiles);
+        }
+        return staleFiles;
+    }
+}
+exports.StaleFilePruner = StaleFilePruner;

package/dist/src/indexing/analysis-rows.d.ts

@@ -0,0 +1,4 @@
+import type { CallEdge, DepEdge } from '../interfaces/IAstParser';
+export declare function workspaceEdges(rawEdges: DepEdge[], workspaceRoot: string): DepEdge[];
+export declare function workspaceCalls(rawCalls: CallEdge[], serviceName: string, relFilePath: string, workspaceRoot: string): CallEdge[];
+export declare function toPromptEdges(edges: DepEdge[]): DepEdge[];