@code-pushup/core 0.48.0 → 0.50.0

package/index.js

@@ -670,6 +670,8 @@ var auditResultSchema = scorableWithPluginMetaSchema.merge(
 );
 var reportsDiffSchema = z15.object({
   commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
+  portalUrl: urlSchema.optional().describe("Link to comparison page in Code PushUp portal"),
+  label: z15.string().optional().describe("Label (e.g. project name)"),
   categories: makeArraysComparisonSchema(
     categoryDiffSchema,
     categoryResultSchema,
@@ -739,15 +741,286 @@ function comparePairs(pairs, equalsFn) {
   );
 }
 
+// packages/utils/src/lib/errors.ts
+function stringifyError(error) {
+  if (error instanceof Error) {
+    if (error.name === "Error" || error.message.startsWith(error.name)) {
+      return error.message;
+    }
+    return `${error.name}: ${error.message}`;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return JSON.stringify(error);
+}
+
 // packages/utils/src/lib/execute-process.ts
-import { spawn } from "node:child_process";
+import {
+  spawn
+} from "node:child_process";
+
+// packages/utils/src/lib/reports/utils.ts
+import ansis from "ansis";
+import { md } from "build-md";
+
+// packages/utils/src/lib/reports/constants.ts
+var TERMINAL_WIDTH = 80;
+var SCORE_COLOR_RANGE = {
+  GREEN_MIN: 0.9,
+  YELLOW_MIN: 0.5
+};
+var FOOTER_PREFIX = "Made with \u2764 by";
+var CODE_PUSHUP_DOMAIN = "code-pushup.dev";
+var README_LINK = "https://github.com/code-pushup/cli#readme";
+var REPORT_HEADLINE_TEXT = "Code PushUp Report";
+var REPORT_RAW_OVERVIEW_TABLE_HEADERS = [
+  "Category",
+  "Score",
+  "Audits"
+];
 
 // packages/utils/src/lib/reports/utils.ts
-import { join } from "node:path";
+function formatReportScore(score) {
+  const scaledScore = score * 100;
+  const roundedScore = Math.round(scaledScore);
+  return roundedScore === 100 && score !== 1 ? Math.floor(scaledScore).toString() : roundedScore.toString();
+}
+function formatScoreWithColor(score, options) {
+  const styledNumber = options?.skipBold ? formatReportScore(score) : md.bold(formatReportScore(score));
+  return md`${scoreMarker(score)} ${styledNumber}`;
+}
+var MARKERS = {
+  circle: {
+    red: "\u{1F534}",
+    yellow: "\u{1F7E1}",
+    green: "\u{1F7E2}"
+  },
+  square: {
+    red: "\u{1F7E5}",
+    yellow: "\u{1F7E8}",
+    green: "\u{1F7E9}"
+  }
+};
+function scoreMarker(score, markerType = "circle") {
+  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
+    return MARKERS[markerType].green;
+  }
+  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
+    return MARKERS[markerType].yellow;
+  }
+  return MARKERS[markerType].red;
+}
+function getDiffMarker(diff) {
+  if (diff > 0) {
+    return "\u2191";
+  }
+  if (diff < 0) {
+    return "\u2193";
+  }
+  return "";
+}
+function colorByScoreDiff(text, diff) {
+  const color = diff > 0 ? "green" : diff < 0 ? "red" : "gray";
+  return shieldsBadge(text, color);
+}
+function shieldsBadge(text, color) {
+  return md.image(
+    `https://img.shields.io/badge/${encodeURIComponent(text)}-${color}`,
+    text
+  );
+}
+function formatDiffNumber(diff) {
+  const number = Math.abs(diff) === Number.POSITIVE_INFINITY ? "\u221E" : `${Math.abs(diff)}`;
+  const sign = diff < 0 ? "\u2212" : "+";
+  return `${sign}${number}`;
+}
+function severityMarker(severity) {
+  if (severity === "error") {
+    return "\u{1F6A8}";
+  }
+  if (severity === "warning") {
+    return "\u26A0\uFE0F";
+  }
+  return "\u2139\uFE0F";
+}
+function formatScoreChange(diff) {
+  const marker = getDiffMarker(diff);
+  const text = formatDiffNumber(Math.round(diff * 1e3) / 10);
+  return colorByScoreDiff(`${marker} ${text}`, diff);
+}
+function formatValueChange({
+  values,
+  scores
+}) {
+  const marker = getDiffMarker(values.diff);
+  const percentage = values.before === 0 ? values.diff > 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY : Math.round(100 * values.diff / values.before);
+  const text = `${formatDiffNumber(percentage)}\u2009%`;
+  return colorByScoreDiff(`${marker} ${text}`, scores.diff);
+}
+function calcDuration(start, stop) {
+  return Math.round((stop ?? performance.now()) - start);
+}
+function countCategoryAudits(refs, plugins) {
+  const groupLookup = plugins.reduce(
+    (lookup, plugin) => {
+      if (plugin.groups == null || plugin.groups.length === 0) {
+        return lookup;
+      }
+      return {
+        ...lookup,
+        [plugin.slug]: Object.fromEntries(
+          plugin.groups.map((group) => [group.slug, group])
+        )
+      };
+    },
+    {}
+  );
+  return refs.reduce((acc, ref) => {
+    if (ref.type === "group") {
+      const groupRefs = groupLookup[ref.plugin]?.[ref.slug]?.refs;
+      return acc + (groupRefs?.length ?? 0);
+    }
+    return acc + 1;
+  }, 0);
+}
+function compareCategoryAuditsAndGroups(a, b) {
+  if (a.score !== b.score) {
+    return a.score - b.score;
+  }
+  if (a.weight !== b.weight) {
+    return b.weight - a.weight;
+  }
+  if ("value" in a && "value" in b && a.value !== b.value) {
+    return b.value - a.value;
+  }
+  return a.title.localeCompare(b.title);
+}
+function compareAudits(a, b) {
+  if (a.score !== b.score) {
+    return a.score - b.score;
+  }
+  if (a.value !== b.value) {
+    return b.value - a.value;
+  }
+  return a.title.localeCompare(b.title);
+}
+function compareIssueSeverity(severity1, severity2) {
+  const levels = {
+    info: 0,
+    warning: 1,
+    error: 2
+  };
+  return levels[severity1] - levels[severity2];
+}
+function throwIsNotPresentError(itemName, presentPlace) {
+  throw new Error(`${itemName} is not present in ${presentPlace}`);
+}
+function getPluginNameFromSlug(slug, plugins) {
+  return plugins.find(({ slug: pluginSlug }) => pluginSlug === slug)?.title || slug;
+}
+function compareIssues(a, b) {
+  if (a.severity !== b.severity) {
+    return -compareIssueSeverity(a.severity, b.severity);
+  }
+  if (!a.source && b.source) {
+    return -1;
+  }
+  if (a.source && !b.source) {
+    return 1;
+  }
+  if (a.source?.file !== b.source?.file) {
+    return a.source?.file.localeCompare(b.source?.file || "") ?? 0;
+  }
+  if (!a.source?.position && b.source?.position) {
+    return -1;
+  }
+  if (a.source?.position && !b.source?.position) {
+    return 1;
+  }
+  if (a.source?.position?.startLine !== b.source?.position?.startLine) {
+    return (a.source?.position?.startLine ?? 0) - (b.source?.position?.startLine ?? 0);
+  }
+  return 0;
+}
+function applyScoreColor({ score, text }, style = ansis) {
+  const formattedScore = text ?? formatReportScore(score);
+  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
+    return text ? style.green(formattedScore) : style.bold(style.green(formattedScore));
+  }
+  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
+    return text ? style.yellow(formattedScore) : style.bold(style.yellow(formattedScore));
+  }
+  return text ? style.red(formattedScore) : style.bold(style.red(formattedScore));
+}
+function targetScoreIcon(score, targetScore, options = {}) {
+  if (targetScore != null) {
+    const {
+      passIcon = "\u2705",
+      failIcon = "\u274C",
+      prefix = "",
+      postfix = ""
+    } = options;
+    if (score >= targetScore) {
+      return `${prefix}${passIcon}${postfix}`;
+    }
+    return `${prefix}${failIcon}${postfix}`;
+  }
+  return "";
+}
+
+// packages/utils/src/lib/execute-process.ts
+var ProcessError = class extends Error {
+  code;
+  stderr;
+  stdout;
+  constructor(result) {
+    super(result.stderr);
+    this.code = result.code;
+    this.stderr = result.stderr;
+    this.stdout = result.stdout;
+  }
+};
+function executeProcess(cfg) {
+  const { command, args, observer, ignoreExitCode = false, ...options } = cfg;
+  const { onStdout, onStderr, onError, onComplete } = observer ?? {};
+  const date = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  return new Promise((resolve, reject) => {
+    const spawnedProcess = spawn(command, args ?? [], {
+      shell: true,
+      ...options
+    });
+    let stdout = "";
+    let stderr = "";
+    spawnedProcess.stdout.on("data", (data) => {
+      stdout += String(data);
+      onStdout?.(String(data), spawnedProcess);
+    });
+    spawnedProcess.stderr.on("data", (data) => {
+      stderr += String(data);
+      onStderr?.(String(data), spawnedProcess);
+    });
+    spawnedProcess.on("error", (err) => {
+      stderr += err.toString();
+    });
+    spawnedProcess.on("close", (code2) => {
+      const timings = { date, duration: calcDuration(start) };
+      if (code2 === 0 || ignoreExitCode) {
+        onComplete?.();
+        resolve({ code: code2, stdout, stderr, ...timings });
+      } else {
+        const errorMsg = new ProcessError({ code: code2, stdout, stderr, ...timings });
+        onError?.(errorMsg);
+        reject(errorMsg);
+      }
+    });
+  });
+}
 
 // packages/utils/src/lib/file-system.ts
+import { bold, gray } from "ansis";
 import { bundleRequire } from "bundle-require";
-import chalk2 from "chalk";
 import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
 
 // packages/utils/src/lib/formatting.ts
