@monoes/monograph 1.5.6 → 1.5.8

package/src/export/adjacency-matrix.ts

@@ -1,127 +0,0 @@
-import type { MonographNode, MonographEdge } from '../types.js';
-import type { MonographDb } from '../storage/db.js';
-
-// ── Output types ───────────────────────────────────────────────────────────────
-
-export interface AdjacencyMatrix {
-  /** Ordered node ids (row/column headers). */
-  nodeIds: string[];
-  /** Ordered node names, parallel to nodeIds. */
-  nodeNames: string[];
-  /** n×n matrix where matrix[i][j] = number of edges from nodeIds[i] to nodeIds[j]. */
-  matrix: number[][];
-}
-
-// ── Builder ────────────────────────────────────────────────────────────────────
-
-/**
- * Build an adjacency matrix from a set of nodes and edges.
- *
- * Multi-edges (same source→target pair) are counted, so the matrix
- * contains edge-counts rather than simple 0/1 booleans.
- *
- * @param nodes - The node list (defines row/column order).
- * @param edges - The edge list.
- * @returns An AdjacencyMatrix with nodeIds, nodeNames, and the n×n matrix.
- */
-export function buildAdjacencyMatrix(
-  nodes: MonographNode[],
-  edges: MonographEdge[],
-): AdjacencyMatrix {
-  const nodeIds = nodes.map(n => n.id);
-  const nodeNames = nodes.map(n => n.name);
-  const indexMap = new Map<string, number>(nodeIds.map((id, i) => [id, i]));
-  const n = nodeIds.length;
-
-  if (n > 5000) {
-    throw new Error(
-      `adjacency matrix would be ${n}×${n} (${n * n} cells). ` +
-      'Pass a pre-filtered node list via the nodeIds parameter, or use a different export format.'
-    );
-  }
-
-  const matrix: number[][] = Array.from({ length: n }, () => new Array<number>(n).fill(0));
-
-  for (const edge of edges) {
-    const si = indexMap.get(edge.sourceId);
-    const ti = indexMap.get(edge.targetId);
-    if (si !== undefined && ti !== undefined) {
-      matrix[si][ti]++;
-    }
-  }
-
-  return { nodeIds, nodeNames, matrix };
-}
-
-// ── DB-backed variant ──────────────────────────────────────────────────────────
-
-/**
- * Build an adjacency matrix directly from a MonographDb.
- * Optionally restrict to a subset of node ids.
- */
-export function buildAdjacencyMatrixFromDb(
-  db: MonographDb,
-  nodeIds?: string[],
-): AdjacencyMatrix {
-  let nodeRows: { id: string; name: string }[];
-
-  if (nodeIds && nodeIds.length > 0) {
-    const ph = nodeIds.map(() => '?').join(',');
-    nodeRows = db
-      .prepare(`SELECT id, name FROM nodes WHERE id IN (${ph})`)
-      .all(...nodeIds) as { id: string; name: string }[];
-  } else {
-    nodeRows = db.prepare('SELECT id, name FROM nodes').all() as { id: string; name: string }[];
-  }
-
-  const nodes: MonographNode[] = nodeRows.map(r => ({
-    id: r.id,
-    label: 'Function' as MonographNode['label'], // placeholder; only id/name needed here
-    name: r.name,
-    normLabel: r.name.toLowerCase(),
-    isExported: false,
-  }));
-
-  const nodeIdSet = new Set(nodeRows.map(r => r.id));
-
-  let edgeRows: { source_id: string; target_id: string }[];
-  if (nodeIds && nodeIds.length > 0) {
-    const ph = nodeIds.map(() => '?').join(',');
-    edgeRows = db
-      .prepare(`SELECT source_id, target_id FROM edges WHERE source_id IN (${ph}) AND target_id IN (${ph})`)
-      .all(...nodeIds, ...nodeIds) as { source_id: string; target_id: string }[];
-  } else {
-    edgeRows = db.prepare('SELECT source_id, target_id FROM edges').all() as {
-      source_id: string;
-      target_id: string;
-    }[];
-  }
-
-  const edges: MonographEdge[] = edgeRows
-    .filter(r => nodeIdSet.has(r.source_id) && nodeIdSet.has(r.target_id))
-    .map((r, i) => ({
-      id: `e${i}`,
-      sourceId: r.source_id,
-      targetId: r.target_id,
-      relation: 'REFERENCES' as MonographEdge['relation'],
-      confidence: 'EXTRACTED' as MonographEdge['confidence'],
-      confidenceScore: 1,
-    }));
-
-  return buildAdjacencyMatrix(nodes, edges);
-}
-
-// ── CSV serialiser ─────────────────────────────────────────────────────────────
-
-/**
- * Serialise an AdjacencyMatrix to a CSV string.
- * The first row and first column are node names (headers).
- */
-export function adjacencyMatrixToCsv(am: AdjacencyMatrix): string {
-  const escape = (s: string) => `"${s.replace(/"/g, '""')}"`;
-  const header = ['', ...am.nodeNames.map(escape)].join(',');
-  const rows = am.matrix.map((row, i) =>
-    [escape(am.nodeNames[i]), ...row.map(String)].join(','),
-  );
-  return [header, ...rows].join('\n');
-}

