claude-brain 0.17.13 → 0.22.0

package/src/code-intelligence/parser.ts

@@ -0,0 +1,484 @@
+import Parser from 'web-tree-sitter'
+import { join, extname } from 'node:path'
+import type { Language, CodeSymbol, ParsedFile, ImportInfo } from './types'
+
+/** Map file extensions to Language */
+const EXTENSION_MAP: Record<string, Language> = {
+  '.ts': 'typescript',
+  '.tsx': 'tsx',
+  '.js': 'javascript',
+  '.jsx': 'jsx',
+  '.mjs': 'javascript',
+  '.cjs': 'javascript',
+  '.py': 'python',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.vue': 'vue',
+  '.html': 'html',
+  '.css': 'css',
+  '.json': 'json',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+}
+
+/** Languages that share the TypeScript grammar */
+const TS_FAMILY = new Set<Language>(['typescript', 'javascript'])
+
+/** Languages that use the TSX grammar */
+const TSX_FAMILY = new Set<Language>(['tsx', 'jsx'])
+
+/** Map Language to WASM grammar file name */
+function grammarNameForLanguage(lang: Language): string | null {
+  if (TS_FAMILY.has(lang)) return 'typescript'
+  if (TSX_FAMILY.has(lang)) return 'tsx'
+  return null
+}
+
+/**
+ * Tree-sitter based code parser.
+ * Currently supports TypeScript, JavaScript, TSX, and JSX.
+ * Call `initialize()` once before using `parseFile()`.
+ */
+export class CodeParser {
+  private parser: Parser | null = null
+  private languages = new Map<string, Parser.Language>()
+  private initialized = false
+
+  /**
+   * Initialize the parser and load WASM grammars.
+   * Must be called once before parseFile().
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) return
+
+    await Parser.init()
+    this.parser = new Parser()
+
+    const grammarsToLoad = ['typescript', 'tsx']
+    for (const name of grammarsToLoad) {
+      const wasmPath = this.resolveWasmPath(name)
+      try {
+        const lang = await Parser.Language.load(wasmPath)
+        this.languages.set(name, lang)
+      } catch (err) {
+        throw new Error(
+          `Failed to load tree-sitter WASM grammar "${name}" from ${wasmPath}: ${err instanceof Error ? err.message : String(err)}`
+        )
+      }
+    }
+
+    this.initialized = true
+  }
+
+  /**
+   * Detect language from a file path's extension.
+   * Returns null for unsupported file types.
+   */
+  detectLanguage(filePath: string): Language | null {
+    const ext = extname(filePath).toLowerCase()
+    return EXTENSION_MAP[ext] ?? null
+  }
+
+  /**
+   * Parse a file and extract its symbols and imports.
+   * Returns an empty symbol list for unsupported languages.
+   */
+  async parseFile(filePath: string, content: string): Promise<ParsedFile> {
+    const language = this.detectLanguage(filePath)
+    if (!language) {
+      return {
+        filePath,
+        language: 'typescript',
+        symbols: [],
+        imports: [],
+        lineCount: content.split('\n').length,
+      }
+    }
+
+    const grammarName = grammarNameForLanguage(language)
+    if (!grammarName) {
+      return {
+        filePath,
+        language,
+        symbols: [],
+        imports: [],
+        lineCount: content.split('\n').length,
+      }
+    }
+
+    if (!this.initialized || !this.parser) {
+      throw new Error('CodeParser not initialized. Call initialize() first.')
+    }
+
+    const treeSitterLang = this.languages.get(grammarName)
+    if (!treeSitterLang) {
+      throw new Error(`Grammar "${grammarName}" not loaded.`)
+    }
+
+    this.parser.setLanguage(treeSitterLang)
+
+    let tree: Parser.Tree | undefined
+    try {
+      tree = this.parser.parse(content)
+
+      const symbols = this.extractSymbols(tree, filePath)
+      const imports = this.extractImports(tree)
+
+      return {
+        filePath,
+        language,
+        symbols,
+        imports,
+        lineCount: content.split('\n').length,
+      }
+    } finally {
+      tree?.delete()
+    }
+  }
+
+  /**
+   * Extract symbols (functions, classes, interfaces, etc.) from a parsed tree.
+   */
+  private extractSymbols(tree: Parser.Tree, filePath: string): CodeSymbol[] {
+    const symbols: CodeSymbol[] = []
+    this.walkForSymbols(tree.rootNode, filePath, null, false, symbols)
+    return symbols
+  }
+
+  /**
+   * Recursively walk the AST to find symbol declarations.
+   */
+  private walkForSymbols(
+    node: Parser.SyntaxNode,
+    filePath: string,
+    parentSymbol: string | null,
+    isExported: boolean,
+    symbols: CodeSymbol[]
+  ): void {
+    const type = node.type
+
+    if (type === 'export_statement') {
+      for (const child of node.namedChildren) {
+        this.walkForSymbols(child, filePath, parentSymbol, true, symbols)
+      }
+      return
+    }
+
+    const symbol = this.nodeToSymbol(node, filePath, parentSymbol, isExported)
+    if (symbol) {
+      symbols.push(symbol)
+
+      // For classes/interfaces, walk children to find methods
+      if (symbol.type === 'class' || symbol.type === 'interface') {
+        const body = node.childForFieldName('body')
+        if (body) {
+          for (const child of body.namedChildren) {
+            this.walkForSymbols(child, filePath, symbol.name, isExported, symbols)
+          }
+        }
+        return
+      }
+    }
+
+    // Continue walking for top-level containers
+    if (this.isContainerNode(type)) {
+      for (const child of node.namedChildren) {
+        this.walkForSymbols(child, filePath, parentSymbol, false, symbols)
+      }
+    }
+  }
+
+  /**
+   * Convert a tree-sitter node to a CodeSymbol if it represents a declaration.
+   */
+  private nodeToSymbol(
+    node: Parser.SyntaxNode,
+    filePath: string,
+    parentSymbol: string | null,
+    isExported: boolean
+  ): CodeSymbol | null {
+    const type = node.type
+
+    switch (type) {
+      case 'function_declaration':
+      case 'function_signature': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'function',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          signature: this.extractSignature(node),
+          exported: isExported,
+        }
+      }
+
+      case 'class_declaration': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'class',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          exported: isExported,
+        }
+      }
+
+      case 'interface_declaration': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'interface',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          exported: isExported,
+        }
+      }
+
+      case 'type_alias_declaration': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'type',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          exported: isExported,
+        }
+      }
+
+      case 'enum_declaration': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'enum',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          exported: isExported,
+        }
+      }
+
+      case 'method_definition':
+      case 'method_signature': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'method',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          signature: this.extractSignature(node),
+          exported: isExported,
+        }
+      }
+
+      case 'public_field_definition':
+      case 'property_signature': {
+        const name = node.childForFieldName('name')
+        if (!name) return null
+        return {
+          name: name.text,
+          type: 'variable',
+          filePath,
+          lineStart: node.startPosition.row + 1,
+          lineEnd: node.endPosition.row + 1,
+          parentSymbol: parentSymbol ?? undefined,
+          exported: isExported,
+        }
+      }
+
+      case 'lexical_declaration':
+      case 'variable_declaration': {
+        return this.extractFromLexicalDeclaration(node, filePath, parentSymbol, isExported)
+      }
+
+      default:
+        return null
+    }
+  }
+
+  /**
+   * Extract a symbol from a lexical_declaration (const/let) or variable_declaration (var).
+   * Handles arrow functions assigned to variables.
+   */
+  private extractFromLexicalDeclaration(
+    node: Parser.SyntaxNode,
+    filePath: string,
+    parentSymbol: string | null,
+    isExported: boolean
+  ): CodeSymbol | null {
+    const declarator = node.namedChildren.find(
+      (c) => c.type === 'variable_declarator'
+    )
+    if (!declarator) return null
+
+    const name = declarator.childForFieldName('name')
+    if (!name) return null
+
+    const value = declarator.childForFieldName('value')
+    const isConst = node.text.trimStart().startsWith('const')
+
+    if (value && (value.type === 'arrow_function' || value.type === 'function_expression' || value.type === 'function')) {
+      return {
+        name: name.text,
+        type: 'function',
+        filePath,
+        lineStart: node.startPosition.row + 1,
+        lineEnd: node.endPosition.row + 1,
+        parentSymbol: parentSymbol ?? undefined,
+        signature: this.extractSignature(value),
+        exported: isExported,
+      }
+    }
+
+    return {
+      name: name.text,
+      type: isConst ? 'constant' : 'variable',
+      filePath,
+      lineStart: node.startPosition.row + 1,
+      lineEnd: node.endPosition.row + 1,
+      parentSymbol: parentSymbol ?? undefined,
+      exported: isExported,
+    }
+  }
+
+  /**
+   * Extract function signature (parameters + return type).
+   */
+  private extractSignature(node: Parser.SyntaxNode): string | undefined {
+    const params = node.childForFieldName('parameters')
+    const returnType = node.childForFieldName('return_type')
+
+    if (!params) return undefined
+
+    let sig = params.text
+    if (returnType) {
+      // returnType.text may include the leading `:`, so avoid doubling it
+      const rt = returnType.text.trimStart()
+      sig += rt.startsWith(':') ? ' ' + rt : ': ' + rt
+    }
+    return sig
+  }
+
+  /**
+   * Extract import statements from the AST.
+   */
+  private extractImports(tree: Parser.Tree): ImportInfo[] {
+    const imports: ImportInfo[] = []
+
+    for (const child of tree.rootNode.namedChildren) {
+      if (child.type === 'import_statement') {
+        const info = this.parseImportStatement(child)
+        if (info) imports.push(info)
+      }
+    }
+
+    return imports
+  }
+
+  /**
+   * Parse a single import_statement node into an ImportInfo.
+   */
+  private parseImportStatement(node: Parser.SyntaxNode): ImportInfo | null {
+    const source = node.childForFieldName('source')
+    if (!source) return null
+
+    const sourcePath = source.text.replace(/^['"]|['"]$/g, '')
+    const names: string[] = []
+
+    for (const child of node.namedChildren) {
+      if (child.type === 'import_clause') {
+        this.collectImportNames(child, names)
+      }
+      if (child.type === 'namespace_import') {
+        const alias = child.childForFieldName('name') ?? child.namedChildren[0]
+        if (alias) names.push(alias.text)
+      }
+      if (child.type === 'named_imports') {
+        for (const spec of child.namedChildren) {
+          if (spec.type === 'import_specifier') {
+            const specName = spec.childForFieldName('name') ?? spec.namedChildren[0]
+            if (specName) names.push(specName.text)
+          }
+        }
+      }
+    }
+
+    return {
+      source: sourcePath,
+      names,
+      importType: 'import',
+      line: node.startPosition.row + 1,
+    }
+  }
+
+  /**
+   * Collect imported names from an import_clause node.
+   */
+  private collectImportNames(node: Parser.SyntaxNode, names: string[]): void {
+    for (const child of node.namedChildren) {
+      switch (child.type) {
+        case 'identifier':
+          names.push(child.text)
+          break
+        case 'named_imports':
+          for (const spec of child.namedChildren) {
+            if (spec.type === 'import_specifier') {
+              const specName = spec.childForFieldName('name') ?? spec.namedChildren[0]
+              if (specName) names.push(specName.text)
+            }
+          }
+          break
+        case 'namespace_import': {
+          const alias = child.childForFieldName('name') ?? child.namedChildren[0]
+          if (alias) names.push(alias.text)
+          break
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if a node type is a container that may hold declarations.
+   */
+  private isContainerNode(type: string): boolean {
+    return (
+      type === 'program' ||
+      type === 'statement_block' ||
+      type === 'module' ||
+      type === 'export_statement'
+    )
+  }
+
+  /**
+   * Resolve the path to a tree-sitter WASM grammar file.
+   */
+  private resolveWasmPath(grammarName: string): string {
+    try {
+      const wasmsDir = require.resolve('tree-sitter-wasms/package.json')
+      return join(wasmsDir, '..', 'out', `tree-sitter-${grammarName}.wasm`)
+    } catch {
+      return join(
+        import.meta.dir,
+        '../../node_modules/tree-sitter-wasms/out',
+        `tree-sitter-${grammarName}.wasm`
+      )
+    }
+  }
+}