codesearch-mcp 0.0.17-alpha.1 → 0.1.0-alpha

package/dist/src/services/EmbedderFactory.js

@@ -0,0 +1,29 @@
+"use strict";
+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.
+ */
+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);
+        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.`);
+        }
+    }
+}

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 { DatabaseService } from './DatabaseService';
-import { LoggerService } from './LoggerService';
+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: DatabaseService, embedder: IEmbedder, ast: IAstParser, config: Config, logger?: LoggerService);
+    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;
@@ -33,16 +47,12 @@ export declare class IndexerService {
         skipped: number;
         failed: number;
     }>;
-    discoverProjects(rootDir: string): {
-        name: string;
-        path: string;
-    }[];
     private writeDepEdges;
-    scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;
-    private getSplitter;
+    scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
+        rootTsConfigPath?: string;
+    }): Promise<IndexStats>;
     private static inferRole;
     private getEnrichedPrompt;
-    private embedText;
     private static hashContent;
     private ingestFile;
 }

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();
@@ -159,12 +215,6 @@ class IndexerService {
         this.logger.debug('IndexerService: backfillCalls done', { total: rows.length, processed, skipped, failed, ms: Date.now() - t0 });
         return { total: rows.length, processed, skipped, failed };
     }
-    discoverProjects(rootDir) {
-        return fs.readdirSync(rootDir, { withFileTypes: true })
-            .filter(d => d.isDirectory() && !file_utils_1.IGNORE_DIRS.has(d.name))
-            .map(d => ({ name: d.name, path: path.join(rootDir, d.name) }))
-            .filter(p => fs.existsSync(path.join(p.path, 'package.json')));
-    }
     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)));
@@ -177,7 +227,7 @@ class IndexerService {
         else
             await this.db.transaction(run);
     }
-    async scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles) {
+    async scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles, opts) {
         const startTime = Date.now();
         this.logger.debug('IndexerService: scanAndIndex start', { serviceName, dir, force });
         if (force) {
@@ -237,7 +287,10 @@ class IndexerService {
             if (signal?.aborted)
                 break;
             const batch = files.slice(batchStart, batchStart + this.config.indexer.astBatchSize);
-            const analysisMap = await this.ast.analyzeProject(batch, serviceName, dir, { skipDependencyResolution: isLargeProject });
+            const analysisMap = await this.ast.analyzeProject(batch, serviceName, dir, {
+                skipDependencyResolution: isLargeProject,
+                rootTsConfigPath: opts?.rootTsConfigPath,
+            });
             for (const filePath of batch) {
                 if (signal?.aborted) {
                     bar.stop();
@@ -293,9 +346,6 @@ class IndexerService {
         });
         return stats;
     }
-    getSplitter(filePath) {
-        return SCHEMA_EXTENSIONS.test(filePath) ? this.schemaSplitter : this.jsSplitter;
-    }
     static inferRole(relPath) {
         const p = relPath.toLowerCase();
         if (p.includes('/services/') || p.endsWith('.service.ts'))
@@ -320,9 +370,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);
@@ -338,12 +388,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');
     }
@@ -367,7 +414,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
@@ -393,25 +440,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,79 @@
+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;
+    /**
+     * 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`),
+ * 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;
+    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()`.
+     */
+    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;
+}

package/dist/src/services/InfinityEmbedder.js

@@ -0,0 +1,199 @@
+"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 = void 0;
+exports.serverRoot = serverRoot;
+exports.probeInfinityHealth = probeInfinityHealth;
+exports.listInfinityModels = listInfinityModels;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const LoggerService_1 = require("./LoggerService");
+const config_store_1 = require("../config-store");
+const OpenAICompatibleEmbedder_1 = require("./OpenAICompatibleEmbedder");
+/**
+ * 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.
+ */
+function serverRoot(baseURL) {
+    return baseURL.replace(/\/+$/, '').replace(/\/(embeddings|v1)$/, '');
+}
+/**
+ * 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`.
+ */
+async function probeInfinityHealth(baseURL, fetchImpl = fetch, timeoutMs = 2000) {
+    try {
+        const res = await fetchImpl(`${serverRoot(baseURL)}/health`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List the model ids an Infinity server currently serves via its OpenAI-style
+ * `/models` listing (`{ data: [{ id }] }`). Returns `[]` on any error.
+ */
+async function listInfinityModels(baseURL, fetchImpl = fetch, timeoutMs = 5000) {
+    try {
+        const res = await fetchImpl(`${serverRoot(baseURL)}/models`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return (data.data ?? []).map(m => m.id).filter((id) => Boolean(id));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 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`),
+ * because Infinity binds its model set at container startup and exposes no
+ * runtime model-pull API.
+ */
+class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedder {
+    base;
+    doFetchImpl;
+    runCommand;
+    composePath;
+    pollIntervalMs;
+    log;
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
+        super(config, logger, deps);
+        this.base = serverRoot(config.embedding.baseURL);
+        this.doFetchImpl = deps.fetchImpl ?? fetch;
+        this.runCommand = deps.runCommand ?? ((cmd, args, env) => {
+            const r = (0, child_process_1.spawnSync)(cmd, args, { stdio: 'inherit', env: env ? { ...process.env, ...env } : process.env });
+            return { status: r.status, stdout: r.stdout?.toString() };
+        });
+        this.composePath = deps.composePath ?? path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
+        this.pollIntervalMs = deps.pollIntervalMs ?? 2000;
+        this.log = logger;
+    }
+    isHealthy() {
+        return probeInfinityHealth(this.base, this.doFetchImpl);
+    }
+    servedModels() {
+        return listInfinityModels(this.base, this.doFetchImpl);
+    }
+    /** True when a managed compose file exists AND declares an `infinity` service. */
+    hasManagedService() {
+        try {
+            const content = fs.readFileSync(this.composePath, 'utf-8');
+            return /^\s*infinity:\s*$/m.test(content);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 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()`.
+     */
+    async ensureModelAvailable() {
+        const model = this.config.embedding.model;
+        if (await this.isHealthy()) {
+            const served = await this.servedModels();
+            // A server that lists no models (older Infinity, or listing disabled) is
+            // trusted — the embed request will surface a real error if the model is
+            // truly absent.
+            if (served.length === 0 || served.includes(model))
+                return;
+            throw new Error(`Infinity at ${this.base} serves [${served.join(', ')}] but embedding.model is "${model}". ` +
+                `Restart the container with the correct --model-id (e.g. recreate the managed container ` +
+                `via rag-setup, or fix embedding.model).`);
+        }
+        // Unreachable.
+        if (this.hasManagedService()) {
+            console.log(`Infinity not reachable at ${this.base} — starting the managed container...`);
+            this.log.info('InfinityEmbedder: starting managed container', { composePath: this.composePath });
+            // Bind the SAME model set the config expects (embed + reranker when enabled),
+            // so the auto-started container matches the config — otherwise compose would
+            // (re)create it with the compose default and silently drop the reranker /
+            // serve the wrong embed model. `--force-recreate` picks up a changed set.
+            const modelIds = [
+                this.config.embedding.model,
+                ...(this.config.reranker.enabled && this.config.reranker.model ? [this.config.reranker.model] : []),
+            ].join(';');
+            const r = this.runCommand('docker', ['compose', '-f', this.composePath, 'up', '-d', '--force-recreate', 'infinity'], { INFINITY_MODEL_ID: modelIds });
+            if (r.status !== 0) {
+                throw new Error(`Failed to start the managed Infinity container (docker compose exited ${r.status}). ` +
+                    `Ensure Docker is running, or start Infinity manually.`);
+            }
+            await this.waitForHealthy();
+            return;
+        }
+        throw new Error(`Infinity is not reachable at ${this.base} and no managed container is configured. ` +
+            `Start it manually, e.g.:\n` +
+            `  docker run -it --gpus all -p 7997:7997 michaelf34/infinity:latest \\\n` +
+            `    v2 --model-id ${model} --port 7997\n` +
+            `(drop --gpus all to run on CPU), or re-run rag-setup to provision it.`);
+    }
+    /**
+     * 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.
+     */
+    async waitForHealthy(maxWaitSec = 1800) {
+        console.log('Waiting for Infinity to be ready (first boot downloads + warms up the model set, this can take several minutes on CPU)...');
+        const deadline = Date.now() + maxWaitSec * 1000;
+        while (Date.now() < deadline) {
+            if (await this.isHealthy()) {
+                console.log('  ✓ Infinity ready.');
+                return;
+            }
+            await new Promise(r => setTimeout(r, this.pollIntervalMs));
+        }
+        throw new Error(`Infinity did not become ready within ${maxWaitSec}s at ${this.base}.`);
+    }
+}
+exports.InfinityEmbedder = InfinityEmbedder;

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

@@ -1,6 +1,7 @@
 import pino from 'pino';
+import type { ILogger } from '../interfaces/ILogger';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export declare class LoggerService {
+export declare class LoggerService implements ILogger {
     private readonly logger;
     constructor(logger: pino.Logger);
     static silent(): LoggerService;

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

@@ -1,14 +1,23 @@
 import type { Config } from '../config';
-import { SearcherService } from './SearcherService';
-import { LoggerService } from './LoggerService';
+import type { ISearcher } from '../interfaces/ISearcher';
+import type { ILogger } from '../interfaces/ILogger';
+/**
+ * McpServer — thin orchestration layer that delegates tool handling
+ * to individual IMcpToolHandler implementations (Open/Closed Principle).
+ *
+ * To add a new tool: implement IMcpToolHandler and register it in createTools().
+ */
 export declare class McpServer {
     private searcher;
     private config;
     private logger;
-    constructor(searcher: SearcherService, config: Config, logger?: LoggerService);
+    private readonly version;
+    private readonly tools;
+    constructor(searcher: ISearcher, config: Config, logger: ILogger);
     start(startupError?: Error): Promise<void>;
-    private formatGraphContext;
-    private formatChunk;
-    private formatDependencies;
-    private formatDependents;
+    /**
+     * Factory method: creates and registers all tool handlers.
+     * New tools are added here without modifying the dispatch logic above.
+     */
+    private createTools;
 }