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

package/vectorizer/analyzers/lsp-analyzer.ts

@@ -1,4 +1,19 @@
+/**
+ * LSPAnalyzer — extracts code relations via Language Server Protocol.
+ *
+ * Uses LSPClient (lsp-client.ts) to communicate with real language servers
+ * (typescript-language-server, pylsp, gopls, etc.).
+ *
+ * Strategy: LSP-first with graceful degradation.
+ * - If LSP server binary not found → isAvailable() returns false → GraphBuilder uses regex fallback
+ * - If LSP server crashes or times out during analysis → analyzeFile() returns [] → GraphBuilder uses regex
+ * - Timeout: 5 seconds per file (configurable)
+ */
+
+import path from "path"
+import fs from "fs/promises"
 import { ChunkWithId } from "../graph-builder"
+import { LSPClient, LSPSymbolInformation, SymbolKind } from "./lsp-client"
 
 export interface Relation {
   from: string
@@ -9,134 +24,248 @@ export interface Relation {
   line?: number
 }
 
+/** Language ID mapping from file extension. */
+const EXT_TO_LANGUAGE: 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",
+}
+
+/** Symbol kinds that represent types (classes, interfaces) — check implementations. */
+const TYPE_SYMBOL_KINDS = new Set([
+  SymbolKind.Class,
+  SymbolKind.Interface,
+])
+
+/** Symbol kinds worth analyzing for references/definitions. */
+const ANALYZABLE_SYMBOL_KINDS = new Set([
+  SymbolKind.Class,
+  SymbolKind.Interface,
+  SymbolKind.Function,
+  SymbolKind.Method,
+  SymbolKind.Variable,
+  SymbolKind.Constant,
+  SymbolKind.Enum,
+])
+
 export class LSPAnalyzer {
-  private readonly timeout = 5000
+  private client: LSPClient | null = null
+  private currentLanguage: string | null = null
+  private filesOpened = 0
+  private readonly timeoutMs: number
+
+  constructor(
+    private projectRoot?: string,
+    timeoutMs?: number,
+  ) {
+    this.timeoutMs = timeoutMs ?? 5000
+  }
 
+  // ---- public API ---------------------------------------------------------
+
+  /** Check if an LSP server is available for this file's language. */
   async isAvailable(filePath: string): Promise<boolean> {
     try {
-      const ext = filePath.split(".").pop()
-      if (!ext) return false
-
-      const language = this.getLanguage(ext)
+      const language = this.getLanguage(filePath)
       if (!language) return false
-
-      return this.checkLSPServer(language)
+      return LSPClient.isAvailable(language)
     } catch {
       return false
     }
   }
 
+  /**
+   * Analyze a file using LSP and return relations.
+   *
+   * Flow:
+   * 1. Start/reuse server for the file's language
+   * 2. Open document
+   * 3. Get document symbols (functions, classes, interfaces)
+   * 4. For each symbol: get definitions, references, implementations
+   * 5. Map LSP locations → chunk IDs → Relation objects
+   * 6. Close document
+   */
   async analyzeFile(filePath: string, chunks: ChunkWithId[]): Promise<Relation[]> {
+    const language = this.getLanguage(filePath)
+    if (!language) return []
+
+    const root = this.projectRoot || process.cwd()
+    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(root, filePath)
+
+    let content: string
+    try {
+      content = await fs.readFile(absPath, "utf-8")
+    } catch {
+      return []
+    }
+
+    // Ensure client is started for this language
+    try {
+      await this.ensureClient(language, root)
+    } catch {
+      return []
+    }
+
+    const client = this.client!
     const relations: Relation[] = []
 
     try {
-      const ext = filePath.split(".").pop()
-      if (!ext) return []
+      // Open the document
+      await client.openDocument(filePath, content, language)
+      this.filesOpened++
 
-      const language = this.getLanguage(ext)
-      if (!language) return []
+      // First file needs extra warmup for project loading / type graph build
+      if (this.filesOpened === 1) {
+        await new Promise(r => setTimeout(r, 2000))
+      } else {
+        await new Promise(r => setTimeout(r, 500))
+      }
 
-      const lines = await this.readFileLines(filePath)
+      // Get all symbols in the file
+      const rawSymbols = await client.documentSymbol(filePath)
+      const symbols = this.flattenSymbols(rawSymbols)
 
-      const symbols = await this.getDocumentSymbols(filePath, language)
-      if (!symbols) return []
+      // Analyze each symbol
+      for (const sym of symbols) {
+        if (!ANALYZABLE_SYMBOL_KINDS.has(sym.kind)) continue
 
-      for (const symbol of symbols) {
-        const fromChunkId = this.findChunkForPosition(chunks, symbol.line)
+        const fromChunkId = this.findChunkForPosition(chunks, sym.selectionRange.start.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) {
+        const selLine = sym.selectionRange.start.line
+        const selChar = sym.selectionRange.start.character
+
+        // --- implementations (for classes/interfaces) ---
+        if (TYPE_SYMBOL_KINDS.has(sym.kind)) {
+          try {
+            const impls = await client.implementation(filePath, selLine, selChar)
+            for (const impl of impls) {
+              const toChunkId = this.locationToChunkId(filePath, impl.uri, impl.range.start.line, root)
+              if (toChunkId && toChunkId !== fromChunkId) {
+                relations.push({
+                  from: fromChunkId,
+                  to: toChunkId,
+                  predicate: "implements",
+                  weight: 1.0,
+                  source: "lsp",
+                  line: selLine,
+                })
+              }
+            }
+          } catch { /* server may not support implementation */ }
+        }
+
+        // --- references ---
+        try {
+          const refs = await client.references(filePath, selLine, selChar)
+          for (const ref of refs) {
+            const toChunkId = this.locationToChunkId(filePath, ref.uri, ref.range.start.line, root)
+            if (toChunkId && toChunkId !== fromChunkId) {
               relations.push({
-                from: fromChunkId,
-                to: toChunkId,
-                predicate: "implements",
+                from: toChunkId,
+                to: fromChunkId,
+                predicate: "used_by",
                 weight: 1.0,
-                source: "lsp"
+                source: "lsp",
+                line: ref.range.start.line,
               })
             }
           }
-        }
+        } catch { /* server may not support references */ }
 
-        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"
-            })
+        // --- definitions ---
+        try {
+          const defs = await client.definition(filePath, selLine, selChar)
+          for (const def of defs) {
+            const toChunkId = this.locationToChunkId(filePath, def.uri, def.range.start.line, root)
+            if (toChunkId && toChunkId !== fromChunkId) {
+              relations.push({
+                from: fromChunkId,
+                to: toChunkId,
+                predicate: "references",
+                weight: 1.0,
+                source: "lsp",
+                line: selLine,
+              })
+            }
           }
-        }
+        } catch { /* server may not support definition */ }
       }
-    } catch (error) {
-      return []
+
+      await client.closeDocument(filePath)
+    } catch {
+      // Any error — return whatever we collected so far (or empty)
     }
 
