claude-brain 0.30.2 → 0.30.3

package/src/code-intelligence/parser.ts

@@ -1,484 +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`
-      )
-    }
-  }
-}
+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`
+      )
+    }
+  }
+}