edhindex 1.0.2 → 1.1.0

package/src/language/adapters/html.ts

@@ -0,0 +1,68 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'html',
+  wasmPath: require.resolve('tree-sitter-html/tree-sitter-html.wasm'),
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['tag_name', 'attribute_name'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class HtmlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'HTML'; }
+  fileExtensions(): string[] { return ['.html', '.htm']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.collectElements(tree.rootNode, symbols, filePath);
+    return symbols;
+  }
+
+  private collectElements(node: any, symbols: CodeSymbol[], filePath: string) {
+    if (node.type === 'element') {
+      const tagName = this.extractTagName(node);
+      const significant = ['script', 'style', 'template', 'main', 'nav', 'header', 'footer',
+        'section', 'article', 'form', 'aside', 'dialog', 'details'];
+      if (significant.includes(tagName) || tagName.includes('-')) {
+        symbols.push({
+          id: `${filePath}:${node.startPosition.row + 1}`,
+          name: tagName,
+          type: SymbolType.Module,
+          language: 'html',
+          file: filePath,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          parent: null,
+          children: [],
+          metadata: { tag: tagName },
+        });
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.collectElements(child, symbols, filePath);
+    }
+  }
+
+  private extractTagName(node: any): string {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'tag_name') return child.text;
+      if (child.type === 'start_tag' || child.type === 'end_tag') {
+        for (let j = 0; j < child.childCount; j++) {
+          const grandchild = child.child(j);
+          if (grandchild && grandchild.type === 'tag_name') return grandchild.text;
+        }
+      }
+    }
+    return 'unknown';
+  }
+}

package/src/language/adapters/java.ts

@@ -0,0 +1,32 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'java',
+  wasmPath: require.resolve('tree-sitter-java/tree-sitter-java.wasm'),
+  queryPatterns: {
+    method_declaration: '(method_declaration name: (identifier) @name)',
+    class_declaration: '(class_declaration name: (identifier) @name)',
+    interface_declaration: '(interface_declaration name: (identifier) @name)',
+    enum_declaration: '(enum_declaration name: (identifier) @name)',
+  },
+  typeMap: {
+    method_declaration: SymbolType.Method,
+    class_declaration: SymbolType.Class,
+    interface_declaration: SymbolType.Interface,
+    enum_declaration: SymbolType.Enum,
+    import_declaration: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['import_declaration'],
+  exportNodeTypes: [],
+};
+
+export class JavaAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Java'; }
+  fileExtensions(): string[] { return ['.java']; }
+}

package/src/language/adapters/javascript.ts

@@ -0,0 +1,33 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'js',
+  wasmPath: require.resolve('tree-sitter-typescript/tree-sitter-typescript.wasm'),
+  queryPatterns: {
+    function_declaration: '(function_declaration name: (identifier) @name)',
+    method_definition: '(method_definition name: (property_identifier) @name)',
+    class_declaration: '(class_declaration name: (identifier) @name)',
+  },
+  typeMap: {
+    function_declaration: SymbolType.Function,
+    arrow_function: SymbolType.Function,
+    method_definition: SymbolType.Method,
+    class_declaration: SymbolType.Class,
+    import_statement: SymbolType.Import,
+    import_declaration: SymbolType.Import,
+    export_statement: SymbolType.Export,
+  },
+  nameNodeTypes: ['identifier', 'property_identifier'],
+  importNodeTypes: ['import_statement', 'import_declaration'],
+  exportNodeTypes: ['export_statement'],
+};
+
+export class JavaScriptAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'JavaScript'; }
+  fileExtensions(): string[] { return ['.js', '.jsx', '.mjs', '.cjs']; }
+}

package/src/language/adapters/json.ts

@@ -0,0 +1,60 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'json',
+  wasmPath: require.resolve('tree-sitter-json/tree-sitter-json.wasm'),
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: [],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class JsonAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'JSON'; }
+  fileExtensions(): string[] { return ['.json']; }
+  fileNames(): string[] { return []; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkPairs(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  private walkPairs(node: any, symbols: CodeSymbol[], filePath: string, parentId: string) {
+    if (node.type === 'pair') {
+      let key = '';
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === 'string' && !key) {
+          key = child.text?.replace(/"/g, '') || '';
+          break;
+        }
+      }
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Property, language: 'json',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && (child.type === 'object' || child.type === 'array')) {
+            this.walkPairs(child, symbols, filePath, id);
+          }
+        }
+      }
+      return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkPairs(child, symbols, filePath, parentId);
+    }
+  }
+}