-    return relations
+    return this.deduplicateRelations(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"
+  /** Stop the LSP server. Call when done indexing. */
+  async shutdown(): Promise<void> {
+    if (this.client) {
+      try { await this.client.stop() } catch { /* best effort */ }
+      this.client = null
+      this.currentLanguage = null
+      this.filesOpened = 0
     }
-    return map[ext] || null
   }
 
-  private checkLSPServer(language: string): Promise<boolean> {
-    return Promise.resolve(false)
-  }
+  // ---- internals ----------------------------------------------------------
 
-  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 getLanguage(filePath: string): string | null {
+    const ext = filePath.split(".").pop()
+    if (!ext) return null
+    return EXT_TO_LANGUAGE[ext] || null
   }
 
-  private async getDocumentSymbols(filePath: string, language: string): Promise<Array<{ name: string; type: string; line: number; character: number }> | null> {
-    return null
+  /** Start or reuse a client for the given language. */
+  private async ensureClient(language: string, root: string): Promise<void> {
+    // If we already have a client for a different language, shut it down
+    if (this.client && this.currentLanguage !== language) {
+      await this.shutdown()
+    }
+    if (!this.client) {
+      this.client = new LSPClient(root, this.timeoutMs)
+      await this.client.start(language)
+      this.currentLanguage = language
+    }
   }
 
-  private async getImplementations(filePath: string, line: number, character: number, language: string): Promise<Array<{ file: string; line: number; character: number }>> {
-    return []
+  /** Flatten hierarchical DocumentSymbol tree into flat array. */
+  private flattenSymbols(symbols: LSPSymbolInformation[]): LSPSymbolInformation[] {
+    const result: LSPSymbolInformation[] = []
+    const walk = (list: LSPSymbolInformation[]) => {
+      for (const sym of list) {
+        result.push(sym)
+        if (sym.children?.length) walk(sym.children)
+      }
+    }
+    walk(symbols)
+    return result
   }
 
-  private async getReferences(filePath: string, line: number, character: number, language: string): Promise<Array<{ file: string; line: number; character: number }>> {
-    return []
-  }
+  /** Convert LSP location URI + line → chunk_id. */
+  private locationToChunkId(currentFile: string, uri: string, line: number, root: string): string | null {
+    // uri = file:///absolute/path/to/file.ts
+    const filePath = uri.startsWith("file://") ? uri.slice(7) : uri
+    const relPath = path.relative(root, filePath)
+
+    // Skip external files (node_modules, etc.)
+    if (relPath.startsWith("..") || relPath.includes("node_modules")) return null
 
-  private async getDefinitions(filePath: string, line: number, character: number, language: string): Promise<Array<{ file: string; line: number; character: number }>> {
-    return []
+    const withoutExt = relPath.replace(/\.[^/.]+$/, "")
+    const normalized = withoutExt.replace(/[^a-zA-Z0-9]/g, "_")
+    // For cross-file references, point to chunk 0 (first chunk of target file)
+    // For same-file, we could be more precise but chunk 0 is sufficient for graph
+    return `chunk_${normalized}_0`
   }
 
   private findChunkForPosition(chunks: ChunkWithId[], line: number): string | null {
@@ -147,16 +276,18 @@ export class LSPAnalyzer {
         }
       }
     }
-    return null
+    // Fallback: if no chunk matches by line, return first chunk
+    return chunks.length > 0 ? chunks[0].chunk_id : 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`
+  /** Remove duplicate relations (same from+to+predicate). */
+  private deduplicateRelations(relations: Relation[]): Relation[] {
+    const seen = new Set<string>()
+    return relations.filter(r => {
+      const key = `${r.from}|${r.to}|${r.predicate}`
+      if (seen.has(key)) return false
+      seen.add(key)
+      return true
+    })
   }
 }