@comfanion/usethis_search 0.2.0-dev.0 → 3.0.0-dev.0

package/index.ts

@@ -2,6 +2,7 @@ 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) => {
@@ -12,6 +13,7 @@ const UsethisSearchPlugin: Plugin = async (ctx) => {
     tool: {
       search,
       codeindex,
+      read: readInterceptor,
     },
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comfanion/usethis_search",
-  "version": "0.2.0-dev.0",
-  "description": "OpenCode plugin: semantic search + code index management (v2: hybrid search, semantic chunking, metadata filtering)",
+  "version": "3.0.0-dev.0",
+  "description": "OpenCode plugin: semantic search with graph-based context (v3: graph relations, 1-hop context, LSP + regex analyzers)",
   "type": "module",
   "main": "./index.ts",
   "exports": {
@@ -15,6 +15,7 @@
     "file-indexer.ts",
     "tools/search.ts",
     "tools/codeindex.ts",
+    "tools/read-interceptor.ts",
     "vectorizer/index.js",
     "vectorizer/content-cleaner.ts",
     "vectorizer/metadata-extractor.ts",
@@ -22,6 +23,10 @@
     "vectorizer/hybrid-search.ts",
     "vectorizer/query-cache.ts",
     "vectorizer/search-metrics.ts",
+    "vectorizer/graph-db.ts",
+    "vectorizer/graph-builder.ts",
+    "vectorizer/analyzers/regex-analyzer.ts",
+    "vectorizer/analyzers/lsp-analyzer.ts",
     "vectorizer/chunkers/markdown-chunker.ts",
     "vectorizer/chunkers/code-chunker.ts",
     "vectorizer/chunkers/chunker-factory.ts",
@@ -30,9 +35,11 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@opencode-ai/plugin": "1.1.39",
+    "@opencode-ai/plugin": ">=1.1.0",
     "@xenova/transformers": "^2.17.0",
     "glob": "^10.3.10",
+    "level": "^8.0.1",
+    "levelgraph": "^4.0.0",
     "vectordb": "^0.4.0"
   },
   "peerDependencies": {

package/tools/read-interceptor.ts

@@ -0,0 +1,54 @@
+import { tool } from "@opencode-ai/plugin"
+import path from "path"
+
+import { CodebaseIndexer } from "../vectorizer/index.js"
+
+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 projectRoot = process.cwd()
+    const filePath = path.isAbsolute(args.filePath) ? args.filePath : path.join(projectRoot, args.filePath)
+
+    const relPath = path.relative(projectRoot, filePath)
+
+    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()
+
+    if (fileChunks.length === 0) {
+      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"
+    }
+
+    const allRelated = fileChunks
+      .flatMap(c => c.relatedContext || [])
+      .filter((r, i, arr) => arr.findIndex(x => x.chunk_id === r.chunk_id) === i)
+
+    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
+  },
+})

package/tools/search.ts

@@ -138,7 +138,20 @@ Examples:
         output += "```\n"
         const content = r.content.length > 500 ? r.content.substring(0, 500) + "\n... (truncated)" : r.content
         output += content
-        output += "\n```\n\n"
+        output += "\n```\n"
+
+        if (r.relatedContext && r.relatedContext.length > 0) {
+          output += "\n**Related Context:**\n"
+          for (const rel of r.relatedContext) {
+            const snippet = rel.content.length > 200
+              ? rel.content.substring(0, 200) + "..."
+              : rel.content
+            output += `- **${rel.file}** (${rel.relation}, via ${rel.via}, score: ${rel.score.toFixed(2)})\n`
+            output += `  \`\`\`\n  ${snippet}\n  \`\`\`\n`
+          }
+        }
+
+        output += "\n"
       }
 
       output += `---\n*Found ${allResults.length} results. Use Read tool to see full files.*`

package/vectorizer/analyzers/lsp-analyzer.ts

