@monoes/monograph 1.5.6 → 1.5.8

package/src/analysis/coverage-gaps.ts

@@ -1,246 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export interface UntestedFile {
-  nodeId: string;
-  filePath: string;
-  reachabilityRole: string;   // 'runtime'
-  inDegree: number;           // from runtime files
-  reason: string;             // e.g. 'No test imports this file'
-}
-
-export interface UntestedExport {
-  nodeId: string;
-  name: string;
-  filePath: string | null;
-  startLine: number | null;
-  exportType: string;   // label
-}
-
-export interface CoverageGapsResult {
-  untestedFiles: UntestedFile[];
-  untestedExports: UntestedExport[];
-  fileCoveragePct: number;     // (runtime files reachable by tests) / (total runtime files) * 100
-  exportCoveragePct: number;
-  summary: string;
-}
-
-interface FileRow {
-  id: string;
-  file_path: string;
-}
-
-interface ImportEdgeRow {
-  source_id: string;
-  target_id: string;
-}
-
-interface ExportRow {
-  id: string;
-  name: string;
-  file_path: string | null;
-  start_line: number | null;
-  label: string;
-}
-
-interface InDegreeRow {
-  target_id: string;
-  cnt: number;
-}
-
-export function computeCoverageGaps(db: MonographDb): CoverageGapsResult {
-  // Runtime-reachable files
-  const runtimeFiles = db.prepare(
-    `SELECT id, file_path FROM nodes
-     WHERE label = 'File'
-       AND json_extract(properties, '$.reachabilityRole') = 'runtime'`
-  ).all() as FileRow[];
-
-  // Test entry points
-  const testFiles = db.prepare(
-    `SELECT id, file_path FROM nodes
-     WHERE label = 'File'
-       AND json_extract(properties, '$.reachabilityRole') = 'test'`
-  ).all() as FileRow[];
-
-  // All IMPORTS edges between files for BFS
-  const allImportEdges = db.prepare(
-    `SELECT e.source_id, e.target_id
-     FROM edges e
-     WHERE e.relation IN ('IMPORTS', 'RE_EXPORTS')
-       AND e.source_id IN (SELECT id FROM nodes WHERE label = 'File')
-       AND e.target_id IN (SELECT id FROM nodes WHERE label = 'File')`
-  ).all() as ImportEdgeRow[];
-
-  // Build forward adjacency for BFS
-  const forwardAdj = new Map<string, string[]>();
-  for (const edge of allImportEdges) {
-    let list = forwardAdj.get(edge.source_id);
-    if (!list) {
-      list = [];
-      forwardAdj.set(edge.source_id, list);
-    }
-    list.push(edge.target_id);
-  }
-
-  // BFS from test entry points
-  const testReachable = new Set<string>();
-  const queue: string[] = [];
-  for (const tf of testFiles) {
-    if (!testReachable.has(tf.id)) {
-      testReachable.add(tf.id);
-      queue.push(tf.id);
-    }
-  }
-
-  let head = 0;
-  while (head < queue.length) {
-    const current = queue[head++];
-    const neighbors = forwardAdj.get(current) ?? [];
-    for (const neighbor of neighbors) {
-      if (!testReachable.has(neighbor)) {
-        testReachable.add(neighbor);
-        queue.push(neighbor);
-      }
-    }
-  }
-
-  // Compute in-degree from runtime files only (not test files) so fan-in reflects
-  // real dependency weight, not test coverage depth.
-  const runtimeFileIdSet = new Set(runtimeFiles.map(rf => rf.id));
-  const inDegreeMap = new Map<string, number>();
-  for (const edge of allImportEdges) {
-    if (!runtimeFileIdSet.has(edge.source_id)) continue;
-    const current = inDegreeMap.get(edge.target_id) ?? 0;
-    inDegreeMap.set(edge.target_id, current + 1);
-  }
-
-  // Untested files = runtime files NOT in the test-reachable set
-  const untestedFiles: UntestedFile[] = [];
-  for (const rf of runtimeFiles) {
-    if (!testReachable.has(rf.id)) {
-      untestedFiles.push({
-        nodeId: rf.id,
-        filePath: rf.file_path,
-        reachabilityRole: 'runtime',
-        inDegree: inDegreeMap.get(rf.id) ?? 0,
-        reason: 'No test imports this file',
-      });
-    }
-  }
-
-  // All exported symbols
-  const allExportedRows = db.prepare(
-    `SELECT n.id, n.name, n.file_path, n.start_line, n.label
-     FROM nodes n
-     WHERE n.is_exported = 1
-       AND n.label IN ('Function','Class','Method','Interface','Const','TypeAlias','Enum','Variable')`
-  ).all() as ExportRow[];
-
-  // Runtime file IDs set for quick lookup
-  const runtimeFileIds = new Set(runtimeFiles.map(rf => rf.id));
-
-  // Map file_path -> file node id for runtime files
-  const runtimeFilePathToId = new Map<string, string>();
-  for (const rf of runtimeFiles) {
-    runtimeFilePathToId.set(rf.file_path, rf.id);
-  }
-
-  // Determine which file a symbol belongs to (by file_path)
-  const testedRuntimeFileIds = new Set<string>();
-  for (const rf of runtimeFiles) {
-    if (testReachable.has(rf.id)) {
-      testedRuntimeFileIds.add(rf.id);
-    }
-  }
-
-  const untestedExports: UntestedExport[] = [];
-  let totalRuntimeExports = 0;
-  let testedRuntimeExports = 0;
-
-  for (const exp of allExportedRows) {
-    if (!exp.file_path) continue;
-    const fileId = runtimeFilePathToId.get(exp.file_path);
-    if (!fileId) continue; // not a runtime file
-
-    totalRuntimeExports++;
-    if (testedRuntimeFileIds.has(fileId)) {
-      testedRuntimeExports++;
-    } else {
-      untestedExports.push({
-        nodeId: exp.id,
-        name: exp.name,
-        filePath: exp.file_path,
-        startLine: exp.start_line ?? null,
-        exportType: exp.label,
-      });
-    }
-  }
-
-  const totalRuntimeFiles = runtimeFiles.length;
-  const testedRuntimeFiles = runtimeFiles.filter(rf => testReachable.has(rf.id)).length;
-
-  const fileCoveragePct = totalRuntimeFiles > 0
-    ? (testedRuntimeFiles / totalRuntimeFiles) * 100
-    : 100;
-
-  const exportCoveragePct = totalRuntimeExports > 0
-    ? (testedRuntimeExports / totalRuntimeExports) * 100
-    : 100;
-
-  const summary = [
-    `${testedRuntimeFiles}/${totalRuntimeFiles} runtime files reachable by tests`,
-    `(${fileCoveragePct.toFixed(1)}% file coverage,`,
-    `${exportCoveragePct.toFixed(1)}% export coverage).`,
-    untestedFiles.length > 0
-      ? `${untestedFiles.length} untested file(s) found.`
-      : 'All runtime files are test-reachable.',
-  ].join(' ');
-
-  return {
-    untestedFiles,
-    untestedExports,
-    fileCoveragePct,
-    exportCoveragePct,
-    summary,
-  };
-}
-
-/** Format CoverageGapsResult as structured text with file:line hints for LLM navigation. */
-export function formatCoverageGaps(result: CoverageGapsResult, topN = 20): string {
-  const lines: string[] = [result.summary, ''];
-
-  if (result.untestedFiles.length > 0) {
-    // Sort untested files by inDegree descending — highest-impact first
-    const sorted = [...result.untestedFiles].sort((a, b) => b.inDegree - a.inDegree);
-    const shown = sorted.slice(0, topN);
-    lines.push(`Top untested files by import-count (${shown.length}/${result.untestedFiles.length} shown):`);
-    for (const f of shown) {
-      lines.push(`  ${f.filePath}  in-degree:${f.inDegree}`);
-    }
-    lines.push('');
-  }
-
-  if (result.untestedExports.length > 0) {
-    // Group untested exports by file
-    const byFile = new Map<string, UntestedExport[]>();
-    for (const exp of result.untestedExports) {
-      const key = exp.filePath ?? '(unknown)';
-      let group = byFile.get(key);
-      if (!group) { group = []; byFile.set(key, group); }
-      group.push(exp);
-    }
-
-    lines.push(`Untested exported symbols (${result.untestedExports.length}) grouped by file:`);
-    for (const [filePath, exports] of byFile) {
-      lines.push(`  ${filePath}`);
-      for (const exp of exports) {
-        const ref = exp.startLine != null ? `${filePath}:${exp.startLine}` : filePath;
-        lines.push(`    ${exp.exportType}  ${exp.name}  (${ref})`);
-      }
-    }
-    lines.push('');
-  }
-
-  lines.push('Fix: add tests importing the untested files, or mark files as non-runtime if they are build artifacts.');
-  return lines.join('\n').trimEnd();
-}

