opencode-rag-plugin 1.19.1 → 1.19.2

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

@@ -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/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.1",
+  "version": "1.19.2",
   "description": "OpenCode plugin for local-first RAG-based semantic code search",
   "type": "module",
   "main": "./dist/plugin-entry.js",