@@ -0,0 +1,162 @@
+import { ChunkWithId } from "../graph-builder"
+
+export interface Relation {
+  from: string
+  to: string
+  predicate: string
+  weight: number
+  source: "lsp"
+  line?: number
+}
+
+export class LSPAnalyzer {
+  private readonly timeout = 5000
+
+  async isAvailable(filePath: string): Promise<boolean> {
+    try {
+      const ext = filePath.split(".").pop()
+      if (!ext) return false
+
+      const language = this.getLanguage(ext)
+      if (!language) return false
+
+      return this.checkLSPServer(language)
+    } catch {
+      return false
+    }
+  }
+
+  async analyzeFile(filePath: string, chunks: ChunkWithId[]): Promise<Relation[]> {
+    const relations: Relation[] = []
+
+    try {
+      const ext = filePath.split(".").pop()
+      if (!ext) return []
+
+      const language = this.getLanguage(ext)
+      if (!language) return []
+
+      const lines = await this.readFileLines(filePath)
+
+      const symbols = await this.getDocumentSymbols(filePath, language)
+      if (!symbols) return []
+
+      for (const symbol of symbols) {
+        const fromChunkId = this.findChunkForPosition(chunks, symbol.line)
+        if (!fromChunkId) continue
+
+        if (symbol.type === "class" || symbol.type === "interface") {
+          const implementations = await this.getImplementations(filePath, symbol.line, symbol.character, language)
+          for (const impl of implementations) {
+            const toChunkId = this.resolveTargetChunk(filePath, impl)
+            if (toChunkId) {
+              relations.push({
+                from: fromChunkId,
+                to: toChunkId,
+                predicate: "implements",
+                weight: 1.0,
+                source: "lsp"
+              })
+            }
+          }
+        }
+
+        const references = await this.getReferences(filePath, symbol.line, symbol.character, language)
+        for (const ref of references) {
+          const toChunkId = this.resolveTargetChunk(filePath, ref)
+          if (toChunkId && toChunkId !== fromChunkId) {
+            relations.push({
+              from: toChunkId,
+              to: fromChunkId,
+              predicate: "used_by",
+              weight: 1.0,
+              source: "lsp"
+            })
+          }
+        }
+
+        const definitions = await this.getDefinitions(filePath, symbol.line, symbol.character, language)
+        for (const def of definitions) {
+          const toChunkId = this.resolveTargetChunk(filePath, def)
+          if (toChunkId && toChunkId !== fromChunkId) {
+            relations.push({
+              from: fromChunkId,
+              to: toChunkId,
+              predicate: "references",
+              weight: 1.0,
+              source: "lsp"
+            })
+          }
+        }
+      }
+    } catch (error) {
+      return []
+    }
+
+    return relations
+  }
+
+  private getLanguage(ext: string): string | null {
+    const map: Record<string, string> = {
+      ts: "typescript",
+      js: "javascript",
+      tsx: "typescriptreact",
+      jsx: "javascriptreact",
+      py: "python",
+      go: "go",
+      rs: "rust",
+      java: "java",
+      cpp: "cpp",
+      c: "c",
+      cs: "csharp"
+    }
+    return map[ext] || null
+  }
+
+  private checkLSPServer(language: string): Promise<boolean> {
+    return Promise.resolve(false)
+  }
+
+  private async readFileLines(filePath: string): Promise<string[]> {
+    const fs = await import("fs/promises")
+    const content = await fs.readFile(filePath, "utf-8")
+    return content.split("\n")
+  }
+
+  private async getDocumentSymbols(filePath: string, language: string): Promise<Array<{ name: string; type: string; line: number; character: number }> | null> {
+    return null
+  }
+
+  private async getImplementations(filePath: string, line: number, character: number, language: string): Promise<Array<{ file: string; line: number; character: number }>> {
+    return []
+  }
+
+  private async getReferences(filePath: string, line: number, character: number, language: string): Promise<Array<{ file: string; line: number; character: number }>> {
+    return []
+  }
+
+  private async getDefinitions(filePath: string, line: number, character: number, language: string): Promise<Array<{ file: string; line: number; character: number }>> {
+    return []
+  }
+
+  private findChunkForPosition(chunks: ChunkWithId[], line: number): string | null {
+    for (const chunk of chunks) {
+      if (chunk.start_line !== undefined && chunk.end_line !== undefined) {
+        if (line >= chunk.start_line && line <= chunk.end_line) {
+          return chunk.chunk_id
+        }
+      }
+    }
+    return null
+  }
+
+  private resolveTargetChunk(currentFile: string, target: { file: string; line: number; character: number }): string | null {
+    if (target.file !== currentFile) {
+      const path = target.file.replace(/[^a-zA-Z0-9]/g, "_")
+      return `chunk_${path}_0`
+    }
+
+    const normalized = currentFile.replace(/[^a-zA-Z0-9]/g, "_")
+    return `chunk_${normalized}_0`
+  }
+}