package/src/analysis/dep-classification.ts

@@ -1,167 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export interface PackageDepClassification {
-  packageName: string;
-  usedAsValue: boolean;       // has any non-type-only import
-  usedAsTypeOnly: boolean;    // has any type-only import
-  recommendation: 'keep-as-dep' | 'move-to-devdeps' | 'type-only' | 'unused';
-  importCount: number;
-  typeOnlyImportCount: number;
-}
-
-export interface DepClassificationResult {
-  packages: PackageDepClassification[];
-  typeOnlyCount: number;      // packages only used in type positions
-  mixedCount: number;         // packages used in both
-  valueOnlyCount: number;
-}
-
-interface EdgeRow {
-  relation: string;
-  confidence: string | null;
-  src: string;
-  tgt: string;
-  tgt_name: string;
-  properties: string | null;
-}
-
-function isExternalPackage(tgtName: string, tgtFilePath: string): boolean {
-  // External if the file_path doesn't start with '/' or '.'
-  // and doesn't look like a relative import
-  if (!tgtFilePath) {
-    // Fall back to name heuristic: starts with alpha, no path separators
-    return /^[a-zA-Z@]/.test(tgtName) && !tgtName.includes('/') || /^@[a-zA-Z]/.test(tgtName);
-  }
-  return !tgtFilePath.startsWith('/') && !tgtFilePath.startsWith('.');
-}
-
-function extractPackageName(tgt: string): string {
-  // Handle scoped packages like @scope/name
-  if (tgt.startsWith('@')) {
-    const parts = tgt.split('/');
-    return parts.slice(0, 2).join('/');
-  }
-  // Plain packages: take only the package name portion (before any '/')
-  return tgt.split('/')[0];
-}
-
-export function classifyDependencies(db: MonographDb): DepClassificationResult {
-  const rows = db.prepare(`
-    SELECT e.relation, e.confidence, n_src.file_path as src, n_tgt.file_path as tgt, n_tgt.name as tgt_name, e.properties
-    FROM edges e
-    JOIN nodes n_src ON n_src.id = e.source_id
-    JOIN nodes n_tgt ON n_tgt.id = e.target_id
-    WHERE e.relation = 'IMPORTS'
-  `).all() as EdgeRow[];
-
-  // Aggregate per external package
-  const packageMap = new Map<string, { valueImports: number; typeImports: number }>();
-
-  for (const row of rows) {
-    const tgtPath = row.tgt ?? '';
-    const tgtName = row.tgt_name ?? '';
-
-    if (!isExternalPackage(tgtName, tgtPath)) continue;
-
-    const packageName = extractPackageName(tgtName || tgtPath);
-    if (!packageName) continue;
-
-    // Check if type-only: parse properties JSON for isTypeOnly flag
-    let isTypeOnly = false;
-    if (row.properties) {
-      try {
-        const props = JSON.parse(row.properties) as Record<string, unknown>;
-        isTypeOnly = props['isTypeOnly'] === true;
-      } catch {
-        // fall through — infer from confidence
-      }
-    }
-    // Note: INFERRED confidence is NOT a reliable signal for type-only imports —
-    // re-export propagation and wildcard synthesis both emit INFERRED edges for real
-    // runtime imports. Only trust the explicit isTypeOnly property.
-
-    const existing = packageMap.get(packageName) ?? { valueImports: 0, typeImports: 0 };
-    if (isTypeOnly) {
-      existing.typeImports++;
-    } else {
-      existing.valueImports++;
-    }
-    packageMap.set(packageName, existing);
-  }
-
-  const packages: PackageDepClassification[] = [];
-
-  for (const [packageName, counts] of packageMap) {
-    const usedAsValue = counts.valueImports > 0;
-    const usedAsTypeOnly = counts.typeImports > 0;
-
-    let recommendation: PackageDepClassification['recommendation'];
-    if (usedAsValue && usedAsTypeOnly) {
-      recommendation = 'keep-as-dep';
-    } else if (usedAsValue && !usedAsTypeOnly) {
-      recommendation = 'keep-as-dep';
-    } else if (!usedAsValue && usedAsTypeOnly) {
-      recommendation = 'type-only';
-    } else {
-      recommendation = 'unused';
-    }
-
-    packages.push({
-      packageName,
-      usedAsValue,
-      usedAsTypeOnly,
-      recommendation,
-      importCount: counts.valueImports + counts.typeImports,
-      typeOnlyImportCount: counts.typeImports,
-    });
-  }
-
-  // Sort: 'type-only' first, then 'unused', then rest
-  const ORDER: Record<string, number> = { 'type-only': 0, 'unused': 1, 'move-to-devdeps': 2, 'keep-as-dep': 3 };
-  packages.sort((a, b) => (ORDER[a.recommendation] ?? 3) - (ORDER[b.recommendation] ?? 3));
-
-  const typeOnlyCount = packages.filter(p => p.recommendation === 'type-only').length;
-  const mixedCount = packages.filter(p => p.usedAsValue && p.usedAsTypeOnly).length;
-  const valueOnlyCount = packages.filter(p => p.usedAsValue && !p.usedAsTypeOnly).length;
-
-  return {
-    packages,
-    typeOnlyCount,
-    mixedCount,
-    valueOnlyCount,
-  };
-}
-
-/** Format DepClassificationResult as structured text for LLM navigation and actionable guidance. */
-export function formatDepClassification(result: DepClassificationResult): string {
-  if (result.packages.length === 0) {
-    return 'Dependency classification: no external packages detected.';
-  }
-
-  const lines: string[] = [
-    `Dependency classification: ${result.packages.length} external package(s).`,
-    `  type-only: ${result.typeOnlyCount}  mixed: ${result.mixedCount}  value-only: ${result.valueOnlyCount}`,
-    '',
-  ];
-
-  const groups: Array<[PackageDepClassification['recommendation'], string, string]> = [
-    ['type-only', 'Type-only (move to devDependencies or use @types)', 'Move to devDependencies — not needed at runtime.'],
-    ['unused', 'Unused', 'Remove from dependencies — no imports detected.'],
-    ['move-to-devdeps', 'Move to devDependencies', 'Only used in non-production code paths.'],
-    ['keep-as-dep', 'Keep as dependency', 'Used as runtime value imports — keep in dependencies.'],
-  ];
-
-  for (const [rec, heading, advice] of groups) {
-    const pkgs = result.packages.filter(p => p.recommendation === rec);
-    if (pkgs.length === 0) continue;
-    lines.push(`${heading} (${pkgs.length}):`);
-    for (const p of pkgs) {
-      const typeNote = p.typeOnlyImportCount > 0 ? ` (${p.typeOnlyImportCount} type-only)` : '';
-      lines.push(`  ${p.packageName}  imports:${p.importCount}${typeNote}`);
-    }
-    lines.push(`  → ${advice}`);
-    lines.push('');
-  }
-
-  return lines.join('\n').trimEnd();
-}

