opencode-rag-plugin 1.19.0 → 1.19.2

package/ReadMe.md

@@ -55,7 +55,7 @@ opencode-rag query "authentication middleware"
 
 A browser-based dashboard for exploring the indexed vector database - browse and inspect chunks and evaluate the OpenCode sessions in terms of retrieved chunks, consumed tokens and more.
 
-![OpenCodeRAG Web UI](doc/assets/eval.png)
+![OpenCodeRAG Web UI](doc/assets/webui-dashboard.png)
 
 Launch with `opencode-rag ui`. See [Web UI documentation](doc/webui.md) for details.
 

package/dist/cli/commands/status.js

@@ -7,7 +7,7 @@
 import path from "node:path";
 import os from "node:os";
 import fs from "node:fs";
-import { c, resolveCliContext, cleanupContext, logCliError, logCliInfo, formatTimestamp } from "../format.js";
+import { c, resolveCliContext, logCliError, logCliInfo, formatTimestamp } from "../format.js";
 import { getIndexStatusSummary } from "../../indexer.js";
 import { getPackageMetadata } from "../helpers.js";
 import { checkForUpdate } from "../../core/version-check.js";
@@ -156,7 +156,9 @@ export function registerStatusCommand(program) {
                     }
                 }).catch(() => { });
             }
