@monoes/monograph 1.5.6 → 1.5.8

package/src/migrate/jsonc-gen.ts

@@ -1,38 +0,0 @@
-const KEY_ORDER = ['entry','ignorePatterns','ignoreDependencies','ignoreExportsUsedInFile','rules','duplicates'];
-
-function indentJsonValue(json: string, spaces: number): string {
-  const indent = ' '.repeat(spaces);
-  const lines = json.split('\n');
-  if (lines.length <= 1) return json;
-  const [first, ...rest] = lines;
-  return [first, ...rest.map(l => indent + l)].join('\n');
-}
-
-export function generateJsonc(config: Record<string, unknown>, sources: string[]): string {
-  const schema = 'https://raw.githubusercontent.com/fallow-rs/fallow/main/schema.json';
-  const entries = Object.entries(config).sort(([a], [b]) => {
-    const ai = KEY_ORDER.indexOf(a), bi = KEY_ORDER.indexOf(b);
-    return (ai === -1 ? Infinity : ai) - (bi === -1 ? Infinity : bi);
-  });
-  const lines: string[] = [
-    '{',
-    `  "$schema": "${schema}",`,
-    `  // Migrated from ${sources.join(', ')}`,
-  ];
-  for (let i = 0; i < entries.length; i++) {
-    const [key, value] = entries[i];
-    const comma = i < entries.length - 1 ? ',' : '';
-    const serialized = JSON.stringify(value, null, 2);
-    const indented = indentJsonValue(serialized, 2);
-    lines.push(`  "${key}": ${indented}${comma}`);
-  }
-  lines.push('}', '');
-  return lines.join('\n');
-}
-
-export function parseJsoncComments(input: string): Record<string, unknown> {
-  const stripped = input.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '');
-  return JSON.parse(stripped) as Record<string, unknown>;
-}
-
-export { indentJsonValue };

package/src/migrate/knip.ts

@@ -1,126 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-
-export interface MigrationWarning {
-  field: string;
-  message: string;
-  knipValue: unknown;
-}
-
-export interface KnipMigrationResult {
-  monographConfig: Record<string, unknown>;   // .monographrc.json content
-  warnings: MigrationWarning[];
-  inputFile: string;
-}
-
-const KNIP_FIELD_MAP: Record<string, string> = {
-  entry: 'entryPoints',
-  project: 'include',
-  ignore: 'exclude',
-  ignoreDependencies: 'ignoreDependencies',
-  workspaces: 'workspaces',
-  rules: 'rules',
-};
-
-export function migrateFromKnip(knipConfigPath: string): KnipMigrationResult {
-  if (!existsSync(knipConfigPath)) {
-    throw new Error(`Knip config not found: ${knipConfigPath}`);
-  }
-
-  const raw = readFileSync(knipConfigPath, 'utf-8');
-  const warnings: MigrationWarning[] = [];
-  const monographConfig: Record<string, unknown> = {};
-
-  let knipConfig: Record<string, unknown>;
-  try {
-    knipConfig = JSON.parse(raw);
-  } catch {
-    warnings.push({
-      field: '<file>',
-      message: 'Failed to parse config as JSON; only plain JSON configs are supported (not TypeScript/JS configs)',
-      knipValue: raw.slice(0, 100),
-    });
-    return { monographConfig, warnings, inputFile: knipConfigPath };
-  }
-
-  for (const [knipKey, knipValue] of Object.entries(knipConfig)) {
-    const monographKey = KNIP_FIELD_MAP[knipKey];
-    if (monographKey) {
-      if (knipKey === 'rules') {
-        // Map rule names; warn on unknown rules
-        if (knipValue && typeof knipValue === 'object' && !Array.isArray(knipValue)) {
-          const mappedRules: Record<string, unknown> = {};
-          for (const [ruleName, ruleValue] of Object.entries(knipValue as Record<string, unknown>)) {
-            mappedRules[ruleName] = ruleValue;
-          }
-          monographConfig[monographKey] = mappedRules;
-        } else {
-          warnings.push({
-            field: knipKey,
-            message: 'Expected rules to be an object mapping rule names to values',
-            knipValue,
-          });
-        }
-      } else {
-        monographConfig[monographKey] = knipValue;
-      }
-    } else {
-      warnings.push({
-        field: knipKey,
-        message: 'No equivalent in monograph config',
-        knipValue,
-      });
-    }
-  }
-
-  return { monographConfig, warnings, inputFile: knipConfigPath };
-}
-
-// ── Round 10: TOML migration output + JSONC reader ────────────────────────────
-
-export function stripJsoncComments(input: string): string {
-  const lines = input.split('\n');
-  const out: string[] = [];
-  let inBlock = false;
-  for (const line of lines) {
-    let result = '';
-    let i = 0;
-    while (i < line.length) {
-      if (inBlock) {
-        if (line[i] === '*' && line[i + 1] === '/') { inBlock = false; i += 2; } else { i++; }
-      } else if (line[i] === '/' && line[i + 1] === '/') {
-        break;
-      } else if (line[i] === '/' && line[i + 1] === '*') {
-        inBlock = true; i += 2;
-      } else {
-        result += line[i++];
-      }
-    }
-    out.push(result);
-  }
-  return out.join('\n');
-}
-
-export function parseJsoncString(input: string): Record<string, unknown> {
-  return JSON.parse(stripJsoncComments(input)) as Record<string, unknown>;
-}
-
-export function generateTomlFromMigration(config: Record<string, unknown>): string {
-  const lines: string[] = [];
-  for (const [key, val] of Object.entries(config)) {
-    if (Array.isArray(val)) {
-      const items = val.map(v => typeof v === 'string' ? `"${v}"` : String(v)).join(', ');
-      lines.push(`${key} = [${items}]`);
-    } else if (typeof val === 'boolean' || typeof val === 'number') {
-      lines.push(`${key} = ${val}`);
-    } else if (typeof val === 'string') {
-      lines.push(`${key} = "${val}"`);
-    } else if (typeof val === 'object' && val !== null) {
-      lines.push(`[${key}]`);
-      for (const [k2, v2] of Object.entries(val as Record<string, unknown>)) {
-        if (typeof v2 === 'string') lines.push(`${k2} = "${v2}"`);
-        else if (typeof v2 === 'boolean' || typeof v2 === 'number') lines.push(`${k2} = ${v2}`);
-      }
-    }
-  }
-  return lines.join('\n');
-}

