@code-pushup/cli 0.35.0 → 0.42.0

package/index.js

@@ -6,9 +6,6 @@ import { hideBin } from "yargs/helpers";
 // packages/cli/src/lib/autorun/autorun-command.ts
 import chalk7 from "chalk";
 
-// packages/models/src/lib/audit.ts
-import { z as z2 } from "zod";
-
 // packages/models/src/lib/implementation/schemas.ts
 import { MATERIAL_ICONS } from "vscode-material-icons";
 import { z } from "zod";
@@ -74,6 +71,7 @@ function missingRefsForCategoriesErrorMsg(categories, plugins) {
 }
 
 // packages/models/src/lib/implementation/schemas.ts
+var primitiveValueSchema = z.union([z.string(), z.number()]);
 function executionMetaSchema(options2 = {
   descriptionDate: "Execution start date and time",
   descriptionDuration: "Execution duration in ms"
@@ -165,6 +163,7 @@ function hasNonZeroWeightedRef(refs) {
 }
 
 // packages/models/src/lib/audit.ts
+import { z as z2 } from "zod";
 var auditSchema = z2.object({
   slug: slugSchema.describe("ID (unique within plugin)")
 }).merge(
@@ -194,7 +193,7 @@ function getDuplicateSlugsInAudits(audits) {
 }
 
 // packages/models/src/lib/audit-output.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // packages/models/src/lib/issue.ts
 import { z as z3 } from "zod";
@@ -225,16 +224,61 @@ var issueSchema = z3.object(
   { description: "Issue information" }
 );
 
+// packages/models/src/lib/table.ts
+import { z as z4 } from "zod";
+var tableAlignmentSchema = z4.enum(["left", "center", "right"], {
+  description: "Cell alignment"
+});
+var tableColumnObjectSchema = z4.object({
+  key: z4.string(),
+  label: z4.string().optional(),
+  align: tableAlignmentSchema.optional()
+});
+var tableRowObjectSchema = z4.record(primitiveValueSchema, {
+  description: "Object row"
+});
+var tableRowPrimitiveSchema = z4.array(primitiveValueSchema, {
+  description: "Primitive row"
+});
+var tableSharedSchema = z4.object({
+  title: z4.string().optional().describe("Display title for table")
+});
+var tablePrimitiveSchema = tableSharedSchema.merge(
+  z4.object(
+    {
+      columns: z4.array(tableAlignmentSchema).optional(),
+      rows: z4.array(tableRowPrimitiveSchema)
+    },
+    { description: "Table with primitive rows and optional alignment columns" }
+  )
+);
+var tableObjectSchema = tableSharedSchema.merge(
+  z4.object(
+    {
+      columns: z4.union([
+        z4.array(tableAlignmentSchema),
+        z4.array(tableColumnObjectSchema)
+      ]).optional(),
+      rows: z4.array(tableRowObjectSchema)
+    },
+    {
+      description: "Table with object rows and optional alignment or object columns"
+    }
+  )
+);
+var tableSchema = (description = "Table information") => z4.union([tablePrimitiveSchema, tableObjectSchema], { description });
+
 // packages/models/src/lib/audit-output.ts
 var auditValueSchema = nonnegativeIntSchema.describe("Raw numeric value");
-var auditDisplayValueSchema = z4.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
-var auditDetailsSchema = z4.object(
+var auditDisplayValueSchema = z5.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
+var auditDetailsSchema = z5.object(
   {
-    issues: z4.array(issueSchema, { description: "List of findings" })
+    issues: z5.array(issueSchema, { description: "List of findings" }).optional(),
+    table: tableSchema("Table of related findings").optional()
   },
   { description: "Detailed information" }
 );
-var auditOutputSchema = z4.object(
+var auditOutputSchema = z5.object(
   {
     slug: slugSchema.describe("Reference to audit"),
     displayValue: auditDisplayValueSchema,
@@ -244,7 +288,7 @@ var auditOutputSchema = z4.object(
   },
   { description: "Audit information" }
 );
-var auditOutputsSchema = z4.array(auditOutputSchema, {
+var auditOutputsSchema = z5.array(auditOutputSchema, {
   description: "List of JSON formatted audit output emitted by the runner process of a plugin"
 }).refine(
   (audits) => !getDuplicateSlugsInAudits2(audits),
@@ -261,13 +305,13 @@ function getDuplicateSlugsInAudits2(audits) {
 }
 
 // packages/models/src/lib/category-config.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var categoryRefSchema = weightedRefSchema(
   "Weighted references to audits and/or groups for the category",
   "Slug of an audit or group (depending on `type`)"
 ).merge(
-  z5.object({
-    type: z5.enum(["audit", "group"], {
+  z6.object({
+    type: z6.enum(["audit", "group"], {
       description: "Discriminant for reference kind, affects where `slug` is looked up"
     }),
     plugin: slugSchema.describe(
@@ -288,8 +332,8 @@ var categoryConfigSchema = scorableSchema(
     description: "Meta info for category"
   })
 ).merge(
-  z5.object({
-    isBinary: z5.boolean({
+  z6.object({
+    isBinary: z6.boolean({
       description: 'Is this a binary category (i.e. only a perfect score considered a "pass")?'
     }).optional()
   })
@@ -305,7 +349,7 @@ function getDuplicateRefsInCategoryMetrics(metrics) {
     metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`)
   );
 }
-var categoriesSchema = z5.array(categoryConfigSchema, {
+var categoriesSchema = z6.array(categoryConfigSchema, {
   description: "Categorization of individual audits"
 }).refine(
   (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
@@ -324,18 +368,18 @@ function getDuplicateSlugCategories(categories) {
 }
 
 // packages/models/src/lib/commit.ts
-import { z as z6 } from "zod";
-var commitSchema = z6.object(
+import { z as z7 } from "zod";
+var commitSchema = z7.object(
   {
-    hash: z6.string({ description: "Commit SHA (full)" }).regex(
+    hash: z7.string({ description: "Commit SHA (full)" }).regex(
       /^[\da-f]{40}$/,
       "Commit SHA should be a 40-character hexadecimal string"
     ),
-    message: z6.string({ description: "Commit message" }),
-    date: z6.coerce.date({
+    message: z7.string({ description: "Commit message" }),
+    date: z7.coerce.date({
       description: "Date and time when commit was authored"
     }),
-    author: z6.string({
+    author: z7.string({
       description: "Commit author name"
     }).trim()
   },
@@ -343,22 +387,22 @@ var commitSchema = z6.object(
 );
 
 // packages/models/src/lib/core-config.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // packages/models/src/lib/persist-config.ts
-import { z as z7 } from "zod";
-var formatSchema = z7.enum(["json", "md"]);
-var persistConfigSchema = z7.object({
+import { z as z8 } from "zod";
+var formatSchema = z8.enum(["json", "md"]);
+var persistConfigSchema = z8.object({
   outputDir: filePathSchema.describe("Artifacts folder").optional(),
   filename: fileNameSchema.describe("Artifacts file name (without extension)").optional(),
-  format: z7.array(formatSchema).optional()
+  format: z8.array(formatSchema).optional()
 });
 
 // packages/models/src/lib/plugin-config.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // packages/models/src/lib/group.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var groupRefSchema = weightedRefSchema(
   "Weighted reference to a group",
   "Reference slug to a group within this plugin (e.g. 'max-lines')"
@@ -375,7 +419,7 @@ var groupSchema = scorableSchema(
   getDuplicateRefsInGroups,
   duplicateRefsInGroupsErrorMsg
 ).merge(groupMetaSchema);
-var groupsSchema = z8.array(groupSchema, {
+var groupsSchema = z9.array(groupSchema, {
   description: "List of groups"
 }).optional().refine(
   (groups2) => !getDuplicateSlugsInGroups(groups2),
@@ -403,14 +447,14 @@ function getDuplicateSlugsInGroups(groups2) {
 }
 
 // packages/models/src/lib/runner-config.ts
-import { z as z9 } from "zod";
-var outputTransformSchema = z9.function().args(z9.unknown()).returns(z9.union([auditOutputsSchema, z9.promise(auditOutputsSchema)]));
-var runnerConfigSchema = z9.object(
+import { z as z10 } from "zod";
+var outputTransformSchema = z10.function().args(z10.unknown()).returns(z10.union([auditOutputsSchema, z10.promise(auditOutputsSchema)]));
+var runnerConfigSchema = z10.object(
   {
-    command: z9.string({
+    command: z10.string({
       description: "Shell command to execute"
     }),
-    args: z9.array(z9.string({ description: "Command arguments" })).optional(),
+    args: z10.array(z10.string({ description: "Command arguments" })).optional(),
     outputFile: filePathSchema.describe("Output path"),
     outputTransform: outputTransformSchema.optional()
   },
@@ -418,8 +462,8 @@ var runnerConfigSchema = z9.object(
     description: "How to execute runner"
   }
 );
-var onProgressSchema = z9.function().args(z9.unknown()).returns(z9.void());
-var runnerFunctionSchema = z9.function().args(onProgressSchema.optional()).returns(z9.union([auditOutputsSchema, z9.promise(auditOutputsSchema)]));
+var onProgressSchema = z10.function().args(z10.unknown()).returns(z10.void());
+var runnerFunctionSchema = z10.function().args(onProgressSchema.optional()).returns(z10.union([auditOutputsSchema, z10.promise(auditOutputsSchema)]));
 
 // packages/models/src/lib/plugin-config.ts
 var pluginMetaSchema = packageVersionSchema().merge(
@@ -430,13 +474,13 @@ var pluginMetaSchema = packageVersionSchema().merge(
     description: "Plugin metadata"
   })
 ).merge(
-  z10.object({
+  z11.object({
     slug: slugSchema.describe("Unique plugin slug within core config"),
     icon: materialIconSchema
   })
 );
-var pluginDataSchema = z10.object({
-  runner: z10.union([runnerConfigSchema, runnerFunctionSchema]),
+var pluginDataSchema = z11.object({
+  runner: z11.union([runnerConfigSchema, runnerFunctionSchema]),
   audits: pluginAuditsSchema,
   groups: groupsSchema
 });
@@ -462,22 +506,22 @@ function getMissingRefsFromGroups(pluginCfg) {
 }
 
 // packages/models/src/lib/upload-config.ts
-import { z as z11 } from "zod";
-var uploadConfigSchema = z11.object({
+import { z as z12 } from "zod";
+var uploadConfigSchema = z12.object({
   server: urlSchema.describe("URL of deployed portal API"),
-  apiKey: z11.string({
+  apiKey: z12.string({
     description: "API key with write access to portal (use `process.env` for security)"
   }),
   organization: slugSchema.describe(
     "Organization slug from Code PushUp portal"
   ),
   project: slugSchema.describe("Project slug from Code PushUp portal"),
-  timeout: z11.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
+  timeout: z12.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
 });
 
 // packages/models/src/lib/core-config.ts
-var unrefinedCoreConfigSchema = z12.object({
-  plugins: z12.array(pluginConfigSchema, {
+var unrefinedCoreConfigSchema = z13.object({
+  plugins: z13.array(pluginConfigSchema, {
     description: "List of plugins to be used (official, community-provided, or custom)"
   }).min(1),
   /** portal configuration for persisting results */
@@ -509,7 +553,7 @@ var DEFAULT_PERSIST_FILENAME = "report";
 var DEFAULT_PERSIST_FORMAT = ["json", "md"];
 
 // packages/models/src/lib/report.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var auditReportSchema = auditSchema.merge(auditOutputSchema);
 var pluginReportSchema = pluginMetaSchema.merge(
   executionMetaSchema({
@@ -517,9 +561,9 @@ var pluginReportSchema = pluginMetaSchema.merge(
     descriptionDuration: "Duration of the plugin run in ms"
   })
 ).merge(
-  z13.object({
-    audits: z13.array(auditReportSchema).min(1),
-    groups: z13.array(groupSchema).optional()
+  z14.object({
+    audits: z14.array(auditReportSchema).min(1),
+    groups: z14.array(groupSchema).optional()
   })
 ).refine(
   (pluginReport) => !getMissingRefsFromGroups2(pluginReport.audits, pluginReport.groups ?? []),
@@ -553,10 +597,10 @@ var reportSchema = packageVersionSchema({
     descriptionDuration: "Duration of the collect run in ms"
   })
 ).merge(
-  z13.object(
+  z14.object(
     {
-      categories: z13.array(categoryConfigSchema),
-      plugins: z13.array(pluginReportSchema).min(1),
+      categories: z14.array(categoryConfigSchema),
+      plugins: z14.array(pluginReportSchema).min(1),
       commit: commitSchema.describe("Git commit for which report was collected").nullable()
     },
     { description: "Collect output data" }
@@ -572,36 +616,40 @@ var reportSchema = packageVersionSchema({
 );
 
 // packages/models/src/lib/reports-diff.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function makeComparisonSchema(schema) {
   const sharedDescription = schema.description || "Result";
-  return z14.object({
+  return z15.object({
     before: schema.describe(`${sharedDescription} (source commit)`),
     after: schema.describe(`${sharedDescription} (target commit)`)
   });
 }
 function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
-  return z14.object(
+  return z15.object(
     {
-      changed: z14.array(diffSchema),
-      unchanged: z14.array(resultSchema),
-      added: z14.array(resultSchema),
-      removed: z14.array(resultSchema)
+      changed: z15.array(diffSchema),
+      unchanged: z15.array(resultSchema),
+      added: z15.array(resultSchema),
+      removed: z15.array(resultSchema)
     },
     { description }
   );
 }
-var scorableMetaSchema = z14.object({ slug: slugSchema, title: titleSchema });
+var scorableMetaSchema = z15.object({
+  slug: slugSchema,
+  title: titleSchema,
+  docsUrl: docsUrlSchema
+});
 var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
-  z14.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true }).describe("Plugin which defines it")
+  z15.object({
+    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
   })
 );
 var scorableDiffSchema = scorableMetaSchema.merge(
-  z14.object({
+  z15.object({
     scores: makeComparisonSchema(scoreSchema).merge(
-      z14.object({
-        diff: z14.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
+      z15.object({
+        diff: z15.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
       })
     ).describe("Score comparison")
   })
@@ -612,10 +660,10 @@ var scorableWithPluginDiffSchema = scorableDiffSchema.merge(
 var categoryDiffSchema = scorableDiffSchema;
 var groupDiffSchema = scorableWithPluginDiffSchema;
 var auditDiffSchema = scorableWithPluginDiffSchema.merge(
-  z14.object({
+  z15.object({
     values: makeComparisonSchema(auditValueSchema).merge(
-      z14.object({
-        diff: z14.number().int().describe("Value change (`values.after - values.before`)")
+      z15.object({
+        diff: z15.number().int().describe("Value change (`values.after - values.before`)")
       })
     ).describe("Audit `value` comparison"),
     displayValues: makeComparisonSchema(auditDisplayValueSchema).describe(
@@ -624,15 +672,15 @@ var auditDiffSchema = scorableWithPluginDiffSchema.merge(
   })
 );
 var categoryResultSchema = scorableMetaSchema.merge(
-  z14.object({ score: scoreSchema })
+  z15.object({ score: scoreSchema })
 );
 var groupResultSchema = scorableWithPluginMetaSchema.merge(
-  z14.object({ score: scoreSchema })
+  z15.object({ score: scoreSchema })
 );
 var auditResultSchema = scorableWithPluginMetaSchema.merge(
   auditOutputSchema.pick({ score: true, value: true, displayValue: true })
 );
-var reportsDiffSchema = z14.object({
+var reportsDiffSchema = z15.object({
   commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
   categories: makeArraysComparisonSchema(
     categoryDiffSchema,
@@ -661,6 +709,291 @@ var reportsDiffSchema = z14.object({
   })
 );
 
+// 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/text-formats/html/link.ts
+function link(href, text) {
+  return `<a href="${href}">${text || href}"</a>`;
+}
+
+// packages/utils/src/lib/transform.ts
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+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/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(String);
+    }
+    return columns.map(
+      ({ key }) => 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({
+  rows,
+  columns = []
+}) {
+  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 firstObject = rows.at(0);
+  return Object.keys(firstObject).map(
+    (key, idx) => getColumnAlignmentForKeyAndIndex(key, idx, columns)
+  );
+}
+
+// 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) {
+  return `${contents.filter(Boolean).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/diff.ts
 function matchArrayItemsByKey({
   before,
@@ -778,40 +1111,48 @@ import chalk from "chalk";
 
 // packages/utils/src/lib/reports/constants.ts
 var TERMINAL_WIDTH = 80;
-var NEW_LINE = "\n";
 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/flowup/quality-metrics-cli#readme";
+var README_LINK = "https://github.com/code-pushup/cli#readme";
 var reportHeadlineText = "Code PushUp Report";
 var reportOverviewTableHeaders = [
-  "\u{1F3F7} Category",
-  "\u2B50 Score",
-  "\u{1F6E1} Audits"
+  {
+    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 reportMetaTableHeaders = [
-  "Commit",
-  "Version",
-  "Duration",
-  "Plugins",
-  "Categories",
-  "Audits"
-];
-var pluginMetaTableHeaders = [
-  "Plugin",
-  "Audits",
-  "Version",
-  "Duration"
-];
-var detailsTableHeaders = [
-  "Severity",
-  "Message",
-  "Source file",
-  "Line(s)"
+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
@@ -837,7 +1178,7 @@ function logListItem(args) {
   singletonisaacUi.rows = [];
   singletonUiInstance?.logger.log(content);
 }
-function link(text) {
+function link3(text) {
   return chalk.underline(chalk.blueBright(text));
 }
 
@@ -904,7 +1245,7 @@ async function ensureDirectoryExists(baseDir) {
     await mkdir(baseDir, { recursive: true });
     return;
   } catch (error) {
-    ui().logger.error(error.message);
+    ui().logger.info(error.message);
     if (error.code !== "EEXIST") {
       throw error;
     }
@@ -940,122 +1281,35 @@ async function importEsmModule(options2) {
   return mod.default;
 }
 
-// packages/utils/src/lib/reports/md/details.ts
-function details(title, content, cfg = { open: false }) {
-  return `<details${cfg.open ? " open" : ""}>
-<summary>${title}</summary>
-
-${content}
-
-</details>
-`;
-}
-
-// packages/utils/src/lib/reports/md/font-style.ts
-var stylesMap = {
-  i: "_",
-  // italic
-  b: "**",
-  // bold
-  s: "~",
-  // strike through
-  c: "`"
-  // code
-};
-function style(text, styles = ["b"]) {
-  return styles.reduce((t, s) => `${stylesMap[s]}${t}${stylesMap[s]}`, text);
-}
-
-// packages/utils/src/lib/reports/md/headline.ts
-function headline(text, hierarchy = 1) {
-  return `${"#".repeat(hierarchy)} ${text}`;
-}
-function h1(text) {
-  return headline(text, 1);
-}
-function h2(text) {
-  return headline(text, 2);
-}
-function h3(text) {
-  return headline(text, 3);
-}
-
-// packages/utils/src/lib/reports/md/image.ts
-function image(src, alt) {
-  return `![${alt}](${src})`;
-}
-
-// packages/utils/src/lib/reports/md/link.ts
-function link2(href, text) {
-  return `[${text || href}](${href})`;
-}
-
-// packages/utils/src/lib/reports/md/list.ts
-function li(text, order = "unordered") {
-  const style2 = order === "unordered" ? "-" : "- [ ]";
-  return `${style2} ${text}`;
-}
-
-// packages/utils/src/lib/reports/md/paragraphs.ts
-function paragraphs(...sections) {
-  return sections.filter(Boolean).join("\n\n");
-}
-
-// packages/utils/src/lib/reports/md/table.ts
-var alignString = /* @__PURE__ */ new Map([
-  ["l", ":--"],
-  ["c", ":--:"],
-  ["r", "--:"]
-]);
-function tableMd(data, align) {
-  if (data.length === 0) {
-    throw new Error("Data can't be empty");
-  }
-  const alignmentSetting = align ?? data[0]?.map(() => "c");
-  const tableContent = data.map((arr) => `|${arr.join("|")}|`);
-  const alignmentRow = `|${alignmentSetting?.map((s) => alignString.get(s)).join("|")}|`;
-  return tableContent[0] + NEW_LINE + alignmentRow + NEW_LINE + tableContent.slice(1).join(NEW_LINE);
-}
-function tableHtml(data) {
-  if (data.length === 0) {
-    throw new Error("Data can't be empty");
-  }
-  const tableContent = data.map((arr, index) => {
-    if (index === 0) {
-      const headerRow = arr.map((s) => `<th>${s}</th>`).join("");
-      return `<tr>${headerRow}</tr>`;
-    }
-    const row = arr.map((s) => `<td>${s}</td>`).join("");
-    return `<tr>${row}</tr>`;
-  });
-  return `<table>${tableContent.join("")}</table>`;
-}
-
 // packages/utils/src/lib/reports/utils.ts
+var { image: image2, bold: boldMd } = md;
 function formatReportScore(score) {
   return Math.round(score * 100).toString();
 }
 function formatScoreWithColor(score, options2) {
-  const styledNumber = options2?.skipBold ? formatReportScore(score) : style(formatReportScore(score));
-  return `${getRoundScoreMarker(score)} ${styledNumber}`;
-}
-function getRoundScoreMarker(score) {
-  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
-    return "\u{1F7E2}";
-  }
-  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
-    return "\u{1F7E1}";
+  const styledNumber = options2?.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}"
   }
-  return "\u{1F534}";
-}
-function getSquaredScoreMarker(score) {
+};
+function scoreMarker(score, markerType = "circle") {
   if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
-    return "\u{1F7E9}";
+    return MARKERS[markerType].green;
   }
   if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
-    return "\u{1F7E8}";
+    return MARKERS[markerType].yellow;
   }
-  return "\u{1F7E5}";
+  return MARKERS[markerType].red;
 }
 function getDiffMarker(diff) {
   if (diff > 0) {
@@ -1071,7 +1325,7 @@ function colorByScoreDiff(text, diff) {
   return shieldsBadge(text, color);
 }
 function shieldsBadge(text, color) {
-  return image(
+  return image2(
     `https://img.shields.io/badge/${encodeURIComponent(text)}-${color}`,
     text
   );
@@ -1081,7 +1335,7 @@ function formatDiffNumber(diff) {
   const sign = diff < 0 ? "\u2212" : "+";
   return `${sign}${number}`;
 }
-function getSeverityIcon(severity) {
+function severityMarker(severity) {
   if (severity === "error") {
     return "\u{1F6A8}";
   }
@@ -1254,12 +1508,12 @@ var ProcessError = class extends Error {
   }
 };
 function executeProcess(cfg) {
-  const { observer, cwd, command, args, ignoreExitCode = false } = cfg;
+  const { observer, cwd, command: command2, 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 });
+    const process2 = spawn(command2, args, { cwd, shell: true });
     let stdout = "";
     let stderr = "";
     process2.stdout.on("data", (data) => {
@@ -1272,13 +1526,13 @@ function executeProcess(cfg) {
     process2.on("error", (err) => {
       stderr += err.toString();
     });
-    process2.on("close", (code) => {
+    process2.on("close", (code3) => {
       const timings = { date, duration: calcDuration(start) };
-      if (code === 0 || ignoreExitCode) {
+      if (code3 === 0 || ignoreExitCode) {
         onComplete?.();
-        resolve({ code, stdout, stderr, ...timings });
+        resolve({ code: code3, stdout, stderr, ...timings });
       } else {
-        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });
+        const errorMsg = new ProcessError({ code: code3, stdout, stderr, ...timings });
         onError?.(errorMsg);
         reject(errorMsg);
       }
@@ -1294,42 +1548,174 @@ function filterItemRefsBy(items, refFilterFn) {
   })).filter((item) => item.refs.length);
 }
 
-// packages/utils/src/lib/git.ts
+// 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
-function toArray(val) {
-  return Array.isArray(val) ? val : [val];
+function getGitRoot(git = simpleGit()) {
+  return git.revparse("--show-toplevel");
 }
-function objectToEntries(obj) {
-  return Object.entries(obj);
+function formatGitPath(path, gitRoot) {
+  const absolutePath = isAbsolute(path) ? path : join2(process.cwd(), path);
+  const relativePath = relative(gitRoot, absolutePath);
+  return toUnixPath(relativePath);
 }
-function deepClone(obj) {
-  return obj == null || typeof obj !== "object" ? obj : structuredClone(obj);
+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);
+        }
+      )
+    );
+  }
+  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
+      )}`
+    );
+  }
+};
+async function guardAgainstLocalChanges(git = simpleGit()) {
+  const status = await git.status(["-s"]);
+  if (status.files.length > 0) {
+    throw new GitStatusError(status);
+  }
 }
-function toUnixPath(path) {
-  return path.replace(/\\/g, "/");
+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/git.ts
-async function getLatestCommit(git = simpleGit()) {
+// 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 (semverString.includes("@")) {
+    return semverString.split("@").at(-1) ?? "";
+  }
+  return semverString;
+}
+function isSemver(semverString = "") {
+  return valid(normalizeSemver(semverString)) != null;
+}
+
+// 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" }
   });
-  if (!log2.latest) {
-    return null;
-  }
   return commitSchema.parse(log2.latest);
 }
-function getGitRoot(git = simpleGit()) {
-  return git.revparse("--show-toplevel");
+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 formatGitPath(path, gitRoot) {
-  const absolutePath = isAbsolute(path) ? path : join2(process.cwd(), path);
-  const relativePath = relative(gitRoot, absolutePath);
-  return toUnixPath(relativePath);
+function validateFilter({ from, to }) {
+  if (to && !from) {
+    throw new Error(
+      `filter needs the "from" option defined to accept the "to" option.
+`
+    );
+  }
+}
+function filterLogs(allTags, opt) {
+  if (!opt) {
+    return allTags;
+  }
+  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);
+}
+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
+  };
+}
+async function getSemverTags(opt = {}, git = simpleGit2()) {
+  validateFilter(opt);
+  const { targetBranch, ...options2 } = opt;
+  let currentBranch;
+  if (targetBranch) {
+    currentBranch = await getCurrentBranchOrTag(git);
+    await git.checkout(targetBranch);
+  }
+  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, options2);
+  const tagsWithHashes = await Promise.all(
+    relevantTags.map((tag) => getHashFromTag(tag, git))
+  );
+  if (currentBranch) {
+    await git.checkout(currentBranch);
+  }
+  return tagsWithHashes;
+}
+async function getHashes(options2 = {}, git = simpleGit2()) {
+  const { targetBranch, from, to, maxCount, ...opt } = options2;
+  validateFilter({ from, to });
+  let currentBranch;
+  if (targetBranch) {
+    currentBranch = await getCurrentBranchOrTag(git);
+    await git.checkout(targetBranch);
+  }
+  const logs = await git.log({
+    ...opt,
+    format: {
+      hash: "%H",
+      message: "%s"
+    },
+    from,
+    to,
+    maxCount
+  });
+  if (targetBranch) {
+    await git.checkout(currentBranch);
+  }
+  return [...logs.all];
 }
 
 // packages/utils/src/lib/group-by-status.ts
@@ -1407,44 +1793,65 @@ function listAuditsFromAllPlugins(report) {
   );
 }
 
-// packages/utils/src/lib/reports/generate-md-report.ts
-function generateMdReport(report) {
-  const printCategories = report.categories.length > 0;
-  return (
-    // header section
-    // eslint-disable-next-line prefer-template
-    reportToHeaderSection() + NEW_LINE + // categories overview section
-    (printCategories ? reportToOverviewSection(report) + NEW_LINE + NEW_LINE : "") + // categories section
-    (printCategories ? reportToCategoriesSection(report) + NEW_LINE + NEW_LINE : "") + // audits section
-    reportToAuditsSection(report) + NEW_LINE + NEW_LINE + // about section
-    reportToAboutSection(report) + NEW_LINE + NEW_LINE + // footer section
-    `${FOOTER_PREFIX} ${link2(README_LINK, "Code PushUp")}`
+// packages/utils/src/lib/reports/formatting.ts
+var { headline: headline2, lines: lines2, link: link4, section: section2, table: table3 } = md;
+function tableSection(tableData, options2) {
+  if (tableData.rows.length === 0) {
+    return "";
+  }
+  const { level = 4 } = options2 ?? {};
+  const render = (h7, l) => l === 0 ? h7 : headline2(h7, l);
+  return lines2(
+    tableData.title && render(tableData.title, level),
+    table3(tableData)
   );
 }
-function reportToHeaderSection() {
-  return headline(reportHeadlineText) + NEW_LINE;
+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 reportToOverviewSection(report) {
+
+// 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;
-  const tableContent = [
-    reportOverviewTableHeaders,
-    ...categories.map(({ title, refs, score }) => [
-      link2(`#${slugify(title)}`, title),
-      `${getRoundScoreMarker(score)} ${style(formatReportScore(score))}`,
-      countCategoryAudits(refs, plugins).toString()
-    ])
-  ];
-  return tableMd(tableContent, ["l", "c", "c"]);
+  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 "";
 }
-function reportToCategoriesSection(report) {
+function categoriesDetailsSection(report) {
   const { categories, plugins } = report;
-  const categoryDetails = categories.reduce((acc, category) => {
-    const categoryTitle = h3(category.title);
-    const categoryScore = `${getRoundScoreMarker(
+  const categoryDetails = categories.flatMap((category) => {
+    const categoryTitle = h32(category.title);
+    const categoryScore = `${scoreMarker(
       category.score
-    )} Score:  ${style(formatReportScore(category.score))}`;
-    const categoryDocs = getDocsAndDescription(category);
-    const categoryMDItems = category.refs.reduce((refAcc, ref) => {
+    )}${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(
@@ -1454,151 +1861,240 @@ function reportToCategoriesSection(report) {
           )
         );
         const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);
-        const mdGroupItem = groupItemToCategorySection(
-          group,
-          groupAudits,
-          pluginTitle
-        );
-        return refAcc + mdGroupItem + NEW_LINE;
+        return categoryGroupItem(group, groupAudits, pluginTitle);
       } else {
         const audit = getSortableAuditByRef(ref, plugins);
         const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);
-        const mdAuditItem = auditItemToCategorySection(audit, pluginTitle);
-        return refAcc + mdAuditItem + NEW_LINE;
+        return categoryRef(audit, pluginTitle);
       }
-    }, "");
-    return acc + NEW_LINE + categoryTitle + NEW_LINE + NEW_LINE + categoryDocs + categoryScore + NEW_LINE + categoryMDItems;
-  }, "");
-  return h2("\u{1F3F7} Categories") + NEW_LINE + categoryDetails;
-}
-function auditItemToCategorySection(audit, pluginTitle) {
-  const auditTitle = link2(
-    `#${slugify(audit.title)}-${slugify(pluginTitle)}`,
-    audit.title
-  );
-  return li(
-    `${getSquaredScoreMarker(
-      audit.score
-    )} ${auditTitle} (_${pluginTitle}_) - ${getAuditResult(audit)}`
-  );
-}
-function groupItemToCategorySection(group, groupAudits, pluginTitle) {
-  const groupScore = Number(formatReportScore(group.score || 0));
-  const groupTitle = li(
-    `${getRoundScoreMarker(groupScore)} ${group.title} (_${pluginTitle}_)`
-  );
-  const auditTitles = groupAudits.reduce((acc, audit) => {
-    const auditTitle = link2(
-      `#${slugify(audit.title)}-${slugify(pluginTitle)}`,
-      audit.title
+    });
+    return section3(
+      categoryTitle,
+      metaDescription(category),
+      categoryScore,
+      ...categoryMDItems
     );
-    return `${acc}  ${li(
-      `${getSquaredScoreMarker(audit.score)} ${auditTitle} - ${getAuditResult(
-        audit
-      )}`
-    )}${NEW_LINE}`;
-  }, "");
-  return groupTitle + NEW_LINE + auditTitles;
-}
-function reportToAuditsSection(report) {
-  const auditsSection = report.plugins.reduce((pluginAcc, plugin) => {
-    const auditsData = plugin.audits.reduce((auditAcc, audit) => {
-      const auditTitle = `${audit.title} (${getPluginNameFromSlug(
-        plugin.slug,
-        report.plugins
+  });
+  return lines3(h22(CATEGORIES_TITLE), ...categoryDetails);
+}
+function categoryRef({ title, score, value, displayValue }, pluginTitle) {
+  const auditTitleAsLink = link5(
+    `#${slugify(title)}-${slugify(pluginTitle)}`,
+    title
+  );
+  const marker = scoreMarker(score, "square");
+  return li2(
+    `${marker}${SPACE}${auditTitleAsLink}${SPACE}(_${pluginTitle}_) - ${boldMd2(
+      (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)
+          )}`
+        )
+      );
+    }
+  );
+  return lines3(groupTitle, ...auditTitles);
+}
+
+// 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(
+    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")}`
+  );
+}
+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 tableSection(detailsTableData);
+}
+function auditDetails(audit) {
+  const { table: table5, issues = [] } = audit.details ?? {};
+  const detailsValue = auditDetailsAuditValue(audit);
+  if (issues.length === 0 && table5 == null) {
+    return section4(detailsValue);
+  }
+  const tableSectionContent = table5 == null ? "" : tableSection(table5);
+  const issuesSectionContent = issues.length > 0 ? auditDetailsIssues(issues) : "";
+  return details2(
+    detailsValue,
+    lines4(tableSectionContent, issuesSectionContent)
+  );
+}
+function auditsSection({
+  plugins
+}) {
+  const content = plugins.flatMap(
+    ({ slug, audits }) => audits.flatMap((audit) => {
+      const auditTitle = `${audit.title}${SPACE}(${getPluginNameFromSlug(
+        slug,
+        plugins
       )})`;
-      return auditAcc + h3(auditTitle) + NEW_LINE + NEW_LINE + reportToDetailsSection(audit) + NEW_LINE + NEW_LINE + getDocsAndDescription(audit);
-    }, "");
-    return pluginAcc + auditsData;
-  }, "");
-  return h2("\u{1F6E1}\uFE0F Audits") + NEW_LINE + NEW_LINE + auditsSection;
-}
-function reportToDetailsSection(audit) {
-  const detailsTitle = `${getSquaredScoreMarker(audit.score)} ${getAuditResult(
-    audit,
-    true
-  )} (score: ${formatReportScore(audit.score)})`;
-  if (!audit.details?.issues.length) {
-    return detailsTitle;
-  }
-  const detailsTableData = [
-    detailsTableHeaders,
-    ...audit.details.issues.map((issue) => {
-      const severity = `${getSeverityIcon(issue.severity)} <i>${issue.severity}</i>`;
-      const message = issue.message;
-      if (!issue.source) {
-        return [severity, message, "", ""];
+      const detailsContent = auditDetails(audit);
+      const descriptionContent = metaDescription(audit);
+      return [h33(auditTitle), detailsContent, 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"
+      }
+    ],
+    rows: plugins.map(
+      ({
+        title: pluginTitle,
+        audits,
+        version: pluginVersion,
+        duration: pluginDuration
+      }) => ({
+        plugin: pluginTitle,
+        audits: audits.length.toString(),
+        version: codeMd(pluginVersion || ""),
+        duration: formatDuration(pluginDuration)
+      })
+    )
+  };
+}
+function reportMetaData({
+  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"
       }
-      const file = `<code>${issue.source.file}</code>`;
-      if (!issue.source.position) {
-        return [severity, message, file, ""];
+    ],
+    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()
       }
-      const { startLine, endLine } = issue.source.position;
-      const line = `${startLine || ""}${endLine && startLine !== endLine ? `-${endLine}` : ""}`;
-      return [severity, message, file, line];
-    })
-  ];
-  const detailsTable = `<h4>Issues</h4>${tableHtml(detailsTableData)}`;
-  return details(detailsTitle, detailsTable);
-}
-function reportToAboutSection(report) {
-  const date = formatDate(/* @__PURE__ */ new Date());
-  const { duration, version: version2, commit, plugins, categories } = report;
-  const commitInfo = commit ? `${commit.message} (${commit.hash})` : "N/A";
-  const reportMetaTable = [
-    reportMetaTableHeaders,
-    [
-      commitInfo,
-      style(version2 || "", ["c"]),
-      formatDuration(duration),
-      plugins.length.toString(),
-      categories.length.toString(),
-      plugins.reduce((acc, { audits }) => acc + audits.length, 0).toString()
     ]
-  ];
-  const pluginMetaTable = [
-    pluginMetaTableHeaders,
-    ...plugins.map((plugin) => [
-      plugin.title,
-      plugin.audits.length.toString(),
-      style(plugin.version || "", ["c"]),
-      formatDuration(plugin.duration)
-    ])
-  ];
-  return (
-    // eslint-disable-next-line prefer-template
-    h2("About") + NEW_LINE + NEW_LINE + `Report was created by [Code PushUp](${README_LINK}) on ${date}.` + NEW_LINE + NEW_LINE + tableMd(reportMetaTable, ["l", "c", "c", "c", "c", "c"]) + NEW_LINE + NEW_LINE + "The following plugins were run:" + NEW_LINE + NEW_LINE + tableMd(pluginMetaTable, ["l", "c", "c", "c"])
-  );
-}
-function getDocsAndDescription({
-  docsUrl,
-  description
-}) {
-  if (docsUrl) {
-    const docsLink = link2(docsUrl, "\u{1F4D6} Docs");
-    if (!description) {
-      return docsLink + NEW_LINE + NEW_LINE;
-    }
-    if (description.endsWith("```")) {
-      return description + NEW_LINE + NEW_LINE + docsLink + NEW_LINE + NEW_LINE;
-    }
-    return `${description} ${docsLink}${NEW_LINE}${NEW_LINE}`;
-  }
-  if (description) {
-    return description + NEW_LINE + NEW_LINE;
-  }
-  return "";
-}
-function getAuditResult(audit, isHtml = false) {
-  const { displayValue, value } = audit;
-  return isHtml ? `<b>${displayValue || value}</b>` : style(String(displayValue || value));
+  };
 }
 
 // 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;
 var MAX_ROWS = 100;
 function generateMdReportsDiff(diff) {
-  return paragraphs(
-    formatDiffHeaderSection(diff),
+  return lines5(
+    section5(formatDiffHeaderSection(diff)),
     formatDiffCategoriesSection(diff),
     formatDiffGroupsSection(diff),
     formatDiffAuditsSection(diff)
@@ -1606,12 +2102,12 @@ function generateMdReportsDiff(diff) {
 }
 function formatDiffHeaderSection(diff) {
   const outcomeTexts = {
-    positive: `\u{1F973} Code PushUp report has ${style("improved")}`,
-    negative: `\u{1F61F} Code PushUp report has ${style("regressed")}`,
-    mixed: `\u{1F928} Code PushUp report has both ${style(
+    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 ${style("unchanged")}`
+    unchanged: `\u{1F610} Code PushUp report is ${boldMd3("unchanged")}`
   };
   const outcome = mergeDiffOutcomes(
     changesToDiffOutcomes([
@@ -1621,8 +2117,8 @@ function formatDiffHeaderSection(diff) {
     ])
   );
   const styleCommits = (commits) => `compared target commit ${commits.after.hash} with source commit ${commits.before.hash}`;
-  return paragraphs(
-    h1("Code PushUp"),
+  return lines5(
+    h13("Code PushUp"),
     diff.commits ? `${outcomeTexts[outcome]} \u2013 ${styleCommits(diff.commits)}.` : `${outcomeTexts[outcome]}.`
   );
 }
@@ -1633,102 +2129,104 @@ function formatDiffCategoriesSection(diff) {
   if (categoriesCount === 0) {
     return "";
   }
-  return paragraphs(
-    h2("\u{1F3F7}\uFE0F Categories"),
-    categoriesCount > 0 && tableMd(
-      [
-        [
-          "\u{1F3F7}\uFE0F Category",
-          hasChanges ? "\u2B50 Current score" : "\u2B50 Score",
-          "\u2B50 Previous score",
-          "\u{1F504} Score change"
-        ],
-        ...sortChanges(changed).map((category) => [
-          category.title,
-          formatScoreWithColor(category.scores.after),
-          formatScoreWithColor(category.scores.before, { skipBold: true }),
-          formatScoreChange(category.scores.diff)
-        ]),
-        ...added.map((category) => [
-          category.title,
-          formatScoreWithColor(category.score),
-          style("n/a (\\*)", ["i"]),
-          style("n/a (\\*)", ["i"])
-        ]),
-        ...unchanged.map((category) => [
-          category.title,
-          formatScoreWithColor(category.score),
-          formatScoreWithColor(category.score, { skipBold: true }),
-          "\u2013"
-        ])
-      ].map((row) => hasChanges ? row : row.slice(0, 2)),
-      hasChanges ? ["l", "c", "c", "c"] : ["l", "c"]
-    ),
-    added.length > 0 && style("(\\*) New category.", ["i"])
+  const columns = [
+    { key: "category", label: "\u{1F3F7}\uFE0F Category", align: "left" },
+    { key: "after", label: hasChanges ? "\u2B50 Current score" : "\u2B50 Score" },
+    { key: "before", label: "\u2B50 Previous 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, after: row.after }
+      )
+    }),
+    added.length > 0 && section5(italicMd("(\\*) New category."))
   );
 }
 function formatDiffGroupsSection(diff) {
   if (diff.groups.changed.length + diff.groups.unchanged.length === 0) {
     return "";
   }
-  return paragraphs(
-    h2("\u{1F5C3}\uFE0F Groups"),
+  return lines5(
+    h24("\u{1F5C3}\uFE0F Groups"),
     formatGroupsOrAuditsDetails("group", diff.groups, {
-      headings: [
-        "\u{1F50C} Plugin",
-        "\u{1F5C3}\uFE0F Group",
-        "\u2B50 Current score",
-        "\u2B50 Previous score",
-        "\u{1F504} Score change"
+      columns: [
+        { key: "plugin", label: "\u{1F50C} Plugin", align: "left" },
+        { key: "group", label: "\u{1F5C3}\uFE0F Group", align: "left" },
+        { key: "after", label: "\u2B50 Current score" },
+        { key: "before", label: "\u2B50 Previous score" },
+        { key: "change", label: "\u{1F504} Score change" }
       ],
-      rows: sortChanges(diff.groups.changed).map((group) => [
-        group.plugin.title,
-        group.title,
-        formatScoreWithColor(group.scores.after),
-        formatScoreWithColor(group.scores.before, { skipBold: true }),
-        formatScoreChange(group.scores.diff)
-      ]),
-      align: ["l", "l", "c", "c", "c"]
+      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 paragraphs(
-    h2("\u{1F6E1}\uFE0F Audits"),
+  return lines5(
+    h24("\u{1F6E1}\uFE0F Audits"),
     formatGroupsOrAuditsDetails("audit", diff.audits, {
-      headings: [
-        "\u{1F50C} Plugin",
-        "\u{1F6E1}\uFE0F Audit",
-        "\u{1F4CF} Current value",
-        "\u{1F4CF} Previous value",
-        "\u{1F504} Value change"
+      columns: [
+        { key: "plugin", label: "\u{1F50C} Plugin", align: "left" },
+        { key: "audit", label: "\u{1F6E1}\uFE0F Audit", align: "left" },
+        { key: "after", label: "\u{1F4CF} Current value" },
+        { key: "before", label: "\u{1F4CF} Previous value" },
+        { key: "change", label: "\u{1F504} Value change" }
       ],
-      rows: sortChanges(diff.audits.changed).map((audit) => [
-        audit.plugin.title,
-        audit.title,
-        `${getSquaredScoreMarker(audit.scores.after)} ${style(
+      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()
         )}`,
-        `${getSquaredScoreMarker(audit.scores.before)} ${audit.displayValues.before || audit.values.before.toString()}`,
-        formatValueChange(audit)
-      ]),
-      align: ["l", "l", "c", "c", "c"]
+        before: `${scoreMarker(audit.scores.before, "square")} ${audit.displayValues.before || audit.values.before.toString()}`,
+        change: formatValueChange(audit)
+      }))
     })
   );
 }
-function formatGroupsOrAuditsDetails(token, { changed, unchanged }, table) {
-  return changed.length === 0 ? summarizeUnchanged(token, { changed, unchanged }) : details(
+function formatGroupsOrAuditsDetails(token, { changed, unchanged }, tableData) {
+  return changed.length === 0 ? summarizeUnchanged(token, { changed, unchanged }) : details3(
     summarizeDiffOutcomes(changesToDiffOutcomes(changed), token),
-    paragraphs(
-      tableMd(
-        [table.headings, ...table.rows.slice(0, MAX_ROWS)],
-        table.align
-      ),
-      changed.length > MAX_ROWS && style(
+    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.`,
-        ["i"]
+        )} are listed above for brevity.`
       ),
       unchanged.length > 0 && summarizeUnchanged(token, { changed, unchanged })
     )
@@ -1749,11 +2247,13 @@ function formatValueChange({
   return colorByScoreDiff(`${marker} ${text}`, scores.diff);
 }
 function summarizeUnchanged(token, { changed, unchanged }) {
-  return [
-    changed.length > 0 ? pluralizeToken(`other ${token}`, unchanged.length) : `All of ${pluralizeToken(token, unchanged.length)}`,
-    unchanged.length === 1 ? "is" : "are",
-    "unchanged."
-  ].join(" ");
+  return section5(
+    [
+      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(
@@ -1773,6 +2273,15 @@ function summarizeDiffOutcomes(outcomes, token) {
     }
   }).join(", ");
 }
+function formatTitle({
+  title,
+  docsUrl
+}) {
+  if (docsUrl) {
+    return link7(docsUrl, title);
+  }
+  return title;
+}
 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)
@@ -1820,7 +2329,7 @@ function log(msg = "") {
 }
 function logStdoutSummary(report) {
   const printCategories = report.categories.length > 0;
-  log(reportToHeaderSection2(report));
+  log(reportToHeaderSection(report));
   log();
   logPlugins(report);
   if (printCategories) {
@@ -1829,7 +2338,7 @@ function logStdoutSummary(report) {
   log(`${FOOTER_PREFIX} ${CODE_PUSHUP_DOMAIN}`);
   log();
 }
-function reportToHeaderSection2(report) {
+function reportToHeaderSection(report) {
   const { packageName, version: version2 } = report;
   return `${chalk4.bold(reportHeadlineText)} - ${packageName}@${version2}`;
 }
@@ -1869,16 +2378,16 @@ function logCategories({ categories, plugins }) {
     applyScoreColor({ score }),
     countCategoryAudits(refs, plugins)
   ]);
-  const table = ui().table();
-  table.columnWidths([TERMINAL_WIDTH - 9 - 10 - 4, 9, 10]);
-  table.head(
+  const table5 = ui().table();
+  table5.columnWidths([TERMINAL_WIDTH - 9 - 10 - 4, 9, 10]);
+  table5.head(
     reportRawOverviewTableHeaders.map((heading, idx) => ({
       content: chalk4.cyan(heading),
       hAlign: hAlign(idx)
     }))
   );
   rows.forEach(
-    (row) => table.row(
+    (row) => table5.row(
       row.map((content, idx) => ({
         content: content.toString(),
         hAlign: hAlign(idx)
@@ -1887,19 +2396,19 @@ function logCategories({ categories, plugins }) {
   );
   log(chalk4.magentaBright.bold("Categories"));
   log();
-  table.render();
+  table5.render();
   log();
 }
 function applyScoreColor({ score, text }) {
   const formattedScore = text ?? formatReportScore(score);
-  const style2 = text ? chalk4 : chalk4.bold;
+  const style = text ? chalk4 : chalk4.bold;
   if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {
-    return style2.green(formattedScore);
+    return style.green(formattedScore);
   }
   if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {
-    return style2.yellow(formattedScore);
+    return style.yellow(formattedScore);
   }
-  return style2.red(formattedScore);
+  return style.red(formattedScore);
 }
 
 // packages/utils/src/lib/reports/scoring.ts
@@ -2061,12 +2570,22 @@ var verboseUtils = (verbose = false) => ({
 
 // packages/core/package.json
 var name = "@code-pushup/core";
-var version = "0.35.0";
+var version = "0.42.0";
 
 // packages/core/src/lib/implementation/execute-plugin.ts
 import chalk5 from "chalk";
 
 // packages/core/src/lib/normalize.ts
+function normalizeIssue(issue, gitRoot) {
+  const { source, ...issueWithoutSource } = issue;
+  return source == null ? issue : {
+    ...issueWithoutSource,
+    source: {
+      ...source,
+      file: formatGitPath(source.file, gitRoot)
+    }
+  };
+}
 async function normalizeAuditOutputs(audits) {
   const gitRoot = await getGitRoot();
   return audits.map((audit) => {
@@ -2078,13 +2597,7 @@ async function normalizeAuditOutputs(audits) {
       details: {
         ...audit.details,
         issues: audit.details.issues.map(
-          (issue) => issue.source == null ? issue : {
-            ...issue,
-            source: {
-              ...issue.source,
-              file: formatGitPath(issue.source.file, gitRoot)
-            }
-          }
+          (issue) => normalizeIssue(issue, gitRoot)
         )
       }
     };
@@ -2094,9 +2607,9 @@ async function normalizeAuditOutputs(audits) {
 // packages/core/src/lib/implementation/runner.ts
 import { join as join3 } from "node:path";
 async function executeRunnerConfig(cfg, onProgress) {
-  const { args, command, outputFile, outputTransform } = cfg;
+  const { args, command: command2, outputFile, outputTransform } = cfg;
   const { duration, date } = await executeProcess({
-    command,
+    command: command2,
     args,
     observer: { onStdout: onProgress }
   });
@@ -2122,7 +2635,11 @@ async function executeRunnerFunction(runner, onProgress) {
 // packages/core/src/lib/implementation/execute-plugin.ts
 var PluginOutputMissingAuditError = class extends Error {
   constructor(auditSlug) {
-    super(`Audit metadata not found for slug ${auditSlug}`);
+    super(
+      `Audit metadata not present in plugin config. Missing slug: ${chalk5.bold(
+        auditSlug
+      )}`
+    );
   }
 };
 async function executePlugin(pluginConfig, onProgress) {
@@ -2136,7 +2653,11 @@ async function executePlugin(pluginConfig, onProgress) {
   } = pluginConfig;
   const runnerResult = typeof runner === "object" ? await executeRunnerConfig(runner, onProgress) : await executeRunnerFunction(runner, onProgress);
   const { audits: unvalidatedAuditOutputs, ...executionMeta } = runnerResult;
-  const auditOutputs = auditOutputsSchema.parse(unvalidatedAuditOutputs);
+  const result = auditOutputsSchema.safeParse(unvalidatedAuditOutputs);
+  if (!result.success) {
+    throw new Error(`Audit output is invalid: ${result.error.message}`);
+  }
+  const auditOutputs = result.data;
   auditOutputsCorrelateWithPluginOutput(auditOutputs, pluginConfigAudits);
   const normalizedAuditOutputs = await normalizeAuditOutputs(auditOutputs);
   const auditReports = normalizedAuditOutputs.map(
@@ -2156,32 +2677,48 @@ async function executePlugin(pluginConfig, onProgress) {
     ...groups2 && { groups: groups2 }
   };
 }
+var wrapProgress = async (pluginCfg, steps, progressBar) => {
+  progressBar?.updateTitle(`Executing ${chalk5.bold(pluginCfg.title)}`);
+  try {
+    const pluginReport = await executePlugin(pluginCfg);
+    progressBar?.incrementInSteps(steps);
+    return pluginReport;
+  } catch (error) {
+    progressBar?.incrementInSteps(steps);
+    throw new Error(
+      error instanceof Error ? `- Plugin ${chalk5.bold(pluginCfg.title)} (${chalk5.bold(
+        pluginCfg.slug
+      )}) produced the following error:
+  - ${error.message}` : String(error)
+    );
+  }
+};
 async function executePlugins(plugins, options2) {
   const { progress = false } = options2 ?? {};
   const progressBar = progress ? getProgressBar("Run plugins") : null;
-  const pluginsResult = await plugins.reduce(async (acc, pluginCfg) => {
-    progressBar?.updateTitle(`Executing ${chalk5.bold(pluginCfg.title)}`);
-    try {
-      const pluginReport = await executePlugin(pluginCfg);
-      progressBar?.incrementInSteps(plugins.length);
-      return [...await acc, Promise.resolve(pluginReport)];
-    } catch (error) {
-      progressBar?.incrementInSteps(plugins.length);
-      return [
-        ...await acc,
-        Promise.reject(error instanceof Error ? error.message : String(error))
-      ];
-    }
-  }, Promise.resolve([]));
+  const pluginsResult = await plugins.reduce(
+    async (acc, pluginCfg) => [
+      ...await acc,
+      wrapProgress(pluginCfg, plugins.length, progressBar)
+    ],
+    Promise.resolve([])
+  );
   progressBar?.endProgress("Done running plugins");
   const errorsTransform = ({ reason }) => String(reason);
   const results = await Promise.allSettled(pluginsResult);
   logMultipleResults(results, "Plugins", void 0, errorsTransform);
   const { fulfilled, rejected } = groupByStatus(results);
   if (rejected.length > 0) {
-    const errorMessages = rejected.map(({ reason }) => String(reason)).join(", ");
+    const errorMessages = rejected.map(({ reason }) => String(reason)).join("\n");
     throw new Error(
-      `Plugins failed: ${rejected.length} errors: ${errorMessages}`
+      `Executing ${pluralizeToken(
+        "plugin",
+        rejected.length
+      )} failed.
+
+${errorMessages}
+
+`
     );
   }
   return fulfilled.map((result) => result.value);
@@ -2344,8 +2881,7 @@ function compareAudits2(reports) {
 }
 function categoryToResult(category) {
   return {
-    slug: category.slug,
-    title: category.title,
+    ...selectMeta(category),
     score: category.score
   };
 }
@@ -2354,8 +2890,7 @@ function categoryPairToDiff({
   after
 }) {
   return {
-    slug: after.slug,
-    title: after.title,
+    ...selectMeta(after),
     scores: {
       before: before.score,
       after: after.score,
@@ -2365,12 +2900,8 @@ function categoryPairToDiff({
 }
 function pluginGroupToResult({ group, plugin }) {
   return {
-    slug: group.slug,
-    title: group.title,
-    plugin: {
-      slug: plugin.slug,
-      title: plugin.title
-    },
+    ...selectMeta(group),
+    plugin: selectMeta(plugin),
     score: group.score
   };
 }
@@ -2379,12 +2910,8 @@ function pluginGroupPairToDiff({
   after
 }) {
   return {
-    slug: after.group.slug,
-    title: after.group.title,
-    plugin: {
-      slug: after.plugin.slug,
-      title: after.plugin.title
-    },
+    ...selectMeta(after.group),
+    plugin: selectMeta(after.plugin),
     scores: {
       before: before.group.score,
       after: after.group.score,
@@ -2394,12 +2921,8 @@ function pluginGroupPairToDiff({
 }
 function pluginAuditToResult({ audit, plugin }) {
   return {
-    slug: audit.slug,
-    title: audit.title,
-    plugin: {
-      slug: plugin.slug,
-      title: plugin.title
-    },
+    ...selectMeta(audit),
+    plugin: selectMeta(plugin),
     score: audit.score,
     value: audit.value,
     displayValue: audit.displayValue
@@ -2410,12 +2933,8 @@ function pluginAuditPairToDiff({
   after
 }) {
   return {
-    slug: after.audit.slug,
-    title: after.audit.title,
-    plugin: {
-      slug: after.plugin.slug,
-      title: after.plugin.title
-    },
+    ...selectMeta(after.audit),
+    plugin: selectMeta(after.plugin),
     scores: {
       before: before.audit.score,
       after: after.audit.score,
@@ -2432,6 +2951,15 @@ function pluginAuditPairToDiff({
     }
   };
 }
+function selectMeta(meta) {
+  return {
+    slug: meta.slug,
+    title: meta.title,
+    ...meta.docsUrl && {
+      docsUrl: meta.docsUrl
+    }
+  };
+}
 
 // packages/core/src/lib/compare.ts
 async function compareReportFiles(inputPaths, persistConfig) {
@@ -2487,46 +3015,6 @@ function reportsDiffToFileContent(reportsDiff, format) {
   }
 }
 
-// packages/core/src/lib/implementation/read-rc-file.ts
-import { join as join6 } from "node:path";
-var ConfigPathError = class extends Error {
-  constructor(configPath) {
-    super(`Provided path '${configPath}' is not valid.`);
-  }
-};
-async function readRcByPath(filepath, tsconfig) {
-  if (filepath.length === 0) {
-    throw new Error("The path to the configuration file is empty.");
-  }
-  if (!await fileExists(filepath)) {
-    throw new ConfigPathError(filepath);
-  }
-  const cfg = await importEsmModule({ filepath, tsconfig });
-  return coreConfigSchema.parse(cfg);
-}
-async function autoloadRc(tsconfig) {
-  let ext = "";
-  for (const extension of SUPPORTED_CONFIG_FILE_FORMATS) {
-    const path = `${CONFIG_FILE_NAME}.${extension}`;
-    const exists2 = await fileExists(path);
-    if (exists2) {
-      ext = extension;
-      break;
-    }
-  }
-  if (!ext) {
-    throw new Error(
-      `No file ${CONFIG_FILE_NAME}.(${SUPPORTED_CONFIG_FILE_FORMATS.join(
-        "|"
-      )}) present in ${process.cwd()}`
-    );
-  }
-  return readRcByPath(
-    join6(process.cwd(), `${CONFIG_FILE_NAME}.${ext}`),
-    tsconfig
-  );
-}
-
 // packages/core/src/lib/upload.ts
 import {
   uploadToPortal
@@ -2572,17 +3060,33 @@ function groupToGQL(group) {
   };
 }
 function auditToGQL(audit) {
+  const {
+    slug,
+    title,
+    description,
+    docsUrl,
+    score,
+    value,
+    displayValue: formattedValue,
+    details: details4
+  } = audit;
+  const {
+    issues
+    /*, table */
+  } = details4 ?? {};
   return {
-    slug: audit.slug,
-    title: audit.title,
-    description: audit.description,
-    docsUrl: audit.docsUrl,
-    score: audit.score,
-    value: audit.value,
-    formattedValue: audit.displayValue,
-    ...audit.details && {
+    slug,
+    title,
+    description,
+    docsUrl,
+    score,
+    value,
+    formattedValue,
+    ...details4 && {
       details: {
-        issues: audit.details.issues.map(issueToGQL)
+        ...issues && { issues: issues.map(issueToGQL) }
+        // @TODO add when https://github.com/code-pushup/cli/issues/530 is implemented
+        // ...(table ? {table} : {}),
       }
     }
   };
@@ -2606,6 +3110,7 @@ function categoryToGQL(category) {
     slug: category.slug,
     title: category.title,
     description: category.description,
+    isBinary: category.isBinary,
     refs: category.refs.map((ref) => ({
       plugin: ref.plugin,
       type: categoryRefTypeToGQL(ref.type),
@@ -2655,6 +3160,80 @@ async function upload(options2, uploadFn = uploadToPortal) {
   return uploadFn({ apiKey, server, data, timeout });
 }
 
+// packages/core/src/lib/history.ts
+async function history(config, commits) {
+  const initialBranch = await getCurrentBranchOrTag();
+  const { skipUploads = false, forceCleanStatus, persist } = config;
+  const reports = [];
+  for (const commit of commits) {
+    ui().logger.info(`Collect ${commit}`);
+    await safeCheckout(commit, forceCleanStatus);
+    const currentConfig = {
+      ...config,
+      persist: {
+        ...persist,
+        format: ["json"],
+        filename: `${commit}-report`
+      }
+    };
+    await collectAndPersistReports(currentConfig);
+    if (skipUploads) {
+      ui().logger.info("Upload is skipped because skipUploads is set to true.");
+    } else {
+      if (currentConfig.upload) {
+        await upload(currentConfig);
+      } else {
+        ui().logger.info(
+          "Upload is skipped because upload config is undefined."
+        );
+      }
+    }
+    reports.push(currentConfig.persist.filename);
+  }
+  await safeCheckout(initialBranch, forceCleanStatus);
+  return reports;
+}
+
+// packages/core/src/lib/implementation/read-rc-file.ts
+import { join as join6 } from "node:path";
+var ConfigPathError = class extends Error {
+  constructor(configPath) {
+    super(`Provided path '${configPath}' is not valid.`);
+  }
+};
+async function readRcByPath(filepath, tsconfig) {
+  if (filepath.length === 0) {
+    throw new Error("The path to the configuration file is empty.");
+  }
+  if (!await fileExists(filepath)) {
+    throw new ConfigPathError(filepath);
+  }
+  const cfg = await importEsmModule({ filepath, tsconfig });
+  return coreConfigSchema.parse(cfg);
+}
+async function autoloadRc(tsconfig) {
+  let ext = "";
+  for (const extension of SUPPORTED_CONFIG_FILE_FORMATS) {
+    const path = `${CONFIG_FILE_NAME}.${extension}`;
+    const exists2 = await fileExists(path);
+    if (exists2) {
+      ext = extension;
+      break;
+    }
+  }
+  if (!ext) {
+    throw new Error(
+      `No file ${CONFIG_FILE_NAME}.(${SUPPORTED_CONFIG_FILE_FORMATS.join(
+        "|"
+      )}) present in ${process.cwd()}`
+    );
+  }
+  return readRcByPath(
+    join6(process.cwd(), `${CONFIG_FILE_NAME}.${ext}`),
+    tsconfig
+  );
+}
+
 // packages/cli/src/lib/constants.ts
 var CLI_NAME = "Code PushUp CLI";
 var CLI_SCRIPT_NAME = "code-pushup";
@@ -2664,7 +3243,7 @@ import chalk6 from "chalk";
 function renderConfigureCategoriesHint() {
   ui().logger.info(
     chalk6.gray(
-      `\u{1F4A1} Configure categories to see the scores in an overview table. See: ${link(
+      `\u{1F4A1} Configure categories to see the scores in an overview table. See: ${link3(
         "https://github.com/code-pushup/cli/blob/main/packages/cli/README.md"
       )}`
     )
@@ -2672,7 +3251,7 @@ function renderConfigureCategoriesHint() {
 }
 function uploadSuccessfulLog(url) {
   ui().logger.success("Upload successful!");
-  ui().logger.success(link(url));
+  ui().logger.success(link3(url));
 }
 function collectSuccessfulLog() {
   ui().logger.success("Collecting report successful!");
@@ -2683,15 +3262,15 @@ function renderIntegratePortalHint() {
       "npx code-pushup upload"
     )}`
   ).add(
-    `  ${link(
+    `  ${link3(
       "https://github.com/code-pushup/cli/tree/main/packages/cli#upload-command"
     )}`
   ).add(
-    `${chalk6.gray("\u276F")} ${chalk6.gray("Portal Integration")} - ${link(
+    `${chalk6.gray("\u276F")} ${chalk6.gray("Portal Integration")} - ${link3(
       "https://github.com/code-pushup/cli/blob/main/packages/cli/README.md#portal-integration"
     )}`
   ).add(
-    `${chalk6.gray("\u276F")} ${chalk6.gray("Upload Command")} - ${link(
+    `${chalk6.gray("\u276F")} ${chalk6.gray("Upload Command")} - ${link3(
       "https://github.com/code-pushup/cli/blob/main/packages/cli/README.md#portal-integration"
     )}`
   ).render();
@@ -2699,13 +3278,13 @@ function renderIntegratePortalHint() {
 
 // packages/cli/src/lib/autorun/autorun-command.ts
 function yargsAutorunCommandObject() {
-  const command = "autorun";
+  const command2 = "autorun";
   return {
-    command,
+    command: command2,
     describe: "Shortcut for running collect followed by upload",
     handler: async (args) => {
       ui().logger.log(chalk7.bold(CLI_NAME));
-      ui().logger.info(chalk7.gray(`Run ${command}...`));
+      ui().logger.info(chalk7.gray(`Run ${command2}...`));
       const options2 = args;
       const optionsWithFormat = {
         ...options2,
@@ -2735,14 +3314,14 @@ function yargsAutorunCommandObject() {
 // packages/cli/src/lib/collect/collect-command.ts
 import chalk8 from "chalk";
 function yargsCollectCommandObject() {
-  const command = "collect";
+  const command2 = "collect";
   return {
-    command,
+    command: command2,
     describe: "Run Plugins and collect results",
     handler: async (args) => {
       const options2 = args;
       ui().logger.log(chalk8.bold(CLI_NAME));
-      ui().logger.info(chalk8.gray(`Run ${command}...`));
+      ui().logger.info(chalk8.gray(`Run ${command2}...`));
       await collectAndPersistReports(options2);
       collectSuccessfulLog();
       if (options2.categories.length === 0) {
@@ -2761,7 +3340,7 @@ function renderUploadAutorunHint() {
       "Run upload to upload the created report to the server"
     )}`
   ).add(
-    `  ${link(
+    `  ${link3(
       "https://github.com/code-pushup/cli/tree/main/packages/cli#upload-command"
     )}`
   ).add(
@@ -2769,7 +3348,7 @@ function renderUploadAutorunHint() {
       "Run collect & upload"
     )}`
   ).add(
-    `  ${link(
+    `  ${link3(
       "https://github.com/code-pushup/cli/tree/main/packages/cli#autorun-command"
     )}`
   ).render();
@@ -2796,14 +3375,14 @@ function yargsCompareOptionsDefinition() {
 
 // packages/cli/src/lib/compare/compare-command.ts
 function yargsCompareCommandObject() {
-  const command = "compare";
+  const command2 = "compare";
   return {
-    command,
+    command: command2,
     describe: "Compare 2 report files and create a diff file",
     builder: yargsCompareOptionsDefinition(),
     handler: async (args) => {
       ui().logger.log(chalk9.bold(CLI_NAME));
-      ui().logger.info(chalk9.gray(`Run ${command}...`));
+      ui().logger.info(chalk9.gray(`Run ${command2}...`));
       const options2 = args;
       const { before, after, persist } = options2;
       const outputPaths = await compareReportFiles({ before, after }, persist);
@@ -2814,6 +3393,9 @@ function yargsCompareCommandObject() {
   };
 }
 
+// packages/cli/src/lib/history/history-command.ts
+import chalk10 from "chalk";
+
 // packages/cli/src/lib/implementation/global.utils.ts
 function filterKebabCaseKeys(obj) {
   return Object.entries(obj).filter(([key]) => !key.includes("-")).reduce(
@@ -2839,11 +3421,146 @@ function coerceArray(param) {
   return [...new Set(toArray(param).flatMap((f) => f.split(",")))];
 }
 
+// packages/cli/src/lib/implementation/only-plugins.options.ts
+var onlyPluginsOption = {
+  describe: "List of plugins to run. If not set all plugins are run.",
+  type: "array",
+  default: [],
+  coerce: coerceArray
+};
+function yargsOnlyPluginsOptionsDefinition() {
+  return {
+    onlyPlugins: onlyPluginsOption
+  };
+}
+
+// packages/cli/src/lib/history/history.options.ts
+function yargsHistoryOptionsDefinition() {
+  return {
+    targetBranch: {
+      describe: "Branch to crawl history",
+      type: "string"
+    },
+    onlySemverTags: {
+      describe: "Skip commits not tagged with a semantic version",
+      type: "boolean",
+      default: false
+    },
+    forceCleanStatus: {
+      describe: "If we reset the status to a clean git history forcefully or not.",
+      type: "boolean",
+      default: false
+    },
+    skipUploads: {
+      describe: "Upload created reports",
+      type: "boolean",
+      default: false
+    },
+    maxCount: {
+      // https://git-scm.com/docs/git-log#Documentation/git-log.txt---max-countltnumbergt
+      describe: "Number of steps in history",
+      type: "number",
+      // eslint-disable-next-line no-magic-numbers
+      default: 5
+    },
+    from: {
+      // https://git-scm.com/docs/git-log#Documentation/git-log.txt-ltrevision-rangegt
+      describe: "hash to first commit in history",
+      type: "string"
+    },
+    to: {
+      // https://git-scm.com/docs/git-log#Documentation/git-log.txt-ltrevision-rangegt
+      describe: "hash to last commit in history",
+      type: "string"
+    }
+  };
+}
+
+// packages/cli/src/lib/history/utils.ts
+async function normalizeHashOptions(processArgs) {
+  const {
+    onlySemverTags,
+    // overwritten
+    maxCount,
+    ...opt
+  } = processArgs;
+  let { from, to, ...processOptions } = opt;
+  if (!onlySemverTags) {
+    if (from && isSemver(from)) {
+      const { hash } = await getHashFromTag(from);
+      from = hash;
+    }
+    if (to && isSemver(to)) {
+      const { hash } = await getHashFromTag(to);
+      to = hash;
+    }
+  }
+  return {
+    ...processOptions,
+    onlySemverTags,
+    maxCount: maxCount && maxCount > 0 ? maxCount : void 0,
+    from,
+    to
+  };
+}
+
+// packages/cli/src/lib/history/history-command.ts
+var command = "history";
+async function handler(args) {
+  ui().logger.info(chalk10.bold(CLI_NAME));
+  ui().logger.info(chalk10.gray(`Run ${command}`));
+  const currentBranch = await getCurrentBranchOrTag();
+  const { targetBranch: rawTargetBranch, ...opt } = args;
+  const {
+    targetBranch,
+    from,
+    to,
+    maxCount,
+    onlySemverTags,
+    ...historyOptions
+  } = await normalizeHashOptions({
+    ...opt,
+    targetBranch: rawTargetBranch ?? currentBranch
+  });
+  const filterOptions = { targetBranch, from, to, maxCount };
+  const results = onlySemverTags ? await getSemverTags(filterOptions) : await getHashes(filterOptions);
+  try {
+    const reports = await history(
+      {
+        targetBranch,
+        ...historyOptions
+      },
+      results.map(({ hash }) => hash)
+    );
+    ui().logger.log(`Reports: ${reports.length}`);
+  } finally {
+    await safeCheckout(currentBranch);
+  }
+}
+function yargsHistoryCommandObject() {
+  return {
+    command,
+    describe: "Collect reports for commit history",
+    builder: (yargs2) => {
+      yargs2.options({
+        ...yargsHistoryOptionsDefinition(),
+        ...yargsOnlyPluginsOptionsDefinition()
+      });
+      yargs2.group(
+        Object.keys(yargsHistoryOptionsDefinition()),
+        "History Options:"
+      );
+      return yargs2;
+    },
+    handler
+  };
+}
+
 // packages/cli/src/lib/print-config/print-config-command.ts
 function yargsConfigCommandObject() {
-  const command = "print-config";
+  const command2 = "print-config";
   return {
-    command,
+    command: command2,
     describe: "Print config",
     handler: (yargsArgs) => {
       const { _, $0, ...args } = yargsArgs;
@@ -2854,15 +3571,15 @@ function yargsConfigCommandObject() {
 }
 
 // packages/cli/src/lib/upload/upload-command.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 function yargsUploadCommandObject() {
-  const command = "upload";
+  const command2 = "upload";
   return {
-    command,
+    command: command2,
     describe: "Upload report results to the portal",
     handler: async (args) => {
-      ui().logger.log(chalk10.bold(CLI_NAME));
-      ui().logger.info(chalk10.gray(`Run ${command}...`));
+      ui().logger.log(chalk11.bold(CLI_NAME));
+      ui().logger.info(chalk11.gray(`Run ${command2}...`));
       const options2 = args;
       if (options2.upload == null) {
         renderIntegratePortalHint();
@@ -2883,6 +3600,7 @@ var commands = [
   yargsAutorunCommandObject(),
   yargsCollectCommandObject(),
   yargsUploadCommandObject(),
+  yargsHistoryCommandObject(),
   yargsCompareCommandObject(),
   yargsConfigCommandObject()
 ];
@@ -2922,7 +3640,7 @@ async function coreConfigMiddleware(processArgs) {
 }
 
 // packages/cli/src/lib/implementation/only-plugins.utils.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 function validateOnlyPluginsOption({
   plugins,
   categories
@@ -2936,7 +3654,7 @@ function validateOnlyPluginsOption({
   );
   if (missingPlugins.length > 0 && verbose) {
     ui().logger.info(
-      `${chalk11.yellow(
+      `${chalk12.yellow(
         "\u26A0"
       )} The --onlyPlugin argument references plugins with "${missingPlugins.join(
         '", "'
@@ -3063,19 +3781,6 @@ function yargsGlobalOptionsDefinition() {
   };
 }
 
-// packages/cli/src/lib/implementation/only-plugins.options.ts
-var onlyPluginsOption = {
-  describe: "List of plugins to run. If not set all plugins are run.",
-  type: "array",
-  default: [],
-  coerce: coerceArray
-};
-function yargsOnlyPluginsOptionsDefinition() {
-  return {
-    onlyPlugins: onlyPluginsOption
-  };
-}
-
 // packages/cli/src/lib/options.ts
 var options = {
   ...yargsGlobalOptionsDefinition(),
@@ -3092,7 +3797,7 @@ var groups = {
 };
 
 // packages/cli/src/lib/yargs-cli.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 import yargs from "yargs";
 function yargsCli(argv, cfg) {
   const { usageMessage, scriptName, noExitProcess } = cfg;
@@ -3112,7 +3817,7 @@ function yargsCli(argv, cfg) {
     (config) => Array.isArray(config) ? config.at(-1) : config
   ).options(options2).wrap(TERMINAL_WIDTH);
   if (usageMessage) {
-    cli2.usage(chalk12.bold(usageMessage));
+    cli2.usage(chalk13.bold(usageMessage));
   }
   if (scriptName) {
     cli2.scriptName(scriptName);