edhindex 1.1.0 → 2.0.0

package/dist/watcher/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/watcher/index.ts"],"names":[],"mappings":"AAIA,KAAK,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzD,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,UAAU,CAAS;gBAEf,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,SAAM;IAMjE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB5B,OAAO,CAAC,WAAW;IAwBb,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAU5B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/watcher/index.ts"],"names":[],"mappings":"AAIA,KAAK,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzD,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,UAAU,CAAS;IAE3B,YAAY,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,SAAM,EAItE;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAoB3B;IAED,OAAO,CAAC,WAAW;IAwBb,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1B;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edhindex",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Local-first hybrid code search engine with knowledge graph — BM25 + vector + rerank, tree-sitter parsing, MCP server",
   "keywords": [
     "code-search",
@@ -47,9 +47,17 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "@derekstride/tree-sitter-sql": "^0.3.11",
     "@huggingface/transformers": "^4.2.0",
     "@lancedb/lancedb": "^0.31.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@tree-sitter-grammars/tree-sitter-hcl": "^1.2.0",
+    "@tree-sitter-grammars/tree-sitter-markdown": "^0.3.2",
+    "@tree-sitter-grammars/tree-sitter-svelte": "^1.0.2",
+    "@tree-sitter-grammars/tree-sitter-toml": "^0.7.0",
+    "@tree-sitter-grammars/tree-sitter-xml": "^0.7.0",
+    "@tree-sitter-grammars/tree-sitter-yaml": "^0.7.1",
+    "apache-arrow": "^21.1.0",
     "better-sqlite3": "^12.11.1",
     "chalk": "^5.6.2",
     "chokidar": "^5.0.0",
@@ -61,25 +69,69 @@
     "tree-sitter-cpp": "^0.23.4",
     "tree-sitter-css": "^0.25.0",
     "tree-sitter-dart": "^1.0.0",
+    "tree-sitter-dockerfile": "^0.0.1-security",
     "tree-sitter-go": "^0.25.0",
     "tree-sitter-haskell": "^0.23.1",
     "tree-sitter-html": "^0.23.2",
     "tree-sitter-java": "^0.23.5",
     "tree-sitter-json": "^0.24.8",
+    "tree-sitter-kotlin": "^0.3.8",
+    "tree-sitter-lua": "^2.1.3",
     "tree-sitter-php": "^0.24.2",
     "tree-sitter-python": "^0.25.0",
     "tree-sitter-ruby": "^0.23.1",
     "tree-sitter-rust": "^0.24.0",
     "tree-sitter-scala": "^0.24.0",
     "tree-sitter-solidity": "^1.2.13",
+    "tree-sitter-sql": "^0.1.0",
+    "tree-sitter-swift": "^0.7.1",
     "tree-sitter-typescript": "^0.23.2",
+    "tree-sitter-vue": "^0.2.1",
+    "tree-sitter-wasm-prebuilt": "^0.0.3",
+    "tree-sitter-wasms": "^0.1.13",
     "web-tree-sitter": "^0.26.11"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/cli-progress": "^3.11.6",
     "@types/node": "^22.13.0",
-    "typescript": "^5.7.0",
+    "typescript": "^5.9.3",
     "vitest": "^4.1.10"
+  },
+  "allowScripts": {
+    "@derekstride/tree-sitter-sql@0.3.11": true,
+    "onnxruntime-node@1.19.2": true,
+    "onnxruntime-node@1.24.3": true,
+    "sharp@0.33.5": true,
+    "sharp@0.34.5": true,
+    "@tree-sitter-grammars/tree-sitter-markdown@0.3.2": true,
+    "@tree-sitter-grammars/tree-sitter-toml@0.7.0": true,
+    "@tree-sitter-grammars/tree-sitter-yaml@0.7.1": true,
+    "better-sqlite3@12.11.1": true,
+    "protobufjs@7.6.5": true,
+    "tree-sitter-c@0.24.1": true,
+    "tree-sitter-c@0.23.6": true,
+    "tree-sitter-c-sharp@0.23.5": true,
+    "tree-sitter-cli@0.23.2": true,
+    "tree-sitter-cpp@0.23.4": true,
+    "tree-sitter-css@0.25.0": true,
+    "tree-sitter-dart@1.0.0": true,
+    "tree-sitter-go@0.25.0": true,
+    "tree-sitter-haskell@0.23.1": true,
+    "tree-sitter-html@0.23.2": true,
+    "tree-sitter-java@0.23.5": true,
+    "tree-sitter-javascript@0.23.1": true,
+    "tree-sitter-json@0.24.8": true,
+    "tree-sitter-kotlin@0.3.8": true,
+    "tree-sitter-lua@2.1.3": true,
+    "tree-sitter-php@0.24.2": true,
+    "tree-sitter-python@0.25.0": true,
+    "tree-sitter-ruby@0.23.1": true,
+    "tree-sitter-rust@0.24.0": true,
+    "tree-sitter-scala@0.24.0": true,
+    "tree-sitter-solidity@1.2.13": true,
+    "tree-sitter-swift@0.7.1": true,
+    "tree-sitter-typescript@0.23.2": true,
+    "yarn@1.22.22": true
   }
 }

