opencode-rag-plugin 1.19.4 → 1.19.5

package/dist/vectorstore/lancedb.js

@@ -396,6 +396,12 @@ export class LanceDbStore {
     }
     async searchWithFilter(embedding, topK, filter) {
         try {
+            // Guard against dimension mismatch BEFORE the native call — LanceDB
+            // throws a cryptic error that used to be swallowed into "no results".
+            if (embedding.length !== this.vectorDimension) {
+                console.warn(`[lancedb] searchWithFilter: query embedding dimension ${embedding.length} != store dimension ${this.vectorDimension} — returning empty`);
+                return [];
+            }
             return await this.searchInternal(embedding, topK, filter);
         }
         catch (err) {
@@ -404,7 +410,12 @@ export class LanceDbStore {
                 if (repaired) {
                     return this.searchInternal(embedding, topK, filter);
                 }
+                console.warn(`[lancedb] searchWithFilter: repair failed: ${err.message}`);
+                return [];
             }
+            // Never silently mask non-corruption failures as "no results" —
+            // that hides provider outages and store bugs from every caller.
+            console.warn(`[lancedb] searchWithFilter failed (returning []): ${err.message}`);
             return [];
         }
     }
@@ -534,6 +545,104 @@ export class LanceDbStore {
             }));
         });
     }
