edhindex 1.0.3 → 2.0.0

package/src/language/adapters/terraform.ts

@@ -0,0 +1,25 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'hcl',
+  wasmPath: new URL('../../node_modules/@tree-sitter-grammars/tree-sitter-hcl/tree-sitter-hcl.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    block: '(block (identifier) @name)',
+    attribute: '(attribute (identifier) @name)',
+  },
+  typeMap: {
+    block: SymbolType.Module,
+    attribute: SymbolType.Property,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class TerraformAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Terraform'; }
+  fileExtensions(): string[] { return ['.tf', '.tfvars']; }
+}

package/src/language/adapters/text.ts

@@ -0,0 +1,195 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class TextAdapter implements LanguageAdapter {
+  languageName(): string { return 'Text'; }
+  fileExtensions(): string[] { return ['.txt', '.log']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith('.txt') || lower.endsWith('.log');
+  }
+  supportsSymbols(): boolean { return true; }
+
+  async parse(content: string, filePath: string): Promise<ParseResult> {
+    const lines = content.split('\n');
+    const symbols: CodeSymbol[] = [];
+    const imports: string[] = [];
+    const exports: string[] = [];
+    const comments: string[] = [];
+
+    if (filePath.endsWith('.log')) {
+      this.extractLogEntries(lines, symbols, filePath);
+    } else {
+      this.extractTextSections(lines, symbols, filePath);
+    }
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractLogEntries(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const logPatterns = [
+      { regex: /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/i, type: SymbolType.Function },
+      { regex: /^\[?\d{4}-\d{2}-\d{2}\]?/i, type: SymbolType.Function },
+      { regex: /^(ERROR|WARN|INFO|DEBUG|FATAL)/i, type: SymbolType.Function },
+      { regex: /^Exception|Error|Warning/i, type: SymbolType.Function },
+    ];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (!line) continue;
+
+      for (const pattern of logPatterns) {
+        if (pattern.regex.test(line)) {
+          symbols.push({
+            id: `${filePath}:${i + 1}`,
+            name: line.substring(0, 50),
+            type: pattern.type,
+            language: 'log',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: { fullLine: line },
+          });
+          break;
+        }
+      }
+
+      // Extract stack traces
+      if (line.includes('at ') && line.includes('(') && line.includes(')')) {
+        symbols.push({
+          id: `${filePath}:${i + 1}:stack`,
+          name: 'stackTrace',
+          type: SymbolType.Function,
+          language: 'log',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: { trace: line },
+        });
+      }
+    }
+  }
+
+  private extractTextSections(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    let currentSection: string | null = null;
+    let currentSectionId: string | null = null;
+    let sectionStart = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Detect section headers (lines that are all uppercase, or followed by underline)
+      const isHeader = this.isSectionHeader(line, lines[i + 1]);
+      
+      if (isHeader && line.length > 0) {
+        // Save previous section
+        if (currentSection) {
+          symbols.push({
+            id: currentSectionId!,
+            name: currentSection,
+            type: SymbolType.Section,
+            language: 'text',
+            file: filePath,
+            startLine: sectionStart,
+            endLine: i,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        }
+
+        // Start new section
+        currentSection = line;
+        currentSectionId = `${filePath}:${i + 1}`;
+        sectionStart = i + 1;
+      }
+    }
+
+    // Save last section
+    if (currentSection) {
+      symbols.push({
+        id: currentSectionId!,
+        name: currentSection,
+        type: SymbolType.Section,
+        language: 'text',
+        file: filePath,
+        startLine: sectionStart,
+        endLine: lines.length,
+        parent: null,
+        children: [],
+        metadata: {},
+      });
+    }
+
+    // If no sections found, create paragraph-based symbols
+    if (symbols.length === 0) {
+      this.extractParagraphs(lines, symbols, filePath);
+    }
+  }
+
+  private isSectionHeader(line: string, nextLine: string | undefined): boolean {
+    if (!line || line.length < 3) return false;
+    
+    // Check if line is all uppercase
+    if (line === line.toUpperCase() && /[A-Z]/.test(line)) return true;
+    
+    // Check if next line is underline (=== or ---)
+    if (nextLine) {
+      const underline = nextLine.trim();
+      if (/^[=-]{3,}$/.test(underline)) return true;
+    }
+    
+    return false;
+  }
+
+  private extractParagraphs(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    let paragraphStart = 0;
+    let paragraphText = '';
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line === '') {
+        if (paragraphText.length > 0) {
+          symbols.push({
+            id: `${filePath}:${paragraphStart + 1}`,
+            name: paragraphText.substring(0, 50),
+            type: SymbolType.Section,
+            language: 'text',
+            file: filePath,
+            startLine: paragraphStart + 1,
+            endLine: i,
+            parent: null,
+            children: [],
+            metadata: { size: paragraphText.length },
+          });
+          paragraphText = '';
+        }
+        paragraphStart = i + 1;
+      } else {
+        paragraphText += (paragraphText ? ' ' : '') + line;
+      }
+    }
+
+    // Handle last paragraph
+    if (paragraphText.length > 0) {
+      symbols.push({
+        id: `${filePath}:${paragraphStart + 1}`,
+        name: paragraphText.substring(0, 50),
+        type: SymbolType.Section,
+        language: 'text',
+        file: filePath,
+        startLine: paragraphStart + 1,
+        endLine: lines.length,
+        parent: null,
+        children: [],
+        metadata: { size: paragraphText.length },
+      });
+    }
+  }
+}

