@code-pushup/coverage-plugin 0.39.0 → 0.42.0

package/index.js

@@ -2,8 +2,277 @@
 import { dirname as dirname2, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// packages/models/src/lib/audit.ts
-import { z as z2 } from "zod";
+// packages/utils/src/lib/text-formats/constants.ts
+var NEW_LINE = "\n";
+var TAB = "  ";
+
+// 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 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/models/src/lib/implementation/schemas.ts
 import { MATERIAL_ICONS } from "vscode-material-icons";
@@ -70,6 +339,7 @@ function missingRefsForCategoriesErrorMsg(categories, plugins) {
 }
 
 // packages/models/src/lib/implementation/schemas.ts
+var primitiveValueSchema = z.union([z.string(), z.number()]);
 function executionMetaSchema(options = {
   descriptionDate: "Execution start date and time",
   descriptionDuration: "Execution duration in ms"
@@ -161,6 +431,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(
@@ -190,7 +461,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";
@@ -221,16 +492,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,
@@ -240,7 +556,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),
@@ -257,13 +573,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(
@@ -284,8 +600,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()
   })
@@ -301,7 +617,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),
@@ -320,18 +636,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()
   },
@@ -339,22 +655,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')"
@@ -371,7 +687,7 @@ var groupSchema = scorableSchema(
   getDuplicateRefsInGroups,
   duplicateRefsInGroupsErrorMsg
 ).merge(groupMetaSchema);
-var groupsSchema = z8.array(groupSchema, {
+var groupsSchema = z9.array(groupSchema, {
   description: "List of groups"
 }).optional().refine(
   (groups) => !getDuplicateSlugsInGroups(groups),
@@ -399,14 +715,14 @@ function getDuplicateSlugsInGroups(groups) {
 }
 
 // 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()
   },
@@ -414,8 +730,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(
@@ -426,13 +742,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
 });
@@ -458,22 +774,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 */
@@ -496,7 +812,7 @@ function refineCoreConfig(schema) {
 }
 
 // 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({
@@ -504,9 +820,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 ?? []),
@@ -540,10 +856,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" }
@@ -559,40 +875,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({
+var scorableMetaSchema = z15.object({
   slug: slugSchema,
   title: titleSchema,
   docsUrl: docsUrlSchema
 });
 var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
-  z14.object({
+  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")
   })
@@ -603,10 +919,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(
@@ -615,15 +931,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,
@@ -721,57 +1037,82 @@ function pluginWorkDir(slug) {
   return join("node_modules", ".code-pushup", slug);
 }
 
-// packages/utils/src/lib/git.ts
+// packages/utils/src/lib/reports/utils.ts
+var { image: image2, bold: boldMd } = md;
+
+// packages/utils/src/lib/git/git.ts
 import { simpleGit } from "simple-git";
 
-// packages/utils/src/lib/transform.ts
-function capitalize(text) {
-  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(
-    1
-  )}`;
-}
+// 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";
 
 // packages/utils/src/lib/progress.ts
 import chalk3 from "chalk";
 import { MultiProgressBars } from "multi-progress-bars";
 
+// packages/utils/src/lib/reports/formatting.ts
+var { headline: headline2, lines: lines2, link: link3, section: section2, table: table3 } = md;
+
+// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
+var { link: link4, section: section3, h2: h22, lines: lines3, li: li2, bold: boldMd2, h3: h32, indentation: indentation2 } = md;
+
+// packages/utils/src/lib/reports/generate-md-report.ts
+var { h1: h12, h2: h23, h3: h33, lines: lines4, link: link5, section: section4, code: codeMd } = md;
+var { bold: boldHtml, details: details2 } = html;
+
+// packages/utils/src/lib/reports/generate-md-reports-diff.ts
+var {
+  h1: h13,
+  h2: h24,
+  lines: lines5,
+  link: link6,
+  bold: boldMd3,
+  italic: italicMd,
+  table: table4,
+  section: section5
+} = md;
+var { details: details3 } = html;
+
 // packages/utils/src/lib/reports/log-stdout-summary.ts
 import chalk4 from "chalk";
 
 // packages/plugin-coverage/package.json
 var name = "@code-pushup/coverage-plugin";
-var version = "0.39.0";
+var version = "0.42.0";
 
 // packages/plugin-coverage/src/lib/config.ts
-import { z as z15 } from "zod";
-var coverageTypeSchema = z15.enum(["function", "branch", "line"]);
-var coverageResultSchema = z15.union([
-  z15.object({
-    resultsPath: z15.string({
+import { z as z16 } from "zod";
+var coverageTypeSchema = z16.enum(["function", "branch", "line"]);
+var coverageResultSchema = z16.union([
+  z16.object({
+    resultsPath: z16.string({
       description: "Path to coverage results for Nx setup."
     }).includes("lcov"),
-    pathToProject: z15.string({
+    pathToProject: z16.string({
       description: "Path from workspace root to project root. Necessary for LCOV reports which provide a relative path."
     }).optional()
   }),
-  z15.string({
+  z16.string({
     description: "Path to coverage results for a single project setup."
   }).includes("lcov")
 ]);
-var coveragePluginConfigSchema = z15.object({
-  coverageToolCommand: z15.object({
-    command: z15.string({ description: "Command to run coverage tool." }).min(1),
-    args: z15.array(z15.string(), {
+var coveragePluginConfigSchema = z16.object({
+  coverageToolCommand: z16.object({
+    command: z16.string({ description: "Command to run coverage tool." }).min(1),
+    args: z16.array(z16.string(), {
       description: "Arguments to be passed to the coverage tool."
     }).optional()
   }).optional(),
-  coverageTypes: z15.array(coverageTypeSchema, {
+  coverageTypes: z16.array(coverageTypeSchema, {
     description: "Coverage types measured. Defaults to all available types."
   }).min(1).default(["function", "branch", "line"]),
-  reports: z15.array(coverageResultSchema, {
+  reports: z16.array(coverageResultSchema, {
     description: "Path to all code coverage report files. Only LCOV format is supported for now."
   }).min(1),
-  perfectScoreThreshold: z15.number({
+  perfectScoreThreshold: z16.number({
     description: "Score will be 1 (perfect) for this coverage and above. Score range is 0 - 1."
   }).gt(0).max(1).optional()
 });