package/src/language/adapters/php.ts

@@ -0,0 +1,31 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'php',
+  wasmPath: require.resolve('tree-sitter-php/tree-sitter-php.wasm'),
+  queryPatterns: {
+    function_definition: '(function_definition name: (name) @name)',
+    method_declaration: '(method_declaration name: (name) @name)',
+    class_declaration: '(class_declaration name: (name) @name)',
+    interface_declaration: '(interface_declaration name: (name) @name)',
+  },
+  typeMap: {
+    function_definition: SymbolType.Function,
+    method_declaration: SymbolType.Method,
+    class_declaration: SymbolType.Class,
+    interface_declaration: SymbolType.Interface,
+  },
+  nameNodeTypes: ['name'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class PhpAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'PHP'; }
+  fileExtensions(): string[] { return ['.php']; }
+}

package/src/language/adapters/python.ts

@@ -0,0 +1,29 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'py',
+  wasmPath: require.resolve('tree-sitter-python/tree-sitter-python.wasm'),
+  queryPatterns: {
+    function_definition: '(function_definition name: (identifier) @name)',
+    class_definition: '(class_definition name: (identifier) @name)',
+  },
+  typeMap: {
+    function_definition: SymbolType.Function,
+    class_definition: SymbolType.Class,
+    import_statement: SymbolType.Import,
+    import_from_statement: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['import_statement', 'import_from_statement'],
+  exportNodeTypes: [],
+};
+
+export class PythonAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Python'; }
+  fileExtensions(): string[] { return ['.py', '.pyw']; }
+}

package/src/language/adapters/ruby.ts

@@ -0,0 +1,31 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'rb',
+  wasmPath: require.resolve('tree-sitter-ruby/tree-sitter-ruby.wasm'),
+  queryPatterns: {
+    method: '(method name: (identifier) @name)',
+    class: '(class name: (constant) @name)',
+    module: '(module name: (constant) @name)',
+  },
+  typeMap: {
+    method: SymbolType.Method,
+    class: SymbolType.Class,
+    module: SymbolType.Module,
+    call: SymbolType.Unknown,
+    require: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier', 'constant'],
+  importNodeTypes: ['require'],
+  exportNodeTypes: [],
+};
+
+export class RubyAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Ruby'; }
+  fileExtensions(): string[] { return ['.rb']; }
+}

package/src/language/adapters/rust.ts

@@ -0,0 +1,33 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'rs',
+  wasmPath: require.resolve('tree-sitter-rust/tree-sitter-rust.wasm'),
+  queryPatterns: {
+    function_item: '(function_item name: (identifier) @name)',
+    struct_item: '(struct_item name: (type_identifier) @name)',
+    trait_item: '(trait_item name: (type_identifier) @name)',
+    enum_item: '(enum_item name: (type_identifier) @name)',
+  },
+  typeMap: {
+    function_item: SymbolType.Function,
+    struct_item: SymbolType.Struct,
+    trait_item: SymbolType.Trait,
+    impl_item: SymbolType.Module,
+    enum_item: SymbolType.Enum,
+    use_declaration: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier', 'type_identifier'],
+  importNodeTypes: ['use_declaration'],
+  exportNodeTypes: [],
+};
+
+export class RustAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Rust'; }
+  fileExtensions(): string[] { return ['.rs']; }
+}

package/src/language/adapters/typescript.ts

