@monoes/monograph 1.5.6 → 1.5.8

package/src/parsers/language-config.ts

@@ -1,28 +0,0 @@
-export interface ImportExtractor {
-  (sourceText: string, importNode: import('tree-sitter').SyntaxNode): string | null;
-}
-
-export interface ExportDetector {
-  (node: import('tree-sitter').SyntaxNode, sourceText: string): boolean;
-}
-
-export interface LanguageConfig {
-  name: string;
-  extensions: string[];
-  treeSitterModule: string;
-  getLanguage: () => import('tree-sitter').Language;
-  classNodeTypes: Set<string>;
-  structNodeTypes: Set<string>;
-  enumNodeTypes: Set<string>;
-  functionNodeTypes: Set<string>;
-  methodNodeTypes: Set<string>;
-  constructorNodeTypes: Set<string>;
-  interfaceNodeTypes: Set<string>;
-  importNodeTypes: Set<string>;
-  callNodeTypes: Set<string>;
-  decoratorNodeTypes: Set<string>;
-  nameField: string;
-  packageScopeType?: string;
-  importExtractor?: ImportExtractor;
-  exportDetector?: ExportDetector;
-}

package/src/parsers/language-parsers.ts

@@ -1,120 +0,0 @@
-export type SupportedLanguage = 'scala' | 'lua' | 'zig' | 'powershell' | 'elixir';
-
-export interface SymbolExtract {
-  name: string;
-  label: 'Function' | 'Class' | 'Module' | 'Namespace';
-  isExported: boolean;
-  line: number;
-  filePath: string;
-}
-
-// ── Scala ────────────────────────────────────────────────────────────
-const SCALA_DEF_RE = /^[ \t]*(?:(?:case\s+)?class|object|trait)\s+(\w[\w$]*)/gm;
-const SCALA_FN_RE = /^[ \t]*(?:override\s+)?def\s+(\w[\w$]*)/gm;
-
-function extractScala(src: string, fp: string): SymbolExtract[] {
-  const out: SymbolExtract[] = [];
-  let m: RegExpExecArray | null;
-
-  SCALA_DEF_RE.lastIndex = 0;
-  while ((m = SCALA_DEF_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    out.push({ name: m[1]!, label: 'Class', isExported: true, line, filePath: fp });
-  }
-  SCALA_FN_RE.lastIndex = 0;
-  while ((m = SCALA_FN_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    out.push({ name: m[1]!, label: 'Function', isExported: true, line, filePath: fp });
-  }
-  return out;
-}
-
-// ── Lua ─────────────────────────────────────────────────────────────
-const LUA_FN_RE = /^[ \t]*(?:local\s+)?function\s+(\w[\w.]*)\s*\(/gm;
-
-function extractLua(src: string, fp: string): SymbolExtract[] {
-  const out: SymbolExtract[] = [];
-  let m: RegExpExecArray | null;
-  LUA_FN_RE.lastIndex = 0;
-  while ((m = LUA_FN_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    const isLocal = /^[ \t]*local\s+function/.test(m[0]);
-    out.push({ name: m[1]!, label: 'Function', isExported: !isLocal, line, filePath: fp });
-  }
-  return out;
-}
-
-// ── Zig ─────────────────────────────────────────────────────────────
-const ZIG_FN_RE = /^[ \t]*(pub\s+)?fn\s+(\w+)\s*\(/gm;
-
-function extractZig(src: string, fp: string): SymbolExtract[] {
-  const out: SymbolExtract[] = [];
-  let m: RegExpExecArray | null;
-  ZIG_FN_RE.lastIndex = 0;
-  while ((m = ZIG_FN_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    out.push({ name: m[2]!, label: 'Function', isExported: !!m[1], line, filePath: fp });
-  }
-  return out;
-}
-
-// ── PowerShell ───────────────────────────────────────────────────────
-const PS_FN_RE = /^[ \t]*function\s+([\w-]+)\s*\{/gim;
-
-function extractPowershell(src: string, fp: string): SymbolExtract[] {
-  const out: SymbolExtract[] = [];
-  let m: RegExpExecArray | null;
-  PS_FN_RE.lastIndex = 0;
-  while ((m = PS_FN_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    out.push({ name: m[1]!, label: 'Function', isExported: true, line, filePath: fp });
-  }
-  return out;
-}
-
-// ── Elixir ───────────────────────────────────────────────────────────
-const ELIXIR_MODULE_RE = /^[ \t]*defmodule\s+([\w.]+)\s+do/gm;
-const ELIXIR_FN_RE = /^[ \t]*(?:def|defp)\s+(\w+)\s*[(\n]/gm;
-
-function extractElixir(src: string, fp: string): SymbolExtract[] {
-  const out: SymbolExtract[] = [];
-  let m: RegExpExecArray | null;
-  ELIXIR_MODULE_RE.lastIndex = 0;
-  while ((m = ELIXIR_MODULE_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    out.push({ name: m[1]!, label: 'Module', isExported: true, line, filePath: fp });
-  }
-  ELIXIR_FN_RE.lastIndex = 0;
-  while ((m = ELIXIR_FN_RE.exec(src)) !== null) {
-    const line = (src.slice(0, m.index).match(/\n/g)?.length ?? 0) + 1;
-    out.push({ name: m[1]!, label: 'Function', isExported: true, line, filePath: fp });
-  }
-  return out;
-}
-
-const DISPATCH: Record<SupportedLanguage, (src: string, fp: string) => SymbolExtract[]> = {
-  scala: extractScala,
-  lua: extractLua,
-  zig: extractZig,
-  powershell: extractPowershell,
-  elixir: extractElixir,
-};
-
-export function extractSymbolsForLanguage(
-  source: string,
-  filePath: string,
-  language: SupportedLanguage,
-): SymbolExtract[] {
-  return DISPATCH[language]?.(source, filePath) ?? [];
-}
-
-export const LANGUAGE_EXTENSIONS: Record<string, SupportedLanguage> = {
-  '.scala': 'scala',
-  '.sc': 'scala',
-  '.lua': 'lua',
-  '.zig': 'zig',
-  '.ps1': 'powershell',
-  '.psm1': 'powershell',
-  '.ex': 'elixir',
-  '.exs': 'elixir',
-};

package/src/parsers/loader.ts

@@ -1,149 +0,0 @@
-import { createRequire } from 'module';
-import Parser from 'tree-sitter';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-const parserCache = new Map<string, Parser>();
-const configCache = new Map<string, LanguageConfig>();
-
-async function loadConfig(ext: string): Promise<LanguageConfig | null> {
-  if (configCache.has(ext)) return configCache.get(ext)!;
-
-  let config: LanguageConfig | null = null;
-  if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs') {
-    const { typescriptConfig } = await import('./typescript.js');
-    config = typescriptConfig;
-  } else if (ext === '.py') {
-    const { pythonConfig } = await import('./python.js');
-    config = pythonConfig;
-  } else if (ext === '.go') {
-    const { goConfig } = await import('./go.js');
-    config = goConfig;
-  } else if (ext === '.rs') {
-    const { rustConfig } = await import('./rust.js');
-    config = rustConfig;
-  } else if (ext === '.java') {
-    const { javaConfig } = await import('./java.js');
-    config = javaConfig;
-  } else if (ext === '.c' || ext === '.h') {
-    const { cConfig } = await import('./c.js');
-    config = cConfig;
-  } else if (ext === '.cpp' || ext === '.cc' || ext === '.cxx' || ext === '.hpp' || ext === '.hxx') {
-    const { cppConfig } = await import('./cpp.js');
-    config = cppConfig;
-  } else if (ext === '.cs') {
-    const { csharpConfig } = await import('./csharp.js');
-    config = csharpConfig;
-  } else if (ext === '.rb') {
-    const { rubyConfig } = await import('./ruby.js');
-    config = rubyConfig;
-  } else if (ext === '.swift') {
-    const { swiftConfig } = await import('./swift.js');
-    config = swiftConfig;
-  } else if (ext === '.php') {
-    const { phpConfig } = await import('./php.js');
-    config = phpConfig;
-  } else if (ext === '.vue') {
-    const { vueConfig } = await import('./vue.js');
-    config = vueConfig;
-  } else if (ext === '.kt' || ext === '.kts') {
-    const { kotlinConfig } = await import('./kotlin.js');
-    config = kotlinConfig;
-  } else if (ext === '.dart') {
-    const { dartConfig } = await import('./dart.js');
-    config = dartConfig;
-  }
-
-  if (config) {
-    for (const e of config.extensions) configCache.set(e, config);
-  }
-  return config;
-}
-
-export async function getParser(ext: string): Promise<{ parser: Parser; config: LanguageConfig } | null> {
-  const config = await loadConfig(ext);
-  if (!config) return null;
-
-  if (parserCache.has(ext)) {
-    return { parser: parserCache.get(ext)!, config };
-  }
-
-  try {
-    const lang = config.getLanguage();
-    if (!lang) throw new Error('getLanguage() returned undefined');
-    const parser = new Parser();
-    parser.setLanguage(lang);
-    parserCache.set(ext, parser);
-    return { parser, config };
-  } catch {
-    // Grammar unavailable at runtime (ABI mismatch, native build failure, etc.) — skip silently.
-    return null;
-  }
-}
-
-export function isSupportedExtension(ext: string): boolean {
-  const supported = [
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-    '.py', '.go', '.rs', '.java',
-    '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx',
-    '.cs', '.rb', '.swift', '.php', '.vue',
-    '.kt', '.kts', '.dart',
-  ];
-  return supported.includes(ext);
-}
-
-export function getLanguageForExt(ext: string): string {
-  const map: Record<string, string> = {
-    '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript',
-    '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
-    '.py': 'python', '.go': 'go', '.rs': 'rust', '.java': 'java',
-    '.c': 'c', '.h': 'c',
-    '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.hpp': 'cpp', '.hxx': 'cpp',
-    '.cs': 'csharp', '.rb': 'ruby', '.swift': 'swift', '.php': 'php', '.vue': 'vue',
-    '.kt': 'kotlin', '.kts': 'kotlin', '.dart': 'dart',
-  };
-  return map[ext] ?? 'unknown';
-}
-
-export interface ParseResult {
-  nodes: import('../types.js').MonographNode[];
-  edges: import('../types.js').MonographEdge[];
-  parseErrors: string[];
-}
-
-export async function parseFile(
-  absolutePath: string,
-  sourceText: string,
-  repoRelativePath: string,
-): Promise<ParseResult> {
-  const ext = absolutePath.slice(absolutePath.lastIndexOf('.'));
-  const entry = await getParser(ext);
-  if (!entry) return { nodes: [], edges: [], parseErrors: [] };
-
-  const { parser, config } = entry;
-  try {
-    // For .vue files using the TypeScript fallback grammar, extract only the <script> block
-    // so the TypeScript parser does not choke on the HTML <template> and <style> sections.
-    let source = sourceText;
-    if (ext === '.vue') {
-      let vueGrammarAvailable = false;
-      try {
-        require('tree-sitter-vue');
-        vueGrammarAvailable = true;
-      } catch {
-        vueGrammarAvailable = false;
-      }
-      if (!vueGrammarAvailable) {
-        const { extractVueScriptContent } = await import('./vue.js');
-        const extracted = extractVueScriptContent(sourceText);
-        source = extracted.content || sourceText;
-      }
-    }
-    const tree = parser.parse(source);
-    const { extractSymbols } = await import('./extractor.js');
-    return extractSymbols(tree, source, repoRelativePath, config, ext);
-  } catch (err) {
-    return { nodes: [], edges: [], parseErrors: [`${repoRelativePath}: ${err}`] };
-  }
-}

package/src/parsers/named-bindings.ts

@@ -1,63 +0,0 @@
-export type BindingLanguage = 'typescript' | 'javascript' | 'python' | 'java' | 'kotlin' | 'go' | 'rust';
-
-export interface NamedBinding {
-  decoratorName: string;
-  targetName: string | null;
-  hasArguments: boolean;
-  line: number;
-  filePath: string;
-}
-
-const TS_DECORATOR_RE = /^([ \t]*)@([\w.]+)([ \t]*\()?/gm;
-const PY_DECORATOR_RE = /^([ \t]*)@([\w.]+)([ \t]*\()?/gm;
-const JAVA_ANNOTATION_RE = /^([ \t]*)@([A-Z]\w*)([ \t]*\()?/gm;
-
-function extractWithRegex(
-  source: string,
-  filePath: string,
-  re: RegExp,
-): NamedBinding[] {
-  const results: NamedBinding[] = [];
-  const lines = source.split('\n');
-  re.lastIndex = 0;
-
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(source)) !== null) {
-    const charsBefore = source.slice(0, m.index);
-    const lineNum = (charsBefore.match(/\n/g)?.length ?? 0) + 1;
-    const nextLine = lines[lineNum] ?? '';
-
-    let targetName: string | null = null;
-    const targetMatch = /(?:class|def|function|public|private|protected|export)\s+(\w+)/.exec(nextLine);
-    if (targetMatch) targetName = targetMatch[1] ?? null;
-
-    results.push({
-      decoratorName: m[2]!,
-      targetName,
-      hasArguments: !!m[3]?.trim(),
-      line: lineNum,
-      filePath,
-    });
-  }
-
-  return results;
-}
-
-export function extractNamedBindings(
-  source: string,
-  filePath: string,
-  language: BindingLanguage,
-): NamedBinding[] {
-  switch (language) {
-    case 'typescript':
-    case 'javascript':
-      return extractWithRegex(source, filePath, TS_DECORATOR_RE);
-    case 'python':
-      return extractWithRegex(source, filePath, PY_DECORATOR_RE);
-    case 'java':
-    case 'kotlin':
-      return extractWithRegex(source, filePath, JAVA_ANNOTATION_RE);
-    default:
-      return [];
-  }
-}

package/src/parsers/php.ts

@@ -1,37 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const phpConfig: LanguageConfig = {
-  name: 'php',
-  extensions: ['.php'],
-  treeSitterModule: 'tree-sitter-php',
-  getLanguage: () => {
-    const mod = require('tree-sitter-php');
-    // tree-sitter-php exports { php, php_only } — use the full PHP grammar
-    return mod.php as import('tree-sitter').Language;
-  },
-  classNodeTypes: new Set(['class_declaration']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set(['function_definition']),
-  methodNodeTypes: new Set(['method_declaration']),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set(['interface_declaration']),
-  importNodeTypes: new Set(['namespace_use_declaration']),
-  callNodeTypes: new Set(['function_call_expression', 'member_call_expression']),
-  decoratorNodeTypes: new Set([]),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    // use App\Models\User; → extract qualified name
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i)!;
-      if (c.type === 'namespace_use_clause') {
-        return c.text.trim() || null;
-      }
-    }
-    return null;
-  },
-  exportDetector: (_node, _source) => true,
-};

package/src/parsers/python.ts

@@ -1,26 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const pythonConfig: LanguageConfig = {
-  name: 'python',
-  extensions: ['.py'],
-  treeSitterModule: 'tree-sitter-python',
-  getLanguage: () => require('tree-sitter-python'),
-  classNodeTypes: new Set(['class_definition']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set([]),
-  functionNodeTypes: new Set(['function_definition']),
-  methodNodeTypes: new Set(['function_definition']),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set([]),
-  importNodeTypes: new Set(['import_statement', 'import_from_statement']),
-  callNodeTypes: new Set(['call']),
-  decoratorNodeTypes: new Set(['decorator']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    const moduleNode = node.childForFieldName('module_name') ?? node.child(1);
-    return moduleNode?.text ?? null;
-  },
-};

package/src/parsers/ruby.ts

@@ -1,39 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const rubyConfig: LanguageConfig = {
-  name: 'ruby',
-  extensions: ['.rb'],
-  treeSitterModule: 'tree-sitter-ruby',
-  getLanguage: () => require('tree-sitter-ruby').language as import('tree-sitter').Language,
-  classNodeTypes: new Set(['class']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set([]),
-  functionNodeTypes: new Set(['method']),
-  methodNodeTypes: new Set(['method']),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set(['module']),
-  // Ruby imports: require 'json' is a call expression at the top level
-  importNodeTypes: new Set(['call']),
-  callNodeTypes: new Set(['call']),
-  decoratorNodeTypes: new Set([]),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    // Only extract 'require' and 'require_relative' calls
-    const receiver = node.child(0);
-    if (receiver?.text !== 'require' && receiver?.text !== 'require_relative') return null;
-    const args = node.childForFieldName('arguments') ?? node.child(1);
-    if (!args) return null;
-    // First argument is a string node
-    for (let i = 0; i < args.childCount; i++) {
-      const c = args.child(i)!;
-      if (c.type === 'string') {
-        return c.text.replace(/['"]/g, '');
-      }
-    }
-    return null;
-  },
-  exportDetector: (_node, _source) => true,
-};

package/src/parsers/rust.ts

@@ -1,25 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const rustConfig: LanguageConfig = {
-  name: 'rust',
-  extensions: ['.rs'],
-  treeSitterModule: 'tree-sitter-rust',
-  getLanguage: () => require('tree-sitter-rust'),
-  classNodeTypes: new Set([]),
-  structNodeTypes: new Set(['struct_item']),
-  enumNodeTypes: new Set(['enum_item']),
-  functionNodeTypes: new Set(['function_item']),
-  methodNodeTypes: new Set(['function_item']),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set(['trait_item']),
-  importNodeTypes: new Set(['use_declaration']),
-  callNodeTypes: new Set(['call_expression', 'method_call_expression']),
-  decoratorNodeTypes: new Set(['attribute_item']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    return node.text.replace(/^use\s+/, '').replace(/;$/, '').trim();
-  },
-};

package/src/parsers/swift.ts

@@ -1,28 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const swiftConfig: LanguageConfig = {
-  name: 'swift',
-  extensions: ['.swift'],
-  treeSitterModule: 'tree-sitter-swift',
-  getLanguage: () => require('tree-sitter-swift').language as import('tree-sitter').Language,
-  classNodeTypes: new Set(['class_declaration']),
-  structNodeTypes: new Set(['struct_declaration']),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set(['function_declaration']),
-  methodNodeTypes: new Set(['function_declaration']),
-  constructorNodeTypes: new Set(['init_declaration']),
-  interfaceNodeTypes: new Set(['protocol_declaration']),
-  importNodeTypes: new Set(['import_declaration']),
-  callNodeTypes: new Set(['call_expression']),
-  decoratorNodeTypes: new Set(['attribute']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    // import Foundation → last child is identifier
-    const last = node.child(node.childCount - 1);
-    return last?.text ?? null;
-  },
-  exportDetector: (_node, _source) => true,
-};

package/src/parsers/typescript.ts

@@ -1,41 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const typescriptConfig: LanguageConfig = {
-  name: 'typescript',
-  extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
-  treeSitterModule: 'tree-sitter-typescript',
-  getLanguage: () => {
-    const ts = require('tree-sitter-typescript');
-    return ts.typescript;
-  },
-  classNodeTypes: new Set(['class_declaration', 'class']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set([
-    'function_declaration', 'function', 'arrow_function',
-    'generator_function_declaration', 'generator_function',
-  ]),
-  methodNodeTypes: new Set(['method_definition', 'method_signature']),
-  constructorNodeTypes: new Set(['constructor']),
-  interfaceNodeTypes: new Set(['interface_declaration', 'type_alias_declaration']),
-  importNodeTypes: new Set(['import_statement', 'import_declaration']),
-  callNodeTypes: new Set(['call_expression', 'new_expression']),
-  decoratorNodeTypes: new Set(['decorator']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i)!;
-      if (child.type === 'string') {
-        return child.text.replace(/['"]/g, '');
-      }
-    }
-    return null;
-  },
-  exportDetector: (node, _source) => {
-    const parent = node.parent;
-    return parent?.type === 'export_statement' || parent?.type === 'export_default_declaration';
-  },
-};

package/src/parsers/vue.ts

@@ -1,79 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-/**
- * Vue SFC parser.
- *
- * tree-sitter-vue (v0.2.1) fails to build on many platforms due to native compilation
- * issues. This module provides a regex-based fallback that strips <template> and <style>
- * blocks then delegates <script lang="ts"> content to the TypeScript node-type sets.
- *
- * The LanguageConfig below is configured to match TypeScript/JavaScript symbol types
- * so the extractor correctly labels Classes, Functions, and Methods when fed the
- * extracted script content.
- */
-
-const require = createRequire(import.meta.url);
-
-function getLanguage(): import('tree-sitter').Language {
-  // Try tree-sitter-vue first; fall through to TypeScript grammar if unavailable.
-  try {
-    const mod = require('tree-sitter-vue');
-    const lang = (mod.default ?? mod) as import('tree-sitter').Language;
-    return lang;
-  } catch {
-    // Fall back to TypeScript grammar for script block parsing.
-    const ts = require('tree-sitter-typescript');
-    return ts.typescript as import('tree-sitter').Language;
-  }
-}
-
-export const vueConfig: LanguageConfig = {
-  name: 'vue',
-  extensions: ['.vue'],
-  treeSitterModule: 'tree-sitter-vue',
-  getLanguage,
-  // Use TypeScript-compatible node types since we parse the extracted script block
-  classNodeTypes: new Set(['class_declaration', 'class']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set([
-    'function_declaration', 'function', 'arrow_function',
-    'generator_function_declaration', 'generator_function',
-  ]),
-  methodNodeTypes: new Set(['method_definition', 'method_signature']),
-  constructorNodeTypes: new Set(['constructor']),
-  interfaceNodeTypes: new Set(['interface_declaration', 'type_alias_declaration']),
-  importNodeTypes: new Set(['import_statement', 'import_declaration']),
-  callNodeTypes: new Set(['call_expression', 'new_expression']),
-  decoratorNodeTypes: new Set(['decorator']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i)!;
-      if (child.type === 'string') {
-        return child.text.replace(/['"]/g, '');
-      }
-    }
-    return null;
-  },
-  exportDetector: (node, _source) => {
-    const parent = node.parent;
-    return parent?.type === 'export_statement' || parent?.type === 'export_default_declaration';
-  },
-};
-
-/**
- * Extracts the <script> block content from a Vue SFC source string.
- * Returns the inner content (stripping the <script> tags) and whether it is TypeScript.
- */
-export function extractVueScriptContent(source: string): { content: string; isTypeScript: boolean } {
-  // Match <script lang="ts"> or <script setup lang="ts"> or just <script>
-  const tsMatch = source.match(/<script(?:\s+setup)?\s+lang=["']ts["'][^>]*>([\s\S]*?)<\/script>/i);
-  if (tsMatch) return { content: tsMatch[1], isTypeScript: true };
-
-  const jsMatch = source.match(/<script(?:\s+setup)?[^>]*>([\s\S]*?)<\/script>/i);
-  if (jsMatch) return { content: jsMatch[1], isTypeScript: false };
-
-  return { content: '', isTypeScript: false };
-}