edhindex 1.0.2 → 1.1.0

package/src/indexer/indexer.ts

@@ -1,13 +1,12 @@
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
 import { logger } from '../logging.js';
 import { emitProgress } from '../progress.js';
-import { Config, MODEL_CONFIGS } from '../config/index.js';
-import { scanFiles, computeFileHash } from './file-utils.js';
-import { createIgnoreRules } from './ignore.js';
-import { initParser, loadLanguage, parseContentAsync, extractSymbols, extractImports, extractExports } from './parser.js';
+import { Config } from '../config/index.js';
+import { LanguageRegistry } from '../language/registry.js';
+import { SymbolType } from '../language/types.js';
+import { scanFiles, computeFileHash, ScannedFile } from './file-utils.js';
 import { Chunk, chunkFile } from './chunker.js';
-import { computeFileDelta, computeChunkDelta } from './incremental.js';
+import { computeFileDelta } from './incremental.js';
 
 export interface IndexFileResult {
   chunks: Chunk[];
@@ -23,6 +22,7 @@ export interface IndexerOptions {
   config: Config;
   rootPath: string;
   indexDir: string;
+  registry: LanguageRegistry;
   onIndex: IndexCallback;
   onDelete?: DeleteCallback;
   signal?: AbortSignal;
@@ -32,44 +32,29 @@ export class Indexer {
   private config: Config;
   private rootPath: string;
   private indexDir: string;
+  private registry: LanguageRegistry;
   private onIndex: IndexCallback;
   private onDelete?: DeleteCallback;
   private signal: AbortSignal;
-  private extToLang: Map<string, string>;
 
   constructor(opts: IndexerOptions) {
     this.config = opts.config;
     this.rootPath = opts.rootPath;
     this.indexDir = opts.indexDir;
+    this.registry = opts.registry;
     this.onIndex = opts.onIndex;
     this.onDelete = opts.onDelete;
     this.signal = opts.signal || new AbortController().signal;
-
-    this.extToLang = new Map();
-    for (const lang of this.config.languages) {
-      const exts = LANG_EXTENSIONS[lang] || [];
-      for (const ext of exts) {
-        this.extToLang.set(ext, lang);
-      }
-    }
   }
 
   async initialize() {
-    await initParser();
-    for (const lang of this.config.languages) {
-      try {
-        await loadLanguage(lang);
-        logger.verbose(`Loaded tree-sitter grammar for ${lang}`);
-      } catch (e) {
-        logger.error(`Failed to load tree-sitter grammar for ${lang}:`, e);
-      }
-    }
+    await this.registry.initialize(this.config.languages);
   }
 
   async runFullIndex(): Promise<Chunk[]> {
     emitProgress({ phase: 'scanning', current: 0, total: 0 });
 
-    const files = scanFiles(this.rootPath, this.config.languages);
+    const files = scanFiles(this.rootPath, this.registry);
     const allChunks: Chunk[] = [];
     let processed = 0;
 
@@ -103,7 +88,7 @@ export class Indexer {
   ): Promise<{ chunks: Chunk[]; removed: string[] }> {
     emitProgress({ phase: 'scanning', current: 0, total: 0 });
 
-    const scannedFiles = scanFiles(this.rootPath, this.config.languages);
+    const scannedFiles = scanFiles(this.rootPath, this.registry);
     const scannedMap = new Map(scannedFiles.map(f => [f.relativePath, f]));
     const delta = computeFileDelta(scannedMap, existingFileHashes);
 
@@ -155,27 +140,18 @@ export class Indexer {
     const content = readFileSync(filePath, 'utf-8');
     const lines = content.split('\n');
 
-    const { tree } = await parseContentAsync(content, language);
-    const symbols = extractSymbols(tree, language);
-    const imports = extractImports(tree, language);
-    const exports = extractExports(tree, language);
+    const { adapter } = this.registry.getAdapter(relativePath);
+    const result = await adapter.parse(content, relativePath);
 
     return chunkFile(
       filePath,
       relativePath,
       language,
-      symbols,
+      result.symbols,
       content,
       lines,
-      imports,
-      exports,
+      result.imports,
+      result.exports,
     );
   }
 }
-
-const LANG_EXTENSIONS: Record<string, string[]> = {
-  ts: ['.ts', '.tsx', '.mts', '.cts'],
-  js: ['.js', '.jsx', '.mjs', '.cjs'],
-  py: ['.py', '.pyw'],
-  go: ['.go'],
-};

package/src/indexer/parser.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { LanguageRegistry } from '../language/registry.js';
+
+const registry = new LanguageRegistry();
+const adapters = registry.getInfoList().filter(a => a.key !== 'generic');
+
+describe('Language Adapter Registry', () => {
+  it('registers all adapters', () => {
+    expect(adapters.length).toBeGreaterThan(0);
+    expect(adapters.find(a => a.key === 'ts')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'py')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'go')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'rs')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'java')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'html')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'css')).toBeTruthy();
+    expect(adapters.find(a => a.key === 'json')).toBeTruthy();
+  });
+
+  it('maps file extensions to correct adapters', () => {
+    expect(registry.getAdapter('file.ts').key).toBe('ts');
+    expect(registry.getAdapter('file.js').key).toBe('js');
+    expect(registry.getAdapter('file.py').key).toBe('py');
+    expect(registry.getAdapter('file.go').key).toBe('go');
+    expect(registry.getAdapter('file.rs').key).toBe('rs');
+    expect(registry.getAdapter('file.java').key).toBe('java');
+    expect(registry.getAdapter('file.rb').key).toBe('rb');
+    expect(registry.getAdapter('file.c').key).toBe('c');
+    expect(registry.getAdapter('file.cpp').key).toBe('cpp');
+    expect(registry.getAdapter('file.cs').key).toBe('csharp');
+    expect(registry.getAdapter('file.php').key).toBe('php');
+    expect(registry.getAdapter('file.html').key).toBe('html');
+    expect(registry.getAdapter('file.css').key).toBe('css');
+    expect(registry.getAdapter('file.json').key).toBe('json');
+  });
+
+  it('returns generic for unknown extensions', () => {
+    const { adapter, key } = registry.getAdapter('file.xyz');
+    expect(key).toBe('generic');
+    expect(adapter.languageName()).toBe('Generic');
+  });
+});
+
+const SAMPLES: Record<string, string> = {
+  ts: `import { readFileSync } from 'node:fs';
+export interface Config { name: string }
+export class App { start() {} }
+function helper() {}`,
+  js: `const { join } = require('node:path');
+class App { constructor() { this.name = 'app'; } }
+function helper() {}`,
+  py: `import os
+def hello(name):
+    pass
+class App:
+    def start(self):
+        pass`,
+  go: `package main
+import "fmt"
+func hello() {}
+func (a App) Start() {}`,
+  rs: `use std::fs;
+pub struct User { name: String }
+pub trait Runner { fn run(&self); }
+pub fn hello() -> String { "hi".into() }
+enum Color { Red, Green }`,
+  java: `import java.util.List;
+public class App {
+    public void start() {}
+    public interface Handler { void handle(); }
+}`,
+  rb: `require 'json'
+module App
+  class User
+    def login; end
+  end
+end`,
+  c: `#include <stdio.h>
+struct Point { int x; int y; };
+void hello() { printf("hi"); }`,
+  cpp: `#include <vector>
+class App { void start() {} };
+struct Point { int x; };
+void hello() {}`,
+  csharp: `using System;
+class App { void Start() {} }
+interface IHandler { void Handle(); }`,
+  php: `<?php
+function hello() {}
+class App {
+    public function start() {}
+}`,
+  json: `{ "name": "test", "version": "1.0.0" }`,
+  css: `.btn { color: red; }
+#header { font-size: 16px; }`,
+  html: `<!DOCTYPE html><html><body><p>Hello</p></body></html>`,
+};
+
+for (const info of adapters) {
+  const sample = SAMPLES[info.key];
+  if (!sample) continue;
+
+  describe(`${info.name} (${info.key})`, () => {
+    const { adapter } = registry.getAdapter(`file.${info.extensions[0]?.replace('.', '') || 'txt'}`);
+
+    it('parses content', async () => {
+      const result = await adapter.parse(sample, `file${info.extensions[0] || ''}`);
+      expect(result).toBeTruthy();
+      expect(Array.isArray(result.symbols)).toBe(true);
+      expect(Array.isArray(result.imports)).toBe(true);
+      expect(Array.isArray(result.exports)).toBe(true);
+    }, 30000);
+
+    if (info.supportsSymbols) {
+      it('extracts symbols', async () => {
+        const result = await adapter.parse(sample, `file${info.extensions[0] || ''}`);
+        expect(result.symbols.length).toBeGreaterThan(0);
+        for (const sym of result.symbols) {
+          expect(sym.name).toBeTruthy();
+          expect(sym.type).toBeTruthy();
+          expect(sym.startLine).toBeGreaterThan(0);
+          expect(sym.endLine).toBeGreaterThanOrEqual(sym.startLine);
+        }
+      }, 30000);
+    }
+  });
+}