package/src/export/analysis-json.ts

@@ -1,87 +0,0 @@
-// Schema-versioned JSON envelope builders for CLI analysis results.
-
-export const ANALYSIS_JSON_SCHEMA_VERSION = 1;
-
-export interface AnalysisEnvelopeOptions {
-  elapsedMs?: number;
-  entryCount?: number;
-  schemaVersion?: number;
-}
-
-export interface AnalysisResultsEnvelope {
-  schemaVersion: number;
-  kind: 'analysis';
-  elapsedMs: number;
-  entryCount: number;
-  totalIssues: number;
-  results: unknown;
-}
-
-export interface HealthResultsEnvelope {
-  schemaVersion: number;
-  kind: 'health';
-  elapsedMs: number;
-  totalFindings: number;
-  includesExplanations: boolean;
-  results: unknown;
-}
-
-export interface DuplicationResultsEnvelope {
-  schemaVersion: number;
-  kind: 'duplication';
-  elapsedMs: number;
-  cloneGroups: number;
-  includesExplanations: boolean;
-  results: unknown;
-}
-
-export function buildAnalysisResultsEnvelope(
-  results: unknown,
-  totalIssues: number,
-  opts: AnalysisEnvelopeOptions = {},
-): AnalysisResultsEnvelope {
-  return {
-    schemaVersion: opts.schemaVersion ?? ANALYSIS_JSON_SCHEMA_VERSION,
-    kind: 'analysis',
-    elapsedMs: opts.elapsedMs ?? 0,
-    entryCount: opts.entryCount ?? 0,
-    totalIssues,
-    results,
-  };
-}
-
-export function buildHealthResultsEnvelope(
-  results: unknown,
-  totalFindings: number,
-  opts: AnalysisEnvelopeOptions & { includesExplanations?: boolean } = {},
-): HealthResultsEnvelope {
-  return {
-    schemaVersion: opts.schemaVersion ?? ANALYSIS_JSON_SCHEMA_VERSION,
-    kind: 'health',
-    elapsedMs: opts.elapsedMs ?? 0,
-    totalFindings,
-    includesExplanations: opts.includesExplanations ?? false,
-    results,
-  };
-}
-
-export function buildDuplicationResultsEnvelope(
-  results: unknown,
-  cloneGroups: number,
-  opts: AnalysisEnvelopeOptions & { includesExplanations?: boolean } = {},
-): DuplicationResultsEnvelope {
-  return {
-    schemaVersion: opts.schemaVersion ?? ANALYSIS_JSON_SCHEMA_VERSION,
-    kind: 'duplication',
-    elapsedMs: opts.elapsedMs ?? 0,
-    cloneGroups,
-    includesExplanations: opts.includesExplanations ?? false,
-    results,
-  };
-}
-
-export function stripRootPrefix(obj: unknown, rootPrefix: string): unknown {
-  const json = JSON.stringify(obj);
-  const escaped = rootPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return JSON.parse(json.replace(new RegExp(escaped, 'g'), ''));
-}

package/src/export/badge.ts

