@monoes/monograph 1.0.0 → 1.2.0

package/src/report/badge-svg.ts

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,74 @@
+// 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

@@ -0,0 +1,137 @@
+// 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

@@ -0,0 +1,291 @@
+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;
+}