+    /**
+     * Retrieve a paginated list of chunks without embeddings, with optional
+     * language and file-path filters pushed into the SQL WHERE clause.
+     *
+     * @param offset - Number of rows to skip (for pagination).
+     * @param limit - Maximum number of rows to return.
+     * @param lang - Optional exact language filter.
+     * @param filePrefix - Optional filePath prefix filter.
+     * @returns The page of chunks plus the total count of matching rows.
+     */
+    async getChunksFiltered(offset, limit, lang, filePrefix) {
+        const conditions = [];
+        if (lang)
+            conditions.push(`language = '${lang.replace(/'/g, "''")}'`);
+        if (filePrefix)
+            conditions.push(`filePath LIKE '${filePrefix.replace(/'/g, "''")}%'`);
+        const where = conditions.length > 0 ? conditions.join(" AND ") : undefined;
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            let query = table.query().select(QUERY_COLUMNS);
+            let countQuery = table.query().select(["id"]);
+            if (where) {
+                query = query.where(where);
+                countQuery = countQuery.where(where);
+            }
+            const [rows, countRows] = await Promise.all([
+                query.offset(Math.max(0, offset)).limit(Math.max(1, Math.min(limit, 1000))).toArray(),
+                countQuery.toArray(),
+            ]);
+            return {
+                chunks: rows.map((row) => ({
+                    id: row.id,
+                    filePath: row.filePath,
+                    language: row.language,
+                    startLine: row.startLine,
+                    endLine: row.endLine,
+                    content: row.content,
+                    description: row.description ?? "",
+                    kind: row.kind ?? "",
+                    quirkType: row.quirkType ?? "",
+                    tags: row.tags ?? "",
+                })),
+                total: countRows.length,
+            };
+        });
+    }
+    /** Look up a single chunk by its ID. Returns undefined when not found. */
+    async getChunkById(id) {
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const rows = await table.query()
+                .select(QUERY_COLUMNS)
+                .where(`id = '${id.replace(/'/g, "''")}'`)
+                .limit(1)
+                .toArray();
+            const row = rows[0];
+            if (!row)
+                return undefined;
+            return {
+                id: row.id,
+                filePath: row.filePath,
+                language: row.language,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                content: row.content,
+                description: row.description ?? "",
+                kind: row.kind ?? "",
+                quirkType: row.quirkType ?? "",
+                tags: row.tags ?? "",
+            };
+        });
+    }
+    /** Fetch chunks by their IDs (for the compare view). Bounded to 100 ids. */
+    async getChunksByIds(ids) {
+        const bounded = ids.slice(0, 100);
+        if (bounded.length === 0)
+            return [];
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const idList = bounded.map((id) => `'${id.replace(/'/g, "''")}'`).join(", ");
+            const rows = await table.query()
+                .select(QUERY_COLUMNS)
+                .where(`id IN (${idList})`)
+                .toArray();
+            return rows.map((row) => ({
+                id: row.id,
+                filePath: row.filePath,
+                language: row.language,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                content: row.content,
+                description: row.description ?? "",
+                kind: row.kind ?? "",
+                quirkType: row.quirkType ?? "",
+                tags: row.tags ?? "",
+            }));
+        });
+    }
     /**
      * Fetch chunks with their embedding vectors included (for embedding projection).
      * @param limit - Maximum number of rows to return.
@@ -614,8 +723,11 @@ export class LanceDbStore {
                 return 0;
             const table = await this.getTable();
             const COUNT_TIMEOUT_MS = 30_000;
+            // Attach a no-op catch to the race loser so a late rejection (after the
+            // timeout resolved `null`) cannot become an unhandled rejection.
+            const countPromise = table.countRows().catch(() => 0);
             const result = await Promise.race([
-                table.countRows(),
+                countPromise,
                 new Promise((resolve) => setTimeout(() => resolve(null), COUNT_TIMEOUT_MS)),
             ]);
             if (result === null) {
@@ -644,6 +756,21 @@ export class LanceDbStore {
                 // GC deleted fragments that the current version still referenced.
                 const threshold = new Date(Date.now() - 60 * 60 * 1000);
                 await table.optimize({ cleanupOlderThan: threshold, deleteUnverified: false });
+                // Build the ANN vector index — without it every vectorSearch() is a
+                // brute-force O(N) flat scan (slow at 50k+ chunks).
+                try {
+                    const count = await table.countRows().catch(() => 0);
+                    const numPartitions = count > 0 ? Math.max(16, Math.min(256, Math.floor(count / 256))) : 16;
+                    // The index metric MUST match the search metric ("cosine", see
+                    // searchInternal).  The ivfFlat default is "l2", which makes LanceDB
+                    // ignore the index and fall back to brute-force on every query.
+                    await table.createIndex("embedding", {
+                        config: lancedb.Index.ivfFlat({ numPartitions, distanceType: "cosine" }),
+                    });
+                }
+                catch {
+                    // Index creation is best-effort — queries still work, just slower.
+                }
             }
             catch {
                 // Optimize is best-effort �?" must not break indexing.
@@ -684,20 +811,39 @@ export class LanceDbStore {
      * @param newPath - Optional new filesystem path for the LanceDB database.
      */
     async reopen(newPath) {
-        await this.table?.close();
-        await this.db?.close();
-        this.table = null;
-        this.db = null;
-        this.tableInit = null;
+        await this.close();
         if (newPath)
             this.dbPath = newPath;
     }
