codesearch-mcp 0.0.18-alpha → 0.2.0-alpha

package/dist/src/services/IndexerService.js

@@ -37,36 +37,92 @@ exports.IndexerService = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
-const textsplitters_1 = require("@langchain/textsplitters");
 const cli_progress_1 = require("cli-progress");
 const drizzle_orm_1 = require("drizzle-orm");
+const owner_path_1 = require("../owner-path");
 const db_1 = require("../db");
 const file_utils_1 = require("../file-utils");
 const LoggerService_1 = require("./LoggerService");
+const constants_1 = require("../constants");
 const SCHEMA_EXTENSIONS = /\.(prisma|graphql|gql)$/;
 class IndexerService {
     db;
     embedder;
     ast;
+    chunker;
     config;
     logger;
-    jsSplitter;
-    schemaSplitter;
-    constructor(db, embedder, ast, config, logger = LoggerService_1.LoggerService.silent()) {
+    constructor(db, embedder, ast, chunker, config, logger = LoggerService_1.LoggerService.silent()) {
         this.db = db;
         this.embedder = embedder;
         this.ast = ast;
+        this.chunker = chunker;
         this.config = config;
         this.logger = logger;
-        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', ' '],
-        });
+    }
+    /**
+     * 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.
+     */
+    async prepareEmbeddingSchema() {
+        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) {
+                // Fresh index — create the table at the resolved width and record it.
+                await this.db.recreateChunkTable(next.dimensions);
+                await this.db.writeIndexMeta(next);
+                this.logger.debug('IndexerService: prepared fresh index', { ...next });
+                return next;
+            }
+            // Legacy index (pre-index_meta): assume the historical default model.
+            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) {
+            // A missing table means a fresh install → 0. Any other (transient) error
+            // must propagate — returning 0 here could wrongly recreate/drop a populated
+            // table on the `!meta` path.
+            if (/does not exist/i.test(err.message))
+                return 0;
+            throw err;
+        }
     }
     async backfillSymbols(signal) {
         const t0 = Date.now();
@@ -180,13 +236,12 @@ class IndexerService {
         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({
@@ -290,8 +345,26 @@ class IndexerService {
         });
         return stats;
     }
-    getSplitter(filePath) {
-        return SCHEMA_EXTENSIONS.test(filePath) ? this.schemaSplitter : this.jsSplitter;
+    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);
+            }
+        }
+        return { removed, failed };
     }
     static inferRole(relPath) {
         const p = relPath.toLowerCase();
@@ -317,9 +390,9 @@ class IndexerService {
             return 'Utility';
         return null;
     }
-    getEnrichedPrompt(chunk, relPath, serviceName, _meta, edges, symbols) {
-        const chunkStart = (chunk.metadata?.loc?.lines?.from ?? 1);
-        const chunkEnd = (chunk.metadata?.loc?.lines?.to ?? chunkStart);
+    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);
@@ -335,12 +408,9 @@ class IndexerService {
             const depNames = [...new Set(edges.map(e => path.basename(e.toFile, path.extname(e.toFile)).split('.')[0]))];
             lines.push(`Dependencies: ${depNames.join(', ')}`);
         }
-        lines.push(`Code: ${chunk.pageContent}`);
+        lines.push(`Code: ${piece.content}`);
         return lines.join('\n');
     }
-    async embedText(prompt) {
-        return this.embedder.embed(prompt);
-    }
     static hashContent(content) {
         return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
     }
@@ -364,7 +434,7 @@ class IndexerService {
                 return { status: 'skipped', chunks: 0, pendingMtimeRefresh: relFilePath };
             }
             const tAst = Date.now();