package/vectorizer/analyzers/regex-analyzer.ts

@@ -0,0 +1,255 @@
+import path from "path"
+import { ChunkWithId } from "../graph-builder"
+
+export interface Relation {
+  from: string
+  to: string
+  predicate: string
+  weight: number
+  source: "regex" | "markdown"
+  line?: number
+}
+
+export class RegexAnalyzer {
+  private readonly patterns = {
+    jsImports: /import\s+(?:\{[^}]+\}|\w+)\s+from\s+['"]([^'"]+)['"]/g,
+    pythonFromImport: /from\s+(\S+)\s+import/g,
+    pythonImport: /import\s+(\S+)/g,
+    extends: /class\s+\w+\s+extends\s+(\w+)/g,
+    implements: /class\s+\w+\s+implements\s+([^{]+)/g,
+    markdownLink: /\[([^\]]+)\]\(([^)]+)\)/g
+  }
+
+  analyzeCode(filePath: string, content: string, chunks: ChunkWithId[]): Relation[] {
+    const relations: Relation[] = []
+    const ext = path.extname(filePath)
+    const lines = content.split("\n")
+
+    if ([".js", ".ts", ".jsx", ".tsx"].includes(ext)) {
+      this.analyzeJSCode(content, lines, filePath, chunks, relations)
+    } else if ([".py"].includes(ext)) {
+      this.analyzePythonCode(content, lines, filePath, chunks, relations)
+    }
+
+    return relations
+  }
+
+  analyzeMarkdown(filePath: string, content: string, chunks: ChunkWithId[]): Relation[] {
+    const relations: Relation[] = []
+    const lines = content.split("\n")
+    const dir = path.dirname(filePath)
+
+    let match
+    this.patterns.markdownLink.lastIndex = 0
+    while ((match = this.patterns.markdownLink.exec(content)) !== null) {
+      const linkText = match[1]
+      const linkTarget = match[2]
+      const lineIndex = content.substring(0, match.index).split("\n").length - 1
+      const line = lines[lineIndex]
+
+      const targetPath = this.resolvePath(filePath, linkTarget)
+      if (!targetPath) continue
+
+      const fromChunkId = this.findChunkForLine(chunks, lineIndex)
+      if (!fromChunkId) continue
+
+      const toChunkId = this.findChunkForLinkTarget(targetPath, linkTarget, chunks)
+      if (toChunkId) {
+        relations.push({
+          from: fromChunkId,
+          to: toChunkId,
+          predicate: "links_to",
+          weight: 1.0,
+          source: "markdown",
+          line: lineIndex
+        })
+      }
+    }
+
+    return relations
+  }
+
+  private analyzeJSCode(content: string, lines: string[], filePath: string, chunks: ChunkWithId[], relations: Relation[]) {
+    let match
+
+    this.patterns.jsImports.lastIndex = 0
+    while ((match = this.patterns.jsImports.exec(content)) !== null) {
+      const importPath = match[1]
+      const lineIndex = content.substring(0, match.index).split("\n").length - 1
+      const line = lines[lineIndex]
+
+      if (importPath.startsWith(".")) {
+        const targetPath = this.resolvePath(filePath, importPath)
+        if (!targetPath) continue
+
+        const fromChunkId = this.findChunkForLine(chunks, lineIndex)
+        if (!fromChunkId) continue
+
+        const toChunkId = this.findFirstChunkInFile(targetPath)
+        if (toChunkId) {
+          relations.push({
+            from: fromChunkId,
+            to: toChunkId,
+            predicate: "imports",
+            weight: 0.8,
+            source: "regex",
+            line: lineIndex
+          })
+        }
+      }
+    }
+
+    this.patterns.extends.lastIndex = 0
+    while ((match = this.patterns.extends.exec(content)) !== null) {
+      const parentClass = match[1]
+      const lineIndex = content.substring(0, match.index).split("\n").length - 1
+
+      const fromChunkId = this.findChunkForLine(chunks, lineIndex)
+      if (!fromChunkId) continue
+
+      const toChunkId = this.findChunkContainingSymbol(chunks, parentClass)
+      if (toChunkId) {
+        relations.push({
+          from: fromChunkId,
+          to: toChunkId,
+          predicate: "extends",
+          weight: 0.8,
+          source: "regex",
+          line: lineIndex
+        })
+      }
+    }
+
+    this.patterns.implements.lastIndex = 0
+    while ((match = this.patterns.implements.exec(content)) !== null) {
+      const interfaces = match[1].split(",").map(s => s.trim())
+      const lineIndex = content.substring(0, match.index).split("\n").length - 1
+
+      const fromChunkId = this.findChunkForLine(chunks, lineIndex)
+      if (!fromChunkId) continue
+
+      for (const iface of interfaces) {
+        const toChunkId = this.findChunkContainingSymbol(chunks, iface)
+        if (toChunkId) {
+          relations.push({
+            from: fromChunkId,
+            to: toChunkId,
+            predicate: "implements",
+            weight: 0.8,
+            source: "regex",
+            line: lineIndex
+          })
+        }
+      }
+    }
+  }
+
+  private analyzePythonCode(content: string, lines: string[], filePath: string, chunks: ChunkWithId[], relations: Relation[]) {
+    let match
+
+    this.patterns.pythonFromImport.lastIndex = 0
+    while ((match = this.patterns.pythonFromImport.exec(content)) !== null) {
+      const importPath = match[1]
+      const lineIndex = content.substring(0, match.index).split("\n").length - 1
+
+      if (importPath.startsWith(".")) {
+        const targetPath = this.resolvePath(filePath, importPath)
+        if (!targetPath) continue
+
+        const fromChunkId = this.findChunkForLine(chunks, lineIndex)
+        if (!fromChunkId) continue
+
+        const toChunkId = this.findFirstChunkInFile(targetPath)
+        if (toChunkId) {
+          relations.push({
+            from: fromChunkId,
+            to: toChunkId,
+            predicate: "imports",
+            weight: 0.8,
+            source: "regex",
+            line: lineIndex
+          })
+        }
+      }
+    }
+
+    this.patterns.pythonImport.lastIndex = 0
+    while ((match = this.patterns.pythonImport.exec(content)) !== null) {
+      const importPath = match[1]
+      const lineIndex = content.substring(0, match.index).split("\n").length - 1
+
+      if (importPath.startsWith(".")) {
+        const targetPath = this.resolvePath(filePath, importPath)
+        if (!targetPath) continue
+
+        const fromChunkId = this.findChunkForLine(chunks, lineIndex)
+        if (!fromChunkId) continue
+
+        const toChunkId = this.findFirstChunkInFile(targetPath)
+        if (toChunkId) {
+          relations.push({
+            from: fromChunkId,
+            to: toChunkId,
+            predicate: "imports",
+            weight: 0.8,
+            source: "regex",
+            line: lineIndex
+          })
+        }
+      }
+    }
+  }
+
+  private resolvePath(filePath: string, target: string): string | null {
+    try {
+      const dir = path.dirname(filePath)
+      const absoluteTarget = path.resolve(dir, target)
+
+      if (!absoluteTarget.startsWith(process.cwd())) {
+        return null
+      }
+
+      return path.relative(process.cwd(), absoluteTarget)
+    } catch {
+      return null
+    }
+  }
+
+  private findChunkForLine(chunks: ChunkWithId[], lineIndex: number): string | null {
+    for (const chunk of chunks) {
+      if (chunk.start_line !== undefined && chunk.end_line !== undefined) {
+        if (lineIndex >= chunk.start_line && lineIndex <= chunk.end_line) {
+          return chunk.chunk_id
+        }
+      }
+    }
+    return null
+  }
+
+  private findFirstChunkInFile(targetPath: string): string | null {
+    const normalized = targetPath.replace(/[^a-zA-Z0-9]/g, "_")
+    return `chunk_${normalized}_0`
+  }
+
+  private findChunkContainingSymbol(chunks: ChunkWithId[], symbol: string): string | null {
+    for (const chunk of chunks) {
+      if (chunk.content.includes(symbol)) {
+        return chunk.chunk_id
+      }
+    }
+    return null
+  }
+
+  private findChunkForLinkTarget(targetPath: string, linkTarget: string, chunks: ChunkWithId[]): string | null {
+    const hashIndex = linkTarget.indexOf("#")
+    if (hashIndex !== -1) {
+      const heading = linkTarget.substring(hashIndex + 1).toLowerCase()
+      for (const chunk of chunks) {
+        if (chunk.heading_context && chunk.heading_context.toLowerCase().includes(heading)) {
+          return chunk.chunk_id
+        }
+      }
+    }
+    return this.findFirstChunkInFile(targetPath)
+  }
+}