package/src/indexer/parser.ts

@@ -44,6 +44,45 @@ export async function loadLanguage(language: string): Promise<any> {
     case 'go':
       wasmPath = require.resolve('tree-sitter-go/tree-sitter-go.wasm');
       break;
+    case 'rs':
+      wasmPath = require.resolve('tree-sitter-rust/tree-sitter-rust.wasm');
+      break;
+    case 'java':
+      wasmPath = require.resolve('tree-sitter-java/tree-sitter-java.wasm');
+      break;
+    case 'rb':
+      wasmPath = require.resolve('tree-sitter-ruby/tree-sitter-ruby.wasm');
+      break;
+    case 'c':
+      wasmPath = require.resolve('tree-sitter-c/tree-sitter-c.wasm');
+      break;
+    case 'cpp':
+      wasmPath = require.resolve('tree-sitter-cpp/tree-sitter-cpp.wasm');
+      break;
+    case 'csharp':
+      wasmPath = require.resolve('tree-sitter-c-sharp/tree-sitter-c_sharp.wasm');
+      break;
+    case 'php':
+      wasmPath = require.resolve('tree-sitter-php/tree-sitter-php.wasm');
+      break;
+    case 'scala':
+      wasmPath = require.resolve('tree-sitter-scala/tree-sitter-scala.wasm');
+      break;
+    case 'hs':
+      wasmPath = require.resolve('tree-sitter-haskell/tree-sitter-haskell.wasm');
+      break;
+    case 'solidity':
+      wasmPath = require.resolve('tree-sitter-solidity/tree-sitter-solidity.wasm');
+      break;
+    case 'css':
+      wasmPath = require.resolve('tree-sitter-css/tree-sitter-css.wasm');
+      break;
+    case 'json':
+      wasmPath = require.resolve('tree-sitter-json/tree-sitter-json.wasm');
+      break;
+    case 'html':
+      wasmPath = require.resolve('tree-sitter-html/tree-sitter-html.wasm');
+      break;
     default:
       throw new Error(`Unsupported language: ${language}`);
   }
