codesearch-mcp 0.1.0-alpha → 0.2.1-alpha

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

@@ -6,6 +6,7 @@ import * as schema from '../db/schema';
 type Schema = typeof schema;
 export type DrizzleDb = NodePgDatabase<Schema>;
 export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
+export declare const CURRENT_SYMBOL_INDEX_VERSION = 2;
 export declare class DatabaseService implements IDatabase {
     private config;
     private pool;
@@ -27,8 +28,24 @@ export declare class DatabaseService implements IDatabase {
     recreateChunkTable(dimensions: number): Promise<void>;
     readIndexMeta(): Promise<IndexMeta | null>;
     writeIndexMeta(meta: IndexMeta): Promise<void>;
+    listKnownFiles(project: string): Promise<string[]>;
+    deleteFiles(project: string, filePaths: string[]): Promise<void>;
+    listIndexedProjects(): Promise<string[]>;
+    deleteProject(name: string): Promise<void>;
+    listProjectsWithIndexRows(): Promise<string[]>;
+    /**
+     * Among `projectNames` (or every project with rows when null), those with at
+     * least one row in `code_chunk`/`code_symbol` and a `symbol_index_version`
+     * below `CURRENT_SYMBOL_INDEX_VERSION` (a missing row counts as version 1).
+     * A missing `symbol_index_version` table (un-migrated DB, `rag-mcp`/`rag-web`
+     * bootstrapped with `initDb`) counts as "no marker rows" — every project with
+     * rows is then outdated. Any other database error propagates.
+     */
+    listOutdatedProjects(projectNames: string[] | null): Promise<string[]>;
+    upsertSymbolIndexVersion(project: string): Promise<void>;
     /** Guard against SQL injection — the dimension is interpolated into DDL. */
     private assertDim;
+    private assertMinPostgresVersion;
     private ensureDatabaseExists;
 }
 export {};

package/dist/src/services/DatabaseService.js

@@ -33,10 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseService = void 0;
+exports.DatabaseService = exports.CURRENT_SYMBOL_INDEX_VERSION = void 0;
 const node_postgres_1 = require("drizzle-orm/node-postgres");
 const pg_1 = require("pg");
+const drizzle_orm_1 = require("drizzle-orm");
 const schema = __importStar(require("../db/schema"));
+const db_1 = require("../db");
+const MIN_PG_VERSION_NUM = 150000;
+exports.CURRENT_SYMBOL_INDEX_VERSION = 2;
 class DatabaseService {
     config;
     pool;
@@ -66,6 +70,12 @@ class DatabaseService {
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
         await this.initDb();
+        // Read as the very first statement on the application database, before any
+        // CREATE TABLE / CREATE INDEX / ALTER TABLE / DROP — `NULLS NOT DISTINCT`
+        // (used below) requires PostgreSQL 15+, and the DROP/CREATE pair must never
+        // run against an older server (it would fail after the DROP and leave
+        // code_symbol without a unique index).
+        await this.assertMinPostgresVersion();
         // code_chunk table — created at the legacy default width (1024) so search
         // tools always have a table. IndexerService recreates it at the resolved
         // width before indexing when the active model's dimension differs.
@@ -128,7 +138,23 @@ class DatabaseService {
         }
         await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name   ON code_symbol (name, project)`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file   ON code_symbol (project, "filePath")`);
-        await this.query(`CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique ON code_symbol (project, "filePath", name, kind)`);
+        await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS container TEXT`);
+        await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "isStatic" BOOLEAN NOT NULL DEFAULT false`);
+        // DDL is transactional in PostgreSQL — either both statements apply or
+        // neither does, so a failure here never leaves code_symbol without a
+        // unique index (the old idx_symbol_unique is dropped only once the new
+        // one is confirmed to exist).
+        await this.transaction(async (tx) => {
+            await tx.execute('DROP INDEX IF EXISTS idx_symbol_unique');
+            await tx.execute('CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique_v2 ' +
+                'ON code_symbol (project, "filePath", container, name, kind, line) NULLS NOT DISTINCT');
+        });
+        await this.query(`
+      CREATE TABLE IF NOT EXISTS symbol_index_version (
+        project TEXT PRIMARY KEY,
+        version INT NOT NULL
+      )
+    `);
         // code_call table
         await this.query(`
       CREATE TABLE IF NOT EXISTS code_call (
@@ -198,6 +224,94 @@ class DatabaseService {
              dimensions = EXCLUDED.dimensions,
              "indexedAt" = now()`, [meta.provider, meta.model, meta.dimensions]);
     }