package/vectorizer/graph-builder.ts

@@ -0,0 +1,95 @@
+import path from "path"
+import { GraphDB, Triple } from "./graph-db"
+import { RegexAnalyzer, Relation as RegexRelation } from "./analyzers/regex-analyzer"
+import { LSPAnalyzer, Relation as LSPRelation } from "./analyzers/lsp-analyzer"
+
+export interface ChunkWithId {
+  chunk_id: string
+  content: string
+  start_line?: number
+  end_line?: number
+  heading_context?: string
+}
+
+export class GraphBuilder {
+  private lspAnalyzer: LSPAnalyzer
+  private regexAnalyzer: RegexAnalyzer
+
+  constructor(
+    private graphDB: GraphDB,
+    private projectRoot: string
+  ) {
+    this.lspAnalyzer = new LSPAnalyzer()
+    this.regexAnalyzer = new RegexAnalyzer()
+  }
+
+  assignChunkIds(filePath: string, chunks: any[]): ChunkWithId[] {
+    const withoutExt = filePath.replace(/\.[^/.]+$/, "")
+    const normalizedPath = withoutExt.replace(/[^a-zA-Z0-9]/g, "_")
+
+    return chunks.map((chunk, index) => {
+      const chunkId = `chunk_${normalizedPath}_${index}`
+      return {
+        ...chunk,
+        chunk_id: chunkId
+      } as ChunkWithId
+    })
+  }
+
+  async buildEdges(
+    filePath: string,
+    content: string,
+    chunks: ChunkWithId[],
+    fileType: "code" | "docs"
+  ): Promise<void> {
+    let relations: Array<RegexRelation | LSPRelation> = []
+
+    if (fileType === "docs") {
+      relations = this.regexAnalyzer.analyzeMarkdown(filePath, content, chunks)
+    } else if (fileType === "code") {
+      const lspAvailable = await this.lspAnalyzer.isAvailable(filePath)
+      
+      if (lspAvailable) {
+        try {
+          relations = await this.lspAnalyzer.analyzeFile(filePath, chunks)
+        } catch (error) {
+          relations = this.regexAnalyzer.analyzeCode(filePath, content, chunks)
+        }
+      } else {
+        relations = this.regexAnalyzer.analyzeCode(filePath, content, chunks)
+      }
+    }
+
+    const triples: Triple[] = relations.map(rel => ({
+      subject: rel.from,
+      predicate: rel.predicate,
+      object: rel.to,
+      weight: rel.weight,
+      source: rel.source,
+      file: filePath,
+      line: rel.line
+    }))
+
+    await this.graphDB.putEdges(triples)
+  }
+
+  resolveChunkId(filePath: string, line: number): string | null {
+    const withoutExt = filePath.replace(/\.[^/.]+$/, "")
+    const normalizedPath = withoutExt.replace(/[^a-zA-Z0-9]/g, "_")
+    return `chunk_${normalizedPath}_0`
+  }
+
+  async getRelatedChunks(chunkId: string): Promise<Array<{ chunk_id: string; predicate: string; weight: number; direction: "outgoing" | "incoming" }>> {
+    const [outgoing, incoming] = await Promise.all([
+      this.graphDB.getOutgoing(chunkId),
+      this.graphDB.getIncoming(chunkId)
+    ])
+
+    const result = [
+      ...outgoing.map(t => ({ chunk_id: t.object, predicate: t.predicate, weight: t.weight, direction: "outgoing" as const })),
+      ...incoming.map(t => ({ chunk_id: t.subject, predicate: t.predicate, weight: t.weight, direction: "incoming" as const }))
+    ]
+
+    return result
+  }
+}

