edhindex 1.0.3 → 2.0.0

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

package/src/language/adapters/dockerfile.ts

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

package/src/language/adapters/documentation.ts

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