edhindex 1.0.3 → 2.0.0

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

package/src/language/registry.ts

@@ -0,0 +1,179 @@
+import { LanguageAdapter, AdapterInfo } from './types.js';
+import { TypeScriptAdapter } from './adapters/typescript.js';
+import { JavaScriptAdapter } from './adapters/javascript.js';
+import { PythonAdapter } from './adapters/python.js';
+import { GoAdapter } from './adapters/go.js';
+import { RustAdapter } from './adapters/rust.js';
+import { JavaAdapter } from './adapters/java.js';
+import { RubyAdapter } from './adapters/ruby.js';
+import { CAdapter } from './adapters/c.js';
+import { CppAdapter } from './adapters/cpp.js';
+import { CSharpAdapter } from './adapters/csharp.js';
+import { PhpAdapter } from './adapters/php.js';
+import { HtmlAdapter } from './adapters/html.js';
+import { CssAdapter } from './adapters/css.js';
+import { JsonAdapter } from './adapters/json.js';
+import { SwiftAdapter } from './adapters/swift.js';
+import { KotlinAdapter } from './adapters/kotlin.js';
+import { DartAdapter } from './adapters/dart.js';
+import { ScalaAdapter } from './adapters/scala.js';
+import { HaskellAdapter } from './adapters/haskell.js';
+import { SolidityAdapter } from './adapters/solidity.js';
+import { LuaAdapter } from './adapters/lua.js';
+import { YamlAdapter } from './adapters/yaml.js';
+import { TomlAdapter } from './adapters/toml.js';
+import { SqlAdapter } from './adapters/sql.js';
+import { MarkdownAdapter } from './adapters/markdown.js';
+import { XmlAdapter } from './adapters/xml.js';
+import { VueAdapter } from './adapters/vue.js';
+import { SvelteAdapter } from './adapters/svelte.js';
+import { TerraformAdapter } from './adapters/terraform.js';
+import { DockerfileAdapter } from './adapters/dockerfile.js';
+import { SalesforceAdapter } from './adapters/salesforce.js';
+import { CsvAdapter } from './adapters/csv.js';
+import { JsonVariantsAdapter } from './adapters/json-variants.js';
+import { ConfigAdapter } from './adapters/config.js';
+import { DocumentationAdapter } from './adapters/documentation.js';
+import { SvgAdapter } from './adapters/svg.js';
+import { TextAdapter } from './adapters/text.js';
+import { AstroAdapter } from './adapters/astro.js';
+import { GenericAdapter } from './generic.js';
+
+export type AdapterEntry = {
+  key: string;
+  adapter: LanguageAdapter;
+  tier: 1 | 2 | 3;
+};
+
+export class LanguageRegistry {
+  private adapters: AdapterEntry[] = [];
+  private extMap: Map<string, AdapterEntry> = new Map();
+  private nameMap: Map<string, AdapterEntry> = new Map();
+  private generic: GenericAdapter;
+
+  constructor() {
+    this.generic = new GenericAdapter();
+    this.registerDefaults();
+  }
+
+  private registerDefaults() {
+    // Tier 1: Full symbol extraction (programming languages)
+    this.register('ts', new TypeScriptAdapter(), 1);
+    this.register('js', new JavaScriptAdapter(), 1);
+    this.register('py', new PythonAdapter(), 1);
+    this.register('go', new GoAdapter(), 1);
+    this.register('rs', new RustAdapter(), 1);
+    this.register('java', new JavaAdapter(), 1);
+    this.register('rb', new RubyAdapter(), 1);
+    this.register('c', new CAdapter(), 1);
+    this.register('cpp', new CppAdapter(), 1);
+    this.register('csharp', new CSharpAdapter(), 1);
+    this.register('php', new PhpAdapter(), 1);
+    this.register('swift', new SwiftAdapter(), 1);
+    this.register('kotlin', new KotlinAdapter(), 1);
+    this.register('dart', new DartAdapter(), 1);
+    this.register('scala', new ScalaAdapter(), 1);
+    this.register('haskell', new HaskellAdapter(), 1);
+    this.register('solidity', new SolidityAdapter(), 1);
+    this.register('lua', new LuaAdapter(), 1);
+    
+    // Tier 2: Structural extraction (markup, config, data)
+    this.register('html', new HtmlAdapter(), 2);
+    this.register('css', new CssAdapter(), 2);
+    this.register('json', new JsonAdapter(), 2);
+    this.register('yaml', new YamlAdapter(), 2);
+    this.register('toml', new TomlAdapter(), 2);
+    this.register('sql', new SqlAdapter(), 2);
+    this.register('markdown', new MarkdownAdapter(), 2);
+    
+    // Tier 2: Additional markup and config languages
+    this.register('xml', new XmlAdapter(), 2);
+    this.register('vue', new VueAdapter(), 2);
+    this.register('svelte', new SvelteAdapter(), 2);
+    this.register('terraform', new TerraformAdapter(), 2);
+    this.register('dockerfile', new DockerfileAdapter(), 2);
+    this.register('salesforce', new SalesforceAdapter(), 2);
+    this.register('csv', new CsvAdapter(), 2);
+    this.register('json-variants', new JsonVariantsAdapter(), 2);
+    this.register('config', new ConfigAdapter(), 2);
+    this.register('documentation', new DocumentationAdapter(), 2);
+    this.register('svg', new SvgAdapter(), 2);
+    this.register('text', new TextAdapter(), 2);
+    this.register('astro', new AstroAdapter(), 2);
+  }
+
+  register(key: string, adapter: LanguageAdapter, tier: 1 | 2 | 3) {
+    const entry: AdapterEntry = { key, adapter, tier };
+    this.adapters.push(entry);
+    for (const ext of adapter.fileExtensions()) {
+      const lower = ext.toLowerCase();
+      if (!this.extMap.has(lower)) {
+        this.extMap.set(lower, entry);
+      }
+    }
+    for (const name of adapter.fileNames()) {
+      const lower = name.toLowerCase();
+      if (!this.nameMap.has(lower)) {
+        this.nameMap.set(lower, entry);
+      }
+    }
+  }
+
+  getAdapter(filePath: string): { adapter: LanguageAdapter; key: string } {
+    const lower = filePath.toLowerCase();
+    const fileName = lower.split('/').pop() || lower;
+
+    const nameEntry = this.nameMap.get(fileName);
+    if (nameEntry) return { adapter: nameEntry.adapter, key: nameEntry.key };
+
+    for (const [ext, entry] of this.extMap) {
+      if (lower.endsWith(ext)) return { adapter: entry.adapter, key: entry.key };
+    }
+
+    return { adapter: this.generic, key: 'generic' };
+  }
+
+  getAdapterByKey(key: string): { adapter: LanguageAdapter; key: string } | null {
+    const entry = this.adapters.find(a => a.key === key);
+    if (!entry) return null;
+    return { adapter: entry.adapter, key: entry.key };
+  }
+
+  getAllAdapters(): AdapterEntry[] {
+    return [...this.adapters];
+  }
+
+  getInfoList(): AdapterInfo[] {
+    return this.adapters.map(a => ({
+      key: a.key,
+      name: a.adapter.languageName(),
+      extensions: a.adapter.fileExtensions(),
+      tier: a.tier,
+      supportsSymbols: a.adapter.supportsSymbols(),
+    }));
+  }
+
+  getExtensionsForKeys(keys: string[]): string[] {
+    const exts: string[] = [];
+    for (const key of keys) {
+      const entry = this.adapters.find(a => a.key === key);
+      if (entry) exts.push(...entry.adapter.fileExtensions());
+    }
+    return exts;
+  }
+
+  async initialize(keys: string[]): Promise<void> {
+    for (const key of keys) {
+      const entry = this.adapters.find(a => a.key === key);
+      if (entry && entry.adapter instanceof (await import('./base.js')).BaseTreeSitterAdapter) {
+        try {
+          await (entry.adapter as any).loadGrammar();
+        } catch (e) {
+          // grammar load failure is non-fatal
+        }
+      }
+    }
+  }
+}
+
+export const defaultRegistry = new LanguageRegistry();

