@code-pushup/core 0.1.0

package/index.js

@@ -0,0 +1,1757 @@
+// packages/core/src/lib/implementation/persist.ts
+import { existsSync, mkdirSync } from "fs";
+import { stat as stat2, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// packages/utils/src/lib/execute-process.ts
+import { spawn } from "child_process";
+
+// packages/utils/src/lib/report.ts
+import { join } 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";
+
+// packages/utils/src/lib/formatting.ts
+function slugify(text) {
+  return text.trim().toLowerCase().replace(/\s+|\//g, "-").replace(/[^a-z0-9-]/g, "");
+}
+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 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
+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);
+}
+
+// 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);
+}
+async function loadReport(options) {
+  const { outputDir, filename, format } = options;
+  await ensureDirectoryExists(outputDir);
+  const filePath = join(outputDir, `${filename}.${format}`);
+  if (format === "json") {
+    const content = await readJsonFile(filePath);
+    return reportSchema.parse(content);
+  }
+  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: version2, plugins, categories } = report;
+  const commitInfo = commitData ? `${commitData.message} (${commitData.hash.slice(0, 7)})` : "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(({ title, version: version3, duration: duration2, audits }) => [
+      title,
+      audits.length.toString(),
+      style(version3 || "", ["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: version2 } = report;
+  return `${chalk3.bold(reportHeadlineText)} - ${packageName}@${version2}`;
+}
+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 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)
+});
+
+// packages/core/src/lib/implementation/persist.ts
+var PersistDirError = class extends Error {
+  constructor(outputDir) {
+    super(`outPath: ${outputDir} is no directory.`);
+  }
+};
+var PersistError = class extends Error {
+  constructor(reportPath) {
+    super(`fileName: ${reportPath} could not be saved.`);
+  }
+};
+async function persistReport(report, config) {
+  const { persist } = config;
+  const outputDir = persist.outputDir;
+  const filename = persist.filename;
+  const format = persist.format ?? [];
+  let scoredReport = scoreReport(report);
+  console.info(reportToStdout(scoredReport));
+  const results = [
+    // JSON is always persisted
+    { format: "json", content: JSON.stringify(report, null, 2) }
+  ];
+  if (format.includes("md")) {
+    scoredReport = scoredReport || scoreReport(report);
+    const commitData = await getLatestCommit();
+    if (!commitData) {
+      console.warn("no commit data available");
+    }
+    results.push({
+      format: "md",
+      content: reportToMd(scoredReport, commitData)
+    });
+  }
+  if (!existsSync(outputDir)) {
+    try {
+      mkdirSync(outputDir, { recursive: true });
+    } catch (e) {
+      console.warn(e);
+      throw new PersistDirError(outputDir);
+    }
+  }
+  return Promise.allSettled(
+    results.map(({ format: format2, content }) => {
+      const reportPath = join2(outputDir, `${filename}.${format2}`);
+      return writeFile(reportPath, content).then(() => stat2(reportPath)).then((stats) => [reportPath, stats.size]).catch((e) => {
+        console.warn(e);
+        throw new PersistError(reportPath);
+      });
+    })
+  );
+}
+function logPersistedResults(persistResults) {
+  logMultipleFileResults(persistResults, "Generated reports");
+}
+
+// packages/core/src/lib/implementation/execute-plugin.ts
+import chalk4 from "chalk";
+
+// packages/core/src/lib/implementation/runner.ts
+import { join as join3 } from "path";
+async function executeRunnerConfig(cfg, onProgress) {
+  const { args, command, outputFile, outputTransform } = cfg;
+  const { duration, date } = await executeProcess({
+    command,
+    args,
+    observer: { onStdout: onProgress }
+  });
+  let audits = await readJsonFile(
+    join3(process.cwd(), outputFile)
+  );
+  if (outputTransform) {
+    audits = await outputTransform(audits);
+  }
+  return {
+    duration,
+    date,
+    audits
+  };
+}
+async function executeRunnerFunction(runner, onProgress) {
+  const date = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  const audits = await runner(onProgress);
+  return {
+    date,
+    duration: calcDuration(start),
+    audits
+  };
+}
+
+// packages/core/src/lib/implementation/execute-plugin.ts
+var PluginOutputMissingAuditError = class extends Error {
+  constructor(auditSlug) {
+    super(`Audit metadata not found for slug ${auditSlug}`);
+  }
+};
+async function executePlugin(pluginConfig, onProgress) {
+  const {
+    runner,
+    audits: pluginConfigAudits,
+    description,
+    docsUrl,
+    groups,
+    ...pluginMeta
+  } = pluginConfig;
+  const runnerResult = typeof runner === "object" ? await executeRunnerConfig(runner, onProgress) : await executeRunnerFunction(runner, onProgress);
+  const { audits: unvalidatedAuditOutputs, ...executionMeta } = runnerResult;
+  const auditOutputs = auditOutputsSchema.parse(unvalidatedAuditOutputs);
+  auditOutputsCorrelateWithPluginOutput(auditOutputs, pluginConfigAudits);
+  const auditReports = auditOutputs.map(
+    (auditOutput) => ({
+      ...auditOutput,
+      ...pluginConfigAudits.find(
+        (audit) => audit.slug === auditOutput.slug
+      )
+    })
+  );
+  return {
+    ...pluginMeta,
+    ...executionMeta,
+    audits: auditReports,
+    ...description && { description },
+    ...docsUrl && { docsUrl },
+    ...groups && { groups }
+  };
+}
+async function executePlugins(plugins, options) {
+  const { progress = false } = options || {};
+  const progressName = "Run Plugins";
+  const progressBar = progress ? getProgressBar(progressName) : null;
+  const pluginsResult = await plugins.reduce(async (acc, pluginCfg) => {
+    const outputs = await acc;
+    progressBar?.updateTitle(`Executing  ${chalk4.bold(pluginCfg.title)}`);
+    try {
+      const pluginReport = await executePlugin(pluginCfg);
+      progressBar?.incrementInSteps(plugins.length);
+      return outputs.concat(Promise.resolve(pluginReport));
+    } catch (e) {
+      progressBar?.incrementInSteps(plugins.length);
+      return outputs.concat(
+        Promise.reject(e instanceof Error ? e.message : String(e))
+      );
+    }
+  }, Promise.resolve([]));
+  progressBar?.endProgress("Done running plugins");
+  const errorsCallback = ({ reason }) => console.error(reason);
+  const results = await Promise.allSettled(pluginsResult);
+  logMultipleResults(results, "Plugins", void 0, errorsCallback);
+  const failedResults = results.filter(isPromiseRejectedResult);
+  if (failedResults.length) {
+    const errorMessages = failedResults.map(({ reason }) => reason).join(", ");
+    throw new Error(
+      `Plugins failed: ${failedResults.length} errors: ${errorMessages}`
+    );
+  }
+  return results.filter(isPromiseFulfilledResult).map((result) => result.value);
+}
+function auditOutputsCorrelateWithPluginOutput(auditOutputs, pluginConfigAudits) {
+  auditOutputs.forEach((auditOutput) => {
+    const auditMetadata = pluginConfigAudits.find(
+      (audit) => audit.slug === auditOutput.slug
+    );
+    if (!auditMetadata) {
+      throw new PluginOutputMissingAuditError(auditOutput.slug);
+    }
+  });
+}
+
+// packages/core/package.json
+var name = "@code-pushup/core";
+var version = "0.1.0";
+
+// packages/core/src/lib/implementation/collect.ts
+async function collect(options) {
+  const { plugins, categories } = options;
+  if (!plugins?.length) {
+    throw new Error("No plugins registered");
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  const pluginOutputs = await executePlugins(plugins, options);
+  return {
+    packageName: name,
+    version,
+    date,
+    duration: calcDuration(start),
+    categories,
+    plugins: pluginOutputs
+  };
+}
+
+// packages/core/src/lib/upload.ts
+import { uploadToPortal } from "@code-pushup/portal-client";
+
+// packages/core/src/lib/implementation/json-to-gql.ts
+import {
+  CategoryConfigRefType,
+  IssueSourceType,
+  IssueSeverity as PortalIssueSeverity
+} from "@code-pushup/portal-client";
+function jsonToGql(report) {
+  return {
+    packageName: report.packageName,
+    packageVersion: report.version,
+    commandStartDate: report.date,
+    commandDuration: report.duration,
+    plugins: report.plugins.map((plugin) => ({
+      audits: plugin.audits.map((audit) => ({
+        description: audit.description,
+        details: {
+          issues: audit.details?.issues.map((issue) => ({
+            message: issue.message,
+            severity: transformSeverity(issue.severity),
+            sourceEndColumn: issue.source?.position?.endColumn,
+            sourceEndLine: issue.source?.position?.endLine,
+            sourceFilePath: issue.source?.file,
+            sourceStartColumn: issue.source?.position?.startColumn,
+            sourceStartLine: issue.source?.position?.startLine,
+            sourceType: IssueSourceType.SourceCode
+          })) || []
+        },
+        docsUrl: audit.docsUrl,
+        formattedValue: audit.displayValue,
+        score: audit.score,
+        slug: audit.slug,
+        title: audit.title,
+        value: audit.value
+      })),
+      description: plugin.description,
+      docsUrl: plugin.docsUrl,
+      groups: plugin.groups?.map((group) => ({
+        slug: group.slug,
+        title: group.title,
+        description: group.description,
+        refs: group.refs.map((ref) => ({ slug: ref.slug, weight: ref.weight }))
+      })),
+      icon: plugin.icon,
+      slug: plugin.slug,
+      title: plugin.title,
+      packageName: plugin.packageName,
+      packageVersion: plugin.version,
+      runnerDuration: plugin.duration,
+      runnerStartDate: plugin.date
+    })),
+    categories: report.categories.map((category) => ({
+      slug: category.slug,
+      title: category.title,
+      description: category.description,
+      refs: category.refs.map((ref) => ({
+        plugin: ref.plugin,
+        type: ref.type === "audit" ? CategoryConfigRefType.Audit : CategoryConfigRefType.Group,
+        weight: ref.weight,
+        slug: ref.slug
+      }))
+    }))
+  };
+}
+function transformSeverity(severity) {
+  switch (severity) {
+    case "info":
+      return PortalIssueSeverity.Info;
+    case "error":
+      return PortalIssueSeverity.Error;
+    case "warning":
+      return PortalIssueSeverity.Warning;
+  }
+}
+
+// packages/core/src/lib/upload.ts
+async function upload(options, uploadFn = uploadToPortal) {
+  if (options?.upload === void 0) {
+    throw new Error("upload config needs to be set");
+  }
+  const { apiKey, server, organization, project } = options.upload;
+  const { outputDir, filename } = options.persist;
+  const report = await loadReport({
+    outputDir,
+    filename,
+    format: "json"
+  });
+  const commitData = await getLatestCommit();
+  if (!commitData) {
+    throw new Error("no commit data available");
+  }
+  const data = {
+    organization,
+    project,
+    commit: commitData.hash,
+    ...jsonToGql(report)
+  };
+  return uploadFn({ apiKey, server, data });
+}
+
+// packages/core/src/lib/collect-and-persist.ts
+async function collectAndPersistReports(options) {
+  const { exec } = verboseUtils(options.verbose);
+  const report = await collect(options);
+  const persistResults = await persistReport(report, options);
+  exec(() => logPersistedResults(persistResults));
+  report.plugins.forEach((plugin) => {
+    pluginReportSchema.parse(plugin);
+  });
+}
+
+// packages/core/src/lib/implementation/read-code-pushup-config.ts
+import { stat as stat3 } from "fs/promises";
+var ConfigPathError = class extends Error {
+  constructor(configPath) {
+    super(`Config path ${configPath} is not a file.`);
+  }
+};
+async function readCodePushupConfig(filepath) {
+  if (!filepath.length) {
+    throw new Error("No filepath provided");
+  }
+  const isFile = (await stat3(filepath)).isFile();
+  if (!isFile) {
+    throw new ConfigPathError(filepath);
+  }
+  return importEsmModule(
+    {
+      filepath
+    },
+    coreConfigSchema.parse
+  );
+}
+export {
+  ConfigPathError,
+  PersistDirError,
+  PersistError,
+  PluginOutputMissingAuditError,
+  collect,
+  collectAndPersistReports,
+  executePlugins,
+  persistReport,
+  readCodePushupConfig,
+  upload
+};