@@ -0,0 +1,37 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'ts',
+  wasmPath: require.resolve('tree-sitter-typescript/tree-sitter-typescript.wasm'),
+  queryPatterns: {
+    function_declaration: '(function_declaration name: (identifier) @name)',
+    method_definition: '(method_definition name: (property_identifier) @name)',
+    class_declaration: '(class_declaration name: (type_identifier) @name)',
+    interface_declaration: '(interface_declaration name: (type_identifier) @name)',
+    enum_declaration: '(enum_declaration name: (type_identifier) @name)',
+  },
+  typeMap: {
+    function_declaration: SymbolType.Function,
+    arrow_function: SymbolType.Function,
+    method_definition: SymbolType.Method,
+    class_declaration: SymbolType.Class,
+    interface_declaration: SymbolType.Interface,
+    enum_declaration: SymbolType.Enum,
+    import_statement: SymbolType.Import,
+    import_declaration: SymbolType.Import,
+    export_statement: SymbolType.Export,
+  },
+  nameNodeTypes: ['identifier', 'property_identifier', 'type_identifier'],
+  importNodeTypes: ['import_statement', 'import_declaration'],
+  exportNodeTypes: ['export_statement'],
+};
+
+export class TypeScriptAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'TypeScript'; }
+  fileExtensions(): string[] { return ['.ts', '.tsx', '.mts', '.cts']; }
+}

package/src/language/base.ts