package/src/language/types.ts

@@ -0,0 +1,71 @@
+export enum SymbolType {
+  Workspace = 'workspace',
+  Folder = 'folder',
+  File = 'file',
+  Module = 'module',
+  Namespace = 'namespace',
+  Class = 'class',
+  Interface = 'interface',
+  Enum = 'enum',
+  Struct = 'struct',
+  Trait = 'trait',
+  Function = 'function',
+  Method = 'method',
+  Variable = 'variable',
+  Constant = 'constant',
+  Property = 'property',
+  Import = 'import',
+  Export = 'export',
+  Comment = 'comment',
+  Unknown = 'unknown',
+  Package = 'package',
+  Constructor = 'constructor',
+  Extension = 'extension',
+  Field = 'field',
+  TypeAlias = 'type_alias',
+  Document = 'document',
+  Section = 'section',
+  Table = 'table',
+  Selector = 'selector',
+  Rule = 'rule',
+  Actor = 'actor',
+  Object = 'object',
+  Protocol = 'protocol',
+}
+
+export interface CodeSymbol {
+  id: string;
+  name: string;
+  type: SymbolType;
+  language: string;
+  file: string;
+  startLine: number;
+  endLine: number;
+  parent: string | null;
+  children: CodeSymbol[];
+  metadata: Record<string, unknown>;
+}
+
+export interface ParseResult {
+  symbols: CodeSymbol[];
+  imports: string[];
+  exports: string[];
+  comments: string[];
+}
+
+export interface LanguageAdapter {
+  languageName(): string;
+  fileExtensions(): string[];
+  fileNames(): string[];
+  canParse(filePath: string): boolean;
+  parse(content: string, filePath: string): Promise<ParseResult>;
+  supportsSymbols(): boolean;
+}
+
+export interface AdapterInfo {
+  key: string;
+  name: string;
+  extensions: string[];
+  tier: 1 | 2 | 3;
+  supportsSymbols: boolean;
+}

