@code-pushup/cli 0.51.0 → 0.53.0

package/README.md

@@ -118,7 +118,26 @@ _If you're looking for programmatic usage, then refer to the underlying [@code-p
 
 ## Portal integration
 
-If you have access to the Code PushUp portal, provide credentials in order to upload reports.
+If you have access to the Code PushUp portal, you can enable report uploads by installing the `@code-pushup/portal-client` package.
+
+<details>
+<summary>Installation command for <code>npm</code>, <code>yarn</code> and <code>pnpm</code></summary>
+
+```sh
+npm install --save-dev @code-pushup/portal-client
+```
+
+```sh
+yarn add --dev @code-pushup/portal-client
+```
+
+```sh
+pnpm add --save-dev @code-pushup/portal-client
+```
+
+</details>
+
+Once the package is installed, update your configuration file to include your portal credentials:
 
 ```ts
 const config: CoreConfig = {

package/index.js

@@ -1608,25 +1608,30 @@ import {
 } from "build-md";
 import { posix as pathPosix } from "node:path";
 
-// packages/utils/src/lib/reports/ide-environment.ts
+// packages/utils/src/lib/reports/types.ts
+var SUPPORTED_ENVIRONMENTS = [
+  "vscode",
+  "github",
+  "gitlab",
+  "other"
+];
+
+// packages/utils/src/lib/reports/environment-type.ts
+var environmentChecks = {
+  vscode: () => process.env["TERM_PROGRAM"] === "vscode",
+  github: () => process.env["GITHUB_ACTIONS"] === "true",
+  gitlab: () => process.env["GITLAB_CI"] === "true",
+  other: () => true
+};
 function getEnvironmentType() {
-  if (isVSCode()) {
-    return "vscode";
-  }
-  if (isGitHub()) {
-    return "github";
-  }
-  return "other";
-}
-function isVSCode() {
-  return process.env["TERM_PROGRAM"] === "vscode";
-}
-function isGitHub() {
-  return process.env["GITHUB_ACTIONS"] === "true";
+  return SUPPORTED_ENVIRONMENTS.find((env) => environmentChecks[env]()) ?? "other";
 }
 function getGitHubBaseUrl() {
   return `${process.env["GITHUB_SERVER_URL"]}/${process.env["GITHUB_REPOSITORY"]}/blob/${process.env["GITHUB_SHA"]}`;
 }
+function getGitLabBaseUrl() {
+  return `${process.env["CI_SERVER_URL"]}/${process.env["CI_PROJECT_PATH"]}/-/blob/${process.env["CI_COMMIT_SHA"]}`;
+}
 
 // packages/utils/src/lib/reports/formatting.ts
 function tableSection(tableData, options2) {
@@ -1692,6 +1697,15 @@ function formatGitHubLink(file, position) {
   const lineRange = end && start !== end ? `${start}-${end}` : start;
   return `${baseUrl}/${file}#${lineRange}`;
 }