package/src/language/adapters/toml.ts

@@ -0,0 +1,82 @@
+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: 'toml',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-toml.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['bare_key', 'string'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class TomlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'TOML'; }
+  fileExtensions(): string[] { return ['.toml']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkToml(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  private walkToml(node: any, symbols: CodeSymbol[], filePath: string, parentId: string) {
+    if (node.type === 'table' || node.type === 'table_array_element') {
+      const key = this.extractTomlKey(node);
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Section, language: 'toml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        parentId = id;
+      }
+    } else if (node.type === 'pair') {
+      const key = this.extractPairKey(node);
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Property, language: 'toml',
+          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) this.walkToml(child, symbols, filePath, parentId);
+    }
+  }
+
+  private extractTomlKey(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'bare_key' || child.type === 'string') {
+        return child.text?.replace(/"/g, '') || null;
+      }
+      if (child.type === 'dotted_key') {
+        return child.text || null;
+      }
+    }
+    return null;
+  }
+
+  private extractPairKey(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'bare_key' || child.type === 'string') {
+        return child.text?.replace(/"/g, '') || null;
+      }
+    }
+    return null;
+  }
+}

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/adapters/vue.ts

@@ -0,0 +1,70 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'vue',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-vue.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['tag_name', 'attribute_name', 'directive_attribute'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class VueAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Vue'; }
+  fileExtensions(): string[] { return ['.vue']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkVue(tree.rootNode, symbols, filePath);
+    return symbols;
+  }
+
+  private walkVue(node: any, symbols: CodeSymbol[], filePath: string) {
+    // Extract top-level sections: <template>, <script>, <style>
+    if (node.type === 'element') {
+      const tagName = this.extractTagName(node);
+      if (tagName && ['template', 'script', 'style'].includes(tagName.toLowerCase())) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: tagName, type: SymbolType.Section, language: 'vue',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: null, children: [], metadata: {},
+        });
+      }
+      
+      // Extract custom components (PascalCase or kebab-case with -)
+      if (tagName && (tagName[0] === tagName[0].toUpperCase() || tagName.includes('-'))) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: tagName, type: SymbolType.Class, language: 'vue',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: null, children: [], metadata: {},
+        });
+      }
+    }
+    
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkVue(child, symbols, filePath);
+    }
+  }
+
+  private extractTagName(node: any): string | null {
+    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 === 'self_closing_tag') {
+        for (let j = 0; j < child.childCount; j++) {
+          const grandchild = child.child(j);
+          if (grandchild && grandchild.type === 'tag_name') return grandchild.text;
+        }
+      }
+    }
+    return null;
+  }
+}

package/src/language/adapters/xml.ts

@@ -0,0 +1,74 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'xml',
+  wasmPath: new URL('../../node_modules/@tree-sitter-grammars/tree-sitter-xml/tree-sitter-xml.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['tag_name', 'attribute_name'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class XmlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'XML'; }
+  fileExtensions(): string[] { return ['.xml']; }
+
+  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, parentId: string) {
+    if (node.type === 'element') {
+      const tagName = this.extractTagName(node);
+      if (tagName) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        const symbolType = this.getSymbolType(tagName);
+        
+        symbols.push({
+          id, name: tagName, type: symbolType, language: 'xml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        
+        // Recurse into child elements
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child) this.collectElements(child, symbols, filePath, id);
+        }
+        return;
+      }
+    }
+    
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.collectElements(child, symbols, filePath, parentId);
+    }
+  }
+
+  private extractTagName(node: any): string | null {
+    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 === 'self_closing_tag') {
+        for (let j = 0; j < child.childCount; j++) {
+          const grandchild = child.child(j);
+          if (grandchild && grandchild.type === 'tag_name') return grandchild.text;
+        }
+      }
+    }
+    return null;
+  }
+
+  private getSymbolType(tagName: string): SymbolType {
+    const significant = ['configuration', 'settings', 'properties', 'beans', 'component', 'module', 'project'];
+    if (significant.includes(tagName.toLowerCase())) return SymbolType.Module;
+    return SymbolType.Property;
+  }
+}

package/src/language/adapters/yaml.ts

@@ -0,0 +1,63 @@
+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: 'yaml',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-yaml.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['string_scalar', 'plain_scalar'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class YamlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'YAML'; }
+  fileExtensions(): string[] { return ['.yaml', '.yml']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkYaml(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  private walkYaml(node: any, symbols: CodeSymbol[], filePath: string, parentId: string) {
+    if (node.type === 'block_mapping_pair' || node.type === 'flow_pair') {
+      const key = this.extractYamlKey(node);
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Property, language: 'yaml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        // Recurse into nested mappings
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && (child.type === 'block_mapping' || child.type === 'flow_mapping')) {
+            this.walkYaml(child, symbols, filePath, id);
+          }
+        }
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkYaml(child, symbols, filePath, parentId);
+    }
+  }
+
+  private extractYamlKey(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'string_scalar' || child.type === 'plain_scalar') {
+        return child.text || null;
+      }
+    }
+    return null;
+  }
+}