@code-pushup/ci 0.56.0 → 0.58.0

package/index.js

@@ -1,1742 +0,0 @@
-// packages/ci/src/lib/monorepo/list-projects.ts
-import { glob as glob2 } from "glob";
-import { join as join7 } from "node:path";
-
-// packages/ci/src/lib/monorepo/handlers/npm.ts
-import { join as join2 } from "node:path";
-
-// packages/models/src/lib/implementation/schemas.ts
-import { MATERIAL_ICONS } from "vscode-material-icons";
-import { z } from "zod";
-
-// packages/models/src/lib/implementation/limits.ts
-var MAX_SLUG_LENGTH = 128;
-var MAX_TITLE_LENGTH = 256;
-var MAX_DESCRIPTION_LENGTH = 65536;
-var MAX_ISSUE_MESSAGE_LENGTH = 1024;
-
-// packages/models/src/lib/implementation/utils.ts
-var slugRegex = /^[a-z\d]+(?:-[a-z\d]+)*$/;
-var filenameRegex = /^(?!.*[ \\/:*?"<>|]).+$/;
-function hasDuplicateStrings(strings) {
-  const sortedStrings = strings.toSorted();
-  const duplStrings = sortedStrings.filter(
-    (item, index) => index !== 0 && item === sortedStrings[index - 1]
-  );
-  return duplStrings.length === 0 ? false : [...new Set(duplStrings)];
-}
-function hasMissingStrings(toCheck, existing) {
-  const nonExisting = toCheck.filter((s) => !existing.includes(s));
-  return nonExisting.length === 0 ? false : nonExisting;
-}
-function errorItems(items, transform = (itemArr) => itemArr.join(", ")) {
-  return transform(items || []);
-}
-function exists(value) {
-  return value != null;
-}
-function getMissingRefsForCategories(categories, plugins) {
-  if (!categories || categories.length === 0) {
-    return false;
-  }
-  const auditRefsFromCategory = categories.flatMap(
-    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
-  );
-  const auditRefsFromPlugins = plugins.flatMap(
-    ({ audits, slug: pluginSlug }) => audits.map(({ slug }) => `${pluginSlug}/${slug}`)
-  );
-  const missingAuditRefs = hasMissingStrings(
-    auditRefsFromCategory,
-    auditRefsFromPlugins
-  );
-  const groupRefsFromCategory = categories.flatMap(
-    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
-  );
-  const groupRefsFromPlugins = plugins.flatMap(
-    ({ groups, slug: pluginSlug }) => Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : []
-  );
-  const missingGroupRefs = hasMissingStrings(
-    groupRefsFromCategory,
-    groupRefsFromPlugins
-  );
-  const missingRefs = [missingAuditRefs, missingGroupRefs].filter((refs) => Array.isArray(refs) && refs.length > 0).flat();
-  return missingRefs.length > 0 ? missingRefs : false;
-}
-function missingRefsForCategoriesErrorMsg(categories, plugins) {
-  const missingRefs = getMissingRefsForCategories(categories, plugins);
-  return `The following category references need to point to an audit or group: ${errorItems(
-    missingRefs
-  )}`;
-}
-
-// packages/models/src/lib/implementation/schemas.ts
-var tableCellValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]).default(null);
-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 })
-  });
-}
-var slugSchema = z.string({ description: "Unique ID (human-readable, URL-safe)" }).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(MAX_SLUG_LENGTH, {
-  message: `slug can be max ${MAX_SLUG_LENGTH} characters long`
-});
-var descriptionSchema = z.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
-var urlSchema = z.string().url();
-var docsUrlSchema = urlSchema.optional().or(z.literal("")).describe("Documentation site");
-var titleSchema = z.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
-var scoreSchema = z.number({
-  description: "Value between 0 and 1"
-}).min(0).max(1);
-function metaSchema(options) {
-  const {
-    descriptionDescription,
-    titleDescription,
-    docsUrlDescription,
-    description
-  } = options ?? {};
-  return z.object(
-    {
-      title: titleDescription ? titleSchema.describe(titleDescription) : titleSchema,
-      description: descriptionDescription ? descriptionSchema.describe(descriptionDescription) : descriptionSchema,
-      docsUrl: docsUrlDescription ? docsUrlSchema.describe(docsUrlDescription) : docsUrlSchema
-    },
-    { description }
-  );
-}
-var filePathSchema = z.string().trim().min(1, { message: "path is invalid" });
-var fileNameSchema = z.string().trim().regex(filenameRegex, {
-  message: `The filename has to be valid`
-}).min(1, { message: "file name is invalid" });
-var positiveIntSchema = z.number().int().positive();
-var nonnegativeNumberSchema = z.number().nonnegative();
-function packageVersionSchema(options) {
-  const { versionDescription = "NPM version of the package", required } = options ?? {};
-  const packageSchema = z.string({ description: "NPM package name" });
-  const versionSchema = z.string({ description: versionDescription });
-  return z.object(
-    {
-      packageName: required ? packageSchema : packageSchema.optional(),
-      version: required ? versionSchema : versionSchema.optional()
-    },
-    { description: "NPM package name and version of a published package" }
-  );
-}
-var weightSchema = nonnegativeNumberSchema.describe(
-  "Coefficient for the given score (use weight 0 if only for display)"
-);
-function weightedRefSchema(description, slugDescription) {
-  return z.object(
-    {
-      slug: slugSchema.describe(slugDescription),
-      weight: weightSchema.describe("Weight used to calculate score")
-    },
-    { description }
-  );
-}
-function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
-  return z.object(
-    {
-      slug: slugSchema.describe('Human-readable unique ID, e.g. "performance"'),
-      refs: z.array(refSchema).min(1).refine(
-        (refs) => !duplicateCheckFn(refs),
-        (refs) => ({
-          message: duplicateMessageFn(refs)
-        })
-      ).refine(hasNonZeroWeightedRef, () => ({
-        message: "In a category there has to be at least one ref with weight > 0"
-      }))
-    },
-    { description }
-  );
-}
-var materialIconSchema = z.enum(MATERIAL_ICONS, {
-  description: "Icon from VSCode Material Icons extension"
-});
-function hasNonZeroWeightedRef(refs) {
-  return refs.reduce((acc, { weight }) => weight + acc, 0) !== 0;
-}
-
-// packages/models/src/lib/source.ts
-import { z as z2 } from "zod";
-var sourceFileLocationSchema = z2.object(
-  {
-    file: filePathSchema.describe("Relative path to source file in Git repo"),
-    position: z2.object(
-      {
-        startLine: positiveIntSchema.describe("Start line"),
-        startColumn: positiveIntSchema.describe("Start column").optional(),
-        endLine: positiveIntSchema.describe("End line").optional(),
-        endColumn: positiveIntSchema.describe("End column").optional()
-      },
-      { description: "Location in file" }
-    ).optional()
-  },
-  { description: "Source file location" }
-);
-
-// packages/models/src/lib/audit.ts
-import { z as z3 } from "zod";
-var auditSchema = z3.object({
-  slug: slugSchema.describe("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 = z3.array(auditSchema, {
-  description: "List of audits maintained in a plugin"
-}).min(1).refine(
-  (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
-  (auditMetadata) => ({
-    message: duplicateSlugsInAuditsErrorMsg(auditMetadata)
-  })
-);
-function duplicateSlugsInAuditsErrorMsg(audits) {
-  const duplicateRefs = getDuplicateSlugsInAudits(audits);
-  return `In plugin audits the following slugs are not unique: ${errorItems(
-    duplicateRefs
-  )}`;
-}
-function getDuplicateSlugsInAudits(audits) {
-  return hasDuplicateStrings(audits.map(({ slug }) => slug));
-}
-
-// packages/models/src/lib/audit-output.ts
-import { z as z6 } from "zod";
-
-// packages/models/src/lib/issue.ts
-import { z as z4 } from "zod";
-var issueSeveritySchema = z4.enum(["info", "warning", "error"], {
-  description: "Severity level"
-});
-var issueSchema = z4.object(
-  {
-    message: z4.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
-    severity: issueSeveritySchema,
-    source: sourceFileLocationSchema.optional()
-  },
-  { description: "Issue information" }
-);
-
-// packages/models/src/lib/table.ts
-import { z as z5 } from "zod";
-var tableAlignmentSchema = z5.enum(["left", "center", "right"], {
-  description: "Cell alignment"
-});
-var tableColumnObjectSchema = z5.object({
-  key: z5.string(),
-  label: z5.string().optional(),
-  align: tableAlignmentSchema.optional()
-});
-var tableRowObjectSchema = z5.record(tableCellValueSchema, {
-  description: "Object row"
-});
-var tableRowPrimitiveSchema = z5.array(tableCellValueSchema, {
-  description: "Primitive row"
-});
-var tableSharedSchema = z5.object({
-  title: z5.string().optional().describe("Display title for table")
-});
-var tablePrimitiveSchema = tableSharedSchema.merge(
-  z5.object(
-    {
-      columns: z5.array(tableAlignmentSchema).optional(),
-      rows: z5.array(tableRowPrimitiveSchema)
-    },
-    { description: "Table with primitive rows and optional alignment columns" }
-  )
-);
-var tableObjectSchema = tableSharedSchema.merge(
-  z5.object(
-    {
-      columns: z5.union([
-        z5.array(tableAlignmentSchema),
-        z5.array(tableColumnObjectSchema)
-      ]).optional(),
-      rows: z5.array(tableRowObjectSchema)
-    },
-    {
-      description: "Table with object rows and optional alignment or object columns"
-    }
-  )
-);
-var tableSchema = (description = "Table information") => z5.union([tablePrimitiveSchema, tableObjectSchema], { description });
-
-// packages/models/src/lib/audit-output.ts
-var auditValueSchema = nonnegativeNumberSchema.describe("Raw numeric value");
-var auditDisplayValueSchema = z6.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
-var auditDetailsSchema = z6.object(
-  {
-    issues: z6.array(issueSchema, { description: "List of findings" }).optional(),
-    table: tableSchema("Table of related findings").optional()
-  },
-  { description: "Detailed information" }
-);
-var auditOutputSchema = z6.object(
-  {
-    slug: slugSchema.describe("Reference to audit"),
-    displayValue: auditDisplayValueSchema,
-    value: auditValueSchema,
-    score: scoreSchema,
-    details: auditDetailsSchema.optional()
-  },
-  { description: "Audit information" }
-);
-var auditOutputsSchema = z6.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/category-config.ts
-import { z as z7 } from "zod";
-var categoryRefSchema = weightedRefSchema(
-  "Weighted references to audits and/or groups for the category",
-  "Slug of an audit or group (depending on `type`)"
-).merge(
-  z7.object({
-    type: z7.enum(["audit", "group"], {
-      description: "Discriminant for reference kind, affects where `slug` is looked up"
-    }),
-    plugin: slugSchema.describe(
-      "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(
-  z7.object({
-    isBinary: z7.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}`)
-  );
-}
-var categoriesSchema = z7.array(categoryConfigSchema, {
-  description: "Categorization of individual audits"
-}).refine(
-  (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
-  (categoryCfg) => ({
-    message: duplicateSlugCategoriesErrorMsg(categoryCfg)
-  })
-);
-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/commit.ts
-import { z as z8 } from "zod";
-var commitSchema = z8.object(
-  {
-    hash: z8.string({ description: "Commit SHA (full)" }).regex(
-      /^[\da-f]{40}$/,
-      "Commit SHA should be a 40-character hexadecimal string"
-    ),
-    message: z8.string({ description: "Commit message" }),
-    date: z8.coerce.date({
-      description: "Date and time when commit was authored"
-    }),
-    author: z8.string({
-      description: "Commit author name"
-    }).trim()
-  },
-  { description: "Git commit" }
-);
-
-// packages/models/src/lib/core-config.ts
-import { z as z14 } from "zod";
-
-// packages/models/src/lib/persist-config.ts
-import { z as z9 } from "zod";
-var formatSchema = z9.enum(["json", "md"]);
-var persistConfigSchema = z9.object({
-  outputDir: filePathSchema.describe("Artifacts folder").optional(),
-  filename: fileNameSchema.describe("Artifacts file name (without extension)").optional(),
-  format: z9.array(formatSchema).optional()
-});
-
-// packages/models/src/lib/plugin-config.ts
-import { z as z12 } from "zod";
-
-// packages/models/src/lib/group.ts
-import { z as z10 } from "zod";
-var groupRefSchema = weightedRefSchema(
-  "Weighted reference to a group",
-  "Reference slug to a group within this plugin (e.g. 'max-lines')"
-);
-var groupMetaSchema = metaSchema({
-  titleDescription: "Descriptive name for the group",
-  descriptionDescription: "Description of the group (markdown)",
-  docsUrlDescription: "Group documentation site",
-  description: "Group metadata"
-});
-var groupSchema = scorableSchema(
-  'A 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',
-  groupRefSchema,
-  getDuplicateRefsInGroups,
-  duplicateRefsInGroupsErrorMsg
-).merge(groupMetaSchema);
-var groupsSchema = z10.array(groupSchema, {
-  description: "List of groups"
-}).optional().refine(
-  (groups) => !getDuplicateSlugsInGroups(groups),
-  (groups) => ({
-    message: duplicateSlugsInGroupsErrorMsg(groups)
-  })
-);
-function duplicateRefsInGroupsErrorMsg(groups) {
-  const duplicateRefs = getDuplicateRefsInGroups(groups);
-  return `In plugin groups the following references are not unique: ${errorItems(
-    duplicateRefs
-  )}`;
-}
-function getDuplicateRefsInGroups(groups) {
-  return hasDuplicateStrings(groups.map(({ slug: ref }) => ref).filter(exists));
-}
-function duplicateSlugsInGroupsErrorMsg(groups) {
-  const duplicateRefs = getDuplicateSlugsInGroups(groups);
-  return `In groups the following slugs are not unique: ${errorItems(
-    duplicateRefs
-  )}`;
-}
-function getDuplicateSlugsInGroups(groups) {
-  return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
-}
-
-// packages/models/src/lib/runner-config.ts
-import { z as z11 } from "zod";
-var outputTransformSchema = z11.function().args(z11.unknown()).returns(z11.union([auditOutputsSchema, z11.promise(auditOutputsSchema)]));
-var runnerConfigSchema = z11.object(
-  {
-    command: z11.string({
-      description: "Shell command to execute"
-    }),
-    args: z11.array(z11.string({ description: "Command arguments" })).optional(),
-    outputFile: filePathSchema.describe("Output path"),
-    outputTransform: outputTransformSchema.optional()
-  },
-  {
-    description: "How to execute runner"
-  }
-);
-var onProgressSchema = z11.function().args(z11.unknown()).returns(z11.void());
-var runnerFunctionSchema = z11.function().args(onProgressSchema.optional()).returns(z11.union([auditOutputsSchema, z11.promise(auditOutputsSchema)]));
-
-// packages/models/src/lib/plugin-config.ts
-var pluginMetaSchema = packageVersionSchema().merge(
-  metaSchema({
-    titleDescription: "Descriptive name",
-    descriptionDescription: "Description (markdown)",
-    docsUrlDescription: "Plugin documentation site",
-    description: "Plugin metadata"
-  })
-).merge(
-  z12.object({
-    slug: slugSchema.describe("Unique plugin slug within core config"),
-    icon: materialIconSchema
-  })
-);
-var pluginDataSchema = z12.object({
-  runner: z12.union([runnerConfigSchema, runnerFunctionSchema]),
-  audits: pluginAuditsSchema,
-  groups: groupsSchema
-});
-var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
-  (pluginCfg) => !getMissingRefsFromGroups(pluginCfg),
-  (pluginCfg) => ({
-    message: missingRefsFromGroupsErrorMsg(pluginCfg)
-  })
-);
-function missingRefsFromGroupsErrorMsg(pluginCfg) {
-  const missingRefs = getMissingRefsFromGroups(pluginCfg);
-  return `The following group references need to point to an existing audit in this plugin config: ${errorItems(
-    missingRefs
-  )}`;
-}
-function getMissingRefsFromGroups(pluginCfg) {
-  return hasMissingStrings(
-    pluginCfg.groups?.flatMap(
-      ({ refs: audits }) => audits.map(({ slug: ref }) => ref)
-    ) ?? [],
-    pluginCfg.audits.map(({ slug }) => slug)
-  );
-}
-
-// packages/models/src/lib/upload-config.ts
-import { z as z13 } from "zod";
-var uploadConfigSchema = z13.object({
-  server: urlSchema.describe("URL of deployed portal API"),
-  apiKey: z13.string({
-    description: "API key with write access to portal (use `process.env` for security)"
-  }),
-  organization: slugSchema.describe(
-    "Organization slug from Code PushUp portal"
-  ),
-  project: slugSchema.describe("Project slug from Code PushUp portal"),
-  timeout: z13.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
-});
-
-// packages/models/src/lib/core-config.ts
-var unrefinedCoreConfigSchema = z14.object({
-  plugins: z14.array(pluginConfigSchema, {
-    description: "List of plugins to be used (official, community-provided, or custom)"
-  }).min(1),
-  /** portal configuration for persisting results */
-  persist: persistConfigSchema.optional(),
-  /** portal configuration for uploading results */
-  upload: uploadConfigSchema.optional(),
-  categories: categoriesSchema.optional()
-});
-var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
-function refineCoreConfig(schema) {
-  return schema.refine(
-    ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
-    ({ categories, plugins }) => ({
-      message: missingRefsForCategoriesErrorMsg(categories, plugins)
-    })
-  );
-}
-
-// packages/models/src/lib/implementation/constants.ts
-var DEFAULT_PERSIST_OUTPUT_DIR = ".code-pushup";
-var DEFAULT_PERSIST_FILENAME = "report";
-var DEFAULT_PERSIST_FORMAT = ["json", "md"];
-
-// packages/models/src/lib/report.ts
-import { z as z15 } 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(
-  z15.object({
-    audits: z15.array(auditReportSchema).min(1),
-    groups: z15.array(groupSchema).optional()
-  })
-).refine(
-  (pluginReport) => !getMissingRefsFromGroups2(pluginReport.audits, pluginReport.groups ?? []),
-  (pluginReport) => ({
-    message: missingRefsFromGroupsErrorMsg2(
-      pluginReport.audits,
-      pluginReport.groups ?? []
-    )
-  })
-);
-function missingRefsFromGroupsErrorMsg2(audits, groups) {
-  const missingRefs = getMissingRefsFromGroups2(audits, groups);
-  return `group references need to point to an existing audit in this plugin report: ${errorItems(
-    missingRefs
-  )}`;
-}
-function getMissingRefsFromGroups2(audits, groups) {
-  return hasMissingStrings(
-    groups.flatMap(
-      ({ refs: auditRefs }) => auditRefs.map(({ slug: ref }) => ref)
-    ),
-    audits.map(({ slug }) => slug)
-  );
-}
-var reportSchema = packageVersionSchema({
-  versionDescription: "NPM version of the CLI",
-  required: true
-}).merge(
-  executionMetaSchema({
-    descriptionDate: "Start date and time of the collect run",
-    descriptionDuration: "Duration of the collect run in ms"
-  })
-).merge(
-  z15.object(
-    {
-      plugins: z15.array(pluginReportSchema).min(1),
-      categories: z15.array(categoryConfigSchema).optional(),
-      commit: commitSchema.describe("Git commit for which report was collected").nullable()
-    },
-    { description: "Collect output data" }
-  )
-).refine(
-  ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
-  ({ categories, plugins }) => ({
-    message: missingRefsForCategoriesErrorMsg(categories, plugins)
-  })
-);
-
-// packages/models/src/lib/reports-diff.ts
-import { z as z16 } from "zod";
-function makeComparisonSchema(schema) {
-  const sharedDescription = schema.description || "Result";
-  return z16.object({
-    before: schema.describe(`${sharedDescription} (source commit)`),
-    after: schema.describe(`${sharedDescription} (target commit)`)
-  });
-}
-function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
-  return z16.object(
-    {
-      changed: z16.array(diffSchema),
-      unchanged: z16.array(resultSchema),
-      added: z16.array(resultSchema),
-      removed: z16.array(resultSchema)
-    },
-    { description }
-  );
-}
-var scorableMetaSchema = z16.object({
-  slug: slugSchema,
-  title: titleSchema,
-  docsUrl: docsUrlSchema
-});
-var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
-  z16.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
-  })
-);
-var scorableDiffSchema = scorableMetaSchema.merge(
-  z16.object({
-    scores: makeComparisonSchema(scoreSchema).merge(
-      z16.object({
-        diff: z16.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
-      })
-    ).describe("Score comparison")
-  })
-);
-var scorableWithPluginDiffSchema = scorableDiffSchema.merge(
-  scorableWithPluginMetaSchema
-);
-var categoryDiffSchema = scorableDiffSchema;
-var groupDiffSchema = scorableWithPluginDiffSchema;
-var auditDiffSchema = scorableWithPluginDiffSchema.merge(
-  z16.object({
-    values: makeComparisonSchema(auditValueSchema).merge(
-      z16.object({
-        diff: z16.number().describe("Value change (`values.after - values.before`)")
-      })
-    ).describe("Audit `value` comparison"),
-    displayValues: makeComparisonSchema(auditDisplayValueSchema).describe(
-      "Audit `displayValue` comparison"
-    )
-  })
-);
-var categoryResultSchema = scorableMetaSchema.merge(
-  z16.object({ score: scoreSchema })
-);
-var groupResultSchema = scorableWithPluginMetaSchema.merge(
-  z16.object({ score: scoreSchema })
-);
-var auditResultSchema = scorableWithPluginMetaSchema.merge(
-  auditOutputSchema.pick({ score: true, value: true, displayValue: true })
-);
-var reportsDiffSchema = z16.object({
-  commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
-  portalUrl: urlSchema.optional().describe("Link to comparison page in Code PushUp portal"),
-  label: z16.string().optional().describe("Label (e.g. project name)"),
-  categories: makeArraysComparisonSchema(
-    categoryDiffSchema,
-    categoryResultSchema,
-    "Changes affecting categories"
-  ),
-  groups: makeArraysComparisonSchema(
-    groupDiffSchema,
-    groupResultSchema,
-    "Changes affecting groups"
-  ),
-  audits: makeArraysComparisonSchema(
-    auditDiffSchema,
-    auditResultSchema,
-    "Changes affecting audits"
-  )
-}).merge(
-  packageVersionSchema({
-    versionDescription: "NPM version of the CLI (when `compare` was run)",
-    required: true
-  })
-).merge(
-  executionMetaSchema({
-    descriptionDate: "Start date and time of the compare run",
-    descriptionDuration: "Duration of the compare run in ms"
-  })
-);
-
-// packages/utils/src/lib/errors.ts
-function stringifyError(error) {
-  if (error instanceof Error) {
-    if (error.name === "Error" || error.message.startsWith(error.name)) {
-      return error.message;
-    }
-    return `${error.name}: ${error.message}`;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return JSON.stringify(error);
-}
-
-// packages/utils/src/lib/execute-process.ts
-import {
-  spawn
-} from "node:child_process";
-
-// packages/utils/src/lib/reports/utils.ts
-import ansis from "ansis";
-import { md } from "build-md";
-function calcDuration(start, stop) {
-  return Math.round((stop ?? performance.now()) - start);
-}
-
-// 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 { command, args, observer, ignoreExitCode = false, ...options } = cfg;
-  const { onStdout, onStderr, onError, onComplete } = observer ?? {};
-  const date = (/* @__PURE__ */ new Date()).toISOString();
-  const start = performance.now();
-  return new Promise((resolve, reject) => {
-    const spawnedProcess = spawn(command, args ?? [], {
-      shell: true,
-      windowsHide: true,
-      ...options
-    });
-    let stdout = "";
-    let stderr = "";
-    spawnedProcess.stdout.on("data", (data) => {
-      stdout += String(data);
-      onStdout?.(String(data), spawnedProcess);
-    });
-    spawnedProcess.stderr.on("data", (data) => {
-      stderr += String(data);
-      onStderr?.(String(data), spawnedProcess);
-    });
-    spawnedProcess.on("error", (err) => {
-      stderr += err.toString();
-    });
-    spawnedProcess.on("close", (code2) => {
-      const timings = { date, duration: calcDuration(start) };
-      if (code2 === 0 || ignoreExitCode) {
-        onComplete?.();
-        resolve({ code: code2, stdout, stderr, ...timings });
-      } else {
-        const errorMsg = new ProcessError({ code: code2, stdout, stderr, ...timings });
-        onError?.(errorMsg);
-        reject(errorMsg);
-      }
-    });
-  });
-}
-
-// packages/utils/src/lib/file-system.ts
-import { bold, gray } from "ansis";
-import { bundleRequire } from "bundle-require";
-import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-
-// packages/utils/src/lib/logging.ts
-import isaacs_cliui from "@isaacs/cliui";
-import { cliui } from "@poppinss/cliui";
-import { underline } from "ansis";
-
-// packages/utils/src/lib/file-system.ts
-async function readTextFile(path3) {
-  const buffer = await readFile(path3);
-  return buffer.toString();
-}
-async function readJsonFile(path3) {
-  const text = await readTextFile(path3);
-  return JSON.parse(text);
-}
-async function fileExists(path3) {
-  try {
-    const stats = await stat(path3);
-    return stats.isFile();
-  } catch {
-    return false;
-  }
-}
-function projectToFilename(project) {
-  return project.replace(/[/\\\s]+/g, "-").replace(/@/g, "");
-}
-
-// packages/utils/src/lib/git/git.ts
-import { simpleGit } from "simple-git";
-
-// packages/utils/src/lib/transform.ts
-function toArray(val) {
-  return Array.isArray(val) ? val : [val];
-}
-
-// packages/utils/src/lib/git/git.commits-and-tags.ts
-import { simpleGit as simpleGit2 } from "simple-git";
-
-// packages/utils/src/lib/semver.ts
-import { rcompare, valid } from "semver";
-
-// packages/utils/src/lib/progress.ts
-import { black, bold as bold2, gray as gray2, green } from "ansis";
-import { MultiProgressBars } from "multi-progress-bars";
-
-// packages/utils/src/lib/reports/generate-md-report.ts
-import { MarkdownDocument as MarkdownDocument3, md as md4 } from "build-md";
-
-// packages/utils/src/lib/reports/formatting.ts
-import {
-  MarkdownDocument,
-  md as md2
-} from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
-import { MarkdownDocument as MarkdownDocument2, md as md3 } from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-reports-diff.ts
-import {
-  MarkdownDocument as MarkdownDocument5,
-  md as md6
-} from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts
-import { MarkdownDocument as MarkdownDocument4, md as md5 } from "build-md";
-
-// packages/utils/src/lib/reports/log-stdout-summary.ts
-import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
-
-// packages/ci/src/lib/monorepo/packages.ts
-import { glob } from "glob";
-import { basename, dirname, join } from "node:path";
-async function listPackages(cwd, patterns = ["**"]) {
-  const files = await glob(
-    patterns.map((pattern) => pattern.replace(/\/?$/, "/package.json")),
-    { cwd }
-  );
-  return Promise.all(
-    files.toSorted().map(async (file) => {
-      const packageJson = await readJsonFile(join(cwd, file));
-      const directory = join(cwd, dirname(file));
-      const name = packageJson.name || basename(directory);
-      return { name, directory, packageJson };
-    })
-  );
-}
-async function listWorkspaces(cwd) {
-  const rootPackageJson = await readRootPackageJson(cwd);
-  const patterns = Array.isArray(rootPackageJson.workspaces) ? rootPackageJson.workspaces : rootPackageJson.workspaces?.packages;
-  return {
-    workspaces: await listPackages(cwd, patterns),
-    rootPackageJson
-  };
-}
-async function hasWorkspacesEnabled(cwd) {
-  const packageJson = await readRootPackageJson(cwd);
-  if (!packageJson.private) {
-    return false;
-  }
-  if (Array.isArray(packageJson.workspaces)) {
-    return packageJson.workspaces.length > 0;
-  }
-  if (typeof packageJson.workspaces === "object") {
-    return Boolean(packageJson.workspaces.packages?.length);
-  }
-  return false;
-}
-async function readRootPackageJson(cwd) {
-  return await readJsonFile(join(cwd, "package.json"));
-}
-function hasDependency(packageJson, name) {
-  const { dependencies = {}, devDependencies = {} } = packageJson;
-  return name in devDependencies || name in dependencies;
-}
-function hasScript(packageJson, script) {
-  const { scripts = {} } = packageJson;
-  return script in scripts;
-}
-function hasCodePushUpDependency(packageJson) {
-  return hasDependency(packageJson, "@code-pushup/cli");
-}
-
-// packages/ci/src/lib/monorepo/handlers/npm.ts
-var npmHandler = {
-  tool: "npm",
-  async isConfigured(options) {
-    return await fileExists(join2(options.cwd, "package-lock.json")) && await hasWorkspacesEnabled(options.cwd);
-  },
-  async listProjects(options) {
-    const { workspaces, rootPackageJson } = await listWorkspaces(options.cwd);
-    return workspaces.filter(
-      ({ packageJson }) => hasScript(packageJson, options.task) || hasCodePushUpDependency(packageJson) || hasCodePushUpDependency(rootPackageJson)
-    ).map(({ name, packageJson }) => ({
-      name,
-      bin: hasScript(packageJson, options.task) ? `npm -w ${name} run ${options.task} --` : `npm -w ${name} exec ${options.task} --`
-    }));
-  }
-};
-
-// packages/ci/src/lib/monorepo/handlers/nx.ts
-import { join as join3 } from "node:path";
-var nxHandler = {
-  tool: "nx",
-  async isConfigured(options) {
-    return await fileExists(join3(options.cwd, "nx.json")) && (await executeProcess({
-      command: "npx",
-      args: ["nx", "report"],
-      cwd: options.cwd,
-      observer: options.observer
-    })).code === 0;
-  },
-  async listProjects(options) {
-    const { stdout } = await executeProcess({
-      command: "npx",
-      args: [
-        "nx",
-        "show",
-        "projects",
-        ...toArray(options.nxProjectsFilter).map(
-          (arg) => arg.replaceAll("{task}", options.task)
-        ),
-        "--json"
-      ],
-      cwd: options.cwd,
-      observer: options.observer
-    });
-    const projects = parseProjects(stdout);
-    return projects.map((project) => ({
-      name: project,
-      bin: `npx nx run ${project}:${options.task} --`
-    }));
-  }
-};
-function parseProjects(stdout) {
-  let json;
-  try {
-    json = JSON.parse(stdout);
-  } catch (error) {
-    throw new Error(
-      `Invalid non-JSON output from 'nx show projects' - ${stringifyError(
-        error
-      )}`
-    );
-  }
-  if (Array.isArray(json) && json.every((item) => typeof item === "string")) {
-    return json;
-  }
-  throw new Error(
-    `Invalid JSON output from 'nx show projects', expected array of strings, received ${JSON.stringify(
-      json
-    )}`
-  );
-}
-
-// packages/ci/src/lib/monorepo/handlers/pnpm.ts
-import { join as join4 } from "node:path";
-import * as YAML from "yaml";
-var WORKSPACE_FILE = "pnpm-workspace.yaml";
-var pnpmHandler = {
-  tool: "pnpm",
-  async isConfigured(options) {
-    return await fileExists(join4(options.cwd, WORKSPACE_FILE)) && await fileExists(join4(options.cwd, "package.json"));
-  },
-  async listProjects(options) {
-    const yaml = await readTextFile(join4(options.cwd, WORKSPACE_FILE));
-    const workspace = YAML.parse(yaml);
-    const packages = await listPackages(options.cwd, workspace.packages);
-    const rootPackageJson = await readRootPackageJson(options.cwd);
-    return packages.filter(
-      ({ packageJson }) => hasScript(packageJson, options.task) || hasCodePushUpDependency(packageJson) || hasCodePushUpDependency(rootPackageJson)
-    ).map(({ name, packageJson }) => ({
-      name,
-      bin: hasScript(packageJson, options.task) ? `pnpm -F ${name} run ${options.task}` : `pnpm -F ${name} exec ${options.task}`
-    }));
-  }
-};
-
-// packages/ci/src/lib/monorepo/handlers/turbo.ts
-import { join as join6 } from "node:path";
-
-// packages/ci/src/lib/monorepo/handlers/yarn.ts
-import { join as join5 } from "node:path";
-var yarnHandler = {
-  tool: "yarn",
-  async isConfigured(options) {
-    return await fileExists(join5(options.cwd, "yarn.lock")) && await hasWorkspacesEnabled(options.cwd);
-  },
-  async listProjects(options) {
-    const { workspaces, rootPackageJson } = await listWorkspaces(options.cwd);
-    return workspaces.filter(
-      ({ packageJson }) => hasScript(packageJson, options.task) || hasCodePushUpDependency(packageJson) || hasCodePushUpDependency(rootPackageJson)
-    ).map(({ name, packageJson }) => ({
-      name,
-      bin: hasScript(packageJson, options.task) ? `yarn workspace ${name} run ${options.task}` : `yarn workspace ${name} exec ${options.task}`
-    }));
-  }
-};
-
-// packages/ci/src/lib/monorepo/handlers/turbo.ts
-var WORKSPACE_HANDLERS = [pnpmHandler, yarnHandler, npmHandler];
-var turboHandler = {
-  tool: "turbo",
-  async isConfigured(options) {
-    const configPath = join6(options.cwd, "turbo.json");
-    return await fileExists(configPath) && options.task in (await readJsonFile(configPath)).tasks;
-  },
-  async listProjects(options) {
-    for (const handler of WORKSPACE_HANDLERS) {
-      if (await handler.isConfigured(options)) {
-        const projects = await handler.listProjects(options);
-        return projects.filter(({ bin }) => bin.includes(`run ${options.task}`)).map(({ name }) => ({
-          name,
-          bin: `npx turbo run ${options.task} -F ${name} --`
-        }));
-      }
-    }
-    throw new Error(
-      `Package manager for Turborepo not found, expected one of ${WORKSPACE_HANDLERS.map(
-        ({ tool }) => tool
-      ).join("/")}`
-    );
-  }
-};
-
-// packages/ci/src/lib/monorepo/handlers/index.ts
-var MONOREPO_TOOL_HANDLERS = [
-  nxHandler,
-  turboHandler,
-  yarnHandler,
-  pnpmHandler,
-  npmHandler
-];
-function getToolHandler(tool) {
-  const matchedHandler = MONOREPO_TOOL_HANDLERS.find(
-    (handler) => handler.tool === tool
-  );
-  if (!matchedHandler) {
-    throw new Error(`No handler available for monorepo tool "${tool}"`);
-  }
-  return matchedHandler;
-}
-
-// packages/ci/src/lib/monorepo/detect-tool.ts
-async function detectMonorepoTool(options) {
-  for (const handler of MONOREPO_TOOL_HANDLERS) {
-    if (await handler.isConfigured(options)) {
-      return handler.tool;
-    }
-  }
-  return null;
-}
-
-// packages/ci/src/lib/monorepo/list-projects.ts
-async function listMonorepoProjects(settings) {
-  if (!settings.monorepo) {
-    throw new Error("Monorepo mode not enabled");
-  }
-  const logger = settings.logger;
-  const options = createMonorepoHandlerOptions(settings);
-  const tool = settings.monorepo === true ? await detectMonorepoTool(options) : settings.monorepo;
-  if (settings.monorepo === true) {
-    if (tool) {
-      logger.info(`Auto-detected monorepo tool ${tool}`);
-    } else {
-      logger.info("Couldn't auto-detect any supported monorepo tool");
-    }
-  } else {
-    logger.info(`Using monorepo tool "${tool}" from inputs`);
-  }
-  if (tool) {
-    const handler = getToolHandler(tool);
-    const projects = await handler.listProjects(options);
-    logger.info(`Found ${projects.length} projects in ${tool} monorepo`);
-    logger.debug(`Projects: ${projects.map(({ name }) => name).join(", ")}`);
-    return projects;
-  }
-  if (settings.projects) {
-    return listProjectsByGlobs({
-      patterns: settings.projects,
-      cwd: options.cwd,
-      bin: settings.bin,
-      logger
-    });
-  }
-  return listProjectsByNpmPackages({
-    cwd: options.cwd,
-    bin: settings.bin,
-    logger
-  });
-}
-function createMonorepoHandlerOptions(settings) {
-  return {
-    task: settings.task,
-    cwd: settings.directory,
-    nxProjectsFilter: settings.nxProjectsFilter,
-    ...!settings.silent && {
-      observer: {
-        onStdout: (stdout) => {
-          console.info(stdout);
-        },
-        onStderr: (stderr) => {
-          console.warn(stderr);
-        }
-      }
-    }
-  };
-}
-async function listProjectsByGlobs(args) {
-  const { patterns, cwd, bin, logger } = args;
-  const directories = await glob2(
-    patterns.map((path3) => path3.replace(/\/$/, "/")),
-    { cwd }
-  );
-  logger.info(
-    `Found ${directories.length} project folders matching "${patterns.join(
-      ", "
-    )}" from configuration`
-  );
-  logger.debug(`Projects: ${directories.join(", ")}`);
-  return directories.toSorted().map((directory) => ({
-    name: directory,
-    bin,
-    directory: join7(cwd, directory)
-  }));
-}
-async function listProjectsByNpmPackages(args) {
-  const { cwd, bin, logger } = args;
-  const packages = await listPackages(cwd);
-  logger.info(`Found ${packages.length} NPM packages in repository`);
-  logger.debug(`Projects: ${packages.map(({ name }) => name).join(", ")}`);
-  return packages.map(({ name, directory }) => ({
-    name,
-    bin,
-    directory
-  }));
-}
-
-// packages/ci/src/lib/monorepo/tools.ts
-var MONOREPO_TOOLS = ["nx", "turbo", "yarn", "pnpm", "npm"];
-function isMonorepoTool(value) {
-  return MONOREPO_TOOLS.includes(value);
-}
-
-// packages/ci/src/lib/run.ts
-import fs from "node:fs/promises";
-import path2 from "node:path";
-import { simpleGit as simpleGit4 } from "simple-git";
-
-// packages/ci/src/lib/cli/persist.ts
-import path from "node:path";
-function persistCliOptions({
-  directory,
-  project,
-  output
-}) {
-  return [
-    `--persist.outputDir=${path.join(directory, output)}`,
-    `--persist.filename=${createFilename(project)}`,
-    ...DEFAULT_PERSIST_FORMAT.map((format) => `--persist.format=${format}`)
-  ];
-}
-function persistedCliFiles({
-  directory,
-  isDiff,
-  project,
-  formats,
-  output
-}) {
-  const rootDir = path.join(directory, output);
-  const filename = isDiff ? `${createFilename(project)}-diff` : createFilename(project);
-  const filePaths = (formats ?? DEFAULT_PERSIST_FORMAT).reduce(
-    (acc, format) => ({
-      ...acc,
-      [`${format}FilePath`]: path.join(rootDir, `${filename}.${format}`)
-    }),
-    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter, @typescript-eslint/consistent-type-assertions
-    {}
-  );
-  const files = Object.values(filePaths);
-  return {
-    ...filePaths,
-    artifactData: {
-      rootDir,
-      files
-    }
-  };
-}
-function createFilename(project) {
-  if (!project) {
-    return DEFAULT_PERSIST_FILENAME;
-  }
-  const prefix = projectToFilename(project);
-  return `${prefix}-${DEFAULT_PERSIST_FILENAME}`;
-}
-
-// packages/ci/src/lib/cli/commands/collect.ts
-async function runCollect({
-  bin,
-  config,
-  directory,
-  silent,
-  project,
-  output
-}) {
-  const { stdout } = await executeProcess({
-    command: bin,
-    args: [
-      ...config ? [`--config=${config}`] : [],
-      ...persistCliOptions({ directory, project, output })
-    ],
-    cwd: directory
-  });
-  if (!silent) {
-    console.info(stdout);
-  }
-  return persistedCliFiles({ directory, project, output });
-}
-
-// packages/ci/src/lib/cli/commands/compare.ts
-async function runCompare({ before, after, label }, { bin, config, directory, silent, project, output }) {
-  const { stdout } = await executeProcess({
-    command: bin,
-    args: [
-      "compare",
-      `--before=${before}`,
-      `--after=${after}`,
-      ...label ? [`--label=${label}`] : [],
-      ...config ? [`--config=${config}`] : [],
-      ...persistCliOptions({ directory, project, output })
-    ],
-    cwd: directory
-  });
-  if (!silent) {
-    console.info(stdout);
-  }
-  return persistedCliFiles({ directory, isDiff: true, project, output });
-}
-
-// packages/ci/src/lib/cli/commands/merge-diffs.ts
-async function runMergeDiffs(files, { bin, config, directory, silent, output }) {
-  const { stdout } = await executeProcess({
-    command: bin,
-    args: [
-      "merge-diffs",
-      ...files.map((file) => `--files=${file}`),
-      ...config ? [`--config=${config}`] : [],
-      ...persistCliOptions({ directory, output })
-    ],
-    cwd: directory
-  });
-  if (!silent) {
-    console.info(stdout);
-  }
-  return persistedCliFiles({
-    directory,
-    isDiff: true,
-    formats: ["md"],
-    output
-  });
-}
-
-// packages/ci/src/lib/cli/commands/print-config.ts
-async function runPrintConfig({
-  bin,
-  config,
-  directory,
-  silent
-}) {
-  const { stdout } = await executeProcess({
-    command: bin,
-    args: [...config ? [`--config=${config}`] : [], "print-config"],
-    cwd: directory
-  });
-  if (!silent) {
-    console.info(stdout);
-  }
-}
-
-// packages/ci/src/lib/cli/context.ts
-function createCommandContext(settings, project) {
-  return {
-    project: project?.name,
-    bin: project?.bin ?? settings.bin,
-    directory: project?.directory ?? settings.directory,
-    config: settings.config,
-    silent: settings.silent,
-    output: settings.output.replaceAll("{project}", project?.name ?? "")
-  };
-}
-
-// packages/ci/src/lib/comment.ts
-import { readFile as readFile2 } from "node:fs/promises";
-async function commentOnPR(mdPath, api, logger) {
-  const markdown = await readFile2(mdPath, "utf8");
-  const identifier = `<!-- generated by @code-pushup/ci -->`;
-  const body = truncateBody(
-    `${markdown}
-
-${identifier}
-`,
-    api.maxCommentChars,
-    logger
-  );
-  const comments = await api.listComments();
-  logger.debug(`Fetched ${comments.length} comments for pull request`);
-  const prevComment = comments.find(
-    (comment) => comment.body.includes(identifier)
-  );
-  logger.debug(
-    prevComment ? `Found previous comment ${prevComment.id} from Code PushUp` : "Previous Code PushUp comment not found"
-  );
-  if (prevComment) {
-    const updatedComment = await api.updateComment(prevComment.id, body);
-    logger.info(`Updated body of comment ${updatedComment.url}`);
-    return updatedComment.id;
-  }
-  const createdComment = await api.createComment(body);
-  logger.info(`Created new comment ${createdComment.url}`);
-  return createdComment.id;
-}
-function truncateBody(body, max, logger) {
-  const truncateWarning = "...*[Comment body truncated]*";
-  if (body.length > max) {
-    logger.warn(`Comment body is too long. Truncating to ${max} characters.`);
-    return body.slice(0, max - truncateWarning.length) + truncateWarning;
-  }
-  return body;
-}
-
-// packages/ci/src/lib/constants.ts
-var DEFAULT_SETTINGS = {
-  monorepo: false,
-  projects: null,
-  task: "code-pushup",
-  bin: "npx --no-install code-pushup",
-  config: null,
-  directory: process.cwd(),
-  silent: false,
-  debug: false,
-  detectNewIssues: true,
-  logger: console,
-  output: DEFAULT_PERSIST_OUTPUT_DIR,
-  nxProjectsFilter: "--with-target={task}"
-};
-
-// packages/ci/src/lib/git.ts
-import { DiffNameStatus, simpleGit as simpleGit3 } from "simple-git";
-async function listChangedFiles(refs, git = simpleGit3()) {
-  const statuses = [
-    DiffNameStatus.ADDED,
-    DiffNameStatus.COPIED,
-    DiffNameStatus.MODIFIED,
-    DiffNameStatus.RENAMED
-  ];
-  const { files } = await git.diffSummary([
-    refs.base,
-    refs.head,
-    `--diff-filter=${statuses.join("")}`,
-    "--find-renames",
-    "--find-copies"
-  ]);
-  const entries = await Promise.all(
-    files.filter(({ binary }) => !binary).map(({ file }) => {
-      const rename = parseFileRename(file);
-      if (rename) {
-        return { file: rename.curr, originalFile: rename.prev };
-      }
-      return { file };
-    }).map(async ({ file, originalFile }) => {
-      const diff = await git.diff([
-        "--unified=0",
-        refs.base,
-        refs.head,
-        "--",
-        file,
-        ...originalFile ? [originalFile] : []
-      ]);
-      const lineChanges = parseDiff(diff);
-      return [
-        file,
-        { ...originalFile && { originalFile }, lineChanges }
-      ];
-    })
-  );
-  return Object.fromEntries(entries);
-}
-function parseFileRename(file) {
-  const partialRenameMatch = file.match(/^(.*){(.*) => (.*)}(.*)$/);
-  if (partialRenameMatch) {
-    const [, prefix = "", prev, curr, suffix] = partialRenameMatch;
-    return {
-      prev: prefix + prev + suffix,
-      curr: prefix + curr + suffix
-    };
-  }
-  const fullRenameMatch = file.match(/^(.*) => (.*)$/);
-  if (fullRenameMatch) {
-    const [, prev = "", curr = ""] = fullRenameMatch;
-    return { prev, curr };
-  }
-  return null;
-}
-function parseDiff(diff) {
-  const changeSummaries = diff.match(/@@ [ \d,+-]+ @@/g);
-  if (changeSummaries == null) {
-    return [];
-  }
-  return changeSummaries.map((summary) => summary.match(/^@@ -(\d+|\d+,\d+) \+(\d+|\d+,\d+) @@$/)).filter((matches) => matches != null).map((matches) => {
-    const [prevLine = "", prevAdded = "1"] = matches[1].split(",");
-    const [currLine = "", currAdded = "1"] = matches[2].split(",");
-    return {
-      prev: {
-        line: Number.parseInt(prevLine, 10),
-        count: Number.parseInt(prevAdded, 10)
-      },
-      curr: {
-        line: Number.parseInt(currLine, 10),
-        count: Number.parseInt(currAdded, 10)
-      }
-    };
-  });
-}
-function isFileChanged(changedFiles, file) {
-  return file in changedFiles;
-}
-function adjustFileName(changedFiles, file) {
-  return Object.entries(changedFiles).find(
-    ([, { originalFile }]) => originalFile === file
-  )?.[0] ?? file;
-}
-function adjustLine(changedFiles, file, line) {
-  const changedFile = changedFiles[adjustFileName(changedFiles, file)];
-  if (!changedFile) {
-    return line;
-  }
-  const offset = changedFile.lineChanges.filter(({ prev }) => prev.line < line).reduce((acc, { prev, curr }) => acc + (curr.count - prev.count), 0);
-  return line + offset;
-}
-
-// packages/ci/src/lib/issues.ts
-function filterRelevantIssues({
-  currReport,
-  prevReport,
-  reportsDiff,
-  changedFiles
-}) {
-  const auditsWithPlugin = [
-    ...reportsDiff.audits.changed,
-    ...reportsDiff.audits.added
-  ].map((auditLink) => {
-    const plugin = currReport.plugins.find(
-      ({ slug }) => slug === auditLink.plugin.slug
-    );
-    const audit = plugin?.audits.find(({ slug }) => slug === auditLink.slug);
-    return plugin && audit && [plugin, audit];
-  }).filter((ctx) => ctx != null);
-  const issues = auditsWithPlugin.flatMap(
-    ([plugin, audit]) => getAuditIssues(audit, plugin)
-  );
-  const prevIssues = prevReport.plugins.flatMap(
-    (plugin) => plugin.audits.flatMap((audit) => getAuditIssues(audit, plugin))
-  );
-  return issues.filter(
-    (issue) => isFileChanged(changedFiles, issue.source.file) && !prevIssues.some(
-      (prevIssue) => issuesMatch(prevIssue, issue, changedFiles)
-    )
-  ).sort(createIssuesSortCompareFn(currReport));
-}
-function getAuditIssues(audit, plugin) {
-  return audit.details?.issues?.filter((issue) => issue.source?.file != null).map((issue) => ({ ...issue, audit, plugin })) ?? [];
-}
-function issuesMatch(prev, curr, changedFiles) {
-  return prev.plugin.slug === curr.plugin.slug && prev.audit.slug === curr.audit.slug && prev.severity === curr.severity && removeDigits(prev.message) === removeDigits(curr.message) && adjustFileName(changedFiles, prev.source.file) === curr.source.file && positionsMatch(prev.source, curr.source, changedFiles);
-}
-function removeDigits(message) {
-  return message.replace(/\d+/g, "");
-}
-function positionsMatch(prev, curr, changedFiles) {
-  if (!hasPosition(prev) || !hasPosition(curr)) {
-    return hasPosition(prev) === hasPosition(curr);
-  }
-  return adjustedStartLinesMatch(prev, curr, changedFiles) || adjustedLineSpansMatch(prev, curr, changedFiles);
-}
-function hasPosition(source) {
-  return source.position != null;
-}
-function adjustedStartLinesMatch(prev, curr, changedFiles) {
-  return adjustLine(changedFiles, prev.file, prev.position.startLine) === curr.position.startLine;
-}
-function adjustedLineSpansMatch(prev, curr, changedFiles) {
-  if (prev.position?.endLine == null || curr.position?.endLine == null) {
-    return false;
-  }
-  const prevLineCount = prev.position.endLine - prev.position.startLine;
-  const currLineCount = curr.position.endLine - curr.position.startLine;
-  const currStartLineOffset = adjustLine(changedFiles, curr.file, curr.position.startLine) - curr.position.startLine;
-  return prevLineCount === currLineCount - currStartLineOffset;
-}
-function createIssuesSortCompareFn(report) {
-  return (a, b) => getAuditImpactValue(b, report) - getAuditImpactValue(a, report);
-}
-function getAuditImpactValue({ audit, plugin }, report) {
-  if (!report.categories) {
-    return 0;
-  }
-  return report.categories.map((category) => {
-    const weights = category.refs.map((ref) => {
-      if (ref.plugin !== plugin.slug) {
-        return 0;
-      }
-      switch (ref.type) {
-        case "audit":
-          return ref.slug === audit.slug ? ref.weight : 0;
-        case "group":
-          return calculateGroupImpact(ref, audit, report);
-      }
-    });
-    return weights.reduce((acc, weight) => acc + weight, 0) / category.refs.reduce((acc, { weight }) => acc + weight, 0);
-  }).reduce((acc, value) => acc + value, 0);
-}
-function calculateGroupImpact(ref, audit, report) {
-  const group = report.plugins.find(({ slug }) => slug === ref.plugin)?.groups?.find(({ slug }) => slug === ref.slug);
-  if (!group?.refs.length) {
-    return 0;
-  }
-  const groupRatio = (group.refs.find(({ slug }) => slug === audit.slug)?.weight ?? 0) / group.refs.reduce((acc, { weight }) => acc + weight, 0);
-  return ref.weight * groupRatio;
-}
-
-// packages/ci/src/lib/run.ts
-async function runInCI(refs, api, options, git = simpleGit4()) {
-  const settings = { ...DEFAULT_SETTINGS, ...options };
-  const logger = settings.logger;
-  if (settings.monorepo) {
-    logger.info("Running Code PushUp in monorepo mode");
-    const projects = await listMonorepoProjects(settings);
-    const projectResults = await projects.reduce(
-      async (acc, project) => [
-        ...await acc,
-        await runOnProject({ project, settings, refs, api, git })
-      ],
-      Promise.resolve([])
-    );
-    const diffJsonPaths = projectResults.map(
-      ({ artifacts: { diff } }) => diff?.files.find((file) => file.endsWith(".json"))
-    ).filter((file) => file != null);
-    if (diffJsonPaths.length > 0) {
-      const { mdFilePath, artifactData: diffArtifact } = await runMergeDiffs(
-        diffJsonPaths,
-        createCommandContext(settings, projects[0])
-      );
-      logger.debug(`Merged ${diffJsonPaths.length} diffs into ${mdFilePath}`);
-      const commentId = await commentOnPR(mdFilePath, api, logger);
-      return {
-        mode: "monorepo",
-        projects: projectResults,
-        commentId,
-        diffArtifact
-      };
-    }
-    return { mode: "monorepo", projects: projectResults };
-  }
-  logger.info("Running Code PushUp in standalone project mode");
-  const { artifacts, newIssues } = await runOnProject({
-    project: null,
-    settings,
-    api,
-    refs,
-    git
-  });
-  const commentMdPath = artifacts.diff?.files.find(
-    (file) => file.endsWith(".md")
-  );
-  if (commentMdPath) {
-    const commentId = await commentOnPR(commentMdPath, api, logger);
-    return {
-      mode: "standalone",
-      artifacts,
-      commentId,
-      newIssues
-    };
-  }
-  return { mode: "standalone", artifacts, newIssues };
-}
-async function runOnProject(args) {
-  const {
-    project,
-    refs: { head, base },
-    settings,
-    git
-  } = args;
-  const logger = settings.logger;
-  const ctx = createCommandContext(settings, project);
-  if (project) {
-    logger.info(`Running Code PushUp on monorepo project ${project.name}`);
-  }
-  const { jsonFilePath: currReportPath, artifactData: reportArtifact } = await runCollect(ctx);
-  const currReport = await fs.readFile(currReportPath, "utf8");
-  logger.debug(`Collected current report at ${currReportPath}`);
-  const noDiffOutput = {
-    name: project?.name ?? "-",
-    artifacts: {
-      report: reportArtifact
-    }
-  };
-  if (base == null) {
-    return noDiffOutput;
-  }
-  logger.info(
-    `PR/MR detected, preparing to compare base branch ${base.ref} to head ${head.ref}`
-  );
-  const prevReport = await collectPreviousReport({ ...args, base, ctx });
-  if (!prevReport) {
-    return noDiffOutput;
-  }
-  const reportsDir = path2.join(settings.directory, ".code-pushup");
-  const currPath = path2.join(reportsDir, "curr-report.json");
-  const prevPath = path2.join(reportsDir, "prev-report.json");
-  await fs.writeFile(currPath, currReport);
-  await fs.writeFile(prevPath, prevReport);
-  logger.debug(`Saved reports to ${currPath} and ${prevPath}`);
-  const comparisonFiles = await runCompare(
-    { before: prevPath, after: currPath, label: project?.name },
-    ctx
-  );
-  logger.info("Compared reports and generated diff files");
-  logger.debug(
-    `Generated diff files at ${comparisonFiles.jsonFilePath} and ${comparisonFiles.mdFilePath}`
-  );
-  const diffOutput = {
-    ...noDiffOutput,
-    artifacts: {
-      ...noDiffOutput.artifacts,
-      diff: comparisonFiles.artifactData
-    }
-  };
-  if (!settings.detectNewIssues) {
-    return diffOutput;
-  }
-  const newIssues = await findNewIssues({
-    base,
-    currReport,
-    prevReport,
-    comparisonFiles,
-    logger,
-    git
-  });
-  return { ...diffOutput, newIssues };
-}
-async function collectPreviousReport(args) {
-  const { project, base, api, settings, ctx, git } = args;
-  const logger = settings.logger;
-  const cachedBaseReport = await api.downloadReportArtifact?.(project?.name).catch((error) => {
-    logger.warn(
-      `Error when downloading previous report artifact, skipping - ${stringifyError(error)}`
-    );
-  });
-  if (api.downloadReportArtifact != null) {
-    logger.info(
-      `Previous report artifact ${cachedBaseReport ? "found" : "not found"}`
-    );
-    if (cachedBaseReport) {
-      logger.debug(
-        `Previous report artifact downloaded to ${cachedBaseReport}`
-      );
-    }
-  }
-  if (cachedBaseReport) {
-    return fs.readFile(cachedBaseReport, "utf8");
-  } else {
-    await git.fetch("origin", base.ref, ["--depth=1"]);
-    await git.checkout(["-f", base.ref]);
-    logger.info(`Switched to base branch ${base.ref}`);
-    try {
-      await runPrintConfig({ ...ctx, silent: !settings.debug });
-      logger.debug(
-        `Executing print-config verified code-pushup installed in base branch ${base.ref}`
-      );
-    } catch (error) {
-      logger.debug(`Error from print-config - ${stringifyError(error)}`);
-      logger.info(
-        `Executing print-config failed, assuming code-pushup not installed in base branch ${base.ref} and skipping comparison`
-      );
-      return null;
-    }
-    const { jsonFilePath: prevReportPath } = await runCollect(ctx);
-    const prevReport = await fs.readFile(prevReportPath, "utf8");
-    logger.debug(`Collected previous report at ${prevReportPath}`);
-    await git.checkout(["-f", "-"]);
-    logger.info("Switched back to PR/MR branch");
-    return prevReport;
-  }
-}
-async function findNewIssues(args) {
-  const { base, currReport, prevReport, comparisonFiles, logger, git } = args;
-  await git.fetch("origin", base.ref, ["--depth=1"]);
-  const reportsDiff = await fs.readFile(comparisonFiles.jsonFilePath, "utf8");
-  const changedFiles = await listChangedFiles(
-    { base: "FETCH_HEAD", head: "HEAD" },
-    git
-  );
-  const issues = filterRelevantIssues({
-    currReport: JSON.parse(currReport),
-    prevReport: JSON.parse(prevReport),
-    reportsDiff: JSON.parse(reportsDiff),
-    changedFiles
-  });
-  logger.debug(
-    `Found ${issues.length} relevant issues for ${Object.keys(changedFiles).length} changed files`
-  );
-  return issues;
-}
-export {
-  MONOREPO_TOOLS,
-  isMonorepoTool,
-  runInCI
-};