@@ -55,7 +94,9 @@ export async function loadLanguage(language: string): Promise<any> {
 }
 
 function langKey(language: string): string {
-  return language === 'ts' || language === 'js' ? 'ts' : language;
+  if (language === 'ts' || language === 'js') return 'ts';
+  if (language === 'c' || language === 'cpp') return 'c-like';
+  return language;
 }
 
 export function parseFile(filePath: string, language: string): any {
@@ -136,6 +177,68 @@ const QUERY_PATTERNS: Record<string, Record<string, string>> = {
     function: '(function_declaration name: (identifier) @name)',
     method: '(method_declaration name: (field_identifier) @name)',
   },
+  rs: {
+    function: '(function_item name: (identifier) @name)',
+    struct: '(struct_item name: (type_identifier) @name)',
+    trait: '(trait_item name: (type_identifier) @name)',
+    impl: '(impl_item trait: (type_identifier) @name)',
+    enum: '(enum_item name: (type_identifier) @name)',
+  },
+  java: {
+    method: '(method_declaration name: (identifier) @name)',
+    class: '(class_declaration name: (identifier) @name)',
+    interface: '(interface_declaration name: (identifier) @name)',
+    enum: '(enum_declaration name: (identifier) @name)',
+  },
+  rb: {
+    method: '(method name: (identifier) @name)',
+    class: '(class name: (constant) @name)',
+    module: '(module name: (constant) @name)',
+  },
+  c: {
+    function: '(function_definition declarator: (function_declarator declarator: (identifier) @name))',
+    struct: '(struct_specifier name: (type_identifier) @name)',
+  },
+  cpp: {
+    function: '(function_definition declarator: (function_declarator declarator: (identifier) @name))',
+    method: '(function_definition declarator: (function_declarator declarator: (field_identifier) @name))',
+    class: '(class_specifier name: (type_identifier) @name)',
+    struct: '(struct_specifier name: (type_identifier) @name)',
+    enum: '(enum_specifier name: (type_identifier) @name)',
+  },
+  csharp: {
+    method: '(method_declaration name: (identifier) @name)',
+    class: '(class_declaration name: (identifier) @name)',
+    interface: '(interface_declaration name: (identifier) @name)',
+    struct: '(struct_declaration name: (identifier) @name)',
+    enum: '(enum_declaration name: (identifier) @name)',
+  },
+  php: {
+    function: '(function_definition name: (name) @name)',
+    method: '(method_declaration name: (name) @name)',
+    class: '(class_declaration name: (name) @name)',
+    interface: '(interface_declaration name: (name) @name)',
+  },
+  scala: {
+    function: '(function_definition name: (identifier) @name)',
+    class: '(class_definition name: (identifier) @name)',
+    trait: '(trait_definition name: (identifier) @name)',
+    object: '(object_definition name: (identifier) @name)',
+    enum: '(enum_definition name: (identifier) @name)',
+  },
+  hs: {
+    function: '(function name: (variable) @name)',
+    class: '(class name: (type) @name)',
+  },
+  solidity: {
+    function: '(function_definition name: (identifier) @name)',
+    event: '(event_definition name: (identifier) @name)',
+    error: '(error_definition name: (identifier) @name)',
+    modifier: '(modifier_definition name: (identifier) @name)',
+  },
+  css: {
+    rule: '(rule_set selectors: (selectors) @name)',
+  },
 };
 
 export function extractSymbols(tree: any, language: string): SymbolInfo[] {
@@ -191,6 +294,87 @@ function nodeTypeToKind(type: string, language: string): SymbolInfo['kind'] | nu
         case 'method_declaration': return 'method';
         default: return null;
       }