@@ -810,55 +1083,7 @@ function isPromiseRejectedResult(result) {
 // packages/utils/src/lib/logging.ts
 import isaacs_cliui from "@isaacs/cliui";
 import { cliui } from "@poppinss/cliui";
-import chalk from "chalk";
-
-// packages/utils/src/lib/reports/constants.ts
-var TERMINAL_WIDTH = 80;
-var SCORE_COLOR_RANGE = {
-  GREEN_MIN: 0.9,
-  YELLOW_MIN: 0.5
-};
-var CATEGORIES_TITLE = "\u{1F3F7} Categories";
-var FOOTER_PREFIX = "Made with \u2764 by";
-var CODE_PUSHUP_DOMAIN = "code-pushup.dev";
-var README_LINK = "https://github.com/code-pushup/cli#readme";
-var reportHeadlineText = "Code PushUp Report";
-var reportOverviewTableHeaders = [
-  {
-    key: "category",
-    label: "\u{1F3F7} Category",
-    align: "left"
-  },
-  {
-    key: "score",
-    label: "\u2B50 Score"
-  },
-  {
-    key: "audits",
-    label: "\u{1F6E1} Audits"
-  }
-];
-var reportRawOverviewTableHeaders = ["Category", "Score", "Audits"];
-var issuesTableHeadings = [
-  {
-    key: "severity",
-    label: "Severity"
-  },
-  {
-    key: "message",
-    label: "Message"
-  },
-  {
-    key: "file",
-    label: "Source file"
-  },
-  {
-    key: "line",
-    label: "Line(s)"
-  }
-];
-
-// packages/utils/src/lib/logging.ts
+import { underline } from "ansis";
 var singletonUiInstance;
 function ui() {
   if (singletonUiInstance === void 0) {
@@ -954,10 +1179,10 @@ async function ensureDirectoryExists(baseDir) {
 function logMultipleFileResults(fileResults, messagePrefix) {
   const succeededTransform = (result) => {
     const [fileName, size] = result.value;
-    const formattedSize = size ? ` (${chalk2.gray(formatBytes(size))})` : "";
-    return `- ${chalk2.bold(fileName)}${formattedSize}`;
+    const formattedSize = size ? ` (${gray(formatBytes(size))})` : "";
+    return `- ${bold(fileName)}${formattedSize}`;
   };
-  const failedTransform = (result) => `- ${chalk2.bold(result.reason)}`;
+  const failedTransform = (result) => `- ${bold(result.reason)}`;
   logMultipleResults(
     fileResults,
     messagePrefix,
@@ -973,570 +1198,35 @@ async function importModule(options) {
   return mod;
 }
 
-// packages/utils/src/lib/text-formats/constants.ts
-var NEW_LINE = "\n";
-var TAB = "  ";
-var SPACE = " ";
-
-// packages/utils/src/lib/text-formats/html/details.ts
-function details(title, content, cfg = { open: false }) {
-  return `<details${cfg.open ? " open" : ""}>${NEW_LINE}<summary>${title}</summary>${NEW_LINE}${// ⚠️ The blank line is needed to ensure Markdown in content is rendered correctly.
-  NEW_LINE}${content}${NEW_LINE}${// @TODO in the future we could consider adding it only if the content ends with a code block
-  // ⚠️ The blank line ensure Markdown in content is rendered correctly.
-  NEW_LINE}</details>${// ⚠️ The blank line is needed to ensure Markdown after details is rendered correctly.
-  NEW_LINE}`;
-}
+// packages/utils/src/lib/git/git.ts
+import { isAbsolute, join, relative } from "node:path";
+import { simpleGit } from "simple-git";
 
-// packages/utils/src/lib/text-formats/html/font-style.ts
-var boldElement = "b";
-function bold(text) {
-  return `<${boldElement}>${text}</${boldElement}>`;
+// packages/utils/src/lib/transform.ts
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
 }
-var italicElement = "i";
-function italic(text) {
-  return `<${italicElement}>${text}</${italicElement}>`;
-}
-var codeElement = "code";
-function code(text) {
-  return `<${codeElement}>${text}</${codeElement}>`;
-}
-
-// packages/utils/src/lib/text-formats/html/link.ts
-function link(href, text) {
-  return `<a href="${href}">${text || href}</a>`;
-}
-
-// packages/utils/src/lib/transform.ts
 function objectToEntries(obj) {
   return Object.entries(obj);
 }
 function deepClone(obj) {
   return obj == null || typeof obj !== "object" ? obj : structuredClone(obj);
 }
-function toUnixPath(path) {
-  return path.replace(/\\/g, "/");
-}
-function capitalize(text) {
-  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(
-    1
-  )}`;
-}
-
-// packages/utils/src/lib/text-formats/table.ts
-function rowToStringArray({ rows, columns = [] }) {
-  if (Array.isArray(rows.at(0)) && typeof columns.at(0) === "object") {
-    throw new TypeError(
-      "Column can`t be object when rows are primitive values"
-    );
-  }
-  return rows.map((row) => {
-    if (Array.isArray(row)) {
-      return row.map(String);
-    }
-    const objectRow = row;
-    if (columns.length === 0 || typeof columns.at(0) === "string") {
-      return Object.values(objectRow).map(
-        (value) => value == null ? "" : String(value)
-      );
-    }
-    return columns.map(
-      ({ key }) => objectRow[key] == null ? "" : String(objectRow[key])
-    );
-  });
-}
-function columnsToStringArray({
-  rows,
-  columns = []
-}) {
-  const firstRow = rows.at(0);
-  const primitiveRows = Array.isArray(firstRow);
-  if (typeof columns.at(0) === "string" && !primitiveRows) {
-    throw new Error("invalid union type. Caught by model parsing.");
-  }
-  if (columns.length === 0) {
-    if (Array.isArray(firstRow)) {
-      return firstRow.map((_, idx) => String(idx));
-    }
-    return Object.keys(firstRow);
-  }
-  if (typeof columns.at(0) === "string") {
-    return columns.map(String);
-  }
-  const cols = columns;
-  return cols.map(({ label, key }) => label ?? capitalize(key));
-}
-function getColumnAlignmentForKeyAndIndex(targetKey, targetIdx, columns = []) {
-  const column = columns.at(targetIdx) ?? columns.find((col) => col.key === targetKey);
-  if (typeof column === "string") {
-    return column;
-  } else if (typeof column === "object") {
-    return column.align ?? "center";
-  } else {
-    return "center";
-  }
-}
-function getColumnAlignmentForIndex(targetIdx, columns = []) {
-  const column = columns.at(targetIdx);
-  if (column == null) {
-    return "center";
-  } else if (typeof column === "string") {
-    return column;
-  } else if (typeof column === "object") {
-    return column.align ?? "center";
-  } else {
-    return "center";
-  }
-}
-function getColumnAlignments(tableData) {
-  const { rows, columns = [] } = tableData;
-  if (rows.at(0) == null) {
-    throw new Error("first row can`t be undefined.");
-  }
-  if (Array.isArray(rows.at(0))) {
-    const firstPrimitiveRow = rows.at(0);
-    return Array.from({ length: firstPrimitiveRow.length }).map(
-      (_, idx) => getColumnAlignmentForIndex(idx, columns)
-    );
-  }
-  const biggestRow = [...rows].sort((a, b) => Object.keys(a).length - Object.keys(b).length).at(-1);
-  if (columns.length > 0) {
-    return columns.map(
-      (column, idx) => typeof column === "string" ? column : getColumnAlignmentForKeyAndIndex(
-        column.key,
-        idx,
-        columns
-      )
-    );
-  }
-  return Object.keys(biggestRow ?? {}).map((_) => "center");
-}
-
-// packages/utils/src/lib/text-formats/html/table.ts
-function wrap(elem, content) {
-  return `<${elem}>${content}</${elem}>${NEW_LINE}`;
-}
-function wrapRow(content) {
-  const elem = "tr";
-  return `<${elem}>${NEW_LINE}${content}</${elem}>${NEW_LINE}`;
-}
-function table(tableData) {
-  if (tableData.rows.length === 0) {
-    throw new Error("Data can't be empty");
-  }
-  const tableHeaderCols = columnsToStringArray(tableData).map((s) => wrap("th", s)).join("");
-  const tableHeaderRow = wrapRow(tableHeaderCols);
-  const tableBody = rowToStringArray(tableData).map((arr) => {
-    const columns = arr.map((s) => wrap("td", s)).join("");
-    return wrapRow(columns);
-  }).join("");
-  return wrap("table", `${NEW_LINE}${tableHeaderRow}${tableBody}`);
-}
-
-// packages/utils/src/lib/text-formats/md/font-style.ts
-var boldWrap = "**";
-function bold2(text) {
-  return `${boldWrap}${text}${boldWrap}`;
-}
-var italicWrap = "_";
-function italic2(text) {
-  return `${italicWrap}${text}${italicWrap}`;
-}
-var strikeThroughWrap = "~";
-function strikeThrough(text) {
-  return `${strikeThroughWrap}${text}${strikeThroughWrap}`;
-}
-var codeWrap = "`";
-function code2(text) {
-  return `${codeWrap}${text}${codeWrap}`;
-}
-
-// packages/utils/src/lib/text-formats/md/headline.ts
-function headline(text, hierarchy = 1) {
-  return `${"#".repeat(hierarchy)} ${text}${NEW_LINE}`;
-}
-function h(text, hierarchy = 1) {
-  return headline(text, hierarchy);
-}
-function h1(text) {
-  return headline(text, 1);
-}
-function h2(text) {
-  return headline(text, 2);
-}
-function h3(text) {
-  return headline(text, 3);
-}
-function h4(text) {
-  return headline(text, 4);
-}
-function h5(text) {
-  return headline(text, 5);
-}
-function h6(text) {
-  return headline(text, 6);
-}
-
-// packages/utils/src/lib/text-formats/md/image.ts
-function image(src, alt) {
-  return `![${alt}](${src})`;
-}
-
-// packages/utils/src/lib/text-formats/md/link.ts
-function link2(href, text) {
-  return `[${text || href}](${href})`;
-}
-
-// packages/utils/src/lib/text-formats/md/list.ts
-function li(text, order = "unordered") {
-  const style = order === "unordered" ? "-" : "- [ ]";
-  return `${style} ${text}`;
-}
-function indentation(text, level = 1) {
-  return `${TAB.repeat(level)}${text}`;
-}
-
-// packages/utils/src/lib/text-formats/md/paragraphs.ts
-function paragraphs(...sections) {
-  return sections.filter(Boolean).join(`${NEW_LINE}${NEW_LINE}`);
-}
-
-// packages/utils/src/lib/text-formats/md/section.ts
-function section(...contents) {
-  return `${lines(...contents)}${NEW_LINE}`;
-}
-function lines(...contents) {
-  const filteredContent = contents.filter(
-    (value) => value != null && value !== "" && value !== false
-  );
-  return `${filteredContent.join(NEW_LINE)}`;
-}
-
-// packages/utils/src/lib/text-formats/md/table.ts
-var alignString = /* @__PURE__ */ new Map([
-  ["left", ":--"],
-  ["center", ":--:"],
-  ["right", "--:"]
-]);
-function tableRow(rows) {
-  return `|${rows.join("|")}|`;
-}
-function table2(data) {
-  if (data.rows.length === 0) {
-    throw new Error("Data can't be empty");
-  }
-  const alignmentRow = getColumnAlignments(data).map(
-    (s) => alignString.get(s) ?? String(alignString.get("center"))
-  );
-  return section(
-    `${lines(
-      tableRow(columnsToStringArray(data)),
-      tableRow(alignmentRow),
-      ...rowToStringArray(data).map(tableRow)
-    )}`
-  );
-}
-
-// packages/utils/src/lib/text-formats/index.ts
-var md = {
-  bold: bold2,
-  italic: italic2,
-  strikeThrough,
-  code: code2,
-  link: link2,
-  image,
-  headline,
-  h,
-  h1,
-  h2,
-  h3,
-  h4,
-  h5,
-  h6,
-  indentation,
-  lines,
-  li,
-  section,
-  paragraphs,
-  table: table2
-};
-var html = {
-  bold,
-  italic,
-  code,
-  link,
-  details,
-  table
-};
-
-// packages/utils/src/lib/reports/utils.ts
-var { image: image2, bold: boldMd } = md;
-function formatReportScore(score) {
-  const scaledScore = score * 100;
-  const roundedScore = Math.round(scaledScore);
-  return roundedScore === 100 && score !== 1 ? Math.floor(scaledScore).toString() : roundedScore.toString();
-}
-function formatScoreWithColor(score, options) {
-  const styledNumber = options?.skipBold ? formatReportScore(score) : boldMd(formatReportScore(score));
-  return `${scoreMarker(score)} ${styledNumber}`;
-}
-var MARKERS = {
-  circle: {
-    red: "\u{1F534}",
-    yellow: "\u{1F7E1}",
-    green: "\u{1F7E2}"
-  },
-  square: {
-    red: "\u{1F7E5}",
-    yellow: "\u{1F7E8}",
-    green: "\u{1F7E9}"
-  }
-};
-function scoreMarker(score, markerType = "circle") {
-  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
-    return MARKERS[markerType].green;
-  }
-  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
-    return MARKERS[markerType].yellow;
-  }
-  return MARKERS[markerType].red;
-}
-function getDiffMarker(diff) {
-  if (diff > 0) {
-    return "\u2191";
-  }
-  if (diff < 0) {
-    return "\u2193";
-  }
-  return "";
-}
-function colorByScoreDiff(text, diff) {
-  const color = diff > 0 ? "green" : diff < 0 ? "red" : "gray";
-  return shieldsBadge(text, color);
-}
-function shieldsBadge(text, color) {
-  return image2(
-    `https://img.shields.io/badge/${encodeURIComponent(text)}-${color}`,
-    text
-  );
-}
-function formatDiffNumber(diff) {
-  const number = Math.abs(diff) === Number.POSITIVE_INFINITY ? "\u221E" : `${Math.abs(diff)}`;
-  const sign = diff < 0 ? "\u2212" : "+";
-  return `${sign}${number}`;
-}
-function severityMarker(severity) {
-  if (severity === "error") {
-    return "\u{1F6A8}";
-  }
-  if (severity === "warning") {
-    return "\u26A0\uFE0F";
-  }
-  return "\u2139\uFE0F";
-}
-function calcDuration(start, stop) {
-  return Math.round((stop ?? performance.now()) - start);
-}
-function countCategoryAudits(refs, plugins) {
-  const groupLookup = plugins.reduce(
-    (lookup, plugin) => {
-      if (plugin.groups == null || plugin.groups.length === 0) {
-        return lookup;
-      }
-      return {
-        ...lookup,
-        [plugin.slug]: Object.fromEntries(
-          plugin.groups.map((group) => [group.slug, group])
-        )
-      };
-    },
-    {}
-  );
-  return refs.reduce((acc, ref) => {
-    if (ref.type === "group") {
-      const groupRefs = groupLookup[ref.plugin]?.[ref.slug]?.refs;
-      return acc + (groupRefs?.length ?? 0);
-    }
-    return acc + 1;
-  }, 0);
-}
-function getSortableAuditByRef({ slug, weight, plugin }, plugins) {
-  const auditPlugin = plugins.find((p) => p.slug === plugin);
-  if (!auditPlugin) {
-    throwIsNotPresentError(`Plugin ${plugin}`, "report");
-  }
-  const audit = auditPlugin.audits.find(
-    ({ slug: auditSlug }) => auditSlug === slug
-  );
-  if (!audit) {
-    throwIsNotPresentError(`Audit ${slug}`, auditPlugin.slug);
-  }
-  return {
-    ...audit,
-    weight,
-    plugin
-  };
-}
-function getSortableGroupByRef({ plugin, slug, weight }, plugins) {
-  const groupPlugin = plugins.find((p) => p.slug === plugin);
-  if (!groupPlugin) {
-    throwIsNotPresentError(`Plugin ${plugin}`, "report");
-  }
-  const group = groupPlugin.groups?.find(
-    ({ slug: groupSlug }) => groupSlug === slug
-  );
-  if (!group) {
-    throwIsNotPresentError(`Group ${slug}`, groupPlugin.slug);
-  }
-  const sortedAudits = getSortedGroupAudits(group, groupPlugin.slug, plugins);
-  const sortedAuditRefs = [...group.refs].sort((a, b) => {
-    const aIndex = sortedAudits.findIndex((ref) => ref.slug === a.slug);
-    const bIndex = sortedAudits.findIndex((ref) => ref.slug === b.slug);
-    return aIndex - bIndex;
-  });
-  return {
-    ...group,
-    refs: sortedAuditRefs,
-    plugin,
-    weight
-  };
-}
-function getSortedGroupAudits(group, plugin, plugins) {
-  return group.refs.map(
-    (ref) => getSortableAuditByRef(
-      {
-        plugin,
-        slug: ref.slug,
-        weight: ref.weight,
-        type: "audit"
-      },
-      plugins
-    )
-  ).sort(compareCategoryAuditsAndGroups);
-}
-function compareCategoryAuditsAndGroups(a, b) {
-  if (a.weight !== b.weight) {
-    return b.weight - a.weight;
-  }
-  if (a.score !== b.score) {
-    return a.score - b.score;
-  }
-  if ("value" in a && "value" in b && a.value !== b.value) {
-    return b.value - a.value;
-  }
-  return a.title.localeCompare(b.title);
-}
-function compareAudits(a, b) {
-  if (a.score !== b.score) {
-    return a.score - b.score;
-  }
-  if (a.value !== b.value) {
-    return b.value - a.value;
-  }
-  return a.title.localeCompare(b.title);
-}
-function compareIssueSeverity(severity1, severity2) {
-  const levels = {
-    info: 0,
-    warning: 1,
-    error: 2
-  };
-  return levels[severity1] - levels[severity2];
-}
-async function loadReport(options) {
-  const { outputDir, filename, format } = options;
-  await ensureDirectoryExists(outputDir);
-  const filePath = join(outputDir, `${filename}.${format}`);
-  if (format === "json") {
-    const content = await readJsonFile(filePath);
-    return reportSchema.parse(content);
-  }
-  const text = await readTextFile(filePath);
-  return text;
-}
-function throwIsNotPresentError(itemName, presentPlace) {
-  throw new Error(`${itemName} is not present in ${presentPlace}`);
-}
-function getPluginNameFromSlug(slug, plugins) {
-  return plugins.find(({ slug: pluginSlug }) => pluginSlug === slug)?.title || slug;
-}
-function compareIssues(a, b) {
-  if (a.severity !== b.severity) {
-    return -compareIssueSeverity(a.severity, b.severity);
-  }
-  if (!a.source && b.source) {
-    return -1;
-  }
-  if (a.source && !b.source) {
-    return 1;
-  }
-  if (a.source?.file !== b.source?.file) {
-    return a.source?.file.localeCompare(b.source?.file || "") ?? 0;
-  }
-  if (!a.source?.position && b.source?.position) {
-    return -1;
-  }
-  if (a.source?.position && !b.source?.position) {
-    return 1;
-  }
-  if (a.source?.position?.startLine !== b.source?.position?.startLine) {
-    return (a.source?.position?.startLine ?? 0) - (b.source?.position?.startLine ?? 0);
-  }
-  return 0;
-}
-
-// packages/utils/src/lib/execute-process.ts
-var ProcessError = class extends Error {
-  code;
-  stderr;
-  stdout;
-  constructor(result) {
-    super(result.stderr);
-    this.code = result.code;
-    this.stderr = result.stderr;
-    this.stdout = result.stdout;
-  }
-};
-function executeProcess(cfg) {
-  const { observer, cwd, command, args, ignoreExitCode = false } = cfg;
-  const { onStdout, onError, onComplete } = observer ?? {};
-  const date = (/* @__PURE__ */ new Date()).toISOString();
-  const start = performance.now();
-  return new Promise((resolve, reject) => {
-    const process2 = spawn(command, args, { cwd, shell: true });
-    let stdout = "";
-    let stderr = "";
-    process2.stdout.on("data", (data) => {
-      stdout += String(data);
-      onStdout?.(String(data));
-    });
-    process2.stderr.on("data", (data) => {
-      stderr += String(data);
-    });
-    process2.on("error", (err) => {
-      stderr += err.toString();
-    });
-    process2.on("close", (code3) => {
-      const timings = { date, duration: calcDuration(start) };
-      if (code3 === 0 || ignoreExitCode) {
-        onComplete?.();
-        resolve({ code: code3, stdout, stderr, ...timings });
-      } else {
-        const errorMsg = new ProcessError({ code: code3, stdout, stderr, ...timings });
-        onError?.(errorMsg);
-        reject(errorMsg);
-      }
-    });
-  });
-}
+function toUnixPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function capitalize(text) {
+  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(
+    1
+  )}`;
+}
 
 // packages/utils/src/lib/git/git.ts
-import { isAbsolute, join as join2, relative } from "node:path";
-import { simpleGit } from "simple-git";
 function getGitRoot(git = simpleGit()) {
   return git.revparse("--show-toplevel");
 }
 function formatGitPath(path, gitRoot) {
-  const absolutePath = isAbsolute(path) ? path : join2(process.cwd(), path);
+  const absolutePath = isAbsolute(path) ? path : join(process.cwd(), path);
   const relativePath = relative(gitRoot, absolutePath);
   return toUnixPath(relativePath);
 }
@@ -1618,17 +1308,17 @@ function groupByStatus(results) {
 }
 
 // packages/utils/src/lib/progress.ts
-import chalk3 from "chalk";
+import { black, bold as bold2, gray as gray2, green } from "ansis";
 import { MultiProgressBars } from "multi-progress-bars";
 var barStyles = {
-  active: (s) => chalk3.green(s),
-  done: (s) => chalk3.gray(s),
-  idle: (s) => chalk3.gray(s)
+  active: (s) => green(s),
+  done: (s) => gray2(s),
+  idle: (s) => gray2(s)
 };
 var messageStyles = {
-  active: (s) => chalk3.black(s),
-  done: (s) => chalk3.green(chalk3.bold(s)),
-  idle: (s) => chalk3.gray(s)
+  active: (s) => black(s),
+  done: (s) => bold2.green(s),
+  idle: (s) => gray2(s)
 };
 var mpb;
 function getSingletonProgressBars(options) {
@@ -1684,467 +1374,483 @@ function listAuditsFromAllPlugins(report) {
   );
 }
 
+// packages/utils/src/lib/reports/generate-md-report.ts
+import { MarkdownDocument as MarkdownDocument3, md as md4 } from "build-md";
+
+// packages/utils/src/lib/text-formats/constants.ts
+var HIERARCHY = {
+  level_1: 1,
+  level_2: 2,
+  level_3: 3,
+  level_4: 4,
+  level_5: 5,
+  level_6: 6
+};
+
+// packages/utils/src/lib/text-formats/table.ts
+function rowToStringArray({ rows, columns = [] }) {
+  if (Array.isArray(rows.at(0)) && typeof columns.at(0) === "object") {
+    throw new TypeError(
+      "Column can`t be object when rows are primitive values"
+    );
+  }
+  return rows.map((row) => {
+    if (Array.isArray(row)) {
+      return row.map(String);
+    }
+    const objectRow = row;
+    if (columns.length === 0 || typeof columns.at(0) === "string") {
+      return Object.values(objectRow).map(
+        (value) => value == null ? "" : String(value)
+      );
+    }
+    return columns.map(
+      ({ key }) => objectRow[key] == null ? "" : String(objectRow[key])
+    );
+  });
+}
+function columnsToStringArray({
+  rows,
+  columns = []
+}) {
+  const firstRow = rows.at(0);
+  const primitiveRows = Array.isArray(firstRow);
+  if (typeof columns.at(0) === "string" && !primitiveRows) {
+    throw new Error("invalid union type. Caught by model parsing.");
+  }
+  if (columns.length === 0) {
+    if (Array.isArray(firstRow)) {
+      return firstRow.map((_, idx) => String(idx));
+    }
+    return Object.keys(firstRow);
+  }
+  if (typeof columns.at(0) === "string") {
+    return columns.map(String);
+  }
+  const cols = columns;
+  return cols.map(({ label, key }) => label ?? capitalize(key));
+}
+function getColumnAlignmentForKeyAndIndex(targetKey, targetIdx, columns = []) {
+  const column = columns.at(targetIdx) ?? columns.find((col) => col.key === targetKey);
+  if (typeof column === "string") {
+    return column;
+  } else if (typeof column === "object") {
+    return column.align ?? "center";
+  } else {
+    return "center";
+  }
+}
+function getColumnAlignmentForIndex(targetIdx, columns = []) {
+  const column = columns.at(targetIdx);
+  if (column == null) {
+    return "center";
+  } else if (typeof column === "string") {
+    return column;
+  } else if (typeof column === "object") {
+    return column.align ?? "center";
+  } else {
+    return "center";
+  }
+}
+function getColumnAlignments(tableData) {
+  const { rows, columns = [] } = tableData;
+  if (rows.at(0) == null) {
+    throw new Error("first row can`t be undefined.");
+  }
+  if (Array.isArray(rows.at(0))) {
+    const firstPrimitiveRow = rows.at(0);
+    return Array.from({ length: firstPrimitiveRow.length }).map(
+      (_, idx) => getColumnAlignmentForIndex(idx, columns)
+    );
+  }
+  const biggestRow = [...rows].sort((a, b) => Object.keys(a).length - Object.keys(b).length).at(-1);
+  if (columns.length > 0) {
+    return columns.map(
+      (column, idx) => typeof column === "string" ? column : getColumnAlignmentForKeyAndIndex(
+        column.key,
+        idx,
+        columns
+      )
+    );
+  }
+  return Object.keys(biggestRow ?? {}).map((_) => "center");
+}
+
 // packages/utils/src/lib/reports/formatting.ts