+    async listKnownFiles(project) {
+        const rows = await this.query(`SELECT "filePath" AS fp FROM code_chunk      WHERE "serviceName" = $1
+       UNION
+       SELECT "filePath" AS fp FROM code_symbol     WHERE project = $1
+       UNION
+       SELECT "fromFile" AS fp FROM code_call       WHERE project = $1
+       UNION
+       SELECT "fromFile" AS fp FROM code_dependency WHERE project = $1`, [project]);
+        return rows.map(r => r.fp);
+    }
+    async deleteFiles(project, filePaths) {
+        if (filePaths.length === 0)
+            return;
+        // PostgreSQL limits ~32 767 bind params per statement; OR queries bind the
+        // array twice (fromFile + calleeFile), so cap each batch at 10 000 entries.
+        const BATCH = 10_000;
+        await this.transaction(async (tx) => {
+            for (let i = 0; i < filePaths.length; i += BATCH) {
+                const batch = filePaths.slice(i, i + BATCH);
+                await tx.delete(db_1.codeChunk).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, project), (0, drizzle_orm_1.inArray)(db_1.codeChunk.filePath, batch)));
+                await tx.delete(db_1.codeSymbol).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeSymbol.project, project), (0, drizzle_orm_1.inArray)(db_1.codeSymbol.filePath, batch)));
+                await tx.delete(db_1.codeCall).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeCall.project, project), (0, drizzle_orm_1.or)((0, drizzle_orm_1.inArray)(db_1.codeCall.fromFile, batch), (0, drizzle_orm_1.inArray)(db_1.codeCall.calleeFile, batch))));
+                await tx.delete(db_1.codeDependency).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeDependency.project, project), (0, drizzle_orm_1.or)((0, drizzle_orm_1.inArray)(db_1.codeDependency.fromFile, batch), (0, drizzle_orm_1.inArray)(db_1.codeDependency.toFile, batch))));
+            }
+        });
+    }
+    async listIndexedProjects() {
+        const rows = await this.query(`SELECT "serviceName" AS name FROM code_chunk
+       UNION
+       SELECT project AS name FROM code_symbol
+       UNION
+       SELECT project AS name FROM code_call
+       UNION
+       SELECT project AS name FROM code_dependency`);
+        return rows.map(r => r.name);
+    }
+    async deleteProject(name) {
+        await this.transaction(async (tx) => {
+            await tx.delete(db_1.codeChunk).where((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, name));
+            await tx.delete(db_1.codeSymbol).where((0, drizzle_orm_1.eq)(db_1.codeSymbol.project, name));
+            await tx.delete(db_1.codeCall).where((0, drizzle_orm_1.eq)(db_1.codeCall.project, name));
+            await tx.delete(db_1.codeDependency).where((0, drizzle_orm_1.eq)(db_1.codeDependency.project, name));
+        });
+    }
+    async listProjectsWithIndexRows() {
+        const rows = await this.query(`SELECT DISTINCT name FROM (
+         SELECT "serviceName" AS name FROM code_chunk
+         UNION
+         SELECT project AS name FROM code_symbol
+       ) t`);
+        return rows.map(r => r.name);
+    }
+    /**
+     * Among `projectNames` (or every project with rows when null), those with at
+     * least one row in `code_chunk`/`code_symbol` and a `symbol_index_version`
+     * below `CURRENT_SYMBOL_INDEX_VERSION` (a missing row counts as version 1).
+     * A missing `symbol_index_version` table (un-migrated DB, `rag-mcp`/`rag-web`
+     * bootstrapped with `initDb`) counts as "no marker rows" — every project with
+     * rows is then outdated. Any other database error propagates.
+     */
+    async listOutdatedProjects(projectNames) {
+        const rowsUnion = `
+      SELECT "serviceName" AS name FROM code_chunk
+      UNION
+      SELECT project AS name FROM code_symbol
+    `;
+        const filterSql = projectNames ? 'AND t.name = ANY($1)' : '';
+        const params = projectNames ? [projectNames] : [];
+        try {
+            const rows = await this.query(`SELECT DISTINCT t.name FROM (${rowsUnion}) t
+         WHERE NOT EXISTS (
+           SELECT 1 FROM symbol_index_version v
+           WHERE v.project = t.name AND v.version >= ${exports.CURRENT_SYMBOL_INDEX_VERSION}
+         )
+         ${filterSql}`, params);
+            return rows.map(r => r.name);
+        }
+        catch (err) {
+            if (!/relation "symbol_index_version" does not exist/i.test(err.message))
+                throw err;
+            const rows = await this.query(`SELECT DISTINCT t.name FROM (${rowsUnion}) t ${projectNames ? 'WHERE t.name = ANY($1)' : ''}`, params);
+            return rows.map(r => r.name);
+        }
+    }
+    async upsertSymbolIndexVersion(project) {
+        await this.query(`INSERT INTO symbol_index_version (project, version) VALUES ($1, $2)
+       ON CONFLICT (project) DO UPDATE SET version = EXCLUDED.version`, [project, exports.CURRENT_SYMBOL_INDEX_VERSION]);
+    }
     /** Guard against SQL injection — the dimension is interpolated into DDL. */
     assertDim(dimensions) {
         if (!Number.isInteger(dimensions) || dimensions <= 0 || dimensions > 2000) {
@@ -205,6 +319,20 @@ class DatabaseService {
         }
         return dimensions;
     }
+    async assertMinPostgresVersion() {
+        let versionNum;
+        try {
+            const rows = await this.query(`SELECT current_setting('server_version_num') AS v`);
+            versionNum = Number(rows[0]?.v);
+        }
+        catch (err) {
+            throw new Error(`Failed to read PostgreSQL server_version_num (requires PostgreSQL 15+): ${err.message}`);
+        }
+        if (!Number.isFinite(versionNum) || versionNum < MIN_PG_VERSION_NUM) {
+            throw new Error(`PostgreSQL 15+ is required (server_version_num=${versionNum}) — ` +
+                `the symbol index's unique index relies on NULLS NOT DISTINCT, added in PostgreSQL 15.`);
+        }
+    }
     async ensureDatabaseExists() {
         const { host, port, username, password, database } = this.config.db;
         const client = new pg_1.Client({ host, port, user: username, password, database: 'postgres' });

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

@@ -4,6 +4,6 @@ import type { ILogger } from '../interfaces/ILogger';
 import { type EmbedderDeps } from './OpenAICompatibleEmbedder';
 /**
  * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
- * The default (`ollama`) keeps existing installs working unchanged.
+ * The default (`infinity`) is the recommended local backend.
  */
 export declare function createEmbedder(config: Config, logger?: ILogger, deps?: EmbedderDeps): IEmbedder;

package/dist/src/services/EmbedderFactory.js

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEmbedder = createEmbedder;
 const LoggerService_1 = require("./LoggerService");
-const OllamaEmbedder_1 = require("./OllamaEmbedder");
 const OpenAICompatibleEmbedder_1 = require("./OpenAICompatibleEmbedder");
 const InfinityEmbedder_1 = require("./InfinityEmbedder");
 const VoyageEmbedder_1 = require("./VoyageEmbedder");
 /**
  * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
- * The default (`ollama`) keeps existing installs working unchanged.
+ * The default (`infinity`) is the recommended local backend.
  */
 function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
     switch (config.embedding.provider) {
@@ -18,12 +17,10 @@ function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(),
             return new InfinityEmbedder_1.InfinityEmbedder(config, logger, deps);
         case 'voyage':
             return new VoyageEmbedder_1.VoyageEmbedder(config, logger, deps);
-        case 'ollama':
-            return new OllamaEmbedder_1.OllamaEmbedder(config, logger, deps);
         default: {
             // The Zod enum should already reject this; guard anyway for a clear message.
             const p = config.embedding.provider;
-            throw new Error(`Unknown embedding provider: "${p}". Expected one of: ollama, openai-compatible, voyage, infinity.`);
+            throw new Error(`Unknown embedding provider: "${p}". Expected one of: openai-compatible, voyage, infinity.`);
         }
     }
 }

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

@@ -35,24 +35,14 @@ export declare class IndexerService {
     prepareEmbeddingSchema(): Promise<IndexMeta>;
     private reconcileIndex;
     private countChunks;
-    backfillSymbols(signal?: AbortSignal): Promise<{
-        total: number;
-        processed: number;
-        skipped: number;
-        failed: number;
-    }>;
-    backfillCalls(signal?: AbortSignal): Promise<{
-        total: number;
-        processed: number;
-        skipped: number;
-        failed: number;
-    }>;
     private writeDepEdges;
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
         rootTsConfigPath?: string;
     }): Promise<IndexStats>;
