@code-pushup/utils 0.47.0 → 0.49.0

package/index.js

@@ -739,11 +739,262 @@ function comparePairs(pairs, equalsFn) {
 import { spawn } from "node:child_process";
 
 // packages/utils/src/lib/reports/utils.ts
-import { join as join2 } from "node:path";
+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
+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.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];
+}
+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 { 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", (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";
 import { join } from "node:path";
 
@@ -836,55 +1087,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) {
@@ -908,7 +1111,7 @@ function logListItem(args) {
   singletonUiInstance?.logger.log(content);
 }
 function link(text) {
-  return chalk.underline(chalk.blueBright(text));
+  return underline.blueBright(text);
 }
 
 // packages/utils/src/lib/log-results.ts
@@ -988,10 +1191,10 @@ async function removeDirectoryIfExists(dir) {
 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,
@@ -1031,46 +1234,25 @@ async function crawlFileSystem(options) {
   return resultsNestedArray.flat();
 }
 function findLineNumberInText(content, pattern) {
-  const lines6 = content.split(/\r?\n/);
-  const lineNumber = lines6.findIndex((line) => line.includes(pattern)) + 1;
+  const lines = content.split(/\r?\n/);
+  const lineNumber = lines.findIndex((line) => line.includes(pattern)) + 1;
   return lineNumber === 0 ? null : lineNumber;
 }
 function filePathToCliArg(path) {
   return `"${path}"`;
 }
 
-// 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/text-formats/html/font-style.ts
-var boldElement = "b";
-function bold(text) {
-  return `<${boldElement}>${text}</${boldElement}>`;
-}
-var italicElement = "i";
-function italic(text) {
-  return `<${italicElement}>${text}</${italicElement}>`;
-}
-var codeElement = "code";
-function code(text) {
-  return `<${codeElement}>${text}</${codeElement}>`;
+// packages/utils/src/lib/filter.ts
+function filterItemRefsBy(items, refFilterFn) {
+  return items.map((item) => ({
+    ...item,
+    refs: item.refs.filter(refFilterFn)
+  })).filter((item) => item.refs.length);
 }
 
-// packages/utils/src/lib/text-formats/html/link.ts
-function link2(href, text) {
-  return `<a href="${href}">${text || href}</a>`;
-}
+// packages/utils/src/lib/git/git.ts
+import { isAbsolute, join as join2, relative } from "node:path";
+import { simpleGit } from "simple-git";
 
 // packages/utils/src/lib/transform.ts
 import { platform } from "node:os";
@@ -1121,6 +1303,12 @@ function objectToCliArgs(params) {
     if (Array.isArray(value)) {
       return value.map((v) => `${prefix}${key}="${v}"`);
     }
+    if (typeof value === "object") {
+      return Object.entries(value).flatMap(
+        // transform nested objects to the dot notation `key.subkey`
+        ([k, v]) => objectToCliArgs({ [`${key}.${k}`]: v })
+      );
+    }
     if (typeof value === "string") {
       return [`${prefix}${key}="${value}"`];
     }
@@ -1151,11 +1339,6 @@ function capitalize(text) {
     1
   )}`;
 }
-function apostrophize(text, upperCase) {
-  const lastCharMatch = text.match(/(\w)\W*$/);
-  const lastChar = lastCharMatch?.[1] ?? "";
-  return `${text}'${lastChar.toLocaleLowerCase() === "s" ? "" : upperCase ? "S" : "s"}`;
-}
 function toNumberPrecision(value, decimalPlaces) {
   return Number(
     `${Math.round(
@@ -1176,1088 +1359,908 @@ function toOrdinal(value) {
   return `${value}th`;
 }
 
-// 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));
+// packages/utils/src/lib/git/git.ts
+function getGitRoot(git = simpleGit()) {
+  return git.revparse("--show-toplevel");
 }
-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 formatGitPath(path, gitRoot) {
+  const absolutePath = isAbsolute(path) ? path : join2(process.cwd(), path);
+  const relativePath = relative(gitRoot, absolutePath);
+  return toUnixPath(relativePath);
 }
-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";
-  }
+async function toGitPath(path, git = simpleGit()) {
+  const gitRoot = await getGitRoot(git);
+  return formatGitPath(path, gitRoot);
 }
-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)
+var GitStatusError = class _GitStatusError extends Error {
+  static ignoredProps = /* @__PURE__ */ new Set(["current", "tracking"]);
+  static getReducedStatus(status) {
+    return Object.fromEntries(
+      Object.entries(status).filter(([key]) => !this.ignoredProps.has(key)).filter(
+        (entry) => {
+          const value = entry[1];
+          if (value == null) {
+            return false;
+          }
+          if (Array.isArray(value) && value.length === 0) {
+            return false;
+          }
+          if (typeof value === "number" && value === 0) {
+            return false;
+          }
+          return !(typeof value === "boolean" && !value);
+        }
+      )
     );
   }
-  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
-      )
+  constructor(status) {
+    super(
+      `Working directory needs to be clean before we you can proceed. Commit your local changes or stash them: 
+ ${JSON.stringify(
+        _GitStatusError.getReducedStatus(status),
+        null,
+        2
+      )}`
     );
   }
-  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");
+};
+async function guardAgainstLocalChanges(git = simpleGit()) {
+  const status = await git.status(["-s"]);
+  if (status.files.length > 0) {
+    throw new GitStatusError(status);
   }
-  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);
+async function safeCheckout(branchOrHash, forceCleanStatus = false, git = simpleGit()) {
+  if (forceCleanStatus) {
+    await git.raw(["reset", "--hard"]);
+    await git.clean(["f", "d"]);
+    ui().logger.info(`git status cleaned`);
+  }
+  await guardAgainstLocalChanges(git);
+  await git.checkout(branchOrHash);
 }
 
-// packages/utils/src/lib/text-formats/md/image.ts
-function image(src, alt) {
-  return `![${alt}](${src})`;
-}
+// packages/utils/src/lib/git/git.commits-and-tags.ts
+import { simpleGit as simpleGit2 } from "simple-git";
 
-// packages/utils/src/lib/text-formats/md/link.ts
-function link3(href, text) {
-  return `[${text || href}](${href})`;
+// packages/utils/src/lib/semver.ts
+import { rcompare, valid } from "semver";
+function normalizeSemver(semverString) {
+  if (semverString.startsWith("v") || semverString.startsWith("V")) {
+    return semverString.slice(1);
+  }
+  if (semverString.includes("@")) {
+    return semverString.split("@").at(-1) ?? "";
+  }
+  return semverString;
 }
-
-// packages/utils/src/lib/text-formats/md/list.ts
-function li(text, order = "unordered") {
-  const style = order === "unordered" ? "-" : "- [ ]";
-  return `${style} ${text}`;
+function isSemver(semverString = "") {
+  return valid(normalizeSemver(semverString)) != null;
 }
-function indentation(text, level = 1) {
-  return `${TAB.repeat(level)}${text}`;
+function sortSemvers(semverStrings) {
+  return semverStrings.map(normalizeSemver).filter(isSemver).sort(rcompare);
 }
 
-// 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/git/git.commits-and-tags.ts
+async function getLatestCommit(git = simpleGit2()) {
+  const log2 = await git.log({
+    maxCount: 1,
+    // git log -1 --pretty=format:"%H %s %an %aI" - See: https://git-scm.com/docs/pretty-formats
+    format: { hash: "%H", message: "%s", author: "%an", date: "%aI" }
+  });
+  return commitSchema.parse(log2.latest);
 }
-
-// packages/utils/src/lib/text-formats/md/section.ts
-function section(...contents) {
-  return `${lines(...contents)}${NEW_LINE}`;
+async function getCurrentBranchOrTag(git = simpleGit2()) {
+  return await git.branch().then((r) => r.current) || // If no current branch, try to get the tag
+  // @TODO use simple git
+  await git.raw(["describe", "--tags", "--exact-match"]).then((out) => out.trim());
 }
-function lines(...contents) {
-  const filteredContent = contents.filter(
-    (value) => value != null && value !== "" && value !== false
-  );
-  return `${filteredContent.join(NEW_LINE)}`;
+function validateFilter({ from, to }) {
+  if (to && !from) {
+    throw new Error(
+      `filter needs the "from" option defined to accept the "to" option.
+`
+    );
+  }
 }
-
-// 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");
+function filterLogs(allTags, opt) {
+  if (!opt) {
+    return allTags;
   }
-  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)
-    )}`
-  );
+  validateFilter(opt);
+  const { from, to, maxCount } = opt;
+  const finIndex = (tagName, fallback) => {
+    const idx = allTags.indexOf(tagName ?? "");
+    if (idx > -1) {
+      return idx;
+    }
+    return fallback;
+  };
+  const fromIndex = finIndex(from, 0);
+  const toIndex = finIndex(to, void 0);
+  return allTags.slice(fromIndex, toIndex ? toIndex + 1 : toIndex).slice(0, maxCount ?? void 0);
 }
-
-// packages/utils/src/lib/text-formats/index.ts
-var md = {
-  bold: bold2,
-  italic: italic2,
-  strikeThrough,
-  code: code2,
-  link: link3,
-  image,
-  headline,
-  h,
-  h1,
-  h2,
-  h3,
-  h4,
-  h5,
-  h6,
-  indentation,
-  lines,
-  li,
-  section,
-  paragraphs,
-  table: table2
-};
-var html = {
-  bold,
-  italic,
-  code,
-  link: link2,
-  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}`;
+async function getHashFromTag(tag, git = simpleGit2()) {
+  const tagDetails = await git.show(["--no-patch", "--format=%H", tag]);
+  const hash = tagDetails.trim();
+  return {
+    hash: hash.split("\n").at(-1) ?? "",
+    message: tag
+  };
 }
-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;
+async function getSemverTags(opt = {}, git = simpleGit2()) {
+  validateFilter(opt);
+  const { targetBranch, ...options } = opt;
+  let currentBranch;
+  if (targetBranch) {
+    currentBranch = await getCurrentBranchOrTag(git);
+    await git.checkout(targetBranch);
   }
-  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
-    return MARKERS[markerType].yellow;
+  const tagsRaw = await git.tag([
+    "--merged",
+    targetBranch ?? await getCurrentBranchOrTag(git)
+  ]);
+  const allTags = tagsRaw.split(/\n/).map((tag) => tag.trim()).filter(Boolean).filter(isSemver);
+  const relevantTags = filterLogs(allTags, options);
+  const tagsWithHashes = await Promise.all(
+    relevantTags.map((tag) => getHashFromTag(tag, git))
+  );
+  if (currentBranch) {
+    await git.checkout(currentBranch);
   }
-  return MARKERS[markerType].red;
+  return tagsWithHashes;
 }
-function getDiffMarker(diff) {
-  if (diff > 0) {
-    return "\u2191";
+async function getHashes(options = {}, git = simpleGit2()) {
+  const { targetBranch, from, to, maxCount, ...opt } = options;
+  validateFilter({ from, to });
+  let currentBranch;
+  if (targetBranch) {
+    currentBranch = await getCurrentBranchOrTag(git);
+    await git.checkout(targetBranch);
   }
-  if (diff < 0) {
-    return "\u2193";
+  const logs = await git.log({
+    ...opt,
+    format: {
+      hash: "%H",
+      message: "%s"
+    },
+    from,
+    to,
+    maxCount
+  });
+  if (targetBranch) {
+    await git.checkout(currentBranch);
   }
-  return "";
-}
-function colorByScoreDiff(text, diff) {
-  const color = diff > 0 ? "green" : diff < 0 ? "red" : "gray";
-  return shieldsBadge(text, color);
+  return [...logs.all];
 }
-function shieldsBadge(text, color) {
-  return image2(
-    `https://img.shields.io/badge/${encodeURIComponent(text)}-${color}`,
-    text
+
+// packages/utils/src/lib/group-by-status.ts
+function groupByStatus(results) {
+  return results.reduce(
+    (acc, result) => result.status === "fulfilled" ? { ...acc, fulfilled: [...acc.fulfilled, result] } : { ...acc, rejected: [...acc.rejected, result] },
+    { fulfilled: [], rejected: [] }
   );
 }
-function formatDiffNumber(diff) {
-  const number = Math.abs(diff) === Number.POSITIVE_INFINITY ? "\u221E" : `${Math.abs(diff)}`;
-  const sign = diff < 0 ? "\u2212" : "+";
-  return `${sign}${number}`;
+
+// packages/utils/src/lib/merge-configs.ts
+function mergeConfigs(config, ...configs) {
+  return configs.reduce(
+    (acc, obj) => ({
+      ...acc,
+      ...mergeCategories(acc.categories, obj.categories),
+      ...mergePlugins(acc.plugins, obj.plugins),
+      ...mergePersist(acc.persist, obj.persist),
+      ...mergeUpload(acc.upload, obj.upload)
+    }),
+    config
+  );
 }
-function severityMarker(severity) {
-  if (severity === "error") {
-    return "\u{1F6A8}";
-  }
-  if (severity === "warning") {
-    return "\u26A0\uFE0F";
+function mergeCategories(a, b) {
+  if (!a && !b) {
+    return {};
   }
-  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;
+  const mergedMap = /* @__PURE__ */ new Map();
+  const addToMap = (categories) => {
+    categories.forEach((newObject) => {
+      if (mergedMap.has(newObject.slug)) {
+        const existingObject = mergedMap.get(
+          newObject.slug
+        );
+        mergedMap.set(newObject.slug, {
+          ...existingObject,
+          ...newObject,
+          refs: mergeByUniqueCategoryRefCombination(
+            existingObject?.refs,
+            newObject.refs
+          )
+        });
+      } else {
+        mergedMap.set(newObject.slug, newObject);
       }
-      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");
+    });
+  };
+  if (a) {
+    addToMap(a);
   }
-  const audit = auditPlugin.audits.find(
-    ({ slug: auditSlug }) => auditSlug === slug
-  );
-  if (!audit) {
-    throwIsNotPresentError(`Audit ${slug}`, auditPlugin.slug);
+  if (b) {
+    addToMap(b);
   }
-  return {
-    ...audit,
-    weight,
-    plugin
-  };
+  return { categories: [...mergedMap.values()] };
 }
-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);
+function mergePlugins(a, b) {
+  if (!a && !b) {
+    return { plugins: [] };
   }
-  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
+  const mergedMap = /* @__PURE__ */ new Map();
+  const addToMap = (plugins) => {
+    plugins.forEach((newObject) => {
+      mergedMap.set(newObject.slug, newObject);
+    });
   };
+  if (a) {
+    addToMap(a);
+  }
+  if (b) {
+    addToMap(b);
+  }
+  return { plugins: [...mergedMap.values()] };
 }
-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;
+function mergePersist(a, b) {
+  if (!a && !b) {
+    return {};
   }
-  if (a.score !== b.score) {
-    return a.score - b.score;
+  if (a) {
+    return b ? { persist: { ...a, ...b } } : {};
+  } else {
+    return { persist: b };
+  }
+}
+function mergeByUniqueCategoryRefCombination(a, b) {
+  const map = /* @__PURE__ */ new Map();
+  const addToMap = (refs) => {
+    refs.forEach((ref) => {
+      const uniqueIdentification = `${ref.type}:${ref.plugin}:${ref.slug}`;
+      if (map.has(uniqueIdentification)) {
+        map.set(uniqueIdentification, {
+          ...map.get(uniqueIdentification),
+          ...ref
+        });
+      } else {
+        map.set(uniqueIdentification, ref);
+      }
+    });
+  };
+  if (a) {
+    addToMap(a);
   }
-  if ("value" in a && "value" in b && a.value !== b.value) {
-    return b.value - a.value;
+  if (b) {
+    addToMap(b);
   }
-  return a.title.localeCompare(b.title);
+  return [...map.values()];
 }
-function compareAudits(a, b) {
-  if (a.score !== b.score) {
-    return a.score - b.score;
+function mergeUpload(a, b) {
+  if (!a && !b) {
+    return {};
   }
-  if (a.value !== b.value) {
-    return b.value - a.value;
+  if (a) {
+    return b ? { upload: { ...a, ...b } } : {};
+  } else {
+    return { upload: b };
   }
-  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 = join2(outputDir, `${filename}.${format}`);
-  if (format === "json") {
-    const content = await readJsonFile(filePath);
-    return reportSchema.parse(content);
+
+// packages/utils/src/lib/progress.ts
+import { black, bold as bold2, gray as gray2, green } from "ansis";
+import { MultiProgressBars } from "multi-progress-bars";
+var barStyles = {
+  active: (s) => green(s),
+  done: (s) => gray2(s),
+  idle: (s) => gray2(s)
+};
+var messageStyles = {
+  active: (s) => black(s),
+  done: (s) => bold2.green(s),
+  idle: (s) => gray2(s)
+};
+var mpb;
+function getSingletonProgressBars(options) {
+  if (!mpb) {
+    mpb = new MultiProgressBars({
+      progressWidth: TERMINAL_WIDTH,
+      initMessage: "",
+      border: true,
+      ...options
+    });
   }
-  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;
+  return mpb;
 }
-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 getProgressBar(taskName) {
+  const tasks = getSingletonProgressBars();
+  tasks.addTask(taskName, {
+    type: "percentage",
+    percentage: 0,
+    message: "",
+    barTransformFn: barStyles.idle
+  });
+  return {
+    incrementInSteps: (numPlugins) => {
+      tasks.incrementTask(taskName, {
+        percentage: 1 / numPlugins,
+        barTransformFn: barStyles.active
+      });
+    },
+    updateTitle: (title) => {
+      tasks.updateTask(taskName, {
+        message: title,
+        barTransformFn: barStyles.active
+      });
+    },
+    endProgress: (message = "") => {
+      tasks.done(taskName, {
+        message: messageStyles.done(message),
+        barTransformFn: barStyles.done
+      });
+    }
+  };
 }
 
-// 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);
-      }
-    });
-  });
+// packages/utils/src/lib/reports/flatten-plugins.ts
+function listGroupsFromAllPlugins(report) {
+  return report.plugins.flatMap(
+    (plugin) => plugin.groups?.map((group) => ({ plugin, group })) ?? []
+  );
+}
+function listAuditsFromAllPlugins(report) {
+  return report.plugins.flatMap(
+    (plugin) => plugin.audits.map((audit) => ({ plugin, audit }))
+  );
 }
 
-// packages/utils/src/lib/filter.ts
-function filterItemRefsBy(items, refFilterFn) {
-  return items.map((item) => ({
-    ...item,
-    refs: item.refs.filter(refFilterFn)
-  })).filter((item) => item.refs.length);
+// 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 NEW_LINE = "\n";
+var TAB = "  ";
+var SPACE = " ";
+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/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 as join3, relative } from "node:path";
-import { simpleGit } from "simple-git";
-function getGitRoot(git = simpleGit()) {
-  return git.revparse("--show-toplevel");
+// packages/utils/src/lib/text-formats/html/font-style.ts
+var boldElement = "b";
+function bold3(text) {
+  return `<${boldElement}>${text}</${boldElement}>`;
 }
-function formatGitPath(path, gitRoot) {
-  const absolutePath = isAbsolute(path) ? path : join3(process.cwd(), path);
-  const relativePath = relative(gitRoot, absolutePath);
-  return toUnixPath(relativePath);
+var italicElement = "i";
+function italic(text) {
+  return `<${italicElement}>${text}</${italicElement}>`;
 }
-async function toGitPath(path, git = simpleGit()) {
-  const gitRoot = await getGitRoot(git);
-  return formatGitPath(path, gitRoot);
+var codeElement = "code";
+function code(text) {
+  return `<${codeElement}>${text}</${codeElement}>`;
 }
-var GitStatusError = class _GitStatusError extends Error {
-  static ignoredProps = /* @__PURE__ */ new Set(["current", "tracking"]);
-  static getReducedStatus(status) {
-    return Object.fromEntries(
-      Object.entries(status).filter(([key]) => !this.ignoredProps.has(key)).filter(
-        (entry) => {
-          const value = entry[1];
-          if (value == null) {
-            return false;
-          }
-          if (Array.isArray(value) && value.length === 0) {
-            return false;
-          }
-          if (typeof value === "number" && value === 0) {
-            return false;
-          }
-          return !(typeof value === "boolean" && !value);
-        }
-      )
+
+// packages/utils/src/lib/text-formats/html/link.ts
+function link2(href, text) {
+  return `<a href="${href}">${text || href}</a>`;
+}
+
+// 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"
     );
   }
-  constructor(status) {
-    super(
-      `Working directory needs to be clean before we you can proceed. Commit your local changes or stash them: 
- ${JSON.stringify(
-        _GitStatusError.getReducedStatus(status),
-        null,
-        2
-      )}`
+  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])
     );
-  }
-};
-async function guardAgainstLocalChanges(git = simpleGit()) {
-  const status = await git.status(["-s"]);
-  if (status.files.length > 0) {
-    throw new GitStatusError(status);
-  }
+  });
 }
-async function safeCheckout(branchOrHash, forceCleanStatus = false, git = simpleGit()) {
-  if (forceCleanStatus) {
-    await git.raw(["reset", "--hard"]);
-    await git.clean(["f", "d"]);
-    ui().logger.info(`git status cleaned`);
+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.");
   }
-  await guardAgainstLocalChanges(git);
-  await git.checkout(branchOrHash);
-}
-
-// packages/utils/src/lib/git/git.commits-and-tags.ts
-import { simpleGit as simpleGit2 } from "simple-git";
-
-// packages/utils/src/lib/semver.ts
-import { rcompare, valid } from "semver";
-function normalizeSemver(semverString) {
-  if (semverString.startsWith("v") || semverString.startsWith("V")) {
-    return semverString.slice(1);
+  if (columns.length === 0) {
+    if (Array.isArray(firstRow)) {
+      return firstRow.map((_, idx) => String(idx));
+    }
+    return Object.keys(firstRow);
   }
-  if (semverString.includes("@")) {
-    return semverString.split("@").at(-1) ?? "";
+  if (typeof columns.at(0) === "string") {
+    return columns.map(String);
   }
-  return semverString;
-}
-function isSemver(semverString = "") {
-  return valid(normalizeSemver(semverString)) != null;
-}
-function sortSemvers(semverStrings) {
-  return semverStrings.map(normalizeSemver).filter(isSemver).sort(rcompare);
+  const cols = columns;
+  return cols.map(({ label, key }) => label ?? capitalize(key));
 }
-
-// packages/utils/src/lib/git/git.commits-and-tags.ts
-async function getLatestCommit(git = simpleGit2()) {
-  const log2 = await git.log({
-    maxCount: 1,
-    // git log -1 --pretty=format:"%H %s %an %aI" - See: https://git-scm.com/docs/pretty-formats
-    format: { hash: "%H", message: "%s", author: "%an", date: "%aI" }
-  });
-  return commitSchema.parse(log2.latest);
+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";
+  }
 }
-async function getCurrentBranchOrTag(git = simpleGit2()) {
-  return await git.branch().then((r) => r.current) || // If no current branch, try to get the tag
-  // @TODO use simple git
-  await git.raw(["describe", "--tags", "--exact-match"]).then((out) => out.trim());
+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 validateFilter({ from, to }) {
-  if (to && !from) {
-    throw new Error(
-      `filter needs the "from" option defined to accept the "to" option.
-`
+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)
     );
   }
-}
-function filterLogs(allTags, opt) {
-  if (!opt) {
-    return allTags;
+  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
+      )
+    );
   }
-  validateFilter(opt);
-  const { from, to, maxCount } = opt;
-  const finIndex = (tagName, fallback) => {
-    const idx = allTags.indexOf(tagName ?? "");
-    if (idx > -1) {
-      return idx;
-    }
-    return fallback;
-  };
-  const fromIndex = finIndex(from, 0);
-  const toIndex = finIndex(to, void 0);
-  return allTags.slice(fromIndex, toIndex ? toIndex + 1 : toIndex).slice(0, maxCount ?? void 0);
+  return Object.keys(biggestRow ?? {}).map((_) => "center");
 }
-async function getHashFromTag(tag, git = simpleGit2()) {
-  const tagDetails = await git.show(["--no-patch", "--format=%H", tag]);
-  const hash = tagDetails.trim();
-  return {
-    hash: hash.split("\n").at(-1) ?? "",
-    message: tag
-  };
+
+// packages/utils/src/lib/text-formats/html/table.ts
+function wrap(elem, content) {
+  return `<${elem}>${content}</${elem}>${NEW_LINE}`;
 }
-async function getSemverTags(opt = {}, git = simpleGit2()) {
-  validateFilter(opt);
-  const { targetBranch, ...options } = opt;
-  let currentBranch;
-  if (targetBranch) {
-    currentBranch = await getCurrentBranchOrTag(git);
-    await git.checkout(targetBranch);
+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 tagsRaw = await git.tag([
-    "--merged",
-    targetBranch ?? await getCurrentBranchOrTag(git)
-  ]);
-  const allTags = tagsRaw.split(/\n/).map((tag) => tag.trim()).filter(Boolean).filter(isSemver);
-  const relevantTags = filterLogs(allTags, options);
-  const tagsWithHashes = await Promise.all(
-    relevantTags.map((tag) => getHashFromTag(tag, git))
+  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/index.ts
+var html = {
+  bold: bold3,
+  italic,
+  code,
+  link: link2,
+  details,
+  table
+};
+
+// packages/utils/src/lib/reports/formatting.ts
+import { MarkdownDocument, md as md2 } from "build-md";
+function tableSection(tableData, options) {
+  if (tableData.rows.length === 0) {
+    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
   );
-  if (currentBranch) {
-    await git.checkout(currentBranch);
-  }
-  return tagsWithHashes;
 }
-async function getHashes(options = {}, git = simpleGit2()) {
-  const { targetBranch, from, to, maxCount, ...opt } = options;
-  validateFilter({ from, to });
-  let currentBranch;
-  if (targetBranch) {
-    currentBranch = await getCurrentBranchOrTag(git);
-    await git.checkout(targetBranch);
+function metaDescription(audit) {
+  const docsUrl = audit.docsUrl;
+  const description = audit.description?.trim();
+  if (docsUrl) {
+    const docsLink = md2.link(docsUrl, "\u{1F4D6} Docs");
+    if (!description) {
+      return docsLink;
+    }
+    const parsedDescription = description.endsWith("```") ? `${description}
+
+` : `${description} `;
+    return md2`${parsedDescription}${docsLink}`;
   }
-  const logs = await git.log({
-    ...opt,
-    format: {
-      hash: "%H",
-      message: "%s"
-    },
-    from,
-    to,
-    maxCount
-  });
-  if (targetBranch) {
-    await git.checkout(currentBranch);
+  if (description && description.trim().length > 0) {
+    return description;
   }
-  return [...logs.all];
+  return "";
 }
 
-// packages/utils/src/lib/group-by-status.ts
-function groupByStatus(results) {
-  return results.reduce(
-    (acc, result) => result.status === "fulfilled" ? { ...acc, fulfilled: [...acc.fulfilled, result] } : { ...acc, rejected: [...acc.rejected, result] },
-    { fulfilled: [], rejected: [] }
+// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
+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");
+  }
+  const audit = auditPlugin.audits.find(
+    ({ slug: auditSlug }) => auditSlug === slug
   );
+  if (!audit) {
+    throwIsNotPresentError(`Audit ${slug}`, auditPlugin.slug);
+  }
+  return {
+    ...audit,
+    weight,
+    plugin
+  };
 }
-
-// packages/utils/src/lib/progress.ts
-import chalk3 from "chalk";
-import { MultiProgressBars } from "multi-progress-bars";
-var barStyles = {
-  active: (s) => chalk3.green(s),
-  done: (s) => chalk3.gray(s),
-  idle: (s) => chalk3.gray(s)
-};
-var messageStyles = {
-  active: (s) => chalk3.black(s),
-  done: (s) => chalk3.green(chalk3.bold(s)),
-  idle: (s) => chalk3.gray(s)
-};
-var mpb;
-function getSingletonProgressBars(options) {
-  if (!mpb) {
-    mpb = new MultiProgressBars({
-      progressWidth: TERMINAL_WIDTH,
-      initMessage: "",
-      border: true,
-      ...options
-    });
+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");
   }
-  return mpb;
+  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 getProgressBar(taskName) {
-  const tasks = getSingletonProgressBars();
-  tasks.addTask(taskName, {
-    type: "percentage",
-    percentage: 0,
-    message: "",
-    barTransformFn: barStyles.idle
+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 {
-    incrementInSteps: (numPlugins) => {
-      tasks.incrementTask(taskName, {
-        percentage: 1 / numPlugins,
-        barTransformFn: barStyles.active
-      });
-    },
-    updateTitle: (title) => {
-      tasks.updateTask(taskName, {
-        message: title,
-        barTransformFn: barStyles.active
-      });
-    },
-    endProgress: (message = "") => {
-      tasks.done(taskName, {
-        message: messageStyles.done(message),
-        barTransformFn: barStyles.done
-      });
-    }
+    ...report,
+    categories: sortedCategories,
+    plugins: sortPlugins(plugins)
   };
 }
-
-// packages/utils/src/lib/reports/flatten-plugins.ts
-function listGroupsFromAllPlugins(report) {
-  return report.plugins.flatMap(
-    (plugin) => plugin.groups?.map((group) => ({ plugin, group })) ?? []
-  );
-}
-function listAuditsFromAllPlugins(report) {
-  return report.plugins.flatMap(
-    (plugin) => plugin.audits.map((audit) => ({ plugin, audit }))
-  );
-}
-
-// packages/utils/src/lib/reports/formatting.ts
-var { headline: headline2, lines: lines2, link: link4, section: section2, table: table3 } = 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)
-  );
-}
-function metaDescription({
-  docsUrl,
-  description
-}) {
-  if (docsUrl) {
-    const docsLink = link4(docsUrl, "\u{1F4D6} Docs");
-    if (!description) {
-      return section2(docsLink);
-    }
-    const parsedDescription = description.toString().endsWith("```") ? `${description}${NEW_LINE + NEW_LINE}` : `${description}${SPACE}`;
-    return section2(`${parsedDescription}${docsLink}`);
-  }
-  if (description && description.trim().length > 0) {
-    return section2(description);
-  }
-  return "";
+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
-var { link: link5, 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: link5(`#${slugify(title)}`, title),
-        score: `${scoreMarker(score)}${SPACE}${boldMd2(
-          formatReportScore(score)
-        )}`,
-        audits: countCategoryAudits(refs, plugins).toString()
-      }))
-    };
-    return tableSection(tableContent);
-  }
-  return "";
+  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;
-  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
-    );
-  });
-  return lines3(h22(CATEGORIES_TITLE), ...categoryDetails);
+  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 = link5(
+  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 = link5(
-        `#${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: link6, 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}${link6(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 = "", duration }) => [
+      title,
+      audits.length.toString(),
+      version && md4.code(version),
+      formatDuration(duration)
+    ])
+  ];
 }
-function reportMetaData({
+function reportMetaTable({
   commit,
   version,
   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(version || ""),
-        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(version),
+        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: link7,
-  bold: boldMd3,
-  italic: italicMd,
-  table: table4,
-  section: section5
-} = md;
-var { details: details3 } = html;
+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) {
+function generateMdReportsDiff(diff, portalUrl) {
+  return new MarkdownDocument4().$concat(
+    createDiffHeaderSection(diff, portalUrl),
+    createDiffCategoriesSection(diff),
+    createDiffGroupsSection(diff),
+    createDiffAuditsSection(diff)
+  ).toString();
+}
+function createDiffHeaderSection(diff, portalUrl) {
   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(
+    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: `\u{1F610} Code PushUp report is ${boldMd3("unchanged")}`
+    unchanged: md5`😐 Code PushUp report is ${md5.bold("unchanged")}`
   };
   const outcome = mergeDiffOutcomes(
     changesToDiffOutcomes([
@@ -2267,143 +2270,127 @@ function formatDiffHeaderSection(diff) {
     ])
   );
   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]}.`
+  return new MarkdownDocument4().heading(HIERARCHY.level_1, "Code PushUp").paragraph(
+    diff.commits ? md5`${outcomeTexts[outcome]} – ${styleCommits(diff.commits)}.` : outcomeTexts[outcome]
+  ).paragraph(
+    portalUrl && md5.link(portalUrl, "\u{1F575}\uFE0F See full comparison in Code PushUp portal \u{1F50D}")
   );
 }
-function formatDiffCategoriesSection(diff) {
+function createDiffCategoriesSection(diff) {
   const { changed, unchanged, added } = diff.categories;
   const categoriesCount = changed.length + unchanged.length + added.length;
   const hasChanges = unchanged.length < categoriesCount;
   if (categoriesCount === 0) {
-    return "";
+    return null;
   }
   const columns = [
-    { key: "category", label: "\u{1F3F7}\uFE0F Category", align: "left" },
-    { key: "before", label: "\u2B50 Previous score" },
-    { key: "after", label: hasChanges ? "\u2B50 Current score" : "\u2B50 Score" },
-    { key: "change", label: "\u{1F504} Score change" }
+    { 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" }
   ];
-  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, after: row.after }
-      )
-    }),
-    added.length > 0 && section5(italicMd("(\\*) New category."))
-  );
+  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),
+      md5.italic("n/a (\\*)"),
+      formatScoreWithColor(category.score),
+      md5.italic("n/a (\\*)")
+    ]),
+    ...unchanged.map((category) => [
+      formatTitle(category),
+      formatScoreWithColor(category.score, { skipBold: true }),
+      formatScoreWithColor(category.score),
+      "\u2013"
+    ])
+  ];
+  return new MarkdownDocument4().heading(HIERARCHY.level_2, "\u{1F3F7}\uFE0F Categories").table(
+    hasChanges ? columns : columns.slice(0, 2),
+    rows.map((row) => hasChanges ? row : row.slice(0, 2))
+  ).paragraph(added.length > 0 && md5.italic("(\\*) New category."));
 }
