edhindex 1.1.0 → 2.0.0

package/src/language/adapters/salesforce.ts

@@ -0,0 +1,236 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class SalesforceAdapter implements LanguageAdapter {
+  languageName(): string { return 'Salesforce'; }
+  fileExtensions(): string[] { 
+    return [
+      '.cls', '.trigger', '.page', '.component', '.cmp', '.app', '.evt', '.intf',
+      '.design', '.auradoc', '.js-meta.xml', '.object-meta.xml', '.field-meta.xml',
+      '.permissionset-meta.xml', '.profile-meta.xml', '.layout-meta.xml',
+      '.flexipage-meta.xml', '.flow-meta.xml', '.workflow-meta.xml',
+      '.approvalProcess-meta.xml', '.quickAction-meta.xml', '.labels-meta.xml',
+      '.globalValueSet-meta.xml', '.remoteSite-meta.xml', '.connectedApp-meta.xml',
+      '.customMetadata-meta.xml', '.customApplication-meta.xml', '.tabs-meta.xml',
+      '.sharingRules-meta.xml', '.queue-meta.xml', '.role-meta.xml',
+      '.group-meta.xml', '.email-meta.xml', '.reportType-meta.xml',
+      '.dashboard-meta.xml', '.report-meta.xml',
+    ]; 
+  }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    const lower = filePath.toLowerCase();
+    for (const ext of this.fileExtensions()) {
+      if (lower.endsWith(ext)) 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('.cls') || filePath.endsWith('.trigger')) {
+      this.extractApexCode(lines, symbols, filePath);
+    } else if (filePath.endsWith('.page') || filePath.endsWith('.component')) {
+      this.extractVisualforce(lines, symbols, filePath);
+    } else if (filePath.endsWith('.cmp') || filePath.endsWith('.app') || filePath.endsWith('.evt') || filePath.endsWith('.intf')) {
+      this.extractAura(lines, symbols, filePath);
+    } else {
+      this.extractMetadata(lines, symbols, filePath);
+    }
+
+    this.extractComments(lines, comments);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractApexCode(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const patterns = [
+      { regex: /^public\s+(?:with\s+sharing\s+|without\s+sharing\s+)?class\s+(\w+)/gi, type: SymbolType.Class },
+      { regex: /^private\s+(?:with\s+sharing\s+|without\s+sharing\s+)?class\s+(\w+)/gi, type: SymbolType.Class },
+      { regex: /^global\s+(?:with\s+sharing\s+|without\s+sharing\s+)?class\s+(\w+)/gi, type: SymbolType.Class },
+      { regex: /^public\s+interface\s+(\w+)/gi, type: SymbolType.Interface },
+      { regex: /^public\s+enum\s+(\w+)/gi, type: SymbolType.Enum },
+      { regex: /^public\s+(?:static\s+)?(?:void|integer|string|boolean|list|map|set)\s+(\w+)\s*\(/gi, type: SymbolType.Function },
+      { regex: /^private\s+(?:static\s+)?(?:void|integer|string|boolean|list|map|set)\s+(\w+)\s*\(/gi, type: SymbolType.Function },
+      { regex: /^public\s+trigger\s+(\w+)\s+on\s+(\w+)/gi, type: SymbolType.Function },
+      { regex: /^trigger\s+(\w+)\s+on\s+(\w+)/gi, type: SymbolType.Function },
+    ];
+
+    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: match[1],
+            type: pattern.type,
+            language: 'salesforce',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        }
+      }
+    }
+  }
+
+  private extractVisualforce(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Extract apex:page, apex:form, apex:inputField, etc.
+      const tagMatch = line.match(/<apex:(\w+)/i);
+      if (tagMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: tagMatch[1],
+          type: SymbolType.Class,
+          language: 'salesforce',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: {},
+        });
+      }
+    }
+  }
+
+  private extractAura(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Extract aura:component, aura:attribute, aura:handler, etc.
+      const tagMatch = line.match(/<aura:(\w+)/i);
+      if (tagMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: tagMatch[1],
+          type: SymbolType.Class,
+          language: 'salesforce',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: {},
+        });
+      }
+      
+      // Extract LWC components
+      const lwcMatch = line.match(/<(\w+-\w+)/i);
+      if (lwcMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: lwcMatch[1],
+          type: SymbolType.Class,
+          language: 'salesforce',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: {},
+        });
+      }
+    }
+  }
+
+  private extractMetadata(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    // For XML-based metadata files, extract root element and key attributes
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Extract root XML element
+      const rootMatch = line.match(/<(\w+)[\s>]/);
+      if (rootMatch && i < 5) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: rootMatch[1],
+          type: SymbolType.Module,
+          language: 'salesforce',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: {},
+        });
+      }
+      
+      // Extract key elements
+      const elementMatch = line.match(/<(\w+)>(.+?)<\/\1>/);
+      if (elementMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}`,
+          name: elementMatch[1],
+          type: SymbolType.Property,
+          language: 'salesforce',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: { value: elementMatch[2] },
+        });
+      }
+    }
+  }
+
+  private extractComments(lines: string[], comments: string[]) {
+    let inBlockComment = false;
+    let blockComment = '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      // Apex/Java style comments
+      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;
+          }
+        }
+        
+        if (trimmed.startsWith('//')) {
+          comments.push(trimmed);
+        }
+        
+        // XML comments
+        if (trimmed.startsWith('<!--')) {
+          const endIdx = line.indexOf('-->');
+          if (endIdx >= 0) {
+            comments.push(line.substring(0, endIdx + 3).trim());
+          }
+        }
+      }
+    }
+  }
+}

package/src/language/adapters/scala.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: 'scala',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-scala.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    class_definition: '(class_definition name: (identifier) @name)',
+    trait_definition: '(trait_definition name: (identifier) @name)',
+    object_definition: '(object_definition name: (identifier) @name)',
+    function_definition: '(function_definition name: (identifier) @name)',
+    val_definition: '(val_definition name: (identifier) @name)',
+    var_definition: '(var_definition name: (identifier) @name)',
+  },
+  typeMap: {
+    class_definition: SymbolType.Class,
+    trait_definition: SymbolType.Trait,
+    object_definition: SymbolType.Object,
+    enum_definition: SymbolType.Enum,
+    function_definition: SymbolType.Function,
+    method_definition: SymbolType.Method,
+    val_definition: SymbolType.Constant,
+    var_definition: SymbolType.Variable,
+    import_declaration: SymbolType.Import,
+    package_clause: SymbolType.Package,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['import_declaration'],
+  exportNodeTypes: [],
+};
+
+export class ScalaAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Scala'; }
+  fileExtensions(): string[] { return ['.scala', '.sc']; }
+}

package/src/language/adapters/solidity.ts

@@ -0,0 +1,42 @@
+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: 'solidity',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-solidity.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    contract_declaration: '(contract_declaration name: (identifier) @name)',
+    interface_declaration: '(interface_declaration name: (identifier) @name)',
+    library_declaration: '(library_declaration name: (identifier) @name)',
+    struct_declaration: '(struct_declaration name: (identifier) @name)',
+    enum_declaration: '(enum_declaration name: (identifier) @name)',
+    event_declaration: '(event_declaration name: (identifier) @name)',
+    modifier_definition: '(modifier_definition name: (identifier) @name)',
+    function_definition: '(function_definition name: (identifier) @name)',
+  },
+  typeMap: {
+    contract_declaration: SymbolType.Class,
+    interface_declaration: SymbolType.Interface,
+    library_declaration: SymbolType.Module,
+    struct_declaration: SymbolType.Struct,
+    enum_declaration: SymbolType.Enum,
+    event_declaration: SymbolType.Function,
+    modifier_definition: SymbolType.Method,
+    constructor_definition: SymbolType.Constructor,
+    function_definition: SymbolType.Function,
+    state_variable_declaration: SymbolType.Variable,
+    import_directive: SymbolType.Import,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: ['import_directive'],
+  exportNodeTypes: [],
+};
+
+export class SolidityAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Solidity'; }
+  fileExtensions(): string[] { return ['.sol']; }
+}

package/src/language/adapters/sql.ts

@@ -0,0 +1,99 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class SqlAdapter implements LanguageAdapter {
+  languageName(): string { return 'SQL'; }
+  fileExtensions(): string[] { return ['.sql']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    return filePath.toLowerCase().endsWith('.sql');
+  }
+  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[] = [];
+
+    // Extract SQL objects using regex patterns
+    this.extractSqlObjects(lines, symbols, filePath);
+    
+    // Extract comments
+    this.extractComments(lines, comments);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractSqlObjects(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const patterns = [
+      { regex: /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"']?(\w+)[`"']?/gi, type: SymbolType.Table },
+      { regex: /CREATE\s+VIEW\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Table },
+      { regex: /CREATE\s+INDEX\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Property },
+      { regex: /CREATE\s+(?:UNIQUE\s+)?INDEX\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Property },
+      { regex: /CREATE\s+TRIGGER\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Function },
+      { regex: /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Function },
+      { regex: /CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Function },
+      { regex: /CREATE\s+SCHEMA\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Namespace },
+      { regex: /CREATE\s+DATABASE\s+[`"']?(\w+)[`"']?/gi, type: SymbolType.Module },
+    ];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      for (const pattern of patterns) {
+        const matches = line.matchAll(pattern.regex);
+        for (const match of matches) {
+          if (match[1]) {
+            symbols.push({
+              id: `${filePath}:${i + 1}`,
+              name: match[1],
+              type: pattern.type,
+              language: 'sql',
+              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;
+          }
+        }
+        
+        const lineCommentIdx = line.indexOf('--');
+        if (lineCommentIdx >= 0) {
+          comments.push(line.substring(lineCommentIdx).trim());
+        }
+      }
+    }
+  }
+}