+function formatGitLabLink(file, position) {
+  const baseUrl = getGitLabBaseUrl();
+  if (!position) {
+    return `${baseUrl}/${file}`;
+  }
+  const { startLine, endLine } = position;
+  const lineRange = endLine && startLine !== endLine ? `${startLine}-${endLine}` : startLine;
+  return `${baseUrl}/${file}#L${lineRange}`;
+}
 function formatFileLink(file, position, outputDir) {
   const relativePath = pathPosix.relative(outputDir, file);
   const env = getEnvironmentType();
@@ -1700,6 +1714,8 @@ function formatFileLink(file, position, outputDir) {
       return position ? `${relativePath}#L${position.startLine}` : relativePath;
     case "github":
       return formatGitHubLink(file, position);
+    case "gitlab":
+      return formatGitLabLink(file, position);
     default:
       return relativePath;
   }
@@ -2345,11 +2361,11 @@ import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
 function log(msg = "") {
   ui().logger.log(msg);
 }
-function logStdoutSummary(report) {
+function logStdoutSummary(report, verbose = false) {
   const printCategories = report.categories.length > 0;
   log(reportToHeaderSection(report));
   log();
-  logPlugins(report);
+  logPlugins(report.plugins, verbose);
   if (printCategories) {
     logCategories(report);
   }
@@ -2360,36 +2376,49 @@ function reportToHeaderSection(report) {
   const { packageName, version: version3 } = report;
   return `${bold4(REPORT_HEADLINE_TEXT)} - ${packageName}@${version3}`;
 }
-function logPlugins(report) {
-  const { plugins } = report;
+function logPlugins(plugins, verbose) {
   plugins.forEach((plugin) => {
     const { title, audits } = plugin;
+    const filteredAudits = verbose ? audits : audits.filter(({ score }) => score !== 1);
+    const diff = audits.length - filteredAudits.length;
+    logAudits(title, filteredAudits);
+    if (diff > 0) {
+      const notice = filteredAudits.length === 0 ? `... All ${diff} audits have perfect scores ...` : `... ${diff} audits with perfect scores omitted for brevity ...`;
+      logRow(1, notice);
+    }
     log();
-    log(bold4.magentaBright(`${title} audits`));
-    log();
-    audits.forEach((audit) => {
-      ui().row([
-        {
-          text: applyScoreColor({ score: audit.score, text: "\u25CF" }),
-          width: 2,
-          padding: [0, 1, 0, 0]
-        },
-        {
-          text: audit.title,
-          // eslint-disable-next-line no-magic-numbers
-          padding: [0, 3, 0, 0]
-        },
-        {
-          text: cyanBright(audit.displayValue || `${audit.value}`),
-          // eslint-disable-next-line no-magic-numbers
-          width: 20,
-          padding: [0, 0, 0, 0]
-        }
-      ]);
-    });
-    log();
   });
 }
+function logAudits(pluginTitle, audits) {
+  log();
+  log(bold4.magentaBright(`${pluginTitle} audits`));
+  log();
+  audits.forEach(({ score, title, displayValue, value }) => {
+    logRow(score, title, displayValue || `${value}`);
+  });
+}
+function logRow(score, title, value) {
+  ui().row([
+    {
+      text: applyScoreColor({ score, text: "\u25CF" }),
+      width: 2,
+      padding: [0, 1, 0, 0]
+    },
+    {
+      text: title,
+      // eslint-disable-next-line no-magic-numbers
+      padding: [0, 3, 0, 0]
+    },
+    ...value ? [
+      {
+        text: cyanBright(value),
+        // eslint-disable-next-line no-magic-numbers
+        width: 20,
+        padding: [0, 0, 0, 0]
+      }
+    ] : []
+  ]);
+}
 function logCategories({ categories, plugins }) {
   const hAlign = (idx) => idx === 0 ? "left" : "right";
   const rows = categories.map(({ title, score, refs, isBinary }) => [
@@ -2535,7 +2564,7 @@ var verboseUtils = (verbose = false) => ({
 
 // packages/core/package.json
 var name = "@code-pushup/core";
-var version = "0.51.0";
+var version = "0.53.0";
 
 // packages/core/src/lib/implementation/execute-plugin.ts
 import { bold as bold5 } from "ansis";
@@ -2730,10 +2759,8 @@ var PersistError = class extends Error {
     super(`fileName: ${reportPath} could not be saved.`);
   }
 };
-async function persistReport(report, options2) {
+async function persistReport(report, sortedScoredReport, options2) {
   const { outputDir, filename, format } = options2;
-  const sortedScoredReport = sortReport(scoreReport(report));
-  logStdoutSummary(sortedScoredReport);
   const results = format.map((reportType) => {
     switch (reportType) {
       case "json":
@@ -2779,7 +2806,13 @@ function logPersistedResults(persistResults) {
 async function collectAndPersistReports(options2) {
   const { exec } = verboseUtils(options2.verbose);
   const report = await collect(options2);
-  const persistResults = await persistReport(report, options2.persist);
+  const sortedScoredReport = sortReport(scoreReport(report));
+  const persistResults = await persistReport(
+    report,
+    sortedScoredReport,
+    options2.persist
+  );
+  logStdoutSummary(sortedScoredReport, options2.verbose);
   exec(() => {
     logPersistedResults(persistResults);
   });
@@ -2791,10 +2824,6 @@ async function collectAndPersistReports(options2) {
 // packages/core/src/lib/compare.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 import { join as join5 } from "node:path";
-import {
-  PortalOperationError,
-  getPortalComparisonLink
-} from "@code-pushup/portal-client";
 
 // packages/core/src/lib/implementation/compare-scorables.ts
 function compareCategories(reports) {
@@ -2930,6 +2959,18 @@ function selectMeta(meta) {
   };
 }
 
+// packages/core/src/lib/load-portal-client.ts
+async function loadPortalClient() {
+  try {
+    return await import("@code-pushup/portal-client");
+  } catch {
+    ui().logger.error(
+      "Optional peer dependency @code-pushup/portal-client is not available. Make sure it is installed to enable upload functionality."
+    );
+    return null;
+  }
+}
+
 // packages/core/src/lib/compare.ts
 async function compareReportFiles(inputPaths, persistConfig, uploadConfig, label) {
   const { outputDir, filename, format } = persistConfig;
@@ -2994,6 +3035,11 @@ function reportsDiffToFileContent(reportsDiff, format) {
 }
 async function fetchPortalComparisonLink(uploadConfig, commits) {
   const { server, apiKey, organization, project } = uploadConfig;
+  const portalClient = await loadPortalClient();
+  if (!portalClient) {
+    return;
+  }
+  const { PortalOperationError, getPortalComparisonLink } = portalClient;
   try {
     return await getPortalComparisonLink({
       server,
@@ -3016,18 +3062,7 @@ async function fetchPortalComparisonLink(uploadConfig, commits) {
   }
 }
 
-// packages/core/src/lib/upload.ts
-import {
-  uploadToPortal
-} from "@code-pushup/portal-client";
-
 // packages/core/src/lib/implementation/report-to-gql.ts
-import {
-  CategoryConfigRefType as PortalCategoryRefType,
-  IssueSeverity as PortalIssueSeverity,
-  IssueSourceType as PortalIssueSourceType,
-  TableAlignment as PortalTableAlignment
-} from "@code-pushup/portal-client";
 function reportToGQL(report) {
   return {
     packageName: report.packageName,
@@ -3094,7 +3129,7 @@ function issueToGQL(issue) {
     message: issue.message,
     severity: issueSeverityToGQL(issue.severity),
     ...issue.source?.file && {
-      sourceType: PortalIssueSourceType.SourceCode,
+      sourceType: safeEnum("SourceCode"),
       sourceFilePath: issue.source.file,
       sourceStartLine: issue.source.position?.startLine,
       sourceStartColumn: issue.source.position?.startColumn,
@@ -3140,37 +3175,45 @@ function categoryToGQL(category) {
 function categoryRefTypeToGQL(type) {
   switch (type) {
     case "audit":
-      return PortalCategoryRefType.Audit;
+      return safeEnum("Audit");
     case "group":
-      return PortalCategoryRefType.Group;
+      return safeEnum("Group");
   }
 }
 function issueSeverityToGQL(severity) {
   switch (severity) {
     case "info":
-      return PortalIssueSeverity.Info;
+      return safeEnum("Info");
     case "error":
-      return PortalIssueSeverity.Error;
+      return safeEnum("Error");
     case "warning":
-      return PortalIssueSeverity.Warning;
+      return safeEnum("Warning");
   }
 }
 function tableAlignmentToGQL(alignment) {
   switch (alignment) {
     case "left":
-      return PortalTableAlignment.Left;
+      return safeEnum("Left");
     case "center":
-      return PortalTableAlignment.Center;
+      return safeEnum("Center");
     case "right":
-      return PortalTableAlignment.Right;
+      return safeEnum("Right");
   }
 }
+function safeEnum(value) {
+  return value;
+}
 
 // packages/core/src/lib/upload.ts
-async function upload(options2, uploadFn = uploadToPortal) {
+async function upload(options2) {
   if (options2.upload == null) {
     throw new Error("Upload configuration is not set.");
   }
+  const portalClient = await loadPortalClient();
+  if (!portalClient) {
+    return;
+  }
+  const { uploadToPortal } = portalClient;
   const { apiKey, server, organization, project, timeout } = options2.upload;
   const report = await loadReport({
     ...options2.persist,
@@ -3185,7 +3228,7 @@ async function upload(options2, uploadFn = uploadToPortal) {
     commit: report.commit.hash,
     ...reportToGQL(report)
   };
-  return uploadFn({ apiKey, server, data, timeout });
+  return uploadToPortal({ apiKey, server, data, timeout });
 }
 
 // packages/core/src/lib/history.ts
@@ -3368,8 +3411,10 @@ function yargsAutorunCommandObject() {
         renderConfigureCategoriesHint();
       }
       if (options2.upload) {
-        const { url } = await upload(options2);
-        uploadSuccessfulLog(url);
+        const report = await upload(options2);
+        if (report?.url) {
+          uploadSuccessfulLog(report.url);
+        }
       } else {
         ui().logger.warning("Upload skipped because configuration is not set.");
         renderIntegratePortalHint();
@@ -3470,6 +3515,94 @@ function yargsCompareCommandObject() {
 // packages/cli/src/lib/history/history-command.ts
 import { bold as bold10, gray as gray7 } from "ansis";
 
+// packages/cli/src/lib/implementation/global.utils.ts
+import yargs from "yargs";
+
+// packages/cli/src/lib/implementation/validate-filter-options.utils.ts
+var OptionValidationError = class extends Error {
+};
+function validateFilterOption(option, { plugins, categories }, { itemsToFilter, verbose }) {
+  const itemsToFilterSet = new Set(itemsToFilter);
+  const validItems = isCategoryOption(option) ? categories : isPluginOption(option) ? plugins : [];
+  const invalidItems = itemsToFilter.filter(
+    (item) => !validItems.some(({ slug }) => slug === item)
+  );
+  const message = createValidationMessage(option, invalidItems, validItems);
+  if (isOnlyOption(option) && itemsToFilterSet.size > 0 && itemsToFilterSet.size === invalidItems.length) {
+    throw new OptionValidationError(message);
+  }
+  if (invalidItems.length > 0) {
+    ui().logger.warning(message);
+  }
+  if (isPluginOption(option) && categories.length > 0 && verbose) {
+    const removedCategorySlugs = filterItemRefsBy(
+      categories,
+      ({ plugin }) => isOnlyOption(option) ? !itemsToFilterSet.has(plugin) : itemsToFilterSet.has(plugin)
+    ).map(({ slug }) => slug);
+    if (removedCategorySlugs.length > 0) {
+      ui().logger.info(
+        `The --${option} argument removed the following categories: ${removedCategorySlugs.join(
+          ", "
+        )}.`
+      );
+    }
+  }
+}
+function validateFinalState(filteredItems, originalItems) {
+  const { categories: filteredCategories, plugins: filteredPlugins } = filteredItems;
+  const { categories: originalCategories, plugins: originalPlugins } = originalItems;
+  if (filteredCategories.length === 0 && filteredPlugins.length === 0 && (originalPlugins.length > 0 || originalCategories.length > 0)) {
+    const availablePlugins = originalPlugins.map((p) => p.slug).join(", ") || "none";
+    const availableCategories = originalCategories.map((c) => c.slug).join(", ") || "none";
+    throw new OptionValidationError(
+      `Nothing to report. No plugins or categories are available after filtering. Available plugins: ${availablePlugins}. Available categories: ${availableCategories}.`
+    );
+  }
+}
+function isCategoryOption(option) {
+  return option.endsWith("Categories");
+}
+function isPluginOption(option) {
+  return option.endsWith("Plugins");
+}
+function isOnlyOption(option) {
+  return option.startsWith("only");
+}
+function getItemType(option, count) {
+  const itemType = isCategoryOption(option) ? "category" : isPluginOption(option) ? "plugin" : "item";
+  return pluralize(itemType, count);
+}
+function createValidationMessage(option, invalidItems, validItems) {
+  const invalidItem = getItemType(option, invalidItems.length);
+  const invalidItemText = invalidItems.length === 1 ? `a ${invalidItem} that does not exist:` : `${invalidItem} that do not exist:`;
+  const invalidSlugs = invalidItems.join(", ");
+  const validItem = getItemType(option, validItems.length);
+  const validItemText = validItems.length === 1 ? `The only valid ${validItem} is` : `Valid ${validItem} are`;
+  const validSlugs = validItems.map(({ slug }) => slug).join(", ");
+  return `The --${option} argument references ${invalidItemText} ${invalidSlugs}. ${validItemText} ${validSlugs}.`;
+}
+function handleConflictingOptions(type, onlyItems, skipItems) {
+  const conflictingItems = onlyItems.filter((item) => skipItems.includes(item));
+  if (conflictingItems.length > 0) {
+    const conflictSubject = () => {
+      switch (type) {
+        case "categories":
+          return conflictingItems.length > 1 ? "categories are" : "category is";
+        case "plugins":
+          return conflictingItems.length > 1 ? "plugins are" : "plugin is";
+      }
+    };
+    const conflictingSlugs = conflictingItems.join(", ");
+    throw new OptionValidationError(
+      `The following ${conflictSubject()} specified in both --only${capitalize(
+        type
+      )} and --skip${capitalize(
+        type
+      )}: ${conflictingSlugs}. Please choose one option.`
+    );
+  }
+}
+
 // packages/cli/src/lib/implementation/global.utils.ts
 function filterKebabCaseKeys(obj) {
   return Object.entries(obj).filter(([key]) => !key.includes("-")).reduce(
@@ -3485,9 +3618,15 @@ function logErrorBeforeThrow(fn) {
     try {
       return await fn(...args);
     } catch (error) {
-      console.error(error);
-      await new Promise((resolve) => process.stdout.write("", resolve));
-      throw error;
+      if (error instanceof OptionValidationError) {
+        ui().logger.error(error.message);
+        await new Promise((resolve) => process.stdout.write("", resolve));
+        yargs().exit(1, error);
+      } else {
+        console.error(error);
+        await new Promise((resolve) => process.stdout.write("", resolve));
+        throw error;
+      }
     }
   };
 }
@@ -3495,21 +3634,19 @@ function coerceArray(param) {
   return [...new Set(toArray(param).flatMap((f) => f.split(",")))];
 }
 
-// packages/cli/src/lib/implementation/only-plugins.options.ts
-var onlyPluginsOption = {
-  describe: "List of plugins to run. If not set all plugins are run.",
+// packages/cli/src/lib/implementation/filter.options.ts
+var skipCategoriesOption = {
+  describe: "List of categories to skip. If not set all categories are run.",
   type: "array",
   default: [],
-  coerce: coerceArray,
-  alias: "p"
+  coerce: coerceArray
+};
+var onlyCategoriesOption = {
+  describe: "List of categories to run. If not set all categories are run.",
+  type: "array",
+  default: [],
+  coerce: coerceArray
 };
-function yargsOnlyPluginsOptionsDefinition() {
-  return {
-    onlyPlugins: onlyPluginsOption
-  };
-}
-
-// packages/cli/src/lib/implementation/skip-plugins.options.ts
 var skipPluginsOption = {
   describe: "List of plugins to skip. If not set all plugins are run.",
   type: "array",
@@ -3517,9 +3654,19 @@ var skipPluginsOption = {
   coerce: coerceArray,
   alias: "P"
 };
-function yargsSkipPluginsOptionsDefinition() {
+var onlyPluginsOption = {
+  describe: "List of plugins to run. If not set all plugins are run.",
+  type: "array",
+  default: [],
+  coerce: coerceArray,
+  alias: "p"
+};
+function yargsFilterOptionsDefinition() {
   return {
-    skipPlugins: skipPluginsOption
+    skipCategories: skipCategoriesOption,
+    onlyCategories: onlyCategoriesOption,
+    skipPlugins: skipPluginsOption,
+    onlyPlugins: onlyPluginsOption
   };
 }
 
@@ -3630,17 +3777,16 @@ function yargsHistoryCommandObject() {
   return {
     command,
     describe: "Collect reports for commit history",
-    builder: (yargs2) => {
-      yargs2.options({
+    builder: (yargs3) => {
+      yargs3.options({
         ...yargsHistoryOptionsDefinition(),
-        ...yargsOnlyPluginsOptionsDefinition(),
-        ...yargsSkipPluginsOptionsDefinition()
+        ...yargsFilterOptionsDefinition()
       });
-      yargs2.group(
+      yargs3.group(
         Object.keys(yargsHistoryOptionsDefinition()),
         "History Options:"
       );
-      return yargs2;
+      return yargs3;
     },
     handler
   };
@@ -3707,8 +3853,10 @@ function yargsUploadCommandObject() {
         renderIntegratePortalHint();
         throw new Error("Upload configuration not set");
       }
-      const { url } = await upload(options2);
-      uploadSuccessfulLog(url);
+      const report = await upload(options2);
+      if (report?.url) {
+        uploadSuccessfulLog(report.url);
+      }
     }
   };
 }
@@ -3765,80 +3913,99 @@ async function coreConfigMiddleware(processArgs) {
 }
 var normalizeFormats = (formats) => (formats ?? []).flatMap((format) => format.split(","));
 
-// packages/cli/src/lib/implementation/validate-plugin-filter-options.utils.ts
-function validatePluginFilterOption(filterOption, {
-  plugins,
-  categories
-}, {
-  pluginsToFilter = [],
-  verbose = false
-} = {}) {
-  const pluginsToFilterSet = new Set(pluginsToFilter);
-  const missingPlugins = pluginsToFilter.filter(
-    (plugin) => !plugins.some(({ slug }) => slug === plugin)
-  );
-  const isSkipOption = filterOption === "skipPlugins";
-  const filterFunction = (plugin) => isSkipOption ? pluginsToFilterSet.has(plugin) : !pluginsToFilterSet.has(plugin);
-  if (missingPlugins.length > 0) {
-    ui().logger.warning(
-      `The --${filterOption} argument references ${missingPlugins.length === 1 ? "a plugin that does" : "plugins that do"} not exist: ${missingPlugins.join(", ")}. The valid plugin ${plugins.length === 1 ? "slug is" : "slugs are"} ${plugins.map(({ slug }) => slug).join(", ")}.`
-    );
-  }
-  if (categories.length > 0 && verbose) {
-    const removedCategorySlugs = filterItemRefsBy(
-      categories,
-      ({ plugin }) => filterFunction(plugin)
-    ).map(({ slug }) => slug);
-    ui().logger.info(
-      `The --${filterOption} argument removed the following categories: ${removedCategorySlugs.join(
-        ", "
-      )}.`
-    );
-  }
-}
-
-// packages/cli/src/lib/implementation/filter-plugins.middleware.ts
-function filterPluginsMiddleware(originalProcessArgs) {
+// packages/cli/src/lib/implementation/filter.middleware.ts
+function filterMiddleware(originalProcessArgs) {
   const {
     plugins,
     categories = [],
+    skipCategories = [],
+    onlyCategories = [],
     skipPlugins = [],
     onlyPlugins = [],
-    verbose
+    verbose = false
   } = originalProcessArgs;
-  if (skipPlugins.length === 0 && onlyPlugins.length === 0) {
+  if (skipCategories.length === 0 && onlyCategories.length === 0 && skipPlugins.length === 0 && onlyPlugins.length === 0) {
     return { ...originalProcessArgs, categories };
   }
-  validatePluginFilterOption(
-    "skipPlugins",
-    { plugins, categories },
-    { pluginsToFilter: skipPlugins, verbose }
-  );
-  validatePluginFilterOption(
-    "onlyPlugins",
-    { plugins, categories },
-    { pluginsToFilter: onlyPlugins, verbose }
+  handleConflictingOptions("categories", onlyCategories, skipCategories);
+  handleConflictingOptions("plugins", onlyPlugins, skipPlugins);
+  const filteredCategories = applyCategoryFilters(
+    { categories, plugins },
+    skipCategories,
+    onlyCategories,
+    verbose
   );
-  const validSkipPlugins = new Set(
-    skipPlugins.filter((sP) => plugins.some((p) => p.slug === sP))
+  const filteredPlugins = applyPluginFilters(
+    { categories: filteredCategories, plugins },
+    skipPlugins,
+    onlyPlugins,
+    verbose
   );
-  const pluginsAfterSkip = plugins.filter(
-    ({ slug }) => !validSkipPlugins.has(slug)
+  const finalCategories = filterItemRefsBy(
+    filteredCategories,
+    (ref) => filteredPlugins.some((plugin) => plugin.slug === ref.plugin)
   );
-  const validOnlyPlugins = new Set(
-    onlyPlugins.filter((oP) => pluginsAfterSkip.some((p) => p.slug === oP))
+  validateFinalState(
+    { categories: finalCategories, plugins: filteredPlugins },
+    { categories, plugins }
   );
-  const filteredPlugins = validOnlyPlugins.size > 0 ? pluginsAfterSkip.filter(({ slug }) => validOnlyPlugins.has(slug)) : pluginsAfterSkip;
-  const filteredCategories = filteredPlugins.length > 0 ? filterItemRefsBy(
-    categories,
-    ({ plugin }) => filteredPlugins.some(({ slug }) => slug === plugin)
-  ) : categories;
   return {
     ...originalProcessArgs,
     plugins: filteredPlugins,
-    categories: filteredCategories
+    categories: finalCategories
   };
 }
+function applyFilters(items, skipItems, onlyItems, key) {
+  return items.filter((item) => {
+    const itemKey = item[key];
+    return !skipItems.includes(itemKey) && (onlyItems.length === 0 || onlyItems.includes(itemKey));
+  });
+}
+function applyCategoryFilters({ categories, plugins }, skipCategories, onlyCategories, verbose) {
+  if (skipCategories.length === 0 && onlyCategories.length === 0) {
+    return categories;
+  }
+  validateFilterOption(
+    "skipCategories",
+    { plugins, categories },
+    { itemsToFilter: skipCategories, verbose }
+  );
+  validateFilterOption(
+    "onlyCategories",
+    { plugins, categories },
+    { itemsToFilter: onlyCategories, verbose }
+  );
+  return applyFilters(categories, skipCategories, onlyCategories, "slug");
+}
+function applyPluginFilters({ categories, plugins }, skipPlugins, onlyPlugins, verbose) {
+  const filteredPlugins = filterPluginsFromCategories({
+    categories,
+    plugins
+  });
+  if (skipPlugins.length === 0 && onlyPlugins.length === 0) {
+    return filteredPlugins;
+  }
+  validateFilterOption(
+    "skipPlugins",
+    { plugins: filteredPlugins, categories },
+    { itemsToFilter: skipPlugins, verbose }
+  );
+  validateFilterOption(
+    "onlyPlugins",
+    { plugins: filteredPlugins, categories },
+    { itemsToFilter: onlyPlugins, verbose }
+  );
+  return applyFilters(filteredPlugins, skipPlugins, onlyPlugins, "slug");
+}
+function filterPluginsFromCategories({
+  categories,
+  plugins
+}) {
+  const validPluginSlugs = new Set(
+    categories.flatMap((category) => category.refs.map((ref) => ref.plugin))
+  );
+  return categories.length > 0 ? plugins.filter((plugin) => validPluginSlugs.has(plugin.slug)) : plugins;
+}
 
 // packages/cli/src/lib/middlewares.ts
 var middlewares = [
@@ -3847,7 +4014,7 @@ var middlewares = [
     applyBeforeValidation: false
   },
   {
-    middlewareFunction: filterPluginsMiddleware,
+    middlewareFunction: filterMiddleware,
     applyBeforeValidation: false
   }
 ];
@@ -3924,14 +4091,12 @@ function yargsGlobalOptionsDefinition() {
 var options = {
   ...yargsGlobalOptionsDefinition(),
   ...yargsCoreConfigOptionsDefinition(),
-  ...yargsOnlyPluginsOptionsDefinition(),
-  ...yargsSkipPluginsOptionsDefinition()
+  ...yargsFilterOptionsDefinition()
 };
 var groups = {
   "Global Options:": [
     ...Object.keys(yargsGlobalOptionsDefinition()),
-    ...Object.keys(yargsOnlyPluginsOptionsDefinition()),
-    ...Object.keys(yargsSkipPluginsOptionsDefinition())
+    ...Object.keys(yargsFilterOptionsDefinition())
   ],
   "Persist Options:": Object.keys(yargsPersistConfigOptionsDefinition()),
   "Upload Options:": Object.keys(yargsUploadConfigOptionsDefinition())
@@ -3939,10 +4104,10 @@ var groups = {
 
 // packages/cli/src/lib/yargs-cli.ts
 import { blue, dim as dim2, green as green4 } from "ansis";
-import yargs from "yargs";
+import yargs2 from "yargs";
 
 // packages/cli/package.json
-var version2 = "0.51.0";
+var version2 = "0.53.0";
 
 // packages/cli/src/lib/implementation/formatting.ts
 import { bold as bold13, dim, green as green3 } from "ansis";
@@ -3994,7 +4159,7 @@ function yargsCli(argv, cfg) {
   const options2 = cfg.options ?? {};
   const groups2 = cfg.groups ?? {};
   const examples = cfg.examples ?? [];
-  const cli2 = yargs(argv);
+  const cli2 = yargs2(argv);
   cli2.updateLocale(yargsDecorator).wrap(Math.max(TERMINAL_WIDTH, cli2.terminalWidth())).help("help", descriptionStyle("Show help")).alias("h", "help").showHelpOnFail(false).version("version", dim2`Show version`, version2).check((args) => {
     const persist = args["persist"];
     return persist == null || validatePersistFormat(persist);

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@code-pushup/cli",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "license": "MIT",
   "description": "A CLI to run all kinds of code quality measurements to align your team with company goals",
   "bin": {
     "code-pushup": "index.js"
   },
   "dependencies": {
-    "@code-pushup/models": "0.51.0",
-    "@code-pushup/core": "0.51.0",
-    "@code-pushup/utils": "0.51.0",
+    "@code-pushup/models": "0.53.0",
+    "@code-pushup/core": "0.53.0",
+    "@code-pushup/utils": "0.53.0",
     "yargs": "^17.7.2",
     "ansis": "^3.3.0",
     "simple-git": "^3.20.0"
@@ -23,6 +23,9 @@
     "url": "git+https://github.com/code-pushup/cli.git",
     "directory": "packages/cli"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts"

package/src/lib/implementation/core-config.middleware.d.ts

@@ -1,8 +1,7 @@
 import { type CoreConfig, type Format } from '@code-pushup/models';
 import type { CoreConfigCliOptions } from './core-config.model';
+import type { FilterOptions } from './filter.model';
 import type { GeneralCliOptions } from './global.model';
-import type { OnlyPluginsOptions } from './only-plugins.model';
-import type { SkipPluginsOptions } from './skip-plugins.model';
-export type CoreConfigMiddlewareOptions = GeneralCliOptions & CoreConfigCliOptions & OnlyPluginsOptions & SkipPluginsOptions;
-export declare function coreConfigMiddleware<T extends CoreConfigMiddlewareOptions>(processArgs: T): Promise<GeneralCliOptions & CoreConfig & OnlyPluginsOptions & SkipPluginsOptions>;
+export type CoreConfigMiddlewareOptions = GeneralCliOptions & CoreConfigCliOptions & FilterOptions;
+export declare function coreConfigMiddleware<T extends CoreConfigMiddlewareOptions>(processArgs: T): Promise<GeneralCliOptions & CoreConfig & FilterOptions>;
 export declare const normalizeFormats: (formats?: string[]) => Format[];

package/src/lib/implementation/filter.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { FilterOptions } from './filter.model';
+export declare function filterMiddleware<T extends FilterOptions>(originalProcessArgs: T): T;

package/src/lib/implementation/filter.model.d.ts

@@ -0,0 +1,9 @@
+import type { GlobalOptions } from '@code-pushup/core';
+import type { CategoryConfig, CoreConfig, PluginConfig } from '@code-pushup/models';
+export type FilterOptions = Partial<GlobalOptions> & Pick<CoreConfig, 'categories' | 'plugins'> & FilterCliOptions;
+export type FilterCliOptions = Partial<Record<FilterOptionType, string[]>>;
+export type FilterOptionType = 'skipCategories' | 'onlyCategories' | 'skipPlugins' | 'onlyPlugins';
+export type Filterables = {
+    categories: CategoryConfig[];
+    plugins: PluginConfig[];
+};

package/src/lib/implementation/filter.options.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from 'yargs';
+import type { FilterCliOptions } from './filter.model';
+export declare const skipCategoriesOption: Options;
+export declare const onlyCategoriesOption: Options;
+export declare const skipPluginsOption: Options;
+export declare const onlyPluginsOption: Options;
+export declare function yargsFilterOptionsDefinition(): Record<keyof FilterCliOptions, Options>;

package/src/lib/implementation/validate-filter-options.utils.d.ts

@@ -0,0 +1,13 @@
+import type { CategoryConfig, PluginConfig } from '@code-pushup/models';
+import type { FilterOptionType, Filterables } from './filter.model';
+export declare class OptionValidationError extends Error {
+}
+export declare function validateFilterOption(option: FilterOptionType, { plugins, categories }: Filterables, { itemsToFilter, verbose }: {
+    itemsToFilter: string[];
+    verbose: boolean;
+}): void;
+export declare function validateFinalState(filteredItems: Filterables, originalItems: Filterables): void;
+export declare function isOnlyOption(option: FilterOptionType): boolean;
+export declare function getItemType(option: FilterOptionType, count: number): string;
+export declare function createValidationMessage(option: FilterOptionType, invalidItems: string[], validItems: Pick<PluginConfig | CategoryConfig, 'slug'>[]): string;
+export declare function handleConflictingOptions(type: 'categories' | 'plugins', onlyItems: string[], skipItems: string[]): void;

package/src/lib/options.d.ts

@@ -1,4 +1,6 @@
 export declare const options: {
+    skipCategories: import("yargs").Options;
+    onlyCategories: import("yargs").Options;
     skipPlugins: import("yargs").Options;
     onlyPlugins: import("yargs").Options;
     "persist.outputDir": import("yargs").Options;

package/src/lib/implementation/filter-plugins.middleware.d.ts

@@ -1,3 +0,0 @@
-import type { OnlyPluginsOptions } from './only-plugins.model';
-import type { SkipPluginsOptions } from './skip-plugins.model';
-export declare function filterPluginsMiddleware<T extends SkipPluginsOptions & OnlyPluginsOptions>(originalProcessArgs: T): T;

package/src/lib/implementation/only-plugins.model.d.ts

@@ -1,6 +0,0 @@
-import type { GlobalOptions } from '@code-pushup/core';
-import type { CoreConfig } from '@code-pushup/models';
-export type OnlyPluginsCliOptions = {
-    onlyPlugins?: string[];
-};
-export type OnlyPluginsOptions = Partial<GlobalOptions> & Pick<CoreConfig, 'categories' | 'plugins'> & OnlyPluginsCliOptions;

package/src/lib/implementation/only-plugins.options.d.ts

@@ -1,4 +0,0 @@
-import type { Options } from 'yargs';
-import type { OnlyPluginsCliOptions } from './only-plugins.model';
-export declare const onlyPluginsOption: Options;
-export declare function yargsOnlyPluginsOptionsDefinition(): Record<keyof OnlyPluginsCliOptions, Options>;

package/src/lib/implementation/skip-plugins.model.d.ts

@@ -1,6 +0,0 @@
-import type { GlobalOptions } from '@code-pushup/core';
-import type { CoreConfig } from '@code-pushup/models';
-export type SkipPluginsCliOptions = {
-    skipPlugins?: string[];
-};
-export type SkipPluginsOptions = Partial<GlobalOptions> & Pick<CoreConfig, 'categories' | 'plugins'> & SkipPluginsCliOptions;

package/src/lib/implementation/skip-plugins.options.d.ts

@@ -1,4 +0,0 @@
-import type { Options } from 'yargs';
-import type { SkipPluginsCliOptions } from './skip-plugins.model';
-export declare const skipPluginsOption: Options;
-export declare function yargsSkipPluginsOptionsDefinition(): Record<keyof SkipPluginsCliOptions, Options>;

package/src/lib/implementation/validate-plugin-filter-options.utils.d.ts

@@ -1,8 +0,0 @@
-import type { CategoryConfig, PluginConfig } from '@code-pushup/models';
-export declare function validatePluginFilterOption(filterOption: 'onlyPlugins' | 'skipPlugins', { plugins, categories, }: {
-    plugins: PluginConfig[];
-    categories: CategoryConfig[];
-}, { pluginsToFilter, verbose, }?: {
-    pluginsToFilter?: string[];
-    verbose?: boolean;
-}): void;