@code-pushup/create-cli 0.51.0

package/README.md

@@ -0,0 +1,32 @@
+# @code-pushup/create-cli
+
+[![npm](https://img.shields.io/npm/v/%40code-pushup%2Fcreate-cli.svg)](https://www.npmjs.com/package/@code-pushup/create-cli)
+[![downloads](https://img.shields.io/npm/dm/%40code-pushup%2Fcreate-cli)](https://npmtrends.com/@code-pushup/create-cli)
+[![dependencies](https://img.shields.io/librariesio/release/npm/%40code-pushup/create-cli)](https://www.npmjs.com/package/@code-pushup/create-cli?activeTab=dependencies)
+
+A CLI tool to set up Code PushUp in your repository.
+
+## Usage
+
+To set up Code PushUp, run the following command:
+
+```bash
+npx init @code-pushup/cli
+```
+
+alternatives:
+
+```bash
+npx @code-pushup/create-cli
+npm exec @code-pushup/create-cli
+```
+
+It should generate the following output:
+
+```bash
+>  <✓>  Generating @code-pushup/nx-plugin:init
+
+>  <✓>  Generating @code-pushup/nx-plugin:configuration
+
+CREATE code-pushup.config.ts
+```

package/index.js

@@ -0,0 +1,958 @@
+#! /usr/bin/env node
+
+// 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].sort();
+  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.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 nonnegativeIntSchema = z.number().int().nonnegative();
+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(
+    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories ?? [], coreCfg.plugins),
+    (coreCfg) => ({
+      message: missingRefsForCategoriesErrorMsg(
+        coreCfg.categories ?? [],
+        coreCfg.plugins
+      )
+    })
+  );
+}
+
+// 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(
+    {
+      categories: z15.array(categoryConfigSchema),
+      plugins: z15.array(pluginReportSchema).min(1),
+      commit: commitSchema.describe("Git commit for which report was collected").nullable()
+    },
+    { description: "Collect output data" }
+  )
+).refine(
+  (report) => !getMissingRefsForCategories(report.categories, report.plugins),
+  (report) => ({
+    message: missingRefsForCategoriesErrorMsg(
+      report.categories,
+      report.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().int().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/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";
+
+// packages/utils/src/lib/reports/constants.ts
+var CODE_PUSHUP_UNICODE_LOGO = "<\u2713>";
+
+// packages/utils/src/lib/reports/utils.ts
+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,
+      ...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";
+
+// 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/git/git.ts
+import { simpleGit } from "simple-git";
+
+// packages/utils/src/lib/transform.ts
+function objectToCliArgs(params) {
+  if (!params) {
+    return [];
+  }
+  return Object.entries(params).flatMap(([key, value]) => {
+    if (key === "_") {
+      return Array.isArray(value) ? value : [`${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 === "object") {
+      return Object.entries(value).flatMap(
+        // transform nested objects to the dot notation `key.subkey`
+        ([k, v]) => objectToCliArgs({ [`${key}.${k}`]: 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}`);
+  });
+}
+
+// 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/create-cli/src/lib/utils.ts
+import { readFile, rm, stat, writeFile } from "node:fs/promises";
+
+// packages/create-cli/src/lib/constants.ts
+var NX_JSON_FILENAME = "nx.json";
+var NX_JSON_CONTENT = JSON.stringify({
+  $schema: "./node_modules/nx/schemas/nx-schema.json",
+  targetDefaults: {}
+});
+var PROJECT_NAME = "source-root";
+var PROJECT_JSON_FILENAME = "project.json";
+var PROJECT_JSON_CONTENT = JSON.stringify({
+  $schema: "node_modules/nx/schemas/project-schema.json",
+  name: PROJECT_NAME
+});
+
+// packages/create-cli/src/lib/utils.ts
+async function setupFile(filename, content = "") {
+  const setupResult = {
+    filename,
+    teardown: false
+  };
+  try {
+    const stats = await stat(filename);
+    if (!stats.isFile()) {
+      await writeFile(filename, content);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("no such file or directory")) {
+      await writeFile(filename, content);
+      return {
+        ...setupResult,
+        teardown: true
+      };
+    } else {
+      console.error(error);
+    }
+  }
+  return setupResult;
+}
+function parseNxProcessOutput(output) {
+  return output.trim().replace("NX", CODE_PUSHUP_UNICODE_LOGO);
+}
+async function setupNxContext() {
+  const { teardown: nxJsonTeardown } = await setupFile(
+    NX_JSON_FILENAME,
+    NX_JSON_CONTENT
+  );
+  const { teardown: projectJsonTeardown } = await setupFile(
+    PROJECT_JSON_FILENAME,
+    PROJECT_JSON_CONTENT
+  );
+  const projectJsonContent = await readFile(PROJECT_JSON_FILENAME, "utf8");
+  const { name = PROJECT_NAME } = JSON.parse(projectJsonContent);
+  return {
+    nxJsonTeardown,
+    projectJsonTeardown,
+    projectName: name
+  };
+}
+async function teardownNxContext({
+  nxJsonTeardown,
+  projectJsonTeardown
+}) {
+  const filesToDelete = [
+    ...nxJsonTeardown ? [NX_JSON_FILENAME] : [],
+    ...projectJsonTeardown ? [PROJECT_JSON_FILENAME] : []
+  ];
+  await Promise.all(filesToDelete.map((file) => rm(file)));
+}
+
+// packages/create-cli/src/lib/init.ts
+function nxPluginGenerator(generator, opt = {}) {
+  return {
+    command: "npx",
+    args: objectToCliArgs({
+      _: ["nx", "g", `@code-pushup/nx-plugin:${generator}`],
+      ...opt
+    })
+  };
+}
+async function initCodePushup() {
+  const setupResult = await setupNxContext();
+  await executeProcess({
+    ...nxPluginGenerator("init", {
+      skipNxJson: true
+    }),
+    observer: {
+      onStdout: (data) => {
+        console.info(parseNxProcessOutput(data.toString()));
+      },
+      onError: (error) => {
+        console.error(parseNxProcessOutput(error.message.toString()));
+      }
+    }
+  });
+  const { stdout: configStdout, stderr: configStderr } = await executeProcess(
+    nxPluginGenerator("configuration", {
+      skipTarget: true,
+      project: setupResult.projectName
+    })
+  );
+  console.info(parseNxProcessOutput(configStdout));
+  console.warn(parseNxProcessOutput(configStderr));
+  await teardownNxContext(setupResult);
+}
+
+// packages/create-cli/src/index.ts
+await initCodePushup();

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@code-pushup/create-cli",
+  "version": "0.51.0",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": "index.js",
+  "dependencies": {
+    "@code-pushup/nx-plugin": "0.51.0",
+    "@code-pushup/utils": "0.51.0"
+  },
+  "homepage": "https://github.com/code-pushup/cli/tree/main/packages/create-cli#readme",
+  "bugs": {
+    "url": "https://github.com/code-pushup/cli/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/code-pushup/cli.git",
+    "directory": "packages/create-cli"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts"
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/src/lib/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const NX_JSON_FILENAME = "nx.json";
+export declare const NX_JSON_CONTENT: string;
+export declare const PROJECT_NAME = "source-root";
+export declare const PROJECT_JSON_FILENAME = "project.json";
+export declare const PROJECT_JSON_CONTENT: string;

package/src/lib/init.d.ts

@@ -0,0 +1,3 @@
+import { type ProcessConfig } from '@code-pushup/utils';
+export declare function nxPluginGenerator(generator: 'init' | 'configuration', opt?: Record<string, unknown>): ProcessConfig;
+export declare function initCodePushup(): Promise<void>;

package/src/lib/utils.d.ts

@@ -0,0 +1,15 @@
+export type SetupResult = {
+    filename: string;
+    teardown: boolean;
+};
+export declare function setupFile(filename: string, content?: string): Promise<SetupResult>;
+export declare function parseNxProcessOutput(output: string): string;
+export declare function setupNxContext(): Promise<{
+    nxJsonTeardown: boolean;
+    projectJsonTeardown: boolean;
+    projectName: string;
+}>;
+export declare function teardownNxContext({ nxJsonTeardown, projectJsonTeardown, }: {
+    nxJsonTeardown: boolean;
+    projectJsonTeardown: boolean;
+}): Promise<void>;