@monoes/monograph 1.5.6 → 1.5.8

package/src/graph/ripple-impact.ts

@@ -1,131 +0,0 @@
-/**
- * Ripple / cascade impact analysis.
- *
- * Given a starting node, perform a multi-hop BFS through *directed* edges and
- * compute how far a change can propagate.  Each depth level is assigned a
- * decaying weight so that direct dependents (depth 1) contribute more to the
- * totalScore than transitive dependents.
- *
- * Default decay factor: 0.5 per hop (configurable).
- */
-
-export interface RippleEdge {
-  sourceId: string;
-  targetId: string;
-}
-
-export interface RippleResult {
-  /** Nodes reachable at each depth, starting at depth 1 (direct neighbors). */
-  byDepth: Record<number, string[]>;
-  /** Weighted sum: Σ(count_at_depth * decay^depth). */
-  totalScore: number;
-}
-
-/**
- * Build a directed outgoing adjacency map from an edge list.
- *
- * Callers that run rippleImpact for multiple starting nodes on the same edge set
- * should build once and pass the map directly to `rippleImpactFromMap`.
- */
-export function buildOutgoingMap(edges: RippleEdge[]): Map<string, string[]> {
-  const outgoing = new Map<string, string[]>();
-  for (const { sourceId, targetId } of edges) {
-    if (!outgoing.has(sourceId)) outgoing.set(sourceId, []);
-    outgoing.get(sourceId)!.push(targetId);
-  }
-  return outgoing;
-}
-
-/**
- * Compute the ripple impact of changing `startNodeId` using a pre-built
- * outgoing adjacency map.
- *
- * Use this variant when querying multiple start nodes on the same edge set —
- * build the map once with `buildOutgoingMap` and reuse it across calls.
- *
- * @param startNodeId  The node whose change we are propagating.
- * @param outgoing     Pre-built directed adjacency map (source → targets).
- * @param maxDepth     Maximum BFS depth (default 3).
- * @param decayFactor  Weight multiplier per depth level (default 0.5).
- */
-export function rippleImpactFromMap(
-  startNodeId: string,
-  outgoing: Map<string, string[]>,
-  maxDepth = 3,
-  decayFactor = 0.5,
-): RippleResult {
-  if (!outgoing.has(startNodeId)) {
-    return { byDepth: {}, totalScore: 0 };
-  }
-
-  const visited = new Set<string>([startNodeId]);
-  const byDepth: Record<number, string[]> = {};
-  let frontier = [startNodeId];
-  let totalScore = 0;
-
-  for (let depth = 1; depth <= maxDepth; depth++) {
-    const nextFrontier: string[] = [];
-    for (const node of frontier) {
-      for (const neighbor of outgoing.get(node) ?? []) {
-        if (!visited.has(neighbor)) {
-          visited.add(neighbor);
-          nextFrontier.push(neighbor);
-        }
-      }
-    }
-    if (nextFrontier.length === 0) break;
-    byDepth[depth] = nextFrontier;
-    totalScore += nextFrontier.length * Math.pow(decayFactor, depth);
-    frontier = nextFrontier;
-  }
-
-  return { byDepth, totalScore };
-}
-
-/**
- * Compute the ripple impact of changing `startNodeId`.
- *
- * Builds the adjacency map from `edges` on each call. For repeated queries
- * over the same edge set, prefer `buildOutgoingMap` + `rippleImpactFromMap`.
- *
- * @param startNodeId  The node whose change we are propagating.
- * @param edges        Directed edges in the graph.
- * @param maxDepth     Maximum BFS depth (default 3).
- * @param decayFactor  Weight multiplier per depth level (default 0.5).
- */
-export function rippleImpact(
-  startNodeId: string,
-  edges: RippleEdge[],
-  maxDepth = 3,
-  decayFactor = 0.5,
-): RippleResult {
-  return rippleImpactFromMap(startNodeId, buildOutgoingMap(edges), maxDepth, decayFactor);
-}
-
-/**
- * Format ripple impact results as structured text for LLM consumption.
- */
-export function formatRippleImpact(
-  startNodeId: string,
-  result: RippleResult,
-  nodeLabels?: Map<string, string>,
-): string {
-  const depths = Object.keys(result.byDepth).map(Number).sort((a, b) => a - b);
-  if (depths.length === 0) {
-    return `No ripple impact found for: ${startNodeId} (isolated or leaf node)`;
-  }
-
-  const lines: string[] = [
-    `Ripple impact of changing: ${startNodeId}`,
-    `  Total score: ${result.totalScore.toFixed(3)} (weighted cascade depth)`,
-  ];
-  for (const depth of depths) {
-    const nodes = result.byDepth[depth]!;
-    lines.push(`  Depth ${depth} (${nodes.length} node${nodes.length === 1 ? '' : 's'}):`);
-    for (const id of nodes) {
-      const label = nodeLabels?.get(id);
-      lines.push(`    - ${id}${label ? ` [${label}]` : ''}`);
-    }
-  }
-  return lines.join('\n');
-}