-var { headline: headline2, lines: lines2, link: link3, section: section2, table: table3 } = md;
+import {
+  MarkdownDocument,
+  md as md2
+} from "build-md";
 function tableSection(tableData, options) {
   if (tableData.rows.length === 0) {
-    return "";
-  }
-  const { level = 4 } = options ?? {};
-  const render = (h7, l) => l === 0 ? h7 : headline2(h7, l);
-  return lines2(
-    tableData.title && render(tableData.title, level),
-    table3(tableData)
+    return null;
+  }
+  const { level = HIERARCHY.level_4 } = options ?? {};
+  const columns = columnsToStringArray(tableData);
+  const alignments = getColumnAlignments(tableData);
+  const rows = rowToStringArray(tableData);
+  return new MarkdownDocument().heading(level, tableData.title).table(
+    columns.map((heading, i) => {
+      const alignment = alignments[i];
+      if (alignment) {
+        return { heading, alignment };
+      }
+      return heading;
+    }),
+    rows
   );
 }
-function metaDescription({
-  docsUrl,
-  description
-}) {
+function metaDescription(audit) {
+  const docsUrl = audit.docsUrl;
+  const description = audit.description?.trim();
   if (docsUrl) {
-    const docsLink = link3(docsUrl, "\u{1F4D6} Docs");
+    const docsLink = md2.link(docsUrl, "\u{1F4D6} Docs");
     if (!description) {
-      return section2(docsLink);
+      return docsLink;
     }
-    const parsedDescription = description.toString().endsWith("```") ? `${description}${NEW_LINE + NEW_LINE}` : `${description}${SPACE}`;
-    return section2(`${parsedDescription}${docsLink}`);
+    const parsedDescription = description.endsWith("```") ? `${description}
+
+` : `${description} `;
+    return md2`${parsedDescription}${docsLink}`;
   }
   if (description && description.trim().length > 0) {
-    return section2(description);
+    return description;
   }
   return "";
 }
 
 // packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
-var { link: link4, section: section3, h2: h22, lines: lines3, li: li2, bold: boldMd2, h3: h32, indentation: indentation2 } = md;
-function categoriesOverviewSection(report) {
-  const { categories, plugins } = report;
-  if (categories.length > 0 && plugins.length > 0) {
-    const tableContent = {
-      columns: reportOverviewTableHeaders,
-      rows: categories.map(({ title, refs, score }) => ({
-        // The heading "ID" is inferred from the heading text in Markdown.
-        category: link4(`#${slugify(title)}`, title),
-        score: `${scoreMarker(score)}${SPACE}${boldMd2(
-          formatReportScore(score)
-        )}`,
-        audits: countCategoryAudits(refs, plugins).toString()
-      }))
-    };
-    return tableSection(tableContent);
+import { MarkdownDocument as MarkdownDocument2, md as md3 } from "build-md";
+
+// packages/utils/src/lib/reports/sorting.ts
+function getSortableAuditByRef({ slug, weight, plugin }, plugins) {
+  const auditPlugin = plugins.find((p) => p.slug === plugin);
+  if (!auditPlugin) {
+    throwIsNotPresentError(`Plugin ${plugin}`, "report");
   }
-  return "";
+  const audit = auditPlugin.audits.find(
+    ({ slug: auditSlug }) => auditSlug === slug
+  );
+  if (!audit) {
+    throwIsNotPresentError(`Audit ${slug}`, auditPlugin.slug);
+  }
+  return {
+    ...audit,
+    weight,
+    plugin
+  };
 }
-function categoriesDetailsSection(report) {
+function getSortedGroupAudits(group, plugin, plugins) {
+  return group.refs.map(
+    (ref) => getSortableAuditByRef(
+      {
+        plugin,
+        slug: ref.slug,
+        weight: ref.weight,
+        type: "audit"
+      },
+      plugins
+    )
+  ).sort(compareCategoryAuditsAndGroups);
+}
+function getSortableGroupByRef({ plugin, slug, weight }, plugins) {
+  const groupPlugin = plugins.find((p) => p.slug === plugin);
+  if (!groupPlugin) {
+    throwIsNotPresentError(`Plugin ${plugin}`, "report");
+  }
+  const group = groupPlugin.groups?.find(
+    ({ slug: groupSlug }) => groupSlug === slug
+  );
+  if (!group) {
+    throwIsNotPresentError(`Group ${slug}`, groupPlugin.slug);
+  }
+  const sortedAudits = getSortedGroupAudits(group, groupPlugin.slug, plugins);
+  const sortedAuditRefs = [...group.refs].sort((a, b) => {
+    const aIndex = sortedAudits.findIndex((ref) => ref.slug === a.slug);
+    const bIndex = sortedAudits.findIndex((ref) => ref.slug === b.slug);
+    return aIndex - bIndex;
+  });
+  return {
+    ...group,
+    refs: sortedAuditRefs,
+    plugin,
+    weight
+  };
+}
+function sortReport(report) {
   const { categories, plugins } = report;
-  const categoryDetails = categories.flatMap((category) => {
-    const categoryTitle = h32(category.title);
-    const categoryScore = `${scoreMarker(
-      category.score
-    )}${SPACE}Score:  ${boldMd2(formatReportScore(category.score))}`;
-    const categoryMDItems = category.refs.map((ref) => {
-      if (ref.type === "group") {
-        const group = getSortableGroupByRef(ref, plugins);
-        const groupAudits = group.refs.map(
-          (groupRef) => getSortableAuditByRef(
-            { ...groupRef, plugin: group.plugin, type: "audit" },
-            plugins
-          )
-        );
-        const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);
-        return categoryGroupItem(group, groupAudits, pluginTitle);
-      } else {
-        const audit = getSortableAuditByRef(ref, plugins);
-        const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);
-        return categoryRef(audit, pluginTitle);
-      }
-    });
-    return section3(
-      categoryTitle,
-      metaDescription(category),
-      categoryScore,
-      ...categoryMDItems
+  const sortedCategories = categories.map((category) => {
+    const { audits, groups } = category.refs.reduce(
+      (acc, ref) => ({
+        ...acc,
+        ...ref.type === "group" ? {
+          groups: [...acc.groups, getSortableGroupByRef(ref, plugins)]
+        } : {
+          audits: [...acc.audits, getSortableAuditByRef(ref, plugins)]
+        }
+      }),
+      { groups: [], audits: [] }
+    );
+    const sortedAuditsAndGroups = [...audits, ...groups].sort(
+      compareCategoryAuditsAndGroups
     );
+    const sortedRefs = [...category.refs].sort((a, b) => {
+      const aIndex = sortedAuditsAndGroups.findIndex(
+        (ref) => ref.slug === a.slug && ref.plugin === a.plugin
+      );
+      const bIndex = sortedAuditsAndGroups.findIndex(
+        (ref) => ref.slug === b.slug && ref.plugin === b.plugin
+      );
+      return aIndex - bIndex;
+    });
+    return { ...category, refs: sortedRefs };
   });
-  return lines3(h22(CATEGORIES_TITLE), ...categoryDetails);
+  return {
+    ...report,
+    categories: sortedCategories,
+    plugins: sortPlugins(plugins)
+  };
+}
+function sortPlugins(plugins) {
+  return plugins.map((plugin) => ({
+    ...plugin,
+    audits: [...plugin.audits].sort(compareAudits).map(
+      (audit) => audit.details?.issues ? {
+        ...audit,
+        details: {
+          ...audit.details,
+          issues: [...audit.details.issues].sort(compareIssues)
+        }
+      } : audit
+    )
+  }));
+}
+
+// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
+function categoriesOverviewSection(report) {
+  const { categories, plugins } = report;
+  return new MarkdownDocument2().table(
+    [
+      { heading: "\u{1F3F7} Category", alignment: "left" },
+      { heading: "\u2B50 Score", alignment: "center" },
+      { heading: "\u{1F6E1} Audits", alignment: "center" }
+    ],
+    categories.map(({ title, refs, score, isBinary }) => [
+      // @TODO refactor `isBinary: boolean` to `targetScore: number` #713
+      // The heading "ID" is inferred from the heading text in Markdown.
+      md3.link(`#${slugify(title)}`, title),
+      md3`${scoreMarker(score)} ${md3.bold(
+        formatReportScore(score)
+      )}${binaryIconSuffix(score, isBinary)}`,
+      countCategoryAudits(refs, plugins).toString()
+    ])
+  );
+}
+function categoriesDetailsSection(report) {
+  const { categories, plugins } = report;
+  return new MarkdownDocument2().heading(HIERARCHY.level_2, "\u{1F3F7} Categories").$foreach(
+    categories,
+    (doc, category) => doc.heading(HIERARCHY.level_3, category.title).paragraph(metaDescription(category)).paragraph(
+      md3`${scoreMarker(category.score)} Score: ${md3.bold(
+        formatReportScore(category.score)
+      )}${binaryIconSuffix(category.score, category.isBinary)}`
+    ).list(
+      category.refs.map((ref) => {
+        if (ref.type === "group") {
+          const group = getSortableGroupByRef(ref, plugins);
+          const groupAudits = group.refs.map(
+            (groupRef) => getSortableAuditByRef(
+              { ...groupRef, plugin: group.plugin, type: "audit" },
+              plugins
+            )
+          );
+          const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);
+          return categoryGroupItem(group, groupAudits, pluginTitle);
+        } else {
+          const audit = getSortableAuditByRef(ref, plugins);
+          const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);
+          return categoryRef(audit, pluginTitle);
+        }
+      })
+    )
+  );
 }
 function categoryRef({ title, score, value, displayValue }, pluginTitle) {
-  const auditTitleAsLink = link4(
+  const auditTitleAsLink = md3.link(
     `#${slugify(title)}-${slugify(pluginTitle)}`,
     title
   );
   const marker = scoreMarker(score, "square");
-  return li2(
-    `${marker}${SPACE}${auditTitleAsLink}${SPACE}(_${pluginTitle}_) - ${boldMd2(
-      (displayValue || value).toString()
-    )}`
-  );
+  return md3`${marker} ${auditTitleAsLink} (${md3.italic(
+    pluginTitle
+  )}) - ${md3.bold((displayValue || value).toString())}`;
 }
 function categoryGroupItem({ score = 0, title }, groupAudits, pluginTitle) {
-  const groupTitle = li2(
-    `${scoreMarker(score)}${SPACE}${title}${SPACE}(_${pluginTitle}_)`
-  );
-  const auditTitles = groupAudits.map(
-    ({ title: auditTitle, score: auditScore, value, displayValue }) => {
-      const auditTitleLink = link4(
-        `#${slugify(auditTitle)}-${slugify(pluginTitle)}`,
-        auditTitle
-      );
-      const marker = scoreMarker(auditScore, "square");
-      return indentation2(
-        li2(
-          `${marker}${SPACE}${auditTitleLink} - ${boldMd2(
-            String(displayValue ?? value)
-          )}`
-        )
-      );
-    }
+  const groupTitle = md3`${scoreMarker(score)} ${title} (${md3.italic(
+    pluginTitle
+  )})`;
+  const auditsList = md3.list(
+    groupAudits.map(
+      ({ title: auditTitle, score: auditScore, value, displayValue }) => {
+        const auditTitleLink = md3.link(
+          `#${slugify(auditTitle)}-${slugify(pluginTitle)}`,
+          auditTitle
+        );
+        const marker = scoreMarker(auditScore, "square");
+        return md3`${marker} ${auditTitleLink} - ${md3.bold(
+          String(displayValue ?? value)
+        )}`;
+      }
+    )
   );
-  return lines3(groupTitle, ...auditTitles);
+  return md3`${groupTitle}${auditsList}`;
+}
+function binaryIconSuffix(score, isBinary) {
+  return targetScoreIcon(score, isBinary ? 1 : void 0, { prefix: " " });
 }
 
 // packages/utils/src/lib/reports/generate-md-report.ts
-var { h1: h12, h2: h23, h3: h33, lines: lines4, link: link5, section: section4, code: codeMd } = md;
-var { bold: boldHtml, details: details2 } = html;
 function auditDetailsAuditValue({
   score,
   value,
   displayValue
 }) {
-  return `${scoreMarker(score, "square")} ${boldHtml(
+  return md4`${scoreMarker(score, "square")} ${md4.bold(
     String(displayValue ?? value)
   )} (score: ${formatReportScore(score)})`;
 }
 function generateMdReport(report) {
-  const printCategories = report.categories.length > 0;
-  return lines4(
-    h12(reportHeadlineText),
-    printCategories ? categoriesOverviewSection(report) : "",
-    printCategories ? categoriesDetailsSection(report) : "",
-    auditsSection(report),
-    aboutSection(report),
-    `${FOOTER_PREFIX}${SPACE}${link5(README_LINK, "Code PushUp")}`
-  );
+  return new MarkdownDocument3().heading(HIERARCHY.level_1, REPORT_HEADLINE_TEXT).$if(
+    report.categories.length > 0,
+    (doc) => doc.$concat(
+      categoriesOverviewSection(report),
+      categoriesDetailsSection(report)
+    )
+  ).$concat(auditsSection(report), aboutSection(report)).rule().paragraph(md4`${FOOTER_PREFIX} ${md4.link(README_LINK, "Code PushUp")}`).toString();
 }
 function auditDetailsIssues(issues = []) {
   if (issues.length === 0) {
-    return "";
-  }
-  const detailsTableData = {
-    title: "Issues",
-    columns: issuesTableHeadings,
-    rows: issues.map(
-      ({ severity: severityVal, message, source: sourceVal }) => {
-        const severity = `${severityMarker(severityVal)} <i>${severityVal}</i>`;
-        if (!sourceVal) {
-          return { severity, message, file: "", line: "" };
-        }
-        const file = `<code>${sourceVal.file}</code>`;
-        if (!sourceVal.position) {
-          return { severity, message, file, line: "" };
-        }
-        const { startLine, endLine } = sourceVal.position;
-        const line = `${startLine || ""}${endLine && startLine !== endLine ? `-${endLine}` : ""}`;
-        return { severity, message, file, line };
+    return null;
+  }
+  return new MarkdownDocument3().heading(HIERARCHY.level_4, "Issues").table(
+    [
+      { heading: "Severity", alignment: "center" },
+      { heading: "Message", alignment: "left" },
+      { heading: "Source file", alignment: "left" },
+      { heading: "Line(s)", alignment: "center" }
+    ],
+    issues.map(({ severity: level, message, source }) => {
+      const severity = md4`${severityMarker(level)} ${md4.italic(level)}`;
+      if (!source) {
+        return [severity, message];
       }
-    )
-  };
-  return tableSection(detailsTableData);
+      const file = md4.code(source.file);
+      if (!source.position) {
+        return [severity, message, file];
+      }
+      const { startLine, endLine } = source.position;
+      const line = `${startLine || ""}${endLine && startLine !== endLine ? `-${endLine}` : ""}`;
+      return [severity, message, file, line];
+    })
+  );
 }
 function auditDetails(audit) {
-  const { table: table5, issues = [] } = audit.details ?? {};
+  const { table: table2, issues = [] } = audit.details ?? {};
   const detailsValue = auditDetailsAuditValue(audit);
-  if (issues.length === 0 && table5 == null) {
-    return section4(detailsValue);
+  if (issues.length === 0 && !table2?.rows.length) {
+    return new MarkdownDocument3().paragraph(detailsValue);
   }
-  const tableSectionContent = table5 == null ? "" : tableSection(table5);
-  const issuesSectionContent = issues.length > 0 ? auditDetailsIssues(issues) : "";
-  return details2(
+  const tableSectionContent = table2 && tableSection(table2);
+  const issuesSectionContent = issues.length > 0 && auditDetailsIssues(issues);
+  return new MarkdownDocument3().details(
     detailsValue,
-    lines4(tableSectionContent, issuesSectionContent)
+    new MarkdownDocument3().$concat(tableSectionContent, issuesSectionContent)
   );
 }
 function auditsSection({
   plugins
 }) {
-  const content = plugins.flatMap(
-    ({ slug, audits }) => audits.flatMap((audit) => {
-      const auditTitle = `${audit.title}${SPACE}(${getPluginNameFromSlug(
-        slug,
-        plugins
-      )})`;
+  return new MarkdownDocument3().heading(HIERARCHY.level_2, "\u{1F6E1}\uFE0F Audits").$foreach(
+    plugins.flatMap(
+      (plugin) => plugin.audits.map((audit) => ({ ...audit, plugin }))
+    ),
+    (doc, { plugin, ...audit }) => {
+      const auditTitle = `${audit.title} (${plugin.title})`;
       const detailsContent = auditDetails(audit);
       const descriptionContent = metaDescription(audit);
-      return [h33(auditTitle), detailsContent, descriptionContent];
-    })
+      return doc.heading(HIERARCHY.level_3, auditTitle).$concat(detailsContent).paragraph(descriptionContent);
+    }
   );
-  return section4(h23("\u{1F6E1}\uFE0F Audits"), ...content);
 }
 function aboutSection(report) {
   const { date, plugins } = report;
-  const reportMetaTable = reportMetaData(report);
-  const pluginMetaTable = reportPluginMeta({ plugins });
-  return lines4(
-    h23("About"),
-    section4(
-      `Report was created by [Code PushUp](${README_LINK}) on ${formatDate(
-        new Date(date)
-      )}.`
-    ),
-    tableSection(pluginMetaTable),
-    tableSection(reportMetaTable)
-  );
-}
-function reportPluginMeta({ plugins }) {
-  return {
-    columns: [
-      {
-        key: "plugin",
-        align: "left"
-      },
-      {
-        key: "audits"
-      },
-      {
-        key: "version"
-      },
-      {
-        key: "duration"
-      }
+  return new MarkdownDocument3().heading(HIERARCHY.level_2, "About").paragraph(
+    md4`Report was created by ${md4.link(
+      README_LINK,
+      "Code PushUp"
+    )} on ${formatDate(new Date(date))}.`
+  ).table(...pluginMetaTable({ plugins })).table(...reportMetaTable(report));
+}
+function pluginMetaTable({
+  plugins
+}) {
+  return [
+    [
+      { heading: "Plugin", alignment: "left" },
+      { heading: "Audits", alignment: "center" },
+      { heading: "Version", alignment: "center" },
+      { heading: "Duration", alignment: "right" }
     ],
-    rows: plugins.map(
-      ({
-        title: pluginTitle,
-        audits,
-        version: pluginVersion,
-        duration: pluginDuration
-      }) => ({
-        plugin: pluginTitle,
-        audits: audits.length.toString(),
-        version: codeMd(pluginVersion || ""),
-        duration: formatDuration(pluginDuration)
-      })
-    )
-  };
+    plugins.map(({ title, audits, version: version2 = "", duration }) => [
+      title,
+      audits.length.toString(),
+      version2 && md4.code(version2),
+      formatDuration(duration)
+    ])
+  ];
 }
-function reportMetaData({
+function reportMetaTable({
   commit,
   version: version2,
   duration,
   plugins,
   categories
 }) {
-  const commitInfo = commit ? `${commit.message}${SPACE}(${commit.hash})` : "N/A";
-  return {
-    columns: [
-      {
-        key: "commit",
-        align: "left"
-      },
-      {
-        key: "version"
-      },
-      {
-        key: "duration"
-      },
-      {
-        key: "plugins"
-      },
-      {
-        key: "categories"
-      },
-      {
-        key: "audits"
-      }
+  return [
+    [
+      { heading: "Commit", alignment: "left" },
+      { heading: "Version", alignment: "center" },
+      { heading: "Duration", alignment: "right" },
+      { heading: "Plugins", alignment: "center" },
+      { heading: "Categories", alignment: "center" },
+      { heading: "Audits", alignment: "center" }
     ],
-    rows: [
-      {
-        commit: commitInfo,
-        version: codeMd(version2 || ""),
-        duration: formatDuration(duration),
-        plugins: plugins.length,
-        categories: categories.length,
-        audits: plugins.reduce((acc, { audits }) => acc + audits.length, 0).toString()
-      }
+    [
+      [
+        commit ? `${commit.message} (${commit.hash})` : "N/A",
+        md4.code(version2),
+        formatDuration(duration),
+        plugins.length.toString(),
+        categories.length.toString(),
+        plugins.reduce((acc, { audits }) => acc + audits.length, 0).toString()
+      ]
     ]
-  };
+  ];
 }
 
 // packages/utils/src/lib/reports/generate-md-reports-diff.ts
-var {
-  h1: h13,
-  h2: h24,
-  lines: lines5,
-  link: link6,
-  bold: boldMd3,
-  italic: italicMd,
-  table: table4,
-  section: section5
-} = md;
-var { details: details3 } = html;
+import {
+  MarkdownDocument as MarkdownDocument5,
+  md as md6
+} from "build-md";
+
+// packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts
+import { MarkdownDocument as MarkdownDocument4, md as md5 } from "build-md";
 var MAX_ROWS = 100;
-function generateMdReportsDiff(diff) {
-  return lines5(
-    section5(formatDiffHeaderSection(diff)),
-    formatDiffCategoriesSection(diff),
-    formatDiffGroupsSection(diff),
-    formatDiffAuditsSection(diff)
-  );
-}
-function formatDiffHeaderSection(diff) {
-  const outcomeTexts = {
-    positive: `\u{1F973} Code PushUp report has ${boldMd3("improved")}`,
-    negative: `\u{1F61F} Code PushUp report has ${boldMd3("regressed")}`,
-    mixed: `\u{1F928} Code PushUp report has both ${boldMd3(
-      "improvements and regressions"
-    )}`,
-    unchanged: `\u{1F610} Code PushUp report is ${boldMd3("unchanged")}`
-  };
-  const outcome = mergeDiffOutcomes(
-    changesToDiffOutcomes([
-      ...diff.categories.changed,
-      ...diff.groups.changed,
-      ...diff.audits.changed
-    ])
-  );
-  const styleCommits = (commits) => `compared target commit ${commits.after.hash} with source commit ${commits.before.hash}`;
-  return lines5(
-    h13("Code PushUp"),
-    diff.commits ? `${outcomeTexts[outcome]} \u2013 ${styleCommits(diff.commits)}.` : `${outcomeTexts[outcome]}.`
-  );
-}
-function formatDiffCategoriesSection(diff) {
-  const { changed, unchanged, added } = diff.categories;
-  const categoriesCount = changed.length + unchanged.length + added.length;
-  const hasChanges = unchanged.length < categoriesCount;
-  if (categoriesCount === 0) {
-    return "";
-  }
-  const columns = [
-    { key: "category", label: "\u{1F3F7}\uFE0F Category", align: "left" },
-    { key: "before", label: hasChanges ? "\u2B50 Previous score" : "\u2B50 Score" },
-    { key: "after", label: "\u2B50 Current score" },
-    { key: "change", label: "\u{1F504} Score change" }
-  ];
-  return lines5(
-    h24("\u{1F3F7}\uFE0F Categories"),
-    categoriesCount > 0 && table4({
-      columns: hasChanges ? columns : columns.slice(0, 2),
-      rows: [
-        ...sortChanges(changed).map((category) => ({
-          category: formatTitle(category),
-          after: formatScoreWithColor(category.scores.after),
-          before: formatScoreWithColor(category.scores.before, {
-            skipBold: true
-          }),
-          change: formatScoreChange(category.scores.diff)
-        })),
-        ...added.map((category) => ({
-          category: formatTitle(category),
-          after: formatScoreWithColor(category.score),
-          before: italicMd("n/a (\\*)"),
-          change: italicMd("n/a (\\*)")
-        })),
-        ...unchanged.map((category) => ({
-          category: formatTitle(category),
-          after: formatScoreWithColor(category.score),
-          before: formatScoreWithColor(category.score, { skipBold: true }),
-          change: "\u2013"
-        }))
-      ].map(
-        (row) => hasChanges ? row : { category: row.category, before: row.before }
-      )
-    }),
-    added.length > 0 && section5(italicMd("(\\*) New category."))
-  );
-}
-function formatDiffGroupsSection(diff) {
-  if (diff.groups.changed.length + diff.groups.unchanged.length === 0) {
-    return "";
-  }
-  return lines5(
-    h24("\u{1F5C3}\uFE0F Groups"),
-    formatGroupsOrAuditsDetails("group", diff.groups, {
-      columns: [
-        { key: "plugin", label: "\u{1F50C} Plugin", align: "left" },
-        { key: "group", label: "\u{1F5C3}\uFE0F Group", align: "left" },
-        { key: "before", label: "\u2B50 Previous score" },
-        { key: "after", label: "\u2B50 Current score" },
-        { key: "change", label: "\u{1F504} Score change" }
-      ],
-      rows: sortChanges(diff.groups.changed).map((group) => ({
-        plugin: formatTitle(group.plugin),
-        group: formatTitle(group),
-        after: formatScoreWithColor(group.scores.after),
-        before: formatScoreWithColor(group.scores.before, { skipBold: true }),
-        change: formatScoreChange(group.scores.diff)
-      }))
-    })
-  );
-}
-function formatDiffAuditsSection(diff) {
-  return lines5(
-    h24("\u{1F6E1}\uFE0F Audits"),
-    formatGroupsOrAuditsDetails("audit", diff.audits, {
-      columns: [
-        { key: "plugin", label: "\u{1F50C} Plugin", align: "left" },
-        { key: "audit", label: "\u{1F6E1}\uFE0F Audit", align: "left" },
-        { key: "before", label: "\u{1F4CF} Previous value" },
-        { key: "after", label: "\u{1F4CF} Current value" },
-        { key: "change", label: "\u{1F504} Value change" }
-      ],
-      rows: sortChanges(diff.audits.changed).map((audit) => ({
-        plugin: formatTitle(audit.plugin),
-        audit: formatTitle(audit),
-        after: `${scoreMarker(audit.scores.after, "square")} ${boldMd3(
-          audit.displayValues.after || audit.values.after.toString()
-        )}`,
-        before: `${scoreMarker(audit.scores.before, "square")} ${audit.displayValues.before || audit.values.before.toString()}`,
-        change: formatValueChange(audit)
-      }))
-    })
-  );
-}
-function formatGroupsOrAuditsDetails(token, { changed, unchanged }, tableData) {
-  return changed.length === 0 ? summarizeUnchanged(token, { changed, unchanged }) : details3(
-    summarizeDiffOutcomes(changesToDiffOutcomes(changed), token),
-    lines5(
-      table4({
-        ...tableData,
-        rows: tableData.rows.slice(0, MAX_ROWS)
-        // use never to avoid typing problem
-      }),
-      changed.length > MAX_ROWS && italicMd(
-        `Only the ${MAX_ROWS} most affected ${pluralize(
-          token
-        )} are listed above for brevity.`
-      ),
-      unchanged.length > 0 && summarizeUnchanged(token, { changed, unchanged })
-    )
-  );
-}
-function formatScoreChange(diff) {
-  const marker = getDiffMarker(diff);
-  const text = formatDiffNumber(Math.round(diff * 1e3) / 10);
-  return colorByScoreDiff(`${marker} ${text}`, diff);
-}
-function formatValueChange({
-  values,
-  scores
-}) {
-  const marker = getDiffMarker(values.diff);
-  const percentage = values.before === 0 ? values.diff > 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY : Math.round(100 * values.diff / values.before);
-  const text = `${formatDiffNumber(percentage)}\u2009%`;
-  return colorByScoreDiff(`${marker} ${text}`, scores.diff);
-}
 function summarizeUnchanged(token, { changed, unchanged }) {
-  return section5(
-    [
-      changed.length > 0 ? pluralizeToken(`other ${token}`, unchanged.length) : `All of ${pluralizeToken(token, unchanged.length)}`,
-      unchanged.length === 1 ? "is" : "are",
-      "unchanged."
-    ].join(" ")
-  );
+  const pluralizedCount = changed.length > 0 ? pluralizeToken(`other ${token}`, unchanged.length) : `All of ${pluralizeToken(token, unchanged.length)}`;
+  const pluralizedVerb = unchanged.length === 1 ? "is" : "are";
+  return `${pluralizedCount} ${pluralizedVerb} unchanged.`;
 }
 function summarizeDiffOutcomes(outcomes, token) {
   return objectToEntries(countDiffOutcomes(outcomes)).filter(
@@ -2164,20 +1870,46 @@ function summarizeDiffOutcomes(outcomes, token) {
     }
   }).join(", ");
 }
+function createGroupsOrAuditsDetails(token, { changed, unchanged }, ...[columns, rows]) {
+  if (changed.length === 0) {
+    return new MarkdownDocument4().paragraph(
+      summarizeUnchanged(token, { changed, unchanged })
+    );
+  }
+  return new MarkdownDocument4().table(columns, rows.slice(0, MAX_ROWS)).paragraph(
+    changed.length > MAX_ROWS && md5.italic(
+      `Only the ${MAX_ROWS} most affected ${pluralize(
+        token
+      )} are listed above for brevity.`
+    )
+  ).paragraph(
+    unchanged.length > 0 && summarizeUnchanged(token, { changed, unchanged })
+  );
+}
 function formatTitle({
   title,
   docsUrl
 }) {
   if (docsUrl) {
-    return link6(docsUrl, title);
+    return md5.link(docsUrl, title);
   }
   return title;
 }
+function formatPortalLink(portalUrl) {
+  return portalUrl && md5.link(portalUrl, "\u{1F575}\uFE0F See full comparison in Code PushUp portal \u{1F50D}");
+}
 function sortChanges(changes) {
   return [...changes].sort(
     (a, b) => Math.abs(b.scores.diff) - Math.abs(a.scores.diff) || Math.abs(b.values?.diff ?? 0) - Math.abs(a.values?.diff ?? 0)
   );
 }
+function getDiffChanges(diff) {
+  return [
+    ...diff.categories.changed,
+    ...diff.groups.changed,
+    ...diff.audits.changed
+  ];
+}
 function changesToDiffOutcomes(changes) {
   return changes.map((change) => {
     if (change.scores.diff > 0) {
@@ -2212,9 +1944,218 @@ function countDiffOutcomes(outcomes) {
     unchanged: outcomes.filter((outcome) => outcome === "unchanged").length
   };
 }
+function formatReportOutcome(outcome, commits) {
+  const outcomeTexts = {
+    positive: md5`🥳 Code PushUp report has ${md5.bold("improved")}`,
+    negative: md5`😟 Code PushUp report has ${md5.bold("regressed")}`,
+    mixed: md5`🤨 Code PushUp report has both ${md5.bold(
+      "improvements and regressions"
+    )}`,
+    unchanged: md5`😐 Code PushUp report is ${md5.bold("unchanged")}`
+  };
+  if (commits) {
+    const commitsText = `compared target commit ${commits.after.hash} with source commit ${commits.before.hash}`;
+    return md5`${outcomeTexts[outcome]} – ${commitsText}.`;
+  }
+  return md5`${outcomeTexts[outcome]}.`;
+}
+function compareDiffsBy(type, a, b) {
+  return sumScoreChanges(b[type].changed) - sumScoreChanges(a[type].changed) || sumConfigChanges(b[type]) - sumConfigChanges(a[type]);
+}
+function sumScoreChanges(changes) {
+  return changes.reduce(
+    (acc, { scores }) => acc + Math.abs(scores.diff),
+    0
+  );
+}
+function sumConfigChanges({
+  added,
+  removed
+}) {
+  return added.length + removed.length;
+}
+
+// packages/utils/src/lib/reports/generate-md-reports-diff.ts
+function generateMdReportsDiff(diff) {
+  return new MarkdownDocument5().$concat(
+    createDiffHeaderSection(diff),
+    createDiffCategoriesSection(diff),
+    createDiffDetailsSection(diff)
+  ).toString();
+}
+function generateMdReportsDiffForMonorepo(diffs) {
+  const diffsWithOutcomes = diffs.map((diff) => ({
+    ...diff,
+    outcome: mergeDiffOutcomes(changesToDiffOutcomes(getDiffChanges(diff)))
+  })).sort(
+    (a, b) => compareDiffsBy("categories", a, b) || compareDiffsBy("groups", a, b) || compareDiffsBy("audits", a, b) || a.label.localeCompare(b.label)
+  );
+  const unchanged = diffsWithOutcomes.filter(
+    ({ outcome }) => outcome === "unchanged"
+  );
+  const changed = diffsWithOutcomes.filter((diff) => !unchanged.includes(diff));
+  return new MarkdownDocument5().$concat(
+    createDiffHeaderSection(diffs),
+    ...changed.map(createDiffProjectSection)
+  ).$if(
+    unchanged.length > 0,
+    (doc) => doc.rule().paragraph(summarizeUnchanged("project", { unchanged, changed }))
+  ).toString();
+}
+function createDiffHeaderSection(diff) {
+  const outcome = mergeDiffOutcomes(
+    changesToDiffOutcomes(toArray(diff).flatMap(getDiffChanges))
+  );
+  const commits = Array.isArray(diff) ? diff[0]?.commits : diff.commits;
+  const portalUrl = Array.isArray(diff) ? void 0 : diff.portalUrl;
+  return new MarkdownDocument5().heading(HIERARCHY.level_1, "Code PushUp").paragraph(formatReportOutcome(outcome, commits)).paragraph(formatPortalLink(portalUrl));
+}
+function createDiffProjectSection(diff) {
+  return new MarkdownDocument5().heading(HIERARCHY.level_2, md6`💼 Project ${md6.code(diff.label)}`).paragraph(formatReportOutcome(diff.outcome)).paragraph(formatPortalLink(diff.portalUrl)).$concat(
+    createDiffCategoriesSection(diff, {
+      skipHeading: true,
+      skipUnchanged: true
+    }),
+    createDiffDetailsSection(diff, HIERARCHY.level_3)
+  );
+}
+function createDiffCategoriesSection(diff, options) {
+  const { changed, unchanged, added } = diff.categories;
+  const { skipHeading, skipUnchanged } = options ?? {};
+  const categoriesCount = changed.length + unchanged.length + added.length;
+  const hasChanges = unchanged.length < categoriesCount;
+  if (categoriesCount === 0) {
+    return null;
+  }
+  const [columns, rows] = createCategoriesTable(diff, {
+    hasChanges,
+    skipUnchanged
+  });
+  return new MarkdownDocument5().heading(HIERARCHY.level_2, !skipHeading && "\u{1F3F7}\uFE0F Categories").table(columns, rows).paragraph(added.length > 0 && md6.italic("(\\*) New category.")).paragraph(
+    skipUnchanged && unchanged.length > 0 && summarizeUnchanged("category", { changed, unchanged })
+  );
+}
+function createCategoriesTable(diff, options) {
+  const { changed, unchanged, added } = diff.categories;
+  const { hasChanges, skipUnchanged } = options;
+  const columns = [
+    { heading: "\u{1F3F7}\uFE0F Category", alignment: "left" },
+    {
+      heading: hasChanges ? "\u2B50 Previous score" : "\u2B50 Score",
+      alignment: "center"
+    },
+    { heading: "\u2B50 Current score", alignment: "center" },
+    { heading: "\u{1F504} Score change", alignment: "center" }
+  ];
+  const rows = [
+    ...sortChanges(changed).map((category) => [
+      formatTitle(category),
+      formatScoreWithColor(category.scores.before, {
+        skipBold: true
+      }),
+      formatScoreWithColor(category.scores.after),
+      formatScoreChange(category.scores.diff)
+    ]),
+    ...added.map((category) => [
+      formatTitle(category),
+      md6.italic("n/a (\\*)"),
+      formatScoreWithColor(category.score),
+      md6.italic("n/a (\\*)")
+    ]),
+    ...skipUnchanged ? [] : unchanged.map((category) => [
+      formatTitle(category),
+      formatScoreWithColor(category.score, { skipBold: true }),
+      formatScoreWithColor(category.score),
+      "\u2013"
+    ])
+  ];
+  return [
+    hasChanges ? columns : columns.slice(0, 2),
+    rows.map((row) => hasChanges ? row : row.slice(0, 2))
+  ];
+}
+function createDiffDetailsSection(diff, level = HIERARCHY.level_2) {
+  if (diff.groups.changed.length + diff.audits.changed.length === 0) {
+    return null;
+  }
+  const summary = ["group", "audit"].map(
+    (token) => summarizeDiffOutcomes(
+      changesToDiffOutcomes(diff[`${token}s`].changed),
+      token
+    )
+  ).filter(Boolean).join(", ");
+  const details2 = new MarkdownDocument5().$concat(
+    createDiffGroupsSection(diff, level),
+    createDiffAuditsSection(diff, level)
+  );
+  return new MarkdownDocument5().details(summary, details2);
+}
+function createDiffGroupsSection(diff, level) {
+  if (diff.groups.changed.length + diff.groups.unchanged.length === 0) {
+    return null;
+  }
+  return new MarkdownDocument5().heading(level, "\u{1F5C3}\uFE0F Groups").$concat(
+    createGroupsOrAuditsDetails(
+      "group",
+      diff.groups,
+      [
+        { heading: "\u{1F50C} Plugin", alignment: "left" },
+        { heading: "\u{1F5C3}\uFE0F Group", alignment: "left" },
+        { heading: "\u2B50 Previous score", alignment: "center" },
+        { heading: "\u2B50 Current score", alignment: "center" },
+        { heading: "\u{1F504} Score change", alignment: "center" }
+      ],
+      sortChanges(diff.groups.changed).map((group) => [
+        formatTitle(group.plugin),
+        formatTitle(group),
+        formatScoreWithColor(group.scores.before, { skipBold: true }),
+        formatScoreWithColor(group.scores.after),
+        formatScoreChange(group.scores.diff)
+      ])
+    )
+  );
+}
+function createDiffAuditsSection(diff, level) {
+  return new MarkdownDocument5().heading(level, "\u{1F6E1}\uFE0F Audits").$concat(
+    createGroupsOrAuditsDetails(
+      "audit",
+      diff.audits,
+      [
+        { heading: "\u{1F50C} Plugin", alignment: "left" },
+        { heading: "\u{1F6E1}\uFE0F Audit", alignment: "left" },
+        { heading: "\u{1F4CF} Previous value", alignment: "center" },
+        { heading: "\u{1F4CF} Current value", alignment: "center" },
+        { heading: "\u{1F504} Value change", alignment: "center" }
+      ],
+      sortChanges(diff.audits.changed).map((audit) => [
+        formatTitle(audit.plugin),
+        formatTitle(audit),
+        `${scoreMarker(audit.scores.before, "square")} ${audit.displayValues.before || audit.values.before.toString()}`,
+        md6`${scoreMarker(audit.scores.after, "square")} ${md6.bold(
+          audit.displayValues.after || audit.values.after.toString()
+        )}`,
+        formatValueChange(audit)
+      ])
+    )
+  );
+}
+
+// packages/utils/src/lib/reports/load-report.ts
+import { join as join2 } from "node:path";
+async function loadReport(options) {
+  const { outputDir, filename, format } = options;
+  await ensureDirectoryExists(outputDir);
+  const filePath = join2(outputDir, `${filename}.${format}`);
+  if (format === "json") {
+    const content = await readJsonFile(filePath);
+    return reportSchema.parse(content);
+  }
+  const text = await readTextFile(filePath);
+  return text;
+}
 
 // packages/utils/src/lib/reports/log-stdout-summary.ts
-import chalk4 from "chalk";
+import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
 function log(msg = "") {
   ui().logger.log(msg);
 }
@@ -2231,14 +2172,14 @@ function logStdoutSummary(report) {
 }
 function reportToHeaderSection(report) {
   const { packageName, version: version2 } = report;
-  return `${chalk4.bold(reportHeadlineText)} - ${packageName}@${version2}`;
+  return `${bold4(REPORT_HEADLINE_TEXT)} - ${packageName}@${version2}`;
 }
 function logPlugins(report) {
   const { plugins } = report;
   plugins.forEach((plugin) => {
     const { title, audits } = plugin;
     log();
-    log(chalk4.magentaBright.bold(`${title} audits`));
+    log(bold4.magentaBright(`${title} audits`));
     log();
     audits.forEach((audit) => {
       ui().row([
@@ -2253,8 +2194,9 @@ function logPlugins(report) {
           padding: [0, 3, 0, 0]
         },
         {
-          text: chalk4.cyanBright(audit.displayValue || `${audit.value}`),
-          width: 10,
+          text: cyanBright(audit.displayValue || `${audit.value}`),
+          // eslint-disable-next-line no-magic-numbers
+          width: 20,
           padding: [0, 0, 0, 0]
         }
       ]);
@@ -2264,42 +2206,38 @@ function logPlugins(report) {
 }
 function logCategories({ categories, plugins }) {
   const hAlign = (idx) => idx === 0 ? "left" : "right";
-  const rows = categories.map(({ title, score, refs }) => [
+  const rows = categories.map(({ title, score, refs, isBinary }) => [
     title,
-    applyScoreColor({ score }),
+    `${binaryIconPrefix(score, isBinary)}${applyScoreColor({ score })}`,
     countCategoryAudits(refs, plugins)
   ]);
-  const table5 = ui().table();
-  table5.columnWidths([TERMINAL_WIDTH - 9 - 10 - 4, 9, 10]);
-  table5.head(
-    reportRawOverviewTableHeaders.map((heading, idx) => ({
-      content: chalk4.cyan(heading),
+  const table2 = ui().table();
+  table2.columnWidths([TERMINAL_WIDTH - 9 - 10 - 4, 9, 10]);
+  table2.head(
+    REPORT_RAW_OVERVIEW_TABLE_HEADERS.map((heading, idx) => ({
+      content: cyan(heading),
       hAlign: hAlign(idx)
     }))
   );
   rows.forEach(
-    (row) => table5.row(
+    (row) => table2.row(
       row.map((content, idx) => ({
         content: content.toString(),
         hAlign: hAlign(idx)
       }))
     )
   );
-  log(chalk4.magentaBright.bold("Categories"));
+  log(bold4.magentaBright("Categories"));
   log();
-  table5.render();
+  table2.render();
   log();
 }
-function applyScoreColor({ score, text }) {
-  const formattedScore = text ?? formatReportScore(score);
-  const style = text ? chalk4 : chalk4.bold;
-  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
-    return style.green(formattedScore);
-  }
-  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
-    return style.yellow(formattedScore);
-  }
-  return style.red(formattedScore);
+function binaryIconPrefix(score, isBinary) {
+  return targetScoreIcon(score, isBinary ? 1 : void 0, {
+    passIcon: bold4(green2("\u2713")),
+    failIcon: bold4(red("\u2717")),
+    postfix: " "
+  });
 }
 
 // packages/utils/src/lib/reports/scoring.ts
@@ -2389,56 +2327,6 @@ function parseScoringParameters(refs, scoreFn) {
   return scoredRefs;
 }
 
-// packages/utils/src/lib/reports/sorting.ts
-function sortReport(report) {
-  const { categories, plugins } = report;
-  const sortedCategories = categories.map((category) => {
-    const { audits, groups } = category.refs.reduce(
-      (acc, ref) => ({
-        ...acc,
-        ...ref.type === "group" ? {
-          groups: [...acc.groups, getSortableGroupByRef(ref, plugins)]
-        } : {
-          audits: [...acc.audits, getSortableAuditByRef(ref, plugins)]
-        }
-      }),
-      { groups: [], audits: [] }
-    );
-    const sortedAuditsAndGroups = [...audits, ...groups].sort(
-      compareCategoryAuditsAndGroups
-    );
-    const sortedRefs = [...category.refs].sort((a, b) => {
-      const aIndex = sortedAuditsAndGroups.findIndex(
-        (ref) => ref.slug === a.slug && ref.plugin === a.plugin
-      );
-      const bIndex = sortedAuditsAndGroups.findIndex(
-        (ref) => ref.slug === b.slug && ref.plugin === b.plugin
-      );
-      return aIndex - bIndex;
-    });
-    return { ...category, refs: sortedRefs };
-  });
-  return {
-    ...report,
-    categories: sortedCategories,
-    plugins: sortPlugins(plugins)
-  };
-}
-function sortPlugins(plugins) {
-  return plugins.map((plugin) => ({
-    ...plugin,
-    audits: [...plugin.audits].sort(compareAudits).map(
-      (audit) => audit.details?.issues ? {
-        ...audit,
-        details: {
-          ...audit.details,
-          issues: [...audit.details.issues].sort(compareIssues)
-        }
-      } : audit
-    )
-  }));
-}
-
 // packages/utils/src/lib/verbose-utils.ts
 function getLogVerbose(verbose = false) {
   return (msg) => {
@@ -2461,10 +2349,10 @@ var verboseUtils = (verbose = false) => ({
 
 // packages/core/package.json
 var name = "@code-pushup/core";
-var version = "0.48.0";
+var version = "0.50.0";
 
 // packages/core/src/lib/implementation/execute-plugin.ts
-import chalk5 from "chalk";
+import { bold as bold5 } from "ansis";
 
 // packages/core/src/lib/normalize.ts
 function normalizeIssue(issue, gitRoot) {
@@ -2527,7 +2415,7 @@ async function executeRunnerFunction(runner, onProgress) {
 var PluginOutputMissingAuditError = class extends Error {
   constructor(auditSlug) {
     super(
-      `Audit metadata not present in plugin config. Missing slug: ${chalk5.bold(
+      `Audit metadata not present in plugin config. Missing slug: ${bold5(
         auditSlug
       )}`
     );
@@ -2569,7 +2457,7 @@ async function executePlugin(pluginConfig, onProgress) {
   };
 }
 var wrapProgress = async (pluginCfg, steps, progressBar) => {
-  progressBar?.updateTitle(`Executing ${chalk5.bold(pluginCfg.title)}`);
+  progressBar?.updateTitle(`Executing ${bold5(pluginCfg.title)}`);
   try {
     const pluginReport = await executePlugin(pluginCfg);
     progressBar?.incrementInSteps(steps);
@@ -2577,7 +2465,7 @@ var wrapProgress = async (pluginCfg, steps, progressBar) => {
   } catch (error) {
     progressBar?.incrementInSteps(steps);
     throw new Error(
-      error instanceof Error ? `- Plugin ${chalk5.bold(pluginCfg.title)} (${chalk5.bold(
+      error instanceof Error ? `- Plugin ${bold5(pluginCfg.title)} (${bold5(
         pluginCfg.slug
       )}) produced the following error:
   - ${error.message}` : String(error)
@@ -2717,6 +2605,10 @@ async function collectAndPersistReports(options) {
 // packages/core/src/lib/compare.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 import { join as join5 } from "node:path";
+import {
+  PortalOperationError,
+  getPortalComparisonLink
+} from "@code-pushup/portal-client";
 
 // packages/core/src/lib/implementation/compare-scorables.ts
 function compareCategories(reports) {
@@ -2853,7 +2745,7 @@ function selectMeta(meta) {
 }
 
 // packages/core/src/lib/compare.ts
-async function compareReportFiles(inputPaths, persistConfig) {
+async function compareReportFiles(inputPaths, persistConfig, uploadConfig, label) {
   const { outputDir, filename, format } = persistConfig;
   const [reportBefore, reportAfter] = await Promise.all([
     readJsonFile(inputPaths.before),
@@ -2863,11 +2755,20 @@ async function compareReportFiles(inputPaths, persistConfig) {
     before: reportSchema.parse(reportBefore),
     after: reportSchema.parse(reportAfter)
   };
-  const reportsDiff = compareReports(reports);
+  const diff = compareReports(reports);
+  if (label) {
+    diff.label = label;
+  }
+  if (uploadConfig && diff.commits) {
+    diff.portalUrl = await fetchPortalComparisonLink(
+      uploadConfig,
+      diff.commits
+    );
+  }
   return Promise.all(
     format.map(async (fmt) => {
       const outputPath = join5(outputDir, `${filename}-diff.${fmt}`);
-      const content = reportsDiffToFileContent(reportsDiff, fmt);
+      const content = reportsDiffToFileContent(diff, fmt);
       await ensureDirectoryExists(outputDir);
       await writeFile2(outputPath, content);
       return outputPath;
@@ -2905,6 +2806,29 @@ function reportsDiffToFileContent(reportsDiff, format) {
       return generateMdReportsDiff(reportsDiff);
   }
 }
+async function fetchPortalComparisonLink(uploadConfig, commits) {
+  const { server, apiKey, organization, project } = uploadConfig;
+  try {
+    return await getPortalComparisonLink({
+      server,
+      apiKey,
+      parameters: {
+        organization,
+        project,
+        before: commits.before.hash,
+        after: commits.after.hash
+      }
+    });
+  } catch (error) {
+    if (error instanceof PortalOperationError) {
+      ui().logger.warning(
+        `Failed to fetch portal comparison link - ${error.message}`
+      );
+      return void 0;
+    }
+    throw error;
+  }
+}
 
 // packages/core/src/lib/upload.ts
 import {
@@ -2960,9 +2884,9 @@ function auditToGQL(audit) {
     score,
     value,
     displayValue: formattedValue,
-    details: details4
+    details: details2
   } = audit;
-  const { issues, table: table5 } = details4 ?? {};
+  const { issues, table: table2 } = details2 ?? {};
   return {
     slug,
     title,
@@ -2971,10 +2895,10 @@ function auditToGQL(audit) {
     score,
     value,
     formattedValue,
-    ...details4 && {
+    ...details2 && {
       details: {
         ...issues && { issues: issues.map(issueToGQL) },
-        ...table5 && { tables: [tableToGQL(table5)] }
+        ...table2 && { tables: [tableToGQL(table2)] }
       }
     }
   };
@@ -2993,11 +2917,11 @@ function issueToGQL(issue) {
     }
   };
 }
-function tableToGQL(table5) {
+function tableToGQL(table2) {
   return {
-    ...table5.title && { title: table5.title },
-    ...table5.columns?.length && {
-      columns: table5.columns.map(
+    ...table2.title && { title: table2.title },
+    ...table2.columns?.length && {
+      columns: table2.columns.map(
         (column) => typeof column === "string" ? { alignment: tableAlignmentToGQL(column) } : {
           key: column.key,
           label: column.label,
@@ -3005,7 +2929,7 @@ function tableToGQL(table5) {
         }
       )
     },
-    rows: table5.rows.map(
+    rows: table2.rows.map(
       (row) => Array.isArray(row) ? row.map((content) => ({ content: content?.toString() ?? "" })) : Object.entries(row).map(([key, content]) => ({
         key,
         content: content?.toString() ?? ""
@@ -3151,6 +3075,45 @@ async function autoloadRc(tsconfig) {
     tsconfig
   );
 }
+
+// packages/core/src/lib/merge-diffs.ts
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { basename, dirname, join as join7 } from "node:path";
+async function mergeDiffs(files, persistConfig) {
+  const results = await Promise.allSettled(
+    files.map(async (file) => {
+      const json = await readJsonFile(file).catch((error) => {
+        throw new Error(
+          `Failed to read JSON file ${file} - ${stringifyError(error)}`
+        );
+      });
+      const result = await reportsDiffSchema.safeParseAsync(json);
+      if (!result.success) {
+        throw new Error(
+          `Invalid reports diff in ${file} - ${result.error.message}`
+        );
+      }
+      return { ...result.data, file };
+    })
+  );
+  results.filter(isPromiseRejectedResult).forEach(({ reason }) => {
+    ui().logger.warning(
+      `Skipped invalid report diff - ${stringifyError(reason)}`
+    );
+  });
+  const diffs = results.filter(isPromiseFulfilledResult).map(({ value }) => value);
+  const labeledDiffs = diffs.map((diff) => ({
+    ...diff,
+    label: diff.label || basename(dirname(diff.file))
+    // fallback is parent folder name
+  }));
+  const markdown = generateMdReportsDiffForMonorepo(labeledDiffs);
+  const { outputDir, filename } = persistConfig;
+  const outputPath = join7(outputDir, `${filename}-diff.md`);
+  await ensureDirectoryExists(outputDir);
+  await writeFile3(outputPath, markdown);
+  return outputPath;
+}
 export {
   ConfigPathError,
   PersistDirError,
@@ -3164,6 +3127,7 @@ export {
   executePlugin,
   executePlugins,
   history,
+  mergeDiffs,
   persistReport,
   readRcByPath,
   upload