@comfanion/usethis_search 3.0.0-dev.0 → 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,7 +3,8 @@ import path from "path"
 import fs from "fs/promises"
 import fsSync from "fs"
 
-import { CodebaseIndexer } from "./vectorizer/index.js"
+import { CodebaseIndexer } from "./vectorizer/index.ts"
+import { initGraphAPI } from "./api"
 
 /**
  * File Indexer Plugin
@@ -252,7 +253,19 @@ async function ensureIndexOnSessionStart(
   for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
     if (!indexConfig.enabled) continue
     const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+    
     try {
+      // Initialize graph API for Mind plugin integration
+      try {
+        const graphDB = (indexer as any).graphDB
+        if (graphDB) {
+          initGraphAPI(graphDB)
+          log("Graph API initialized for Mind plugin")
+        }
+      } catch (error) {
+        debug("Failed to initialize graph API:", error)
+      }
+      
       const indexExists = await hasIndex(projectRoot, indexName)
       const health = await indexer.checkHealth(config.exclude)
 

package/index.ts

@@ -2,20 +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"
 
-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 default UsethisSearchPlugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/usethis_search",
-  "version": "3.0.0-dev.0",
+  "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",
@@ -24,9 +24,11 @@
     "vectorizer/query-cache.ts",
     "vectorizer/search-metrics.ts",
     "vectorizer/graph-db.ts",
+    "vectorizer/usage-tracker.ts",
     "vectorizer/graph-builder.ts",
     "vectorizer/analyzers/regex-analyzer.ts",
     "vectorizer/analyzers/lsp-analyzer.ts",
+    "vectorizer/analyzers/lsp-client.ts",
     "vectorizer/chunkers/markdown-chunker.ts",
     "vectorizer/chunkers/code-chunker.ts",
     "vectorizer/chunkers/chunker-factory.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"],
@@ -61,6 +61,7 @@ Actions:
 - "list" → List all available indexes with stats
 - "reindex" → Re-index files using local vectorizer
 - "test" → Run gold dataset quality tests (if configured)
+- "validate-graph" → Validate graph consistency (orphaned triples, broken chunk refs)
 
 Available indexes:
 - "code" - Source code files
@@ -68,7 +69,7 @@ Available indexes:
 - "config" - Configuration files`,
 
   args: {
-    action: tool.schema.enum(["status", "list", "reindex", "test"]).describe("Action to perform"),
+    action: tool.schema.enum(["status", "list", "reindex", "test", "validate-graph"]).describe("Action to perform"),
     index: tool.schema.string().optional().default("code").describe("Index name: code, docs, config"),
     dir: tool.schema.string().optional().describe("Directory to index (default: project root)"),
   },
@@ -170,11 +171,27 @@ Available indexes:
 
         let indexed = 0
         let skipped = 0
-        for (const filePath of files) {
+        const total = files.length
+
+        // FR-053: Progress reporting during indexing + graph building
+        const progressLines: string[] = []
+        for (let i = 0; i < files.length; i++) {
+          const filePath = files[i]
           try {
             const wasIndexed = await indexer.indexFile(filePath)
-            if (wasIndexed) indexed++
-            else skipped++
+            if (wasIndexed) {
+              indexed++
+              // Log progress at 10%, 25%, 50%, 75%, 100% milestones
+              const pct = Math.round(((i + 1) / total) * 100)
+              if (pct === 10 || pct === 25 || pct === 50 || pct === 75 || pct === 100) {
+                const msg = `Building index + graph: ${i + 1}/${total} files (${pct}%)`
+                if (progressLines.length === 0 || progressLines[progressLines.length - 1] !== msg) {
+                  progressLines.push(msg)
+                }
+              }
+            } else {
+              skipped++
+            }
           } catch {}
         }
 
@@ -184,13 +201,21 @@ Available indexes:
         let output = `## Re-indexing Complete\n\n`
         output += `**Index:** ${indexName}\n`
         output += `**Directory:** ${args.dir || "(project root)"}\n`
-        output += `**Files found:** ${files.length}\n`
+        output += `**Files found:** ${total}\n`
         output += `**Files indexed:** ${indexed}\n`
         output += `**Files unchanged:** ${skipped}\n`
         output += `**Total chunks:** ${stats.chunkCount}\n`
         if (stats.features) {
           output += `**Chunking:** ${stats.features.chunking}\n`
         }
+
+        if (progressLines.length > 0) {
+          output += `\n**Build Progress:**\n`
+          for (const line of progressLines) {
+            output += `- ${line}\n`
+          }
+        }
+
         return output
       } catch (error: any) {
         return `Re-indexing failed: ${error.message || String(error)}`
@@ -273,6 +298,147 @@ Available indexes:
       }
     }
 
-    return `Unknown action: ${args.action}. Use: status, list, reindex, or test`
+    // NFR-031: Graph validation
+    if (args.action === "validate-graph") {
+      try {
+        const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+
+        // Access internal graphDB and db
+        const graphDB = (indexer as any).graphDB
+        const db = (indexer as any).db
+
+        if (!graphDB) {
+          await indexer.unloadModel()
+          return `## Graph Validation: "${indexName}"\n\nNo graph database found. Run reindex first.`
+        }
+
+        // 1. Get all triples from graph
+        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")
+          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}" })`
+          }
+        }
+
+        // 3. Validate: find orphaned triples (subject or object points to non-existent chunk)
+        const orphanedSubjects: Array<{ triple: string; missingId: string }> = []
+        const orphanedObjects: Array<{ triple: string; missingId: string }> = []
+        const predicateCounts: Record<string, number> = {}
+        const sourceCounts: Record<string, number> = {}
+        const fileCounts: Record<string, number> = {}
+
+        for (const t of allTriples) {
+          // Count predicates/sources
+          predicateCounts[t.predicate] = (predicateCounts[t.predicate] || 0) + 1
+          sourceCounts[t.source] = (sourceCounts[t.source] || 0) + 1
+          fileCounts[t.file] = (fileCounts[t.file] || 0) + 1
+
+          // Check subject (skip meta: prefixed subjects)
+          if (!t.subject.startsWith("meta:") && t.subject.startsWith("chunk_") && !knownChunkIds.has(t.subject)) {
+            orphanedSubjects.push({
+              triple: `${t.subject} --[${t.predicate}]--> ${t.object}`,
+              missingId: t.subject,
+            })
+          }
+
+          // Check object (skip non-chunk objects like file paths, hashes)
+          if (t.object.startsWith("chunk_") && !knownChunkIds.has(t.object)) {
+            orphanedObjects.push({
+              triple: `${t.subject} --[${t.predicate}]--> ${t.object}`,
+              missingId: t.object,
+            })
+          }
+        }
+
+        // 4. Get file metadata stats
+        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()
+
+        // 5. Build report
+        const totalOrphaned = orphanedSubjects.length + orphanedObjects.length
+        const isHealthy = totalOrphaned === 0
+
+        let output = `## Graph Validation: "${indexName}"\n\n`
+        output += `**Status:** ${isHealthy ? "HEALTHY" : "ISSUES FOUND"}\n\n`
+
+        output += `### Statistics\n`
+        output += `- **Total triples:** ${allTriples.length}\n`
+        output += `- **Known chunk IDs:** ${knownChunkIds.size}\n`
+        output += `- **Files with graph metadata:** ${fileMeta.length}\n`
+        output += `- **Unique files in graph:** ${Object.keys(fileCounts).length}\n\n`
+
+        output += `### Edge Types\n`
+        for (const [pred, count] of Object.entries(predicateCounts).sort((a, b) => b[1] - a[1])) {
+          output += `- **${pred}:** ${count}\n`
+        }
+        output += `\n`
+
+        output += `### Edge Sources\n`
+        for (const [source, count] of Object.entries(sourceCounts).sort((a, b) => b[1] - a[1])) {
+          output += `- **${source}:** ${count}\n`
+        }
+        output += `\n`
+
+        if (totalOrphaned > 0) {
+          output += `### Orphaned References (${totalOrphaned})\n\n`
+
+          if (orphanedSubjects.length > 0) {
+            output += `**Broken subjects** (${orphanedSubjects.length}):\n`
+            for (const o of orphanedSubjects.slice(0, 10)) {
+              output += `- \`${o.missingId}\` in: ${o.triple}\n`
+            }
+            if (orphanedSubjects.length > 10) {
+              output += `- ... and ${orphanedSubjects.length - 10} more\n`
+            }
+            output += `\n`
+          }
+
+          if (orphanedObjects.length > 0) {
+            output += `**Broken objects** (${orphanedObjects.length}):\n`
+            for (const o of orphanedObjects.slice(0, 10)) {
+              output += `- \`${o.missingId}\` in: ${o.triple}\n`
+            }
+            if (orphanedObjects.length > 10) {
+              output += `- ... and ${orphanedObjects.length - 10} more\n`
+            }
+            output += `\n`
+          }
+
+          output += `**Recommendation:** Run \`codeindex({ action: "reindex", index: "${indexName}" })\` to rebuild the graph.\n`
+        } else {
+          output += `### Integrity\nAll chunk references are valid. No orphaned triples found.\n`
+        }
+
+        return output
+      } catch (error: any) {
+        return `Graph validation failed: ${error.message || String(error)}`
+      }
+    }
+
+    return `Unknown action: ${args.action}. Use: status, list, reindex, test, or validate-graph`
   },
 })

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.