Fixed merge conflits

Author: sunil-lakshman

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Contentstack
+Copyright (c) 2026 Contentstack
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package-lock.json

@@ -19,7 +19,7 @@ $ npm install -g @contentstack/cli-audit
 $ csdx COMMAND
 running command...
 $ csdx (--version|-v)
-@contentstack/cli-audit/1.16.1 darwin-arm64 node-v22.14.0
+@contentstack/cli-audit/2.0.0-beta.0 darwin-arm64 node-v22.14.0
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND

packages/contentstack-audit/README.md

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-audit",
-  "version": "1.16.1",
+  "version": "2.0.0-beta.0",
   "description": "Contentstack audit plugin",
   "author": "Contentstack CLI",
   "homepage": "https://github.com/contentstack/cli",
@@ -18,11 +18,11 @@
     "/oclif.manifest.json"
   ],
   "dependencies": {
-    "@contentstack/cli-command": "~1.7.0",
+    "@contentstack/cli-command": "~1.6.1",
     "@contentstack/cli-utilities": "~1.15.0",
     "@oclif/core": "^4.3.0",
     "@oclif/plugin-help": "^6.2.28",
-    "@oclif/plugin-plugins": "^5.4.54",
+    "@oclif/plugin-plugins": "^5.4.38",
     "chalk": "^4.1.2",
     "fast-csv": "^4.3.6",
     "fs-extra": "^11.3.0",

packages/contentstack-audit/package.json

@@ -5,7 +5,7 @@ import { v4 as uuid } from 'uuid';
 import isEmpty from 'lodash/isEmpty';
 import { join, resolve } from 'path';
 import cloneDeep from 'lodash/cloneDeep';
-import { cliux, sanitizePath, TableFlags, TableHeader, log, configHandler } from '@contentstack/cli-utilities';
+import { cliux, sanitizePath, TableFlags, TableHeader, log, configHandler, CLIProgressManager, clearProgressModuleSetting } from '@contentstack/cli-utilities';
 import { createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs';
 import config from './config';
 import { print } from './util/log';
@@ -71,11 +71,23 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
    */
   async start(command: CommandNames): Promise<boolean> {
     this.currentCommand = command;
+    
+    // Set progress supported module and console logs setting BEFORE any log calls
+    // This ensures the logger respects the setting when it's initialized
+    const logConfig = configHandler.get('log') || {};
+    // Default to false so progress bars are shown instead of console logs
+    if (logConfig.showConsoleLogs === undefined) {
+      configHandler.set('log.showConsoleLogs', false);
+    }
+    configHandler.set('log.progressSupportedModule', 'audit');
+    
     // Initialize audit context
     this.auditContext = this.createAuditContext();
     log.debug(`Starting audit command: ${command}`, this.auditContext);
     log.info(`Starting audit command: ${command}`, this.auditContext);
-
+    
+    // Initialize global summary for progress tracking
+    CLIProgressManager.initializeGlobalSummary('AUDIT', '', 'Auditing content...');
 
     await this.promptQueue();
     await this.createBackUp();
@@ -163,6 +175,12 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
       }
     }
 
+    // Print comprehensive summary at the end
+    CLIProgressManager.printGlobalSummary();
+    
+    // Clear progress module setting now that audit is complete
+    clearProgressModuleSetting();
+
     return (
       !isEmpty(missingCtRefs) ||
       !isEmpty(missingGfRefs) ||
@@ -222,47 +240,59 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
 
     let dataModuleWise: Record<string, any> = await new ModuleDataReader(cloneDeep(constructorParam)).run();
     log.debug(`Data module wise: ${JSON.stringify(dataModuleWise)}`, this.auditContext);
+    
+    // Extract logConfig and showConsoleLogs once before the loop to reuse throughout
+    const logConfig = configHandler.get('log') || {};
+    const showConsoleLogs = logConfig.showConsoleLogs ?? true;
+    
     for (const module of this.sharedConfig.flags.modules || this.sharedConfig.modules) {
       // Update audit context with current module
       this.auditContext = this.createAuditContext(module);
       log.debug(`Starting audit for module: ${module}`, this.auditContext);
       log.info(`Starting audit for module: ${module}`, this.auditContext);
 
-      print([
-        {
-          bold: true,
-          color: 'whiteBright',
-          message: this.$t(this.messages.AUDIT_START_SPINNER, { module }),
-        },
-      ]);
+      // Only show spinner message if console logs are enabled (compatible with line-by-line logs)
+      if (showConsoleLogs) {
+        print([
+          {
+            bold: true,
+            color: 'whiteBright',
+            message: this.$t(this.messages.AUDIT_START_SPINNER, { module }),
+          },
+        ]);
+      }
 
       constructorParam['moduleName'] = module;
 
       switch (module) {
         case 'assets':
           log.info('Executing assets audit', this.auditContext);
-          missingEnvLocalesInAssets = await new Assets(cloneDeep(constructorParam)).run();
+          const assetsTotalCount = dataModuleWise['assets']?.Total || 0;
+          missingEnvLocalesInAssets = await new Assets(cloneDeep(constructorParam)).run(false, assetsTotalCount);
           await this.prepareReport(module, missingEnvLocalesInAssets);
           this.getAffectedData('assets', dataModuleWise['assets'], missingEnvLocalesInAssets);
           log.success(`Assets audit completed. Found ${Object.keys(missingEnvLocalesInAssets || {}).length} issues`, this.auditContext);
           break;
         case 'content-types':
           log.info('Executing content-types audit', this.auditContext);
-          missingCtRefs = await new ContentType(cloneDeep(constructorParam)).run();
+          const contentTypesTotalCount = dataModuleWise['content-types']?.Total || 0;
+          missingCtRefs = await new ContentType(cloneDeep(constructorParam)).run(false, contentTypesTotalCount);
           await this.prepareReport(module, missingCtRefs);
           this.getAffectedData('content-types', dataModuleWise['content-types'], missingCtRefs);
           log.success(`Content-types audit completed. Found ${Object.keys(missingCtRefs || {}).length} issues`, this.auditContext);
           break;
         case 'global-fields':
           log.info('Executing global-fields audit', this.auditContext);
-          missingGfRefs = await new GlobalField(cloneDeep(constructorParam)).run();
+          const globalFieldsTotalCount = dataModuleWise['global-fields']?.Total || 0;
+          missingGfRefs = await new GlobalField(cloneDeep(constructorParam)).run(false, globalFieldsTotalCount);
           await this.prepareReport(module, missingGfRefs);
           this.getAffectedData('global-fields', dataModuleWise['global-fields'], missingGfRefs);
           log.success(`Global-fields audit completed. Found ${Object.keys(missingGfRefs || {}).length} issues`, this.auditContext);
           break;
         case 'entries':
           log.info('Executing entries audit', this.auditContext);
-          missingEntry = await new Entries(cloneDeep(constructorParam)).run();
+          const entriesTotalCount = dataModuleWise['entries']?.Total || 0;
+          missingEntry = await new Entries(cloneDeep(constructorParam)).run(entriesTotalCount);
           missingEntryRefs = missingEntry.missingEntryRefs ?? {};
           missingSelectFeild = missingEntry.missingSelectFeild ?? {};
           missingMandatoryFields = missingEntry.missingMandatoryFields ?? {};
@@ -286,27 +316,30 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
           break;
         case 'workflows':
           log.info('Executing workflows audit', this.auditContext);
+          const workflowsTotalCount = dataModuleWise['workflows']?.Total || 0;
           missingCtRefsInWorkflow = await new Workflows({
             ctSchema,
             moduleName: module,
             config: this.sharedConfig,
             fix: this.currentCommand === 'cm:stacks:audit:fix',
-          }).run();
+          }).run(workflowsTotalCount);
           await this.prepareReport(module, missingCtRefsInWorkflow);
           this.getAffectedData('workflows', dataModuleWise['workflows'], missingCtRefsInWorkflow);
           log.success(`Workflows audit completed. Found ${Object.keys(missingCtRefsInWorkflow || {}).length} issues`, this.auditContext);
 
           break;
         case 'extensions':
           log.info('Executing extensions audit', this.auditContext);
-          missingCtRefsInExtensions = await new Extensions(cloneDeep(constructorParam)).run();
+          const extensionsTotalCount = dataModuleWise['extensions']?.Total || 0;
+          missingCtRefsInExtensions = await new Extensions(cloneDeep(constructorParam)).run(extensionsTotalCount);
           await this.prepareReport(module, missingCtRefsInExtensions);
           this.getAffectedData('extensions', dataModuleWise['extensions'], missingCtRefsInExtensions);
           log.success(`Extensions audit completed. Found ${Object.keys(missingCtRefsInExtensions || {}).length} issues`, this.auditContext);
           break;
         case 'custom-roles':
           log.info('Executing custom-roles audit', this.auditContext);
-          missingRefInCustomRoles = await new CustomRoles(cloneDeep(constructorParam)).run();
+          const customRolesTotalCount = dataModuleWise['custom-roles']?.Total || 0;
+          missingRefInCustomRoles = await new CustomRoles(cloneDeep(constructorParam)).run(customRolesTotalCount);
           await this.prepareReport(module, missingRefInCustomRoles);
           this.getAffectedData('custom-roles', dataModuleWise['custom-roles'], missingRefInCustomRoles);
           log.success(`Custom-roles audit completed. Found ${Object.keys(missingRefInCustomRoles || {}).length} issues`, this.auditContext);
@@ -318,25 +351,29 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
           const data =  this.getCtAndGfSchema();
           constructorParam.ctSchema = data.ctSchema;
           constructorParam.gfSchema = data.gfSchema;
-          missingFieldRules = await new FieldRule(cloneDeep(constructorParam)).run();
+          const fieldRulesTotalCount = dataModuleWise['content-types']?.Total || 0;
+          missingFieldRules = await new FieldRule(cloneDeep(constructorParam)).run(fieldRulesTotalCount);
           await this.prepareReport(module, missingFieldRules);
           this.getAffectedData('field-rules', dataModuleWise['content-types'], missingFieldRules);
           log.success(`Field-rules audit completed. Found ${Object.keys(missingFieldRules || {}).length} issues`, this.auditContext);
           break;
       }
 
-      print([
-        {
-          bold: true,
-          color: 'whiteBright',
-          message: this.$t(this.messages.AUDIT_START_SPINNER, { module }),
-        },
-        {
-          bold: true,
-          message: ' done',
-          color: 'whiteBright',
-        },
-      ]);
+      // Only show completion message if console logs are enabled
+      if (showConsoleLogs) {
+        print([
+          {
+            bold: true,
+            color: 'whiteBright',
+            message: this.$t(this.messages.AUDIT_START_SPINNER, { module }),
+          },
+          {
+            bold: true,
+            message: ' done',
+            color: 'whiteBright',
+          },
+        ]);
+      }
     }
 
     log.debug('Scan and fix process completed', this.auditContext);