-            await cleanupContext(ctx);
+            // Force exit — avoid LanceDB close() hanging on Windows native bindings.
+            // Status is read-only so there's no state to lose.
+            process.exit(0);
         }
         catch (err) {
             const message = err.message || String(err);

package/dist/cli/index.d.ts

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /**
  * @fileoverview CLI entry point creating the Commander program, wiring all command modules, and handling auto-run detection.
  */

package/dist/cli/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /**
  * @fileoverview CLI entry point creating the Commander program, wiring all command modules, and handling auto-run detection.
  */

package/dist/core/config.js

@@ -114,7 +114,7 @@ export const DEFAULT_CONFIG = {
         minFileSizeBytes: 0,
         concurrency: 8,
         embedBatchSize: 100,
-        embedConcurrency: 6,
+        embedConcurrency: 3,
         ollamaMaxBatchSize: 500,
         descriptionConcurrency: 4,
         maxSvgSizeBytes: 1_048_576,
@@ -266,14 +266,14 @@ export const DEFAULT_CONFIG = {
     },
     memory: {
         enabled: true,
-        autoInject: false,
+        autoInject: true,
         minConfidence: 0.5,
-        recallMinScore: 0.72,
-        autoInjectMinScore: 0.6,
+        recallMinScore: 0.6,
+        autoInjectMinScore: 0.5,
         autoInjectLatencyBudgetMs: 2000,
         autoInjectTopK: 2,
         autoInjectMinTokenOverlap: 1,
-        passiveCapture: false,
+        passiveCapture: true,
         promptEnforcement: true,
         sessionEndExtraction: true,
         autoCaptureMaxPerTurn: 2,

package/dist/embedder/factory.d.ts

@@ -16,12 +16,16 @@ import type { RagConfig } from "../core/config.js";
  */
 export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
 /**
- * Embed a list of texts in batches with optional concurrency control.
+ * Embed a list of texts in batches with optional concurrency control and per-batch retry.
  *
  * Splits the input texts into chunks of `batchSize` and embeds them sequentially
  * (or concurrently when `concurrency > 1`). When concurrency is limited, uses
  * `p-limit` to cap the number of in-flight requests.
  *
+ * Each batch is retried up to `retryMax` times with exponential backoff. If all
+ * retries are exhausted, the batch is skipped and empty arrays are returned for
+ * those texts so the caller can still process successfully embedded batches.
+ *
  * @param embedder - The embedding provider to use
  * @param texts - Array of text strings to embed
  * @param batchSize - Number of texts per batch (default 10)
@@ -29,6 +33,9 @@ export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
  * @param onProgress - Optional callback invoked after each batch with the running
  *   completed count and total; per-text granularity when `concurrency <= 1`.
- * @returns A promise resolving to a flat array of embedding vectors (one per input text)
+ * @param retryMax - Maximum retry attempts per batch (default 3)
+ * @param retryBaseDelayMs - Base delay for exponential backoff (default 1000)
+ * @returns A promise resolving to a flat array of embedding vectors (one per input text);
+ *   failed batches return empty arrays
  */
-export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void): Promise<number[][]>;
+export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void, retryMax?: number, retryBaseDelayMs?: number): Promise<number[][]>;

package/dist/embedder/factory.js

@@ -35,12 +35,16 @@ export function createEmbedder(config) {
     throw new Error(`Unknown embedding provider: ${provider}`);
 }
 /**
- * Embed a list of texts in batches with optional concurrency control.
+ * Embed a list of texts in batches with optional concurrency control and per-batch retry.
  *
  * Splits the input texts into chunks of `batchSize` and embeds them sequentially
  * (or concurrently when `concurrency > 1`). When concurrency is limited, uses
  * `p-limit` to cap the number of in-flight requests.
  *
+ * Each batch is retried up to `retryMax` times with exponential backoff. If all
+ * retries are exhausted, the batch is skipped and empty arrays are returned for
+ * those texts so the caller can still process successfully embedded batches.
+ *
  * @param embedder - The embedding provider to use
  * @param texts - Array of text strings to embed
  * @param batchSize - Number of texts per batch (default 10)
@@ -48,31 +52,56 @@ export function createEmbedder(config) {
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
  * @param onProgress - Optional callback invoked after each batch with the running
  *   completed count and total; per-text granularity when `concurrency <= 1`.
- * @returns A promise resolving to a flat array of embedding vectors (one per input text)
+ * @param retryMax - Maximum retry attempts per batch (default 3)
+ * @param retryBaseDelayMs - Base delay for exponential backoff (default 1000)
+ * @returns A promise resolving to a flat array of embedding vectors (one per input text);
+ *   failed batches return empty arrays
  */
-export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress) {
+export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress, retryMax = 3, retryBaseDelayMs = 1000) {
     if (texts.length === 0)
         return [];
     const batches = [];
     for (let i = 0; i < texts.length; i += batchSize) {
         batches.push({ index: i, texts: texts.slice(i, i + batchSize) });
     }
+    async function embedWithRetry(batchTexts) {
+        for (let attempt = 0; attempt <= retryMax; attempt++) {
+            try {
+                return await embedder.embed(batchTexts, purpose);
+            }
+            catch (err) {
+                if (attempt < retryMax) {
+                    const delay = retryBaseDelayMs * Math.pow(2, attempt);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        return null;
+    }
     if (concurrency <= 1 || batches.length <= 1) {
         const results = [];
         for (const batch of batches) {
-            const embeddings = await embedder.embed(batch.texts, purpose);
-            results.push(...embeddings);
+            const embeddings = await embedWithRetry(batch.texts);
+            if (embeddings) {
+                results.push(...embeddings);
+            }
+            else {
+                for (let i = 0; i < batch.texts.length; i++) {
+                    results.push([]);
+                }
+            }
             onProgress?.(results.length, texts.length);
         }
         return results;
     }
-    const limit = pLimit(concurrency);
     let completedCount = 0;
+    const limit = pLimit(concurrency);
     const batchResults = await Promise.all(batches.map((batch) => limit(async () => {
-        const embeddings = await embedder.embed(batch.texts, purpose);
-        completedCount += embeddings.length;
+        const embeddings = await embedWithRetry(batch.texts);
+        const flatResult = embeddings ?? batch.texts.map(() => []);
+        completedCount += embeddings?.length ?? 0;
         onProgress?.(completedCount, texts.length);
-        return { index: batch.index, embeddings };
+        return { index: batch.index, embeddings: flatResult };
     })));
     batchResults.sort((a, b) => a.index - b.index);
     const results = [];

package/dist/indexer/pipeline.js

@@ -590,7 +590,7 @@ async function runIndexPassInner(options, logger) {
                     hash: prepared[fileIdx].hash,
                     chunkCount: 0, fileLabel: prepared[fileIdx].fileLabel,
                     isNew: false, isModified: false, isUnchanged: false, isEmpty: false,
-                    isTooSmall: false, isRemoved: true, hadChunks: false,
+                    isTooSmall: false, isRemoved: false, hadChunks: false,
                     descriptionFailed: prepared[fileIdx].descriptionFailed,
                 });
             }
@@ -639,14 +639,14 @@ async function runIndexPassInner(options, logger) {
         const result = {
             normalizedPath: prep.normalizedPath,
             hash: prep.hash,
-            chunkCount: prep.chunks?.length ?? 0,
+            chunkCount: validChunks.length,
             fileLabel: prep.fileLabel,
             isNew: !prep.isModified,
             isModified: prep.isModified,
             isUnchanged: false,
             isEmpty: false,
             isTooSmall: false,
-            isRemoved: validChunks.length === 0,
+            isRemoved: (prep.chunks?.length ?? 0) > 0 && validChunks.length === 0 ? false : validChunks.length === 0,
             hadChunks: (prep.chunks?.length ?? 0) > 0,
             descriptionFailed: prep.descriptionFailed,
             descHash: prep.descHash,

package/dist/vectorstore/lancedb.d.ts

@@ -10,6 +10,19 @@ export declare function l2Normalize(vec: number[]): number[];
  * @returns True if the error matches a known corruption pattern.
  */
 export declare function isCorruptionError(err: unknown): boolean;
+/**
+ * Check whether an error is a LanceDB transient transaction conflict
+ * (e.g. "Incompatible transaction: This Append transaction is incompatible
+ * with concurrent transaction Restore at version ...").
+ *
+ * These are recoverable by retrying after the conflicting transaction finishes.
+ * Cross-process writes are the primary source; in-process writes are serialized
+ * by the write lock.
+ *
+ * @param err - The error to inspect.
+ * @returns True if the error matches a transient transaction conflict.
+ */
+export declare function isTransientConflictError(err: unknown): boolean;
 /**
  * Atomically replace one LanceDB store directory with another.
  * Swaps the real directory with a temporary one that was built during a rebuild.
@@ -31,6 +44,23 @@ export declare class LanceDbStore implements VectorStore {
     private table;
     private tableInit;
     private writeLock;
+    /**
+     * Execute an async function under an exclusive write lock.
+     *
+     * All write operations (addChunks, deleteByFilePath, optimize, tryRepair) must
+     * go through this helper to prevent concurrent LanceDB transactions from
+     * conflicting (e.g. Append vs Restore, which produces the "Incompatible
+     * transaction" error).
+     *
+     * The lock is a Promise chain: each caller chains onto `this.writeLock` and
+     * sets it to a new promise that resolves only when its operation finishes
+     * (or throws).  This guarantees FIFO serialization without any busy-waiting
+     * or timers.
+     *
+     * @param fn - The async function to execute under the lock.
+     * @returns The result of `fn`.
+     */
+    private withWriteLock;
     /**
      * @param dbPath - Filesystem path to the LanceDB database directory.
      * @param vectorDimension - Dimension of the embedding vectors. Default: 384.
@@ -191,4 +221,10 @@ export declare class LanceDbStore implements VectorStore {
      */
     private withCorruptionRecovery;
     private tryRepair;
+    /**
+     * Drop the existing chunks table and let getTable() create a fresh one.
+     * All indexed data is lost — callers should detect the empty table and
+     * trigger a re-index if needed.
+     */
+    private tryRebuildTable;
 }

package/dist/vectorstore/lancedb.js

@@ -27,9 +27,32 @@ export function l2Normalize(vec) {
  */
 export function isCorruptionError(err) {
     if (err instanceof Error) {
-        return (err.message.includes("Not found") &&
+        return ((err.message.includes("Not found") &&
             err.message.includes(".lance") &&
-            err.message.includes("lance error"));
+            err.message.includes("lance error")) ||
+            // Database has an incompatible transaction (e.g. a Restore from a prior
+            // version that conflicts with new Appends).  This is a recoverable
+            // corruption — tryRepair() iterates prior versions to find a consistent one.
+            (err.message.includes("Incompatible transaction") &&
+                err.message.includes("version")));
+    }
+    return false;
+}
+/**
+ * Check whether an error is a LanceDB transient transaction conflict
+ * (e.g. "Incompatible transaction: This Append transaction is incompatible
+ * with concurrent transaction Restore at version ...").
+ *
+ * These are recoverable by retrying after the conflicting transaction finishes.
+ * Cross-process writes are the primary source; in-process writes are serialized
+ * by the write lock.
+ *
+ * @param err - The error to inspect.
+ * @returns True if the error matches a transient transaction conflict.
+ */
+export function isTransientConflictError(err) {
+    if (err instanceof Error) {
+        return err.message.includes("Incompatible transaction");
     }
     return false;
 }
@@ -76,6 +99,43 @@ export class LanceDbStore {
     table = null;
     tableInit = null;
     writeLock = Promise.resolve(void 0);
+    /**
+     * Execute an async function under an exclusive write lock.
+     *
+     * All write operations (addChunks, deleteByFilePath, optimize, tryRepair) must
+     * go through this helper to prevent concurrent LanceDB transactions from
+     * conflicting (e.g. Append vs Restore, which produces the "Incompatible
+     * transaction" error).
+     *
+     * The lock is a Promise chain: each caller chains onto `this.writeLock` and
+     * sets it to a new promise that resolves only when its operation finishes
+     * (or throws).  This guarantees FIFO serialization without any busy-waiting
+     * or timers.
+     *
+     * @param fn - The async function to execute under the lock.
+     * @returns The result of `fn`.
+     */
+    async withWriteLock(fn) {
+        const prev = this.writeLock;
+        let release = () => { };
+        this.writeLock = new Promise((resolve) => { release = resolve; });
+        await prev;
+        try {
+            return await fn();
+        }
+        catch (err) {
+            // Cross-process transient conflict (e.g. CLI vs plugin):
+            // wait briefly and retry once, still under the same lock hold.
+            if (isTransientConflictError(err)) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                return await fn();
+            }
+            throw err;
+        }
+        finally {
+            release();
+        }
+    }
     /**
      * @param dbPath - Filesystem path to the LanceDB database directory.
      * @param vectorDimension - Dimension of the embedding vectors. Default: 384.
@@ -242,21 +302,18 @@ export class LanceDbStore {
     async addChunks(chunks) {
         if (chunks.length === 0)
             return;
-        const done = this.writeLock.then(() => this.addChunksInternal(chunks));
-        this.writeLock = done.catch(() => { });
-        try {
-            await done;
-        }
-        catch (err) {
-            this.writeLock = Promise.resolve();
-            if (isCorruptionError(err) && await this.tryRepair()) {
-                const retry = this.addChunksInternal(chunks);
-                this.writeLock = retry.catch(() => { });
-                await retry;
-                return;
+        await this.withWriteLock(async () => {
+            try {
+                await this.addChunksInternal(chunks);
             }
-            throw err;
-        }
+            catch (err) {
+                if (isCorruptionError(err) && await this.tryRepair()) {
+                    await this.addChunksInternal(chunks);
+                    return;
+                }
+                throw err;
+            }
+        });
     }
     async addChunksInternal(chunks) {
         const table = await this.getTable();
@@ -343,7 +400,7 @@ export class LanceDbStore {
         }
         catch (err) {
             if (isCorruptionError(err)) {
-                const repaired = await this.tryRepair();
+                const repaired = await this.withWriteLock(() => this.tryRepair());
                 if (repaired) {
                     return this.searchInternal(embedding, topK, filter);
                 }
@@ -577,19 +634,21 @@ export class LanceDbStore {
      * Should be called at the end of a successful index pass.
      */
     async optimize() {
-        try {
-            const table = await this.getTable();
-            // Clean up versions older than 1 hour — not "right now" — so in-flight
-            // queries (e.g. Web UI search, background auto-index) can finish before
-            // their data files are reclaimed.  Using new Date() here caused data-file
-            // race conditions where a reader got "Not found: … .lance" because the
-            // 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 });
-        }
-        catch {
-            // Optimize is best-effort — must not break indexing.
-        }
+        await this.withWriteLock(async () => {
+            try {
+                const table = await this.getTable();
+                // Clean up versions older than 1 hour �?" not "right now" �?" so in-flight
+                // queries (e.g. Web UI search, background auto-index) can finish before
+                // their data files are reclaimed.  Using new Date() here caused data-file
+                // race conditions where a reader got "Not found: �?� .lance" because the
+                // 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 });
+            }
+            catch {
+                // Optimize is best-effort �?" must not break indexing.
+            }
+        });
     }
     /**
      * Return all unique file paths currently stored in the index.
@@ -727,16 +786,18 @@ export class LanceDbStore {
      * @param filePath - The file path whose chunks should be deleted.
      */
     async deleteByFilePath(filePath) {
-        try {
-            await this.deleteByFilePathInternal(filePath);
-        }
-        catch (err) {
-            if (isCorruptionError(err) && await this.tryRepair()) {
+        await this.withWriteLock(async () => {
+            try {
                 await this.deleteByFilePathInternal(filePath);
-                return;
             }
-            throw err;
-        }
+            catch (err) {
+                if (isCorruptionError(err) && await this.tryRepair()) {
+                    await this.deleteByFilePathInternal(filePath);
+                    return;
+                }
+                throw err;
+            }
+        });
     }
     async deleteByFilePathInternal(filePath) {
         const db = await this.getDb();
@@ -791,8 +852,13 @@ export class LanceDbStore {
             return await fn();
         }
         catch (err) {
-            if (isCorruptionError(err) && await this.tryRepair()) {
-                return fn();
+            if (isCorruptionError(err)) {
+                // Repair must be under writeLock to prevent Restore from conflicting
+                // with concurrent Append transactions (addChunks / deleteByFilePath).
+                const repaired = await this.withWriteLock(() => this.tryRepair());
+                if (repaired) {
+                    return fn();
+                }
             }
             throw err;
         }
@@ -823,7 +889,7 @@ export class LanceDbStore {
                 return false;
             }
             if (versions.length <= 1) {
-                return false;
+                return this.tryRebuildTable(db);
             }
             const sorted = [...versions].sort((a, b) => b.version - a.version);
             for (const ver of sorted.slice(1)) {
@@ -839,10 +905,29 @@ export class LanceDbStore {
                     continue;
                 }
             }
-            console.error("[lancedb] All version-restore attempts failed. " +
-                "Run 'opencode-rag index --force' to rebuild the index.");
+            // All version-restore attempts failed (likely corrupted version graph
+            // with incompatible Restore transactions).  Drop and recreate the table.
+            console.warn("[lancedb] Version restore failed. Dropping and recreating table to recover from corrupt version graph.");
+            return this.tryRebuildTable(db);
+        }
+        catch {
             return false;
         }
+    }
+    /**
+     * Drop the existing chunks table and let getTable() create a fresh one.
+     * All indexed data is lost — callers should detect the empty table and
+     * trigger a re-index if needed.
+     */
+    async tryRebuildTable(db) {
+        try {
+            await db.dropTable(TABLE_NAME).catch(() => { });
+            this.table = null;
+            // Re-create fresh via getTable → initTable
+            await this.getTable();
+            console.warn("[lancedb] Table recreated from scratch after corruption recovery.");
+            return true;
+        }
         catch {
             return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-rag-plugin",
-  "version": "1.19.0",
+  "version": "1.19.2",
   "description": "OpenCode plugin for local-first RAG-based semantic code search",
   "type": "module",
   "main": "./dist/plugin-entry.js",