codesearch-mcp 0.0.18-alpha → 0.2.0-alpha

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

@@ -7,4 +7,11 @@ export interface ILogger {
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;
     error(msg: string, data?: Record<string, unknown>): void;
+    /**
+     * Structured telemetry emitted at `info` **independent of the configured log
+     * level** — so an operator can collect it in production without the full
+     * `debug` firehose. No-op when file logging is disabled (never writes to
+     * stdout, which the MCP transport owns).
+     */
+    metric(msg: string, data?: Record<string, unknown>): void;
 }

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

@@ -8,6 +8,7 @@ export interface ISearcher {
         query: string;
         translated: boolean;
     }>;
+    assertIndexMatches(): Promise<void>;
     listProjects(): Promise<ProjectRow[]>;
     getProjectEdges(): Promise<{
         from: string;

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

@@ -1,5 +1,6 @@
-export type { IEmbedder } from './IEmbedder';
+export type { IEmbedder, InputType } from './IEmbedder';
 export type { IAstParser, DepEdge, SymbolEntry, CallEdge, FileAnalysis } from './IAstParser';
+export type { IChunker, ChunkPiece, ChunkOpts } from './IChunker';
 export type { ILogger } from './ILogger';
 export type { IDatabase } from './IDatabase';
 export type { ISearcher } from './ISearcher';

package/dist/src/owner-path.d.ts

@@ -0,0 +1,10 @@
+import type { OwnerRange } from './interfaces/IAstParser';
+/**
+ * Resolve the owning declaration for a chunk given its 1-based start line and a
+ * flat list of candidate ranges (top-level symbols + method ranges). The
+ * deepest range containing the start line wins (smallest `endLine - line` span),
+ * so a method beats its enclosing class. Returns `Container.name` for methods
+ * (via `container`) or `name` for top-level declarations, and `null` when the
+ * start line lies outside every range (imports / module-scope gaps).
+ */
+export declare function resolveOwnerPath(startLine: number, ranges: OwnerRange[]): string | null;

package/dist/src/owner-path.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOwnerPath = resolveOwnerPath;
+/**
+ * Resolve the owning declaration for a chunk given its 1-based start line and a
+ * flat list of candidate ranges (top-level symbols + method ranges). The
+ * deepest range containing the start line wins (smallest `endLine - line` span),
+ * so a method beats its enclosing class. Returns `Container.name` for methods
+ * (via `container`) or `name` for top-level declarations, and `null` when the
+ * start line lies outside every range (imports / module-scope gaps).
+ */
+function resolveOwnerPath(startLine, ranges) {
+    let best = null;
+    let bestSpan = Infinity;
+    for (const r of ranges) {
+        if (r.line <= startLine && startLine <= r.endLine) {
+            const span = r.endLine - r.line;
+            if (span < bestSpan) {
+                bestSpan = span;
+                best = r;
+            }
+        }
+    }
+    if (!best)
+        return null;
+    return best.container ? `${best.container}.${best.name}` : best.name;
+}

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

@@ -0,0 +1,42 @@
+import type { Config } from '../config';
+import type { IChunker, ChunkPiece, ChunkOpts } from '../interfaces/IChunker';
+/**
+ * Splits TS/JS source into embeddable pieces aligned to top-level declaration
+ * ranges (AST strategy). Falls back to the character-based recursive splitter
+ * for schema files, files without symbol analysis, or when strategy is
+ * 'character' — that path is byte-for-byte the previous behavior.
+ */
+export declare class AstChunker implements IChunker {
+    private config;
+    private readonly jsSplitter;
+    private readonly schemaSplitter;
+    private readonly chunkSize;
+    constructor(config: Config);
+    chunk(code: string, opts: ChunkOpts): Promise<ChunkPiece[]>;
+    private produce;
+    /**
+     * True iff every significant line (blank and comment lines stripped) belongs
+     * to an `import` / re-export statement and at least one is an import or
+     * re-export keyword — so the chunk carries no value/type declaration and is
+     * never a search answer. Any `export const|let|var|function|class|interface|
+     * enum|namespace|default|declare|async function|type X = …` disqualifies
+     * exclusion. Pure. Distinguishes `export { … } from` / `export type { … }`
+     * (re-export → drop) from `export type X = …` (declaration → keep).
+     */
+    static isImportOrReexportOnly(content: string): boolean;
+    /** Character-splitter path for a whole file; line numbers from splitter metadata. */
+    private splitWholeFile;
+    private chunkByAst;
+    /**
+     * Build disjoint, sorted line intervals from symbol ranges. Overlapping /
+     * nested ranges merge into the outermost (a merged region covers any symbol
+     * inside it). Ranges are clamped to the file's line count.
+     */
+    private static buildIntervals;
+    /**
+     * Emit pieces for a 1-based inclusive line region. Whitespace-only gaps are
+     * dropped; regions longer than chunkSize are sub-split with the char splitter,
+     * with sub-piece line numbers offset back to absolute file lines.
+     */
+    private regionPieces;
+}

package/dist/src/services/AstChunker.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstChunker = void 0;
+const textsplitters_1 = require("@langchain/textsplitters");
+/**
+ * Splits TS/JS source into embeddable pieces aligned to top-level declaration
+ * ranges (AST strategy). Falls back to the character-based recursive splitter
+ * for schema files, files without symbol analysis, or when strategy is
+ * 'character' — that path is byte-for-byte the previous behavior.
+ */
+class AstChunker {
+    config;
+    jsSplitter;
+    schemaSplitter;
+    chunkSize;
+    constructor(config) {
+        this.config = config;
+        this.chunkSize = config.indexer.chunkSize;
+        this.jsSplitter = textsplitters_1.RecursiveCharacterTextSplitter.fromLanguage('js', {
+            chunkSize: config.indexer.chunkSize,
+            chunkOverlap: config.indexer.chunkOverlap,
+        });
+        this.schemaSplitter = new textsplitters_1.RecursiveCharacterTextSplitter({
+            chunkSize: config.indexer.chunkSize,
+            chunkOverlap: config.indexer.chunkOverlap,
+            separators: ['\n\n', '\n', ' '],
+        });
+    }
+    async chunk(code, opts) {
+        const pieces = await this.produce(code, opts);
+        // Single post-chunk pass: drop pieces whose only significant content is
+        // import / re-export statements. Both chunk sources — AST "gap" regions and
+        // the whole-file character path for barrel files — can emit these, so we
+        // filter once over the final pieces. Dependency edges are untouched (they
+        // come from analyzeProject → code_dependency, not from chunk text).
+        return pieces.filter(p => !AstChunker.isImportOrReexportOnly(p.content));
+    }
+    async produce(code, opts) {
+        if (opts.isSchemaFile) {
+            return this.splitWholeFile(code, this.schemaSplitter);
+        }
+        if (opts.strategy === 'character' || opts.symbols.length === 0) {
+            return this.splitWholeFile(code, this.jsSplitter);
+        }
+        return this.chunkByAst(code, opts.symbols);
+    }
+    /**
+     * True iff every significant line (blank and comment lines stripped) belongs
+     * to an `import` / re-export statement and at least one is an import or
+     * re-export keyword — so the chunk carries no value/type declaration and is
+     * never a search answer. Any `export const|let|var|function|class|interface|
+     * enum|namespace|default|declare|async function|type X = …` disqualifies
+     * exclusion. Pure. Distinguishes `export { … } from` / `export type { … }`
+     * (re-export → drop) from `export type X = …` (declaration → keep).
+     */
+    static isImportOrReexportOnly(content) {
+        const lines = content
+            .replace(/\/\*[\s\S]*?\*\//g, '') // strip block comments
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l !== '' && !l.startsWith('//') && !l.startsWith('*'));
+        if (lines.length === 0)
+            return false;
+        const IMPORT = /^import\b/;
+        const REEXPORT = /^export\s+(\*|type\s+\{|\{)/; // export * | export type { | export {
+        const DISQUALIFY = /^export\s+(default|async\b|function\b|const\b|let\b|var\b|class\b|abstract\b|interface\b|enum\b|namespace\b|declare\b|type\s+[A-Za-z_$])/;
+        const CONTINUATION = /^(\}?\s*from\s+['"][^'"]+['"];?|[{}]|(type\s+)?[A-Za-z_$][\w$]*(\s+as\s+[A-Za-z_$][\w$]*)?,?|['"][^'"]*['"];?)$/;
+        let keywords = 0;
+        for (const line of lines) {
+            if (DISQUALIFY.test(line))
+                return false;
+            if (IMPORT.test(line) || REEXPORT.test(line)) {
+                keywords++;
+                continue;
+            }
+            if (CONTINUATION.test(line))
+                continue;
+            return false; // unrecognized line → real code, keep the chunk
+        }
+        return keywords >= 1;
+    }
+    /** Character-splitter path for a whole file; line numbers from splitter metadata. */
+    async splitWholeFile(code, splitter) {
+        const docs = await splitter.createDocuments([code]);
+        return docs.map((d) => {
+            const from = (d.metadata?.loc?.lines?.from ?? 1);
+            const to = (d.metadata?.loc?.lines?.to ?? from);
+            return { content: d.pageContent, startLine: from, endLine: to };
+        });
+    }
+    async chunkByAst(code, symbols) {
+        const lines = code.split('\n');
+        const total = lines.length;
+        const intervals = AstChunker.buildIntervals(symbols, total);
+        const pieces = [];
+        let cursor = 1;
+        for (const iv of intervals) {
+            if (cursor < iv.start) {
+                pieces.push(...await this.regionPieces(lines, cursor, iv.start - 1, true));
+            }
+            pieces.push(...await this.regionPieces(lines, iv.start, iv.end, false));
+            cursor = iv.end + 1;
+        }
+        if (cursor <= total) {
+            pieces.push(...await this.regionPieces(lines, cursor, total, true));
+        }
+        return pieces;
+    }
+    /**
+     * Build disjoint, sorted line intervals from symbol ranges. Overlapping /
+     * nested ranges merge into the outermost (a merged region covers any symbol
+     * inside it). Ranges are clamped to the file's line count.
+     */
+    static buildIntervals(symbols, total) {
+        const raw = symbols
+            .filter(s => s.line != null && s.line >= 1 && s.line <= total)
+            .map(s => ({
+            start: s.line,
+            end: Math.min(Math.max(s.endLine ?? s.line, s.line), total),
+        }))
+            .sort((a, b) => a.start - b.start || b.end - a.end);
+        const merged = [];
+        for (const iv of raw) {
+            const last = merged[merged.length - 1];
+            if (last && iv.start <= last.end) {
+                last.end = Math.max(last.end, iv.end);
+            }
+            else {
+                merged.push({ ...iv });
+            }
+        }
+        return merged;
+    }
+    /**
+     * Emit pieces for a 1-based inclusive line region. Whitespace-only gaps are
+     * dropped; regions longer than chunkSize are sub-split with the char splitter,
+     * with sub-piece line numbers offset back to absolute file lines.
+     */
+    async regionPieces(lines, start, end, isGap) {
+        const text = lines.slice(start - 1, end).join('\n');
+        if (isGap && text.trim() === '')
+            return [];
+        if (text.length <= this.chunkSize) {
+            return [{ content: text, startLine: start, endLine: end }];
+        }
+        const docs = await this.jsSplitter.createDocuments([text]);
+        return docs.map((d) => {
+            const from = (d.metadata?.loc?.lines?.from ?? 1);
+            const to = (d.metadata?.loc?.lines?.to ?? from);
+            return {
+                content: d.pageContent,
+                startLine: start + from - 1,
+                endLine: start + to - 1,
+            };
+        });
+    }
+}
+exports.AstChunker = AstChunker;

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

@@ -14,6 +14,12 @@ export declare class AstParserService implements IAstParser {
     private resolveFromSymbol;
     private buildUsageMap;
     private extractSymbols;
+    /**
+     * Method / constructor / accessor line ranges with their enclosing class, for
+     * owner-path resolution only. Deliberately NOT fed into `code_symbol` (methods
+     * stay grep-based in find_symbol), so this is separate from extractSymbols.
+     */
+    private extractOwnerRanges;
     private extractCalls;
     private getContainerName;
 }

package/dist/src/services/AstParserService.js

@@ -77,7 +77,8 @@ class AstParserService {
                 const edges = this.extractEdges(sourceFile, filePath, serviceName);
                 const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
                 const calls = this.extractCalls(sourceFile, filePath, serviceName);
-                analysisMap.set(filePath, { edges, symbols, calls });
+                const ownerRanges = this.extractOwnerRanges(sourceFile);
+                analysisMap.set(filePath, { edges, symbols, calls, ownerRanges });
             }
             catch (err) {
                 this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
@@ -126,9 +127,10 @@ class AstParserService {
         const edges = this.extractEdges(sourceFile, filePath, serviceName);
         const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
         const calls = this.extractCalls(sourceFile, filePath, serviceName);
+        const ownerRanges = this.extractOwnerRanges(sourceFile);
         morphProject.removeSourceFile(sourceFile);
         this.logger.debug('AstParser: analyzeFile done', { filePath, edges: edges.length, symbols: symbols.length, calls: calls.length, ms: Date.now() - t0 });
-        return { edges, symbols, calls };
+        return { edges, symbols, calls, ownerRanges };
     }
     // Kept for test compatibility (extract-import-edges.test.ts).
     async extractImportEdges(filePath, serviceName, projectRoot) {
@@ -369,6 +371,33 @@ class AstParserService {
         }
         return symbols;
     }
+    /**
+     * Method / constructor / accessor line ranges with their enclosing class, for
+     * owner-path resolution only. Deliberately NOT fed into `code_symbol` (methods
+     * stay grep-based in find_symbol), so this is separate from extractSymbols.
+     */
+    extractOwnerRanges(sourceFile) {
+        const ranges = [];
+        for (const cls of sourceFile.getClasses()) {
+            const container = cls.getName();
+            if (!container)
+                continue;
+            const members = [
+                ...cls.getMethods().map(n => ({ name: n.getName(), node: n })),
+                ...cls.getGetAccessors().map(n => ({ name: n.getName(), node: n })),
+                ...cls.getSetAccessors().map(n => ({ name: n.getName(), node: n })),
+                ...cls.getConstructors().map(n => ({ name: 'constructor', node: n })),
+            ];
+            for (const { name, node } of members) {
+                ranges.push({
+                    name, container,
+                    line: node.getStartLineNumber(),
+                    endLine: node.getEndLineNumber(),
+                });
+            }
+        }
+        return ranges;
+    }
     // ── private: call graph extraction ────────────────────────────────────────
     extractCalls(sourceFile, filePath, serviceName) {
         const calls = [];

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

@@ -1,7 +1,7 @@
 import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
 import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
 import type { Config } from '../config';
-import type { IDatabase } from '../interfaces/IDatabase';
+import type { IDatabase, IndexMeta } from '../interfaces/IDatabase';
 import * as schema from '../db/schema';
 type Schema = typeof schema;
 export type DrizzleDb = NodePgDatabase<Schema>;
@@ -17,6 +17,22 @@ export declare class DatabaseService implements IDatabase {
     destroy(): Promise<void>;
     initDb(): Promise<void>;
     initDbWithSchema(): Promise<void>;
+    /**
+     * Create `code_chunk` at `dimensions` if it does not exist, plus its HNSW and
+     * (serviceName, filePath) indexes and the additive `contentHash`/`ownerPath`
+     * columns for pre-existing tables. Idempotent — safe to call repeatedly.
+     */
+    ensureChunkTable(dimensions: number): Promise<void>;
+    /** Drop and recreate `code_chunk` at `dimensions` — used on a dimension change. */
+    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>;
+    /** Guard against SQL injection — the dimension is interpolated into DDL. */
+    private assertDim;
     private ensureDatabaseExists;
 }
 export {};

package/dist/src/services/DatabaseService.js

@@ -36,7 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseService = 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");
 class DatabaseService {
     config;
     pool;
@@ -66,33 +68,20 @@ class DatabaseService {
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
         await this.initDb();
-        // code_chunk table
-        const [{ exists }] = await this.query(`
-      SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_schema = 'public' AND table_name = 'code_chunk'
+        // 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.
+        await this.ensureChunkTable(1024);
+        // index_meta table — source of truth for the model that built the index.
+        await this.query(`
+      CREATE TABLE IF NOT EXISTS index_meta (
+        id          BOOLEAN PRIMARY KEY DEFAULT true,
+        provider    TEXT NOT NULL,
+        model       TEXT NOT NULL,
+        dimensions  INT  NOT NULL,
+        "indexedAt" TIMESTAMPTZ NOT NULL DEFAULT now()
       )
     `);
-        if (!exists) {
-            await this.query(`
-        CREATE TABLE code_chunk (
-          id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          "serviceName" TEXT NOT NULL,
-          "filePath"    TEXT NOT NULL,
-          "startLine"   INT,
-          content       TEXT NOT NULL,
-          embedding     vector(1024) NOT NULL,
-          "lastModified" DOUBLE PRECISION,
-          "contentHash"  VARCHAR(64)
-        )
-      `);
-            await this.query(`
-        CREATE INDEX idx_code_chunk_embedding
-        ON code_chunk USING hnsw (embedding vector_cosine_ops)
-      `);
-        }
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
-        await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "contentHash" varchar(64) NULL`);
         // code_dependency table
         const [{ existsDep }] = await this.query(`
       SELECT EXISTS (
@@ -160,6 +149,108 @@ class DatabaseService {
         await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee_file ON code_call (project, "calleeFile")`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_call_from        ON code_call (project, "fromFile")`);
     }
+    /**
+     * Create `code_chunk` at `dimensions` if it does not exist, plus its HNSW and
+     * (serviceName, filePath) indexes and the additive `contentHash`/`ownerPath`
+     * columns for pre-existing tables. Idempotent — safe to call repeatedly.
+     */
+    async ensureChunkTable(dimensions) {
+        const dim = this.assertDim(dimensions);
+        await this.query(`
+      CREATE TABLE IF NOT EXISTS code_chunk (
+        id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        "serviceName" TEXT NOT NULL,
+        "filePath"    TEXT NOT NULL,
+        "startLine"   INT,
+        content       TEXT NOT NULL,
+        embedding     vector(${dim}) NOT NULL,
+        "lastModified" DOUBLE PRECISION,
+        "contentHash"  VARCHAR(64),
+        "ownerPath"    VARCHAR
+      )
+    `);
+        await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "contentHash" varchar(64) NULL`);
+        await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "ownerPath" varchar NULL`);
+        await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_embedding ON code_chunk USING hnsw (embedding vector_cosine_ops)`);
+        await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
+    }
+    /** Drop and recreate `code_chunk` at `dimensions` — used on a dimension change. */
+    async recreateChunkTable(dimensions) {
+        const dim = this.assertDim(dimensions);
+        await this.query(`DROP TABLE IF EXISTS code_chunk`);
+        await this.ensureChunkTable(dim);
+    }
+    async readIndexMeta() {
+        try {
+            const rows = await this.query(`SELECT provider, model, dimensions FROM index_meta LIMIT 1`);
+            const row = rows[0];
+            return row ? { provider: row.provider, model: row.model, dimensions: Number(row.dimensions) } : null;
+        }
+        catch {
+            // Table absent (un-migrated DB) — treat as "no metadata".
+            return null;
+        }
+    }
+    async writeIndexMeta(meta) {
+        await this.query(`INSERT INTO index_meta (id, provider, model, dimensions, "indexedAt")
+       VALUES (true, $1, $2, $3, now())
+       ON CONFLICT (id) DO UPDATE
+         SET provider = EXCLUDED.provider,
+             model = EXCLUDED.model,
+             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));
+        });
+    }
+    /** Guard against SQL injection — the dimension is interpolated into DDL. */
+    assertDim(dimensions) {
+        if (!Number.isInteger(dimensions) || dimensions <= 0 || dimensions > 2000) {
+            throw new Error(`Invalid vector dimension: ${dimensions} (must be an integer 1–2000)`);
+        }
+        return dimensions;
+    }
     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

@@ -0,0 +1,9 @@
+import type { Config } from '../config';
+import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { ILogger } from '../interfaces/ILogger';
+import { type EmbedderDeps } from './OpenAICompatibleEmbedder';
+/**
+ * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
+ * 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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmbedder = createEmbedder;
+const LoggerService_1 = require("./LoggerService");
+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 (`infinity`) is the recommended local backend.
+ */
+function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
+    switch (config.embedding.provider) {
+        case 'openai-compatible':
+            return new OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedder(config, logger, deps);
+        case 'infinity':
+            return new InfinityEmbedder_1.InfinityEmbedder(config, logger, deps);
+        case 'voyage':
+            return new VoyageEmbedder_1.VoyageEmbedder(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: openai-compatible, voyage, infinity.`);
+        }
+    }
+}

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

@@ -1,8 +1,10 @@
 import type { Config } from '../config';
 import type { IEmbedder } from '../interfaces/IEmbedder';
 import type { IAstParser } from '../interfaces/IAstParser';
+import type { IChunker } from '../interfaces/IChunker';
 import type { IDatabase } from '../interfaces/IDatabase';
 import type { ILogger } from '../interfaces/ILogger';
+import type { IndexMeta } from '../interfaces/IDatabase';
 export interface IndexStats {
     serviceName: string;
     indexed: number;
@@ -16,11 +18,23 @@ export declare class IndexerService {
     private db;
     private embedder;
     private ast;
+    private chunker;
     private config;
     private logger;
-    private readonly jsSplitter;
-    private readonly schemaSplitter;
-    constructor(db: IDatabase, embedder: IEmbedder, ast: IAstParser, config: Config, logger?: ILogger);
+    constructor(db: IDatabase, embedder: IEmbedder, ast: IAstParser, chunker: IChunker, config: Config, logger?: ILogger);
+    /**
+     * Resolve the active embedding dimension (config override → registry → probe),
+     * reconcile it against `index_meta`, and prepare `code_chunk` accordingly:
+     * a dimension change drops+recreates the table; a same-dimension model/provider
+     * change clears its rows (vector spaces are not comparable across models); an
+     * unchanged model keeps the rows for incremental indexing. Back-compat: an
+     * existing populated table with no `index_meta` row is treated as the legacy
+     * `ollama`/`bge-m3`/1024 index. Writes `index_meta` to reflect the active model.
+     * Call once per run, before the scan loop.
+     */
+    prepareEmbeddingSchema(): Promise<IndexMeta>;
+    private reconcileIndex;
+    private countChunks;
     backfillSymbols(signal?: AbortSignal): Promise<{
         total: number;
         processed: number;
@@ -37,10 +51,12 @@ export declare class IndexerService {
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
         rootTsConfigPath?: string;
     }): Promise<IndexStats>;
-    private getSplitter;
+    pruneProjects(keep: string[]): Promise<{
+        removed: string[];
+        failed: string[];
+    }>;
     private static inferRole;
     private getEnrichedPrompt;
-    private embedText;
     private static hashContent;
     private ingestFile;
 }