-    private static inferRole;
-    private getEnrichedPrompt;
+    pruneProjects(keep: string[]): Promise<{
+        removed: string[];
+        failed: string[];
+    }>;
     private static hashContent;
     private ingestFile;
 }

package/dist/src/services/IndexerService.js

@@ -40,6 +40,8 @@ const crypto_1 = require("crypto");
 const cli_progress_1 = require("cli-progress");
 const drizzle_orm_1 = require("drizzle-orm");
 const owner_path_1 = require("../owner-path");
+const enriched_prompt_1 = require("../enriched-prompt");
+const symbol_rows_1 = require("../symbol-rows");
 const db_1 = require("../db");
 const file_utils_1 = require("../file-utils");
 const LoggerService_1 = require("./LoggerService");
@@ -124,97 +126,6 @@ class IndexerService {
             throw err;
         }
     }
-    async backfillSymbols(signal) {
-        const t0 = Date.now();
-        const rows = await this.db.query(`SELECT DISTINCT "serviceName", "filePath" FROM code_chunk ORDER BY "serviceName", "filePath"`);
-        this.logger.debug('IndexerService: backfillSymbols start', { total: rows.length });
-        let processed = 0, skipped = 0, failed = 0;
-        for (const { serviceName, filePath } of rows) {
-            if (signal?.aborted)
-                break;
-            const absPath = path.join(this.config.workspaceRoot, filePath);
-            const projectRoot = path.join(this.config.workspaceRoot, serviceName);
-            if (!fs.existsSync(absPath)) {
-                skipped++;
-                continue;
-            }
-            try {
-                const { symbols: rawSymbols } = await this.ast.analyzeFile(absPath, serviceName, projectRoot);
-                const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath })).map(s => [`${s.name}:${s.kind}`, s])).values()].map(({ project, filePath: fp, name, kind, signature, line, col }) => ({ project, filePath: fp, name, kind, signature, line, col }));
-                await this.db.transaction(async (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, filePath)));
-                    if (symbols.length > 0) {
-                        await tx.insert(db_1.codeSymbol).values(symbols);
-                    }
-                });
-                processed++;
-            }
-            catch (err) {
-                const reason = err.message;
-                console.error(`  Failed: ${filePath} — ${reason}`);
-                this.logger.error('IndexerService: symbol backfill failed', { file: filePath, reason });
-                failed++;
-            }
-            const count = processed + failed;
-            if (count > 0 && count % 50 === 0) {
-                const msg = `  ${count}/${rows.length} files...`;
-                process.stdout.isTTY ? process.stdout.write(msg + '\r') : console.log(msg);
-            }
-        }
-        this.logger.debug('IndexerService: backfillSymbols done', { total: rows.length, processed, skipped, failed, ms: Date.now() - t0 });
-        return { total: rows.length, processed, skipped, failed };
-    }
-    async backfillCalls(signal) {
-        const t0 = Date.now();
-        const rows = await this.db.query(`SELECT DISTINCT "serviceName", "filePath" FROM code_chunk ORDER BY "serviceName", "filePath"`);
-        this.logger.debug('IndexerService: backfillCalls start', { total: rows.length });
-        let processed = 0, skipped = 0, failed = 0;
-        for (const { serviceName, filePath } of rows) {
-            if (signal?.aborted)
-                break;
-            const absPath = path.join(this.config.workspaceRoot, filePath);
-            const projectRoot = path.join(this.config.workspaceRoot, serviceName);
-            if (!fs.existsSync(absPath)) {
-                skipped++;
-                continue;
-            }
-            try {
-                const { calls: rawCalls } = await this.ast.analyzeFile(absPath, serviceName, projectRoot);
-                const calls = rawCalls
-                    .filter(c => c.calleeFile.startsWith(this.config.workspaceRoot))
-                    .map(c => ({
-                    project: serviceName,
-                    fromFile: filePath,
-                    fromSymbol: c.fromSymbol,
-                    calleeName: c.calleeName,
-                    calleeFile: path.relative(this.config.workspaceRoot, c.calleeFile),
-                    calleeSymbol: c.calleeSymbol,
-                    line: c.line,
-                    col: c.col,
-                }));
-                await this.db.transaction(async (tx) => {
-                    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, filePath)));
-                    if (calls.length > 0) {
-                        await tx.insert(db_1.codeCall).values(calls);
-                    }
-                });
-                processed++;
-            }
-            catch (err) {
-                const reason = err.message;
-                console.error(`  Failed: ${filePath} — ${reason}`);
-                this.logger.error('IndexerService: call backfill failed', { file: filePath, reason });
-                failed++;
-            }
-            const count = processed + failed;
-            if (count > 0 && count % 50 === 0) {
-                const msg = `  ${count}/${rows.length} files...`;
-                process.stdout.isTTY ? process.stdout.write(msg + '\r') : console.log(msg);
-            }
-        }
-        this.logger.debug('IndexerService: backfillCalls done', { total: rows.length, processed, skipped, failed, ms: Date.now() - t0 });
-        return { total: rows.length, processed, skipped, failed };
-    }
     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)));