-            const { edges: rawEdges, symbols: rawSymbols, calls: rawCalls } = analysis ?? { edges: [], symbols: [], calls: [] };
+            const { edges: rawEdges, symbols: rawSymbols, 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
@@ -390,25 +460,38 @@ class IndexerService {
             // 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 }));
             const astMs = Date.now() - tAst;
-            const chunks = await this.getSplitter(filePath).createDocuments([code]);
+            const chunks = await this.chunker.chunk(code, {
+                strategy: this.config.indexer.chunkStrategy,
+                isSchemaFile: SCHEMA_EXTENSIONS.test(filePath),
+                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,
+            ];
             const t2 = Date.now();
             const records = [];
-            for (let i = 0; i < chunks.length; i += this.config.indexer.batchSize) {
-                const batch = chunks.slice(i, i + this.config.indexer.batchSize);
-                const embedded = await Promise.all(batch.map(async (chunk) => {
-                    const startLine = (chunk.metadata?.loc?.lines?.from ?? 1);
-                    const prompt = this.getEnrichedPrompt(chunk, relPath, serviceName, meta ?? 'missing', edges, rawSymbols);
-                    const embedding = await this.embedText(prompt);
-                    return {
-                        serviceName, filePath: relFilePath, startLine,
-                        content: chunk.pageContent,
-                        embedding: `[${embedding}]`,
+            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 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,
-                    };
-                }));
-                records.push(...embedded);
+                        ownerPath: (0, owner_path_1.resolveOwnerPath)(piece.startLine, ownerRanges),
+                    });
+                }
             }
             const embedMs = Date.now() - t2;
             const t3 = Date.now();

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

@@ -0,0 +1,38 @@
+import type { Config } from '../config';
+import type { ILogger } from '../interfaces/ILogger';
+import { OpenAICompatibleEmbedder, type EmbedderDeps } from './OpenAICompatibleEmbedder';
+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;
+}
+/**
+ * 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`,
+ * `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 composePath;
+    private readonly provisioningDeps;
+    constructor(config: Config, logger?: ILogger, deps?: InfinityDeps);
+    /**
+     * 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>;
+    listModels(): Promise<string[]>;
+}

package/dist/src/services/InfinityEmbedder.js

@@ -0,0 +1,88 @@
+"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.InfinityEmbedder = exports.listInfinityModels = exports.probeInfinityHealth = exports.serverRoot = void 0;
+const LoggerService_1 = require("./LoggerService");
+const config_store_1 = require("../config-store");
+const OpenAICompatibleEmbedder_1 = require("./OpenAICompatibleEmbedder");
+const infinity_provisioning_1 = require("./infinity-provisioning");
+Object.defineProperty(exports, "serverRoot", { enumerable: true, get: function () { return infinity_provisioning_1.serverRoot; } });
+Object.defineProperty(exports, "probeInfinityHealth", { enumerable: true, get: function () { return infinity_provisioning_1.probeInfinityHealth; } });
+Object.defineProperty(exports, "listInfinityModels", { enumerable: true, get: function () { return infinity_provisioning_1.listInfinityModels; } });
+const path = __importStar(require("path"));
+/**
+ * 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`,
+ * `listModels`), delegating to the standalone `infinity-provisioning` primitive
+ * because Infinity binds its model set at container startup and exposes no
+ * runtime model-pull API.
+ */
+class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedder {
+    base;
+    composePath;
+    provisioningDeps;
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
+        super(config, logger, deps);
+        this.base = (0, infinity_provisioning_1.serverRoot)(config.embedding.baseURL);
+        this.composePath = deps.composePath ?? path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
+        this.provisioningDeps = {
+            fetchImpl: deps.fetchImpl,
+            runCommand: deps.runCommand,
+            pollIntervalMs: deps.pollIntervalMs,
+            readinessTimeoutMs: deps.readinessTimeoutMs,
+        };
+    }
+    /**
+     * 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.
+     */
+    async ensureModelAvailable() {
+        await (0, infinity_provisioning_1.ensureBackendReady)({
+            baseURL: this.config.embedding.baseURL,
+            requiredModels: [this.config.embedding.model],
+            modelSetToWrite: (0, infinity_provisioning_1.requiredModelSet)(this.config),
+            composePath: this.composePath,
+            deps: this.provisioningDeps,
+        });
+    }
+    async listModels() {
+        return (0, infinity_provisioning_1.listInfinityModels)(this.base, this.provisioningDeps.fetchImpl ?? fetch, 2000);
+    }
+}
+exports.InfinityEmbedder = InfinityEmbedder;

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

