refactor: use CP_VERBOSE flag instead of verbose param

Author: vmasek

packages/cli/src/lib/implementation/core-config.middleware.integration.test.ts

@@ -21,7 +21,7 @@ const configDirPath = path.join(
 describe('coreConfigMiddleware', () => {
   const CLI_DEFAULTS = {
     progress: true,
-    verbose: false,
+    plugins: [],
     onlyPlugins: [],
     skipPlugins: [],
   };

packages/cli/src/lib/implementation/core-config.model.ts

@@ -16,6 +16,7 @@ export type UploadConfigCliOptions = {
 export type ConfigCliOptions = {
   config?: string;
   tsconfig?: string;
+  verbose?: string;
 };
 
 export type CoreConfigCliOptions = Pick<CoreConfig, 'persist'> & {

packages/cli/src/lib/implementation/filter.middleware.ts

@@ -30,7 +30,6 @@ export function filterMiddleware<T extends FilterOptions>(
     onlyCategories = [],
     skipPlugins = [],
     onlyPlugins = [],
-    verbose = false,
   } = originalProcessArgs;
 
   const plugins = filterSkippedInPlugins(rcPlugins);
@@ -43,7 +42,7 @@ export function filterMiddleware<T extends FilterOptions>(
     onlyPlugins.length === 0
   ) {
     if (rcCategories && categories) {
-      validateSkippedCategories(rcCategories, categories, verbose);
+      validateSkippedCategories(rcCategories, categories);
     }
     return {
       ...originalProcessArgs,
@@ -61,12 +60,12 @@ export function filterMiddleware<T extends FilterOptions>(
   const filteredCategories = applyCategoryFilters(
     { categories, plugins },
     skippedCategories,
-    { skipCategories, onlyCategories, verbose },
+    { skipCategories, onlyCategories },
   );
   const filteredPlugins = applyPluginFilters(
     { categories: filteredCategories, plugins },
     skippedPlugins,
-    { skipPlugins, onlyPlugins, verbose },
+    { skipPlugins, onlyPlugins },
   );
   const finalCategories = filteredCategories
     ? filterItemRefsBy(filteredCategories, ref =>
@@ -89,9 +88,9 @@ export function filterMiddleware<T extends FilterOptions>(
 function applyCategoryFilters(
   { categories, plugins }: Filterables,
   skippedCategories: string[],
-  options: Pick<FilterOptions, 'skipCategories' | 'onlyCategories' | 'verbose'>,
+  options: Pick<FilterOptions, 'skipCategories' | 'onlyCategories'>,
 ): CoreConfig['categories'] {
-  const { skipCategories = [], onlyCategories = [], verbose = false } = options;
+  const { skipCategories = [], onlyCategories = [] } = options;
   if (
     (skipCategories.length === 0 && onlyCategories.length === 0) ||
     ((!categories || categories.length === 0) && skippedCategories.length === 0)
@@ -101,22 +100,22 @@ function applyCategoryFilters(
   validateFilterOption(
     'skipCategories',
     { plugins, categories },
-    { itemsToFilter: skipCategories, skippedItems: skippedCategories, verbose },
+    { itemsToFilter: skipCategories, skippedItems: skippedCategories },
   );
   validateFilterOption(
     'onlyCategories',
     { plugins, categories },
-    { itemsToFilter: onlyCategories, skippedItems: skippedCategories, verbose },
+    { itemsToFilter: onlyCategories, skippedItems: skippedCategories },
   );
   return applyFilters(categories ?? [], skipCategories, onlyCategories, 'slug');
 }
 
 function applyPluginFilters(
   { categories, plugins }: Filterables,
   skippedPlugins: string[],
-  options: Pick<FilterOptions, 'skipPlugins' | 'onlyPlugins' | 'verbose'>,
+  options: Pick<FilterOptions, 'skipPlugins' | 'onlyPlugins'>,
 ): CoreConfig['plugins'] {
-  const { skipPlugins = [], onlyPlugins = [], verbose = false } = options;
+  const { skipPlugins = [], onlyPlugins = [] } = options;
   const filteredPlugins = filterPluginsFromCategories({
     categories,
     plugins,
@@ -127,12 +126,12 @@ function applyPluginFilters(
   validateFilterOption(
     'skipPlugins',
     { plugins: filteredPlugins, categories },
-    { itemsToFilter: skipPlugins, skippedItems: skippedPlugins, verbose },
+    { itemsToFilter: skipPlugins, skippedItems: skippedPlugins },
   );
   validateFilterOption(
     'onlyPlugins',
     { plugins: filteredPlugins, categories },
-    { itemsToFilter: onlyPlugins, skippedItems: skippedPlugins, verbose },
+    { itemsToFilter: onlyPlugins, skippedItems: skippedPlugins },
   );
   return applyFilters(filteredPlugins, skipPlugins, onlyPlugins, 'slug');
 }

packages/cli/src/lib/implementation/filter.middleware.unit.test.ts

@@ -291,6 +291,8 @@ describe('filterMiddleware', () => {
   );
 
   it('should trigger verbose logging when skipPlugins or onlyPlugins removes categories', () => {
+    vi.stubEnv('CP_VERBOSE', 'true');
+
     filterMiddleware({
       onlyPlugins: ['p1'],
       skipPlugins: ['p2'],
@@ -311,7 +313,6 @@ describe('filterMiddleware', () => {
           refs: [{ type: 'audit', plugin: 'p2', slug: 'a1-p2', weight: 1 }],
         },
       ] as CategoryConfig[],
-      verbose: true,
     });
 
     expect(ui()).toHaveNthLogged(

packages/cli/src/lib/implementation/global.options.ts

@@ -13,7 +13,7 @@ export function yargsGlobalOptionsDefinition(): Record<
     },
     verbose: {
       describe:
-        'When true creates more verbose output. This is helpful when debugging.',
+        'When true creates more verbose output. This is helpful when debugging. You may also set CP_VERBOSE env variable instead.',
       type: 'boolean',
       default: false,
     },

packages/cli/src/lib/implementation/validate-filter-options.utils.ts

@@ -2,6 +2,7 @@ import type { PluginConfig } from '@code-pushup/models';
 import {
   capitalize,
   filterItemRefsBy,
+  isVerbose,
   pluralize,
   ui,
 } from '@code-pushup/utils';
@@ -16,8 +17,7 @@ export function validateFilterOption(
   {
     itemsToFilter,
     skippedItems,
-    verbose,
-  }: { itemsToFilter: string[]; skippedItems: string[]; verbose: boolean },
+  }: { itemsToFilter: string[]; skippedItems: string[] },
 ): void {
   const validItems = isCategoryOption(option)
     ? categories.map(({ slug }) => slug)
@@ -51,14 +51,14 @@ export function validateFilterOption(
     }
     ui().logger.warning(message);
   }
-  if (skippedValidItems.length > 0 && verbose) {
+  if (skippedValidItems.length > 0 && isVerbose()) {
     const item = getItemType(option, skippedValidItems.length);
     const prefix = skippedValidItems.length === 1 ? `a skipped` : `skipped`;
     ui().logger.warning(
       `The --${option} argument references ${prefix} ${item}: ${skippedValidItems.join(', ')}.`,
     );
   }
-  if (isPluginOption(option) && categories.length > 0 && verbose) {
+  if (isPluginOption(option) && categories.length > 0 && isVerbose()) {
     const removedCategories = filterItemRefsBy(categories, ({ plugin }) =>
       isOnlyOption(option)
         ? !itemsToFilterSet.has(plugin)
@@ -78,12 +78,11 @@ export function validateFilterOption(
 export function validateSkippedCategories(
   originalCategories: NonNullable<Filterables['categories']>,
   filteredCategories: NonNullable<Filterables['categories']>,
-  verbose: boolean,
 ): void {
   const skippedCategories = originalCategories.filter(
     original => !filteredCategories.some(({ slug }) => slug === original.slug),
   );
-  if (skippedCategories.length > 0 && verbose) {
+  if (skippedCategories.length > 0 && isVerbose()) {
     skippedCategories.forEach(category => {
       ui().logger.info(
         `Category ${category.slug} was removed because all its refs were skipped. Affected refs: ${category.refs

packages/cli/src/lib/implementation/validate-filter-options.utils.unit.test.ts

@@ -48,7 +48,7 @@ describe('validateFilterOption', () => {
             { slug: 'c1', refs: [{ plugin: 'p1', slug: 'a1-p1' }] },
           ] as CategoryConfig[],
         },
-        { itemsToFilter, skippedItems: [], verbose: false },
+        { itemsToFilter, skippedItems: [] },
       );
       expect(ui()).toHaveLogged('warn', expected);
     },
@@ -91,7 +91,7 @@ describe('validateFilterOption', () => {
             },
           ] as CategoryConfig[],
         },
-        { itemsToFilter, skippedItems: [], verbose: false },
+        { itemsToFilter, skippedItems: [] },
       );
       expect(ui()).toHaveLogged('warn', expected);
     },
@@ -106,12 +106,14 @@ describe('validateFilterOption', () => {
           { slug: 'p2', audits: [{ slug: 'a1-p2' }] },
         ] as PluginConfig[],
       },
-      { itemsToFilter: ['p1'], skippedItems: [], verbose: false },
+      { itemsToFilter: ['p1'], skippedItems: [] },
     );
     expect(ui()).not.toHaveLogs();
   });
 
   it('should log a category ignored as a result of plugin filtering', () => {
+    vi.stubEnv('CP_VERBOSE', 'true');
+
     validateFilterOption(
       'onlyPlugins',
       {
@@ -125,7 +127,7 @@ describe('validateFilterOption', () => {
           { slug: 'c3', refs: [{ plugin: 'p2' }] },
         ] as CategoryConfig[],
       },
-      { itemsToFilter: ['p1'], skippedItems: [], verbose: true },
+      { itemsToFilter: ['p1'], skippedItems: [] },
     );
     expect(ui()).toHaveLoggedTimes(1);
     expect(ui()).toHaveLogged(
@@ -145,7 +147,7 @@ describe('validateFilterOption', () => {
             { slug: 'p3', audits: [{ slug: 'a1-p3' }] },
           ] as PluginConfig[],
         },
-        { itemsToFilter: ['p4', 'p5'], skippedItems: [], verbose: false },
+        { itemsToFilter: ['p4', 'p5'], skippedItems: [] },
       );
     }).toThrow(
       new OptionValidationError(
@@ -164,12 +166,12 @@ describe('validateFilterOption', () => {
       validateFilterOption(
         'skipPlugins',
         { plugins: allPlugins },
-        { itemsToFilter: ['plugin1'], skippedItems: [], verbose: false },
+        { itemsToFilter: ['plugin1'], skippedItems: [] },
       );
       validateFilterOption(
         'onlyPlugins',
         { plugins: allPlugins },
-        { itemsToFilter: ['plugin3'], skippedItems: [], verbose: false },
+        { itemsToFilter: ['plugin3'], skippedItems: [] },
       );
     }).toThrow(
       new OptionValidationError(
@@ -178,7 +180,7 @@ describe('validateFilterOption', () => {
     );
   });
 
-  it('should throw OptionValidationError when none of the onlyCatigories are valid', () => {
+  it('should throw OptionValidationError when none of the onlyCategories are valid', () => {
     expect(() => {
       validateFilterOption(
         'onlyCategories',
@@ -197,7 +199,7 @@ describe('validateFilterOption', () => {
             },
           ] as CategoryConfig[],
         },
-        { itemsToFilter: ['c2', 'c3'], skippedItems: [], verbose: false },
+        { itemsToFilter: ['c2', 'c3'], skippedItems: [] },
       );
     }).toThrow(
       new OptionValidationError(
@@ -207,6 +209,8 @@ describe('validateFilterOption', () => {
   });
 
   it('should log skipped items if verbose mode is enabled', () => {
+    vi.stubEnv('CP_VERBOSE', 'true');
+
     const plugins = [
       { slug: 'p1', audits: [{ slug: 'a1-p1' }] },
     ] as PluginConfig[];
@@ -217,7 +221,7 @@ describe('validateFilterOption', () => {
     validateFilterOption(
       'skipPlugins',
       { plugins, categories },
-      { itemsToFilter: ['p1'], skippedItems: ['p1'], verbose: true },
+      { itemsToFilter: ['p1'], skippedItems: ['p1'] },
     );
     expect(ui()).toHaveNthLogged(
       1,
@@ -450,16 +454,14 @@ describe('validateSkippedCategories', () => {
   ] as NonNullable<Filterables['categories']>;
 
   it('should log info when categories are removed', () => {
-    validateSkippedCategories(
-      categories,
-      [
-        {
-          slug: 'c2',
-          refs: [{ type: 'audit', plugin: 'p2', slug: 'a1', weight: 1 }],
-        },
-      ] as NonNullable<Filterables['categories']>,
-      true,
-    );
+    vi.stubEnv('CP_VERBOSE', 'true');
+
+    validateSkippedCategories(categories, [
+      {
+        slug: 'c2',
+        refs: [{ type: 'audit', plugin: 'p2', slug: 'a1', weight: 1 }],
+      },
+    ] as NonNullable<Filterables['categories']>);
     expect(ui()).toHaveLogged(
       'info',
       'Category c1 was removed because all its refs were skipped. Affected refs: g1 (group)',
@@ -468,12 +470,12 @@ describe('validateSkippedCategories', () => {
 
   it('should not log anything when categories are not removed', () => {
     const loggerSpy = vi.spyOn(ui().logger, 'info');
-    validateSkippedCategories(categories, categories, true);
+    validateSkippedCategories(categories, categories);
     expect(loggerSpy).not.toHaveBeenCalled();
   });
 
   it('should throw an error when no categories remain after filtering', () => {
-    expect(() => validateSkippedCategories(categories, [], false)).toThrow(
+    expect(() => validateSkippedCategories(categories, [])).toThrow(
       new OptionValidationError(
         'No categories remain after filtering. Removed categories: c1, c2',
       ),

packages/core/src/lib/collect-and-persist.ts

@@ -3,7 +3,12 @@ import {
   type PersistConfig,
   pluginReportSchema,
 } from '@code-pushup/models';
-import { logStdoutSummary, scoreReport, sortReport } from '@code-pushup/utils';
+import {
+  isVerbose,
+  logStdoutSummary,
+  scoreReport,
+  sortReport,
+} from '@code-pushup/utils';
 import { collect } from './implementation/collect.js';
 import {
   logPersistedResults,
@@ -29,9 +34,9 @@ export async function collectAndPersistReports(
   );
 
   // terminal output
-  logStdoutSummary(sortedScoredReport, options.verbose);
+  logStdoutSummary(sortedScoredReport);
 
-  if (options.verbose) {
+  if (isVerbose()) {
     logPersistedResults(persistResults);
   }