-    /** Close the database connection and release resources. */
+    /**
+     * Close the database connection and release resources.
+     *
+     * The native LanceDB `close()` can hang indefinitely on Windows, so the
+     * whole close is raced against a timeout — callers (CLI commands, plugin
+     * reload, web server) must never block forever on shutdown.
+     */
     async close() {
-        await this.table?.close();
-        this.table = null;
-        await this.db?.close();
-        this.db = null;
+        await Promise.race([
+            (async () => {
+                try {
+                    await this.table?.close();
+                }
+                catch {
+                    // best-effort — the connection may already be gone
+                }
+                this.table = null;
+                try {
+                    await this.db?.close();
+                }
+                catch {
+                    // best-effort — the connection may already be gone
+                }
+                this.db = null;
+            })(),
+            new Promise((resolve) => {
+                setTimeout(resolve, 5000).unref();
+            }),
+        ]);
     }
     /**
      * Back up the chunks.lance directory before a destructive operation.

package/dist/vectorstore/memory.js

@@ -13,7 +13,11 @@ export class InMemoryVectorStore {
             .filter((c) => matchesFilter(c, filter))
             .map((chunk) => {
             const sim = cosineSimilarity(embedding, chunk.embedding);
-            return { chunk, score: sim };
+            // Normalize cosine [-1,1] into [0,1] so scores are comparable with
+            // the LanceDB store's clamped `1 - distance/2` domain (minScore and
+            // displayed scores mean the same thing across both stores).
+            const normalized = Math.min(1, Math.max(0, (sim + 1) / 2));
+            return { chunk, score: normalized };
         })
             .sort((a, b) => b.score - a.score)
             .slice(0, topK);

package/dist/watcher.js

@@ -37,7 +37,7 @@ export function createBackgroundIndexer(options) {
     const runPass = async (filterPaths) => {
         updateStatus({ running: true, lastRunAt: Date.now() });
         try {
-            await runIndexPass({
+            const stats = await runIndexPass({
                 cwd,
                 storePath,
                 config,
@@ -54,6 +54,20 @@ export function createBackgroundIndexer(options) {
                     debug: (message) => appendDebugLog(logFilePath, { scope: "autoIndex", message: `DEBUG: ${message}`, severity: "debug" }, logLevel),
                 },
             });
+            // A lock-skipped pass did NO work — retry shortly so the workspace
+            // does not stay unindexed until the next file event.
+            if (stats.skipped) {
+                appendDebugLog(logFilePath, {
+                    scope: "autoIndex",
+                    message: "Index pass skipped (another pass holds the lock) — retrying in 30s",
+                }, logLevel);
+                if (!ac.signal.aborted) {
+                    setTimeout(() => {
+                        if (!ac.signal.aborted)
+                            scheduler.notifyChange(filterPaths);
+                    }, 30_000).unref();
+                }
+            }
             updateStatus({ running: false, lastRunAt: Date.now() });
         }
         catch (err) {
@@ -106,21 +120,33 @@ export function createBackgroundIndexer(options) {
             error,
         }, logLevel);
     });
-    // Periodic timer: only needed for git backend (chokidar gets real FS events)
+    // Periodic timer: only needed for git backend (chokidar gets real FS events).
+    // Note: with git mode BOTH backends run — the scheduler coalesces redundant
+    // passes into one, so this only adds a safety net for missed events.
     const watcherBackend = autoIndexCfg.watcher ?? "chokidar";
     const periodicTimer = watcherBackend === "git"
         ? setInterval(() => {
             scheduler.notifyChange();
         }, autoIndexCfg.intervalMs)
         : undefined;
+    // Never keep the process alive just for the periodic scan
+    periodicTimer?.unref();
     return {
         async close() {
             if (periodicTimer)
                 clearInterval(periodicTimer);
             ac.abort();
             scheduler.close();
-            await scheduler.waitForIdle();
-            await watcher.close();
+            // chokidar close() can hang on some Windows setups — guard it like
+            // the CLI does.
+            await Promise.race([
+                scheduler.waitForIdle(),
+                new Promise((resolve) => setTimeout(resolve, 5000).unref()),
+            ]);
+            await Promise.race([
+                watcher.close(),
+                new Promise((resolve) => setTimeout(resolve, 5000).unref()),
+            ]);
             const statusPath = path.join(storePath, "watcher-status.json");
             if (existsSync(statusPath)) {
                 try {

package/dist/web/api.d.ts

@@ -28,7 +28,7 @@ interface ApiResponse {
  * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig, getEmbedder?: () => Promise<EmbeddingProvider>): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig, getEmbedder?: () => Promise<EmbeddingProvider>, token?: string): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 /**
  * Perform token-usage analysis for a single evaluation session.
  *
@@ -52,4 +52,8 @@ export declare function handleEvalTokenCompare(storePath: string, params: URLSea
  * `avgReadsPerQueryWithRAG`, `queryCount`.
  */
 export declare function handleEvalProjectSavings(body: unknown): ApiResponse;
+/** Thrown when the request body exceeds {@link MAX_BODY_BYTES}; mapped to a 413 response. */
+export declare class BodyTooLargeError extends Error {
+    constructor();
+}
 export {};