opencode-rag-plugin 1.21.0 → 1.21.2

package/dist/cli/commands/init-helpers.d.ts

@@ -21,8 +21,11 @@ export declare function buildWorkspacePackageJson(existing: Record<string, unkno
 /**
  * Build the `.opencode/opencode.json` config object.
  *
- * Ensures the `$schema` key is present and removes any stale `plugin`
- * entries that would trigger erroneous npm installs.
+ * Ensures the `$schema` key is present and removes stale `plugin` entries
+ * (which would trigger erroneous npm installs) plus stale MCP entries that
+ * are not valid local/remote server configs (e.g. a leftover
+ * `mcp.<name>: { enabled: true }` that OpenCode ignores with
+ * "Ignoring MCP config entry without type").
  *
  * @param existing - The existing opencode.json content (if any).
  * @returns The normalized config object.

package/dist/cli/commands/init-helpers.js

@@ -49,8 +49,11 @@ export function buildWorkspacePackageJson(existing, packageMetadata) {
 /**
  * Build the `.opencode/opencode.json` config object.
  *
- * Ensures the `$schema` key is present and removes any stale `plugin`
- * entries that would trigger erroneous npm installs.
+ * Ensures the `$schema` key is present and removes stale `plugin` entries
+ * (which would trigger erroneous npm installs) plus stale MCP entries that
+ * are not valid local/remote server configs (e.g. a leftover
+ * `mcp.<name>: { enabled: true }` that OpenCode ignores with
+ * "Ignoring MCP config entry without type").
  *
  * @param existing - The existing opencode.json content (if any).
  * @returns The normalized config object.
@@ -65,6 +68,27 @@ export function buildOpencodeConfig(existing) {
     // init versions would trigger npm install (which fails due to native
     // dependencies like sharp) and produce "Plugin export is not a function".
     delete next.plugin;
+    // Keep only MCP entries that look like real server configs (have a
+    // "type" of "local" or "remote"). Drop shorthand entries such as
+    // `{ enabled: true }` that OpenCode ignores at startup.
+    if (next.mcp && typeof next.mcp === "object" && !Array.isArray(next.mcp)) {
+        const mcp = next.mcp;
+        const valid = {};
+        for (const [name, value] of Object.entries(mcp)) {
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                const entry = value;
+                if (entry.type === "local" || entry.type === "remote") {
+                    valid[name] = value;
+                }
+            }
+        }
+        if (Object.keys(valid).length === 0) {
+            delete next.mcp;
+        }
+        else {
+            next.mcp = valid;
+        }
+    }
     return next;
 }
 /**

package/dist/core/interfaces.d.ts

@@ -209,9 +209,14 @@ export interface VectorStore {
      * accumulation.
      * @param options - `aggressive: true` prunes all but the current version
      *   (only safe when no other process reads the store, e.g. temp rebuilds).
+     *   `skipIndex: true` skips ANN index creation/repair (private temp stores
+     *   are never searched — the rebuild pipeline builds the index once at the
+     *   end). `logger` receives diagnostics instead of the console.
      */
     optimize?(options?: {
         aggressive?: boolean;
+        skipIndex?: boolean;
+        logger?: (message: string) => void;
     }): Promise<void>;
     /**
      * Verify that the store's data is actually readable.

package/dist/indexer/pipeline.js

@@ -528,6 +528,11 @@ async function runIndexPassInner(options, logger) {
             prep.chunks = undefined;
             prep.textToEmbed = undefined;
         }
+        // Number of files whose chunks were actually bulk-written this window.
+        // The caller uses this to skip mid-run compaction on idle passes that
+        // wrote nothing (no fragments were added, so nothing needs compacting,
+        // and the store avoids unnecessary index-repair churn).
+        return storePayloads.length;
     }
     // ── Windowed pipeline ────────────────────────────────────────────────────
     // The prepare→describe→embed→store chain used to materialize ALL chunks,
@@ -833,12 +838,18 @@ async function runIndexPassInner(options, logger) {
         // entries and skip every file ("Store phase: storing N → 0 files stored").
         prevStore = storeWindow(prepared, new Map(earlyWorkerResults));
         // Periodically compact fragments and prune old versions so the store
-        // phase doesn't slow down as the index grows during long runs.
+        // phase doesn't slow down as the index grows during long runs. Skipped on
+        // windows that wrote nothing — an idle pass (no changed files) adds no
+        // fragments, so compaction would only churn the index-repair path.
         if (optimizeInterval > 0 && windowCount % optimizeInterval === 0) {
-            await prevStore;
+            const storedInWindow = await prevStore;
             prevStore = null;
-            logger.info("Optimizing vector store (mid-run compaction, pruning old versions)...");
-            await effectiveStore.optimize?.(tempStorePath ? { aggressive: true } : undefined);
+            if (storedInWindow > 0) {
+                logger.info("Optimizing vector store (mid-run compaction, pruning old versions)...");
+                await effectiveStore.optimize?.(tempStorePath
+                    ? { aggressive: true, skipIndex: true, logger: logger.warn }
+                    : { logger: logger.warn });
+            }
         }
         if (abortedInWindow)
             break;
@@ -915,7 +926,7 @@ async function runIndexPassInner(options, logger) {
         const optimizeStart = Date.now();
         try {
             const optimizeTarget = tempStorePath ? options.store : effectiveStore;
-            await optimizeTarget.optimize?.(tempStorePath ? { aggressive: true } : undefined);
+            await optimizeTarget.optimize?.(tempStorePath ? { aggressive: true, logger: logger.warn } : { logger: logger.warn });
             logger.info(`Vector store optimized in ${((Date.now() - optimizeStart) / 1000).toFixed(1)}s`);
         }
         catch (err) {

package/dist/vectorstore/lancedb.d.ts

@@ -1,4 +1,34 @@
 import type { VectorStore, Chunk, ChunkSummary, SearchResult, MetadataFilter } from "../core/interfaces.js";
+/** Minimal warning sink for store diagnostics (defaults to console.warn). */
+export type StoreWarn = (message: string) => void;
+/**
+ * Count index-version directories in a LanceDB table directory. Each
+ * `createIndex` writes a new `<uuid>/` directory under `_indices`; a healthy
+ * 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, 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.
@@ -62,6 +92,8 @@ export declare class LanceDbStore implements VectorStore {
      * back to brute-force. This repairs that stale index on first search.
      */
     private indexRepairPromise;
+    /** Consecutive failed repair attempts — bounded so a broken store cannot retrain forever. */
+    private indexRepairFailures;
     /**
      * Execute an async function under an exclusive write lock.
      *
@@ -245,6 +277,8 @@ export declare class LanceDbStore implements VectorStore {
      */
     optimize(options?: {
         aggressive?: boolean;
+        skipIndex?: boolean;
+        logger?: StoreWarn;
     }): Promise<void>;
     /**
      * Return all unique file paths currently stored in the index.

package/dist/vectorstore/lancedb.js

@@ -3,11 +3,102 @@
  */
 import * as lancedb from "@lancedb/lancedb";
 import fs from "node:fs/promises";
+import fsSync from "node:fs";
 import path from "node:path";
 import { normalizeFilePath, manifestPathFor } from "../core/manifest.js";
 import { normalizeFileExtensions, matchesFileExtension } from "../core/filters.js";
 const TABLE_NAME = "chunks";
 const QUERY_COLUMNS = ["id", "content", "description", "filePath", "startLine", "endLine", "language", "kind", "quirkType", "tags"];
+/**
+ * Upper bound for the number of failed index-creation attempts per process.
+ * Beyond this the repair gives up for the process lifetime instead of
+ * retraining the IVF index on every optimize/search call (each attempt runs
+ * a full KMeans training pass and logs "partition N is empty, skipping").
+ */
+const MAX_INDEX_REPAIR_ATTEMPTS = 3;
+/**
+ * Upper bound for stale index-version directories under `chunks.lance/_indices`.
+ * Healthy stores have one per built index; a store whose index registration
+ * keeps failing accumulates one directory per attempt and never converges.
+ * Above this threshold the repair refuses to create yet another version and
+ * instead tells the user to rebuild the store.
+ */
+const MAX_STALE_INDEX_VERSIONS = 40;
+/**
+ * Count index-version directories in a LanceDB table directory. Each
+ * `createIndex` writes a new `<uuid>/` directory under `_indices`; a healthy
+ * 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, options) {
+    try {
+        const entries = fsSync.readdirSync(path.join(tablePath, "_indices"), { withFileTypes: true });
+        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.
@@ -108,6 +199,8 @@ export class LanceDbStore {
      * back to brute-force. This repairs that stale index on first search.
      */
     indexRepairPromise = null;
+    /** Consecutive failed repair attempts — bounded so a broken store cannot retrain forever. */
+    indexRepairFailures = 0;
     /**
      * Execute an async function under an exclusive write lock.
      *
@@ -817,9 +910,9 @@ export class LanceDbStore {
      * Callers must hold the write lock (searchInternal wraps the call in
      * withWriteLock; optimize runs under it already).
      */
-    ensureCosineIndex() {
+    ensureCosineIndex(warn) {
         if (!this.indexRepairPromise) {
-            this.indexRepairPromise = this.repairIndexMetricOnce();
+            this.indexRepairPromise = this.repairIndexMetricOnce(warn);
         }
         return this.indexRepairPromise;
     }
@@ -831,8 +924,25 @@ export class LanceDbStore {
      * stale index in place. On failure the memo is cleared so the next
      * search/optimize retries.
      */
-    async repairIndexMetricOnce() {
+    async repairIndexMetricOnce(warn) {
+        const report = (message) => {
+            (warn ?? console.warn)(message);
+        };
         try {
+            // Guard against a store that never converges: each failed createIndex
+            // 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"), { 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;
+            }
             const table = await this.getTable();
             const count = await table.countRows().catch(() => 0);
             const indices = await table.listIndices();
@@ -854,6 +964,17 @@ 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;
                 }
                 catch (err) {
@@ -866,9 +987,19 @@ export class LanceDbStore {
             }
         }
         catch (err) {
+            this.indexRepairFailures++;
+            const message = `[lancedb] index metric repair failed (queries continue in brute-force): ` +
+                `${err instanceof Error ? err.message : String(err)}`;
+            if (this.indexRepairFailures >= MAX_INDEX_REPAIR_ATTEMPTS) {
+                // Stop retrying for this process — a store that fails repeatedly would
+                // otherwise be retrained (with KMeans "partition empty" warning spam)
+                // on every optimize() and search() call.
+                report(`${message} — giving up after ${this.indexRepairFailures} attempts this session. ` +
+                    `Delete the rag_db directory and re-index.`);
+                return; // memo stays resolved: no further attempts this process
+            }
             this.indexRepairPromise = null; // allow retry on a later search/optimize
-            console.warn(`[lancedb] index metric repair failed (queries continue in brute-force): ` +
-                `${err instanceof Error ? err.message : String(err)}`);
+            report(message);
         }
     }
     /**
@@ -894,15 +1025,31 @@ 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.
-                await this.ensureCosineIndex();
+                // an index with the correct cosine metric already exists, and can be
+                // skipped entirely for a private temporary store that is never
+                // searched (the rebuild pipeline builds the index once at the end).
+                if (!options?.skipIndex) {
+                    await this.ensureCosineIndex(options?.logger);
+                }
             }
             catch (err) {
                 // Optimize is best-effort — must not break indexing, but surface the
                 // failure instead of swallowing it silently.
-                console.warn(`[lancedb] optimize failed: ${err instanceof Error ? err.message : String(err)}`);
+                const message = `[lancedb] optimize failed: ${err instanceof Error ? err.message : String(err)}`;
+                (options?.logger ?? console.warn)(message);
             }
         });
     }

package/dist/vectorstore/memory.d.ts

@@ -27,5 +27,7 @@ export declare class InMemoryVectorStore implements VectorStore {
     /** No-op for the in-memory store. */
     optimize(_options?: {
         aggressive?: boolean;
+        skipIndex?: boolean;
+        logger?: (message: string) => void;
     }): Promise<void>;
 }

package/package.json

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