@code-pushup/utils 0.1.0

package/index.js

@@ -0,0 +1,1529 @@
+// packages/utils/src/lib/execute-process.ts
+import { spawn } from "child_process";
+
+// packages/utils/src/lib/report.ts
+import { join as join2 } from "path";
+
+// packages/models/src/lib/category-config.ts
+import { z as z2 } from "zod";
+
+// packages/models/src/lib/implementation/schemas.ts
+import { z } from "zod";
+import { MATERIAL_ICONS } from "@code-pushup/portal-client";
+
+// packages/models/src/lib/implementation/utils.ts
+var slugRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var filenameRegex = /^(?!.*[ \\/:*?"<>|]).+$/;
+function hasDuplicateStrings(strings) {
+  const uniqueStrings = Array.from(new Set(strings));
+  const duplicatedStrings = strings.filter(
+    /* @__PURE__ */ ((i) => (v) => uniqueStrings[i] !== v || !++i)(0)
+  );
+  return duplicatedStrings.length === 0 ? false : duplicatedStrings;
+}
+function hasMissingStrings(toCheck, existing) {
+  const nonExisting = toCheck.filter((s) => !existing.includes(s));
+  return nonExisting.length === 0 ? false : nonExisting;
+}
+function errorItems(items, transform = (items2) => items2.join(", ")) {
+  const paredItems = items ? items : [];
+  return transform(paredItems);
+}
+function exists(value) {
+  return value != null;
+}
+
+// packages/models/src/lib/implementation/schemas.ts
+function executionMetaSchema(options = {
+  descriptionDate: "Execution start date and time",
+  descriptionDuration: "Execution duration in ms"
+}) {
+  return z.object({
+    date: z.string({ description: options.descriptionDate }),
+    duration: z.number({ description: options.descriptionDuration })
+  });
+}
+function slugSchema(description = "Unique ID (human-readable, URL-safe)") {
+  return z.string({ description }).regex(slugRegex, {
+    message: "The slug has to follow the pattern [0-9a-z] followed by multiple optional groups of -[0-9a-z]. e.g. my-slug"
+  }).max(128, {
+    message: "slug can be max 128 characters long"
+  });
+}
+function descriptionSchema(description = "Description (markdown)") {
+  return z.string({ description }).max(65536).optional();
+}
+function docsUrlSchema(description = "Documentation site") {
+  return urlSchema(description).optional().or(z.string().max(0));
+}
+function urlSchema(description) {
+  return z.string({ description }).url();
+}
+function titleSchema(description = "Descriptive name") {
+  return z.string({ description }).max(256);
+}
+function metaSchema(options) {
+  const {
+    descriptionDescription,
+    titleDescription,
+    docsUrlDescription,
+    description
+  } = options || {};
+  return z.object(
+    {
+      title: titleSchema(titleDescription),
+      description: descriptionSchema(descriptionDescription),
+      docsUrl: docsUrlSchema(docsUrlDescription)
+    },
+    { description }
+  );
+}
+function filePathSchema(description) {
+  return z.string({ description }).trim().min(1, { message: "path is invalid" });
+}
+function fileNameSchema(description) {
+  return z.string({ description }).trim().regex(filenameRegex, {
+    message: `The filename has to be valid`
+  }).min(1, { message: "file name is invalid" });
+}
+function positiveIntSchema(description) {
+  return z.number({ description }).int().nonnegative();
+}
+function packageVersionSchema(options) {
+  let { versionDescription, optional } = options || {};
+  versionDescription = versionDescription || "NPM version of the package";
+  optional = !!optional;
+  const packageSchema = z.string({ description: "NPM package name" });
+  const versionSchema = z.string({ description: versionDescription });
+  return z.object(
+    {
+      packageName: optional ? packageSchema.optional() : packageSchema,
+      version: optional ? versionSchema.optional() : versionSchema
+    },
+    { description: "NPM package name and version of a published package" }
+  );
+}
+function weightSchema(description = "Coefficient for the given score (use weight 0 if only for display)") {
+  return positiveIntSchema(description);
+}
+function weightedRefSchema(description, slugDescription) {
+  return z.object(
+    {
+      slug: slugSchema(slugDescription),
+      weight: weightSchema("Weight used to calculate score")
+    },
+    { description }
+  );
+}
+function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
+  return z.object(
+    {
+      slug: slugSchema('Human-readable unique ID, e.g. "performance"'),
+      refs: z.array(refSchema).refine(
+        (refs) => !duplicateCheckFn(refs),
+        (refs) => ({
+          message: duplicateMessageFn(refs)
+        })
+      )
+    },
+    { description }
+  );
+}
+var materialIconSchema = z.enum(
+  MATERIAL_ICONS,
+  { description: "Icon from VSCode Material Icons extension" }
+);
+
+// packages/models/src/lib/category-config.ts
+var categoryRefSchema = weightedRefSchema(
+  "Weighted references to audits and/or groups for the category",
+  "Slug of an audit or group (depending on `type`)"
+).merge(
+  z2.object({
+    type: z2.enum(["audit", "group"], {
+      description: "Discriminant for reference kind, affects where `slug` is looked up"
+    }),
+    plugin: slugSchema(
+      "Plugin slug (plugin should contain referenced audit or group)"
+    )
+  })
+);
+var categoryConfigSchema = scorableSchema(
+  "Category with a score calculated from audits and groups from various plugins",
+  categoryRefSchema,
+  getDuplicateRefsInCategoryMetrics,
+  duplicateRefsInCategoryMetricsErrorMsg
+).merge(
+  metaSchema({
+    titleDescription: "Category Title",
+    docsUrlDescription: "Category docs URL",
+    descriptionDescription: "Category description",
+    description: "Meta info for category"
+  })
+).merge(
+  z2.object({
+    isBinary: z2.boolean({
+      description: 'Is this a binary category (i.e. only a perfect score considered a "pass")?'
+    }).optional()
+  })
+);
+function duplicateRefsInCategoryMetricsErrorMsg(metrics) {
+  const duplicateRefs = getDuplicateRefsInCategoryMetrics(metrics);
+  return `In the categories, the following audit or group refs are duplicates: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInCategoryMetrics(metrics) {
+  return hasDuplicateStrings(
+    metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`)
+  );
+}
+
+// packages/models/src/lib/core-config.ts
+import { z as z11 } from "zod";
+
+// packages/models/src/lib/persist-config.ts
+import { z as z3 } from "zod";
+var formatSchema = z3.enum(["json", "md"]);
+var persistConfigSchema = z3.object({
+  outputDir: filePathSchema("Artifacts folder"),
+  filename: fileNameSchema("Artifacts file name (without extension)").default(
+    "report"
+  ),
+  format: z3.array(formatSchema).default(["json"]).optional()
+  // @TODO remove default or optional value and otherwise it will not set defaults.
+});
+
+// packages/models/src/lib/plugin-config.ts
+import { z as z9 } from "zod";
+
+// packages/models/src/lib/plugin-config-audits.ts
+import { z as z4 } from "zod";
+var auditSchema = z4.object({
+  slug: slugSchema("ID (unique within plugin)")
+}).merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Link to documentation (rationale)",
+    description: "List of scorable metrics for the given plugin"
+  })
+);
+var pluginAuditsSchema = z4.array(auditSchema, {
+  description: "List of audits maintained in a plugin"
+}).refine(
+  (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
+  (auditMetadata) => ({
+    message: duplicateSlugsInAuditsErrorMsg(auditMetadata)
+  })
+);
+function duplicateSlugsInAuditsErrorMsg(audits) {
+  const duplicateRefs = getDuplicateSlugsInAudits(audits);
+  return `In plugin audits the slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits(audits) {
+  return hasDuplicateStrings(audits.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/plugin-config-groups.ts
+import { z as z5 } from "zod";
+var auditGroupRefSchema = weightedRefSchema(
+  "Weighted references to audits",
+  "Reference slug to an audit within this plugin (e.g. 'max-lines')"
+);
+var auditGroupSchema = scorableSchema(
+  'An audit group aggregates a set of audits into a single score which can be referenced from a category. E.g. the group slug "performance" groups audits and can be referenced in a category',
+  auditGroupRefSchema,
+  getDuplicateRefsInGroups,
+  duplicateRefsInGroupsErrorMsg
+).merge(
+  metaSchema({
+    titleDescription: "Descriptive name for the group",
+    descriptionDescription: "Description of the group (markdown)",
+    docsUrlDescription: "Group documentation site",
+    description: "Group metadata"
+  })
+);
+var auditGroupsSchema = z5.array(auditGroupSchema, {
+  description: "List of groups"
+}).optional().refine(
+  (groups) => !getDuplicateSlugsInGroups(groups),
+  (groups) => ({
+    message: duplicateSlugsInGroupsErrorMsg(groups)
+  })
+);
+function duplicateRefsInGroupsErrorMsg(groupAudits) {
+  const duplicateRefs = getDuplicateRefsInGroups(groupAudits);
+  return `In plugin groups the audit refs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInGroups(groupAudits) {
+  return hasDuplicateStrings(
+    groupAudits.map(({ slug: ref }) => ref).filter(exists)
+  );
+}
+function duplicateSlugsInGroupsErrorMsg(groups) {
+  const duplicateRefs = getDuplicateSlugsInGroups(groups);
+  return `In groups the slugs are not unique: ${errorItems(duplicateRefs)}`;
+}
+function getDuplicateSlugsInGroups(groups) {
+  return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
+}
+
+// packages/models/src/lib/plugin-config-runner.ts
+import { z as z8 } from "zod";
+
+// packages/models/src/lib/plugin-process-output.ts
+import { z as z7 } from "zod";
+
+// packages/models/src/lib/plugin-process-output-audit-issue.ts
+import { z as z6 } from "zod";
+var sourceFileLocationSchema = z6.object(
+  {
+    file: filePathSchema("Relative path to source file in Git repo"),
+    position: z6.object(
+      {
+        startLine: positiveIntSchema("Start line"),
+        startColumn: positiveIntSchema("Start column").optional(),
+        endLine: positiveIntSchema("End line").optional(),
+        endColumn: positiveIntSchema("End column").optional()
+      },
+      { description: "Location in file" }
+    ).optional()
+  },
+  { description: "Source file location" }
+);
+var issueSeveritySchema = z6.enum(["info", "warning", "error"], {
+  description: "Severity level"
+});
+var issueSchema = z6.object(
+  {
+    message: z6.string({ description: "Descriptive error message" }).max(512),
+    severity: issueSeveritySchema,
+    source: sourceFileLocationSchema.optional()
+  },
+  { description: "Issue information" }
+);
+
+// packages/models/src/lib/plugin-process-output.ts
+var auditOutputSchema = z7.object(
+  {
+    slug: slugSchema("Reference to audit"),
+    displayValue: z7.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional(),
+    value: positiveIntSchema("Raw numeric value"),
+    score: z7.number({
+      description: "Value between 0 and 1"
+    }).min(0).max(1),
+    details: z7.object(
+      {
+        issues: z7.array(issueSchema, { description: "List of findings" })
+      },
+      { description: "Detailed information" }
+    ).optional()
+  },
+  { description: "Audit information" }
+);
+var auditOutputsSchema = z7.array(auditOutputSchema, {
+  description: "List of JSON formatted audit output emitted by the runner process of a plugin"
+}).refine(
+  (audits) => !getDuplicateSlugsInAudits2(audits),
+  (audits) => ({ message: duplicateSlugsInAuditsErrorMsg2(audits) })
+);
+function duplicateSlugsInAuditsErrorMsg2(audits) {
+  const duplicateRefs = getDuplicateSlugsInAudits2(audits);
+  return `In plugin audits the slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits2(audits) {
+  return hasDuplicateStrings(audits.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/plugin-config-runner.ts
+var outputTransformSchema = z8.function().args(z8.unknown()).returns(z8.union([auditOutputsSchema, z8.promise(auditOutputsSchema)]));
+var runnerConfigSchema = z8.object(
+  {
+    command: z8.string({
+      description: "Shell command to execute"
+    }),
+    args: z8.array(z8.string({ description: "Command arguments" })).optional(),
+    outputFile: filePathSchema("Output path"),
+    outputTransform: outputTransformSchema.optional()
+  },
+  {
+    description: "How to execute runner"
+  }
+);
+var onProgressSchema = z8.function().args(z8.unknown()).returns(z8.void());
+var runnerFunctionSchema = z8.function().args(onProgressSchema.optional()).returns(z8.union([auditOutputsSchema, z8.promise(auditOutputsSchema)]));
+
+// packages/models/src/lib/plugin-config.ts
+var pluginMetaSchema = packageVersionSchema({
+  optional: true
+}).merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Plugin documentation site",
+    description: "Plugin metadata"
+  })
+).merge(
+  z9.object({
+    slug: slugSchema("References plugin. ID (unique within core config)"),
+    icon: materialIconSchema
+  })
+);
+var pluginDataSchema = z9.object({
+  runner: z9.union([runnerConfigSchema, runnerFunctionSchema]),
+  audits: pluginAuditsSchema,
+  groups: auditGroupsSchema
+});
+var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
+  (pluginCfg) => !getMissingRefsFromGroups(pluginCfg),
+  (pluginCfg) => ({
+    message: missingRefsFromGroupsErrorMsg(pluginCfg)
+  })
+);
+function missingRefsFromGroupsErrorMsg(pluginCfg) {
+  const missingRefs = getMissingRefsFromGroups(pluginCfg);
+  return `In the groups, the following audit ref's needs to point to a audit in this plugin config: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups(pluginCfg) {
+  if (pluginCfg?.groups?.length && pluginCfg?.audits?.length) {
+    const groups = pluginCfg?.groups || [];
+    const audits = pluginCfg?.audits || [];
+    return hasMissingStrings(
+      groups.flatMap(({ refs: audits2 }) => audits2.map(({ slug: ref }) => ref)),
+      audits.map(({ slug }) => slug)
+    );
+  }
+  return false;
+}
+
+// packages/models/src/lib/upload-config.ts
+import { z as z10 } from "zod";
+var uploadConfigSchema = z10.object({
+  server: urlSchema("URL of deployed portal API"),
+  apiKey: z10.string({
+    description: "API key with write access to portal (use `process.env` for security)"
+  }),
+  organization: z10.string({
+    description: "Organization in code versioning system"
+  }),
+  project: z10.string({
+    description: "Project in code versioning system"
+  })
+});
+
+// packages/models/src/lib/core-config.ts
+var unrefinedCoreConfigSchema = z11.object({
+  plugins: z11.array(pluginConfigSchema, {
+    description: "List of plugins to be used (official, community-provided, or custom)"
+  }),
+  /** portal configuration for persisting results */
+  persist: persistConfigSchema,
+  /** portal configuration for uploading results */
+  upload: uploadConfigSchema.optional(),
+  categories: z11.array(categoryConfigSchema, {
+    description: "Categorization of individual audits"
+  }).refine(
+    (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
+    (categoryCfg) => ({
+      message: duplicateSlugCategoriesErrorMsg(categoryCfg)
+    })
+  )
+});
+var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
+function refineCoreConfig(schema) {
+  return schema.refine(
+    (coreCfg) => !getMissingRefsForCategories(coreCfg),
+    (coreCfg) => ({
+      message: missingRefsForCategoriesErrorMsg(coreCfg)
+    })
+  );
+}
+function missingRefsForCategoriesErrorMsg(coreCfg) {
+  const missingRefs = getMissingRefsForCategories(coreCfg);
+  return `In the categories, the following plugin refs do not exist in the provided plugins: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsForCategories(coreCfg) {
+  const missingRefs = [];
+  const auditRefsFromCategory = coreCfg.categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
+  );
+  const auditRefsFromPlugins = coreCfg.plugins.flatMap(
+    ({ audits, slug: pluginSlug }) => {
+      return audits.map(({ slug }) => `${pluginSlug}/${slug}`);
+    }
+  );
+  const missingAuditRefs = hasMissingStrings(
+    auditRefsFromCategory,
+    auditRefsFromPlugins
+  );
+  if (Array.isArray(missingAuditRefs) && missingAuditRefs.length > 0) {
+    missingRefs.push(...missingAuditRefs);
+  }
+  const groupRefsFromCategory = coreCfg.categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
+  );
+  const groupRefsFromPlugins = coreCfg.plugins.flatMap(
+    ({ groups, slug: pluginSlug }) => {
+      return Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : [];
+    }
+  );
+  const missingGroupRefs = hasMissingStrings(
+    groupRefsFromCategory,
+    groupRefsFromPlugins
+  );
+  if (Array.isArray(missingGroupRefs) && missingGroupRefs.length > 0) {
+    missingRefs.push(...missingGroupRefs);
+  }
+  return missingRefs.length ? missingRefs : false;
+}
+function duplicateSlugCategoriesErrorMsg(categories) {
+  const duplicateStringSlugs = getDuplicateSlugCategories(categories);
+  return `In the categories, the following slugs are duplicated: ${errorItems(
+    duplicateStringSlugs
+  )}`;
+}
+function getDuplicateSlugCategories(categories) {
+  return hasDuplicateStrings(categories.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/report.ts
+import { z as z12 } from "zod";
+var auditReportSchema = auditSchema.merge(auditOutputSchema);
+var pluginReportSchema = pluginMetaSchema.merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of plugin run",
+    descriptionDuration: "Duration of the plugin run in ms"
+  })
+).merge(
+  z12.object({
+    audits: z12.array(auditReportSchema),
+    groups: z12.array(auditGroupSchema).optional()
+  })
+);
+var reportSchema = packageVersionSchema({
+  versionDescription: "NPM version of the CLI"
+}).merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of the collect run",
+    descriptionDuration: "Duration of the collect run in ms"
+  })
+).merge(
+  z12.object(
+    {
+      categories: z12.array(categoryConfigSchema),
+      plugins: z12.array(pluginReportSchema)
+    },
+    { description: "Collect output data" }
+  )
+);
+
+// packages/utils/src/lib/file-system.ts
+import { bundleRequire } from "bundle-require";
+import chalk from "chalk";
+import { mkdir, readFile, readdir, stat } from "fs/promises";
+import { join } from "path";
+
+// packages/utils/src/lib/formatting.ts
+function slugify(text) {
+  return text.trim().toLowerCase().replace(/\s+|\//g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function pluralize(text) {
+  if (text.endsWith("y")) {
+    return text.slice(0, -1) + "ies";
+  }
+  if (text.endsWith("s")) {
+    return `${text}es`;
+  }
+  return `${text}s`;
+}
+function formatBytes(bytes, decimals = 2) {
+  if (!+bytes)
+    return "0 B";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+function pluralizeToken(token, times = 0) {
+  return `${times} ${Math.abs(times) === 1 ? token : pluralize(token)}`;
+}
+function formatDuration(duration) {
+  if (duration < 1e3) {
+    return `${duration} ms`;
+  }
+  return `${(duration / 1e3).toFixed(2)} s`;
+}
+
+// packages/utils/src/lib/guards.ts
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+
+// packages/utils/src/lib/log-results.ts
+function logMultipleResults(results, messagePrefix, succeededCallback, failedCallback) {
+  if (succeededCallback) {
+    const succeededResults = results.filter(isPromiseFulfilledResult);
+    logPromiseResults(
+      succeededResults,
+      `${messagePrefix} successfully: `,
+      succeededCallback
+    );
+  }
+  if (failedCallback) {
+    const failedResults = results.filter(isPromiseRejectedResult);
+    logPromiseResults(
+      failedResults,
+      `${messagePrefix} failed: `,
+      failedCallback
+    );
+  }
+}
+function logPromiseResults(results, logMessage, callback) {
+  if (results.length) {
+    if (results[0]?.status === "fulfilled") {
+      console.info(logMessage);
+    } else {
+      console.warn(logMessage);
+    }
+    results.forEach(callback);
+  }
+}
+
+// packages/utils/src/lib/file-system.ts
+function toUnixPath(path, options) {
+  const unixPath = path.replace(/\\/g, "/");
+  if (options?.toRelative) {
+    return unixPath.replace(process.cwd().replace(/\\/g, "/") + "/", "");
+  }
+  return unixPath;
+}
+async function ensureDirectoryExists(baseDir) {
+  try {
+    await mkdir(baseDir, { recursive: true });
+    return;
+  } catch (error) {
+    console.error(error.message);
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function readTextFile(path) {
+  const buffer = await readFile(path);
+  return buffer.toString();
+}
+async function readJsonFile(path) {
+  const text = await readTextFile(path);
+  return JSON.parse(text);
+}
+function logMultipleFileResults(fileResults, messagePrefix) {
+  const succeededCallback = (result) => {
+    const [fileName, size] = result.value;
+    console.info(
+      `- ${chalk.bold(fileName)}` + (size ? ` (${chalk.gray(formatBytes(size))})` : "")
+    );
+  };
+  const failedCallback = (result) => {
+    console.warn(`- ${chalk.bold(result.reason)}`);
+  };
+  logMultipleResults(
+    fileResults,
+    messagePrefix,
+    succeededCallback,
+    failedCallback
+  );
+}
+var NoExportError = class extends Error {
+  constructor(filepath) {
+    super(`No export found in ${filepath}`);
+  }
+};
+async function importEsmModule(options, parse) {
+  parse = parse || ((v) => v);
+  options = {
+    format: "esm",
+    ...options
+  };
+  const { mod } = await bundleRequire(options);
+  if (mod.default === void 0) {
+    throw new NoExportError(options.filepath);
+  }
+  return parse(mod.default);
+}
+function pluginWorkDir(slug) {
+  return join("node_modules", ".code-pushup", slug);
+}
+async function crawlFileSystem(options) {
+  const {
+    directory,
+    pattern,
+    fileTransform = (filePath) => filePath
+  } = options;
+  const files = await readdir(directory);
+  const promises = files.map(async (file) => {
+    const filePath = join(directory, file);
+    const stats = await stat(filePath);
+    if (stats.isDirectory()) {
+      return crawlFileSystem({ directory: filePath, pattern, fileTransform });
+    }
+    if (stats.isFile() && (!pattern || new RegExp(pattern).test(file))) {
+      return fileTransform(filePath);
+    }
+    return [];
+  });
+  const resultsNestedArray = await Promise.all(promises);
+  return resultsNestedArray.flat();
+}
+function findLineNumberInText(content, pattern) {
+  const lines = content.split(/\r?\n/);
+  const lineNumber = lines.findIndex((line) => line.includes(pattern)) + 1;
+  return lineNumber === 0 ? null : lineNumber;
+}
+
+// packages/utils/src/lib/report.ts
+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 reportHeadlineText = "Code PushUp Report";
+var reportOverviewTableHeaders = [
+  "\u{1F3F7} Category",
+  "\u2B50 Score",
+  "\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)"
+];
+function formatReportScore(score) {
+  return Math.round(score * 100).toString();
+}
+function getRoundScoreMarker(score) {
+  if (score >= 0.9) {
+    return "\u{1F7E2}";
+  }
+  if (score >= 0.5) {
+    return "\u{1F7E1}";
+  }
+  return "\u{1F534}";
+}
+function getSquaredScoreMarker(score) {
+  if (score >= 0.9) {
+    return "\u{1F7E9}";
+  }
+  if (score >= 0.5) {
+    return "\u{1F7E8}";
+  }
+  return "\u{1F7E5}";
+}
+function getSeverityIcon(severity) {
+  if (severity === "error") {
+    return "\u{1F6A8}";
+  }
+  if (severity === "warning") {
+    return "\u26A0\uFE0F";
+  }
+  return "\u2139\uFE0F";
+}
+function calcDuration(start, stop) {
+  stop = stop !== void 0 ? stop : performance.now();
+  return Math.floor(stop - start);
+}
+function countCategoryAudits(refs, plugins) {
+  const groupLookup = plugins.reduce((lookup, plugin) => {
+    if (!plugin.groups.length) {
+      return lookup;
+    }
+    return {
+      ...lookup,
+      [plugin.slug]: {
+        ...plugin.groups.reduce(
+          (groupLookup2, group) => {
+            return {
+              ...groupLookup2,
+              [group.slug]: group
+            };
+          },
+          {}
+        )
+      }
+    };
+  }, {});
+  return refs.reduce((acc, ref) => {
+    if (ref.type === "group") {
+      const groupRefs = groupLookup[ref.plugin]?.[ref.slug]?.refs;
+      return acc + (groupRefs?.length || 0);
+    }
+    return acc + 1;
+  }, 0);
+}
+function getAuditByRef({ slug, weight, plugin }, plugins) {
+  const auditPlugin = plugins.find(({ slug: slug2 }) => slug2 === plugin);
+  if (!auditPlugin) {
+    throwIsNotPresentError(`Plugin ${plugin}`, "report");
+  }
+  const audit = auditPlugin?.audits.find(
+    ({ slug: auditSlug }) => auditSlug === slug
+  );
+  if (!audit) {
+    throwIsNotPresentError(`Audit ${slug}`, auditPlugin?.slug);
+  }
+  return {
+    ...audit,
+    weight,
+    plugin
+  };
+}
+function getGroupWithAudits(refSlug, refPlugin, plugins) {
+  const plugin = plugins.find(({ slug }) => slug === refPlugin);
+  if (!plugin) {
+    throwIsNotPresentError(`Plugin ${refPlugin}`, "report");
+  }
+  const groupWithAudits = plugin?.groups?.find(({ slug }) => slug === refSlug);
+  if (!groupWithAudits) {
+    throwIsNotPresentError(`Group ${refSlug}`, plugin?.slug);
+  }
+  const groupAudits = groupWithAudits.refs.reduce(
+    (acc, ref) => {
+      const audit = getAuditByRef(
+        { ...ref, plugin: refPlugin },
+        plugins
+      );
+      if (audit) {
+        return [...acc, audit];
+      }
+      return [...acc];
+    },
+    []
+  );
+  const audits = groupAudits.sort(sortCategoryAudits);
+  return {
+    ...groupWithAudits,
+    audits
+  };
+}
+function sortCategoryAudits(a, b) {
+  if (a.weight !== b.weight) {
+    return b.weight - a.weight;
+  }
+  if (a.score !== b.score) {
+    return a.score - b.score;
+  }
+  if (a.value !== b.value) {
+    return b.value - a.value;
+  }
+  return a.title.localeCompare(b.title);
+}
+function sortAudits(a, b) {
+  if (a.score !== b.score) {
+    return a.score - b.score;
+  }
+  if (a.value !== b.value) {
+    return b.value - a.value;
+  }
+  return a.title.localeCompare(b.title);
+}
+function compareIssueSeverity(severity1, severity2) {
+  const levels = {
+    info: 0,
+    warning: 1,
+    error: 2
+  };
+  return levels[severity1] - levels[severity2];
+}
+async function loadReport(options) {
+  const { outputDir, filename, format } = options;
+  await ensureDirectoryExists(outputDir);
+  const filePath = join2(outputDir, `${filename}.${format}`);
+  if (format === "json") {
+    const content = await readJsonFile(filePath);
+    return reportSchema.parse(content);
+  }
+  return readTextFile(filePath);
+}
+function throwIsNotPresentError(itemName, presentPlace) {
+  throw new Error(`${itemName} is not present in ${presentPlace}`);
+}
+function getPluginNameFromSlug(slug, plugins) {
+  return plugins.find(({ slug: pluginSlug }) => pluginSlug === slug)?.title || slug;
+}
+
+// packages/utils/src/lib/execute-process.ts
+var ProcessError = class extends Error {
+  code;
+  stderr;
+  stdout;
+  constructor(result) {
+    super(result.stderr);
+    this.code = result.code;
+    this.stderr = result.stderr;
+    this.stdout = result.stdout;
+  }
+};
+function executeProcess(cfg) {
+  const { observer, cwd } = cfg;
+  const { onStdout, onError, onComplete } = observer || {};
+  const date = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  return new Promise((resolve, reject) => {
+    const process2 = spawn(cfg.command, cfg.args, { cwd, shell: true });
+    let stdout = "";
+    let stderr = "";
+    process2.stdout.on("data", (data) => {
+      stdout += data.toString();
+      onStdout?.(data);
+    });
+    process2.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    process2.on("error", (err) => {
+      stderr += err.toString();
+    });
+    process2.on("close", (code) => {
+      const timings = { date, duration: calcDuration(start) };
+      if (code === 0) {
+        onComplete?.();
+        resolve({ code, stdout, stderr, ...timings });
+      } else {
+        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });
+        onError?.(errorMsg);
+        reject(errorMsg);
+      }
+    });
+  });
+}
+function objectToCliArgs(params) {
+  if (!params) {
+    return [];
+  }
+  return Object.entries(params).flatMap(([key, value]) => {
+    if (key === "_") {
+      if (Array.isArray(value)) {
+        return value;
+      } else {
+        return [value + ""];
+      }
+    }
+    const prefix = key.length === 1 ? "-" : "--";
+    if (Array.isArray(value)) {
+      return value.map((v) => `${prefix}${key}="${v}"`);
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => `${prefix}${key}="${v}"`);
+    }
+    if (typeof value === "string") {
+      return [`${prefix}${key}="${value}"`];
+    }
+    if (typeof value === "number") {
+      return [`${prefix}${key}=${value}`];
+    }
+    if (typeof value === "boolean") {
+      return [`${prefix}${value ? "" : "no-"}${key}`];
+    }
+    throw new Error(`Unsupported type ${typeof value} for key ${key}`);
+  });
+}
+objectToCliArgs({ z: 5 });
+
+// packages/utils/src/lib/git.ts
+import simpleGit from "simple-git";
+var git = simpleGit();
+async function getLatestCommit() {
+  const log = await git.log({
+    maxCount: 1,
+    format: { hash: "%H", message: "%s", author: "%an", date: "%ad" }
+  });
+  return log?.latest;
+}
+
+// packages/utils/src/lib/progress.ts
+import chalk2 from "chalk";
+import { MultiProgressBars } from "multi-progress-bars";
+var barStyles = {
+  active: (s) => chalk2.green(s),
+  done: (s) => chalk2.gray(s),
+  idle: (s) => chalk2.gray(s)
+};
+var messageStyles = {
+  active: (s) => chalk2.black(s),
+  done: (s) => chalk2.green(chalk2.bold(s)),
+  idle: (s) => chalk2.gray(s)
+};
+var mpb;
+function getSingletonProgressBars(options) {
+  if (!mpb) {
+    mpb = new MultiProgressBars({
+      initMessage: "",
+      border: true,
+      ...options
+    });
+  }
+  return mpb;
+}
+function getProgressBar(taskName) {
+  const tasks = getSingletonProgressBars();
+  tasks.addTask(taskName, {
+    type: "percentage",
+    percentage: 0,
+    message: "",
+    barTransformFn: barStyles.idle
+  });
+  return {
+    incrementInSteps: (numPlugins) => {
+      tasks.incrementTask(taskName, {
+        percentage: 1 / numPlugins,
+        barTransformFn: barStyles.active
+      });
+    },
+    updateTitle: (title) => {
+      tasks.updateTask(taskName, {
+        message: title,
+        barTransformFn: barStyles.active
+      });
+    },
+    endProgress: (message = "") => {
+      tasks.done(taskName, {
+        message: messageStyles.done(message),
+        barTransformFn: barStyles.done
+      });
+    }
+  };
+}
+
+// packages/utils/src/lib/md/details.ts
+function details(title, content, cfg = { open: false }) {
+  return `<details${cfg.open ? " open" : ""}>
+<summary>${title}</summary>
+${content}
+</details>
+`;
+}
+
+// packages/utils/src/lib/md/headline.ts
+function headline(text, hierarchy = 1) {
+  return `${new Array(hierarchy).fill("#").join("")} ${text}`;
+}
+function h2(text) {
+  return headline(text, 2);
+}
+function h3(text) {
+  return headline(text, 3);
+}
+
+// packages/utils/src/lib/md/constants.ts
+var NEW_LINE = "\n";
+
+// packages/utils/src/lib/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");
+  }
+  align = align || data[0]?.map(() => "c");
+  const _data = data.map((arr) => "|" + arr.join("|") + "|");
+  const secondRow = "|" + align?.map((s) => alignString.get(s)).join("|") + "|";
+  return _data.shift() + NEW_LINE + secondRow + NEW_LINE + _data.join(NEW_LINE);
+}
+function tableHtml(data) {
+  if (data.length === 0) {
+    throw new Error("Data can't be empty");
+  }
+  const _data = data.map((arr, index) => {
+    if (index === 0) {
+      return "<tr>" + arr.map((s) => `<th>${s}</th>`).join("") + "</tr>";
+    }
+    return "<tr>" + arr.map((s) => `<td>${s}</td>`).join("") + "</tr>";
+  });
+  return "<table>" + _data.join("") + "</table>";
+}
+
+// packages/utils/src/lib/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/md/link.ts
+function link(href, text) {
+  return `[${text || href}](${href})`;
+}
+
+// packages/utils/src/lib/md/list.ts
+function li(text, order = "unordered") {
+  const style2 = order === "unordered" ? "-" : "- [ ]";
+  return `${style2} ${text}`;
+}
+
+// packages/utils/src/lib/report-to-md.ts
+function reportToMd(report, commitData) {
+  let md = reportToHeaderSection() + NEW_LINE;
+  md += reportToOverviewSection(report) + NEW_LINE + NEW_LINE;
+  md += reportToCategoriesSection(report) + NEW_LINE + NEW_LINE;
+  md += reportToAuditsSection(report) + NEW_LINE + NEW_LINE;
+  md += reportToAboutSection(report, commitData) + NEW_LINE + NEW_LINE;
+  md += `${FOOTER_PREFIX} ${link(README_LINK, "Code PushUp")}`;
+  return md;
+}
+function reportToHeaderSection() {
+  return headline(reportHeadlineText) + NEW_LINE;
+}
+function reportToOverviewSection(report) {
+  const { categories } = report;
+  const tableContent = [
+    reportOverviewTableHeaders,
+    ...categories.map(({ title, refs, score }) => [
+      link(`#${slugify(title)}`, title),
+      `${getRoundScoreMarker(score)} ${style(formatReportScore(score))}`,
+      countCategoryAudits(refs, report.plugins).toString()
+    ])
+  ];
+  return tableMd(tableContent, ["l", "c", "c"]);
+}
+function reportToCategoriesSection(report) {
+  const { categories, plugins } = report;
+  const categoryDetails = categories.reduce((acc, category) => {
+    const categoryTitle = h3(category.title);
+    const categoryScore = `${getRoundScoreMarker(
+      category.score
+    )} Score:  ${style(formatReportScore(category.score))}`;
+    const categoryDocs = getDocsAndDescription(category);
+    const auditsAndGroups = category.refs.reduce(
+      (acc2, ref) => ({
+        ...acc2,
+        ...ref.type === "group" ? {
+          groups: [
+            ...acc2.groups,
+            getGroupWithAudits(ref.slug, ref.plugin, plugins)
+          ]
+        } : {
+          audits: [...acc2.audits, getAuditByRef(ref, plugins)]
+        }
+      }),
+      { groups: [], audits: [] }
+    );
+    const audits = auditsAndGroups.audits.sort(sortCategoryAudits).map((audit) => auditItemToCategorySection(audit, plugins)).join(NEW_LINE);
+    const groups = auditsAndGroups.groups.map((group) => groupItemToCategorySection(group, plugins)).join("");
+    return acc + NEW_LINE + categoryTitle + NEW_LINE + NEW_LINE + categoryDocs + categoryScore + NEW_LINE + groups + NEW_LINE + audits;
+  }, "");
+  return h2("\u{1F3F7} Categories") + NEW_LINE + categoryDetails;
+}
+function auditItemToCategorySection(audit, plugins) {
+  const pluginTitle = getPluginNameFromSlug(audit.plugin, plugins);
+  const auditTitle = link(
+    `#${slugify(audit.title)}-${slugify(pluginTitle)}`,
+    audit?.title
+  );
+  return li(
+    `${getSquaredScoreMarker(
+      audit.score
+    )} ${auditTitle} (_${pluginTitle}_) - ${getAuditResult(audit)}`
+  );
+}
+function groupItemToCategorySection(group, plugins) {
+  const pluginTitle = getPluginNameFromSlug(group.plugin, plugins);
+  const groupScore = Number(formatReportScore(group?.score || 0));
+  const groupTitle = li(
+    `${getRoundScoreMarker(groupScore)} ${group.title} (_${pluginTitle}_)`
+  );
+  const groupAudits = group.audits.reduce((acc, audit) => {
+    const auditTitle = link(
+      `#${slugify(audit.title)}-${slugify(pluginTitle)}`,
+      audit?.title
+    );
+    acc += `  ${li(
+      `${getSquaredScoreMarker(audit.score)} ${auditTitle} - ${getAuditResult(
+        audit
+      )}`
+    )}`;
+    acc += NEW_LINE;
+    return acc;
+  }, "");
+  return groupTitle + NEW_LINE + groupAudits;
+}
+function reportToAuditsSection(report) {
+  const auditsSection = report.plugins.reduce((acc, plugin) => {
+    const auditsData = plugin.audits.sort(sortAudits).reduce((acc2, audit) => {
+      const auditTitle = `${audit.title} (${getPluginNameFromSlug(
+        audit.plugin,
+        report.plugins
+      )})`;
+      const detailsTitle = `${getSquaredScoreMarker(
+        audit.score
+      )} ${getAuditResult(audit, true)} (score: ${formatReportScore(
+        audit.score
+      )})`;
+      const docsItem = getDocsAndDescription(audit);
+      acc2 += h3(auditTitle);
+      acc2 += NEW_LINE;
+      acc2 += NEW_LINE;
+      if (!audit.details?.issues?.length) {
+        acc2 += detailsTitle;
+        acc2 += NEW_LINE;
+        acc2 += NEW_LINE;
+        acc2 += docsItem;
+        return acc2;
+      }
+      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 file = `<code>${issue.source?.file}</code>`;
+          if (!issue.source.position) {
+            return [severity, message, file, ""];
+          }
+          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)}`;
+      acc2 += details(detailsTitle, detailsTable);
+      acc2 += NEW_LINE;
+      acc2 += NEW_LINE;
+      acc2 += docsItem;
+      return acc2;
+    }, "");
+    return acc + auditsData;
+  }, "");
+  return h2("\u{1F6E1}\uFE0F Audits") + NEW_LINE + NEW_LINE + auditsSection;
+}
+function reportToAboutSection(report, commitData) {
+  const date = (/* @__PURE__ */ new Date()).toString();
+  const { duration, version, plugins, categories } = report;
+  const commitInfo = commitData ? `${commitData.message} (${commitData.hash.slice(0, 7)})` : "N/A";
+  const reportMetaTable = [
+    reportMetaTableHeaders,
+    [
+      commitInfo,
+      style(version || "", ["c"]),
+      formatDuration(duration),
+      plugins.length.toString(),
+      categories.length.toString(),
+      plugins.reduce((acc, { audits }) => acc + audits.length, 0).toString()
+    ]
+  ];
+  const pluginMetaTable = [
+    pluginMetaTableHeaders,
+    ...plugins.map(({ title, version: version2, duration: duration2, audits }) => [
+      title,
+      audits.length.toString(),
+      style(version2 || "", ["c"]),
+      formatDuration(duration2)
+    ])
+  ];
+  return 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 = link(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/report-to-stdout.ts
+import cliui from "@isaacs/cliui";
+import chalk3 from "chalk";
+import Table from "cli-table3";
+function addLine(line = "") {
+  return line + NEW_LINE;
+}
+function reportToStdout(report) {
+  let output = "";
+  output += addLine(reportToHeaderSection2(report));
+  output += addLine();
+  output += addLine(reportToDetailSection(report));
+  output += addLine(reportToOverviewSection2(report));
+  output += addLine(`${FOOTER_PREFIX} ${CODE_PUSHUP_DOMAIN}`);
+  return output;
+}
+function reportToHeaderSection2(report) {
+  const { packageName, version } = report;
+  return `${chalk3.bold(reportHeadlineText)} - ${packageName}@${version}`;
+}
+function reportToOverviewSection2({
+  categories,
+  plugins
+}) {
+  let output = addLine(chalk3.magentaBright.bold("Categories"));
+  output += addLine();
+  const table = new Table({
+    head: reportRawOverviewTableHeaders,
+    colAligns: ["left", "right", "right"],
+    style: {
+      head: ["cyan"]
+    }
+  });
+  table.push(
+    ...categories.map(({ title, score, refs }) => [
+      title,
+      withColor({ score }),
+      countCategoryAudits(refs, plugins)
+    ])
+  );
+  output += addLine(table.toString());
+  return output;
+}
+function reportToDetailSection(report) {
+  const { plugins } = report;
+  let output = "";
+  plugins.forEach(({ title, audits }) => {
+    output += addLine();
+    output += addLine(chalk3.magentaBright.bold(`${title} audits`));
+    output += addLine();
+    const ui = cliui({ width: 80 });
+    audits.sort(sortAudits).forEach(({ score, title: title2, displayValue, value }) => {
+      ui.div(
+        {
+          text: withColor({ score, text: "\u25CF" }),
+          width: 2,
+          padding: [0, 1, 0, 0]
+        },
+        {
+          text: title2,
+          padding: [0, 3, 0, 0]
+        },
+        {
+          text: chalk3.cyanBright(displayValue || `${value}`),
+          width: 10,
+          padding: [0, 0, 0, 0]
+        }
+      );
+    });
+    output += addLine(ui.toString());
+    output += addLine();
+  });
+  return output;
+}
+function withColor({ score, text }) {
+  let str = text ?? formatReportScore(score);
+  const style2 = text ? chalk3 : chalk3.bold;
+  if (score < 0.5) {
+    str = style2.red(str);
+  } else if (score < 0.9) {
+    str = style2.yellow(str);
+  } else {
+    str = style2.green(str);
+  }
+  return str;
+}
+
+// packages/utils/src/lib/transformation.ts
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+function objectToKeys(obj) {
+  return Object.keys(obj);
+}
+function objectToEntries(obj) {
+  return Object.entries(obj);
+}
+function countOccurrences(values) {
+  return values.reduce(
+    (acc, value) => ({ ...acc, [value]: (acc[value] ?? 0) + 1 }),
+    {}
+  );
+}
+function distinct(array) {
+  return Array.from(new Set(array));
+}
+function deepClone(obj) {
+  if (obj == null || typeof obj !== "object") {
+    return obj;
+  }
+  const cloned = Array.isArray(obj) ? [] : {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+
+// packages/utils/src/lib/scoring.ts
+function calculateScore(refs, scoreFn) {
+  const { numerator, denominator } = refs.reduce(
+    (acc, ref) => {
+      const score = scoreFn(ref);
+      return {
+        numerator: acc.numerator + score * ref.weight,
+        denominator: acc.denominator + ref.weight
+      };
+    },
+    { numerator: 0, denominator: 0 }
+  );
+  return numerator / denominator;
+}
+function scoreReport(report) {
+  const scoredReport = deepClone(report);
+  const allScoredAuditsAndGroups = /* @__PURE__ */ new Map();
+  scoredReport.plugins?.forEach((plugin) => {
+    const { audits } = plugin;
+    const groups = plugin.groups || [];
+    audits.forEach((audit) => {
+      const key = `${plugin.slug}-${audit.slug}-audit`;
+      audit.plugin = plugin.slug;
+      allScoredAuditsAndGroups.set(key, audit);
+    });
+    function groupScoreFn(ref) {
+      const score = allScoredAuditsAndGroups.get(
+        `${plugin.slug}-${ref.slug}-audit`
+      )?.score;
+      if (score == null) {
+        throw new Error(
+          `Group has invalid ref - audit with slug ${plugin.slug}-${ref.slug}-audit not found`
+        );
+      }
+      return score;
+    }
+    groups.forEach((group) => {
+      const key = `${plugin.slug}-${group.slug}-group`;
+      group.score = calculateScore(group.refs, groupScoreFn);
+      group.plugin = plugin.slug;
+      allScoredAuditsAndGroups.set(key, group);
+    });
+    plugin.groups = groups;
+  });
+  function catScoreFn(ref) {
+    const key = `${ref.plugin}-${ref.slug}-${ref.type}`;
+    const item = allScoredAuditsAndGroups.get(key);
+    if (!item) {
+      throw new Error(
+        `Category has invalid ref - ${ref.type} with slug ${key} not found in ${ref.plugin} plugin`
+      );
+    }
+    return item.score;
+  }
+  const scoredCategoriesMap = /* @__PURE__ */ new Map();
+  for (const category of scoredReport.categories) {
+    category.score = calculateScore(category.refs, catScoreFn);
+    scoredCategoriesMap.set(category.slug, category);
+  }
+  scoredReport.categories = Array.from(scoredCategoriesMap.values());
+  return scoredReport;
+}
+
+// packages/utils/src/lib/verbose-utils.ts
+function getLogVerbose(verbose) {
+  return (...args) => {
+    if (verbose) {
+      console.info(...args);
+    }
+  };
+}
+function getExecVerbose(verbose) {
+  return (fn) => {
+    if (verbose) {
+      fn();
+    }
+  };
+}
+var verboseUtils = (verbose) => ({
+  log: getLogVerbose(verbose),
+  exec: getExecVerbose(verbose)
+});
+export {
+  CODE_PUSHUP_DOMAIN,
+  FOOTER_PREFIX,
+  NEW_LINE,
+  ProcessError,
+  README_LINK,
+  calcDuration,
+  compareIssueSeverity,
+  countOccurrences,
+  crawlFileSystem,
+  distinct,
+  ensureDirectoryExists,
+  executeProcess,
+  findLineNumberInText,
+  formatBytes,
+  formatDuration,
+  getLatestCommit,
+  getProgressBar,
+  git,
+  importEsmModule,
+  isPromiseFulfilledResult,
+  isPromiseRejectedResult,
+  loadReport,
+  logMultipleFileResults,
+  logMultipleResults,
+  objectToCliArgs,
+  objectToEntries,
+  objectToKeys,
+  pluginWorkDir,
+  pluralize,
+  pluralizeToken,
+  readJsonFile,
+  readTextFile,
+  reportToMd,
+  reportToStdout,
+  scoreReport,
+  slugify,
+  toArray,
+  toUnixPath,
+  verboseUtils
+};