@monoes/monograph 1.5.6 → 1.5.8

package/src/report/badge-svg.ts

@@ -1,100 +0,0 @@
-const CHAR_WIDTHS: Record<string, number> = {
-  ' ': 33, '!': 37, '"': 42, '#': 67, '$': 67, '%': 80, '&': 80, "'": 24,
-  '(': 40, ')': 40, '*': 47, '+': 70, ',': 33, '-': 40, '.': 33, '/': 47,
-  '0': 67, '1': 67, '2': 67, '3': 67, '4': 67, '5': 67, '6': 67, '7': 67,
-  '8': 67, '9': 67, ':': 37, ';': 37, '<': 70, '=': 70, '>': 70, '?': 60,
-  '@': 117, 'A': 73, 'B': 73, 'C': 73, 'D': 80, 'E': 67, 'F': 60, 'G': 80,
-  'H': 80, 'I': 27, 'J': 47, 'K': 73, 'L': 60, 'M': 87, 'N': 80, 'O': 87,
-  'P': 67, 'Q': 87, 'R': 73, 'S': 67, 'T': 60, 'U': 80, 'V': 73, 'W': 100,
-  'X': 67, 'Y': 67, 'Z': 67, '[': 40, '\\': 47, ']': 40, '^': 70, '_': 67,
-  '`': 47, 'a': 60, 'b': 67, 'c': 53, 'd': 67, 'e': 60, 'f': 40, 'g': 67,
-  'h': 67, 'i': 27, 'j': 27, 'k': 60, 'l': 27, 'm': 100, 'n': 67, 'o': 67,
-  'p': 67, 'q': 67, 'r': 40, 's': 53, 't': 47, 'u': 67, 'v': 60, 'w': 80,
-  'x': 60, 'y': 60, 'z': 53, '{': 40, '|': 32, '}': 40, '~': 70,
-};
-
-export function textWidth(s: string): number {
-  let w = 0;
-  for (const ch of s) w += CHAR_WIDTHS[ch] ?? 67;
-  return Math.ceil(w / 10);
-}
-
-export type HealthGrade = 'A' | 'B' | 'C' | 'D' | 'F';
-
-export function gradeColor(grade: HealthGrade | string): string {
-  switch (grade) {
-    case 'A': return '#4c1';
-    case 'B': return '#97ca00';
-    case 'C': return '#dfb317';
-    case 'D': return '#fe7d37';
-    case 'F': return '#e05d44';
-    default:   return '#9f9f9f';
-  }
-}
-
-export function xmlEscape(s: string): string {
-  return s
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&apos;');
-}
-
-export function svgIdSuffix(label: string, message: string): string {
-  return `${label}-${message}`.replace(/[^a-zA-Z0-9]/g, '-');
-}
-
-export interface BadgeOptions {
-  label: string;
-  message: string;
-  color?: string;
-  labelColor?: string;
-  style?: 'flat' | 'flat-square' | 'plastic';
-}
-
-export function renderBadge(opts: BadgeOptions): string {
-  const { label, message } = opts;
-  const color = opts.color ?? '#4c1';
-  const labelColor = opts.labelColor ?? '#555';
-  const lw = textWidth(label) + 10;
-  const mw = textWidth(message) + 10;
-  const totalW = lw + mw;
-  const idSuffix = svgIdSuffix(label, message);
-  const lx = Math.floor(lw / 2);
-  const mx = lw + Math.floor(mw / 2);
-
-  return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${totalW}" height="20" role="img" aria-label="${xmlEscape(label)}: ${xmlEscape(message)}">
-  <title>${xmlEscape(label)}: ${xmlEscape(message)}</title>
-  <linearGradient id="s-${idSuffix}" x2="0" y2="100%">
-    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
-    <stop offset="1" stop-opacity=".1"/>
-  </linearGradient>
-  <clipPath id="r-${idSuffix}">
-    <rect width="${totalW}" height="20" rx="3" fill="#fff"/>
-  </clipPath>
-  <g clip-path="url(#r-${idSuffix})">
-    <rect width="${lw}" height="20" fill="${xmlEscape(labelColor)}"/>
-    <rect x="${lw}" width="${mw}" height="20" fill="${xmlEscape(color)}"/>
-    <rect width="${totalW}" height="20" fill="url(#s-${idSuffix})"/>
-  </g>
-  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
-    <text aria-hidden="true" x="${lx * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${lw * 10}">${xmlEscape(label)}</text>
-    <text x="${lx * 10}" y="140" transform="scale(.1)" fill="#fff" textLength="${lw * 10}">${xmlEscape(label)}</text>
-    <text aria-hidden="true" x="${mx * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${mw * 10}">${xmlEscape(message)}</text>
-    <text x="${mx * 10}" y="140" transform="scale(.1)" fill="#fff" textLength="${mw * 10}">${xmlEscape(message)}</text>
-  </g>
-</svg>`;
-}
-
-export function renderHealthBadge(score: number, grade: string): string {
-  return renderBadge({
-    label: 'health',
-    message: `${score} ${grade}`,
-    color: gradeColor(grade),
-  });
-}
-
-export function renderGradeBadge(label: string, grade: string): string {
-  return renderBadge({ label, message: grade, color: gradeColor(grade) });
-}

package/src/report/cross-ref-human.ts

@@ -1,50 +0,0 @@
-import { relative } from 'node:path';
-
-export type CrossRefDeadCodeKind =
-  | { type: 'unused-file' }
-  | { type: 'unused-export'; exportName: string }
-  | { type: 'unused-type'; typeName: string };
-
-export interface CrossRefHumanFinding {
-  cloneFile: string;
-  startLine: number;
-  endLine: number;
-  deadCodeKind: CrossRefDeadCodeKind;
-  groupIndex: number;
-}
-
-export interface CrossRefHumanResult {
-  findings: CrossRefHumanFinding[];
-  clonesInUnusedFiles: number;
-  clonesWithUnusedExports: number;
-}
-
-function rel(p: string, root: string): string { return relative(root, p); }
-
-function deadCodeReason(kind: CrossRefDeadCodeKind): string {
-  if (kind.type === 'unused-file') return 'entire file is unused';
-  if (kind.type === 'unused-export') return `export '${kind.exportName}' is unused`;
-  return `type '${(kind as { type: 'unused-type'; typeName: string }).typeName}' is unused`;
-}
-
-export function buildCrossReferenceLines(result: CrossRefHumanResult, root: string): string[] {
-  if (result.findings.length === 0) return [];
-  const lines: string[] = [
-    '',
-    '● Duplicated + Unused (safe to delete)',
-    '',
-  ];
-  for (const f of result.findings) {
-    const location = `${rel(f.cloneFile, root)}:${f.startLine}-${f.endLine}`;
-    lines.push(`  ${location} (${deadCodeReason(f.deadCodeKind)})`);
-  }
-  lines.push('');
-  return lines;
-}
-
-export function printCrossReferenceFindings(result: CrossRefHumanResult, root: string, quiet = false): void {
-  if (result.findings.length === 0 || quiet) return;
-  for (const line of buildCrossReferenceLines(result, root)) console.log(line);
-  const { findings: { length: total }, clonesInUnusedFiles: files, clonesWithUnusedExports: exports_ } = result;
-  console.error(`  ${total} combined finding(s): ${files} in unused file(s), ${exports_} overlapping unused export(s)`);
-}

package/src/report/duplication-grouping.ts

@@ -1,74 +0,0 @@
-// Groups raw clone-detection output by package/owner/directory
-// for grouped duplication reports.
-
-export interface DuplicationGroupEntry {
-  groupId: number;
-  owner: string;   // package name or directory path
-  filePaths: string[];
-  duplicatedLines: number;
-  instances: number;
-}
-
-export interface DuplicationGrouping {
-  groups: DuplicationGroupEntry[];
-  totalDuplicatedLines: number;
-  totalInstances: number;
-  ownerCount: number;
-}
-
-export interface CloneGroupInput {
-  id: number;
-  instances: Array<{ filePath: string; startLine: number; endLine: number }>;
-  duplicatedLines: number;
-}
-
-export type OwnerResolver = (filePath: string) => string;
-
-/** Default resolver: uses the immediate parent directory as the owner. */
-export function defaultOwnerResolver(filePath: string): string {
-  const norm = filePath.replace(/\\/g, '/');
-  const parts = norm.split('/');
-  return parts.length > 1 ? parts[parts.length - 2] : '.';
-}
-
-export function buildDuplicationGrouping(
-  groups: CloneGroupInput[],
-  resolver: OwnerResolver = defaultOwnerResolver,
-): DuplicationGrouping {
-  const byOwner = new Map<string, DuplicationGroupEntry>();
-
-  for (const group of groups) {
-    for (const inst of group.instances) {
-      const owner = resolver(inst.filePath);
-      if (!byOwner.has(owner)) {
-        byOwner.set(owner, {
-          groupId: group.id,
-          owner,
-          filePaths: [],
-          duplicatedLines: 0,
-          instances: 0,
-        });
-      }
-      const entry = byOwner.get(owner)!;
-      if (!entry.filePaths.includes(inst.filePath)) entry.filePaths.push(inst.filePath);
-      entry.duplicatedLines += group.duplicatedLines;
-      entry.instances++;
-    }
-  }
-
-  const result = [...byOwner.values()].sort((a, b) => b.duplicatedLines - a.duplicatedLines);
-  return {
-    groups: result,
-    totalDuplicatedLines: result.reduce((s, g) => s + g.duplicatedLines, 0),
-    totalInstances: result.reduce((s, g) => s + g.instances, 0),
-    ownerCount: result.length,
-  };
-}
-
-export function formatDuplicationGrouping(grouping: DuplicationGrouping): string {
-  const lines = [`Duplication by owner (${grouping.ownerCount} owners, ${grouping.totalDuplicatedLines} total lines):`];
-  for (const g of grouping.groups) {
-    lines.push(`  ${g.owner}: ${g.duplicatedLines} lines, ${g.instances} instances, ${g.filePaths.length} files`);
-  }
-  return lines.join('\n');
-}

package/src/report/grouping.ts

@@ -1,137 +0,0 @@
-// Partition analysis results into labeled groups by owner, directory, package, or section.
-
-export type GroupByMode = 'owner' | 'directory' | 'package' | 'section';
-
-export interface GroupEntry<T> {
-  label: string;
-  items: T[];
-}
-
-export interface AttributedInstance {
-  filePath: string;
-  startLine: number;
-  endLine: number;
-  owner: string;
-}
-
-export interface AttributedCloneGroup {
-  id: number;
-  instances: AttributedInstance[];
-  primaryOwner: string;
-  duplicatedLines: number;
-}
-
-export interface PackageResolver {
-  packages: Array<{ root: string; name: string }>;
-  resolve(filePath: string): string;
-}
-
-export function createPackageResolver(packages: Array<{ root: string; name: string }>): PackageResolver {
-  const sorted = [...packages].sort((a, b) => b.root.length - a.root.length);
-  return {
-    packages,
-    resolve(filePath: string): string {
-      const normalized = filePath.replace(/\\/g, '/');
-      const match = sorted.find(p => normalized.startsWith(p.root.replace(/\\/g, '/')));
-      return match?.name ?? '(root)';
-    },
-  };
-}
-
-export function resolveDirectoryGroup(filePath: string, depth = 1): string {
-  const parts = filePath.replace(/\\/g, '/').split('/');
-  return parts.slice(0, depth + 1).join('/') || '(root)';
-}
-
-export function groupItemsByFile<T extends { filePath: string }>(
-  items: T[],
-  resolve: (filePath: string) => string,
-): GroupEntry<T>[] {
-  const map = new Map<string, T[]>();
-  for (const item of items) {
-    const label = resolve(item.filePath);
-    if (!map.has(label)) map.set(label, []);
-    map.get(label)!.push(item);
-  }
-  return [...map.entries()]
-    .map(([label, its]) => ({ label, items: its }))
-    .sort((a, b) => b.items.length - a.items.length);
-}
-
-/** Attribution: most instances wins, alphabetical tiebreak. */
-export function largestOwner(
-  instances: Array<{ filePath: string }>,
-  resolveOwner: (filePath: string) => string,
-): string {
-  const counts = new Map<string, number>();
-  for (const inst of instances) {
-    const owner = resolveOwner(inst.filePath);
-    counts.set(owner, (counts.get(owner) ?? 0) + 1);
-  }
-  if (counts.size === 0) return '(unknown)';
-  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0][0];
-}
-
-export function attributeCloneGroup(
-  group: { id: number; duplicatedLines: number; instances: Array<{ filePath: string; startLine: number; endLine: number }> },
-  resolveOwner: (filePath: string) => string,
-): AttributedCloneGroup {
-  const attributed = group.instances.map(i => ({
-    ...i,
-    owner: resolveOwner(i.filePath),
-  }));
-  return {
-    id: group.id,
-    instances: attributed,
-    primaryOwner: largestOwner(group.instances, resolveOwner),
-    duplicatedLines: group.duplicatedLines,
-  };
-}
-
-// ── Round 10: result group partitioning ───────────────────────────────────────
-
-export type OwnershipResolverKind = 'owner' | 'directory' | 'package' | 'section';
-
-export interface ResultGroup<T = unknown> {
-  key: string;
-  owners?: string[];
-  results: T[];
-  fileCount: number;
-}
-
-export function groupResultsByOwner<T extends { filePath?: string; path?: string }>(
-  items: T[],
-  resolver: (filePath: string) => string,
-): Map<string, T[]> {
-  const map = new Map<string, T[]>();
-  for (const item of items) {
-    const fp = item.filePath ?? (item as Record<string, unknown>)['path'] as string ?? '';
-    const key = resolver(fp);
-    if (!map.has(key)) map.set(key, []);
-    map.get(key)!.push(item);
-  }
-  return map;
-}
-
-export function partitionByOwner<T extends { filePath?: string; path?: string }>(
-  items: T[],
-  resolver: (filePath: string) => string,
-): ResultGroup<T>[] {
-  const grouped = groupResultsByOwner(items, resolver);
-  const groups: ResultGroup<T>[] = [];
-  for (const [key, results] of grouped) {
-    const filePaths = new Set(results.map(r => r.filePath ?? (r as Record<string, unknown>)['path'] as string ?? ''));
-    groups.push({ key, results, fileCount: filePaths.size });
-  }
-  return groups.sort((a, b) => b.results.length - a.results.length);
-}
-
-export function resolveWithPattern(
-  filePath: string,
-  ownerMap: Map<string, string>,
-): { owner: string; pattern: string | null } {
-  for (const [pattern, owner] of ownerMap) {
-    if (filePath.includes(pattern)) return { owner, pattern };
-  }
-  return { owner: 'unowned', pattern: null };
-}

package/src/report/human-check.ts

@@ -1,291 +0,0 @@
-import type {
-  FallowAnalysisResults,
-  FallowUnusedFile,
-  FallowUnusedExport,
-  FallowUnusedDependency,
-  FallowUnusedMember,
-  FallowUnresolvedImport,
-} from '../results/fallow-results.js';
-
-const RESET = '\x1b[0m';
-const BOLD = '\x1b[1m';
-const DIM = '\x1b[2m';
-const RED = '\x1b[31m';
-const YELLOW = '\x1b[33m';
-const CYAN = '\x1b[36m';
-
-function col(c: string, t: string): string { return `${c}${t}${RESET}`; }
-function dim(t: string): string { return col(DIM, t); }
-function bold(t: string): string { return col(BOLD, t); }
-
-const MAX_FLAT = 10;
-const MAX_GROUPED_FILES = 10;
-const MAX_ITEMS_PER_FILE = 5;
-const SCOPING_THRESHOLD = 500;
-
-export interface HumanCheckOptions {
-  maxFlatItems?: number;
-  maxGroupedFiles?: number;
-  maxItemsPerFile?: number;
-  top?: number;
-}
-
-function truncHint(remaining: number, total: number): string {
-  if (remaining > SCOPING_THRESHOLD || total > SCOPING_THRESHOLD) {
-    return dim(`... and ${remaining} more — try --workspace <name> or --changed-since main to scope`);
-  }
-  return dim(`... and ${remaining} more (--format json for full list)`);
-}
-
-function sectionHeader(title: string, count: number, level: 'error' | 'warn' | 'info' = 'error'): string {
-  const bullet = level === 'error' ? col(RED, '●') : level === 'warn' ? col(YELLOW, '●') : col(CYAN, '●');
-  return `${bullet} ${bold(`${title} (${count})`)}`;
-}
-
-function categoryHeader(label: string): string {
-  const bar = '─'.repeat(37);
-  return dim(`── ${label} ${bar}`);
-}
-
-export function formatUnusedFiles(files: FallowUnusedFile[], opts: HumanCheckOptions = {}): string[] {
-  if (files.length === 0) return [];
-  const max = opts.maxFlatItems ?? opts.top ?? MAX_FLAT;
-  const total = files.length;
-  const lines: string[] = [sectionHeader('Unused files', total)];
-  const shown = files.slice(0, max);
-  for (const f of shown) {
-    lines.push(`  ${f.filePath}`);
-  }
-  if (total > max) {
-    lines.push(`  ${truncHint(total - max, total)}`);
-  }
-  lines.push('');
-  return lines;
-}
-
-function groupByFile<T extends { filePath: string }>(items: T[]): Map<string, T[]> {
-  const map = new Map<string, T[]>();
-  for (const item of items) {
-    const arr = map.get(item.filePath) ?? [];
-    arr.push(item);
-    map.set(item.filePath, arr);
-  }
-  return map;
-}
-
-export function formatUnusedExports(exports: FallowUnusedExport[], opts: HumanCheckOptions = {}): string[] {
-  if (exports.length === 0) return [];
-  const maxFiles = opts.maxGroupedFiles ?? opts.top ?? MAX_GROUPED_FILES;
-  const maxPerFile = opts.maxItemsPerFile ?? MAX_ITEMS_PER_FILE;
-  const total = exports.length;
-  const lines: string[] = [sectionHeader('Unused exports', total)];
-
-  const byFile = groupByFile(exports);
-  const sorted = [...byFile.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-  const shownFiles = sorted.slice(0, maxFiles);
-
-  for (const [filePath, items] of shownFiles) {
-    lines.push(`  ${filePath}`);
-    const shownItems = items.slice(0, maxPerFile);
-    for (const e of shownItems) {
-      const tag = e.isReExport ? dim(' (re-export)') : '';
-      lines.push(`    ${dim(`:${e.line}`)} ${bold(e.exportName)}${tag}`);
-    }
-    if (items.length > maxPerFile) {
-      lines.push(`    ${dim(`... and ${items.length - maxPerFile} more`)}`);
-    }
-  }
-
-  const hiddenFiles = sorted.length - shownFiles.length;
-  if (hiddenFiles > 0) {
-    const hiddenItems = sorted.slice(maxFiles).reduce((s, [, v]) => s + v.length, 0);
-    lines.push(`  ${dim(`... and ${hiddenItems} more in ${hiddenFiles} file${hiddenFiles === 1 ? '' : 's'}`)}`);
-  }
-  lines.push('');
-  return lines;
-}
-
-export function formatUnusedDeps(deps: FallowUnusedDependency[]): string[] {
-  if (deps.length === 0) return [];
-  const lines: string[] = [sectionHeader('Unused dependencies', deps.length)];
-  for (const d of deps) {
-    const workspaces = d.usedInWorkspaces.length > 0
-      ? dim(` (imported in ${d.usedInWorkspaces.join(', ')})`)
-      : '';
-    lines.push(`  ${bold(d.name)}${workspaces}`);
-  }
-  lines.push('');
-  return lines;
-}
-
-export function formatUnusedMembers(members: FallowUnusedMember[], title = 'Unused class members'): string[] {
-  if (members.length === 0) return [];
-  const total = members.length;
-  const lines: string[] = [sectionHeader(title, total)];
-
-  const byFile = groupByFile(members);
-  const sorted = [...byFile.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-  const shownFiles = sorted.slice(0, MAX_GROUPED_FILES);
-
-  for (const [filePath, items] of shownFiles) {
-    lines.push(`  ${filePath}`);
-    for (const m of items.slice(0, MAX_ITEMS_PER_FILE)) {
-      lines.push(`    ${dim(`:${m.line}`)} ${bold(`${m.parentName}.${m.memberName}`)}`);
-    }
-    if (items.length > MAX_ITEMS_PER_FILE) {
-      lines.push(`    ${dim(`... and ${items.length - MAX_ITEMS_PER_FILE} more`)}`);
-    }
-  }
-
-  const hiddenFiles = sorted.length - shownFiles.length;
-  if (hiddenFiles > 0) {
-    const hiddenItems = sorted.slice(MAX_GROUPED_FILES).reduce((s, [, v]) => s + v.length, 0);
-    lines.push(`  ${dim(`... and ${hiddenItems} more in ${hiddenFiles} file${hiddenFiles === 1 ? '' : 's'}`)}`);
-  }
-  lines.push('');
-  return lines;
-}
-
-export function formatUnresolvedImports(imports: FallowUnresolvedImport[]): string[] {
-  if (imports.length === 0) return [];
-  const total = imports.length;
-  const lines: string[] = [sectionHeader('Unresolved imports', total)];
-
-  const byFile = groupByFile(imports);
-  const sorted = [...byFile.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-  const shownFiles = sorted.slice(0, MAX_GROUPED_FILES);
-
-  for (const [filePath, items] of shownFiles) {
-    lines.push(`  ${filePath}`);
-    for (const i of items.slice(0, MAX_ITEMS_PER_FILE)) {
-      lines.push(`    ${dim(`:${i.line}`)} ${bold(i.specifier)}`);
-    }
-    if (items.length > MAX_ITEMS_PER_FILE) {
-      lines.push(`    ${dim(`... and ${items.length - MAX_ITEMS_PER_FILE} more`)}`);
-    }
-  }
-
-  const hiddenFiles = sorted.length - shownFiles.length;
-  if (hiddenFiles > 0) {
-    const hiddenItems = sorted.slice(MAX_GROUPED_FILES).reduce((s, [, v]) => s + v.length, 0);
-    lines.push(`  ${dim(`... and ${hiddenItems} more in ${hiddenFiles} file${hiddenFiles === 1 ? '' : 's'}`)}`);
-  }
-  lines.push('');
-  return lines;
-}
-
-export function buildCheckHumanLines(results: FallowAnalysisResults, opts: HumanCheckOptions = {}): string[] {
-  const lines: string[] = [];
-
-  const unusedFileSet = new Set(results.unusedFiles.map(f => f.filePath));
-  const filteredExports = results.unusedExports.filter(e => !unusedFileSet.has(e.filePath));
-  const filteredTypes = results.unusedTypes.filter(e => !unusedFileSet.has(e.filePath));
-
-  const hasUnusedCode =
-    results.unusedFiles.length > 0 ||
-    filteredExports.length > 0 ||
-    filteredTypes.length > 0 ||
-    results.unusedEnumMembers.length > 0 ||
-    results.unusedClassMembers.length > 0;
-
-  const hasDeps =
-    results.unusedDependencies.length > 0 ||
-    results.unusedDevDependencies.length > 0 ||
-    results.unresolvedImports.length > 0 ||
-    results.unlistedDependencies.length > 0 ||
-    results.typeOnlyDependencies.length > 0 ||
-    results.testOnlyDependencies.length > 0;
-
-  const hasStructure =
-    results.duplicateExports.length > 0 ||
-    results.circularDependencies.length > 0 ||
-    results.boundaryViolations.length > 0;
-
-  if (hasUnusedCode) {
-    lines.push(categoryHeader('Unused Code'));
-    lines.push('');
-    lines.push(...formatUnusedFiles(results.unusedFiles, opts));
-    lines.push(...formatUnusedExports(filteredExports, opts));
-    if (filteredTypes.length > 0) {
-      const typeLines = formatUnusedExports(filteredTypes, opts);
-      if (typeLines.length > 0) {
-        typeLines[0] = sectionHeader('Unused type exports', filteredTypes.length);
-      }
-      lines.push(...typeLines);
-    }
-    lines.push(...formatUnusedMembers(results.unusedEnumMembers, 'Unused enum members'));
-    lines.push(...formatUnusedMembers(results.unusedClassMembers, 'Unused class members'));
-  }
-
-  if (hasDeps) {
-    lines.push(categoryHeader('Dependencies'));
-    lines.push('');
-    lines.push(...formatUnusedDeps(results.unusedDependencies));
-    if (results.unusedDevDependencies.length > 0) {
-      const devLines = formatUnusedDeps(results.unusedDevDependencies);
-      if (devLines.length > 0) devLines[0] = sectionHeader('Unused devDependencies', results.unusedDevDependencies.length);
-      lines.push(...devLines);
-    }
-    lines.push(...formatUnresolvedImports(results.unresolvedImports));
-    if (results.unlistedDependencies.length > 0) {
-      lines.push(sectionHeader('Unlisted dependencies', results.unlistedDependencies.length));
-      for (const d of results.unlistedDependencies) {
-        lines.push(`  ${bold(d.name)}`);
-      }
-      lines.push('');
-    }
-    if (results.typeOnlyDependencies.length > 0) {
-      lines.push(sectionHeader('Type-only dependencies (consider moving to devDependencies)', results.typeOnlyDependencies.length));
-      for (const d of results.typeOnlyDependencies) {
-        lines.push(`  ${bold(d.name)}`);
-      }
-      lines.push('');
-    }
-    if (results.testOnlyDependencies.length > 0) {
-      lines.push(sectionHeader('Test-only production dependencies (consider moving to devDependencies)', results.testOnlyDependencies.length));
-      for (const d of results.testOnlyDependencies) {
-        lines.push(`  ${bold(d.name)}`);
-      }
-      lines.push('');
-    }
-  }
-
-  if (hasStructure) {
-    lines.push(categoryHeader('Structure'));
-    lines.push('');
-    if (results.duplicateExports.length > 0) {
-      lines.push(sectionHeader('Duplicate exports', results.duplicateExports.length));
-      for (const dup of results.duplicateExports.slice(0, MAX_FLAT)) {
-        const locs = dup.locations.map(l => `${l.filePath}:${l.line}`).join(' ↔ ');
-        lines.push(`  ${bold(dup.exportName)}  ${dim(locs)}`);
-      }
-      lines.push('');
-    }
-    if (results.circularDependencies.length > 0) {
-      lines.push(sectionHeader('Circular dependencies', results.circularDependencies.length));
-      for (const c of results.circularDependencies.slice(0, MAX_FLAT)) {
-        lines.push(`  ${c.cycle.join(dim(' → '))}`);
-      }
-      lines.push('');
-    }
-    if (results.boundaryViolations.length > 0) {
-      lines.push(sectionHeader('Boundary violations', results.boundaryViolations.length));
-      for (const v of results.boundaryViolations.slice(0, MAX_FLAT)) {
-        lines.push(`  ${v.fromPath}:${v.line} ${dim('→')} ${v.toPath} ${dim(`(${v.fromZone} → ${v.toZone})`)}`);
-      }
-      lines.push('');
-    }
-  }
-
-  if (results.staleSuppressions.length > 0) {
-    lines.push(categoryHeader('Maintenance'));
-    lines.push('');
-    lines.push(sectionHeader('Stale suppressions', results.staleSuppressions.length));
-    for (const s of results.staleSuppressions.slice(0, MAX_FLAT)) {
-      lines.push(`  ${s.filePath}:${s.commentLine}  ${dim(s.issueKind ?? 'unknown')}`);
-    }
-    lines.push('');
-  }
-
-  return lines;
-}