@comfanion/usethis_search 3.0.0-dev.1 → 3.0.0-dev.10

package/api.ts

@@ -0,0 +1,92 @@
+/**
+ * usethis_search API
+ * 
+ * Exports internal functions for plugin-to-plugin communication.
+ * Used by Mind plugin for graph-based workspace management.
+ */
+
+import { GraphDB } from "./vectorizer/graph-db"
+
+// Global GraphDB instance (shared across plugins)
+let graphDBInstance: GraphDB | null = null
+
+/**
+ * Initialize API with GraphDB instance
+ */
+export function initGraphAPI(db: GraphDB): void {
+  graphDBInstance = db
+}
+
+/**
+ * Get related files for a given file path
+ * 
+ * @param filePath - File path to get relations for
+ * @param maxDepth - Maximum graph depth to traverse (default: 1)
+ * @returns Array of related files with relation type and weight
+ * 
+ * Example:
+ * ```javascript
+ * const related = await getRelatedFiles("src/auth/login.ts", 1)
+ * // Returns:
+ * [
+ *   { path: "src/types/User.ts", relation: "imports", weight: 0.9 },
+ *   { path: "src/auth/BaseAuth.ts", relation: "extends", weight: 0.95 },
+ *   { path: "src/routes/api.ts", relation: "used_by", weight: 0.8 }
+ * ]
+ * ```
+ */
+export async function getRelatedFiles(
+  filePath: string,
+  maxDepth: number = 1
+): Promise<{path: string, relation: string, weight: number}[]> {
+  if (!graphDBInstance) {
+    console.warn("[usethis_search API] GraphDB not initialized. Returning empty array.")
+    return []
+  }
+
+  try {
+    const chunkId = `file:${filePath}`
+    const related = await graphDBInstance.getRelatedFiles(chunkId, maxDepth)
+    
+    // Filter out the input file itself (it might appear in the graph)
+    const filtered = related.filter(r => r.path !== filePath)
+    
+    return filtered
+  } catch (error) {
+    console.error(`[usethis_search API] Error getting related files for ${filePath}:`, error)
+    return []
+  }
+}
+
+/**
+ * Check if graph API is available
+ */
+export function isGraphAPIAvailable(): boolean {
+  return graphDBInstance !== null
+}
+
+/**
+ * Get all graph entries for a file (both incoming and outgoing)
+ */
+export async function getGraphEntries(filePath: string) {
+  if (!graphDBInstance) {
+    return null
+  }
+
+  try {
+    const chunkId = `file:${filePath}`
+    const [outgoing, incoming] = await Promise.all([
+      graphDBInstance.getOutgoing(chunkId),
+      graphDBInstance.getIncoming(chunkId),
+    ])
+
+    return {
+      imports: outgoing.filter(t => t.predicate === "imports"),
+      extends: outgoing.filter(t => t.predicate === "extends"),
+      used_by: incoming,
+    }
+  } catch (error) {
+    console.error(`[usethis_search API] Error getting graph entries for ${filePath}:`, error)
+    return null
+  }
+}

package/file-indexer.ts

@@ -3,8 +3,8 @@ import path from "path"
 import fs from "fs/promises"
 import fsSync from "fs"
 
