codesearch-mcp 0.0.18-alpha → 0.1.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();
@@ -290,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'))
@@ -317,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);
@@ -335,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');
     }
@@ -364,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
@@ -390,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/OllamaEmbedder.d.ts

@@ -1,14 +1,25 @@
 import type { Config } from '../config';
-import type { IEmbedder } from '../interfaces';
+import type { IEmbedder, InputType } from '../interfaces';
 import type { ILogger } from '../interfaces';
+import type { EmbedderDeps } from './OpenAICompatibleEmbedder';
 export declare class OllamaEmbedder implements IEmbedder {
     private config;
     private logger;
+    readonly dimensions: number;
     private client;
     rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
-    constructor(config: Config, logger?: ILogger);
-    embed(text: string): Promise<number[]>;
+    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
+    embed(text: string, _inputType?: InputType): Promise<number[]>;
+    embedBatch(texts: string[], _inputType?: InputType): Promise<number[][]>;
     listModels(): Promise<string[]>;
-    translate(text: string, model: string): Promise<string>;
-    private _rerank;
+    /**
+     * Pull the configured model if it is not already present locally, so a plain
+     * `rag-index` works after switching to (or back to) a local model that was
+     * never pulled — `rag-setup` is no longer the only place that fetches models.
+     * A tagless model name (`bge-m3`) matches its `:latest`/tagged install.
+     * Streams pull progress to the console: a live single-line bar on a TTY, or
+     * de-duplicated status lines otherwise.
+     */
+    ensureModelAvailable(): Promise<void>;
+    private static formatPullProgress;
 }

package/dist/src/services/OllamaEmbedder.js

@@ -3,61 +3,109 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OllamaEmbedder = void 0;
 const ollama_1 = require("ollama");
 const LoggerService_1 = require("./LoggerService");
+const reranker_1 = require("./reranker");
+const constants_1 = require("../constants");
 class OllamaEmbedder {
     config;
     logger;
+    dimensions;
     client;
     rerank;
-    constructor(config, logger = LoggerService_1.LoggerService.silent()) {
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
         this.config = config;
         this.logger = logger;
-        this.client = new ollama_1.Ollama({ host: config.ollama.host });
-        if (config.search.rerankerEnabled) {
-            if (config.ollama.rerankerModel) {
-                this.rerank = this._rerank.bind(this);
-            }
-            else {
-                this.logger.warn('OllamaEmbedder: rerankerEnabled=true but rerankerModel is not set — reranking disabled');
-            }
-        }
+        this.client = new ollama_1.Ollama({ host: config.embedding.baseURL });
+        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) {
+    // Ollama has no query/document asymmetry — inputType is accepted and ignored.
+    async embed(text, _inputType) {
         const { embedding } = await this.client.embeddings({
-            model: this.config.ollama.model,
+            model: this.config.embedding.model,
             prompt: text,
         });
         return embedding;
     }
+    async embedBatch(texts, _inputType) {
+        if (texts.length === 0)
+            return [];
+        try {
+            // /api/embed accepts an array input and returns one vector per input.
+            const res = await this.client.embed({ model: this.config.embedding.model, input: texts });
+            if (res.embeddings?.length === texts.length)
+                return res.embeddings;
+            this.logger.warn('OllamaEmbedder: batch embed count mismatch, falling back to sequential', {
+                expected: texts.length, got: res.embeddings?.length ?? 0,
+            });
+        }
+        catch (err) {
+            this.logger.warn('OllamaEmbedder: batch embed failed, falling back to sequential', {
+                reason: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Sequential fallback — the contract (one vector per input, in order) holds.
+        const out = [];
+        for (const t of texts)
+            out.push(await this.embed(t));
+        return out;
+    }
     async listModels() {
         const res = await this.client.list();
         return res.models.map(m => m.name).filter(Boolean).sort();
     }
-    async translate(text, model) {
-        const response = await this.client.chat({
-            model,
-            messages: [{ role: 'user', content: `Translate the following text to English. Return only the translation, no explanations:\n${text}` }],
-        });
-        return response.message.content.trim();
+    /**
+     * Pull the configured model if it is not already present locally, so a plain
+     * `rag-index` works after switching to (or back to) a local model that was
+     * never pulled — `rag-setup` is no longer the only place that fetches models.
+     * A tagless model name (`bge-m3`) matches its `:latest`/tagged install.
+     * Streams pull progress to the console: a live single-line bar on a TTY, or
+     * de-duplicated status lines otherwise.
+     */
+    async ensureModelAvailable() {
+        const model = this.config.embedding.model;
+        try {
+            const res = await this.client.list();
+            const present = res.models.some(m => m.name === model || m.name.startsWith(`${model}:`));
+            if (present)
+                return;
+        }
+        catch (err) {
+            // Can't list (Ollama unreachable?) — try the pull; its error is clearer.
+            this.logger.warn('OllamaEmbedder: could not list models before pull', {
+                reason: err instanceof Error ? err.message : String(err),
+            });
+        }
+        console.log(`Pulling Ollama model "${model}" (not found locally)...`);
+        this.logger.info('OllamaEmbedder: pulling model', { model });
+        const stream = await this.client.pull({ model, stream: true });
+        const isTty = Boolean(process.stdout.isTTY);
+        let lastLen = 0;
+        let lastLog = '';
+        for await (const part of stream) {
+            const out = '  ' + OllamaEmbedder.formatPullProgress(part);
+            if (isTty) {
+                process.stdout.write('\r' + out.padEnd(lastLen));
+                lastLen = out.length;
+            }
+            else if (out !== lastLog) {
+                console.log(out);
+                lastLog = out;
+            }
+        }
+        if (isTty && lastLen > 0)
+            process.stdout.write('\r' + ' '.repeat(lastLen) + '\r');
+        console.log(`  ✓ ${model} ready.`);
     }
-    async _rerank(query, documents, topN) {
-        const res = await fetch(this.config.ollama.rerankerUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(30_000),
-            body: JSON.stringify({
-                model: this.config.ollama.rerankerModel,
-                query,
-                documents,
-                top_n: topN,
-                truncate: true,
-            }),
-        });
-        if (!res.ok) {
-            const body = (await res.text().catch(() => res.statusText)).slice(0, 200);
-            throw new Error(`Ollama rerank failed: ${res.status} ${body}`);
+    static formatPullProgress(p) {
+        const status = p.status ?? 'pulling';
+        if (p.total && p.total > 0) {
+            const pct = Math.min(100, Math.floor(((p.completed ?? 0) / p.total) * 100));
+            const width = 24;
+            const filled = Math.round((pct / 100) * width);
+            const bar = '[' + '█'.repeat(filled) + '░'.repeat(width - filled) + ']';
+            return `${status} ${bar} ${pct}% (${((p.completed ?? 0) / 1e6).toFixed(1)}/${(p.total / 1e6).toFixed(1)} MB)`;
         }
-        const data = await res.json();
-        return data.results.map(r => r.index);
+        return status;
     }
 }
 exports.OllamaEmbedder = OllamaEmbedder;