package/vectorizer/graph-db.ts

@@ -0,0 +1,97 @@
+import levelgraph from "levelgraph"
+import { Level } from "level"
+
+export interface Triple {
+  subject: string
+  predicate: string
+  object: string
+  weight: number
+  source: string
+  file: string
+  line?: number
+}
+
+export class GraphDB {
+  private db: any
+  private initialized: boolean = false
+
+  constructor(private dbPath: string) {}
+
+  async init(): Promise<this> {
+    const levelDb = new Level(this.dbPath)
+    this.db = levelgraph(levelDb)
+    this.initialized = true
+    return this
+  }
+
+  async putEdges(triples: Triple[]): Promise<void> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    await new Promise<void>((resolve, reject) => {
+      this.db.put(triples, (err: Error | undefined) => {
+        if (err) reject(err)
+        else resolve()
+      })
+    })
+  }
+
+  async getOutgoing(chunkId: string): Promise<Triple[]> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    return new Promise<Triple[]>((resolve, reject) => {
+      this.db.get({ subject: chunkId }, (err: Error | undefined, triples: Triple[]) => {
+        if (err) reject(err)
+        else resolve(triples || [])
+      })
+    })
+  }
+
+  async getIncoming(chunkId: string): Promise<Triple[]> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    return new Promise<Triple[]>((resolve, reject) => {
+      this.db.get({ object: chunkId }, (err: Error | undefined, triples: Triple[]) => {
+        if (err) reject(err)
+        else resolve(triples || [])
+      })
+    })
+  }
+
+  async deleteByFile(filePath: string): Promise<void> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    const allTriples = await new Promise<Triple[]>((resolve, reject) => {
+      this.db.get({}, (err: Error | undefined, triples: Triple[]) => {
+        if (err) reject(err)
+        else resolve(triples || [])
+      })
+    })
+
+    const toDelete = allTriples.filter(t => t.file === filePath)
+
+    for (const t of toDelete) {
+      await new Promise<void>((resolve, reject) => {
+        this.db.del(t, (err: Error | undefined) => {
+          if (err) reject(err)
+          else resolve()
+        })
+      })
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.initialized && this.db) {
+      await new Promise<void>((resolve, reject) => {
+        this.db.close((err: Error | undefined) => {
+          if (err) reject(err)
+          else resolve()
+        })
+      })
+      this.initialized = false
+    }
+  }
+}