+    case 'rs':
+      switch (type) {
+        case 'function_item': return 'function';
+        case 'struct_item': return 'class';
+        case 'trait_item': return 'interface';
+        case 'impl_item': return 'module';
+        case 'enum_item': return 'enum';
+        default: return null;
+      }
+    case 'java':
+      switch (type) {
+        case 'method_declaration': return 'method';
+        case 'class_declaration': return 'class';
+        case 'interface_declaration': return 'interface';
+        case 'enum_declaration': return 'enum';
+        default: return null;
+      }
+    case 'rb':
+      switch (type) {
+        case 'method': return 'method';
+        case 'class': return 'class';
+        case 'module': return 'module';
+        default: return null;
+      }
+    case 'c':
+      switch (type) {
+        case 'function_definition': return 'function';
+        case 'struct_specifier': return 'class';
+        default: return null;
+      }
+    case 'cpp':
+      switch (type) {
+        case 'function_definition': return 'function';
+        case 'class_specifier': return 'class';
+        case 'struct_specifier': return 'class';
+        case 'enum_specifier': return 'enum';
+        default: return null;
+      }
+    case 'csharp':
+      switch (type) {
+        case 'method_declaration': return 'method';
+        case 'class_declaration': return 'class';
+        case 'interface_declaration': return 'interface';
+        case 'struct_declaration': return 'class';
+        case 'enum_declaration': return 'enum';
+        default: return null;
+      }
+    case 'php':
+      switch (type) {
+        case 'function_definition': return 'function';
+        case 'method_declaration': return 'method';
+        case 'class_declaration': return 'class';
+        case 'interface_declaration': return 'interface';
+        default: return null;
+      }
+    case 'scala':
+      switch (type) {
+        case 'function_definition': return 'function';
+        case 'class_definition': return 'class';
+        case 'trait_definition': return 'interface';
+        case 'object_definition': return 'module';
+        case 'enum_definition': return 'enum';
+        default: return null;
+      }
+    case 'hs':
+      switch (type) {
+        case 'function': return 'function';
+        case 'class': return 'interface';
+        default: return null;
+      }
+    case 'solidity':
+      switch (type) {
+        case 'function_definition': return 'function';
+        case 'event_definition': return 'function';
+        case 'error_definition': return 'function';
+        case 'modifier_definition': return 'method';
+        default: return null;
+      }
+    case 'css':
+      if (type === 'rule_set') return 'module';
+      return null;
     default:
       return null;
   }