package/src/types/better-sqlite3.d.ts

@@ -0,0 +1,55 @@
+declare module 'better-sqlite3' {
+  namespace Database {
+    interface Database {
+      prepare(sql: string): Statement;
+      exec(sql: string): Database;
+      pragma(pragma: string, options?: { simple?: boolean }): any;
+      function(name: string, cb: (...args: any[]) => any): Database;
+      aggregate(name: string, options: any): Database;
+      loadExtension(path: string, entryPoint?: string): Database;
+      close(): Database;
+      defaultSafeIntegers(toggleState?: boolean): Database;
+      unsafeMode(unsafe?: boolean): Database;
+      transaction(fn: (...args: any[]) => any): (...args: any[]) => any;
+      savepoint(fn: (...args: any[]) => any): (...args: any[]) => any;
+      checkpoint(databaseName?: string): Database;
+      readonly(toggleState?: boolean): Database;
+      open: boolean;
+      inTransaction: boolean;
+      name: string;
+      memory: boolean;
+      readonly: boolean;
+    }
+
+    interface Statement {
+      database: Database;
+      source: string;
+      reader: boolean;
+      readonly: boolean;
+      busy: boolean;
+      run(...params: any[]): RunResult;
+      get(...params: any[]): any;
+      all(...params: any[]): any[];
+      iterate(...params: any[]): IterableIterator<any>;
+      pluck(toggleState?: boolean): Statement;
+      expand(toggleState?: boolean): Statement;
+      raw(toggleState?: boolean): Statement;
+      columns(toggleState?: boolean): Statement;
+      bind(...params: any[]): Statement;
+      safeIntegers(toggleState?: boolean): Statement;
+    }
+
+    interface RunResult {
+      changes: number;
+      lastInsertRowid: number | bigint;
+    }
+  }
+
+  interface DatabaseConstructor {
+    new(filename?: string | Buffer, options?: any): Database.Database;
+    (filename?: string | Buffer, options?: any): Database.Database;
+  }
+
+  const Database: DatabaseConstructor;
+  export = Database;
+}

package/src/types/cli-progress.d.ts

@@ -0,0 +1,32 @@
+declare module 'cli-progress' {
+  export class SingleBar {
+    constructor(options?: any, preset?: any);
+    start(total: number, startValue?: number, payload?: any): void;
+    update(current: number, payload?: any): void;
+    stop(): void;
+    updateETA(): void;
+    setTotal(total: number): void;
+    getProgress(): number;
+    getTotal(): number;
+    getETA(): number;
+    formatTime(t: number, roundToMultipleOf: number): string;
+  }
+
+  export class MultiBar {
+    constructor(options?: any, preset?: any);
+    create(total: number, startValue: number, payload?: any): SingleBar;
+    stop(): void;
+    update(): void;
+    log(data: any): void;
+  }
+
+  export class Presets {
+    static shades_classic: any;
+    static shades_grey: any;
+    static rect: any;
+    static legacy: any;
+  }
+
+  export const Format: any;
+  export const Formatter: any;
+}

package/src/types/vitest.d.ts

@@ -0,0 +1,11 @@
+declare module 'vitest' {
+  export function describe(name: string, fn: () => void): void;
+  export function it(name: string, fn?: () => void | Promise<void>, timeout?: number): void;
+  export function test(name: string, fn?: () => void | Promise<void>, timeout?: number): void;
+  export function expect(actual: any): any;
+  export function beforeAll(fn: () => void | Promise<void>, timeout?: number): void;
+  export function afterAll(fn: () => void | Promise<void>, timeout?: number): void;
+  export function beforeEach(fn: () => void | Promise<void>, timeout?: number): void;
+  export function afterEach(fn: () => void | Promise<void>, timeout?: number): void;
+}
+