@@ -231,18 +142,26 @@ class IndexerService {
         const startTime = Date.now();
         this.logger.debug('IndexerService: scanAndIndex start', { serviceName, dir, force });
         if (force) {
-            await this.db.query(`UPDATE code_chunk SET "lastModified" = NULL, "contentHash" = NULL WHERE "serviceName" = $1`, [serviceName]);
+            // Reset incremental state and clear the project's symbol/call rows in one
+            // transaction: a file whose re-ingestion later fails must hold no rows at
+            // all, never rows in the previous (pre-member-extraction) format.
+            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));
+            });
         }
         const files = preCollectedFiles ?? (0, file_utils_1.collectFiles)(dir, (0, file_utils_1.loadIgnore)(dir), dir);
         this.logger.debug('IndexerService: scanAndIndex files collected', { serviceName, count: files.length, force });
         const collectedRelPaths = new Set(files.map(f => path.relative(this.config.workspaceRoot, f)));
-        const dbPaths = await this.db.query(`SELECT DISTINCT "filePath" FROM code_chunk WHERE "serviceName" = $1`, [serviceName]);
-        for (const { filePath } of dbPaths) {
-            if (!collectedRelPaths.has(filePath)) {
-                await this.db.transaction(tx => 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, filePath))));
-                await this.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "fromFile" = $2`, [serviceName, filePath]);
-                await this.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "toFile" = $2`, [serviceName, filePath]);
-                console.log(`  Removed stale: ${path.basename(filePath)}`);
+        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);
+            for (const f of staleFiles) {
+                console.log(`  Removed stale: ${path.basename(f)}`);
             }
         }
         const bar = new cli_progress_1.SingleBar({
@@ -335,6 +254,12 @@ class IndexerService {
             }
         }
         this.ast.clearCache(dir);
+        // The marker is written exactly when the scan reaches here without having
+        // been interrupted — never on the early-return abort path above, and never
+        // when anything in this method throws (the error propagates instead).
+        if (!signal?.aborted) {
+            await this.db.upsertSymbolIndexVersion(serviceName);
+        }
         stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
         this.logger.debug('IndexerService: project indexed', {
             project: serviceName,
@@ -346,50 +271,26 @@ class IndexerService {
         });
         return stats;
     }
-    static inferRole(relPath) {
-        const p = relPath.toLowerCase();
-        if (p.includes('/services/') || p.endsWith('.service.ts'))
-            return 'Service';
-        if (p.includes('/controllers/') || p.endsWith('.controller.ts'))
-            return 'Controller';
-        if (p.includes('/entities/') || p.endsWith('.entity.ts'))
-            return 'Entity';
-        if (p.includes('/guards/') || p.endsWith('.guard.ts'))
-            return 'Guard';
-        if (p.includes('/commands/'))
-            return 'Command';
-        if (p.includes('/interfaces/'))
-            return 'Interface';
-        if (p.includes('/middleware/'))
-            return 'Middleware';
-        if (p.includes('/interceptors/'))
-            return 'Interceptor';
-        if (p.endsWith('.test.ts') || p.endsWith('.spec.ts') || p.includes('/tests/'))
-            return 'Test';
-        if (p.includes('/utils/') || p.includes('/helpers/') || p.endsWith('-utils.ts'))
-            return 'Utility';
-        return null;
-    }
-    getEnrichedPrompt(piece, relPath, serviceName, _meta, edges, symbols) {
-        const chunkStart = piece.startLine;
-        const chunkEnd = piece.endLine;
-        const lines = [];
-        lines.push(`Project: ${serviceName} | File: ${relPath}`);
-        const role = IndexerService.inferRole(relPath);
-        if (role)
-            lines.push(`Role: ${role}`);
-        const overlapping = symbols.filter(s => s.line != null &&
-            s.line <= chunkEnd &&
-            (s.endLine ?? s.line) >= chunkStart);
-        if (overlapping.length > 0) {
-            lines.push(`Symbols: ${overlapping.map(s => `${s.kind} ${s.name}`).join(', ')}`);
-        }
-        if (edges.length > 0) {
-            const depNames = [...new Set(edges.map(e => path.basename(e.toFile, path.extname(e.toFile)).split('.')[0]))];
-            lines.push(`Dependencies: ${depNames.join(', ')}`);
+    async pruneProjects(keep) {
+        if (keep.length === 0)
+            return { removed: [], failed: [] };
+        const indexed = await this.db.listIndexedProjects();
+        const keepSet = new Set(keep);
+        const toRemove = indexed.filter(name => !keepSet.has(name));
+        const removed = [];
+        const failed = [];
+        for (const name of toRemove) {
+            try {
+                await this.db.deleteProject(name);
+                removed.push(name);
+            }
+            catch (err) {
+                console.error(`Failed to prune project ${name}: ${err.message}`);
+                this.logger.error('IndexerService: pruneProject failed', { name, reason: err.message });
+                failed.push(name);
+            }
         }
-        lines.push(`Code: ${piece.content}`);
-        return lines.join('\n');
+        return { removed, failed };
     }
     static hashContent(content) {
         return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
@@ -414,7 +315,7 @@ class IndexerService {
                 return { status: 'skipped', chunks: 0, pendingMtimeRefresh: relFilePath };
             }
             const tAst = Date.now();
-            const { edges: rawEdges, symbols: rawSymbols, calls: rawCalls, ownerRanges: rawOwnerRanges = [] } = analysis ?? { edges: [], symbols: [], calls: [] };
+            const { edges: rawEdges, symbols: rawSymbols, members: rawMembers = [], calls: rawCalls, ownerRanges: rawOwnerRanges = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
             // astMs is near-zero — actual AST time is spent upfront in analyzeProject()
             // Normalize edges to workspace-relative paths
             const edges = rawEdges
@@ -437,8 +338,9 @@ class IndexerService {
                 line: c.line,
                 col: c.col,
             }));
-            // Normalize symbols: replace absolute filePath with workspace-relative, strip endLine (not stored)
-            const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath: relFilePath })).map(s => [`${s.name}:${s.kind}`, s])).values()].map(({ project, filePath: fp, name, kind, signature, line, col }) => ({ project, filePath: fp, name, kind, signature, line, col }));
+            // symbols ∪ members → code_symbol rows: overload sets collapse to their
+            // representative row, then a final dedup by (container, name, kind, line).
+            const symbolRows = (0, symbol_rows_1.buildSymbolRows)(rawSymbols, rawMembers).map(s => ({ ...s, filePath: relFilePath }));
             const astMs = Date.now() - tAst;
             const chunks = await this.chunker.chunk(code, {
                 strategy: this.config.indexer.chunkStrategy,
@@ -446,20 +348,16 @@ class IndexerService {
                 symbols: rawSymbols,
             });
             const relPath = path.relative(projectRoot, filePath);
-            // Owner-path ranges: top-level symbols (container: null) + method ranges.
-            // Deepest range containing a chunk's start line wins → Class.method.
-            const ownerRanges = [
-                ...rawSymbols
-                    .filter(s => s.line != null)
-                    .map(s => ({ name: s.name, container: null, line: s.line, endLine: s.endLine ?? s.line })),
-                ...rawOwnerRanges,
-            ];
+            // Ownership ranges (decorator-inclusive, symbols ∪ members minus
+            // method_signature) are built by AstParserService — the deepest range
+            // containing a chunk's start line wins.
+            const ownerRanges = rawOwnerRanges;
             const t2 = Date.now();
             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 => this.getEnrichedPrompt(piece, relPath, serviceName, meta ?? 'missing', edges, rawSymbols));