package/vectorizer/index.js

@@ -15,6 +15,8 @@ import { BM25Index } from "./bm25-index.ts";
 import { mergeResults, DEFAULT_HYBRID_CONFIG } from "./hybrid-search.ts";
 import { QueryCache, DEFAULT_CACHE_CONFIG } from "./query-cache.ts";
 import { SearchMetrics } from "./search-metrics.ts";
+import { GraphDB } from "./graph-db.ts";
+import { GraphBuilder } from "./graph-builder.ts";
 
 // Suppress transformers.js logs unless DEBUG is set
 const DEBUG = process.env.DEBUG?.includes("vectorizer") || process.env.DEBUG === "*";
@@ -350,6 +352,8 @@ class CodebaseIndexer {
     this.configLoaded = false;
     this.bm25 = null;          // lazy-built BM25 index
     this.metrics = null;       // lazy-loaded SearchMetrics
+    this.graphDB = null;       // Graph DB for relationships
+    this.graphBuilder = null;   // Graph builder orchestrator
   }
 
   async init() {
@@ -360,6 +364,13 @@ class CodebaseIndexer {
     await fs.mkdir(this.cacheDir, { recursive: true });
     this.db = await lancedb.connect(path.join(this.cacheDir, "lancedb"));
     await this.loadHashes();
+
+    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);
+
     return this;
   }
 
