contextpro-mcp 0.0.0-stage → 1.5.0

package/build/core/embeddings.js

@@ -0,0 +1,693 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+// Multi-provider vector embedding engine with cosine similarity search
+// Supports Ollama (local) and OpenAI-compatible APIs (Gemini, OpenAI, etc.)
+// Indexes file headers and symbols, caches embeddings to disk for speed
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { getProvider, getEmbedModelName, getApiKey, getBaseUrl } from "./provider-config.js";
+import { observeProviderCall } from "./provider-usage.js";
+const EMBED_TIMEOUT_MS = 60_000;
+let embedAbortController = new AbortController();
+export function cancelAllEmbeddings() {
+    embedAbortController.abort();
+    embedAbortController = new AbortController();
+}
+// Provider configuration is centralized in provider-config.ts. See that file for the full
+// env-var precedence (generic CONTEXTPRO_* → legacy → provider-native → default). Resolved once
+// at module load to preserve prior behavior; restart the server to pick up env changes.
+const EMBED_PROVIDER = getProvider();
+const EMBED_MODEL = getEmbedModelName("ollama");
+const OPENAI_EMBED_MODEL = getEmbedModelName("openai");
+const OPENAI_API_KEY = getApiKey();
+const OPENAI_BASE_URL = getBaseUrl();
+const CACHE_DIR = ".contextpro";
+const MIN_EMBED_BATCH_SIZE = 1;
+const MAX_EMBED_BATCH_SIZE = 128;
+const DEFAULT_OLLAMA_EMBED_BATCH_SIZE = 32;
+const DEFAULT_REMOTE_EMBED_BATCH_SIZE = 8;
+const MIN_EMBED_INPUT_CHARS = 1;
+const SINGLE_INPUT_SHRINK_FACTOR = 0.75;
+const MAX_SINGLE_INPUT_RETRIES = 40;
+const MIN_EMBED_CHUNK_CHARS = 256;
+const DEFAULT_EMBED_CHUNK_CHARS = 2000;
+const MAX_EMBED_CHUNK_CHARS = 8000;
+let ollamaClient = null;
+const ollamaSignals = new AsyncLocalStorage();
+async function getOllamaClient() {
+    if (!ollamaClient) {
+        const { Ollama } = await import("ollama");
+        // Ollama embed() serializes its request body; a `signal` property there does
+        // not cancel HTTP. Install the signal on the actual fetch instead.
+        ollamaClient = new Ollama({ host: process.env.OLLAMA_HOST,
+            fetch: (input, init) => fetch(input, { ...init, signal: ollamaSignals.getStore() ?? init?.signal }),
+        });
+    }
+    return ollamaClient;
+}
+async function callOllamaEmbed(input, signal) {
+    const client = await getOllamaClient();
+    const options = getEmbedRuntimeOptions();
+    const request = { model: EMBED_MODEL, input };
+    if (options)
+        request.options = options;
+    try {
+        const response = await observeProviderCall({ kind: "embedding", provider: "ollama", model: EMBED_MODEL }, () => ollamaSignals.run(signal, () => client.embed(request)), result => ({ input: result.prompt_eval_count }));
+        return response.embeddings;
+    }
+    catch (error) {
+        throw new Error(formatOllamaModelError(error, "embedding", EMBED_MODEL));
+    }
+}
+async function callOpenAIEmbed(input, signal) {
+    return observeProviderCall({ kind: "embedding", provider: "openai", model: OPENAI_EMBED_MODEL }, async () => {
+        const url = `${OPENAI_BASE_URL.replace(/\/+$/, "")}/embeddings`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${OPENAI_API_KEY}`,
+            },
+            body: JSON.stringify({ model: OPENAI_EMBED_MODEL, input }),
+            signal,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`OpenAI embed API error ${response.status}: ${body}`);
+        }
+        return await response.json();
+    }, result => ({ input: result.usage?.prompt_tokens ?? result.usage?.total_tokens })).then(data => data.data.map(item => item.embedding));
+}
+async function callProviderEmbed(input, signal) {
+    const deadline = queryDeadline.getStore();
+    // Cold index preparation must not consume the shared provider budget.
+    if (deadline)
+        signal = AbortSignal.any([signal, deadline.signal ??= AbortSignal.timeout(deadline.timeoutMs)]);
+    signal.throwIfAborted();
+    if (EMBED_PROVIDER === "openai") {
+        return callOpenAIEmbed(input, signal);
+    }
+    return callOllamaEmbed(input, signal);
+}
+function toIntegerOr(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function toOptionalInteger(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function toOptionalBoolean(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes")
+        return true;
+    if (normalized === "false" || normalized === "0" || normalized === "no")
+        return false;
+    return undefined;
+}
+function getEmbedRuntimeOptions() {
+    if (EMBED_PROVIDER === "openai")
+        return undefined;
+    const options = {
+        num_gpu: toOptionalInteger(process.env.CONTEXTPRO_EMBED_NUM_GPU ?? process.env.CONTEXTPLUS_EMBED_NUM_GPU),
+        main_gpu: toOptionalInteger(process.env.CONTEXTPRO_EMBED_MAIN_GPU ?? process.env.CONTEXTPLUS_EMBED_MAIN_GPU),
+        num_thread: toOptionalInteger(process.env.CONTEXTPRO_EMBED_NUM_THREAD ?? process.env.CONTEXTPLUS_EMBED_NUM_THREAD),
+        num_batch: toOptionalInteger(process.env.CONTEXTPRO_EMBED_NUM_BATCH ?? process.env.CONTEXTPLUS_EMBED_NUM_BATCH),
+        num_ctx: toOptionalInteger(process.env.CONTEXTPRO_EMBED_NUM_CTX ?? process.env.CONTEXTPLUS_EMBED_NUM_CTX),
+        low_vram: toOptionalBoolean(process.env.CONTEXTPRO_EMBED_LOW_VRAM ?? process.env.CONTEXTPLUS_EMBED_LOW_VRAM),
+    };
+    if (Object.values(options).every((value) => value === undefined))
+        return undefined;
+    return options;
+}
+export function getEmbeddingBatchSize() {
+    const defaultSize = EMBED_PROVIDER === "ollama"
+        ? DEFAULT_OLLAMA_EMBED_BATCH_SIZE
+        : DEFAULT_REMOTE_EMBED_BATCH_SIZE;
+    const requested = toIntegerOr(process.env.CONTEXTPRO_EMBED_BATCH_SIZE ?? process.env.CONTEXTPLUS_EMBED_BATCH_SIZE, defaultSize);
+    return Math.min(MAX_EMBED_BATCH_SIZE, Math.max(MIN_EMBED_BATCH_SIZE, requested));
+}
+export function getEmbedChunkChars() {
+    const requested = toIntegerOr(process.env.CONTEXTPRO_EMBED_CHUNK_CHARS ?? process.env.CONTEXTPLUS_EMBED_CHUNK_CHARS, DEFAULT_EMBED_CHUNK_CHARS);
+    return Math.min(MAX_EMBED_CHUNK_CHARS, Math.max(MIN_EMBED_CHUNK_CHARS, requested));
+}
+export function getEmbedProvider() {
+    return EMBED_PROVIDER;
+}
+export function getEmbedModel() {
+    return EMBED_PROVIDER === "openai" ? OPENAI_EMBED_MODEL : EMBED_MODEL;
+}
+export function hasCompatibleEmbeddingModel(db) {
+    return db.getMeta("embed_provider") === getEmbedProvider() && db.getMeta("embed_model") === getEmbedModel();
+}
+export function currentEmbeddingModel() {
+    return { provider: getEmbedProvider(), model: getEmbedModel() };
+}
+/** Include durable identity/population changes made by other MCP workers. */
+export function embeddingCacheIdentity(db) {
+    return JSON.stringify([getEmbedProvider(), getEmbedModel(), db.getMeta("embed_provider"), db.getMeta("embed_model"), db.getMeta("embedding_revision")]);
+}
+/** Memory writes cannot migrate another worker's vector space implicitly. */
+export async function embedMemoryText(db, text) {
+    db.transaction(() => {
+        if (!db.getMeta("embed_provider") && !db.getMeta("embed_model")) {
+            const stats = db.getEmbeddingStats();
+            if (!stats.total && !stats.memory)
+                db.recordEmbeddingProvider(getEmbedProvider(), getEmbedModel());
+        }
+    });
+    if (!hasCompatibleEmbeddingModel(db))
+        return [];
+    const [vector] = await fetchEmbedding(text);
+    return hasCompatibleEmbeddingModel(db) ? vector : [];
+}
+function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function formatOllamaModelError(error, kind, model) {
+    const message = getErrorMessage(error);
+    const lower = message.toLowerCase();
+    const installHint = "Install Ollama from https://ollama.com/download, then run `ollama serve`.";
+    const modelHint = `Run \`ollama pull ${model}\`, or set OLLAMA_${kind === "embedding" ? "EMBED" : "CHAT"}_MODEL to any model shown by \`ollama list\`.`;
+    if (lower.includes("econnrefused")
+        || lower.includes("fetch failed")
+        || lower.includes("connection refused")
+        || lower.includes("connect")) {
+        return `Ollama is not reachable while loading the ${kind} model "${model}". ${installHint} ${modelHint} Original error: ${message}`;
+    }
+    if (lower.includes("not found")
+        || lower.includes("no such model")
+        || lower.includes("model")) {
+        return `Ollama ${kind} model "${model}" is not available. ${modelHint} Original error: ${message}`;
+    }
+    return `Ollama ${kind} model "${model}" failed. ${installHint} ${modelHint} Original error: ${message}`;
+}
+function isContextLengthError(error) {
+    const message = getErrorMessage(error).toLowerCase();
+    return message.includes("input length exceeds context length")
+        || (message.includes("context") && message.includes("exceed"))
+        || message.includes("maximum context length");
+}
+function shrinkEmbeddingInput(input) {
+    if (input.length <= MIN_EMBED_INPUT_CHARS)
+        return input;
+    const nextLength = Math.max(MIN_EMBED_INPUT_CHARS, Math.floor(input.length * SINGLE_INPUT_SHRINK_FACTOR));
+    if (nextLength >= input.length)
+        return input.slice(0, input.length - 1);
+    return input.slice(0, nextLength);
+}
+async function embedSingleAdaptive(input) {
+    let candidate = input;
+    for (let attempt = 0; attempt <= MAX_SINGLE_INPUT_RETRIES; attempt++) {
+        try {
+            const timeoutCtrl = AbortSignal.timeout(EMBED_TIMEOUT_MS);
+            const signal = AbortSignal.any([embedAbortController.signal, timeoutCtrl]);
+            const embeddings = await callProviderEmbed([candidate], signal);
+            if (!embeddings[0])
+                throw new Error("Missing embedding vector in response");
+            return embeddings[0];
+        }
+        catch (error) {
+            if (!isContextLengthError(error))
+                throw error;
+            const nextCandidate = shrinkEmbeddingInput(candidate);
+            if (nextCandidate.length === candidate.length)
+                throw error;
+            candidate = nextCandidate;
+        }
+    }
+    throw new Error("Unable to embed oversized input after adaptive retries");
+}
+async function embedBatchAdaptive(batch) {
+    try {
+        const timeoutCtrl = AbortSignal.timeout(EMBED_TIMEOUT_MS);
+        const signal = AbortSignal.any([embedAbortController.signal, timeoutCtrl]);
+        const embeddings = await callProviderEmbed(batch, signal);
+        if (embeddings.length !== batch.length) {
+            throw new Error(`Embedding response size mismatch: expected ${batch.length}, got ${embeddings.length}`);
+        }
+        return embeddings;
+    }
+    catch (error) {
+        if (!isContextLengthError(error))
+            throw error;
+        if (batch.length === 1) {
+            return [await embedSingleAdaptive(batch[0])];
+        }
+        const middle = Math.ceil(batch.length / 2);
+        const left = await embedBatchAdaptive(batch.slice(0, middle));
+        const right = await embedBatchAdaptive(batch.slice(middle));
+        return [...left, ...right];
+    }
+}
+function splitEmbeddingInput(input) {
+    const chunkChars = getEmbedChunkChars();
+    if (input.length <= chunkChars)
+        return [input];
+    const chunks = [];
+    for (let start = 0; start < input.length; start += chunkChars) {
+        chunks.push(input.slice(start, start + chunkChars));
+    }
+    return chunks;
+}
+function mergeEmbeddingVectors(vectors, weights) {
+    if (vectors.length === 0)
+        throw new Error("Cannot merge empty embedding vectors");
+    if (vectors.length === 1)
+        return vectors[0];
+    const dimension = vectors[0].length;
+    const merged = new Array(dimension).fill(0);
+    let totalWeight = 0;
+    for (let i = 0; i < vectors.length; i++) {
+        const vector = vectors[i];
+        if (vector.length !== dimension) {
+            throw new Error(`Embedding dimension mismatch: expected ${dimension}, got ${vector.length}`);
+        }
+        const weight = Math.max(1, weights[i] ?? 1);
+        totalWeight += weight;
+        for (let d = 0; d < dimension; d++)
+            merged[d] += vector[d] * weight;
+    }
+    if (totalWeight <= 0)
+        return vectors[0];
+    for (let d = 0; d < merged.length; d++)
+        merged[d] /= totalWeight;
+    return merged;
+}
+export async function fetchEmbedding(input) {
+    const inputs = Array.isArray(input) ? input : [input];
+    if (inputs.length === 0)
+        return [];
+    const chunkedInputs = inputs.map(splitEmbeddingInput);
+    const flattenedInputs = chunkedInputs.flat();
+    const batchSize = getEmbeddingBatchSize();
+    const flattenedEmbeddings = [];
+    for (let i = 0; i < flattenedInputs.length; i += batchSize) {
+        const batch = flattenedInputs.slice(i, i + batchSize);
+        flattenedEmbeddings.push(...await embedBatchAdaptive(batch));
+    }
+    const embeddings = [];
+    let offset = 0;
+    for (const chunks of chunkedInputs) {
+        const vectors = flattenedEmbeddings.slice(offset, offset + chunks.length);
+        if (vectors.length !== chunks.length) {
+            throw new Error(`Merged embedding size mismatch: expected ${chunks.length}, got ${vectors.length}`);
+        }
+        embeddings.push(mergeEmbeddingVectors(vectors, chunks.map((chunk) => chunk.length)));
+        offset += chunks.length;
+    }
+    return embeddings;
+}
+function hashContent(text) {
+    let h = 0;
+    for (let i = 0; i < text.length; i++)
+        h = ((h << 5) - h + text.charCodeAt(i)) | 0;
+    return h.toString(36);
+}
+function cosine(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+const SEARCH_STOPWORDS = new Set("a an the and or but for from to of in on at by with without that this these those is are was were be been being as it its after before using use how which when then than into through".split(" "));
+export function searchTerms(text) {
+    return splitCamelCase(text).filter(term => !SEARCH_STOPWORDS.has(term));
+}
+function splitCamelCase(text) {
+    return text
+        .normalize("NFC")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2")
+        .toLowerCase()
+        .split(/[^\p{L}\p{M}\p{N}]+/u)
+        .filter((t) => t.length > 1 || /[^\x00-\x7F]/u.test(t));
+}
+function clamp01(value) {
+    if (value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+}
+function normalizeThreshold(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    if (value > 1)
+        return clamp01(value / 100);
+    return clamp01(value);
+}
+function normalizeWeight(value, fallback) {
+    if (value === undefined || !Number.isFinite(value) || value < 0)
+        return fallback;
+    return value;
+}
+function normalizeTopK(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.floor(value));
+}
+function resolveSearchOptions(optionsOrTopK) {
+    const raw = typeof optionsOrTopK === "number" ? { topK: optionsOrTopK } : (optionsOrTopK ?? {});
+    return {
+        topK: normalizeTopK(raw.topK, 5),
+        semanticWeight: normalizeWeight(raw.semanticWeight, 0.72),
+        keywordWeight: normalizeWeight(raw.keywordWeight, 0.28),
+        minSemanticScore: normalizeThreshold(raw.minSemanticScore, 0),
+        minKeywordScore: normalizeThreshold(raw.minKeywordScore, 0),
+        minCombinedScore: normalizeThreshold(raw.minCombinedScore, 0.1),
+        requireKeywordMatch: raw.requireKeywordMatch ?? false,
+        requireSemanticMatch: raw.requireSemanticMatch ?? false,
+        fusion: raw.fusion === "weighted" ? "weighted" : "rrf",
+    };
+}
+/**
+ * Reciprocal rank fusion (Cormack, Clarke & Büttcher, SIGIR 2009): fuse two ranked lists by
+ * rank position rather than raw score value, sidestepping the scale mismatch between an
+ * unbounded/keyword-style score and a bounded cosine similarity. k=60 is the empirical
+ * default from the original paper's TREC evaluation. Result is normalized to [0, 1] by the
+ * best-possible score (rank 1 in both lists). That rank signal is subsequently
+ * calibrated with the candidate's absolute semantic/keyword evidence before it
+ * is exposed as a confidence-like combined score or compared to minCombinedScore.
+ */
+const RRF_K = 60;
+function reciprocalRankFusionScores(semanticScores, keywordScores) {
+    const n = semanticScores.length;
+    const buildRanks = (scores) => {
+        const ranks = new Array(n).fill(null);
+        const ranked = [...scores.keys()]
+            .filter((index) => scores[index] > 0)
+            .sort((left, right) => scores[right] - scores[left] || left - right);
+        ranked.forEach((index, rank) => { ranks[index] = rank + 1; });
+        return ranks;
+    };
+    const semanticRank = buildRanks(semanticScores.map((score) => Math.max(score, 0)));
+    const keywordRank = buildRanks(keywordScores);
+    const activeLists = Number(semanticRank.some((rank) => rank !== null)) + Number(keywordRank.some((rank) => rank !== null));
+    if (activeLists === 0)
+        return new Array(n).fill(0);
+    const bestPossible = activeLists / (RRF_K + 1);
+    return semanticScores.map((_, index) => {
+        const semantic = semanticRank[index] === null ? 0 : 1 / (RRF_K + semanticRank[index]);
+        const keyword = keywordRank[index] === null ? 0 : 1 / (RRF_K + keywordRank[index]);
+        return (semantic + keyword) / bestPossible;
+    });
+}
+function calibrateRrfScore(rankScore, semanticScore, keywordScore) {
+    // RRF says which result ranks first; it does not say whether the underlying
+    // signal is strong. Without this gate, a lone 0.16 cosine match becomes 100%.
+    const absoluteEvidence = Math.max(Math.max(semanticScore, 0), keywordScore);
+    return clamp01(rankScore * clamp01(absoluteEvidence));
+}
+const LOW_SEMANTIC_FLOOR = 0.15;
+function dampLowSemanticScore(score, semanticScore, keywordScore, semanticAvailable) {
+    const semantic = Math.max(semanticScore, 0);
+    if (!semanticAvailable || semantic >= LOW_SEMANTIC_FLOOR)
+        return score;
+    // A lexical collision should remain visible as a low-confidence fallback, but it must not
+    // outrank a genuinely semantic result. The ceiling rises smoothly from 12% at semantic=0
+    // to just under 40% at the 0.15 semantic floor.
+    const ceiling = keywordScore * (0.12 + 0.28 * (semantic / LOW_SEMANTIC_FLOOR));
+    return Math.min(score, ceiling);
+}
+function getTermCoverage(queryTerms, docTerms) {
+    if (queryTerms.size === 0)
+        return 0;
+    let matched = 0;
+    for (const term of queryTerms) {
+        if (docTerms.has(term))
+            matched++;
+    }
+    return matched / queryTerms.size;
+}
+function getMatchedSymbols(symbols, queryTerms) {
+    if (queryTerms.size === 0)
+        return [];
+    return symbols.filter((symbol) => splitCamelCase(symbol).some((term) => queryTerms.has(term)));
+}
+function computeKeywordScore(query, queryTerms, doc, matchedSymbols, preparedTerms, weights) {
+    if (queryTerms.size === 0)
+        return 0;
+    const docText = `${doc.path} ${doc.header} ${doc.symbols.join(" ")} ${doc.content}`;
+    const docTerms = preparedTerms ?? new Set(searchTerms(docText));
+    const queryLower = query.trim().toLowerCase();
+    const phraseBoost = queryLower.length > 0 && docText.toLowerCase().includes(queryLower) ? 0.15 : 0;
+    const symbolTerms = new Set(splitCamelCase(matchedSymbols.join(" ")));
+    const coverage = (terms) => {
+        let total = 0, matched = 0;
+        for (const term of queryTerms) {
+            const weight = weights?.get(term) ?? 1;
+            total += weight;
+            if (terms.has(term))
+                matched += weight;
+        }
+        return total ? matched / total : 0;
+    };
+    const termCoverage = coverage(docTerms);
+    const symbolCoverage = coverage(symbolTerms);
+    return clamp01(termCoverage * 0.65 + symbolCoverage * 0.2 + phraseBoost);
+}
+function computeCombinedScore(semanticScore, keywordScore, options) {
+    const semanticComponent = Math.max(semanticScore, 0);
+    const totalWeight = options.semanticWeight + options.keywordWeight;
+    if (totalWeight <= 0)
+        return semanticComponent;
+    const blended = (options.semanticWeight * semanticComponent + options.keywordWeight * keywordScore) / totalWeight;
+    // Trust dampener: when one component is essentially zero, the combined score is misleading.
+    // A pure-keyword 94 should not look like a high-confidence hybrid match. Cap at 0.7 when
+    // semantic ≈ 0, and at 0.7 when keyword ≈ 0 (allows lexical hits to surface without claiming
+    // high hybrid confidence). 0.7 is the "medium" threshold in the qualityLabel UI.
+    const SEMANTIC_FLOOR = 0.05;
+    const KEYWORD_FLOOR = 0.05;
+    const SINGLE_COMPONENT_CAP = 0.7;
+    if (semanticComponent < SEMANTIC_FLOOR || keywordScore < KEYWORD_FLOOR) {
+        return clamp01(Math.min(blended, SINGLE_COMPONENT_CAP));
+    }
+    return clamp01(blended);
+}
+const FILE_SEARCH_SOURCE_TYPE = "file_search_cache";
+async function loadCache(rootDir) {
+    const { getDB, bufferToVec } = await import("./db.js");
+    const db = await getDB(rootDir);
+    if (!hasCompatibleEmbeddingModel(db))
+        return {};
+    const rows = db.getEmbeddingsByType(FILE_SEARCH_SOURCE_TYPE);
+    const cache = {};
+    for (const r of rows) {
+        cache[r.sourceId] = { hash: r.contentHash, vector: bufferToVec(r.vector) };
+    }
+    return cache;
+}
+async function saveCache(rootDir, cache, dirtyKeys) {
+    const { getDB } = await import("./db.js");
+    const db = await getDB(rootDir);
+    const keys = dirtyKeys ?? new Set(Object.keys(cache));
+    const entries = [];
+    for (const key of keys) {
+        const entry = cache[key];
+        if (entry)
+            entries.push({ sourceId: key, vector: entry.vector, hash: entry.hash });
+    }
+    db.upsertEmbeddingsBatch(FILE_SEARCH_SOURCE_TYPE, entries);
+}
+export async function deleteFileSearchEmbedding(rootDir, path) {
+    const { getDB } = await import("./db.js");
+    const db = await getDB(rootDir);
+    db.deleteEmbeddingsByPrefix(FILE_SEARCH_SOURCE_TYPE, path);
+}
+export async function ensureMcpDataDir(rootDir) {
+    await mkdir(join(rootDir, CACHE_DIR), { recursive: true });
+}
+function formatLineRange(line, endLine) {
+    if (endLine && endLine > line)
+        return `L${line}-L${endLine}`;
+    return `L${line}`;
+}
+function getMatchedSymbolEntries(symbols, queryTerms) {
+    if (queryTerms.size === 0)
+        return [];
+    return symbols.filter((symbol) => splitCamelCase(symbol.name).some((term) => queryTerms.has(term)));
+}
+// Query vectors are shared only inside one retrieval request, never across projects or turns.
+const queryEmbeddings = new AsyncLocalStorage();
+const queryDeadline = new AsyncLocalStorage();
+export function withQueryEmbeddingCache(fn) {
+    const configured = Number(process.env.CONTEXTPRO_QUERY_EMBED_TIMEOUT_MS ?? 1500);
+    const timeout = Number.isFinite(configured) ? Math.max(100, Math.min(10000, Math.trunc(configured))) : 1500;
+    return queryEmbeddings.getStore() ? fn() : queryDeadline.run({ timeoutMs: timeout }, () => queryEmbeddings.run(new Map(), fn));
+}
+export function fetchQueryEmbedding(query) {
+    const cache = queryEmbeddings.getStore();
+    let pending = cache?.get(query);
+    if (!pending) {
+        pending = withQueryEmbeddingCache(() => fetchEmbedding(query).then(([vector]) => vector ?? []));
+        cache?.set(query, pending);
+    }
+    return pending;
+}
+/** Hard constraints use the same public 0..100 scores returned to the caller. */
+export function matchesSearchConstraints(result, options) {
+    const percent = (value) => value === undefined ? 0 : value > 1 ? value : value * 100;
+    return (!options.requireSemanticMatch || result.semanticScore > 0)
+        && (!options.requireKeywordMatch || result.keywordScore > 0)
+        && result.semanticScore >= percent(options.minSemanticScore)
+        && result.keywordScore >= percent(options.minKeywordScore)
+        && result.score >= percent(options.minCombinedScore);
+}
+export class SearchIndex {
+    documents = [];
+    vectors = [];
+    lexicalDocuments = [];
+    inverseFrequency = new Map();
+    async index(docs, rootDir, skipEmbeddings = false, cacheOnly = false) {
+        this.documents = docs;
+        this.lexicalDocuments = docs.map(doc => new Set(searchTerms(`${doc.path} ${doc.header} ${doc.symbols.join(" ")} ${doc.content}`)));
+        const frequencies = new Map();
+        for (const terms of this.lexicalDocuments)
+            for (const term of terms)
+                frequencies.set(term, (frequencies.get(term) ?? 0) + 1);
+        this.inverseFrequency = new Map([...frequencies].map(([term, count]) => [term, Math.log(1 + (docs.length + 1) / (count + 1))]));
+        if (skipEmbeddings) {
+            this.vectors = new Array(docs.length);
+            return;
+        }
+        if (!cacheOnly) {
+            const { getDB } = await import("./db.js");
+            (await getDB(rootDir)).recordEmbeddingProvider(getEmbedProvider(), getEmbedModel());
+        }
+        const cache = await loadCache(rootDir);
+        const uncached = [];
+        const dirtyKeys = new Set();
+        this.vectors = new Array(docs.length);
+        for (let i = 0; i < docs.length; i++) {
+            const doc = docs[i];
+            const rawText = `${doc.header} ${doc.symbols.join(" ")} ${doc.content}`;
+            const hash = hashContent(rawText);
+            if (cache[doc.path]?.hash === hash) {
+                this.vectors[i] = cache[doc.path].vector;
+            }
+            else {
+                uncached.push({ idx: i, text: rawText, hash });
+            }
+        }
+        if (!cacheOnly && uncached.length > 0) {
+            const batchSize = getEmbeddingBatchSize();
+            const batches = [];
+            for (let b = 0; b < uncached.length; b += batchSize) {
+                batches.push(uncached.slice(b, b + batchSize));
+            }
+            const pLimit = (await import("p-limit")).default;
+            const limit = pLimit(4);
+            await Promise.all(batches.map((batch) => limit(async () => {
+                try {
+                    const embeddings = await fetchEmbedding(batch.map((u) => u.text));
+                    for (let j = 0; j < batch.length; j++) {
+                        this.vectors[batch[j].idx] = embeddings[j];
+                        const key = docs[batch[j].idx].path;
+                        cache[key] = { hash: batch[j].hash, vector: embeddings[j] };
+                        dirtyKeys.add(key);
+                    }
+                }
+                catch (error) {
+                    if (!isContextLengthError(error)) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        process.stderr.write(`[contextpro/embeddings] degraded: batch failed (${message}); falling back to keyword-only for ${batch.length} files\n`);
+                        return;
+                    }
+                    for (const item of batch) {
+                        try {
+                            const [vector] = await fetchEmbedding(item.text);
+                            this.vectors[item.idx] = vector;
+                            const key = docs[item.idx].path;
+                            cache[key] = { hash: item.hash, vector };
+                            dirtyKeys.add(key);
+                        }
+                        catch (innerError) {
+                            const message = innerError instanceof Error ? innerError.message : String(innerError);
+                            process.stderr.write(`[contextpro/embeddings] degraded: single-item embed failed for ${docs[item.idx].path} (${message})\n`);
+                            delete cache[docs[item.idx].path];
+                        }
+                    }
+                }
+            })));
+            await saveCache(rootDir, cache, dirtyKeys);
+        }
+    }
+    async search(query, optionsOrTopK) {
+        const options = resolveSearchOptions(optionsOrTopK);
+        let queryVec;
+        try {
+            queryVec = options.semanticWeight === 0 || !this.vectors.some(vector => vector?.length) ? [] : await fetchQueryEmbedding(query);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[contextpro/embeddings] degraded: query embed failed (${message}); using keyword-only ranking\n`);
+            queryVec = [];
+        }
+        const queryTerms = new Set(searchTerms(query));
+        const candidates = [];
+        for (let i = 0; i < this.vectors.length; i++) {
+            const doc = this.documents[i];
+            const semanticScore = queryVec.length > 0 && this.vectors[i] ? cosine(queryVec, this.vectors[i]) : 0;
+            const matchedEntries = doc.symbolEntries ? getMatchedSymbolEntries(doc.symbolEntries, queryTerms) : [];
+            const matchedSymbols = matchedEntries.length > 0
+                ? matchedEntries.map((entry) => entry.name)
+                : getMatchedSymbols(doc.symbols, queryTerms);
+            const matchedSymbolLocations = matchedEntries.map((entry) => `${entry.name}@${formatLineRange(entry.line, entry.endLine)}`);
+            const keywordScore = computeKeywordScore(query, queryTerms, doc, matchedSymbols, this.lexicalDocuments[i], this.inverseFrequency);
+            if (options.requireSemanticMatch && semanticScore <= 0)
+                continue;
+            if (options.requireKeywordMatch && keywordScore <= 0)
+                continue;
+            if (Math.max(semanticScore, 0) < options.minSemanticScore)
+                continue;
+            if (keywordScore < options.minKeywordScore)
+                continue;
+            candidates.push({ idx: i, semanticScore, keywordScore, matchedSymbols, matchedSymbolLocations });
+        }
+        // RRF fuses by rank position across the filtered candidate set, so it's computed once over
+        // all of them rather than per-candidate like the weighted blend.
+        const rrfScores = options.fusion === "rrf"
+            ? reciprocalRankFusionScores(candidates.map((c) => c.semanticScore), candidates.map((c) => c.keywordScore))
+            : null;
+        const semanticAvailable = candidates.some((candidate) => candidate.semanticScore >= LOW_SEMANTIC_FLOOR);
+        const scores = candidates
+            .map((candidate, i) => ({
+            ...candidate,
+            score: dampLowSemanticScore(rrfScores
+                ? calibrateRrfScore(rrfScores[i], candidate.semanticScore, candidate.keywordScore)
+                : computeCombinedScore(candidate.semanticScore, candidate.keywordScore, options), candidate.semanticScore, candidate.keywordScore, semanticAvailable),
+        }))
+            .filter((candidate) => candidate.score >= options.minCombinedScore);
+        return scores
+            .sort((a, b) => b.score - a.score || b.keywordScore - a.keywordScore || b.semanticScore - a.semanticScore)
+            .slice(0, options.topK)
+            .map(({ idx, score, semanticScore, keywordScore, matchedSymbols, matchedSymbolLocations }) => {
+            const doc = this.documents[idx];
+            return {
+                path: doc.path,
+                score: Math.round(score * 10000) / 100,
+                semanticScore: Math.round(Math.max(semanticScore, 0) * 1000) / 10,
+                keywordScore: Math.round(keywordScore * 1000) / 10,
+                header: doc.header,
+                matchedSymbols,
+                matchedSymbolLocations,
+            };
+        });
+    }
+    getDocumentCount() {
+        return this.documents.length;
+    }
+}
+//# sourceMappingURL=embeddings.js.map