-function formatDiffGroupsSection(diff) {
+function createDiffGroupsSection(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" }
+    return null;
+  }
+  return new MarkdownDocument4().heading(HIERARCHY.level_2, "\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" }
       ],
-      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)
-      }))
-    })
+      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 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" }
+function createDiffAuditsSection(diff) {
+  return new MarkdownDocument4().heading(HIERARCHY.level_2, "\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" }
       ],
-      rows: sortChanges(diff.audits.changed).map((audit) => ({
-        plugin: formatTitle(audit.plugin),
-        audit: formatTitle(audit),
-        after: `${scoreMarker(audit.scores.after, "square")} ${boldMd3(
+      sortChanges(diff.audits.changed).map((audit) => [
+        formatTitle(audit.plugin),
+        formatTitle(audit),
+        `${scoreMarker(audit.scores.before, "square")} ${audit.displayValues.before || audit.values.before.toString()}`,
+        md5`${scoreMarker(audit.scores.after, "square")} ${md5.bold(
           audit.displayValues.after || audit.values.after.toString()
         )}`,
-        before: `${scoreMarker(audit.scores.before, "square")} ${audit.displayValues.before || audit.values.before.toString()}`,
-        change: formatValueChange(audit)
-      }))
-    })
+        formatValueChange(audit)
+      ])
+    )
   );
 }
-function formatGroupsOrAuditsDetails(token, { changed, unchanged }, tableData) {
-  return changed.length === 0 ? summarizeUnchanged(token, { changed, unchanged }) : details3(
+function createGroupsOrAuditsDetails(token, { changed, unchanged }, ...[columns, rows]) {
+  if (changed.length === 0) {
+    return new MarkdownDocument4().paragraph(
+      summarizeUnchanged(token, { changed, unchanged })
+    );
+  }
+  return new MarkdownDocument4().details(
     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(
+    md5`${md5.table(columns, rows.slice(0, MAX_ROWS))}${changed.length > MAX_ROWS ? md5.paragraph(
+      md5.italic(
         `Only the ${MAX_ROWS} most affected ${pluralize(
           token
         )} are listed above for brevity.`
-      ),
-      unchanged.length > 0 && summarizeUnchanged(token, { changed, unchanged })
-    )
+      )
+    ) : ""}${unchanged.length > 0 ? md5.paragraph(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(" ")
-  );
+  return [
+    changed.length > 0 ? pluralizeToken(`other ${token}`, unchanged.length) : `All of ${pluralizeToken(token, unchanged.length)}`,
+    unchanged.length === 1 ? "is" : "are",
+    "unchanged."
+  ].join(" ");
 }
 function summarizeDiffOutcomes(outcomes, token) {
   return objectToEntries(countDiffOutcomes(outcomes)).filter(
@@ -2428,7 +2415,7 @@ function formatTitle({
   docsUrl
 }) {
   if (docsUrl) {
-    return link7(docsUrl, title);
+    return md5.link(docsUrl, title);
   }
   return title;
 }
@@ -2472,8 +2459,22 @@ function countDiffOutcomes(outcomes) {
   };
 }
 
+// packages/utils/src/lib/reports/load-report.ts
+import { join as join3 } from "node:path";
+async function loadReport(options) {
+  const { outputDir, filename, format } = options;
+  await ensureDirectoryExists(outputDir);
+  const filePath = join3(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);
 }
@@ -2490,14 +2491,14 @@ function logStdoutSummary(report) {
 }
 function reportToHeaderSection(report) {
   const { packageName, version } = report;
-  return `${chalk4.bold(reportHeadlineText)} - ${packageName}@${version}`;
+  return `${bold4(REPORT_HEADLINE_TEXT)} - ${packageName}@${version}`;
 }
 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([
@@ -2512,7 +2513,7 @@ function logPlugins(report) {
           padding: [0, 3, 0, 0]
         },
         {
-          text: chalk4.cyanBright(audit.displayValue || `${audit.value}`),
+          text: cyanBright(audit.displayValue || `${audit.value}`),
           width: 10,
           padding: [0, 0, 0, 0]
         }
@@ -2523,42 +2524,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
@@ -2648,56 +2645,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) => {
@@ -2720,13 +2667,13 @@ var verboseUtils = (verbose = false) => ({
 export {
   CODE_PUSHUP_DOMAIN,
   FOOTER_PREFIX,
+  HIERARCHY,
   NEW_LINE,
   ProcessError,
   README_LINK,
   SPACE,
   TAB,
   TERMINAL_WIDTH,
-  apostrophize,
   calcDuration,
   capitalize,
   compareIssueSeverity,
@@ -2771,7 +2718,7 @@ export {
   logMultipleResults,
   logStdoutSummary,
   matchArrayItemsByKey,
-  md,
+  mergeConfigs,
   normalizeSemver,
   objectFromEntries,
   objectToCliArgs,