@@ -503,13 +514,21 @@ class CodebaseIndexer {
     // Semantic chunking
     const chunks = chunkContent(cleaned, fileMeta.file_type, fileMeta.language, CHUNKING_CONFIG);
 
+    // v3: Assign chunk IDs for graph tracking
+    const chunksWithIds = this.graphBuilder.assignChunkIds(relPath, chunks);
+
+    // v3: Delete old edges for this file and build new ones
+    await this.graphDB.deleteByFile(relPath);
+    await this.graphBuilder.buildEdges(relPath, content, chunksWithIds, fileMeta.file_type);
+
     const data = [];
-    for (let i = 0; i < chunks.length; i++) {
-      const embedding = await this.embed(chunks[i].content);
+    for (let i = 0; i < chunksWithIds.length; i++) {
+      const embedding = await this.embed(chunksWithIds[i].content);
       data.push({
+        chunk_id: chunksWithIds[i].chunk_id,
         file: relPath,
         chunk_index: i,
-        content: chunks[i].content,
+        content: chunksWithIds[i].content,
         vector: embedding,
         archived: archived,
         // v2 metadata
@@ -517,9 +536,9 @@ class CodebaseIndexer {
         language: fileMeta.language,
         last_modified: fileMeta.last_modified,
         file_size: fileMeta.file_size,
-        heading_context: chunks[i].heading_context || "",
-        function_name: chunks[i].function_name || "",
-        class_name: chunks[i].class_name || "",
+        heading_context: chunksWithIds[i].heading_context || "",
+        function_name: chunksWithIds[i].function_name || "",
+        class_name: chunksWithIds[i].class_name || "",
         tags: (fileMeta.tags || []).join(","),
       });
     }
@@ -720,9 +739,64 @@ class CodebaseIndexer {
       }
     }
 
+    // ── Graph context expansion (v3) ───────────────────────────────────────
+    if (this.graphDB) {
+      for (const result of finalResults) {
+        if (!result.chunk_id) continue;
+
+        const outgoing = await this.graphDB.getOutgoing(result.chunk_id);
+        const incoming = await this.graphDB.getIncoming(result.chunk_id);
+        const allEdges = [...outgoing, ...incoming];
+
+        const neighbors = [];
+        for (const edge of allEdges) {
+          const neighborId = edge.subject === result.chunk_id ? edge.object : edge.subject;
+          const neighborChunk = await this.findChunkById(neighborId);
+          if (!neighborChunk) continue;
+
+          const similarity = this.cosineSimilarity(neighborChunk.vector, queryEmbedding);
+          const score = edge.weight * similarity;
+
+          neighbors.push({
+            chunk_id: neighborId,
+            file: neighborChunk.file,
+            content: neighborChunk.content,
+            relation: edge.predicate,
+            score,
+            via: edge.source
+          });
+        }
+
+        neighbors.sort((a, b) => b.score - a.score);
+        result.relatedContext = neighbors.slice(0, 3);
+      }
+    }
+
     return finalResults;
   }
 
+  async findChunkById(chunkId) {
+    const tableName = "chunks";
+    const tables = await this.db.tableNames();
+    if (!tables.includes(tableName)) return null;
+
+    const table = await this.db.openTable(tableName);
+    const rows = await table.search([0]).limit(100000).execute();
+    return rows.find(r => r.chunk_id === chunkId) || null;
+  }
+
+  cosineSimilarity(vecA, vecB) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < vecA.length; i++) {
+      dotProduct += vecA[i] * vecB[i];
+      normA += vecA[i] * vecA[i];
+      normB += vecB[i] * vecB[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+
   async checkHealth(extraIgnore = []) {
     const { glob } = await import("glob");
     const preset = INDEX_PRESETS[this.indexName] || DEFAULT_PRESETS.code;

package/vectorizer.yaml

@@ -39,6 +39,20 @@ vectorizer:
     hybrid: false          # Enable hybrid search (vector + BM25)
     bm25_weight: 0.3       # BM25 weight in hybrid mode (0.0-1.0)
 
+  # Graph-based context (v3)
+  graph:
+    enabled: true
+    max_related: 3           # How many related chunks to attach
+    min_relevance: 0.5       # Minimum score threshold for related context
+
+    # LSP for code analysis
+    lsp:
+      enabled: true
+      timeout_ms: 5000       # Timeout per file
+
+    # Read() intercept
+    read_intercept: true
+
   # Quality monitoring (v2)
   quality:
     enable_metrics: false   # Track search quality metrics