@comfanion/usethis_search 3.0.0-dev.24 → 3.0.0-dev.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/usethis_search",
-  "version": "3.0.0-dev.24",
+  "version": "3.0.0-dev.25",
   "description": "OpenCode plugin: semantic search with graph-based context (v3: graph relations, 1-hop context, LSP + regex analyzers)",
   "type": "module",
   "main": "./index.ts",

package/tools/search.ts

@@ -10,7 +10,7 @@ import { tool } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
 
-import { CodebaseIndexer, getSearchConfig } from "../vectorizer/index.ts"
+import { CodebaseIndexer, getSearchConfig, getIndexer, releaseIndexer } from "../vectorizer/index.ts"
 
 // ── Extension → language mapping (for filter parsing) ─────────────────────
 const EXT_TO_LANG: Record<string, string> = {
@@ -133,9 +133,9 @@ Examples:
       // Freshen from config (default: false — auto_index handles it)
       if (cfg.freshen) {
         try {
-          const tempIndexer = await new CodebaseIndexer(projectRoot, indexName).init()
-          await tempIndexer.freshen()
-          await tempIndexer.unloadModel()
+          const indexer = await getIndexer(projectRoot, indexName)
+          await indexer.freshen()
+          releaseIndexer(projectRoot, indexName)
         } catch {
           // non-fatal — search can proceed without freshen
         }
@@ -144,19 +144,22 @@ Examples:
       let allResults: any[] = []
 
       if (args.searchAll) {
-        const tempIndexer = await new CodebaseIndexer(projectRoot, "code").init()
+        const tempIndexer = await getIndexer(projectRoot, "code")
         const indexes = await tempIndexer.listIndexes()
-        await tempIndexer.unloadModel()
+        releaseIndexer(projectRoot, "code")
 
         if (indexes.length === 0) {
           return `No indexes found. The codebase needs to be indexed first.\n\nRun the CLI: bunx usethis_search reindex`
         }
 
         for (const idx of indexes) {
-          const indexer = await new CodebaseIndexer(projectRoot, idx).init()
-          const results = await indexer.search(args.query, limit, includeArchived, searchOptions)
-          allResults.push(...results.map((r: any) => ({ ...r, _index: idx })))
-          await indexer.unloadModel()
+          const indexer = await getIndexer(projectRoot, idx)
+          try {
+            const results = await indexer.search(args.query, limit, includeArchived, searchOptions)
+            allResults.push(...results.map((r: any) => ({ ...r, _index: idx })))
+          } finally {
+            releaseIndexer(projectRoot, idx)
+          }
         }
 
         allResults.sort((a, b) => {
@@ -171,9 +174,9 @@ Examples:
           await fs.access(hashesFile)
         } catch {
           // Index doesn't exist — check what indexes ARE available
-          const tempIndexer = await new CodebaseIndexer(projectRoot, "code").init()
+          const tempIndexer = await getIndexer(projectRoot, "code")
           const available = await tempIndexer.listIndexes()
-          await tempIndexer.unloadModel()
+          releaseIndexer(projectRoot, "code")
 
           if (available.length > 0) {
             const list = available.map(i => `"${i}"`).join(", ")
@@ -182,10 +185,13 @@ Examples:
           return `No indexes found. The codebase needs to be indexed first.\n\nRun the CLI: bunx usethis_search reindex`
         }
 
-        const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
-        const results = await indexer.search(args.query, limit, includeArchived, searchOptions)
-        allResults = results.map((r: any) => ({ ...r, _index: indexName }))
-        await indexer.unloadModel()
+        const indexer = await getIndexer(projectRoot, indexName)
+        try {
+          const results = await indexer.search(args.query, limit, includeArchived, searchOptions)
+          allResults = results.map((r: any) => ({ ...r, _index: indexName }))
+        } finally {
+          releaseIndexer(projectRoot, indexName)
+        }
       }
 
       // ── Score cutoff — drop low-relevance results ──────────────────────────

package/vectorizer/index.ts

@@ -460,17 +460,24 @@ class CodebaseIndexer {
     await this.loadHashes();
 
     // Graph DB — only if graph is enabled in config
+    // Non-fatal: if LevelDB lock fails (parallel access), search works without graph
     if (GRAPH_CONFIG.enabled) {
-      const graphType = this.indexName === "docs" ? "doc_graph" : "code_graph";
-      const graphPath = path.join(this.root, ".opencode", "graph", graphType);
-      await fs.mkdir(path.dirname(graphPath), { recursive: true });
-      this.graphDB = await new GraphDB(graphPath).init();
-      this.graphBuilder = new GraphBuilder(
-        this.graphDB,
-        this.root,
-        GRAPH_CONFIG.lsp.enabled,
-        GRAPH_CONFIG.lsp.timeout_ms,
-      );
+      try {
+        const graphType = this.indexName === "docs" ? "doc_graph" : "code_graph";
+        const graphPath = path.join(this.root, ".opencode", "graph", graphType);
+        await fs.mkdir(path.dirname(graphPath), { recursive: true });
+        this.graphDB = await new GraphDB(graphPath).init();
+        this.graphBuilder = new GraphBuilder(
+          this.graphDB,
+          this.root,
+          GRAPH_CONFIG.lsp.enabled,
+          GRAPH_CONFIG.lsp.timeout_ms,
+        );
+      } catch (e) {
+        if (DEBUG) console.log(`[vectorizer] GraphDB init failed (lock?): ${e.message || e}`);
+        this.graphDB = null;
+        this.graphBuilder = null;
+      }
     }
 
     // Usage tracker — provenance & usage stats
@@ -1327,4 +1334,65 @@ function getSearchConfig() {
   return SEARCH_CONFIG;
 }
 
-export { CodebaseIndexer, INDEX_PRESETS, getEmbeddingModel, getSearchConfig };
+// ── Singleton indexer pool ──────────────────────────────────────────────────
+// Prevents LevelDB lock conflicts when parallel searches hit the same index.
+// Each unique (projectRoot, indexName) gets one shared CodebaseIndexer.
+const _indexerPool = new Map<string, { indexer: CodebaseIndexer; refCount: number; initPromise: Promise<CodebaseIndexer> }>();
+
+/**
+ * Get or create a shared CodebaseIndexer for the given project + index.
+ * Multiple callers get the same instance — no LevelDB lock conflicts.
+ *
+ * Usage:
+ *   const indexer = await getIndexer(projectRoot, "code");
+ *   try {
+ *     const results = await indexer.search(...);
+ *   } finally {
+ *     releaseIndexer(projectRoot, "code");
+ *   }
+ */
+async function getIndexer(projectRoot: string, indexName: string = "code"): Promise<CodebaseIndexer> {
+  const key = `${projectRoot}::${indexName}`;
+  const existing = _indexerPool.get(key);
+  if (existing) {
+    existing.refCount++;
+    return existing.initPromise;
+  }
+
+  const indexer = new CodebaseIndexer(projectRoot, indexName);
+  const initPromise = indexer.init();
+  _indexerPool.set(key, { indexer, refCount: 1, initPromise });
+  return initPromise;
+}
+
+/**
+ * Release a reference to a shared indexer. When refCount reaches 0,
+ * the indexer is kept alive (for future reuse) but model memory is freed.
+ * Call destroyIndexer() to fully close and remove from pool.
+ */
+function releaseIndexer(projectRoot: string, indexName: string = "code") {
+  const key = `${projectRoot}::${indexName}`;
+  const entry = _indexerPool.get(key);
+  if (!entry) return;
+  entry.refCount = Math.max(0, entry.refCount - 1);
+  // Keep in pool — don't unload. Next search reuses the same instance.
+}
+
+/**
+ * Fully close and remove an indexer from the pool.
+ * Used by CLI clear/reindex operations that need a fresh state.
+ */
+async function destroyIndexer(projectRoot: string, indexName: string = "code") {
+  const key = `${projectRoot}::${indexName}`;
+  const entry = _indexerPool.get(key);
+  if (!entry) return;
+  _indexerPool.delete(key);
+  try {
+    const indexer = await entry.initPromise;
+    await indexer.unloadModel();
+  } catch {
+    // best effort
+  }
+}
+
+export { CodebaseIndexer, INDEX_PRESETS, getEmbeddingModel, getSearchConfig, getIndexer, releaseIndexer, destroyIndexer };