package/src/migrate/toml-gen.ts

@@ -1,48 +0,0 @@
-export function generateToml(config: Record<string, unknown>, sources: string[]): string {
-  const lines: string[] = [`# Migrated from ${sources.join(', ')}\n`];
-  const simpleArrayKeys = ['entry','ignorePatterns','ignoreDependencies'];
-
-  for (const key of simpleArrayKeys) {
-    const arr = config[key];
-    if (Array.isArray(arr)) {
-      const items = (arr as unknown[]).filter(v => typeof v === 'string').map(v => `"${v as string}"`);
-      if (items.length > 0) lines.push(`${key} = [${items.join(', ')}]`);
-    }
-  }
-
-  const ieuf = config['ignoreExportsUsedInFile'];
-  if (typeof ieuf === 'boolean') {
-    lines.push(`ignoreExportsUsedInFile = ${ieuf}`);
-  } else if (ieuf && typeof ieuf === 'object' && !Array.isArray(ieuf)) {
-    const obj = ieuf as Record<string, boolean>;
-    const parts = Object.entries(obj).filter(([, v]) => typeof v === 'boolean').map(([k, v]) => `${k} = ${v}`);
-    if (parts.length) lines.push(`ignoreExportsUsedInFile = { ${parts.join(', ')} }`);
-  }
-
-  const rules = config['rules'];
-  if (rules && typeof rules === 'object' && !Array.isArray(rules)) {
-    const entries = Object.entries(rules as Record<string, unknown>).filter(([, v]) => typeof v === 'string');
-    if (entries.length) {
-      lines.push('\n[rules]');
-      for (const [k, v] of entries) lines.push(`${k} = "${v as string}"`);
-    }
-  }
-
-  const dupes = config['duplicates'];
-  if (dupes && typeof dupes === 'object' && !Array.isArray(dupes)) {
-    const entries = Object.entries(dupes as Record<string, unknown>);
-    if (entries.length) {
-      lines.push('\n[duplicates]');
-      for (const [k, v] of entries) {
-        if (typeof v === 'number') lines.push(`${k} = ${v}`);
-        else if (typeof v === 'boolean') lines.push(`${k} = ${v}`);
-        else if (typeof v === 'string') lines.push(`${k} = "${v}"`);
-        else if (Array.isArray(v)) {
-          const items = (v as unknown[]).filter(x => typeof x === 'string').map(x => `"${x as string}"`);
-          lines.push(`${k} = [${items.join(', ')}]`);
-        }
-      }
-    }
-  }
-  return lines.join('\n') + '\n';
-}