+                const prompts = batch.map(piece => (0, enriched_prompt_1.getEnrichedPrompt)(piece, relPath, serviceName, edges, rawSymbols));
                 const vectors = await this.embedder.embedBatch(prompts, 'document');
                 for (let j = 0; j < batch.length; j++) {
                     const piece = batch[j];
@@ -482,8 +380,8 @@ class IndexerService {
                 }
                 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 (symbols.length > 0) {
-                    await tx.insert(db_1.codeSymbol).values(symbols);
+                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) {

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

@@ -1,79 +1,38 @@
 import type { Config } from '../config';
 import type { ILogger } from '../interfaces/ILogger';
 import { OpenAICompatibleEmbedder, type EmbedderDeps } from './OpenAICompatibleEmbedder';
-/** Result of a shell command run, mirroring the parts of `spawnSync` we use. */
-export interface CommandResult {
-    status: number | null;
-    stdout?: string;
-}
-/**
- * Extra injection seams for `InfinityEmbedder` beyond the shared `EmbedderDeps`.
- * All optional and defaulted to the real implementations; tests inject fakes so
- * `ensureModelAvailable()` runs without a live Infinity server or Docker.
- */
-export interface InfinityDeps extends EmbedderDeps {
-    /** Runs a shell command (docker), optionally with extra env. Defaults to `spawnSync`. */
-    runCommand?: (cmd: string, args: string[], env?: Record<string, string>) => CommandResult;
+import { serverRoot, probeInfinityHealth, listInfinityModels, type ProvisioningDeps } from './infinity-provisioning';
+export { serverRoot, probeInfinityHealth, listInfinityModels };
+export type { CommandResult } from './infinity-provisioning';
+/** Extra injection seams for `InfinityEmbedder` beyond the shared `EmbedderDeps`. */
+export interface InfinityDeps extends EmbedderDeps, ProvisioningDeps {
     /**
      * Path to the managed docker-compose.yml. Defaults to the file `rag-setup`
      * writes into `~/.config/codesearch-mcp/`. A missing file (or one without an
      * `infinity` service) means "external backend" — the Docker path is skipped.
      */
     composePath?: string;
-    /** Sleep between readiness polls (ms). Defaults to 2000; tests pass 0. */
-    pollIntervalMs?: number;
 }
-/**
- * Strip trailing slashes and a trailing `/embeddings` or `/v1` to get the server
- * root — Infinity serves `/health`, `/models`, `/rerank`, `/embeddings` from the
- * root, so a baseURL written with an OpenAI-style suffix must be normalized here
- * to keep the probe/models URLs aligned with the embeddings URL.
- */
-export declare function serverRoot(baseURL: string): string;
-/**
- * Probe an Infinity-style `/health` endpoint. Resolves `true` when the server
- * answers with a 2xx, `false` on any error or non-2xx. Reused by setup's
- * `waitForInfinity`.
- */
-export declare function probeInfinityHealth(baseURL: string, fetchImpl?: typeof fetch, timeoutMs?: number): Promise<boolean>;
-/**
- * List the model ids an Infinity server currently serves via its OpenAI-style
- * `/models` listing (`{ data: [{ id }] }`). Returns `[]` on any error.
- */
-export declare function listInfinityModels(baseURL: string, fetchImpl?: typeof fetch, timeoutMs?: number): Promise<string[]>;
 /**
  * Embedder for a local Infinity server. Inherits the OpenAI-style `/embeddings`
  * HTTP path, batching, retry, and reranker wiring from `OpenAICompatibleEmbedder`
- * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`),
+ * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`,
+ * `listModels`), delegating to the standalone `infinity-provisioning` primitive
  * because Infinity binds its model set at container startup and exposes no
  * runtime model-pull API.
  */
 export declare class InfinityEmbedder extends OpenAICompatibleEmbedder {
     private readonly base;
-    private readonly doFetchImpl;
-    private readonly runCommand;
     private readonly composePath;
-    private readonly pollIntervalMs;
-    private readonly log;
+    private readonly provisioningDeps;
     constructor(config: Config, logger?: ILogger, deps?: InfinityDeps);
-    private isHealthy;
-    private servedModels;
-    /** True when a managed compose file exists AND declares an `infinity` service. */
-    private hasManagedService;
     /**
-     * Bring the Infinity backend to a serving state per the D4 decision tree:
-     *   healthy + model served      → OK
-     *   healthy + model NOT served  → throw (restart container with correct --model-id)
-     *   unreachable + managed        → `docker compose up -d infinity`, wait /health
-     *   unreachable + external       → print manual instructions (no Docker touched)
-     *
-     * Called by `IndexCommand` before `prepareEmbeddingSchema()`.
+     * Index-time embed readiness (see `local-backend-provisioning`): verifies only
+     * the embedding model — indexing does not use the reranker, so a missing
+     * reranker model never blocks or restarts indexing. Whenever a recreate is
+     * needed, the full configured set is written so an already-served reranker
+     * model is never dropped. Called by `IndexCommand` before indexing.
      */
     ensureModelAvailable(): Promise<void>;
-    /**
-     * Poll `/health` until ready or the timeout elapses. Generous default (30 min)
-     * because a CPU first boot downloads the model set and runs a lengthy per-model
-     * warmup before `/health` flips to 200.
-     */
-    private waitForHealthy;
+    listModels(): Promise<string[]>;
 }