-import { CodebaseIndexer } from "./vectorizer/index.js"
-import { initGraphAPI } from "./api.js"
+import { CodebaseIndexer } from "./vectorizer/index.ts"
+import { initGraphAPI } from "./api"
 
 /**
  * File Indexer Plugin

package/index.ts

@@ -2,24 +2,34 @@ import type { Plugin } from "@opencode-ai/plugin"
 
 import search from "./tools/search"
 import codeindex from "./tools/codeindex"
-import readInterceptor from "./tools/read-interceptor"
 import FileIndexerPlugin from "./file-indexer"
-import { getRelatedFiles, getGraphEntries, isGraphAPIAvailable } from "./api.js"
 
-const UsethisSearchPlugin: Plugin = async (ctx) => {
-  const fileIndexerHooks = await FileIndexerPlugin(ctx as any)
+const UsethisSearchPlugin: Plugin = async ({ directory, client }) => {
+  // Start file indexer (background indexing + event handling)
+  let fileIndexerEvent: ((args: any) => Promise<void>) | null = null
+  try {
+    const hooks = await FileIndexerPlugin({ directory, client } as any)
+    fileIndexerEvent = hooks?.event || null
+  } catch {
+    // file indexer init failed — tools still work, just no auto-indexing
+  }
 
   return {
-    ...fileIndexerHooks,
     tool: {
       search,
       codeindex,
-      read: readInterceptor,
+    },
+
+    event: async (args: any) => {
+      if (fileIndexerEvent) {
+        try {
+          await fileIndexerEvent(args)
+        } catch {
+          // non-fatal
+        }
+      }
     },
   }
 }
 
 export default UsethisSearchPlugin
-
-// Export graph API for other plugins (e.g., Mind)
-export { getRelatedFiles, getGraphEntries, isGraphAPIAvailable }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/usethis_search",
-  "version": "3.0.0-dev.1",
+  "version": "3.0.0-dev.10",
   "description": "OpenCode plugin: semantic search with graph-based context (v3: graph relations, 1-hop context, LSP + regex analyzers)",
   "type": "module",
   "main": "./index.ts",
@@ -12,11 +12,11 @@
   },
   "files": [
     "index.ts",
+    "api.ts",
     "file-indexer.ts",
     "tools/search.ts",
     "tools/codeindex.ts",
-    "tools/read-interceptor.ts",
-    "vectorizer/index.js",
+    "vectorizer/index.ts",
     "vectorizer/content-cleaner.ts",
     "vectorizer/metadata-extractor.ts",
     "vectorizer/bm25-index.ts",

package/tools/codeindex.ts

@@ -9,7 +9,7 @@ import { tool } from "@opencode-ai/plugin"
 import path from "path"
 import fs from "fs/promises"
 
-import { CodebaseIndexer } from "../vectorizer/index.js"
+import { CodebaseIndexer } from "../vectorizer/index.ts"
 
 const INDEX_EXTENSIONS: Record<string, string[]> = {
   code: [".js", ".ts", ".jsx", ".tsx", ".go", ".py", ".rs", ".java", ".kt", ".swift", ".c", ".cpp", ".h", ".cs", ".rb", ".php"],
@@ -313,16 +313,27 @@ Available indexes:
         }
 
         // 1. Get all triples from graph
-        const allTriples = await graphDB.getAllTriples()
+        let allTriples: any[] = []
+        try {
+          allTriples = await graphDB.getAllTriples()
+        } catch (e: any) {
+          await indexer.unloadModel()
+          return `## Graph Validation: "${indexName}"\n\n**Error:** Failed to read graph database: ${e.message || String(e)}\n\nThe graph database may be corrupted. Run: codeindex({ action: "reindex", index: "${indexName}" })`
+        }
 
         // 2. Get all chunk IDs from vector DB
         const knownChunkIds = new Set<string>()
         const tables = await db.tableNames()
         if (tables.includes("chunks")) {
           const table = await db.openTable("chunks")
-          const rows = await table.search([0]).limit(100000).execute()
-          for (const row of rows) {
-            if (row.chunk_id) knownChunkIds.add(row.chunk_id)
+          try {
+            const rows = await table.search([0]).limit(100000).execute()
+            for (const row of rows) {
+              if (row.chunk_id) knownChunkIds.add(row.chunk_id)
+            }
+          } catch (e: any) {
+            await indexer.unloadModel()
+            return `## Graph Validation: "${indexName}"\n\n**Error:** Failed to read vector database: ${e.message || String(e)}\n\nThe vector database may be corrupted. Run: codeindex({ action: "reindex", index: "${indexName}" })`
           }
         }
 
@@ -357,7 +368,13 @@ Available indexes:
         }
 
         // 4. Get file metadata stats
-        const fileMeta = await graphDB.getAllFileMeta()
+        let fileMeta: Array<{ filePath: string; hash: string; timestamp: number }> = []
+        try {
+          fileMeta = await graphDB.getAllFileMeta()
+        } catch (e: any) {
+          // Non-fatal - continue validation without metadata
+          console.warn(`Warning: Failed to get file metadata: ${e.message || String(e)}`)
+        }
 
         await indexer.unloadModel()
 

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 } from "../vectorizer/index.js"
+import { CodebaseIndexer } from "../vectorizer/index.ts"
 
 export default tool({
   description: `Search the codebase semantically. Use this to find relevant code snippets, functions, or files based on meaning, not just text matching.

package/vectorizer/{index.js → index.ts}

@@ -603,7 +603,13 @@ class CodebaseIndexer {
     if (!tables.includes(tableName)) return null;
 
     const table = await this.db.openTable(tableName);
-    const allRows = await table.search([0]).limit(100000).execute();
+    let allRows;
+    try {
+      allRows = await table.search([0]).limit(100000).execute();
+    } catch (e) {
+      if (DEBUG) console.log("[vectorizer] BM25 index build failed (corrupted table?):", e.message);
+      return null;
+    }
 
     if (allRows.length === 0) return null;
 
@@ -643,7 +649,14 @@ class CodebaseIndexer {
                        (options.tags && options.tags.length > 0);
     const isHybrid = HYBRID_CONFIG.enabled || options.hybrid;
     const fetchLimit = (hasFilters || isHybrid) ? Math.max(limit * 3, 50) : limit;
-    let results = await table.search(queryEmbedding).limit(fetchLimit).execute();
+    let results;
+    try {
+      results = await table.search(queryEmbedding).limit(fetchLimit).execute();
+    } catch (e) {
+      // LanceDB schema error (e.g. missing vector column) — index is corrupted
+      if (DEBUG) console.log("[vectorizer] Vector search failed (corrupted index?):", e.message);
+      return [];
+    }
 
     // ── Hybrid search ───────────────────────────────────────────────────────
     if (HYBRID_CONFIG.enabled || options.hybrid) {
@@ -833,7 +846,13 @@ class CodebaseIndexer {
       if (!tables.includes(tableName)) return null;
 
       const table = await this.db.openTable(tableName);
-      const rows = await table.search([0]).limit(100000).execute();
+      let rows;
+      try {
+        rows = await table.search([0]).limit(100000).execute();
+      } catch (e) {
+        if (DEBUG) console.log("[vectorizer] Chunk cache build failed (corrupted table?):", e.message);
+        return null;
+      }
       this._chunkCache = new Map();
       for (const row of rows) {
         if (row.chunk_id) {

package/tools/read-interceptor.ts

@@ -1,127 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import path from "path"
-import fs from "fs/promises"
-
-import { CodebaseIndexer } from "../vectorizer/index.js"
-
-// FR-043: Logging for intercepted Read() calls
-const DEBUG = process.env.DEBUG?.includes("vectorizer") || process.env.DEBUG === "*"
-
-interface ReadLogEntry {
-  timestamp: number
-  filePath: string
-  relPath: string
-  chunksFound: number
-  relatedContextCount: number
-  durationMs: number
-  fallback: boolean
-}
-
-const LOG_MAX_ENTRIES = 500
-
-/**
- * Append a log entry to the Read() interception log file.
- * Non-blocking, non-fatal — errors are silently ignored.
- */
-async function logReadInterception(projectRoot: string, entry: ReadLogEntry): Promise<void> {
-  try {
-    const logPath = path.join(projectRoot, ".opencode", "vectors", "read-intercept.log.json")
-    await fs.mkdir(path.dirname(logPath), { recursive: true })
-
-    let entries: ReadLogEntry[] = []
-    try {
-      const raw = await fs.readFile(logPath, "utf-8")
-      entries = JSON.parse(raw)
-    } catch {
-      // file doesn't exist or is invalid — start fresh
-    }
-
-    entries.push(entry)
-    // Cap log size to avoid unbounded growth
-    if (entries.length > LOG_MAX_ENTRIES) {
-      entries = entries.slice(-LOG_MAX_ENTRIES)
-    }
-
-    await fs.writeFile(logPath, JSON.stringify(entries, null, 2), "utf-8")
-  } catch {
-    // non-fatal — logging must never break Read
-  }
-}
-
-export default tool({
-  description: `Read file with graph-aware context attachment. When available, this tool searches the file in the index and returns content + related context from the graph (imports, links, etc.).
-
-Use this instead of the standard Read tool for better context awareness.`,
-
-  args: {
-    filePath: tool.schema.string().describe("Path to the file to read"),
-  },
-
-  async execute(args) {
-    const startTime = Date.now()
-    const projectRoot = process.cwd()
-    const filePath = path.isAbsolute(args.filePath) ? args.filePath : path.join(projectRoot, args.filePath)
-
-    const relPath = path.relative(projectRoot, filePath)
-
-    if (DEBUG) {
-      console.log(`[read-interceptor] Intercepted Read("${relPath}")`)
-    }
-
-    const indexer = await new CodebaseIndexer(projectRoot, "code").init()
-    const results = await indexer.search(relPath, 20, false, {})
-    const fileChunks = results.filter(r => r.file === relPath)
-    await indexer.unloadModel()
-
-    const allRelated = fileChunks
-      .flatMap(c => c.relatedContext || [])
-      .filter((r, i, arr) => arr.findIndex(x => x.chunk_id === r.chunk_id) === i)
-
-    const durationMs = Date.now() - startTime
-    const fallback = fileChunks.length === 0
-
-    // FR-043: Log the interception asynchronously (non-blocking)
-    logReadInterception(projectRoot, {
-      timestamp: startTime,
-      filePath: args.filePath,
-      relPath,
-      chunksFound: fileChunks.length,
-      relatedContextCount: allRelated.length,
-      durationMs,
-      fallback,
-    }).catch(() => {})
-
-    if (DEBUG) {
-      console.log(
-        `[read-interceptor] ${relPath}: ${fileChunks.length} chunks, ${allRelated.length} related, ${durationMs}ms${fallback ? " (fallback)" : ""}`
-      )
-    }
-
-    if (fallback) {
-      return `File "${relPath}" not indexed. Use original Read tool or run codeindex({ action: "reindex", index: "code" })`
-    }
-
-    let output = `## ${relPath}\n\n`
-
-    output += `### Content\n\n`
-    for (const chunk of fileChunks) {
-      output += chunk.content + "\n\n"
-    }
-
-    if (allRelated.length > 0) {
-      output += `### Related Context\n\n`
-      for (const rel of allRelated) {
-        const snippet = rel.content.length > 300
-          ? rel.content.substring(0, 300) + "..."
-          : rel.content
-        output += `**${rel.file}** (${rel.relation})\n`
-        output += `\`\`\`\n${snippet}\n\`\`\`\n\n`
-      }
-    }
-
-    return output
-  },
-})
-
-// Export for testing
-export { logReadInterception, ReadLogEntry }