packages/contentstack-audit/src/audit-base-command.ts

@@ -2,7 +2,6 @@ import { join, resolve } from 'path';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { FsUtility, sanitizePath, cliux, log } from '@contentstack/cli-utilities';
 import {
-  ConfigType,
   ContentTypeStruct,
   CtConstructorParam,
   ModuleConstructorParam,
@@ -12,13 +11,13 @@ import auditConfig from '../config';
 import { $t, auditFixMsg, auditMsg, commonMsg } from '../messages';
 import values from 'lodash/values';
 import { keys } from 'lodash';
+import BaseClass from './base-class';
 
-/* The `ContentType` class is responsible for scanning content types, looking for references, and
-generating a report in JSON and CSV formats. */
-export default class Assets {
+/* The `Assets` class is responsible for scanning assets, looking for missing environment/locale references,
+and generating a report in JSON and CSV formats. */
+export default class Assets extends BaseClass {
   protected fix: boolean;
   public fileName: string;
-  public config: ConfigType;
   public folderPath: string;
   public currentUid!: string;
   public currentTitle!: string;
@@ -30,7 +29,7 @@ export default class Assets {
   public moduleName: keyof typeof auditConfig.moduleConfig;
 
   constructor({ fix, config, moduleName }: ModuleConstructorParam & CtConstructorParam) {
-    this.config = config;
+    super({ config });
     this.fix = fix ?? false;
     this.moduleName = this.validateModules(moduleName!, this.config.moduleConfig);
     this.fileName = config.moduleConfig[this.moduleName].fileName;
@@ -52,25 +51,36 @@ export default class Assets {
   /**
    * The `run` function checks if a folder path exists, sets the schema based on the module name,
    * iterates over the schema and looks for references, and returns a list of missing references.
+   * @param returnFixSchema - If true, returns the fixed schema instead of missing references
+   * @param totalCount - Total number of assets to process (for progress tracking)
    * @returns the `missingEnvLocales` object.
    */
-  async run(returnFixSchema = false) {
-    log.debug(`Starting ${this.moduleName} audit process`, this.config.auditContext);
-    log.debug(`Data directory: ${this.folderPath}`, this.config.auditContext);
-    log.debug(`Fix mode: ${this.fix}`, this.config.auditContext);
-
-    if (!existsSync(this.folderPath)) {
-      log.debug(`Skipping ${this.moduleName} audit - path does not exist`, this.config.auditContext);
-      log.warn(`Skipping ${this.moduleName} audit`, this.config.auditContext);
-      cliux.print($t(auditMsg.NOT_VALID_PATH, { path: this.folderPath }), { color: 'yellow' });
-      return returnFixSchema ? [] : {};
-    }
+  async run(returnFixSchema = false, totalCount?: number) {
+    try {
+      log.debug(`Starting ${this.moduleName} audit process`, this.config.auditContext);
+      log.debug(`Data directory: ${this.folderPath}`, this.config.auditContext);
+      log.debug(`Fix mode: ${this.fix}`, this.config.auditContext);
 
-    log.debug('Loading prerequisite data (locales and environments)', this.config.auditContext);
-    await this.prerequisiteData();
+      if (!existsSync(this.folderPath)) {
+        log.debug(`Skipping ${this.moduleName} audit - path does not exist`, this.config.auditContext);
+        log.warn(`Skipping ${this.moduleName} audit`, this.config.auditContext);
+        cliux.print($t(auditMsg.NOT_VALID_PATH, { path: this.folderPath }), { color: 'yellow' });
+        return returnFixSchema ? [] : {};
+      }
+
+      // Load prerequisite data with loading spinner
+      await this.withLoadingSpinner('ASSETS: Loading prerequisite data (locales and environments)...', async () => {
+        await this.prerequisiteData();
+      });
+
+      // Create progress manager if we have a total count
+      if (totalCount && totalCount > 0) {
+        const progress = this.createSimpleProgress(this.moduleName, totalCount);
+        progress.updateStatus('Validating asset references...');
+      }
 
-    log.debug('Starting asset Reference, Environment and Locale validation', this.config.auditContext);
-    await this.lookForReference();
+      log.debug('Starting asset Reference, Environment and Locale validation', this.config.auditContext);
+      await this.lookForReference();
 
     if (returnFixSchema) {
       log.debug(`Returning fixed schema with ${this.schema?.length || 0} items`, this.config.auditContext);
@@ -86,9 +96,15 @@ export default class Assets {
       }
     }
 
-    const totalIssues = Object.keys(this.missingEnvLocales).length;
-    log.debug(`${this.moduleName} audit completed. Found ${totalIssues} assets with missing environment/locale references`, this.config.auditContext);
-    return this.missingEnvLocales;
+      const totalIssues = Object.keys(this.missingEnvLocales).length;
+      log.debug(`${this.moduleName} audit completed. Found ${totalIssues} assets with missing environment/locale references`, this.config.auditContext);
+      
+      this.completeProgress(true);
+      return this.missingEnvLocales;
+    } catch (error: any) {
+      this.completeProgress(false, error?.message || 'Assets audit failed');
+      throw error;
+    }
   }
 
   /**
@@ -227,6 +243,11 @@ export default class Assets {
         const remainingPublishDetails = this.assets[assetUid].publish_details?.length || 0;
         log.debug(`Asset ${assetUid} now has ${remainingPublishDetails} valid publish details`, this.config.auditContext);
 
+        // Track progress for each asset processed
+        if (this.progressManager) {
+          this.progressManager.tick(true, `asset: ${assetUid}`, null);
+        }
+        
         if (this.fix) {
           log.debug(`Fixing asset ${assetUid}`, this.config.auditContext);
           log.info($t(auditFixMsg.ASSET_FIX, { uid: assetUid }), this.config.auditContext);