@@ -200,18 +384,15 @@ function extractName(node: any, language: string): string | null {
   try {
     for (let i = 0; i < node.childCount; i++) {
       const child = node.child(i);
-      if (language === 'ts' || language === 'js') {
-        if (child.type === 'identifier' || child.type === 'property_identifier' || child.type === 'type_identifier') {
-          return child.text;
-        }
-      } else if (language === 'py') {
-        if (child.type === 'identifier') {
-          return child.text;
-        }
-      } else if (language === 'go') {
-        if (child.type === 'identifier' || child.type === 'field_identifier') {
-          return child.text;
-        }
+      const nameTypes = new Set([
+        'identifier', 'property_identifier', 'type_identifier',
+        'field_identifier', 'constant', 'variable', 'name', 'type',
+      ]);
+      if (nameTypes.has(child.type)) {
+        return child.text;
+      }
+      if (language === 'css' && child.type === 'selectors') {
+        return child.text?.split(',')[0]?.trim() || null;
       }
     }
   } catch {

package/src/language/adapters/c.ts

@@ -0,0 +1,27 @@
+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: 'c',
+  wasmPath: require.resolve('tree-sitter-c/tree-sitter-c.wasm'),
+  queryPatterns: {
+    function_definition: '(function_definition declarator: (function_declarator declarator: (identifier) @name))',
+    struct_specifier: '(struct_specifier name: (type_identifier) @name)',
+  },
+  typeMap: {
+    function_definition: SymbolType.Function,
+    struct_specifier: SymbolType.Struct,
+  },
+  nameNodeTypes: ['identifier', 'type_identifier', 'field_identifier'],
+  importNodeTypes: ['preproc_include'],
+  exportNodeTypes: [],
+};
+
+export class CAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'C'; }
+  fileExtensions(): string[] { return ['.c', '.h']; }
+}

package/src/language/adapters/cpp.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: 'cpp',
+  wasmPath: require.resolve('tree-sitter-cpp/tree-sitter-cpp.wasm'),
+  queryPatterns: {
+    function_definition: '(function_definition declarator: (function_declarator declarator: (identifier) @name))',
+    class_specifier: '(class_specifier name: (type_identifier) @name)',
+    struct_specifier: '(struct_specifier name: (type_identifier) @name)',
+    enum_specifier: '(enum_specifier name: (type_identifier) @name)',
+  },
+  typeMap: {
+    function_definition: SymbolType.Function,
+    class_specifier: SymbolType.Class,
+    struct_specifier: SymbolType.Struct,
+    enum_specifier: SymbolType.Enum,
+  },
+  nameNodeTypes: ['identifier', 'type_identifier', 'field_identifier'],
+  importNodeTypes: ['preproc_include', 'using_declaration'],
+  exportNodeTypes: [],
+};
+
+export class CppAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'C++'; }
+  fileExtensions(): string[] { return ['.cpp', '.cxx', '.cc', '.c++', '.hpp', '.hxx', '.hh']; }
+}

package/src/language/adapters/csharp.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: 'csharp',
+  wasmPath: require.resolve('tree-sitter-c-sharp/tree-sitter-c_sharp.wasm'),
+  queryPatterns: {
+    method_declaration: '(method_declaration name: (identifier) @name)',
+    class_declaration: '(class_declaration name: (identifier) @name)',
+    interface_declaration: '(interface_declaration name: (identifier) @name)',
+    struct_declaration: '(struct_declaration name: (identifier) @name)',
+    enum_declaration: '(enum_declaration name: (identifier) @name)',
+  },
+  typeMap: {
+    method_declaration: SymbolType.Method,
+    class_declaration: SymbolType.Class,
+    interface_declaration: SymbolType.Interface,
+    struct_declaration: SymbolType.Struct,
+    enum_declaration: SymbolType.Enum,
+    using_directive: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['using_directive'],
+  exportNodeTypes: [],
+};
+
+export class CSharpAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'C#'; }
+  fileExtensions(): string[] { return ['.cs']; }
+}

package/src/language/adapters/css.ts

@@ -0,0 +1,57 @@
+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: 'css',
+  wasmPath: require.resolve('tree-sitter-css/tree-sitter-css.wasm'),
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: [],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class CssAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'CSS'; }
+  fileExtensions(): string[] { return ['.css', '.scss', '.less']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.collectRules(tree.rootNode, symbols, filePath);
+    return symbols;
+  }
+
+  private collectRules(node: any, symbols: CodeSymbol[], filePath: string) {
+    if (node.type === 'rule_set') {
+      let selectorText = '';
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === 'selectors') {
+          selectorText = child.text || '';
+          break;
+        }
+      }
+      if (selectorText) {
+        const first = selectorText.split(',')[0].trim();
+        symbols.push({
+          id: `${filePath}:${node.startPosition.row + 1}`,
+          name: first,
+          type: SymbolType.Module,
+          language: 'css',
+          file: filePath,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          parent: null, children: [], metadata: { selector: selectorText },
+        });
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.collectRules(child, symbols, filePath);
+    }
+  }
+}

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