package/src/graph/risk-profile.ts

@@ -1,179 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export interface SizeBin {
-  label: string;    // e.g. '1-10 lines'
-  min: number;
-  max: number;
-  count: number;
-  percentage: number;
-}
-
-export interface RiskProfileReport {
-  functionSizeDistribution: SizeBin[];
-  paramCountDistribution: SizeBin[];
-  riskSummary: {
-    largeFunction: number;    // LOC > 100
-    longParamList: number;    // params > 5
-    highRisk: number;         // BOTH large AND long param list
-  };
-  p50loc: number;
-  p90loc: number;
-  p95loc: number;
-}
-
-interface FunctionNode {
-  start_line: number | null;
-  end_line: number | null;
-  properties: string | null;
-}
-
-const LOC_BINS: Array<{ label: string; min: number; max: number }> = [
-  { label: '1-10 lines',   min: 1,   max: 10  },
-  { label: '11-25 lines',  min: 11,  max: 25  },
-  { label: '26-50 lines',  min: 26,  max: 50  },
-  { label: '51-100 lines', min: 51,  max: 100 },
-  { label: '101-250 lines',min: 101, max: 250 },
-  { label: '250+ lines',   min: 251, max: Infinity },
-];
-
-const PARAM_BINS: Array<{ label: string; min: number; max: number }> = [
-  { label: '0-2 params', min: 0, max: 2 },
-  { label: '3-5 params', min: 3, max: 5 },
-  { label: '6-8 params', min: 6, max: 8 },
-  { label: '9+ params',  min: 9, max: Infinity },
-];
-
-function percentile(sorted: number[], p: number): number {
-  if (sorted.length === 0) return 0;
-  const idx = Math.floor(sorted.length * p);
-  return sorted[Math.min(idx, sorted.length - 1)];
-}
-
-export function computeRiskProfile(db: MonographDb): RiskProfileReport {
-  // Push paramCount extraction to SQL with json_extract to avoid per-row JSON.parse
-  const rows = db.prepare(`
-    SELECT
-      start_line,
-      end_line,
-      CAST(json_extract(properties, '$.paramCount') AS INTEGER) AS param_count
-    FROM nodes
-    WHERE label IN ('Function', 'Method')
-      AND start_line IS NOT NULL
-      AND end_line IS NOT NULL
-  `).all() as { start_line: number; end_line: number; param_count: number | null }[];
-
-  // ── Single-pass: compute LOC, assign to bins, accumulate risk summary ─────
-  const locBinCounts = new Array<number>(LOC_BINS.length).fill(0);
-  const paramBinCounts = new Array<number>(PARAM_BINS.length).fill(0);
-  const sortedLocs: number[] = [];
-  let largeFunction = 0;
-  let longParamList = 0;
-  let highRisk = 0;
-
-  for (const row of rows) {
-    const loc = row.end_line - row.start_line + 1;
-    if (loc < 1) continue;
-
-    sortedLocs.push(loc);
-
-    // Assign to LOC bin in O(bins) rather than O(N×bins) via filter
-    for (let i = 0; i < LOC_BINS.length; i++) {
-      const bin = LOC_BINS[i];
-      if (loc >= bin.min && loc <= bin.max) {
-        locBinCounts[i]++;
-        break;
-      }
-    }
-
-    const pc = row.param_count ?? 0;
-    for (let i = 0; i < PARAM_BINS.length; i++) {
-      const bin = PARAM_BINS[i];
-      if (pc >= bin.min && pc <= bin.max) {
-        paramBinCounts[i]++;
-        break;
-      }
-    }
-
-    const large = loc > 100;
-    const longParam = pc > 5;
-    if (large) largeFunction++;
-    if (longParam) longParamList++;
-    if (large && longParam) highRisk++;
-  }
-
-  const total = sortedLocs.length;
-
-  // ── Build bin result arrays ───────────────────────────────────────────────
-  const functionSizeDistribution: SizeBin[] = LOC_BINS.map((bin, i) => ({
-    label: bin.label,
-    min: bin.min,
-    max: bin.max === Infinity ? 999999 : bin.max,
-    count: locBinCounts[i],
-    percentage: total > 0 ? Math.round((locBinCounts[i] / total) * 1000) / 10 : 0,
-  }));
-
-  const paramCountDistribution: SizeBin[] = PARAM_BINS.map((bin, i) => ({
-    label: bin.label,
-    min: bin.min,
-    max: bin.max === Infinity ? 999999 : bin.max,
-    count: paramBinCounts[i],
-    percentage: total > 0 ? Math.round((paramBinCounts[i] / total) * 1000) / 10 : 0,
-  }));
-
-  // ── Percentiles ────────────────────────────────────────────────────────────
-  sortedLocs.sort((a, b) => a - b);
-  const p50loc = percentile(sortedLocs, 0.50);
-  const p90loc = percentile(sortedLocs, 0.90);
-  const p95loc = percentile(sortedLocs, 0.95);
-
-  return {
-    functionSizeDistribution,
-    paramCountDistribution,
-    riskSummary: { largeFunction, longParamList, highRisk },
-    p50loc,
-    p90loc,
-    p95loc,
-  };
-}
-
-/**
- * Format a RiskProfileReport as structured text with distribution tables for LLM navigation.
- *
- * @param report - RiskProfileReport from computeRiskProfile()
- * @returns structured text suitable for LLM consumption
- */
-export function formatRiskProfile(report: RiskProfileReport): string {
-  const { functionSizeDistribution, paramCountDistribution, riskSummary, p50loc, p90loc, p95loc } = report;
-
-  const total = functionSizeDistribution.reduce((s, b) => s + b.count, 0);
-  if (total === 0) {
-    return 'risk_profile: no Function/Method nodes with line info found\n';
-  }
-
-  const lines: string[] = [
-    `risk_profile: ${total} functions analysed`,
-    `  p50_loc: ${p50loc}  p90_loc: ${p90loc}  p95_loc: ${p95loc}`,
-    `  large_functions(loc>100): ${riskSummary.largeFunction}  long_param_list(params>5): ${riskSummary.longParamList}  high_risk(both): ${riskSummary.highRisk}`,
-    '',
-    'function_size_distribution:',
-  ];
-
-  for (const bin of functionSizeDistribution) {
-    const bar = '#'.repeat(Math.round(bin.percentage / 5)); // 1 char per 5%
-    lines.push(`  ${bin.label.padEnd(15)}  ${String(bin.count).padStart(5)}  (${String(bin.percentage).padStart(5)}%)  ${bar}`);
-  }
-
-  lines.push('');
-  lines.push('param_count_distribution:');
-  for (const bin of paramCountDistribution) {
-    const bar = '#'.repeat(Math.round(bin.percentage / 5));
-    lines.push(`  ${bin.label.padEnd(15)}  ${String(bin.count).padStart(5)}  (${String(bin.percentage).padStart(5)}%)  ${bar}`);
-  }
-
-  if (riskSummary.highRisk > 0) {
-    lines.push('');
-    lines.push(`high_risk_note: ${riskSummary.highRisk} function(s) have both loc>100 AND params>5 — prime refactor candidates`);
-  }
-
-  return lines.join('\n');
-}