package/src/parsers/c.ts

@@ -1,31 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const cConfig: LanguageConfig = {
-  name: 'c',
-  extensions: ['.c', '.h'],
-  treeSitterModule: 'tree-sitter-c',
-  getLanguage: () => require('tree-sitter-c').language as import('tree-sitter').Language,
-  // struct_specifier and enum_specifier expose a 'name' field with the type name.
-  // function_declarator (nested in function_definition) has a 'declarator' field for the
-  // function identifier, but no 'name' field. Using nameField 'name' produces clean names
-  // for structs/enums and falls back to node text for functions (acceptable).
-  classNodeTypes: new Set([]),
-  structNodeTypes: new Set(['struct_specifier']),
-  enumNodeTypes: new Set(['enum_specifier']),
-  // function_declarator is nested inside function_definition and carries the real function name
-  functionNodeTypes: new Set(['function_declarator']),
-  methodNodeTypes: new Set([]),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set(['type_definition']),
-  importNodeTypes: new Set(['preproc_include']),
-  callNodeTypes: new Set(['call_expression']),
-  decoratorNodeTypes: new Set([]),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    const pathNode = node.childForFieldName('path') ?? node.child(1);
-    return pathNode?.text.replace(/[<>"]/g, '') ?? null;
-  },
-};

package/src/parsers/cpp.ts

@@ -1,29 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const cppConfig: LanguageConfig = {
-  name: 'cpp',
-  extensions: ['.cpp', '.cc', '.cxx', '.hpp', '.hxx'],
-  treeSitterModule: 'tree-sitter-cpp',
-  getLanguage: () => require('tree-sitter-cpp').language as import('tree-sitter').Language,
-  classNodeTypes: new Set(['class_specifier']),
-  structNodeTypes: new Set(['struct_specifier']),
-  enumNodeTypes: new Set(['enum_specifier']),
-  // function_declarator is nested inside function_definition and carries the real function name.
-  // Using nameField 'declarator' extracts the identifier directly.
-  functionNodeTypes: new Set(['function_declarator']),
-  methodNodeTypes: new Set([]),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set([]),
-  importNodeTypes: new Set(['preproc_include']),
-  callNodeTypes: new Set(['call_expression']),
-  decoratorNodeTypes: new Set([]),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    const pathNode = node.childForFieldName('path') ?? node.child(1);
-    return pathNode?.text.replace(/[<>"]/g, '') ?? null;
-  },
-  exportDetector: (_node, _source) => false,
-};

package/src/parsers/csharp.ts

@@ -1,43 +0,0 @@
-import { createRequire } from 'module';
-import { dirname, join } from 'path';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-function getLanguage(): import('tree-sitter').Language {
-  // tree-sitter-c-sharp@0.23+ uses an ESM module with top-level await, which
-  // cannot be loaded via require(). Load the prebuilt native binding directly.
-  try {
-    const pkgPath = require.resolve('tree-sitter-c-sharp/package.json');
-    const pkgDir = dirname(pkgPath);
-    const binPath = join(pkgDir, 'prebuilds', `${process.platform}-${process.arch}`, 'tree-sitter-c-sharp.node');
-    const mod = require(binPath);
-    return mod.language as import('tree-sitter').Language;
-  } catch (err) {
-    throw new Error(`tree-sitter-c-sharp unavailable: ${err}`);
-  }
-}
-
-export const csharpConfig: LanguageConfig = {
-  name: 'csharp',
-  extensions: ['.cs'],
-  treeSitterModule: 'tree-sitter-c-sharp',
-  getLanguage,
-  classNodeTypes: new Set(['class_declaration']),
-  structNodeTypes: new Set(['struct_declaration']),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set(['local_function_statement']),
-  methodNodeTypes: new Set(['method_declaration']),
-  constructorNodeTypes: new Set(['constructor_declaration']),
-  interfaceNodeTypes: new Set(['interface_declaration']),
-  importNodeTypes: new Set(['using_directive']),
-  callNodeTypes: new Set(['invocation_expression', 'object_creation_expression']),
-  decoratorNodeTypes: new Set(['attribute']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    // using System.IO; → "System.IO"
-    const last = node.child(node.childCount - 2);
-    return last?.text ?? null;
-  },
-  exportDetector: (_node, _source) => true,
-};

package/src/parsers/dart.ts

@@ -1,39 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const dartConfig: LanguageConfig = {
-  name: 'dart',
-  extensions: ['.dart'],
-  treeSitterModule: 'tree-sitter-dart',
-  getLanguage: () => {
-    const mod = require('tree-sitter-dart');
-    return (mod.default ?? mod) as import('tree-sitter').Language;
-  },
-  classNodeTypes: new Set(['class_definition']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set(['function_signature', 'function_declaration']),
-  methodNodeTypes: new Set(['method_signature', 'method_declaration']),
-  constructorNodeTypes: new Set(['constructor_signature']),
-  interfaceNodeTypes: new Set([]),
-  importNodeTypes: new Set(['import_or_export']),
-  callNodeTypes: new Set(['invocation_expression']),
-  decoratorNodeTypes: new Set(['metadata']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    // import 'package:flutter/material.dart'; → extract string content
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i)!;
-      if (c.type === 'uri') {
-        return c.text.replace(/['"]/g, '') ?? null;
-      }
-      if (c.type === 'string_literal' || c.type === 'string') {
-        return c.text.replace(/['"]/g, '') ?? null;
-      }
-    }
-    return null;
-  },
-  exportDetector: (_node, _source) => true,
-};

package/src/parsers/extractor.ts

@@ -1,202 +0,0 @@
-import type Parser from 'tree-sitter';
-import type { LanguageConfig } from './language-config.js';
-import type { MonographNode, MonographEdge } from '../types.js';
-import { makeId, toNormLabel, CONFIDENCE_SCORE } from '../types.js';
-import type { ParseResult } from './loader.js';
-
-export function extractSymbols(
-  tree: Parser.Tree,
-  source: string,
-  repoPath: string,
-  config: LanguageConfig,
-  ext: string,
-): ParseResult {
-  const nodes: MonographNode[] = [];
-  const edges: MonographEdge[] = [];
-  const parseErrors: string[] = [];
-  const language = config.name;
-
-  function nodeId(name: string, filePath: string, extra?: string): string {
-    return makeId(filePath.replace(/\//g, '_'), name, extra ?? '');
-  }
-
-  const fileNodeId = makeId(repoPath.replace(/\//g, '_'), 'file');
-  nodes.push({
-    id: fileNodeId,
-    label: 'File',
-    name: repoPath.split('/').pop() ?? repoPath,
-    normLabel: toNormLabel(repoPath.split('/').pop() ?? repoPath),
-    filePath: repoPath,
-    isExported: false,
-    language,
-  });
-
-  function walk(node: Parser.SyntaxNode, parentId?: string): void {
-    const { type } = node;
-
-    if (config.importNodeTypes.has(type)) {
-      handleImport(node, fileNodeId, source, config, edges, repoPath);
-      return;
-    }
-
-    const isClass = config.classNodeTypes.has(type);
-    const isStruct = config.structNodeTypes.has(type);
-    const isEnum = config.enumNodeTypes.has(type);
-    const isFunction = config.functionNodeTypes.has(type);
-    const isMethod = config.methodNodeTypes.has(type);
-    const isInterface = config.interfaceNodeTypes.has(type);
-    const isConstructor = config.constructorNodeTypes.has(type);
-
-    if (isClass || isStruct || isEnum || isFunction || isMethod || isInterface || isConstructor) {
-      const nameNode = node.childForFieldName(config.nameField);
-      const name = nameNode?.text ?? node.text.split('\n')[0].slice(0, 40);
-      // When a node type is in BOTH functionNodeTypes and methodNodeTypes (e.g. Python
-      // `function_definition`), check parent chain to disambiguate: a function_definition
-      // whose grandparent is a class_definition is a method, otherwise it's a function.
-      const isBothFunctionAndMethod = isFunction && isMethod;
-      const isActuallyMethod = isBothFunctionAndMethod
-        ? config.classNodeTypes.has(node.parent?.parent?.type ?? '')
-        : isMethod;
-      const label = isClass ? 'Class' : isStruct ? 'Struct' : isEnum ? 'Enum' :
-                    isInterface ? 'Interface' : isActuallyMethod ? 'Method' :
-                    isConstructor ? 'Constructor' : 'Function';
-      const id = nodeId(name, repoPath, label.toLowerCase());
-      const isExported = config.exportDetector
-        ? config.exportDetector(node, source)
-        : isNodeExported(node, source);
-
-      nodes.push({
-        id, label, name,
-        normLabel: toNormLabel(name),
-        filePath: repoPath,
-        startLine: node.startPosition.row + 1,
-        endLine: node.endPosition.row + 1,
-        isExported, language,
-      });
-
-      const containerId = parentId ?? fileNodeId;
-      edges.push({
-        id: makeId(containerId, id, 'contains'),
-        sourceId: containerId, targetId: id,
-        relation: 'CONTAINS',
-        confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-      });
-
-      handleInheritance(node, id, edges, repoPath, config, source);
-
-      for (let i = 0; i < node.childCount; i++) {
-        walk(node.child(i)!, id);
-      }
-      return;
-    }
-
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i)!, parentId);
-    }
-  }
-
-  walk(tree.rootNode);
-
-  // Re-export detection: export { ... } from '...' or export * from '...'
-  // These create RE_EXPORTS edges from this file to the re-exported module.
-  // Only applicable for TypeScript/JavaScript files.
-  if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs') {
-    const reExportPattern = /export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/g;
-    let reMatch: RegExpExecArray | null;
-    while ((reMatch = reExportPattern.exec(source)) !== null) {
-      const targetPath = reMatch[1];
-      // Use same placeholder convention as handleImport so cross-file resolution applies
-      const targetId = makeId('import', targetPath);
-      edges.push({
-        id: makeId(fileNodeId, targetId, 'reexports'),
-        sourceId: fileNodeId,
-        targetId,
-        relation: 'RE_EXPORTS',
-        confidence: 'EXTRACTED',
-        confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-      });
-    }
-  }
-
-  return { nodes, edges, parseErrors };
-}
-
-function isNodeExported(node: Parser.SyntaxNode, _source: string): boolean {
-  const parent = node.parent;
-  if (!parent) return false;
-  return parent.type === 'export_statement' ||
-    parent.type === 'export_default_declaration';
-}
-
-function handleImport(
-  node: Parser.SyntaxNode,
-  fileNodeId: string,
-  source: string,
-  config: LanguageConfig,
-  edges: MonographEdge[],
-  repoPath: string,
-): void {
-  const targetPath = config.importExtractor ? config.importExtractor(source, node) : null;
-  const targetId = makeId('import', targetPath ?? node.text.slice(0, 60));
-  edges.push({
-    id: makeId(fileNodeId, targetId, 'imports'),
-    sourceId: fileNodeId, targetId,
-    relation: 'IMPORTS',
-    confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-  });
-}
-
-function handleInheritance(
-  node: Parser.SyntaxNode,
-  nodeId: string,
-  edges: MonographEdge[],
-  _repoPath: string,
-  _config: LanguageConfig,
-  _source: string,
-): void {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i)!;
-    if (child.type === 'extends_clause') {
-      const targetId = makeId('import', child.text.replace(/extends?\s+/, '').trim());
-      edges.push({
-        id: makeId(nodeId, targetId, 'extends'),
-        sourceId: nodeId, targetId,
-        relation: 'EXTENDS',
-        confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-      });
-    }
-    if (child.type === 'implements_clause') {
-      const targetId = makeId('import', child.text.replace(/implements\s+/, '').trim());
-      edges.push({
-        id: makeId(nodeId, targetId, 'implements'),
-        sourceId: nodeId, targetId,
-        relation: 'IMPLEMENTS',
-        confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-      });
-    }
-    // class_heritage is the direct child; implements_clause is nested inside it
-    if (child.type === 'class_heritage') {
-      for (let j = 0; j < child.childCount; j++) {
-        const grandChild = child.child(j)!;
-        if (grandChild.type === 'extends_clause') {
-          const targetId = makeId('import', grandChild.text.replace(/extends?\s+/, '').trim());
-          edges.push({
-            id: makeId(nodeId, targetId, 'extends'),
-            sourceId: nodeId, targetId,
-            relation: 'EXTENDS',
-            confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-          });
-        }
-        if (grandChild.type === 'implements_clause') {
-          const targetId = makeId('import', grandChild.text.replace(/implements\s+/, '').trim());
-          edges.push({
-            id: makeId(nodeId, targetId, 'implements'),
-            sourceId: nodeId, targetId,
-            relation: 'IMPLEMENTS',
-            confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
-          });
-        }
-      }
-    }
-  }
-}

package/src/parsers/go.ts

@@ -1,27 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const goConfig: LanguageConfig = {
-  name: 'go',
-  extensions: ['.go'],
-  treeSitterModule: 'tree-sitter-go',
-  getLanguage: () => require('tree-sitter-go'),
-  classNodeTypes: new Set([]),
-  structNodeTypes: new Set(['type_spec']),
-  enumNodeTypes: new Set([]),
-  functionNodeTypes: new Set(['function_declaration']),
-  methodNodeTypes: new Set(['method_declaration']),
-  constructorNodeTypes: new Set([]),
-  interfaceNodeTypes: new Set(['interface_type']),
-  importNodeTypes: new Set(['import_declaration', 'import_spec']),
-  callNodeTypes: new Set(['call_expression']),
-  decoratorNodeTypes: new Set([]),
-  nameField: 'name',
-  packageScopeType: 'package_clause',
-  importExtractor: (_source, node) => {
-    const pathNode = node.childForFieldName('path') ?? node.child(1);
-    return pathNode?.text.replace(/['"]/g, '') ?? null;
-  },
-};

package/src/parsers/java.ts

@@ -1,27 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const javaConfig: LanguageConfig = {
-  name: 'java',
-  extensions: ['.java'],
-  treeSitterModule: 'tree-sitter-java',
-  getLanguage: () => require('tree-sitter-java'),
-  classNodeTypes: new Set(['class_declaration']),
-  structNodeTypes: new Set(['record_declaration']),
-  enumNodeTypes: new Set(['enum_declaration']),
-  functionNodeTypes: new Set([]),
-  methodNodeTypes: new Set(['method_declaration']),
-  constructorNodeTypes: new Set(['constructor_declaration']),
-  interfaceNodeTypes: new Set(['interface_declaration', 'annotation_type_declaration']),
-  importNodeTypes: new Set(['import_declaration']),
-  callNodeTypes: new Set(['method_invocation', 'object_creation_expression']),
-  decoratorNodeTypes: new Set(['annotation']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    const path = node.text.replace(/^import\s+(static\s+)?/, '').replace(/;$/, '').trim();
-    return path || null;
-  },
-  exportDetector: (_node, _source) => true,
-};

package/src/parsers/kotlin.ts

@@ -1,36 +0,0 @@
-import { createRequire } from 'module';
-import type { LanguageConfig } from './language-config.js';
-
-const require = createRequire(import.meta.url);
-
-export const kotlinConfig: LanguageConfig = {
-  name: 'kotlin',
-  extensions: ['.kt', '.kts'],
-  treeSitterModule: 'tree-sitter-kotlin',
-  getLanguage: () => {
-    const mod = require('tree-sitter-kotlin');
-    return (mod.language ?? mod) as import('tree-sitter').Language;
-  },
-  classNodeTypes: new Set(['class_declaration']),
-  structNodeTypes: new Set([]),
-  enumNodeTypes: new Set(['enum_class_declaration']),
-  functionNodeTypes: new Set(['function_declaration']),
-  methodNodeTypes: new Set(['function_declaration']),
-  constructorNodeTypes: new Set(['primary_constructor', 'secondary_constructor']),
-  interfaceNodeTypes: new Set(['interface_declaration']),
-  importNodeTypes: new Set(['import_header']),
-  callNodeTypes: new Set(['call_expression']),
-  decoratorNodeTypes: new Set(['annotation']),
-  nameField: 'name',
-  importExtractor: (_source, node) => {
-    // import com.example.Foo → extract the qualified identifier
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i)!;
-      if (c.type === 'identifier' || c.type === 'dot_qualified_expression') {
-        return c.text ?? null;
-      }
-    }
-    return null;
-  },
-  exportDetector: (_node, _source) => true,
-};