package/src/analysis/dependency-health.ts

@@ -1,146 +0,0 @@
-/**
- * Dependency health scoring.
- *
- * Produces a composite [0, 1] score by combining four sub-metrics:
- *
- *  1. Cycle penalty   — fraction of nodes involved in cycles (lower = worse)
- *  2. Dead-code ratio — fraction of nodes that are unreachable / unused
- *  3. Fan-out skew    — coefficient of variation of out-degrees (high skew = god nodes)
- *  4. God-node concentration — max in-degree / total edges (hub dominance)
- *
- * Final score = 1 − weighted average of penalties.
- * All individual penalty components are clamped to [0, 1].
- */
-
-export interface DependencyHealthEdge {
-  sourceId: string;
-  targetId: string;
-}
-
-export interface DependencyHealthInput {
-  /** All node IDs in the graph. */
-  nodes: string[];
-  /** All directed edges. */
-  edges: DependencyHealthEdge[];
-  /** Pre-computed number of cycles (e.g., from detectCycles). */
-  cycleCount: number;
-  /** Pre-computed count of dead nodes (e.g., from detectDeadCode). */
-  deadNodeCount: number;
-}
-
-export interface DependencyHealthDetails {
-  /** Fraction of nodes involved in cycles in [0, 1]. */
-  cyclePenalty: number;
-  /** Fraction of dead nodes in [0, 1]. */
-  deadCodeRatio: number;
-  /** Coefficient of variation for out-degree distribution (normalised to [0,1]). */
-  fanSkew: number;
-  /** Max in-degree / total edge count — hub dominance in [0, 1]. */
-  godNodeConcentration: number;
-}
-
-export interface DependencyHealthResult {
-  /** Composite health score in [0, 1] where 1 is perfectly healthy. */
-  score: number;
-  details: DependencyHealthDetails;
-}
-
-function stdDev(values: number[]): number {
-  if (values.length === 0) return 0;
-  const mean = values.reduce((a, b) => a + b, 0) / values.length;
-  const variance = values.reduce((a, b) => a + (b - mean) ** 2, 0) / values.length;
-  return Math.sqrt(variance);
-}
-
-function clamp(x: number): number {
-  return Math.max(0, Math.min(1, x));
-}
-
-/**
- * Compute a composite dependency health score for the given graph.
- */
-export function dependencyHealth(input: DependencyHealthInput): DependencyHealthResult {
-  const { nodes, edges, cycleCount, deadNodeCount } = input;
-  const n = nodes.length;
-  const m = edges.length;
-
-  if (n === 0) {
-    return {
-      score: 1,
-      details: { cyclePenalty: 0, deadCodeRatio: 0, fanSkew: 0, godNodeConcentration: 0 },
-    };
-  }
-
-  // 1. Cycle penalty: cycleCount is the number of nodes in cycles (from topologicalLevelSort)
-  //    Normalised by node count. Capped at 1.
-  const cyclePenalty = clamp(cycleCount / n);
-
-  // 2. Dead-code ratio
-  const deadCodeRatio = clamp(deadNodeCount / n);
-
-  // 3. Fan-out skew: coefficient of variation of out-degrees, normalised
-  const outDegree = new Map<string, number>(nodes.map(id => [id, 0]));
-  for (const { sourceId } of edges) {
-    outDegree.set(sourceId, (outDegree.get(sourceId) ?? 0) + 1);
-  }
-  const outValues = [...outDegree.values()];
-  const outMean = outValues.reduce((a, b) => a + b, 0) / n;
-  const cv = outMean > 0 ? stdDev(outValues) / outMean : 0;
-  // CV > 2 → very skewed; normalise to [0,1] by clamping at 4
-  const fanSkew = clamp(cv / 4);
-
-  // 4. God-node concentration: max in-degree / total edges
-  const inDegree = new Map<string, number>(nodes.map(id => [id, 0]));
-  for (const { targetId } of edges) {
-    inDegree.set(targetId, (inDegree.get(targetId) ?? 0) + 1);
-  }
-  // Use reduce instead of spread to avoid RangeError on graphs with 65k+ nodes
-  const maxInDeg = inDegree.size > 0
-    ? [...inDegree.values()].reduce((a, b) => Math.max(a, b), 0)
-    : 0;
-  const godNodeConcentration = m > 0 ? clamp(maxInDeg / m) : 0;
-
-  // Weighted composite penalty (weights sum to 1)
-  const W_CYCLE = 0.35;
-  const W_DEAD = 0.25;
-  const W_FAN = 0.20;
-  const W_GOD = 0.20;
-
-  const penalty =
-    W_CYCLE * cyclePenalty +
-    W_DEAD * deadCodeRatio +
-    W_FAN * fanSkew +
-    W_GOD * godNodeConcentration;
-
-  const score = clamp(1 - penalty);
-
-  return {
-    score,
-    details: { cyclePenalty, deadCodeRatio, fanSkew, godNodeConcentration },
-  };
-}
-
-/**
- * Format dependency health results as structured text for LLM consumption.
- */
-export function formatDependencyHealth(result: DependencyHealthResult): string {
-  const { score, details } = result;
-  const pct = (v: number) => `${(v * 100).toFixed(1)}%`;
-  const grade = score >= 0.9 ? 'Excellent' : score >= 0.75 ? 'Good' : score >= 0.5 ? 'Fair' : 'Poor';
-  const lines: string[] = [
-    `Dependency health score: ${pct(score)} (${grade})`,
-    `  Cycle penalty       : ${pct(details.cyclePenalty)}  (fraction of nodes in cycles; weight 35%)`,
-    `  Dead-code ratio     : ${pct(details.deadCodeRatio)}  (fraction of unreachable nodes; weight 25%)`,
-    `  Fan-out skew        : ${pct(details.fanSkew)}  (out-degree coefficient of variation / 4; weight 20%)`,
-    `  God-node density    : ${pct(details.godNodeConcentration)}  (max in-degree / total edges; weight 20%)`,
-  ];
-  const advice: string[] = [];
-  if (details.cyclePenalty > 0.1) advice.push('reduce circular imports (cyclePenalty high)');
-  if (details.deadCodeRatio > 0.1) advice.push('remove unreachable exports (deadCodeRatio high)');
-  if (details.fanSkew > 0.25) advice.push('break up high-fan-out modules (fanSkew high)');
-  if (details.godNodeConcentration > 0.1) advice.push('distribute hub dependencies (godNodeConcentration high)');
-  if (advice.length > 0) {
-    lines.push('  Recommendations: ' + advice.join('; '));
-  }
-  return lines.join('\n');
-}