package/src/graph/statistics.ts

@@ -1,165 +0,0 @@
-import { bfsFromNode } from 'graphology-traversal/bfs.js';
-import type Graph from 'graphology';
-import { loadGraphFromDb } from './loader.js';
-import type { MonographDb } from '../storage/db.js';
-
-// ---------------------------------------------------------------------------
-// Module-level graph cache — avoids reloading the full graph on every call
-// when multiple statistics functions are invoked in the same request cycle.
-// TTL: 5 seconds; keyed by DB file path (better-sqlite3 exposes .name).
-// ---------------------------------------------------------------------------
-const GRAPH_CACHE_TTL_MS = 5_000;
-
-interface GraphCacheEntry {
-  graph: Graph;
-  expiresAt: number;
-}
-
-const _graphCache = new Map<string, GraphCacheEntry>();
-
-function getGraph(db: MonographDb): Graph {
-  const key = (db as unknown as { name: string }).name ?? '__default__';
-  const now = Date.now();
-  const cached = _graphCache.get(key);
-  if (cached && now < cached.expiresAt) return cached.graph;
-  const graph = loadGraphFromDb(db);
-  _graphCache.set(key, { graph, expiresAt: now + GRAPH_CACHE_TTL_MS });
-  return graph;
-}
-
-/**
- * Graph density: ratio of actual edges to maximum possible directed edges.
- * For a directed graph with n nodes: max = n * (n - 1).
- * Ignores self-loops.
- */
-export function graphDensity(db: MonographDb): number {
-  const graph = getGraph(db);
-  const n = graph.order;
-  if (n < 2) return 0;
-  const maxEdges = n * (n - 1);
-  // Use simple directed edge count (deduplicate multi-edges for density)
-  const seen = new Set<string>();
-  graph.forEachEdge((_, _attr, src, tgt) => {
-    if (src !== tgt) seen.add(`${src}→${tgt}`);
-  });
-  return seen.size / maxEdges;
-}
-
-/**
- * Average local clustering coefficient across all nodes.
- * For a directed graph, the local clustering coefficient of node v is:
- *   (triangles through v) / (directed_pairs through v)
- * where directed_pairs = k_in * k_out - mutual_pairs
- * We use the undirected approximation: treat edges as undirected, count triangles.
- */
-export function clusteringCoefficient(db: MonographDb): number {
-  const graph = getGraph(db);
-  if (graph.order === 0) return 0;
-
-  // Build undirected adjacency sets
-  const neighbors = new Map<string, Set<string>>();
-  graph.forEachNode(node => neighbors.set(node, new Set()));
-  graph.forEachEdge((_, _attr, src, tgt) => {
-    if (src !== tgt) {
-      neighbors.get(src)!.add(tgt);
-      neighbors.get(tgt)!.add(src);
-    }
-  });
-
-  let totalCoeff = 0;
-  let countWithNeighbors = 0;
-
-  // Cap per-node neighbor scan to avoid O(k²) explosion on hub nodes
-  const MAX_K = 200;
-  for (const [node, nbrs] of neighbors) {
-    const k = nbrs.size;
-    if (k < 2) continue;
-
-    let triangles = 0;
-    const nbList = k <= MAX_K ? [...nbrs] : [...nbrs].slice(0, MAX_K);
-    const effectiveK = nbList.length;
-    for (let i = 0; i < effectiveK; i++) {
-      for (let j = i + 1; j < effectiveK; j++) {
-        if (neighbors.get(nbList[i])?.has(nbList[j])) {
-          triangles++;
-        }
-      }
-    }
-
-    const possible = (effectiveK * (effectiveK - 1)) / 2;
-    totalCoeff += triangles / possible;
-    countWithNeighbors++;
-  }
-
-  if (countWithNeighbors === 0) return 0;
-  return totalCoeff / countWithNeighbors;
-}
-
-// ---------------------------------------------------------------------------
-// Shared BFS result for path-length metrics
-// ---------------------------------------------------------------------------
-
-export interface PathStats {
-  /** Average shortest path length across all reachable pairs (i ≠ j). */
-  averagePathLength: number;
-  /** Maximum shortest path length (diameter) across all reachable pairs. */
-  diameter: number;
-}
-
-/**
- * Compute both average path length and graph diameter via BFS.
- * For graphs > 500 nodes, uses deterministic sampling (every Nth node)
- * to keep runtime practical — O(sample * E) instead of O(N * E).
- */
-export function pathStats(db: MonographDb): PathStats {
-  const graph = getGraph(db);
-  const nodes = graph.nodes();
-  if (nodes.length < 2) return { averagePathLength: 0, diameter: 0 };
-
-  // Sample sources for large graphs — stride ensures even coverage
-  const MAX_SOURCES = 500;
-  const stride = nodes.length <= MAX_SOURCES ? 1 : Math.ceil(nodes.length / MAX_SOURCES);
-  const sources: string[] = [];
-  for (let i = 0; i < nodes.length && sources.length < MAX_SOURCES; i += stride) {
-    sources.push(nodes[i]);
-  }
-
-  let totalLength = 0;
-  let reachablePairs = 0;
-  let maxDist = 0;
-
-  for (const source of sources) {
-    bfsFromNode(graph, source, (node, _attr, depth) => {
-      if (node !== source && depth > 0) {
-        totalLength += depth;
-        reachablePairs++;
-        if (depth > maxDist) maxDist = depth;
-      }
-    });
-  }
-
-  return {
-    averagePathLength: reachablePairs === 0 ? 0 : totalLength / reachablePairs,
-    diameter: maxDist,
-  };
-}
-
-/**
- * Average shortest path length across all reachable node pairs (i, j) where i ≠ j.
- * Computed using BFS from each node. Unreachable pairs are excluded from the average.
- *
- * @deprecated Prefer `pathStats(db).averagePathLength` to share BFS with `graphDiameter`.
- */
-export function averagePathLength(db: MonographDb): number {
-  return pathStats(db).averagePathLength;
-}
-
-/**
- * Graph diameter: the maximum shortest path length across all reachable node pairs.
- * Returns 0 for empty or single-node graphs.
- *
- * @deprecated Prefer `pathStats(db).diameter` to share BFS with `averagePathLength`.
- */
-export function graphDiameter(db: MonographDb): number {
-  return pathStats(db).diameter;
-}