@@ -1,105 +0,0 @@
-export interface BadgeOptions {
-  label?: string;      // left label text (default: 'monograph')
-  value: string;       // right value text (e.g. 'A' or '87/100')
-  color?: string;      // hex color (auto-determined from grade if omitted)
-  uniqueId?: string;   // SVG element ID prefix (default: 'mg')
-}
-
-/** Map a letter grade to a shield-style hex color (without leading #). */
-export function gradeToColor(grade: string): string {
-  switch (grade.trim().toUpperCase()) {
-    case 'A': return '4c1';
-    case 'B': return '97ca00';
-    case 'C': return 'dfb317';
-    case 'D': return 'fe7d37';
-    case 'F': return 'e05d44';
-    default:  return '9f9f9f';
-  }
-}
-
-/** Approximate text width using Verdana 11px metrics: ~6.5px per char + 10px padding. */
-function textWidth(text: string): number {
-  return Math.round(text.length * 6.5 + 10);
-}
-
-/**
- * Generate a self-contained shields.io-style SVG health-grade badge.
- * Returns the SVG string; callers can write it to a file or embed it inline.
- */
-export function generateBadge(options: BadgeOptions): string {
-  const label = options.label ?? 'monograph';
-  const { value } = options;
-  const id = options.uniqueId ?? 'mg';
-
-  // Determine color: caller-supplied (strip leading #) or derived from grade
-  let colorHex: string;
-  if (options.color) {
-    colorHex = options.color.replace(/^#/, '');
-  } else {
-    colorHex = gradeToColor(value);
-  }
-
-  const labelW = textWidth(label);
-  const valueW = textWidth(value);
-  const totalW = labelW + valueW;
-
-  // X centres for text (SVG font-size="110" means 11px in a 10x-scaled coordinate space)
-  const lx = Math.round(labelW / 2);
-  const rx = labelW + Math.round(valueW / 2);
-
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="20">
-  <linearGradient id="${id}-lg" x2="0" y2="100%">
-    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
-    <stop offset="1" stop-opacity=".1"/>
-  </linearGradient>
-  <rect width="${totalW}" height="20" rx="3" fill="#555"/>
-  <rect x="${labelW}" width="${valueW}" height="20" rx="3" fill="#${colorHex}"/>
-  <rect width="${totalW}" height="20" rx="3" fill="url(#${id}-lg)"/>
-  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="110">
-    <text x="${lx * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${(labelW - 10) * 10}">${label}</text>
-    <text x="${lx * 10}" y="140" transform="scale(.1)" textLength="${(labelW - 10) * 10}">${label}</text>
-    <text x="${rx * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${(valueW - 10) * 10}">${value}</text>
-    <text x="${rx * 10}" y="140" transform="scale(.1)" textLength="${(valueW - 10) * 10}">${value}</text>
-  </g>
-</svg>`;
-}
-
-// ── Round 10: health terminal badge ───────────────────────────────────────────
-
-export type HealthGradeLetter = 'A' | 'B' | 'C' | 'D' | 'F';
-
-export interface HealthBadgeOptions {
-  grade: HealthGradeLetter;
-  score: number;
-  label?: string;
-  ansiColors?: boolean;
-}
-
-const GRADE_ANSI_BG: Record<HealthGradeLetter, string> = {
-  A: '\x1b[42m', // green
-  B: '\x1b[32m', // dark green
-  C: '\x1b[43m', // yellow
-  D: '\x1b[33m', // dark yellow
-  F: '\x1b[41m', // red
-};
-
-const ANSI_RESET = '\x1b[0m';
-const ANSI_BOLD = '\x1b[1m';
-
-export function renderHealthTerminalBadge(opts: HealthBadgeOptions): string {
-  const label = opts.label ?? 'health';
-  const score = Math.round(opts.score);
-  if (!opts.ansiColors) {
-    return `[${label}: ${opts.grade} (${score}/100)]`;
-  }
-  const bg = GRADE_ANSI_BG[opts.grade];
-  return `${ANSI_BOLD}${bg} ${label.toUpperCase()}: ${opts.grade} (${score}/100) ${ANSI_RESET}`;
-}
-
-export function healthScoreToGrade(score: number): HealthGradeLetter {
-  if (score >= 90) return 'A';
-  if (score >= 75) return 'B';
-  if (score >= 60) return 'C';
-  if (score >= 45) return 'D';
-  return 'F';
-}

package/src/export/canvas.ts

@@ -1,42 +0,0 @@
-import type { MonographNode, MonographEdge } from '../types.js';
-
-export function toCanvas(nodes: MonographNode[], edges: MonographEdge[]): string {
-  const canvasNodes = nodes.map((n, i) => ({
-    id: n.id,
-    type: 'text',
-    text: `**${n.label}**\n${n.name}`,
-    x: (i % 20) * 200,
-    y: Math.floor(i / 20) * 120,
-    width: 180,
-    height: 80,
-    color: labelColor(n.label),
-  }));
-
-  const canvasEdges = edges.map(e => ({
-    id: e.id,
-    fromNode: e.sourceId,
-    toNode: e.targetId,
-    label: e.relation,
-    color: confidenceColor(e.confidence),
-  }));
-
-  return JSON.stringify({ nodes: canvasNodes, edges: canvasEdges }, null, 2);
-}
-
-function labelColor(label: string): string {
-  const map: Record<string, string> = {
-    Class: '1',
-    Function: '2',
-    Interface: '3',
-    Module: '4',
-    Namespace: '5',
-    Method: '6',
-  };
-  return map[label] ?? '6';
-}
-
-function confidenceColor(c: string): string {
-  if (c === 'EXTRACTED') return '#22c55e';
-  if (c === 'INFERRED') return '#f59e0b';
-  return '#ef4444';
-}

package/src/export/codeclimate.ts

@@ -1,201 +0,0 @@
-import { relative } from 'path';
-import type { MonographDb } from '../storage/db.js';
-
-export interface CodeClimateIssue {
-  type: 'issue';
-  check_name: string;
-  description: string;
-  categories: string[];
-  fingerprint: string;
-  severity: 'blocker' | 'critical' | 'major' | 'minor' | 'info';
-  location: {
-    path: string;
-    lines: { begin: number; end?: number };
-  };
-}
-
-/** FNV-1a 32-bit hash → 8 lowercase hex chars. */
-function fnv1a32(str: string): string {
-  let h = 2166136261;
-  for (const b of Buffer.from(str)) {
-    h ^= b;
-    h = Math.imul(h, 16777619) >>> 0;
-  }
-  return h.toString(16).padStart(8, '0');
-}
-
-/** Normalize Next.js dynamic route segments. */
-function normalizePath(p: string): string {
-  return p.replace(/\[([^\]]+)\]/g, '%5B$1%5D');
-}
-
-function relativePath(filePath: string, repoRoot?: string): string {
-  if (!repoRoot) return filePath;
-  return relative(repoRoot, filePath);
-}
-
-function makeIssue(
-  checkName: string,
-  description: string,
-  categories: string[],
-  severity: CodeClimateIssue['severity'],
-  filePath: string,
-  line: number,
-  repoRoot?: string,
-): CodeClimateIssue {
-  const relPath = normalizePath(relativePath(filePath, repoRoot));
-  const fingerprint = fnv1a32(`${checkName}:${relPath}:${line}`);
-  return {
-    type: 'issue',
-    check_name: checkName,
-    description,
-    categories,
-    fingerprint,
-    severity,
-    location: {
-      path: relPath,
-      lines: { begin: line },
-    },
-  };
-}
-
-/**
- * Export CodeClimate-compatible issue list from the monograph DB.
- * Returns a JSON-serialisable array of issues.
- */
-export function exportCodeClimate(db: MonographDb, repoRoot?: string): CodeClimateIssue[] {
-  const issues: CodeClimateIssue[] = [];
-
-  // ── God nodes (top 10% by fan-in) ─────────────────────────────────────────
-  const totalNodes = (db.prepare(`SELECT COUNT(*) as c FROM nodes WHERE label = 'File'`).get() as { c: number }).c;
-  const top10pct = Math.max(1, Math.floor(totalNodes * 0.1));
-  const godNodes = db.prepare(`
-    SELECT n.id, n.name, n.file_path, COALESCE(n.start_line, 1) AS line,
-           COUNT(e.id) AS in_degree
-    FROM nodes n
-    LEFT JOIN edges e ON e.target_id = n.id AND e.relation IN ('IMPORTS', 'RE_EXPORTS')
-    WHERE n.file_path IS NOT NULL AND n.label = 'File'
-    GROUP BY n.id
-    ORDER BY in_degree DESC
-    LIMIT ?
-  `).all(top10pct) as { id: string; name: string; file_path: string; line: number; in_degree: number }[];
-
-  for (const row of godNodes) {
-    if (row.in_degree === 0) continue;
-    issues.push(makeIssue(
-      'monograph/god-node',
-      `God node: "${row.name}" has ${row.in_degree} incoming dependencies.`,
-      ['Complexity'],
-      'major',
-      row.file_path,
-      row.line ?? 1,
-      repoRoot,
-    ));
-  }
-
-  // ── Unreachable files ──────────────────────────────────────────────────────
-  const unreachable = db.prepare(`
-    SELECT id, name, file_path FROM nodes
-    WHERE label = 'File'
-    AND (
-      json_extract(properties, '$.reachabilityRole') = 'unreachable'
-      OR properties LIKE '%"unreachable"%'
-    )
-    AND file_path IS NOT NULL
-  `).all() as { id: string; name: string; file_path: string }[];
-
-  for (const row of unreachable) {
-    issues.push(makeIssue(
-      'monograph/unreachable-file',
-      `Unreachable file: "${row.name}" is not reachable from any entry point.`,
-      ['Duplication'],
-      'minor',
-      row.file_path,
-      1,
-      repoRoot,
-    ));
-  }
-
-  // ── Structural duplicates (STRUCTURALLY_SIMILAR edges) ───────────────────
-  const dupes = db.prepare(`
-    SELECT e.id, n1.name AS src_name, n1.file_path AS src_path,
-           COALESCE(n1.start_line, 1) AS src_line
-    FROM edges e
-    JOIN nodes n1 ON n1.id = e.source_id
-    JOIN nodes n2 ON n2.id = e.target_id
-    WHERE e.relation = 'STRUCTURALLY_SIMILAR'
-    AND n1.file_path IS NOT NULL
-  `).all() as { id: string; src_name: string; src_path: string; src_line: number }[];
-
-  for (const row of dupes) {
-    issues.push(makeIssue(
-      'monograph/duplicate',
-      `Duplicate: "${row.src_name}" is structurally similar to another file.`,
-      ['Duplication'],
-      'minor',
-      row.src_path,
-      row.src_line ?? 1,
-      repoRoot,
-    ));
-  }
-
-  return issues;
-}
-
-// ── Round 10: health + duplication CodeClimate exports ────────────────────────
-
-export interface CodeClimateHealthIssue extends CodeClimateIssue {
-  categories: ['Complexity'];
-}
-
-export interface CodeClimateDuplicationIssue extends CodeClimateIssue {
-  categories: ['Duplication'];
-}
-
-export interface HealthFindingInput {
-  filePath: string;
-  functionName: string;
-  startLine: number;
-  endLine: number;
-  severity: 'major' | 'minor' | 'critical' | 'info';
-  crapScore: number;
-  cyclomatic: number;
-}
-
-export interface DuplicationFindingInput {
-  filePath: string;
-  startLine: number;
-  endLine: number;
-  groupId: number;
-  duplicatedLines: number;
-}
-
-function fingerprint(s: string): string {
-  let h = 0;
-  for (let i = 0; i < s.length; i++) h = (Math.imul(31, h) + s.charCodeAt(i)) >>> 0;
-  return h.toString(16).padStart(8, '0');
-}
-
-export function exportHealthCodeClimate(findings: HealthFindingInput[]): CodeClimateIssue[] {
-  return findings.map(f => ({
-    type: 'issue',
-    check_name: 'complexity',
-    description: `${f.functionName}: cyclomatic=${f.cyclomatic}, CRAP=${f.crapScore.toFixed(1)}`,
-    categories: ['Complexity'],
-    severity: f.severity,
-    fingerprint: fingerprint(`${f.filePath}:${f.functionName}:${f.startLine}`),
-    location: { path: f.filePath, lines: { begin: f.startLine, end: f.endLine } },
-  }));
-}
-
-export function exportDuplicationCodeClimate(findings: DuplicationFindingInput[]): CodeClimateIssue[] {
-  return findings.map(f => ({
-    type: 'issue',
-    check_name: 'duplication',
-    description: `Code duplication: ${f.duplicatedLines} lines (group ${f.groupId})`,
-    categories: ['Duplication'],
-    severity: 'minor' as const,
-    fingerprint: fingerprint(`${f.filePath}:${f.groupId}:${f.startLine}`),
-    location: { path: f.filePath, lines: { begin: f.startLine, end: f.endLine } },
-  }));
-}

package/src/export/compact-health.ts

@@ -1,119 +0,0 @@
-import { relative } from 'node:path';
-
-export interface CompactHealthFinding {
-  path: string;
-  line: number;
-  name: string;
-  cyclomatic: number;
-  cognitive: number;
-  severity: string;
-  crap?: number;
-  coveragePct?: number;
-}
-
-export interface CompactHotspot {
-  path: string;
-  score: number;
-  commits: number;
-  linesAdded: number;
-  linesDeleted: number;
-  complexityDensity: number;
-  fanIn: number;
-  trend: string;
-}
-
-export interface CompactHealthScore {
-  score: number;
-  grade: string;
-}
-
-export interface CompactVitalSigns {
-  totalLoc?: number;
-  avgCyclomatic: number;
-  p90Cyclomatic: number;
-  deadFilePct?: number;
-  deadExportPct?: number;
-  maintainabilityAvg?: number;
-  hotspotCount?: number;
-  circularDepCount?: number;
-  unusedDepCount?: number;
-}
-
-export interface CompactHealthTrend {
-  overallDirection: string;
-  metrics: Array<{ name: string; previous: number; current: number; delta: number; direction: string }>;
-}
-
-export interface CompactHealthReport {
-  root: string;
-  healthScore?: CompactHealthScore;
-  vitalSigns?: CompactVitalSigns;
-  findings?: CompactHealthFinding[];
-  hotspots?: CompactHotspot[];
-  healthTrend?: CompactHealthTrend;
-}
-
-export interface CompactCloneGroup {
-  instances: Array<{ file: string; startLine: number; endLine: number; tokenCount?: number }>;
-}
-
-export interface CompactDuplicationReport {
-  root: string;
-  cloneGroups: CompactCloneGroup[];
-}
-
-function rel(p: string, root: string): string { return relative(root, p); }
-
-export function buildHealthCompactLines(report: CompactHealthReport): string[] {
-  const lines: string[] = [];
-  const { root } = report;
-  if (report.healthScore)
-    lines.push(`health-score:${report.healthScore.score.toFixed(1)}:${report.healthScore.grade}`);
-
-  if (report.vitalSigns) {
-    const vs = report.vitalSigns;
-    const parts: string[] = [];
-    if (vs.totalLoc) parts.push(`total_loc=${vs.totalLoc}`);
-    parts.push(`avg_cyclomatic=${vs.avgCyclomatic.toFixed(1)}`);
-    parts.push(`p90_cyclomatic=${vs.p90Cyclomatic}`);
-    if (vs.deadFilePct !== undefined) parts.push(`dead_file_pct=${vs.deadFilePct.toFixed(1)}`);
-    if (vs.deadExportPct !== undefined) parts.push(`dead_export_pct=${vs.deadExportPct.toFixed(1)}`);
-    if (vs.maintainabilityAvg !== undefined) parts.push(`maintainability_avg=${vs.maintainabilityAvg.toFixed(1)}`);
-    if (vs.hotspotCount !== undefined) parts.push(`hotspot_count=${vs.hotspotCount}`);
-    if (vs.circularDepCount !== undefined) parts.push(`circular_dep_count=${vs.circularDepCount}`);
-    if (vs.unusedDepCount !== undefined) parts.push(`unused_dep_count=${vs.unusedDepCount}`);
-    lines.push(`vital-signs:${parts.join(',')}`);
-  }
-
-  for (const f of report.findings ?? []) {
-    const crapSuffix = f.crap !== undefined
-      ? `,crap=${f.crap.toFixed(1)}${f.coveragePct !== undefined ? `,coverage_pct=${f.coveragePct.toFixed(1)}` : ''}` : '';
-    lines.push(`high-complexity:${rel(f.path, root)}:${f.line}:${f.name}:cyclomatic=${f.cyclomatic},cognitive=${f.cognitive},severity=${f.severity}${crapSuffix}`);
-  }
-
-  for (const h of report.hotspots ?? []) {
-    lines.push(`hotspot:${rel(h.path, root)}:score=${h.score.toFixed(1)},commits=${h.commits},churn=${h.linesAdded + h.linesDeleted},density=${h.complexityDensity.toFixed(2)},fan_in=${h.fanIn},trend=${h.trend}`);
-  }
-
-  if (report.healthTrend) {
-    lines.push(`trend:overall:direction=${report.healthTrend.overallDirection}`);
-    for (const m of report.healthTrend.metrics) {
-      const sign = m.delta >= 0 ? '+' : '';
-      lines.push(`trend:${m.name}:previous=${m.previous.toFixed(1)},current=${m.current.toFixed(1)},delta=${sign}${m.delta.toFixed(1)},direction=${m.direction}`);
-    }
-  }
-  return lines;
-}
-
-export function buildDuplicationCompactLines(report: CompactDuplicationReport): string[] {
-  const lines: string[] = [];
-  const { root } = report;
-  for (let i = 0; i < report.cloneGroups.length; i++) {
-    const group = report.cloneGroups[i];
-    for (const inst of group.instances) {
-      const tokens = inst.tokenCount !== undefined ? `${inst.tokenCount}tokens` : '';
-      lines.push(`clone-group-${i + 1}:${rel(inst.file, root)}:${inst.startLine}-${inst.endLine}${tokens ? ':' + tokens : ''}`);
-    }
-  }
-  return lines;
-}