package/src/analysis/duplicate-exports.ts

@@ -1,110 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export interface DuplicateExportLocation {
-  nodeId: string;
-  filePath: string | null;
-  startLine: number | null;
-  label: string;
-}
-
-export interface DuplicateExportGroup {
-  exportName: string;
-  locations: DuplicateExportLocation[];
-  count: number;
-}
-
-export interface DuplicateExportsResult {
-  groups: DuplicateExportGroup[];
-  totalDuplicates: number;
-  affectedFiles: number;
-}
-
-interface ExportedRow {
-  id: string;
-  name: string;
-  file_path: string | null;
-  start_line: number | null;
-  label: string;
-}
-
-/** Generic names that are too common to be meaningful duplicates. */
-const GENERIC_NAMES = new Set(['default', 'index', 'module']);
-
-export function detectDuplicateExports(db: MonographDb): DuplicateExportsResult {
-  const rows = db.prepare(
-    `SELECT id, name, file_path, start_line, label
-     FROM nodes
-     WHERE is_exported = 1
-       AND label IN ('Function','Class','Method','Interface','Const','TypeAlias','Enum','Variable')`
-  ).all() as ExportedRow[];
-
-  // Group by normalized name
-  const groups = new Map<string, DuplicateExportLocation[]>();
-
-  for (const row of rows) {
-    const normalized = row.name.toLowerCase().trim();
-    if (GENERIC_NAMES.has(normalized)) continue;
-
-    let list = groups.get(normalized);
-    if (!list) {
-      list = [];
-      groups.set(normalized, list);
-    }
-    list.push({ nodeId: row.id, filePath: row.file_path, startLine: row.start_line ?? null, label: row.label });
-  }
-
-  // Filter to duplicates only (count > 1)
-  const duplicateGroups: DuplicateExportGroup[] = [];
-  const affectedFileSet = new Set<string>();
-
-  for (const [name, locations] of groups) {
-    if (locations.length <= 1) continue;
-
-    duplicateGroups.push({
-      exportName: name,
-      locations,
-      count: locations.length,
-    });
-
-    for (const loc of locations) {
-      if (loc.filePath) affectedFileSet.add(loc.filePath);
-    }
-  }
-
-  // Sort by count descending
-  duplicateGroups.sort((a, b) => b.count - a.count);
-
-  return {
-    groups: duplicateGroups,
-    totalDuplicates: duplicateGroups.length,
-    affectedFiles: affectedFileSet.size,
-  };
-}
-
-/** Format DuplicateExportsResult as structured text with file:line hints for LLM navigation. */
-export function formatDuplicateExports(result: DuplicateExportsResult): string {
-  if (result.totalDuplicates === 0) {
-    return 'Duplicate exports: none detected.';
-  }
-
-  const lines: string[] = [
-    `Duplicate exports: ${result.totalDuplicates} name(s) exported from multiple files (${result.affectedFiles} file(s) affected).`,
-    '',
-  ];
-
-  for (const group of result.groups) {
-    lines.push(`  ${group.exportName} (${group.count} locations):`);
-    for (const loc of group.locations) {
-      const ref = loc.filePath
-        ? loc.startLine != null
-          ? `${loc.filePath}:${loc.startLine}`
-          : loc.filePath
-        : '(unknown)';
-      lines.push(`    ${loc.label}  ${ref}`);
-    }
-  }
-
-  lines.push('');
-  lines.push('Fix: consolidate duplicate exports into a single canonical location or rename to avoid conflicts.');
-  return lines.join('\n').trimEnd();
-}