package/src/graph/stats.ts

@@ -1,157 +0,0 @@
-import type Database from 'better-sqlite3';
-
-// Per-DB prepared statement cache to avoid re-parsing SQL on repeated calls
-const stmtCache = new WeakMap<Database.Database, Map<string, Database.Statement>>();
-
-function stmt(db: Database.Database, sql: string): Database.Statement {
-  let dbCache = stmtCache.get(db);
-  if (!dbCache) { dbCache = new Map(); stmtCache.set(db, dbCache); }
-  let s = dbCache.get(sql);
-  if (!s) { s = db.prepare(sql); dbCache.set(sql, s); }
-  return s;
-}
-
-/** Binary search: returns index of first element > value in a sorted ascending array. */
-function upperBound(sorted: number[], value: number): number {
-  let lo = 0, hi = sorted.length;
-  while (lo < hi) {
-    const mid = (lo + hi) >>> 1;
-    if (sorted[mid] <= value) lo = mid + 1;
-    else hi = mid;
-  }
-  return lo;
-}
-
-export type RiskBin = 'low' | 'medium' | 'high' | 'critical';
-
-export interface RiskProfile {
-  low: number;
-  medium: number;
-  high: number;
-  critical: number;
-  lowPct: number;
-  mediumPct: number;
-  highPct: number;
-  criticalPct: number;
-}
-
-export interface CouplingProfile {
-  p50FanIn: number;
-  p75FanIn: number;
-  p90FanIn: number;
-  p95FanIn: number;
-  couplingHighPct: number;
-  fanInProfile: RiskProfile;
-  fanOutProfile: RiskProfile;
-  totalFiles: number;
-}
-
-export interface GraphStatsSummary {
-  nodeCount: number;
-  edgeCount: number;
-  communityCount: number;
-  fileCount: number;
-  couplingProfile: CouplingProfile;
-}
-
-function percentile(sorted: number[], p: number): number {
-  if (sorted.length === 0) return 0;
-  const idx = Math.floor((p / 100) * sorted.length);
-  return sorted[Math.min(idx, sorted.length - 1)];
-}
-
-function buildRiskProfile(values: number[]): RiskProfile {
-  const total = values.length;
-  let low = 0, medium = 0, high = 0, critical = 0;
-  for (const v of values) {
-    if (v < 5) low++;
-    else if (v <= 15) medium++;
-    else if (v <= 30) high++;
-    else critical++;
-  }
-  const pct = (n: number) => total > 0 ? Math.round((n / total) * 100) : 0;
-  return {
-    low,
-    medium,
-    high,
-    critical,
-    lowPct: pct(low),
-    mediumPct: pct(medium),
-    highPct: pct(high),
-    criticalPct: pct(critical),
-  };
-}
-
-/**
- * Compute full coupling profile from SQLite.
- */
-export function computeCouplingProfile(db: Database.Database): CouplingProfile {
-  const fanInRows = stmt(db, 'SELECT target_id, COUNT(*) as c FROM edges GROUP BY target_id')
-    .all() as { target_id: string; c: number }[];
-
-  const fanOutRows = stmt(db, 'SELECT source_id, COUNT(*) as c FROM edges GROUP BY source_id')
-    .all() as { source_id: string; c: number }[];
-
-  const totalFiles = (stmt(db, "SELECT COUNT(*) as n FROM nodes WHERE label = 'File'")
-    .get() as { n: number }).n;
-
-  const fanInValues = fanInRows.map(r => r.c).sort((a, b) => a - b);
-  const fanOutValues = fanOutRows.map(r => r.c).sort((a, b) => a - b);
-
-  const p95FanIn = percentile(fanInValues, 95);
-  // Use binary search instead of O(N) filter to count elements above p95 threshold
-  const couplingHighCount = fanInValues.length - upperBound(fanInValues, p95FanIn);
-  const couplingHighPct = fanInValues.length > 0
-    ? Math.round((couplingHighCount / fanInValues.length) * 100)
-    : 0;
-
-  return {
-    p50FanIn: percentile(fanInValues, 50),
-    p75FanIn: percentile(fanInValues, 75),
-    p90FanIn: percentile(fanInValues, 90),
-    p95FanIn,
-    couplingHighPct,
-    fanInProfile: buildRiskProfile(fanInValues),
-    fanOutProfile: buildRiskProfile(fanOutValues),
-    totalFiles,
-  };
-}
-
-/**
- * Quick stats summary (extends existing stats from monograph_stats MCP tool).
- */
-export function computeGraphStats(db: Database.Database): GraphStatsSummary {
-  const nodeCount = (stmt(db, 'SELECT COUNT(*) as n FROM nodes').get() as { n: number }).n;
-  const edgeCount = (stmt(db, 'SELECT COUNT(*) as n FROM edges').get() as { n: number }).n;
-  const communityCount = (stmt(db,
-    "SELECT COUNT(DISTINCT community_id) as n FROM nodes WHERE community_id IS NOT NULL"
-  ).get() as { n: number }).n;
-  const fileCount = (stmt(db, "SELECT COUNT(*) as n FROM nodes WHERE label = 'File'")
-    .get() as { n: number }).n;
-
-  const couplingProfile = computeCouplingProfile(db);
-
-  return {
-    nodeCount,
-    edgeCount,
-    communityCount,
-    fileCount,
-    couplingProfile,
-  };
-}
-
-/** Format a GraphStatsSummary as structured text for LLM consumption. */
-export function formatGraphStats(s: GraphStatsSummary): string {
-  const cp = s.couplingProfile;
-  const totalEntities = cp.fanInProfile.low + cp.fanInProfile.medium + cp.fanInProfile.high + cp.fanInProfile.critical;
-  const lines: string[] = [
-    `Graph Stats`,
-    `  Nodes: ${s.nodeCount}  Edges: ${s.edgeCount}  Communities: ${s.communityCount}  Files: ${s.fileCount}`,
-    `Coupling Profile (${totalEntities} entities, ${cp.totalFiles} files)`,
-    `  Fan-in p50/p75/p90/p95: ${cp.p50FanIn}/${cp.p75FanIn}/${cp.p90FanIn}/${cp.p95FanIn}`,
-    `  High-coupling (>p95): ${cp.couplingHighPct}%`,
-    `Fan-in Risk: low=${cp.fanInProfile.low}(${cp.fanInProfile.lowPct}%) med=${cp.fanInProfile.medium}(${cp.fanInProfile.mediumPct}%) high=${cp.fanInProfile.high}(${cp.fanInProfile.highPct}%) crit=${cp.fanInProfile.critical}(${cp.fanInProfile.criticalPct}%)`,
-    `Fan-out Risk: low=${cp.fanOutProfile.low}(${cp.fanOutProfile.lowPct}%) med=${cp.fanOutProfile.medium}(${cp.fanOutProfile.mediumPct}%) high=${cp.fanOutProfile.high}(${cp.fanOutProfile.highPct}%) crit=${cp.fanOutProfile.critical}(${cp.fanOutProfile.criticalPct}%)`,
-  ];
-  return lines.join('\n');
-}