opencode-rag-plugin 1.21.1 → 1.21.2

package/dist/vectorstore/lancedb.d.ts

@@ -7,10 +7,28 @@ export type StoreWarn = (message: string) => void;
  * store holds one per built index, while a store whose index commits fail
  * accumulates one per attempt (and eventually degrades / corrupts).
  *
+ * Empty directories are the husks of pruned versions (Lance removes the files
+ * but leaves the directory behind) and are harmless — they must not count
+ * toward the corruption threshold.
+ *
  * @param tablePath - Filesystem path of the table directory (e.g. `.../chunks.lance`).
+ * @param options - `withFiles: true` counts only directories that still contain index files.
  * @returns The number of index-version directories, or 0 when unavailable.
  */
-export declare function countIndexVersionDirs(tablePath: string): number;
+export declare function countIndexVersionDirs(tablePath: string, options?: {
+    withFiles?: boolean;
+}): number;
+/**
+ * Remove stale empty index-version directories (husks of versions whose files
+ * Lance already pruned). Empty directories are never referenced by the index,
+ * so removing them is safe; only husks older than `MIN_HUSK_AGE_MS` are swept
+ * so a concurrent createIndex from another process can never lose its
+ * freshly-created (and momentarily empty) version directory.
+ *
+ * @param tablePath - Filesystem path of the table directory (e.g. `.../chunks.lance`).
+ * @returns The number of removed directories.
+ */
+export declare function sweepEmptyIndexVersionDirs(tablePath: string): number;
 /**
  * L2-normalize a vector to unit length. Cosine models require unit vectors
  * for the dot product to equal cosine similarity.

package/dist/vectorstore/lancedb.js

@@ -30,18 +30,75 @@ const MAX_STALE_INDEX_VERSIONS = 40;
  * store holds one per built index, while a store whose index commits fail
  * accumulates one per attempt (and eventually degrades / corrupts).
  *
+ * Empty directories are the husks of pruned versions (Lance removes the files
+ * but leaves the directory behind) and are harmless — they must not count
+ * toward the corruption threshold.
+ *
  * @param tablePath - Filesystem path of the table directory (e.g. `.../chunks.lance`).
+ * @param options - `withFiles: true` counts only directories that still contain index files.
  * @returns The number of index-version directories, or 0 when unavailable.
  */
