@kb-labs/qa-core 2.93.0 → 2.96.0

package/dist/report/index.js

@@ -1,452 +1,222 @@
-import { getCheckIcon, getCheckLabel } from '@kb-labs/qa-contracts';
-
-// src/report/json-reporter.ts
-function buildJsonReport(results, diff, checks) {
-  const severityMap = {};
-  if (checks) {
-    for (const c of checks) {
-      severityMap[c.id] = c.severity ?? "blocker";
-    }
-  }
-  const hasBlockerFailures = Object.entries(results).some(([ct, r]) => {
-    const sev = severityMap[ct] ?? "blocker";
-    return sev !== "info" && sev !== "warning" && r.failed.length > 0;
-  });
-  const summary = {};
-  const failures = {};
-  const errors = {};
-  const blockers = [];
-  const warnings = [];
-  for (const ct of Object.keys(results)) {
-    const r = results[ct];
-    const total = r.passed.length + r.failed.length + r.skipped.length;
-    summary[ct] = {
-      total,
-      passed: r.passed.length,
-      failed: r.failed.length,
-      skipped: r.skipped.length
-    };
-    failures[ct] = [...r.failed];
-    errors[ct] = { ...r.errors };
-    if (r.failed.length > 0) {
-      const sev = severityMap[ct] ?? "blocker";
-      const items = r.failed.flatMap((target) => {
-        const detailItems = r.details?.[target];
-        if (detailItems && detailItems.length > 0) {
-          return detailItems;
-        }
-        const msg = r.errors[target];
-        return msg ? [{ target, message: msg }] : [{ target, message: `check ${ct} failed` }];
-      });
-      if (sev === "blocker") {
-        blockers.push({ check: ct, items });
-      } else if (sev === "warning") {
-        warnings.push({ check: ct, items });
-      }
-    }
-  }
-  return {
-    status: hasBlockerFailures ? "failed" : "passed",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    summary,
-    failures,
-    errors,
-    baseline: diff ?? null,
-    blockers,
-    warnings
-  };
-}
-function buildDetailedJsonReport(results, grouped, diff, checks) {
-  const base = buildJsonReport(results, diff, checks);
-  return { ...base, grouped };
+// src/report/text-reporter.ts
+function formatTaskName(task) {
+  return task.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
-function icon(ct) {
-  return getCheckIcon(ct);
-}
-function label(ct) {
-  return getCheckLabel(ct);
-}
-function buildBaselineDiffLines(diff) {
-  const lines = [];
-  for (const ct of Object.keys(diff)) {
-    const d = diff[ct];
-    if (d.newFailures.length > 0) {
-      lines.push(`${icon(ct)} ${label(ct)}: +${d.newFailures.length} new failures`);
-      for (const pkg of d.newFailures) {
-        lines.push(`     - ${pkg}`);
-      }
-    }
-    if (d.fixed.length > 0) {
-      lines.push(`${icon(ct)} ${label(ct)}: -${d.fixed.length} fixed`);
-    }
+function buildRunReport(snap) {
+  if (!snap) {
+    return [{ header: "Run", lines: ["No run data available."] }];
   }
-  return lines;
-}
-function buildRunReport(results, diff) {
   const sections = [];
-  const summaryLines = [];
-  let totalPassed = 0;
-  let totalFailed = 0;
-  let totalSkipped = 0;
-  for (const ct of Object.keys(results)) {
-    const r = results[ct];
-    const total = r.passed.length + r.failed.length + r.skipped.length;
-    const pct = total > 0 ? Math.round(r.passed.length / total * 100) : 100;
-    const status = r.failed.length === 0 ? "PASS" : "FAIL";
-    summaryLines.push(`${status} ${icon(ct)}  ${label(ct).padEnd(12)} ${r.passed.length}/${total} passed (${pct}%)`);
-    if (r.failed.length > 0) {
-      for (const pkg of r.failed.slice(0, 5)) {
-        summaryLines.push(`     - ${pkg}`);
-      }
-      if (r.failed.length > 5) {
-        summaryLines.push(`     ... and ${r.failed.length - 5} more`);
+  const tasks = [...new Set(snap.raw.results.map((r) => r.Task))];
+  for (const task of tasks) {
+    const results = snap.raw.results.filter((r) => r.Task === task);
+    const passed = results.filter((r) => r.OK && !r.Cached).length;
+    const failed = results.filter((r) => !r.OK && !r.Cached).length;
+    const cached = results.filter((r) => r.Cached).length;
+    const failedPkgs = results.filter((r) => !r.OK && !r.Cached).map((r) => r.Package);
+    const lines = [`pass ${passed}  fail ${failed}  cached ${cached}`];
+    if (failedPkgs.length > 0) {
+      const shown = failedPkgs.slice(0, 5);
+      lines.push(...shown.map((p2) => `  \u2717 ${p2}`));
+      if (failedPkgs.length > 5) {
+        lines.push(`  ... ${failedPkgs.length - 5} more`);
       }
     }
-    totalPassed += r.passed.length;
-    totalFailed += r.failed.length;
-    totalSkipped += r.skipped.length;
-  }
-  sections.push({ header: "QA Summary Report", lines: summaryLines });
-  if (diff) {
-    const diffLines = buildBaselineDiffLines(diff);
-    if (diffLines.length > 0) {
-      sections.push({ header: "Baseline Comparison", lines: diffLines });
-    }
+    sections.push({ header: formatTaskName(task), lines });
   }
+  const status = snap.raw.ok ? "passed" : "failed";
+  const { total, passed: p, failed: f, cached: c } = snap.raw.summary;
   sections.push({
-    header: "Totals",
-    lines: [`Total: ${totalPassed} passed, ${totalFailed} failed, ${totalSkipped} skipped`]
+    header: "Summary",
+    lines: [`${status.toUpperCase()}  total ${total}  pass ${p}  fail ${f}  cached ${c}  (${snap.raw.elapsed})`]
   });
   return sections;
 }
-function buildHistoryTable(history, limit = 20) {
-  const entries = history.slice(-limit);
-  const lines = [];
-  for (const entry of entries) {
-    const date = new Date(entry.timestamp).toLocaleDateString();
-    const status = entry.status === "passed" ? "PASS" : "FAIL";
-    const summary = Object.keys(entry.summary).map((ct) => {
-      const s = entry.summary[ct];
-      return `${icon(ct)} ${s.failed}F`;
-    }).join(" ");
-    lines.push(`${date} ${entry.git.commit} ${status} ${summary} ${entry.git.message.slice(0, 40)}`);
+function buildCheckReport(snap) {
+  if (!snap) {
+    return [{ header: "Check", lines: ["No check data available."] }];
   }
-  return [{ header: `QA History (last ${entries.length})`, lines }];
-}
-function buildTrendsReport(trends, history) {
-  if (trends.length === 0) {
-    return [{ header: "QA Trends", lines: ["Not enough history (need at least 2 entries)"] }];
-  }
-  const lines = [];
-  for (const t of trends) {
-    const arrow = t.delta > 0 ? `+${t.delta} (regression)` : t.delta < 0 ? `${t.delta} (improvement)` : "\u2192 no change";
-    lines.push(`${icon(t.checkType)} ${label(t.checkType).padEnd(12)} ${t.previous} \u2192 ${t.current}  ${arrow}`);
+  const sections = [];
+  for (const [pkg, pkgData] of Object.entries(snap.raw.packages)) {
+    const issues = pkgData.issues ?? [];
+    if (issues.length === 0) {
+      continue;
+    }
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warning").length;
+    const infos = issues.filter((i) => i.severity === "info").length;
+    const lines = [`errors ${errors}  warnings ${warnings}  info ${infos}`];
+    for (const issue of issues.slice(0, 5)) {
+      lines.push(`  [${issue.severity}] ${issue.check}: ${issue.message}`);
+    }
+    if (issues.length > 5) {
+      lines.push(`  ... ${issues.length - 5} more`);
+    }
+    sections.push({ header: pkg, lines });
   }
-  if (history.length >= 2) {
-    const first = history[Math.max(0, history.length - 10)];
-    const last = history[history.length - 1];
-    lines.push("");
-    lines.push(`Period: ${new Date(first.timestamp).toLocaleDateString()} \u2192 ${new Date(last.timestamp).toLocaleDateString()}`);
+  if (sections.length === 0) {
+    sections.push({ header: "Check", lines: ["All packages OK."] });
   }
-  return [{ header: "QA Trends", lines }];
+  return sections;
 }
-function buildRegressionsReport(result, history) {
-  if (history.length < 2) {
-    return [{ header: "Regression Detection", lines: ["Not enough history (need at least 2 entries)"] }];
+function buildStatsReport(snap) {
+  if (!snap) {
+    return [{ header: "Stats", lines: ["No stats data available."] }];
   }
-  const prev = history[history.length - 2];
-  const curr = history[history.length - 1];
-  const lines = [
-    `Comparing: ${prev.git.commit} \u2192 ${curr.git.commit}`,
-    ""
-  ];
-  if (!result.hasRegressions) {
-    lines.push("No regressions detected.");
-    return [{ header: "Regression Detection", lines }];
-  }
-  for (const r of result.regressions) {
-    lines.push(`${r.checkType}: +${r.newFailures.length} new failures`);
-    for (const pkg of r.newFailures) {
-      lines.push(`  - ${pkg}`);
-    }
+  const { score, grade, summary, by_category, coverage } = snap.raw;
+  const sections = [];
+  sections.push({
+    header: "Score",
+    lines: [`${score}/100  Grade: ${grade}  (${summary.healthy} healthy / ${summary.warning} warning / ${summary.error} error)`]
+  });
+  const catLines = Object.entries(by_category).map(([cat, data]) => {
+    const pct = data.total > 0 ? Math.round(data.healthy / data.total * 100) : 0;
+    return `  ${cat.padEnd(20)} ${data.grade}  ${pct}%  (${data.healthy}/${data.total})`;
+  });
+  sections.push({ header: "By Category", lines: catLines });
+  if (Object.keys(coverage).length > 0) {
+    const covLines = Object.entries(coverage).map(([k, v]) => `  ${k.padEnd(20)} ${v.pct}%  (${v.pass}/${v.total})`);
+    sections.push({ header: "Coverage", lines: covLines });
   }
-  lines.push("");
-  lines.push("REGRESSIONS DETECTED!");
-  return [{ header: "Regression Detection", lines }];
+  return sections;
 }
-function buildBaselineReport(baseline) {
-  if (!baseline) {
-    return [{ header: "Baseline Status", lines: ["No baseline captured yet. Run baseline:update first."] }];
+function buildHistoryTable(history, limit = 20) {
+  const rows = [...history].reverse().slice(0, limit);
+  if (rows.length === 0) {
+    return [{ header: "History", lines: ["No history available."] }];
+  }
+  const lines = rows.map((snap) => {
+    const status = snap.raw.ok ? "pass" : "fail";
+    const tasks = snap.tasks.join(", ");
+    const commit = snap.git?.commit ?? "-------";
+    const date = new Date(snap.timestamp).toLocaleString();
+    return `  ${date}  ${commit}  ${status}  [${tasks}]`;
+  });
+  return [{ header: `History (last ${rows.length})`, lines }];
+}
+function buildTrendsReport(analysis) {
+  if (analysis.tasks.length === 0) {
+    return [{ header: "Trends", lines: ["Not enough history for trend analysis."] }];
   }
-  const lines = [
-    `Captured: ${new Date(baseline.timestamp).toLocaleString()}`,
-    `Git: ${baseline.git.commit} (${baseline.git.branch})`,
-    ""
-  ];
-  for (const ct of Object.keys(baseline.results)) {
-    const r = baseline.results[ct];
-    lines.push(`${icon(ct)} ${label(ct).padEnd(12)} ${r.passed} passed, ${r.failed} failed`);
-    if (r.failedPackages.length > 0) {
-      const shown = r.failedPackages.slice(0, 3);
-      for (const pkg of shown) {
-        lines.push(`     - ${pkg}`);
+  const sections = [];
+  for (const trend of analysis.tasks) {
+    const arrow = trend.direction === "regression" ? "\u2191" : trend.direction === "improvement" ? "\u2193" : "\u2192";
+    const lines = [
+      `${arrow} ${trend.direction}  prev ${trend.previous}  curr ${trend.current}  delta ${trend.delta > 0 ? "+" : ""}${trend.delta}  velocity ${trend.velocity}`
+    ];
+    if (trend.changelog.length > 0) {
+      const last = trend.changelog[trend.changelog.length - 1];
+      if (last.newFailures.length > 0) {
+        lines.push(`  last regression: ${last.newFailures.slice(0, 3).join(", ")}`);
       }
-      if (r.failedPackages.length > 3) {
-        lines.push(`     ... and ${r.failedPackages.length - 3} more`);
+      if (last.fixed.length > 0) {
+        lines.push(`  last fixed: ${last.fixed.slice(0, 3).join(", ")}`);
       }
     }
+    sections.push({ header: formatTaskName(trend.task), lines });
   }
-  return [{ header: "Baseline Status", lines }];
-}
-function checkTag(status, ct) {
-  const short = ct === "typeCheck" ? "types" : ct;
-  if (status === "failed") {
-    return short.toUpperCase();
-  }
-  if (status === "skipped") {
-    return `-${short}-`;
-  }
-  return short;
-}
-function getErrorPreview(raw) {
-  const errLines = raw.split("\n").filter((l) => l.trim().length > 0);
-  for (const el of errLines) {
-    const cleaned = el.replace(/^Command failed: .*/, "").trim();
-    if (cleaned.length > 0) {
-      return cleaned.replace(/\/[^\s]*\/kb-labs\//g, "").slice(0, 100);
-    }
-  }
-  return "";
+  return sections;
 }
-function renderPackageLines(pkg, lines) {
-  const hasFail = Object.values(pkg.checks).some((v) => v === "failed");
-  const status = hasFail ? "FAIL" : "PASS";
-  const tags = Object.keys(pkg.checks).map((ct) => checkTag(pkg.checks[ct], ct)).join(" ");
-  lines.push(`    ${status} ${pkg.name.padEnd(40)} ${tags}`);
-  if (hasFail) {
-    for (const ct of Object.keys(pkg.checks)) {
-      if (pkg.checks[ct] === "failed") {
-        const preview = getErrorPreview((pkg.errors[ct] ?? "").trim());
-        lines.push(`         ${ct}: ${preview || "failed"}`);
-      }
-    }
+function buildRegressionsReport(detection) {
+  if (!detection.hasRegressions) {
+    return [{ header: "Regressions", lines: ["No regressions detected."] }];
   }
+  const sections = [];
+  for (const reg of detection.regressions) {
+    const lines = [
+      `delta +${reg.delta}`,
+      ...reg.newFailures.slice(0, 5).map((p) => `  \u2717 ${p}`)
+    ];
+    if (reg.newFailures.length > 5) {
+      lines.push(`  ... ${reg.newFailures.length - 5} more`);
+    }
+    sections.push({ header: formatTaskName(reg.task), lines });
+  }
+  const prev = new Date(detection.comparedAt.previous).toLocaleString();
+  const curr = new Date(detection.comparedAt.current).toLocaleString();
+  sections.push({ header: "Compared", lines: [`${prev} \u2192 ${curr}`] });
+  return sections;
 }
-function renderCategoryLines(catKey, grouped) {
-  const cat = grouped.categories[catKey];
-  const lines = [`PASS ${cat.summary.passed} | FAIL ${cat.summary.failed}`, ""];
-  for (const repoKey of Object.keys(cat.repos).sort()) {
-    const repo = cat.repos[repoKey];
-    lines.push(`  ${repoKey} (${repo.summary.total} packages)`);
-    const sorted = [...repo.packages].sort((a, b) => {
-      const aFail = Object.values(a.checks).some((v) => v === "failed") ? 0 : 1;
-      const bFail = Object.values(b.checks).some((v) => v === "failed") ? 0 : 1;
-      if (aFail !== bFail) {
-        return aFail - bFail;
-      }
-      return a.name.localeCompare(b.name);
-    });
-    for (const pkg of sorted) {
-      renderPackageLines(pkg, lines);
-    }
-    lines.push("");
-  }
-  return lines;
-}
-function buildDetailedRunReport(grouped, diff) {
+function buildBaselineReport(baseline) {
+  if (!baseline) {
+    return [{ header: "Baseline", lines: ["No baseline set. Run `qa baseline update` to set one."] }];
+  }
+  const { score, grade } = baseline.stats;
+  const totalIssues = Object.values(baseline.check.packages).reduce((sum, pkg) => sum + (pkg.issues?.length ?? 0), 0);
+  const commit = baseline.git?.commit ?? "unknown";
+  const date = new Date(baseline.timestamp).toLocaleString();
+  return [{
+    header: "Baseline",
+    lines: [`score ${score}/100  grade ${grade}  issues ${totalIssues}  commit ${commit}  set ${date}`]
+  }];
+}
+function buildBaselineDiffReport(diff) {
   const sections = [];
-  const categoryKeys = Object.keys(grouped.categories).sort((a, b) => {
-    if (a === "uncategorized") {
-      return 1;
-    }
-    if (b === "uncategorized") {
-      return -1;
-    }
-    return a.localeCompare(b);
+  const scoreDir = diff.scoreDelta > 0 ? "+" : "";
+  sections.push({
+    header: "Score Delta",
+    lines: [`${scoreDir}${diff.scoreDelta}  ${diff.gradeDelta}  new ${diff.newIssueCount}  fixed ${diff.fixedIssueCount}`]
   });
-  for (const catKey of categoryKeys) {
-    const cat = grouped.categories[catKey];
-    sections.push({ header: `${cat.label} (${cat.summary.total} packages)`, lines: renderCategoryLines(catKey, grouped) });
+  if (diff.newIssues.length > 0) {
+    const lines = diff.newIssues.slice(0, 10).map((i) => `  [${i.severity}] ${i.pkg}  ${i.check}: ${i.message}`);
+    if (diff.newIssues.length > 10) {
+      lines.push(`  ... ${diff.newIssues.length - 10} more`);
+    }
+    sections.push({ header: "New Issues", lines });
   }
-  if (diff) {
-    const diffLines = buildBaselineDiffLines(diff);
-    if (diffLines.length > 0) {
-      sections.push({ header: "Baseline Comparison", lines: diffLines });
+  if (diff.fixedIssues.length > 0) {
+    const lines = diff.fixedIssues.slice(0, 10).map((i) => `  [${i.severity}] ${i.pkg}  ${i.check}: ${i.message}`);
+    if (diff.fixedIssues.length > 10) {
+      lines.push(`  ... ${diff.fixedIssues.length - 10} more`);
     }
+    sections.push({ header: "Fixed Issues", lines });
   }
-  let totalPassed = 0;
-  let totalFailed = 0;
-  for (const catKey of categoryKeys) {
-    totalPassed += grouped.categories[catKey].summary.passed;
-    totalFailed += grouped.categories[catKey].summary.failed;
+  if (diff.persistingIssues.length > 0) {
+    sections.push({ header: "Persisting Issues", lines: [`${diff.persistingIssues.length} issues unchanged`] });
   }
-  sections.push({
-    header: "Totals",
-    lines: [`Total: ${totalPassed} passed, ${totalFailed} failed (${categoryKeys.length} categories)`]
-  });
   return sections;
 }
 
-// src/report/grouped-reporter.ts
-function emptyGroupSummary(checkTypes) {
-  const checks = {};
-  for (const ct of checkTypes) {
-    checks[ct] = { passed: 0, failed: 0, skipped: 0 };
-  }
-  return { total: 0, passed: 0, failed: 0, checks };
-}
-function resolveCheckStatus(pkgName, ct, results) {
-  const r = results[ct];
-  if (!r) {
-    return "skipped";
-  }
-  if (r.failed.includes(pkgName)) {
-    return "failed";
-  }
-  if (r.passed.includes(pkgName)) {
-    return "passed";
-  }
-  return "skipped";
-}
-function buildPackageStatus(pkg, results, category) {
-  const checks = {};
-  const errors = {};
-  for (const ct of Object.keys(results)) {
-    checks[ct] = resolveCheckStatus(pkg.name, ct, results);
-    if (checks[ct] === "failed" && results[ct]?.errors[pkg.name]) {
-      errors[ct] = results[ct].errors[pkg.name];
-    }
-  }
+// src/report/json-reporter.ts
+function buildRunJsonReport(snap) {
   return {
-    name: pkg.name,
-    repo: pkg.repo,
-    category,
-    checks,
-    errors
+    id: snap.id,
+    timestamp: snap.timestamp,
+    git: snap.git,
+    durationMs: snap.durationMs,
+    tasks: snap.tasks,
+    ok: snap.raw.ok,
+    elapsed: snap.raw.elapsed,
+    summary: snap.raw.summary,
+    results: snap.raw.results
   };
 }
-function addToSummary(summary, status) {
-  summary.total++;
-  const hasFail = Object.values(status.checks).some((v) => v === "failed");
-  if (hasFail) {
-    summary.failed++;
-  } else {
-    summary.passed++;
-  }
-  for (const ct of Object.keys(status.checks)) {
-    const s = status.checks[ct];
-    if (!summary.checks[ct]) {
-      summary.checks[ct] = { passed: 0, failed: 0, skipped: 0 };
-    }
-    if (s === "passed") {
-      summary.checks[ct].passed++;
-    } else if (s === "failed") {
-      summary.checks[ct].failed++;
-    } else {
-      summary.checks[ct].skipped++;
-    }
-  }
-}
-function groupResults(results, packages, categoryMap, config) {
-  const checkTypes = Object.keys(results);
-  const grouped = { categories: {} };
-  for (const pkg of packages) {
-    const categoryKeys = categoryMap.get(pkg.name) ?? ["uncategorized"];
-    for (const categoryKey of categoryKeys) {
-      const status = buildPackageStatus(pkg, results, categoryKey);
-      if (!grouped.categories[categoryKey]) {
-        const label2 = categoryKey === "uncategorized" ? "Uncategorized" : config?.categories?.[categoryKey]?.label ?? categoryKey;
-        grouped.categories[categoryKey] = {
-          label: label2,
-          repos: {},
-          summary: emptyGroupSummary(checkTypes)
-        };
-      }
-      const categoryGroup = grouped.categories[categoryKey];
-      if (!categoryGroup.repos[pkg.repo]) {
-        categoryGroup.repos[pkg.repo] = {
-          packages: [],
-          summary: emptyGroupSummary(checkTypes)
-        };
-      }
-      const repoGroup = categoryGroup.repos[pkg.repo];
-      repoGroup.packages.push(status);
-      addToSummary(repoGroup.summary, status);
-      addToSummary(categoryGroup.summary, status);
-    }
-  }
-  return grouped;
-}
-
-// src/report/error-grouping.ts
-function extractPattern(errorText, checkType) {
-  if (checkType === "lint") {
-    const ruleMatch = errorText.match(/(\S+\/[\w-]+|no-[\w-]+)/);
-    if (ruleMatch?.[1]) {
-      return ruleMatch[1];
-    }
-  }
-  if (checkType === "typeCheck") {
-    const tsMatch = errorText.match(/TS(\d{4,5})/);
-    if (tsMatch) {
-      return `TS${tsMatch[1]}`;
-    }
-  }
-  if (checkType === "test") {
-    const failMatch = errorText.match(/FAIL\s+(\S+)/);
-    if (failMatch) {
-      return `FAIL: ${failMatch[1]}`;
-    }
-  }
-  if (checkType === "build") {
-    if (errorText.includes("Cannot find module")) {
-      return "Cannot find module";
-    }
-    if (errorText.includes("Module not found")) {
-      return "Module not found";
-    }
-  }
-  const firstLine = errorText.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
-  return firstLine.slice(0, 100) || "Unknown error";
+function buildCheckJsonReport(snap) {
+  return {
+    id: snap.id,
+    timestamp: snap.timestamp,
+    git: snap.git,
+    durationMs: snap.durationMs,
+    ok: snap.raw.ok,
+    packages: snap.raw.packages
+  };
 }
-function groupErrors(results) {
-  const groupMap = /* @__PURE__ */ new Map();
-  let ungrouped = 0;
-  for (const ct of Object.keys(results)) {
-    const check = results[ct];
-    if (!check.errors) {
-      continue;
-    }
-    for (const [pkgName, errorText] of Object.entries(check.errors)) {
-      const pattern = extractPattern(errorText, ct);
-      const key = `${ct}::${pattern}`;
-      const existing = groupMap.get(key);
-      if (existing) {
-        existing.count++;
-        existing.packages.push(pkgName);
-      } else {
-        groupMap.set(key, {
-          pattern,
-          count: 1,
-          packages: [pkgName],
-          checkType: ct,
-          example: errorText.slice(0, 200)
-        });
-      }
-    }
-  }
-  const groups = [];
-  for (const group of groupMap.values()) {
-    if (group.count === 1) {
-      ungrouped++;
-    } else {
-      groups.push(group);
-    }
-  }
-  groups.sort((a, b) => b.count - a.count);
-  return { groups, ungrouped };
+function buildStatsJsonReport(snap) {
+  return {
+    id: snap.id,
+    timestamp: snap.timestamp,
+    git: snap.git,
+    durationMs: snap.durationMs,
+    ok: snap.raw.ok,
+    score: snap.raw.score,
+    grade: snap.raw.grade,
+    summary: snap.raw.summary,
+    by_category: snap.raw.by_category,
+    issues_by_type: snap.raw.issues_by_type,
+    coverage: snap.raw.coverage
+  };
 }
 
-export { buildBaselineReport, buildDetailedJsonReport, buildDetailedRunReport, buildHistoryTable, buildJsonReport, buildRegressionsReport, buildRunReport, buildTrendsReport, groupErrors, groupResults };
+export { buildBaselineDiffReport, buildBaselineReport, buildCheckJsonReport, buildCheckReport, buildHistoryTable, buildRegressionsReport, buildRunJsonReport, buildRunReport, buildStatsJsonReport, buildStatsReport, buildTrendsReport, formatTaskName };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map