package/src/language/adapters/svelte.ts

@@ -0,0 +1,80 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'svelte',
+  wasmPath: new URL('../../node_modules/@tree-sitter-grammars/tree-sitter-svelte/tree-sitter-svelte.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['tag_name', 'attribute_name'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class SvelteAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Svelte'; }
+  fileExtensions(): string[] { return ['.svelte']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkSvelte(tree.rootNode, symbols, filePath);
+    return symbols;
+  }
+
+  private walkSvelte(node: any, symbols: CodeSymbol[], filePath: string) {
+    // Extract top-level sections: <script>, <style>, <template>
+    if (node.type === 'element' || node.type === 'script_element' || node.type === 'style_element') {
+      const tagName = this.extractTagName(node);
+      if (tagName && ['script', 'style', 'template'].includes(tagName.toLowerCase())) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: tagName, type: SymbolType.Section, language: 'svelte',
+          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: 'svelte',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: null, children: [], metadata: {},
+        });
+      }
+    }
+    
+    // Extract Svelte-specific blocks: {#if}, {#each}, {#await}
+    if (node.type === 'if_block' || node.type === 'each_block' || node.type === 'await_block') {
+      const id = `${filePath}:${node.startPosition.row + 1}`;
+      symbols.push({
+        id, name: node.type.replace('_block', ''), type: SymbolType.Function, language: 'svelte',
+        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.walkSvelte(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/svg.ts

@@ -0,0 +1,137 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class SvgAdapter implements LanguageAdapter {
+  languageName(): string { return 'SVG'; }
+  fileExtensions(): string[] { return ['.svg']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    return filePath.toLowerCase().endsWith('.svg');
+  }
+  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.extractSvgElements(lines, symbols, filePath);
+    this.extractComments(lines, comments);
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractSvgElements(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const significantElements = [
+      'svg', 'g', 'defs', 'symbol', 'use', 'path', 'rect', 'circle', 'ellipse',
+      'line', 'polyline', 'polygon', 'text', 'tspan', 'textPath', 'image',
+      'switch', 'foreignObject', 'marker', 'pattern', 'clipPath', 'mask',
+      'filter', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite',
+      'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood',
+      'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology',
+      'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'animate',
+      'animateTransform', 'animateMotion', 'set',
+    ];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Extract SVG elements
+      const elementMatch = line.match(/<(\w+)(?:\s|>|\/)/);
+      if (elementMatch) {
+        const elementName = elementMatch[1].toLowerCase();
+        if (significantElements.includes(elementName)) {
+          const symbolType = this.getSymbolType(elementName);
+          symbols.push({
+            id: `${filePath}:${i + 1}`,
+            name: elementName,
+            type: symbolType,
+            language: 'svg',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        }
+      }
+
+      // Extract id attributes as properties
+      const idMatch = line.match(/\bid=["']([^"']+)["']/);
+      if (idMatch) {
+        symbols.push({
+          id: `${filePath}:${i + 1}:id`,
+          name: idMatch[1],
+          type: SymbolType.Property,
+          language: 'svg',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: {},
+        });
+      }
+
+      // Extract class attributes
+      const classMatch = line.match(/\bclass=["']([^"']+)["']/);
+      if (classMatch) {
+        const classes = classMatch[1].split(/\s+/);
+        for (const cls of classes) {
+          if (cls.trim()) {
+            symbols.push({
+              id: `${filePath}:${i + 1}:class:${cls}`,
+              name: cls,
+              type: SymbolType.Property,
+              language: 'svg',
+              file: filePath,
+              startLine: i + 1,
+              endLine: i + 1,
+              parent: null,
+              children: [],
+              metadata: {},
+            });
+          }
+        }
+      }
+    }
+  }
+
+  private getSymbolType(elementName: string): SymbolType {
+    const structural = ['svg', 'g', 'defs', 'symbol', 'marker', 'pattern', 'clipPath', 'mask', 'filter'];
+    if (structural.includes(elementName)) return SymbolType.Module;
+    return SymbolType.Property;
+  }
+
+  private extractComments(lines: string[], comments: string[]) {
+    let inComment = false;
+    let comment = '';
+
+    for (const line of lines) {
+      if (inComment) {
+        const endIdx = line.indexOf('-->');
+        if (endIdx >= 0) {
+          comment += line.substring(0, endIdx + 3);
+          comments.push(comment.trim());
+          comment = '';
+          inComment = false;
+        } else {
+          comment += line + '\n';
+        }
+      } else {
+        const startIdx = line.indexOf('<!--');
+        if (startIdx >= 0) {
+          const endIdx = line.indexOf('-->', startIdx + 4);
+          if (endIdx >= 0) {
+            comments.push(line.substring(startIdx, endIdx + 3).trim());
+          } else {
+            comment = line.substring(startIdx) + '\n';
+            inComment = true;
+          }
+        }
+      }
+    }
+  }
+}

package/src/language/adapters/swift.ts

@@ -0,0 +1,44 @@
+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: 'swift',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-swift.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    class_declaration: '(class_declaration name: (type_identifier) @name)',
+    struct_declaration: '(struct_declaration name: (type_identifier) @name)',
+    enum_declaration: '(enum_declaration name: (type_identifier) @name)',
+    protocol_declaration: '(protocol_declaration name: (type_identifier) @name)',
+    extension_declaration: '(extension_declaration type: (user_type) @name)',
+    actor_declaration: '(actor_declaration name: (type_identifier) @name)',
+    function_declaration: '(function_declaration name: (simple_identifier) @name)',
+    initializer_declaration: '(initializer_declaration) @name',
+  },
+  typeMap: {
+    class_declaration: SymbolType.Class,
+    struct_declaration: SymbolType.Struct,
+    enum_declaration: SymbolType.Enum,
+    protocol_declaration: SymbolType.Protocol,
+    extension_declaration: SymbolType.Extension,
+    actor_declaration: SymbolType.Actor,
+    function_declaration: SymbolType.Function,
+    method_declaration: SymbolType.Method,
+    initializer_declaration: SymbolType.Constructor,
+    property_declaration: SymbolType.Property,
+    variable_declaration: SymbolType.Variable,
+    type_alias_declaration: SymbolType.TypeAlias,
+    import_declaration: SymbolType.Import,
+  },
+  nameNodeTypes: ['simple_identifier', 'type_identifier'],
+  importNodeTypes: ['import_declaration'],
+  exportNodeTypes: [],
+};
+
+export class SwiftAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Swift'; }
+  fileExtensions(): string[] { return ['.swift']; }
+}