-export function countIndexVersionDirs(tablePath) {
+export function countIndexVersionDirs(tablePath, options) {
     try {
         const entries = fsSync.readdirSync(path.join(tablePath, "_indices"), { withFileTypes: true });
-        return entries.filter((e) => e.isDirectory()).length;
+        const dirs = entries.filter((e) => e.isDirectory());
+        if (!options?.withFiles)
+            return dirs.length;
+        let count = 0;
+        for (const dir of dirs) {
+            try {
+                if (fsSync.readdirSync(path.join(tablePath, "_indices", dir.name)).length > 0)
+                    count++;
+            }
+            catch {
+                // unreadable dir — count it conservatively
+                count++;
+            }
+        }
+        return count;
     }
     catch {
         return 0;
     }
 }
+/**
+ * Remove stale empty index-version directories (husks of versions whose files
+ * Lance already pruned). Empty directories are never referenced by the index,
+ * so removing them is safe; only husks older than `MIN_HUSK_AGE_MS` are swept
+ * so a concurrent createIndex from another process can never lose its
+ * freshly-created (and momentarily empty) version directory.
+ *
+ * @param tablePath - Filesystem path of the table directory (e.g. `.../chunks.lance`).
+ * @returns The number of removed directories.
+ */
+export function sweepEmptyIndexVersionDirs(tablePath) {
+    const MIN_HUSK_AGE_MS = 10 * 60 * 1000;
+    let removed = 0;
+    try {
+        const indicesDir = path.join(tablePath, "_indices");
+        for (const name of fsSync.readdirSync(indicesDir)) {
+            const full = path.join(indicesDir, name);
+            try {
+                const stat = fsSync.statSync(full);
+                if (!stat.isDirectory())
+                    continue;
+                if (Date.now() - stat.mtimeMs < MIN_HUSK_AGE_MS)
+                    continue;
+                if (fsSync.readdirSync(full).length > 0)
+                    continue;
+                fsSync.rmdirSync(full);
+                removed++;
+            }
+            catch {
+                // best-effort — skip unreadable/racing entries
+            }
+        }
+    }
+    catch {
+        // best-effort
+    }
+    return removed;
+}
 /**
  * L2-normalize a vector to unit length. Cosine models require unit vectors
  * for the dot product to equal cosine similarity.
@@ -873,15 +930,16 @@ export class LanceDbStore {
         };
         try {
             // Guard against a store that never converges: each failed createIndex
-            // leaves a new index-version directory behind. If many stale versions
-            // accumulated, building yet another index only entrenches the problem.
-            // The store must be rebuilt instead (see doc/troubleshooting.md).
-            const staleVersions = this.dbPath.startsWith("memory://")
+            // leaves a new index-version directory behind. Empty directories are
+            // the husks of already-pruned versions and are harmless — only
+            // versions that still carry index files count (see countIndexVersionDirs).
+            const activeVersions = this.dbPath.startsWith("memory://")
                 ? 0
-                : countIndexVersionDirs(path.join(this.dbPath, TABLE_NAME + ".lance"));
-            if (staleVersions > MAX_STALE_INDEX_VERSIONS) {
-                report(`[lancedb] ${staleVersions} stale index versions detected in ${this.dbPath} — ` +
-                    `skipping index rebuild (the store is corrupted). Delete the rag_db directory and re-index.`);
+                : countIndexVersionDirs(path.join(this.dbPath, TABLE_NAME + ".lance"), { withFiles: true });
+            if (activeVersions > MAX_STALE_INDEX_VERSIONS) {
+                report(`[lancedb] ${activeVersions} active index versions detected in ${this.dbPath} — ` +
+                    `index rebuild skipped to avoid retrain churn. The store cannot converge; ` +
+                    `delete the rag_db directory and re-index.`);
                 // Resolve the memo so no further attempts run this process.
                 return;
             }
@@ -906,6 +964,16 @@ export class LanceDbStore {
                         // race a background index-creation from another process.
                         waitTimeoutSeconds: 120,
                     });
+                    // Verify the index actually registered. On a store whose index
+                    // commits never register, createIndex can return successfully
+                    // while leaving the table without a visible index — the failure
+                    // mode that caused constant retraining and "partition N is empty,
+                    // skipping" warning spam. Detect it and stop retraining.
+                    const verify = await table.indexStats(idxName).catch(() => undefined);
+                    if (!verify || verify.distanceType !== "cosine") {
+                        throw new Error(`index build did not register (store cannot converge) — ` +
+                            `delete the rag_db directory and re-index`);
+                    }
                     this.indexRepairFailures = 0;
                     return;
                 }
@@ -957,6 +1025,17 @@ export class LanceDbStore {
                     const threshold = new Date(Date.now() - 60 * 60 * 1000);
                     await table.optimize({ cleanupOlderThan: threshold, deleteUnverified: false });
                 }
+                // Remove stale empty index-version directories (husks Lance leaves
+                // behind after pruning a version's files). Keeps the directory count
+                // from growing unboundedly and prevents false positives in the
+                // index-repair stale-version guard.
+                if (!this.dbPath.startsWith("memory://")) {
+                    const swept = sweepEmptyIndexVersionDirs(path.join(this.dbPath, TABLE_NAME + ".lance"));
+                    if (swept > 0) {
+                        const message = `[lancedb] swept ${swept} stale index-version directories`;
+                        (options?.logger ?? console.warn)(message);
+                    }
+                }
                 // Build the ANN vector index — without it every vectorSearch() is a
                 // brute-force O(N) flat scan (slow at 50k+ chunks). Skips early when
                 // an index with the correct cosine metric already exists, and can be

package/package.json

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