edhindex 1.1.0 → 2.0.0

package/src/language/adapters/dockerfile.ts

@@ -0,0 +1,78 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class DockerfileAdapter implements LanguageAdapter {
+  languageName(): string { return 'Dockerfile'; }
+  fileExtensions(): string[] { return []; }
+  fileNames(): string[] { return ['dockerfile', 'Dockerfile', 'dockerfile.dev', 'Dockerfile.dev', 'dockerfile.prod', 'Dockerfile.prod']; }
+  canParse(filePath: string): boolean {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith('dockerfile') || lower.includes('dockerfile.');
+  }
+  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[] = [];
+
+    this.extractDockerInstructions(lines, symbols, filePath);
+    this.extractComments(lines, comments);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractDockerInstructions(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const patterns = [
+      { regex: /^FROM\s+(.+)$/gi, type: SymbolType.Import, name: 'FROM' },
+      { regex: /^RUN\s+(.+)$/gi, type: SymbolType.Function, name: 'RUN' },
+      { regex: /^CMD\s+(.+)$/gi, type: SymbolType.Function, name: 'CMD' },
+      { regex: /^ENTRYPOINT\s+(.+)$/gi, type: SymbolType.Function, name: 'ENTRYPOINT' },
+      { regex: /^COPY\s+(.+)$/gi, type: SymbolType.Function, name: 'COPY' },
+      { regex: /^ADD\s+(.+)$/gi, type: SymbolType.Function, name: 'ADD' },
+      { regex: /^ENV\s+(\w+)/gi, type: SymbolType.Variable, name: 'ENV' },
+      { regex: /^EXPOSE\s+(\d+)/gi, type: SymbolType.Variable, name: 'EXPOSE' },
+      { regex: /^VOLUME\s+(.+)$/gi, type: SymbolType.Variable, name: 'VOLUME' },
+      { regex: /^WORKDIR\s+(.+)$/gi, type: SymbolType.Variable, name: 'WORKDIR' },
+      { regex: /^USER\s+(.+)$/gi, type: SymbolType.Variable, name: 'USER' },
+      { regex: /^LABEL\s+(\w+)/gi, type: SymbolType.Property, name: 'LABEL' },
+      { regex: /^ARG\s+(\w+)/gi, type: SymbolType.Variable, name: 'ARG' },
+      { regex: /^STOPSIGNAL\s+(.+)$/gi, type: SymbolType.Variable, name: 'STOPSIGNAL' },
+      { regex: /^HEALTHCHECK\s+(.+)$/gi, type: SymbolType.Function, name: 'HEALTHCHECK' },
+      { regex: /^SHELL\s+(.+)$/gi, type: SymbolType.Function, name: 'SHELL' },
+    ];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      for (const pattern of patterns) {
+        pattern.regex.lastIndex = 0;
+        const match = pattern.regex.exec(line);
+        if (match) {
+          symbols.push({
+            id: `${filePath}:${i + 1}`,
+            name: pattern.name,
+            type: pattern.type,
+            language: 'dockerfile',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: { instruction: match[1]?.trim() },
+          });
+        }
+      }
+    }
+  }
+
+  private extractComments(lines: string[], comments: string[]) {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('#')) {
+        comments.push(trimmed);
+      }
+    }
+  }
+}

package/src/language/adapters/documentation.ts

@@ -0,0 +1,158 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class DocumentationAdapter implements LanguageAdapter {
+  languageName(): string { return 'Documentation'; }
+  fileExtensions(): string[] { return ['.rst', '.adoc']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith('.rst') || lower.endsWith('.adoc');
+  }
+  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('.rst')) {
+      this.extractRST(lines, symbols, filePath);
+    } else if (filePath.endsWith('.adoc')) {
+      this.extractAsciiDoc(lines, symbols, filePath);
+    }
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractRST(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const headingChars = ['=', '-', '~', '^', '"', '#', '*', '+'];
+    let currentSection: string | null = null;
+    let currentSectionId: string | null = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check for RST headings (underline style)
+      if (i > 0 && trimmed.length > 0 && headingChars.includes(trimmed[0])) {
+        const prevLine = lines[i - 1].trim();
+        if (prevLine.length > 0 && trimmed.length >= prevLine.length) {
+          // This is a heading underline
+          const level = headingChars.indexOf(trimmed[0]);
+          currentSectionId = `${filePath}:${i}`;
+          symbols.push({
+            id: currentSectionId,
+            name: prevLine,
+            type: SymbolType.Section,
+            language: 'rst',
+            file: filePath,
+            startLine: i,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: { level },
+          });
+          continue;
+        }
+      }
+
+      // Check for RST directives
+      const directiveMatch = trimmed.match(/^\.\.\s+(\w+)::/);
+      if (directiveMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: directiveMatch[1],
+          type: SymbolType.Function,
+          language: 'rst',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: currentSectionId,
+          children: [],
+          metadata: {},
+        });
+      }
+
+      // Extract code blocks
+      if (trimmed === '.. code-block::' || trimmed.startsWith('.. code-block::')) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: 'code-block',
+          type: SymbolType.Module,
+          language: 'rst',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: currentSectionId,
+          children: [],
+          metadata: {},
+        });
+      }
+    }
+  }
+
+  private extractAsciiDoc(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    let currentSection: string | null = null;
+    let currentSectionId: string | null = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check for AsciiDoc headings
+      const headingMatch = trimmed.match(/^(={1,6})\s+(.+)$/);
+      if (headingMatch) {
+        const level = headingMatch[1].length;
+        currentSectionId = `${filePath}:${i + 1}`;
+        symbols.push({
+          id: currentSectionId,
+          name: headingMatch[2],
+          type: SymbolType.Section,
+          language: 'adoc',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: { level },
+        });
+        continue;
+      }
+
+      // Check for block attributes
+      const blockMatch = trimmed.match(/^\[(.+)\]$/);
+      if (blockMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: blockMatch[1],
+          type: SymbolType.Property,
+          language: 'adoc',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: currentSectionId,
+          children: [],
+          metadata: {},
+        });
+      }
+
+      // Extract code blocks
+      if (trimmed === '----' || trimmed === '....') {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: 'code-block',
+          type: SymbolType.Module,
+          language: 'adoc',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: currentSectionId,
+          children: [],
+          metadata: {},
+        });
+      }
+    }
+  }
+}

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/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/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;
+  }
+}