package/src/cli/index.ts

@@ -19,7 +19,7 @@ const program = new Command();
 program
   .name('edhindex')
   .description('Local-first hybrid code search engine with MCP')
-  .version('1.0.0')
+  .version('2.0.0')
   .option('-v, --verbose', 'Enable verbose logging')
   .option('--debug', 'Enable debug logging')
   .hook('preAction', (thisCommand) => {

package/src/graph/builder.ts

@@ -226,6 +226,19 @@ export class GraphBuilder {
       case 'property': return 'variable';
       case 'module': return 'module';
       case 'namespace': return 'module';
+      case 'package': return 'package';
+      case 'constructor': return 'constructor';
+      case 'extension': return 'extension';
+      case 'field': return 'field';
+      case 'type_alias': return 'type_alias';
+      case 'document': return 'document';
+      case 'section': return 'section';
+      case 'table': return 'table';
+      case 'selector': return 'selector';
+      case 'rule': return 'rule';
+      case 'actor': return 'actor';
+      case 'object': return 'object';
+      case 'protocol': return 'protocol';
       default: return 'module';
     }
   }

package/src/graph/types.ts

@@ -10,7 +10,20 @@ export type NodeType =
   | 'method'
   | 'variable'
   | 'import'
-  | 'export';
+  | 'export'
+  | 'package'
+  | 'constructor'
+  | 'extension'
+  | 'field'
+  | 'type_alias'
+  | 'document'
+  | 'section'
+  | 'table'
+  | 'selector'
+  | 'rule'
+  | 'actor'
+  | 'object'
+  | 'protocol';
 
 export type EdgeType =
   | 'contains'

package/src/language/adapters/astro.ts

@@ -0,0 +1,206 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class AstroAdapter implements LanguageAdapter {
+  languageName(): string { return 'Astro'; }
+  fileExtensions(): string[] { return ['.astro']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    return filePath.toLowerCase().endsWith('.astro');
+  }
+  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.extractAstroComponents(lines, symbols, imports, filePath);
+    this.extractComments(lines, comments);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractAstroComponents(lines: string[], symbols: CodeSymbol[], imports: string[], filePath: string) {
+    // Astro files have three sections: frontmatter (---), template, and style
+    let inFrontmatter = false;
+    let frontmatterStart = 0;
+    let currentSection: string | null = null;
+    let currentSectionId: string | null = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // Frontmatter boundaries
+      if (line === '---') {
+        if (!inFrontmatter) {
+          inFrontmatter = true;
+          frontmatterStart = i;
+          currentSectionId = `${filePath}:${i + 1}`;
+          symbols.push({
+            id: currentSectionId,
+            name: 'frontmatter',
+            type: SymbolType.Section,
+            language: 'astro',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        } else {
+          inFrontmatter = false;
+          if (currentSectionId) {
+            // Update end line for frontmatter
+            const idx = symbols.findIndex(s => s.id === currentSectionId);
+            if (idx >= 0) {
+              symbols[idx].endLine = i + 1;
+            }
+          }
+        }
+        continue;
+      }
+
+      // Extract imports in frontmatter
+      if (inFrontmatter) {
+        const importMatch = line.match(/^import\s+(.+?)\s+from\s+['"](.+?)['"]/);
+        if (importMatch) {
+          imports.push(line);
+          symbols.push({
+            id: `${filePath}:${i + 1}`,
+            name: importMatch[1],
+            type: SymbolType.Import,
+            language: 'astro',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: currentSectionId,
+            children: [],
+            metadata: { source: importMatch[2] },
+          });
+        }
+
+        // Extract variable declarations
+        const varMatch = line.match(/^(?:const|let|var)\s+(\w+)/);
+        if (varMatch) {
+          symbols.push({
+            id: `${filePath}:${i + 1}`,
+            name: varMatch[1],
+            type: SymbolType.Variable,
+            language: 'astro',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: currentSectionId,
+            children: [],
+            metadata: {},
+          });
+        }
+      }
+
+      // Extract Astro components in template
+      if (!inFrontmatter) {
+        const componentMatch = line.match(/<(\w+[-\w]*)/);
+        if (componentMatch) {
+          const componentName = componentMatch[1];
+          // Astro components are PascalCase or kebab-case
+          if (componentName[0] === componentName[0].toUpperCase() || componentName.includes('-')) {
+            symbols.push({
+              id: `${filePath}:${i + 1}`,
+              name: componentName,
+              type: SymbolType.Class,
+              language: 'astro',
+              file: filePath,
+              startLine: i + 1,
+              endLine: i + 1,
+              parent: null,
+              children: [],
+              metadata: {},
+            });
+          }
+        }
+
+        // Extract style blocks
+        if (line.includes('<style')) {
+          currentSectionId = `${filePath}:${i + 1}`;
+          symbols.push({
+            id: currentSectionId,
+            name: 'style',
+            type: SymbolType.Section,
+            language: 'astro',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        }
+
+        // Extract script blocks
+        if (line.includes('<script')) {
+          currentSectionId = `${filePath}:${i + 1}`;
+          symbols.push({
+            id: currentSectionId,
+            name: 'script',
+            type: SymbolType.Section,
+            language: 'astro',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        }
+      }
+    }
+  }
+
+  private extractComments(lines: string[], comments: string[]) {
+    let inBlockComment = false;
+    let blockComment = '';
+
+    for (const line of lines) {
+      if (inBlockComment) {
+        const endIdx = line.indexOf('*/');
+        if (endIdx >= 0) {
+          blockComment += line.substring(0, endIdx + 2);
+          comments.push(blockComment.trim());
+          blockComment = '';
+          inBlockComment = false;
+        } else {
+          blockComment += line + '\n';
+        }
+      } else {
+        const startIdx = line.indexOf('/*');
+        if (startIdx >= 0) {
+          const endIdx = line.indexOf('*/', startIdx + 2);
+          if (endIdx >= 0) {
+            comments.push(line.substring(startIdx, endIdx + 2).trim());
+          } else {
+            blockComment = line.substring(startIdx) + '\n';
+            inBlockComment = true;
+          }
+        }
+
+        // Single-line comments
+        const lineCommentIdx = line.indexOf('//');
+        if (lineCommentIdx >= 0) {
+          comments.push(line.substring(lineCommentIdx).trim());
+        }
+
+        // HTML comments
+        const htmlCommentIdx = line.indexOf('<!--');
+        if (htmlCommentIdx >= 0) {
+          const endIdx = line.indexOf('-->', htmlCommentIdx + 4);
+          if (endIdx >= 0) {
+            comments.push(line.substring(htmlCommentIdx, endIdx + 3).trim());
+          }
+        }
+      }
+    }
+  }
+}

package/src/language/adapters/config.ts

@@ -0,0 +1,144 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class ConfigAdapter implements LanguageAdapter {
+  languageName(): string { return 'Config'; }
+  fileExtensions(): string[] { return ['.ini', '.properties', '.env', '.conf', '.cfg']; }
+  fileNames(): string[] { return ['.gitignore', '.editorconfig']; }
+  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.endsWith('/' + name) || lower === name || lower.endsWith(name)) return true;
+    }
+    return false;
+  }
+  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('.ini') || filePath.endsWith('.conf') || filePath.endsWith('.cfg') || filePath.endsWith('.editorconfig')) {
+      this.extractIniStyle(lines, symbols, filePath);
+    } else if (filePath.endsWith('.properties') || filePath.endsWith('.env')) {
+      this.extractKeyValue(lines, symbols, filePath);
+    } else if (filePath.endsWith('.gitignore')) {
+      this.extractGitignore(lines, symbols, filePath);
+    } else {
+      this.extractKeyValue(lines, symbols, filePath);
+    }
+
+    this.extractComments(lines, comments);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractIniStyle(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].trim();
+      
+      // Section headers: [section]
+      const sectionMatch = line.match(/^\[(.+)\]$/);
+      if (sectionMatch) {
+        currentSection = sectionMatch[1];
+        currentSectionId = `${filePath}:${i + 1}`;
+        symbols.push({
+          id: currentSectionId,
+          name: currentSection,
+          type: SymbolType.Section,
+          language: 'config',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: {},
+        });
+        continue;
+      }
+
+      // Key-value pairs
+      const kvMatch = line.match(/^([^#=]+?)\s*=\s*(.+)$/);
+      if (kvMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: kvMatch[1].trim(),
+          type: SymbolType.Property,
+          language: 'config',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: currentSectionId,
+          children: [],
+          metadata: { value: kvMatch[2].trim() },
+        });
+      }
+    }
+  }
+
+  private extractKeyValue(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Skip empty lines and comments
+      if (!line || line.startsWith('#') || line.startsWith('!')) continue;
+
+      // Key-value pairs
+      const kvMatch = line.match(/^([^=]+?)\s*=\s*(.+)$/);
+      if (kvMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: kvMatch[1].trim(),
+          type: SymbolType.Property,
+          language: 'config',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: { value: kvMatch[2].trim() },
+        });
+      }
+    }
+  }
+
+  private extractGitignore(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Skip empty lines and comments
+      if (!line || line.startsWith('#')) continue;
+
+      // Treat each pattern as a property
+      symbols.push({
+        id: `${filePath}:${i + 1}`,
+        name: line,
+        type: SymbolType.Property,
+        language: 'config',
+        file: filePath,
+        startLine: i + 1,
+        endLine: i + 1,
+        parent: null,
+        children: [],
+        metadata: {},
+      });
+    }
+  }
+
+  private extractComments(lines: string[], comments: string[]) {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('#') || trimmed.startsWith(';') || trimmed.startsWith('!')) {
+        comments.push(trimmed);
+      }
+    }
+  }
+}

