edhindex 1.0.3 → 2.0.0

package/src/language/adapters/go.ts

@@ -0,0 +1,28 @@
+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: 'go',
+  wasmPath: require.resolve('tree-sitter-go/tree-sitter-go.wasm'),
+  queryPatterns: {
+    function_declaration: '(function_declaration name: (identifier) @name)',
+    method_declaration: '(method_declaration name: (field_identifier) @name)',
+  },
+  typeMap: {
+    function_declaration: SymbolType.Function,
+    method_declaration: SymbolType.Method,
+    import_declaration: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier', 'field_identifier'],
+  importNodeTypes: ['import_declaration', 'import_spec'],
+  exportNodeTypes: [],
+};
+
+export class GoAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Go'; }
+  fileExtensions(): string[] { return ['.go']; }
+}

package/src/language/adapters/haskell.ts

@@ -0,0 +1,35 @@
+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: 'haskell',
+  wasmPath: new URL('../../node_modules/tree-sitter-haskell/tree-sitter-haskell.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    data_declaration: '(data_declaration name: (type) @name)',
+    type_declaration: '(type_declaration name: (type) @name)',
+    class_declaration: '(class_declaration name: (type) @name)',
+    instance_declaration: '(instance_declaration type: (type) @name)',
+    function_declaration: '(function name: (variable) @name)',
+  },
+  typeMap: {
+    data_declaration: SymbolType.Struct,
+    type_declaration: SymbolType.TypeAlias,
+    class_declaration: SymbolType.Interface,
+    instance_declaration: SymbolType.Object,
+    function_declaration: SymbolType.Function,
+    import_declaration: SymbolType.Import,
+    module_declaration: SymbolType.Module,
+  },
+  nameNodeTypes: ['variable', 'type'],
+  importNodeTypes: ['import_declaration'],
+  exportNodeTypes: [],
+};
+
+export class HaskellAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Haskell'; }
+  fileExtensions(): string[] { return ['.hs', '.lhs']; }
+}

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-variants.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 JsonVariantsAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'JSON'; }
+  fileExtensions(): string[] { return ['.jsonc', '.json5']; }
+  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/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/kotlin.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: 'kotlin',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-kotlin.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    class_declaration: '(class_declaration name: (simple_identifier) @name)',
+    interface_declaration: '(class_declaration "data" name: (simple_identifier) @name)',
+    object_declaration: '(object_declaration name: (simple_identifier) @name)',
+    enum_declaration: '(enum_declaration name: (simple_identifier) @name)',
+    function_declaration: '(function_declaration name: (simple_identifier) @name)',
+    property_declaration: '(property_declaration name: (simple_identifier) @name)',
+  },
+  typeMap: {
+    class_declaration: SymbolType.Class,
+    interface_declaration: SymbolType.Interface,
+    object_declaration: SymbolType.Object,
+    enum_declaration: SymbolType.Enum,
+    function_declaration: SymbolType.Function,
+    property_declaration: SymbolType.Property,
+    import_declaration: SymbolType.Import,
+    package_declaration: SymbolType.Package,
+  },
+  nameNodeTypes: ['simple_identifier'],
+  importNodeTypes: ['import_declaration'],
+  exportNodeTypes: [],
+};
+
+export class KotlinAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Kotlin'; }
+  fileExtensions(): string[] { return ['.kt', '.kts']; }
+}

package/src/language/adapters/lua.ts

@@ -0,0 +1,34 @@
+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: 'lua',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-lua.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    function_declaration: '(function_declaration name: (identifier) @name)',
+    local_function_declaration: '(local_function_declaration name: (identifier) @name)',
+    method_definition: '(method_definition name: (identifier) @name)',
+    variable_declaration: '(variable_declaration name: (identifier) @name)',
+  },
+  typeMap: {
+    function_declaration: SymbolType.Function,
+    local_function_declaration: SymbolType.Function,
+    method_definition: SymbolType.Method,
+    variable_declaration: SymbolType.Variable,
+    local_variable_declaration: SymbolType.Variable,
+    table_constructor: SymbolType.Struct,
+    require_statement: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['require_statement'],
+  exportNodeTypes: [],
+};
+
+export class LuaAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Lua'; }
+  fileExtensions(): string[] { return ['.lua']; }
+}

package/src/language/adapters/markdown.ts

@@ -0,0 +1,81 @@
+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: 'markdown',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasm-prebuilt/lib/tree-sitter-markdown.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['inline'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class MarkdownAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Markdown'; }
+  fileExtensions(): string[] { return ['.md', '.markdown']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkMarkdown(tree.rootNode, symbols, filePath);
+    return symbols;
+  }
+
+  private walkMarkdown(node: any, symbols: CodeSymbol[], filePath: string) {
+    if (node.type.startsWith('atx_heading') || node.type.startsWith('setext_heading')) {
+      const level = parseInt(node.type.match(/\d/)?.[0] || '1');
+      const text = this.extractHeadingText(node);
+      if (text) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: text, type: SymbolType.Section, language: 'markdown',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: null, children: [],
+          metadata: { level },
+        });
+      }
+    }
+    
+    if (node.type === 'fenced_code_block') {
+      const lang = this.extractCodeBlockLang(node);
+      const id = `${filePath}:${node.startPosition.row + 1}`;
+      symbols.push({
+        id, name: `code_block_${lang || 'unknown'}`, type: SymbolType.Module, language: 'markdown',
+        file: filePath, startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1, parent: null, children: [],
+        metadata: { language: lang },
+      });
+    }
+    
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkMarkdown(child, symbols, filePath);
+    }
+  }
+
+  private extractHeadingText(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'inline') {
+        return child.text?.trim() || null;
+      }
+    }
+    return null;
+  }
+
+  private extractCodeBlockLang(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'info_string') {
+        return child.text?.trim() || null;
+      }
+    }
+    return null;
+  }
+}

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']; }
+}