@@ -3,7 +3,8 @@ import type { ILogger } from '../interfaces/ILogger';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export declare class LoggerService implements ILogger {
     private readonly logger;
-    constructor(logger: pino.Logger);
+    private readonly metricsLogger;
+    constructor(logger: pino.Logger, metricsLogger?: pino.Logger | null);
     static silent(): LoggerService;
     static fromConfig(cfg: {
         level: string;
@@ -14,4 +15,5 @@ export declare class LoggerService implements 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;
+    metric(msg: string, data?: Record<string, unknown>): void;
 }

package/dist/src/services/LoggerService.js

@@ -44,8 +44,13 @@ const fs = __importStar(require("fs"));
 const DEFAULT_LOG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp', 'logs');
 class LoggerService {
     logger;
-    constructor(logger) {
+    // Dedicated `info`-level channel for search telemetry, independent of the
+    // main logger's configured level. Null when file logging is disabled so
+    // metrics never reach stdout (owned by the MCP JSON transport).
+    metricsLogger;
+    constructor(logger, metricsLogger = null) {
         this.logger = logger;
+        this.metricsLogger = metricsLogger;
     }
     static silent() {
         return new LoggerService((0, pino_1.default)({ level: 'silent' }));
@@ -66,6 +71,10 @@ class LoggerService {
     static buildFromPath(level, filePath) {
         if (filePath)
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        // The transport target must accept `info` so the metrics channel can emit
+        // even when the main level is `warn`/`error`; the main logger still gates
+        // normal calls at `level`, so nothing else leaks below it.
+        const targetLevel = pino_1.default.levels.values[level] < pino_1.default.levels.values.info ? level : 'info';
         const transport = filePath
             ? pino_1.default.transport({
                 targets: [{
@@ -79,18 +88,23 @@ class LoggerService {
                             limit: { count: 30 },
                             size: '50m',
                         },
-                        level,
+                        level: targetLevel,
                     }],
             })
             : undefined;
         const logger = transport
             ? (0, pino_1.default)({ level }, transport)
             : (0, pino_1.default)({ level: 'silent' });
-        return new LoggerService(logger);
+        // Child logger pinned at `info` regardless of the parent level; only used by
+        // metric(). Null when there is no file transport (default stdout must stay
+        // clean for the MCP transport).
+        const metricsLogger = transport ? logger.child({}, { level: 'info' }) : null;
+        return new LoggerService(logger, metricsLogger);
     }
     debug(msg, data) { this.logger.debug(data ?? {}, msg); }
     info(msg, data) { this.logger.info(data ?? {}, msg); }
     warn(msg, data) { this.logger.warn(data ?? {}, msg); }
     error(msg, data) { this.logger.error(data ?? {}, msg); }
+    metric(msg, data) { this.metricsLogger?.info(data ?? {}, msg); }
 }
 exports.LoggerService = LoggerService;

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

@@ -0,0 +1,25 @@
+import type { Config } from '../config';
+import type { IEmbedder, InputType } from '../interfaces/IEmbedder';
+import type { ILogger } from '../interfaces/ILogger';
+export interface EmbedderDeps {
+    fetchImpl?: typeof fetch;
+    baseDelayMs?: number;
+}
+/**
+ * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
+ * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
+ * inputs (`{ input: string[], model, dimensions? }`) and returns
+ * `{ data: [{ embedding, index }] }`, re-ordered to input order.
+ */
+export declare class OpenAICompatibleEmbedder implements IEmbedder {
+    protected config: Config;
+    private logger;
+    readonly dimensions: number;
+    rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
+    private readonly url;
+    private readonly doFetch;
+    private readonly baseDelayMs?;
+    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
+    embed(text: string, inputType?: InputType): Promise<number[]>;
+    embedBatch(texts: string[], _inputType?: InputType): Promise<number[][]>;
+}

package/dist/src/services/OpenAICompatibleEmbedder.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleEmbedder = void 0;
+const LoggerService_1 = require("./LoggerService");
+const config_1 = require("../config");
+const reranker_1 = require("./reranker");
+const http_retry_1 = require("./http-retry");
+const constants_1 = require("../constants");
+/**
+ * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
+ * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
+ * inputs (`{ input: string[], model, dimensions? }`) and returns
+ * `{ data: [{ embedding, index }] }`, re-ordered to input order.
+ */
+class OpenAICompatibleEmbedder {
+    config;
+    logger;
+    dimensions;
+    rerank;
+    url;
+    doFetch;
+    baseDelayMs;
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
+        this.config = config;
+        this.logger = logger;
+        const base = config.embedding.baseURL.replace(/\/+$/, '');
+        // Allow a baseURL that already includes the path (…/v1) or not.
+        this.url = /\/embeddings$/.test(base) ? base : `${base}/embeddings`;
+        this.doFetch = deps.fetchImpl ?? fetch;
+        this.baseDelayMs = deps.baseDelayMs;
+        this.dimensions = config.embedding.dimensions ?? (0, constants_1.registryDimension)(config.embedding.model) ?? 0;
+        this.rerank = (0, reranker_1.makeReranker)(config, logger, deps);
+    }
+    async embed(text, inputType) {
+        const [v] = await this.embedBatch([text], inputType);
+        return v;
+    }
+    async embedBatch(texts, _inputType) {
+        if (texts.length === 0)
+            return [];
+        return (0, http_retry_1.withRetry)(async () => {
+            const headers = { 'Content-Type': 'application/json' };
+            // Resolve the key lazily — an unset `env:` ref throws here (request time),
+            // not at construction, so `rag-web`/`rag-mcp` still start.
+            const apiKey = (0, config_1.resolveEnvRef)(this.config.embedding.apiKey);
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            const body = { model: this.config.embedding.model, input: texts };
+            if (this.config.embedding.dimensions != null)
+                body.dimensions = this.config.embedding.dimensions;
+            const res = await this.doFetch(this.url, {
+                method: 'POST',
+                headers,
+                signal: AbortSignal.timeout(120_000),
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                const errBody = (await res.text().catch(() => res.statusText)).slice(0, 200);
+                throw new http_retry_1.HttpError(res.status, `embeddings request failed: ${res.status} ${errBody}`);
+            }
+            const data = await res.json();
+            // Guard against a partial/mismatched response — a missing vector would
+            // otherwise be inserted as "[undefined]" and fail the whole file, or (with
+            // reordering + no index) silently misalign vectors to the wrong chunks.
+            if (!Array.isArray(data.data) || data.data.length !== texts.length) {
+                throw new Error(`embeddings response returned ${data.data?.length ?? 0} vectors for ${texts.length} inputs`);
+            }
+            // Sort by `index` so vectors line up with input order regardless of server ordering.
+            return [...data.data]
+                .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
+                .map(d => d.embedding);
+        }, { logger: this.logger, baseDelayMs: this.baseDelayMs, label: 'openai-embed' });
+    }
+}
+exports.OpenAICompatibleEmbedder = OpenAICompatibleEmbedder;

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

@@ -9,6 +9,7 @@ export interface ChunkRow {
     filePath: string;
     startLine: number;
     content: string;
+    ownerPath?: string | null;
 }
 export interface SearchResult extends ChunkRow {
     score: number;
@@ -102,8 +103,28 @@ export declare class SearcherService {
         query: string;
         translated: boolean;
     }>;
+    /**
+     * Refuse when the configured embedding model disagrees with the one that built
+     * the index — embedding a query into a foreign vector space returns noise. A
+     * missing `index_meta` row with an empty (or altogether absent) `code_chunk`
+     * does not block — but a *populated* `code_chunk` with no `index_meta` row is a
+     * pre-`index_meta` install, treated as the legacy `ollama`/`bge-m3` index (same
+     * interpretation as the `rag-index` legacy-Ollama guard), read-only — this check
+     * never writes `index_meta`.
+     */
+    assertIndexMatches(): Promise<void>;
+    private compareIndexed;
     listProjects(): Promise<ProjectRow[]>;
     searchChunks(query: string, limit: number, project: string | null, threshold?: number): Promise<SearchResult[]>;
+    /**
+     * Emit one structured search-tuning line (via `logger.metric`, at `info`
+     * regardless of `logging.level`). `candidates` are in cosine order, so a
+     * candidate's array index is its cosine rank — `maxCosineRankSurvived` is the
+     * deepest cosine position that survived reranking into the returned set. Read
+     * it alongside `poolSaturated` to tune `candidateFloor`/`overfetch`/threshold
+     * per hardware. Never logs chunk content, embeddings, or credentials.
+     */
+    private emitSearchMetrics;
     fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
     fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
     getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
@@ -125,7 +146,6 @@ export declare class SearcherService {
     };
     readFileAbsolute(absPath: string, maxLines: number): Promise<FileRangeResult>;
     readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
-    private isNonEnglish;
     private walkDir;
     private buildFindSymbolPattern;
     private inferKind;