package/src/language/adapters/csv.ts

@@ -0,0 +1,110 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class CsvAdapter implements LanguageAdapter {
+  languageName(): string { return 'CSV'; }
+  fileExtensions(): string[] { return ['.csv']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    return filePath.toLowerCase().endsWith('.csv');
+  }
+  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 (lines.length > 0) {
+      // Extract header row as column definitions
+      const headers = this.parseCSVLine(lines[0]);
+      if (headers.length > 0) {
+        symbols.push({
+          id: `${filePath}:1`,
+          name: 'headers',
+          type: SymbolType.Module,
+          language: 'csv',
+          file: filePath,
+          startLine: 1,
+          endLine: 1,
+          parent: null,
+          children: [],
+          metadata: { columns: headers, columnCount: headers.length },
+        });
+
+        // Extract each column as a property
+        headers.forEach((header, index) => {
+          if (header.trim()) {
+            symbols.push({
+              id: `${filePath}:1:${index}`,
+              name: header.trim(),
+              type: SymbolType.Property,
+              language: 'csv',
+              file: filePath,
+              startLine: 1,
+              endLine: 1,
+              parent: `${filePath}:1`,
+              children: [],
+              metadata: { columnIndex: index },
+            });
+          }
+        });
+      }
+
+      // Extract data summary
+      const dataLines = lines.length - 1;
+      if (dataLines > 0) {
+        symbols.push({
+          id: `${filePath}:data`,
+          name: 'data',
+          type: SymbolType.Table,
+          language: 'csv',
+          file: filePath,
+          startLine: 2,
+          endLine: lines.length,
+          parent: null,
+          children: [],
+          metadata: { rowCount: dataLines, columnCount: headers.length },
+        });
+      }
+
+      // Extract comments (lines starting with #)
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('#')) {
+          comments.push(line);
+        }
+      }
+    }
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private parseCSVLine(line: string): string[] {
+    const result: string[] = [];
+    let current = '';
+    let inQuotes = false;
+
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+
+      if (char === '"') {
+        if (inQuotes && i + 1 < line.length && line[i + 1] === '"') {
+          current += '"';
+          i++; // Skip next quote
+        } else {
+          inQuotes = !inQuotes;
+        }
+      } else if (char === ',' && !inQuotes) {
+        result.push(current);
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+
+    result.push(current);
+    return result;
+  }
+}

package/src/language/adapters/dart.ts

@@ -0,0 +1,39 @@
+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: 'dart',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-dart.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    class_declaration: '(class_declaration name: (identifier) @name)',
+    mixin_declaration: '(mixin_declaration name: (identifier) @name)',
+    extension_declaration: '(extension_declaration name: (identifier) @name)',
+    enum_declaration: '(enum_declaration name: (identifier) @name)',
+    function_declaration: '(function_signature name: (identifier) @name)',
+    method_declaration: '(method_signature name: (identifier) @name)',
+  },
+  typeMap: {
+    class_declaration: SymbolType.Class,
+    mixin_declaration: SymbolType.Extension,
+    extension_declaration: SymbolType.Extension,
+    enum_declaration: SymbolType.Enum,
+    typedef_declaration: SymbolType.TypeAlias,
+    function_declaration: SymbolType.Function,
+    method_declaration: SymbolType.Method,
+    constructor_declaration: SymbolType.Constructor,
+    variable_declaration: SymbolType.Variable,
+    import_or_export: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['import_or_export'],
+  exportNodeTypes: [],
+};
+
+export class DartAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Dart'; }
+  fileExtensions(): string[] { return ['.dart']; }
+}