@@ -0,0 +1,167 @@
+import { createRequire } from 'node:module';
+import { Parser, Language } from 'web-tree-sitter';
+import { SymbolType, CodeSymbol, ParseResult, LanguageAdapter } from './types.js';
+
+const require = createRequire(import.meta.url);
+
+export interface GrammarConfig {
+  language: string;
+  wasmPath: string;
+  queryPatterns: Record<string, string>;
+  typeMap: Record<string, SymbolType>;
+  nameNodeTypes: string[];
+  importNodeTypes: string[];
+  exportNodeTypes: string[];
+}
+
+export abstract class BaseTreeSitterAdapter implements LanguageAdapter {
+  protected abstract grammar: GrammarConfig;
+  protected parser: Parser | null = null;
+  protected loadedLang: any = null;
+  private static initialized = false;
+  private static loadedGrammars = new Map<string, any>();
+
+  abstract languageName(): string;
+  abstract fileExtensions(): string[];
+  fileNames(): string[] { return []; }
+
+  canParse(filePath: string): boolean {
+    const lower = filePath.toLowerCase();
+    for (const ext of this.fileExtensions()) {
+      if (lower.endsWith(ext)) return true;
+    }
+    for (const name of this.fileNames()) {
+      if (lower === name || lower.endsWith('/' + name)) return true;
+    }
+    return false;
+  }
+
+  supportsSymbols(): boolean {
+    return Object.keys(this.grammar.queryPatterns).length > 0;
+  }
+
+  async loadGrammar(): Promise<void> {
+    const key = this.grammar.language;
+    if (BaseTreeSitterAdapter.loadedGrammars.has(key)) {
+      this.loadedLang = BaseTreeSitterAdapter.loadedGrammars.get(key);
+      return;
+    }
+    if (!BaseTreeSitterAdapter.initialized) {
+      await Parser.init();
+      BaseTreeSitterAdapter.initialized = true;
+    }
+    const lang = await Language.load(this.grammar.wasmPath);
+    BaseTreeSitterAdapter.loadedGrammars.set(key, lang);
+    this.loadedLang = lang;
+    this.parser = new Parser();
+    this.parser.setLanguage(lang);
+  }
+
+  async parse(content: string, filePath: string): Promise<ParseResult> {
+    if (!this.parser) await this.loadGrammar();
+
+    const tree = this.parser!.parse(content);
+    const symbols = await this.extractSymbolsFromTree(tree, filePath, content);
+    const imports = this.extractImportsFromTree(tree);
+    const exports = this.extractExportsFromTree(tree);
+    const comments = this.extractCommentsFromTree(tree);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    if (Object.keys(this.grammar.queryPatterns).length === 0) return symbols;
+    this.walkForSymbols(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  protected walkForSymbols(node: any, symbols: CodeSymbol[], filePath: string, parentId: string): void {
+    const type = node.type;
+    const symbolType = this.grammar.typeMap[type];
+
+    if (symbolType) {
+      const name = this.extractName(node);
+      if (name) {
+        symbols.push({
+          id: `${filePath}:${node.startPosition.row + 1}`,
+          name,
+          type: symbolType,
+          language: this.grammar.language,
+          file: filePath,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          parent: parentId || null,
+          children: [],
+          metadata: {},
+        });
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      const childNode = node.child(i);
+      if (childNode) {
+        this.walkForSymbols(childNode, symbols, filePath, '');
+      }
+    }
+  }
+
+  protected extractName(node: any): string | null {
+    try {
+      const nameTypes = new Set([
+        'identifier', 'property_identifier', 'type_identifier',
+        'field_identifier', 'constant', 'variable', 'name', 'type',
+        'selector', 'class_name', 'function_name', 'method_name',
+      ]);
+      return this.findName(node, nameTypes);
+    } catch {
+      return null;
+    }
+  }
+
+  private findName(node: any, nameTypes: Set<string>): string | null {
+    if (nameTypes.has(node.type)) {
+      return node.text;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) {
+        const result = this.findName(child, nameTypes);
+        if (result) return result;
+      }
+    }
+    return null;
+  }
+
+  protected extractImportsFromTree(tree: any): string[] {
+    const imports: string[] = [];
+    const importTypes = this.grammar.importNodeTypes;
+    if (importTypes.length === 0) return imports;
+    this.collectNodesOfType(tree.rootNode, importTypes, imports);
+    return imports;
+  }
+
+  protected extractExportsFromTree(tree: any): string[] {
+    const exports: string[] = [];
+    const exportTypes = this.grammar.exportNodeTypes;
+    if (exportTypes.length === 0) return exports;
+    this.collectNodesOfType(tree.rootNode, exportTypes, exports);
+    return exports;
+  }
+
+  protected extractCommentsFromTree(tree: any): string[] {
+    const comments: string[] = [];
+    this.collectNodesOfType(tree.rootNode, ['comment', 'block_comment', 'line_comment'], comments);
+    return comments;
+  }
+
+  private collectNodesOfType(node: any, types: string[], results: string[]) {
+    if (types.includes(node.type)) {
+      results.push(node.text || '');
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.collectNodesOfType(child, types, results);
+    }
+  }
+}

package/src/language/generic.ts

@@ -0,0 +1,58 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from './types.js';
+
+const BINARY_EXTS = new Set([
+  '.exe', '.dll', '.so', '.dylib', '.bin', '.wasm',
+  '.o', '.a', '.lib', '.pyc', '.class', '.jar', '.war',
+  '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.webp', '.bmp', '.tiff',
+  '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+  '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar',
+  '.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv',
+  '.mp3', '.wav', '.flac', '.ogg',
+]);
+
+export class GenericAdapter implements LanguageAdapter {
+  languageName(): string { return 'Generic'; }
+  fileExtensions(): string[] { return []; }
+  fileNames(): string[] { return []; }
+
+  canParse(filePath: string): boolean {
+    const ext = '.' + filePath.split('.').pop()?.toLowerCase();
+    return !BINARY_EXTS.has(ext);
+  }
+
+  supportsSymbols(): boolean { return false; }
+
+  async parse(content: string, filePath: string): Promise<ParseResult> {
+    const lines = content.split('\n');
+    const paragraphs = content.split(/\n\s*\n/).filter(p => p.trim().length > 0);
+    const symbols: CodeSymbol[] = [];
+
+    for (let i = 0; i < Math.min(paragraphs.length, 100); i++) {
+      const plines = paragraphs[i].split('\n');
+      const firstLine = plines[0].trim().substring(0, 80);
+      const startLine = this.lineOf(content, paragraphs[i]);
+      const endLine = startLine + plines.length - 1;
+
+      symbols.push({
+        id: `${filePath}:${startLine}`,
+        name: firstLine || `paragraph_${i}`,
+        type: SymbolType.Module,
+        language: 'generic',
+        file: filePath,
+        startLine,
+        endLine,
+        parent: null,
+        children: [],
+        metadata: { size: paragraphs[i].length },
+      });
+    }
+
+    return { symbols, imports: [], exports: [], comments: [] };
+  }
+
+  private lineOf(content: string, substring: string): number {
+    const idx = content.indexOf(substring);
+    if (idx < 0) return 1;
+    return content.substring(0, idx).split('\n').length;
+  }
+}