ragcode-context-engine 0.1.0

package/dist/src/semantic/lance-semantic-store.js

@@ -0,0 +1,623 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { renderChunkForEmbedding } from "./in-memory-semantic-store.js";
+export class LanceSemanticStore {
+    uri;
+    tablePromise;
+    tableName;
+    connection;
+    module;
+    vectorDimensions;
+    embeddingProfile;
+    profileStore;
+    embeddingBatchSize;
+    embeddingConcurrency;
+    embeddingRetryAttempts;
+    embeddingRetryBaseDelayMs;
+    repairOnMismatch;
+    maxChunks;
+    onProgress;
+    constructor(uri, tableNameOrOptions = "code_chunks") {
+        this.uri = uri;
+        if (typeof tableNameOrOptions === "string") {
+            this.tableName = tableNameOrOptions;
+            this.embeddingProfile = { provider: "unknown" };
+            this.profileStore = defaultProfileStore(uri, this.tableName);
+            this.embeddingBatchSize = 64;
+            this.embeddingConcurrency = 1;
+            this.embeddingRetryAttempts = 3;
+            this.embeddingRetryBaseDelayMs = 100;
+            this.repairOnMismatch = true;
+            return;
+        }
+        this.tableName = tableNameOrOptions.tableName ?? "code_chunks";
+        this.connection = tableNameOrOptions.connection;
+        this.module = tableNameOrOptions.module;
+        this.vectorDimensions = tableNameOrOptions.vectorDimensions;
+        this.embeddingProfile = tableNameOrOptions.embeddingProfile ?? { provider: "unknown" };
+        this.profileStore = tableNameOrOptions.profileStore ?? defaultProfileStore(uri, this.tableName);
+        this.embeddingBatchSize = positiveInteger(tableNameOrOptions.embeddingBatchSize, 64);
+        this.embeddingConcurrency = positiveInteger(tableNameOrOptions.embeddingConcurrency, 1);
+        this.embeddingRetryAttempts = positiveInteger(tableNameOrOptions.embeddingRetryAttempts, 3);
+        this.embeddingRetryBaseDelayMs = positiveInteger(tableNameOrOptions.embeddingRetryBaseDelayMs, 100);
+        this.repairOnMismatch = tableNameOrOptions.repairOnMismatch ?? true;
+        this.maxChunks = tableNameOrOptions.maxChunks;
+        this.onProgress = tableNameOrOptions.onProgress;
+    }
+    async needsRebuild(_repoRoot, _projectId) {
+        const profile = await this.profileStore.read();
+        if (!profile)
+            return true;
+        const table = await this.getExistingTable(profile.dimensions, { repair: false }).catch(() => undefined);
+        return !table;
+    }
+    async resetRepo(repoRoot) {
+        const table = await this.getExistingTable();
+        if (!table) {
+            const dimensions = this.vectorDimensions ?? 64;
+            await this.getTable(dimensions, [emptySeedRecord(dimensions)]);
+            return;
+        }
+        await table.delete(equalsPredicate("repoRoot", repoRoot));
+    }
+    async deleteFile(_repoRoot, projectId, filePath) {
+        const table = await this.getExistingTable();
+        if (!table)
+            return;
+        await table.delete(andPredicate(equalsPredicate("projectId", projectId), equalsPredicate("filePath", filePath)));
+    }
+    async upsertChunks(chunks, provider, generation = 1) {
+        if (chunks.length === 0)
+            return;
+        const selectedChunks = selectChunksForEmbedding(chunks, this.maxChunks);
+        const knownDimensions = provider.dimensions ?? this.vectorDimensions;
+        const repairedBeforeReuse = knownDimensions ? await this.ensureCompatibleProfile(knownDimensions) : false;
+        let table = repairedBeforeReuse ? undefined : await this.getExistingTable(knownDimensions);
+        let { chunksToEmbed, reusedRows } = table
+            ? await this.planChunkEmbeddings(table, selectedChunks, generation)
+            : { chunksToEmbed: selectedChunks, reusedRows: [] };
+        if (table)
+            await this.deleteFileScopesForChunks(table, chunks);
+        const reusedVectorDimensions = reusedRows[0]?.vector.length;
+        if (reusedVectorDimensions) {
+            const repaired = await this.ensureCompatibleProfile(reusedVectorDimensions);
+            if (repaired) {
+                table = undefined;
+                chunksToEmbed = selectedChunks;
+                reusedRows = [];
+            }
+            else {
+                table = await this.addRows(table, reusedRows);
+            }
+        }
+        if (chunksToEmbed.length === 0)
+            return;
+        const batches = chunkArray(chunksToEmbed, this.embeddingBatchSize);
+        let completedChunks = 0;
+        const startedAt = Date.now();
+        for (let start = 0; start < batches.length; start += this.embeddingConcurrency) {
+            const window = batches.slice(start, start + this.embeddingConcurrency);
+            const settled = await Promise.allSettled(window.map((batch) => this.embedChunkBatch(batch, provider, generation)));
+            for (let offset = 0; offset < settled.length; offset += 1) {
+                const outcome = settled[offset];
+                if (outcome.status !== "fulfilled")
+                    continue;
+                const rows = outcome.value;
+                const vectorDimensions = rows[0]?.vector.length;
+                if (!vectorDimensions)
+                    continue;
+                const repaired = await this.ensureCompatibleProfile(vectorDimensions);
+                if (repaired)
+                    table = undefined;
+                table = await this.addRows(table, rows);
+                completedChunks += rows.length;
+                this.onProgress?.({
+                    totalChunks: chunksToEmbed.length,
+                    completedChunks,
+                    batchChunks: rows.length,
+                    batchIndex: start + offset + 1,
+                    batchCount: batches.length,
+                    elapsedMs: Date.now() - startedAt
+                });
+            }
+            // Surface a failure only after persisting every batch that succeeded in this window, so
+            // one transient error never discards (and forces re-embedding of) already-completed batches.
+            const failure = settled.find((outcome) => outcome.status === "rejected");
+            if (failure)
+                throw failure.reason;
+        }
+    }
+    async embedChunkBatch(chunks, provider, generation) {
+        const texts = chunks.map((chunk) => renderChunkForEmbedding(chunk));
+        const vectors = await retryEmbedding(() => provider.embedBatch ? provider.embedBatch(texts) : Promise.all(texts.map((text) => provider.embed(text))), {
+            attempts: this.embeddingRetryAttempts,
+            baseDelayMs: this.embeddingRetryBaseDelayMs
+        });
+        if (vectors.length !== chunks.length) {
+            throw new Error(`Embedding provider returned ${vectors.length} vector(s), expected ${chunks.length}.`);
+        }
+        return chunks.map((chunk, index) => ({
+            id: chunk.id,
+            projectId: chunk.projectId,
+            repoRoot: chunk.repoRoot,
+            filePath: chunk.filePath,
+            language: chunk.language,
+            kind: chunk.kind,
+            symbolName: chunk.symbolName ?? "",
+            startLine: chunk.startLine,
+            endLine: chunk.endLine,
+            content: chunk.content,
+            contentHash: chunk.contentHash,
+            generation,
+            vector: vectors[index]
+        }));
+    }
+    async deleteFileScopesForChunks(table, chunks) {
+        const fileScopes = new Set(chunks.map((chunk) => JSON.stringify([chunk.projectId, chunk.filePath])));
+        for (const fileScope of fileScopes) {
+            const [projectId, filePath] = JSON.parse(fileScope);
+            await table.delete(andPredicate(equalsPredicate("projectId", projectId), equalsPredicate("filePath", filePath), "id != '__seed__'"));
+        }
+    }
+    async planChunkEmbeddings(table, chunks, generation) {
+        if (!table.query)
+            return { chunksToEmbed: chunks, reusedRows: [] };
+        const reusableVectors = await this.loadReusableVectors(table, chunks);
+        const chunksToEmbed = [];
+        const reusedRows = [];
+        for (const chunk of chunks) {
+            const vector = reusableVectors.get(reuseVectorKey(chunk.projectId, chunk.contentHash));
+            if (vector)
+                reusedRows.push(rowForChunk(chunk, vector, generation));
+            else
+                chunksToEmbed.push(chunk);
+        }
+        return { chunksToEmbed, reusedRows };
+    }
+    async loadReusableVectors(table, chunks) {
+        const vectors = new Map();
+        if (!table.query)
+            return vectors;
+        const hashesByProject = new Map();
+        for (const chunk of chunks) {
+            const existing = hashesByProject.get(chunk.projectId);
+            if (existing)
+                existing.add(chunk.contentHash);
+            else
+                hashesByProject.set(chunk.projectId, new Set([chunk.contentHash]));
+        }
+        for (const [projectId, hashSet] of hashesByProject) {
+            // One batched IN-query per project (chunked to keep predicates bounded) replaces the
+            // former one-round-trip-per-chunk lookup. A truncated batch only lowers the reuse hit
+            // rate (those chunks get re-embedded) and never reuses a stale vector.
+            for (const batch of chunkArray([...hashSet], REUSE_LOOKUP_BATCH)) {
+                const rows = await table.query()
+                    .where(andPredicate(equalsPredicate("projectId", projectId), inPredicate("contentHash", batch)))
+                    .limit(batch.length * REUSE_LOOKUP_ROW_MULTIPLIER)
+                    .toArray();
+                for (const reusable of rows) {
+                    const key = reuseVectorKey(projectId, reusable.contentHash);
+                    // A vector read back from LanceDB is an Arrow Vector, not a plain number[]; re-adding it
+                    // verbatim makes the next table.add() fail Arrow schema inference ("vector.isValid").
+                    // Materialize a plain number[] so reused rows write back cleanly on real LanceDB.
+                    if (!vectors.has(key))
+                        vectors.set(key, Array.from(reusable.vector));
+                }
+            }
+        }
+        return vectors;
+    }
+    async search(query, provider) {
+        const vector = await retryEmbedding(() => provider.embed(query.query), {
+            attempts: this.embeddingRetryAttempts,
+            baseDelayMs: this.embeddingRetryBaseDelayMs
+        });
+        const repaired = await this.ensureCompatibleProfile(vector.length);
+        if (repaired)
+            return [];
+        const table = await this.getExistingTable(vector.length);
+        if (!table)
+            return [];
+        const predicate = searchPredicate(query);
+        const rows = await table
+            .search(vector)
+            .where(predicate)
+            .limit(query.limit ?? 20)
+            .toArray();
+        return rows.filter((row) => row.id !== "__seed__").map((row) => ({
+            chunk: {
+                id: row.id,
+                projectId: row.projectId,
+                repoRoot: row.repoRoot,
+                filePath: row.filePath,
+                language: row.language,
+                kind: row.kind,
+                symbolName: row.symbolName || undefined,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                content: row.content,
+                contentHash: row.contentHash
+            },
+            score: 1 / (1 + (row._distance ?? 0)),
+            source: "semantic",
+            reason: "LanceDB vector similarity match"
+        }));
+    }
+    async getTable(vectorDimensions, seedRows) {
+        if (!this.tablePromise) {
+            this.tablePromise = this.openOrCreateTable(vectorDimensions, seedRows);
+        }
+        return this.tablePromise;
+    }
+    async getExistingTable(vectorDimensions, options = {}) {
+        const db = await this.getConnection();
+        const names = await db.tableNames();
+        if (!names.includes(this.tableName))
+            return undefined;
+        if (!this.tablePromise)
+            this.tablePromise = db.openTable(this.tableName);
+        const table = await this.tablePromise;
+        const problems = await tableSchemaProblems(table, vectorDimensions);
+        if (problems.length === 0)
+            return table;
+        const repair = options.repair ?? this.repairOnMismatch;
+        if (!repair)
+            throw new Error(`LanceDB table "${this.tableName}" schema mismatch: ${problems.join("; ")}.`);
+        await this.dropTableForRepair(db, problems);
+        return undefined;
+    }
+    async addRows(table, rows) {
+        const vectorDimensions = rows[0]?.vector.length;
+        if (!vectorDimensions)
+            throw new Error("Cannot write LanceDB rows without vector dimensions.");
+        if (!table)
+            return this.getTable(vectorDimensions, rows);
+        await deleteSeedRecord(table);
+        await table.add(rows);
+        return table;
+    }
+    async openOrCreateTable(vectorDimensions, seedRows) {
+        const db = await this.getConnection();
+        const names = await db.tableNames();
+        if (names.includes(this.tableName)) {
+            const table = await db.openTable(this.tableName);
+            const problems = await tableSchemaProblems(table, vectorDimensions);
+            if (problems.length > 0) {
+                await this.dropTableForRepair(db, problems);
+                if (seedRows?.length) {
+                    return db.createTable(this.tableName, seedRows);
+                }
+                const seedRow = emptySeedRecord(vectorDimensions);
+                const created = await db.createTable(this.tableName, [seedRow]);
+                return created;
+            }
+            if (seedRows?.length) {
+                await deleteSeedRecord(table);
+                await table.add(seedRows);
+            }
+            return table;
+        }
+        if (seedRows?.length) {
+            return db.createTable(this.tableName, seedRows);
+        }
+        const seedRow = emptySeedRecord(vectorDimensions);
+        return db.createTable(this.tableName, [seedRow]);
+    }
+    async getConnection() {
+        return this.connection ?? await (this.module ?? await loadLanceDb()).connect(this.uri);
+    }
+    async ensureCompatibleProfile(dimensions) {
+        const expected = this.expectedProfile(dimensions);
+        const existing = await this.profileStore.read();
+        if (!existing) {
+            await this.profileStore.write(expected);
+            return false;
+        }
+        const mismatches = profileMismatches(existing, expected);
+        if (mismatches.length > 0) {
+            if (!this.repairOnMismatch) {
+                throw new Error(`LanceDB embedding profile mismatch for table "${this.tableName}": ${mismatches.join("; ")}. Re-index into a new LanceDB URI/table or clear the existing semantic table/profile.`);
+            }
+            await this.dropTableForRepair(await this.getConnection(), mismatches);
+            await this.profileStore.write(expected);
+            return true;
+        }
+        return false;
+    }
+    async dropTableForRepair(db, reasons) {
+        if (!db.dropTable) {
+            throw new Error(`LanceDB table "${this.tableName}" requires repair but the current connection cannot drop/recreate tables: ${reasons.join("; ")}.`);
+        }
+        this.tablePromise = undefined;
+        await db.dropTable(this.tableName);
+    }
+    expectedProfile(dimensions) {
+        const now = Date.now();
+        return {
+            schemaVersion: 1,
+            tableName: this.tableName,
+            provider: this.embeddingProfile.provider,
+            model: this.embeddingProfile.model,
+            baseUrl: this.embeddingProfile.baseUrl,
+            requestDimensions: this.embeddingProfile.requestDimensions,
+            dimensions,
+            createdAtMs: now,
+            updatedAtMs: now
+        };
+    }
+}
+function rowForChunk(chunk, vector, generation) {
+    return {
+        id: chunk.id,
+        projectId: chunk.projectId,
+        repoRoot: chunk.repoRoot,
+        filePath: chunk.filePath,
+        language: chunk.language,
+        kind: chunk.kind,
+        symbolName: chunk.symbolName ?? "",
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        content: chunk.content,
+        contentHash: chunk.contentHash,
+        generation,
+        vector
+    };
+}
+async function retryEmbedding(operation, options) {
+    let lastError;
+    for (let attempt = 1; attempt <= options.attempts; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= options.attempts || !isRetryableEmbeddingError(error))
+                break;
+            await sleep(options.baseDelayMs * 2 ** (attempt - 1));
+        }
+    }
+    throw lastError;
+}
+function isRetryableEmbeddingError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    if (candidate.status === 429 || candidate.status === 408 || (candidate.status !== undefined && candidate.status >= 500))
+        return true;
+    // Node/undici network failures surface the code on error.cause, not the top-level error.
+    const text = `${candidate.code ?? ""} ${candidate.cause?.code ?? ""} ${candidate.message ?? ""}`.toLowerCase();
+    return /rate|timeout|temporar|econnreset|etimedout|429|5\d\d/.test(text);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function selectChunksForEmbedding(chunks, maxChunks) {
+    if (maxChunks === undefined || chunks.length <= maxChunks)
+        return chunks;
+    return chunks
+        .map((chunk, index) => ({ chunk, index, priority: semanticChunkPriority(chunk) }))
+        .sort((a, b) => a.priority - b.priority || a.index - b.index)
+        .slice(0, maxChunks)
+        .sort((a, b) => a.index - b.index)
+        .map((entry) => entry.chunk);
+}
+function semanticChunkPriority(chunk) {
+    switch (chunk.kind) {
+        case "function":
+        case "method":
+            return 0;
+        case "class":
+        case "type":
+            return 1;
+        case "file":
+            return 2;
+        case "block":
+            return 3;
+        case "variable":
+            return 4;
+        default:
+            return 5;
+    }
+}
+function chunkArray(items, size) {
+    const batches = [];
+    for (let index = 0; index < items.length; index += size) {
+        batches.push(items.slice(index, index + size));
+    }
+    return batches;
+}
+function positiveInteger(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value <= 0)
+        throw new Error(`Invalid positive integer: ${value}`);
+    return value;
+}
+function profileMismatches(existing, expected) {
+    const mismatches = [];
+    if (existing.schemaVersion !== expected.schemaVersion)
+        mismatches.push(`schemaVersion ${existing.schemaVersion} != ${expected.schemaVersion}`);
+    if (existing.tableName !== expected.tableName)
+        mismatches.push(`tableName ${existing.tableName} != ${expected.tableName}`);
+    if (existing.provider !== expected.provider)
+        mismatches.push(`provider ${existing.provider} != ${expected.provider}`);
+    if ((existing.model ?? "") !== (expected.model ?? ""))
+        mismatches.push(`model ${existing.model ?? "<unset>"} != ${expected.model ?? "<unset>"}`);
+    if ((existing.baseUrl ?? "") !== (expected.baseUrl ?? ""))
+        mismatches.push(`baseUrl ${existing.baseUrl ?? "<unset>"} != ${expected.baseUrl ?? "<unset>"}`);
+    if (Boolean(existing.requestDimensions) !== Boolean(expected.requestDimensions))
+        mismatches.push(`requestDimensions ${Boolean(existing.requestDimensions)} != ${Boolean(expected.requestDimensions)}`);
+    if (existing.dimensions !== expected.dimensions)
+        mismatches.push(`dimensions ${existing.dimensions} != ${expected.dimensions}`);
+    return mismatches;
+}
+function defaultProfileStore(uri, tableName) {
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(uri)) {
+        return new MemoryLanceProfileStore(`${uri}::${tableName}`);
+    }
+    return new FileLanceProfileStore(path.join(uri, `${tableName}.embedding-profile.json`));
+}
+const memoryProfiles = new Map();
+class MemoryLanceProfileStore {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    async read() {
+        return memoryProfiles.get(this.key);
+    }
+    async write(profile) {
+        const existing = memoryProfiles.get(this.key);
+        memoryProfiles.set(this.key, {
+            ...profile,
+            createdAtMs: existing?.createdAtMs ?? profile.createdAtMs
+        });
+    }
+}
+class FileLanceProfileStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async read() {
+        const content = await fs.readFile(this.filePath, "utf8").catch(() => undefined);
+        if (!content)
+            return undefined;
+        const parsed = JSON.parse(content);
+        return parsed;
+    }
+    async write(profile) {
+        const existing = await this.read();
+        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+        await fs.writeFile(this.filePath, JSON.stringify({
+            ...profile,
+            createdAtMs: existing?.createdAtMs ?? profile.createdAtMs,
+            updatedAtMs: profile.updatedAtMs
+        }, null, 2));
+    }
+}
+async function loadLanceDb() {
+    try {
+        return await import("@lancedb/lancedb");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`LanceDB is not installed. Install @lancedb/lancedb to use LanceSemanticStore. Cause: ${message}`);
+    }
+}
+function emptySeedRecord(vectorDimensions) {
+    return {
+        id: "__seed__",
+        projectId: "__seed__",
+        repoRoot: "__seed__",
+        filePath: "__seed__",
+        language: "unknown",
+        kind: "block",
+        symbolName: "",
+        startLine: 0,
+        endLine: 0,
+        content: "seed",
+        contentHash: "seed",
+        generation: 1,
+        vector: new Array(vectorDimensions).fill(0)
+    };
+}
+async function tableSchemaProblems(table, vectorDimensions) {
+    const problems = [];
+    if (!table.schema)
+        return problems;
+    const schema = await table.schema();
+    const fields = schema.fields ?? [];
+    const fieldNames = new Set(fields.map((field) => field.name).filter((name) => typeof name === "string"));
+    for (const fieldName of requiredLanceFields) {
+        if (!fieldNames.has(fieldName))
+            problems.push(`missing column ${fieldName}`);
+    }
+    const vectorField = fields.find((field) => field.name === "vector");
+    const actualDimensions = vectorDimensionsFromField(vectorField);
+    if (vectorDimensions !== undefined && actualDimensions !== undefined && actualDimensions !== vectorDimensions) {
+        problems.push(`vector dimensions ${actualDimensions} != ${vectorDimensions}`);
+    }
+    return problems;
+}
+const requiredLanceFields = [
+    "id",
+    "projectId",
+    "repoRoot",
+    "filePath",
+    "language",
+    "kind",
+    "symbolName",
+    "startLine",
+    "endLine",
+    "content",
+    "contentHash",
+    "generation",
+    "vector"
+];
+function vectorDimensionsFromField(field) {
+    if (!field || typeof field !== "object")
+        return undefined;
+    const direct = field.vectorDimensions;
+    if (typeof direct === "number")
+        return direct;
+    const type = field.type ?? field.dataType;
+    return vectorDimensionsFromType(type);
+}
+function vectorDimensionsFromType(type) {
+    if (!type)
+        return undefined;
+    if (typeof type === "object") {
+        const candidate = type;
+        for (const key of ["listSize", "fixedSize", "dimension", "dimensions", "length"]) {
+            if (typeof candidate[key] === "number")
+                return candidate[key];
+        }
+        if (typeof candidate.toString === "function")
+            return vectorDimensionsFromType(candidate.toString());
+    }
+    if (typeof type === "string") {
+        const match = /(?:fixed_size_list|vector|float32|float64)[^0-9]*(\d+)/i.exec(type);
+        if (match)
+            return Number(match[1]);
+    }
+    return undefined;
+}
+async function deleteSeedRecord(table) {
+    await table.delete(equalsPredicate("id", "__seed__"));
+}
+function andPredicate(...predicates) {
+    return predicates.join(" AND ");
+}
+const REUSE_LOOKUP_BATCH = 512;
+const REUSE_LOOKUP_ROW_MULTIPLIER = 4;
+function inPredicate(column, values) {
+    if (values.length === 0)
+        return "1 = 0";
+    const list = values.map((value) => `'${escapeSqlLiteral(value)}'`).join(", ");
+    return `${identifier(column)} IN (${list})`;
+}
+function reuseVectorKey(projectId, contentHash) {
+    return `${projectId}${contentHash}`;
+}
+function equalsPredicate(column, value) {
+    return `${identifier(column)} = '${escapeSqlLiteral(value)}'`;
+}
+function identifier(value) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value))
+        throw new Error(`Invalid LanceDB predicate identifier: ${value}`);
+    return value;
+}
+function escapeSqlLiteral(value) {
+    // DataFusion (LanceDB's query engine) follows standard SQL: backslashes are literal inside
+    // string literals — only single quotes are escaped, by doubling. Doubling backslashes too
+    // made Windows paths (repoRoot from path.resolve) query as `\\` and miss the stored single `\`.
+    return value.replaceAll("'", "''");
+}
+function searchPredicate(query) {
+    if (query.projectId)
+        return equalsPredicate("projectId", query.projectId);
+    if (query.repoRoot)
+        return equalsPredicate("repoRoot", query.repoRoot);
+    throw new Error("Internal error: LanceDB semantic search requires a resolved projectId or repoRoot.");
+}

package/dist/src/semantic/openai-compatible-embedding.d.ts

@@ -0,0 +1,19 @@
+import type { EmbeddingProvider } from "../core/contracts.js";
+export interface OpenAICompatibleEmbeddingProviderOptions {
+    apiKey: string;
+    model: string;
+    baseUrl?: string;
+    dimensions?: number;
+    requestDimensions?: boolean;
+    fetch?: typeof fetch;
+}
+export declare class OpenAICompatibleEmbeddingProvider implements EmbeddingProvider {
+    private readonly options;
+    readonly dimensions?: number;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(options: OpenAICompatibleEmbeddingProviderOptions);
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    private requestEmbeddings;
+}