@contentstack/cli-utilities 1.14.2 → 1.15.0

package/lib/config-handler.d.ts

@@ -1,8 +1,30 @@
 import Conf from 'conf';
+declare class Config {
+    private config;
+    private inMemoryStore;
+    private isPrepackMode;
+    constructor();
+    init(): Conf<Record<string, unknown>>;
+    importOldConfig(): void;
+    setOldConfigStoreData(data: any, _path?: string): void;
+    isConfigFileValid(configPath: string): boolean;
+    safeDeleteConfigIfInvalid(configFilePath: string): void;
+    removeOldConfigStoreFile(): void;
+    private getOldConfig;
+    private fallbackInit;
+    private getObfuscationKey;
+    private getConfigDataAndUnlinkConfigFile;
+    private getEncryptedConfig;
+    private getDecryptedConfig;
+    get(key: any): string | any;
+    set(key: any, value: any): this | Conf<Record<string, unknown>>;
+    delete(key: any): this | Conf<Record<string, unknown>>;
+    clear(): void;
+}
 declare const lazyConfig: {
     get(key: string): any;
-    set(key: string, value: any): Conf<Record<string, unknown>>;
-    delete(key: string): Conf<Record<string, unknown>>;
+    set(key: string, value: any): Config | Conf<Record<string, unknown>>;
+    delete(key: string): Config | Conf<Record<string, unknown>>;
     clear(): void;
 };
 export default lazyConfig;

package/lib/config-handler.js

@@ -22,10 +22,19 @@ const oldConfigPath = path.join(oldConfigDirectory, pathPrefix);
 const cwd = process.env.CS_CLI_CONFIG_PATH;
 class Config {
     constructor() {
+        this.inMemoryStore = new Map();
+        this.isPrepackMode = process.env.NODE_ENV === 'PREPACK_MODE';
         this.init();
-        this.importOldConfig();
+        if (!this.isPrepackMode) {
+            this.importOldConfig();
+        }
     }
     init() {
+        // Skip file-based config during prepack to prevent race conditions
+        if (this.isPrepackMode) {
+            // Initialize with empty in-memory store for prepack
+            return;
+        }
         return ENCRYPT_CONF === true ? this.getEncryptedConfig() : this.getDecryptedConfig();
     }
     importOldConfig() {
@@ -189,20 +198,35 @@ class Config {
     }
     get(key) {
         var _a;
+        if (this.isPrepackMode) {
+            return this.inMemoryStore.get(key);
+        }
         return (_a = this.config) === null || _a === void 0 ? void 0 : _a.get(key);
     }
     set(key, value) {
         var _a;
+        if (this.isPrepackMode) {
+            this.inMemoryStore.set(key, value);
+            return this;
+        }
         (_a = this.config) === null || _a === void 0 ? void 0 : _a.set(key, value);
         return this.config;
     }
     delete(key) {
         var _a;
+        if (this.isPrepackMode) {
+            this.inMemoryStore.delete(key);
+            return this;
+        }
         (_a = this.config) === null || _a === void 0 ? void 0 : _a.delete(key);
         return this.config;
     }
     clear() {
         var _a;
+        if (this.isPrepackMode) {
+            this.inMemoryStore.clear();
+            return;
+        }
         (_a = this.config) === null || _a === void 0 ? void 0 : _a.clear();
     }
 }

package/lib/constants/logging.d.ts

@@ -13,3 +13,4 @@ export declare const levelColors: {
     info: string;
     debug: string;
 };
+export declare const PROGRESS_SUPPORTED_MODULES: readonly ["export", "import"];

package/lib/constants/logging.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.levelColors = exports.logLevels = void 0;
+exports.PROGRESS_SUPPORTED_MODULES = exports.levelColors = exports.logLevels = void 0;
 exports.logLevels = {
     error: 0,
     warn: 1,
     info: 2,
     success: 2,
     debug: 3,
-    verbose: 4
+    verbose: 4,
 };
 // 2. Create color mappings (for console only)
 exports.levelColors = {
@@ -15,5 +15,6 @@ exports.levelColors = {
     warn: 'yellow',
     success: 'green',
     info: 'white',
-    debug: 'blue'
+    debug: 'blue',
 };
+exports.PROGRESS_SUPPORTED_MODULES = ['export', 'import'];

package/lib/helpers.d.ts

@@ -27,3 +27,4 @@ export declare const formatError: (error: any) => string;
  * from.
  */
 export declare const redactObject: (obj: any) => any;
+export declare function clearProgressModuleSetting(): void;

package/lib/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.redactObject = exports.formatError = exports.validateRegex = exports.validateFileName = exports.validateUids = exports.sanitizePath = exports.escapeRegExp = exports.validatePath = exports.createDeveloperHubUrl = exports.isManagementTokenValid = exports.getBranchFromAlias = exports.doesBranchExist = exports.isAuthenticated = void 0;
+exports.clearProgressModuleSetting = exports.redactObject = exports.formatError = exports.validateRegex = exports.validateFileName = exports.validateUids = exports.sanitizePath = exports.escapeRegExp = exports.validatePath = exports.createDeveloperHubUrl = exports.isManagementTokenValid = exports.getBranchFromAlias = exports.doesBranchExist = exports.isAuthenticated = void 0;
 const tslib_1 = require("tslib");
 const recheck_1 = require("recheck");
 const traverse_1 = tslib_1.__importDefault(require("traverse"));
@@ -185,8 +185,8 @@ const formatError = function (error) {
     // If message is in JSON format, parse it to extract the actual message string
     try {
         const parsedMessage = JSON.parse(message);
-        if (typeof parsedMessage === 'object') {
-            message = (parsedMessage === null || parsedMessage === void 0 ? void 0 : parsedMessage.message) || message;
+        if (typeof parsedMessage === 'object' && parsedMessage !== null) {
+            message = (parsedMessage === null || parsedMessage === void 0 ? void 0 : parsedMessage.message) || (parsedMessage === null || parsedMessage === void 0 ? void 0 : parsedMessage.errorMessage) || (parsedMessage === null || parsedMessage === void 0 ? void 0 : parsedMessage.error) || message;
         }
     }
     catch (e) {
@@ -238,3 +238,11 @@ const sensitiveKeys = [
     /management[-._]?token/i,
     /delivery[-._]?token/i,
 ];
+function clearProgressModuleSetting() {
+    const logConfig = _1.configHandler.get('log') || {};
+    if (logConfig === null || logConfig === void 0 ? void 0 : logConfig.progressSupportedModule) {
+        delete logConfig.progressSupportedModule;
+        _1.configHandler.set('log', logConfig);
+    }
+}
+exports.clearProgressModuleSetting = clearProgressModuleSetting;

package/lib/index.d.ts

@@ -25,3 +25,4 @@ export { default as TablePrompt } from './inquirer-table-prompt';
 export { Logger };
 export { default as authenticationHandler } from './authentication-handler';
 export { v2Logger as log, cliErrorHandler, handleAndLogError, getLogPath } from './logger/log';
+export { CLIProgressManager, SummaryManager, PrimaryProcessStrategy, ProgressStrategyRegistry, CustomProgressStrategy, DefaultProgressStrategy } from './progress-summary';

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogPath = exports.handleAndLogError = exports.cliErrorHandler = exports.log = exports.authenticationHandler = exports.Logger = exports.TablePrompt = exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.run = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Args = exports.marketplaceSDKInitiator = exports.MarketplaceSDKInitiator = exports.marketplaceSDKClient = exports.CLITable = exports.Command = exports.flags = exports.args = exports.NodeCrypto = exports.printFlagDeprecation = exports.managementSDKInitiator = exports.managementSDKClient = exports.configHandler = exports.authHandler = exports.messageHandler = exports.CLIError = exports.cliux = exports.LoggerService = void 0;
+exports.DefaultProgressStrategy = exports.CustomProgressStrategy = exports.ProgressStrategyRegistry = exports.PrimaryProcessStrategy = exports.SummaryManager = exports.CLIProgressManager = exports.getLogPath = exports.handleAndLogError = exports.cliErrorHandler = exports.log = exports.authenticationHandler = exports.Logger = exports.TablePrompt = exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.run = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Args = exports.marketplaceSDKInitiator = exports.MarketplaceSDKInitiator = exports.marketplaceSDKClient = exports.CLITable = exports.Command = exports.flags = exports.args = exports.NodeCrypto = exports.printFlagDeprecation = exports.managementSDKInitiator = exports.managementSDKClient = exports.configHandler = exports.authHandler = exports.messageHandler = exports.CLIError = exports.cliux = exports.LoggerService = void 0;
 const tslib_1 = require("tslib");
 const logger_1 = tslib_1.__importDefault(require("./logger"));
 exports.Logger = logger_1.default;
@@ -69,3 +69,10 @@ Object.defineProperty(exports, "log", { enumerable: true, get: function () { ret
 Object.defineProperty(exports, "cliErrorHandler", { enumerable: true, get: function () { return log_1.cliErrorHandler; } });
 Object.defineProperty(exports, "handleAndLogError", { enumerable: true, get: function () { return log_1.handleAndLogError; } });
 Object.defineProperty(exports, "getLogPath", { enumerable: true, get: function () { return log_1.getLogPath; } });
+var progress_summary_1 = require("./progress-summary");
+Object.defineProperty(exports, "CLIProgressManager", { enumerable: true, get: function () { return progress_summary_1.CLIProgressManager; } });
+Object.defineProperty(exports, "SummaryManager", { enumerable: true, get: function () { return progress_summary_1.SummaryManager; } });
+Object.defineProperty(exports, "PrimaryProcessStrategy", { enumerable: true, get: function () { return progress_summary_1.PrimaryProcessStrategy; } });
+Object.defineProperty(exports, "ProgressStrategyRegistry", { enumerable: true, get: function () { return progress_summary_1.ProgressStrategyRegistry; } });
+Object.defineProperty(exports, "CustomProgressStrategy", { enumerable: true, get: function () { return progress_summary_1.CustomProgressStrategy; } });
+Object.defineProperty(exports, "DefaultProgressStrategy", { enumerable: true, get: function () { return progress_summary_1.DefaultProgressStrategy; } });

package/lib/interfaces/index.d.ts

@@ -1,4 +1,5 @@
-import { logLevels } from "../constants/logging";
+import { logLevels } from '../constants/logging';
+import ProgressBar from 'cli-progress';
 export interface IPromptOptions {
     prompt?: string;
     type?: 'normal' | 'mask' | 'hide' | 'single';
@@ -101,3 +102,51 @@ export interface ErrorContextBase {
 export type ErrorContext = ErrorContextBase & {
     [key: string]: unknown;
 };
+export interface Failure {
+    item: string;
+    error: string | null;
+    process?: string;
+}
+export interface ProcessProgress {
+    name: string;
+    total: number;
+    current: number;
+    status: 'pending' | 'active' | 'completed' | 'failed';
+    successCount: number;
+    failureCount: number;
+    failures: Failure[];
+    progressBar?: ProgressBar.SingleBar;
+}
+export interface ProgressManagerOptions {
+    showConsoleLogs?: boolean;
+    total?: number;
+    moduleName?: string;
+    enableNestedProgress?: boolean;
+}
+export interface ModuleResult {
+    name: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    startTime?: number;
+    endTime?: number;
+    totalItems: number;
+    successCount: number;
+    failureCount: number;
+    failures: Array<{
+        item: string;
+        error: string;
+    }>;
+    processes?: Array<{
+        processName: string;
+        [key: string]: any;
+    }>;
+}
+export interface SummaryOptions {
+    operationName: string;
+    context?: any;
+    branchName?: string;
+}
+export interface ProgressResult {
+    total: number;
+    success: number;
+    failures: number;
+}

package/lib/logger/cli-error-handler.js

@@ -114,8 +114,7 @@ class CLIErrorHandler {
         if (typeof error === 'object') {
             try {
                 const errorObj = error;
-                const message = errorObj.message || errorObj.error || errorObj.statusText || 'Unknown error';
-                const normalizedError = new Error(message);
+                const normalizedError = new Error('Error occurred');
                 // Only copy essential properties
                 const essentialProps = [
                     'code',

package/lib/logger/log.js

@@ -13,7 +13,7 @@ function createLoggerInstance() {
     var _a;
     const logConfig = __1.configHandler.get('log');
     const logLevel = (logConfig === null || logConfig === void 0 ? void 0 : logConfig.level) || 'info';
-    const showConsoleLogs = (_a = logConfig === null || logConfig === void 0 ? void 0 : logConfig['show-console-logs']) !== null && _a !== void 0 ? _a : false;
+    const showConsoleLogs = (_a = logConfig === null || logConfig === void 0 ? void 0 : logConfig.showConsoleLogs) !== null && _a !== void 0 ? _a : false;
     const config = {
         basePath: getLogPath(),
         logLevel: logLevel,

package/lib/logger/logger.js

@@ -6,6 +6,7 @@ const full_1 = require("klona/full");
 const path_1 = require("path");
 const winston = tslib_1.__importStar(require("winston"));
 const logging_1 = require("../constants/logging");
+const __1 = require("..");
 class Logger {
     constructor(config) {
         this.consoleSensitiveKeys = [
@@ -43,26 +44,45 @@ class Logger {
         };
     }
     createLogger(level, filePath) {
+        var _a;
+        const transports = [
+            new winston.transports.File(Object.assign(Object.assign({}, this.loggerOptions), { filename: `${filePath}/${level}.log`, format: winston.format.combine(winston.format.timestamp(), winston.format.printf((info) => {
+                    // Apply minimal redaction for files (debugging info preserved)
+                    const redactedInfo = this.redact(info, false);
+                    return JSON.stringify(redactedInfo);
+                })) })),
+        ];
+        // Determine console logging based on configuration
+        let showConsoleLogs = true;
+        if (__1.configHandler && typeof __1.configHandler.get === 'function') {
+            const logConfig = __1.configHandler.get('log') || {};
+            const currentModule = logConfig.progressSupportedModule;
+            const hasProgressSupport = currentModule && logging_1.PROGRESS_SUPPORTED_MODULES.includes(currentModule);
+            if (hasProgressSupport) {
+                // Plugin has progress bars - respect user's showConsoleLogs setting
+                showConsoleLogs = (_a = logConfig.showConsoleLogs) !== null && _a !== void 0 ? _a : true;
+            }
+            else {
+                // Plugin doesn't have progress support - always show console logs
+                showConsoleLogs = true;
+            }
+        }
+        if (showConsoleLogs) {
+            transports.push(new winston.transports.Console({
+                format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf((info) => {
+                    // Apply full redaction for console (user-facing)
+                    const redactedInfo = this.redact(info, true);
+                    const colorizer = winston.format.colorize();
+                    const levelText = redactedInfo.level.toUpperCase();
+                    const { timestamp, message } = redactedInfo;
+                    return colorizer.colorize(redactedInfo.level, `[${timestamp}] ${levelText}: ${message}`);
+                })),
+            }));
+        }
         return winston.createLogger({
             levels: logging_1.logLevels,
             level,
-            transports: [
-                new winston.transports.File(Object.assign(Object.assign({}, this.loggerOptions), { filename: `${filePath}/${level}.log`, format: winston.format.combine(winston.format.timestamp(), winston.format.printf((info) => {
-                        // Apply minimal redaction for files (debugging info preserved)
-                        const redactedInfo = this.redact(info, false);
-                        return JSON.stringify(redactedInfo);
-                    })) })),
-                new winston.transports.Console({
-                    format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf((info) => {
-                        // Apply full redaction for console (user-facing)
-                        const redactedInfo = this.redact(info, true);
-                        const colorizer = winston.format.colorize();
-                        const levelText = redactedInfo.level.toUpperCase();
-                        const { timestamp, message } = redactedInfo;
-                        return colorizer.colorize(redactedInfo.level, `[${timestamp}] ${levelText}: ${message}`);
-                    })),
-                }),
-            ],
+            transports,
         });
     }
     isSensitiveKey(keyStr, consoleMode = false) {

package/lib/progress-summary/cli-progress-manager.d.ts

@@ -0,0 +1,121 @@
+import SummaryManager from './summary-manager';
+import { ProgressManagerOptions } from '../interfaces';
+interface ProgressCallback {
+    onModuleStart?: (moduleName: string) => void;
+    onModuleComplete?: (moduleName: string, success: boolean, error?: string) => void;
+    onProgress?: (moduleName: string, success: boolean, itemName: string, error?: string) => void;
+}
+export default class CLIProgressManager {
+    private static globalSummary;
+    private showConsoleLogs;
+    private total;
+    private moduleName;
+    private enableNestedProgress;
+    private successCount;
+    private failureCount;
+    private failures;
+    private spinner;
+    private progressBar;
+    private processes;
+    private multiBar;
+    private currentProcess;
+    private callbacks;
+    private branchName;
+    constructor({ showConsoleLogs, total, moduleName, enableNestedProgress, }?: ProgressManagerOptions);
+    /**
+     * Initialize global summary manager for the entire operation
+     */
+    static initializeGlobalSummary(operationName: string, branchName: string, headerTitle?: string): SummaryManager;
+    /**
+     * Display operation header with branch information
+     */
+    static displayOperationHeader(branchName: string, headerTitle?: string): void;
+    /**
+     * Print the final summary for all modules using strategies
+     */
+    static printGlobalSummary(): void;
+    /**
+     * Apply strategy-based corrections to module data
+     */
+    private static applyStrategyCorrections;
+    /**
+     * Clear global summary (for cleanup)
+     */
+    static clearGlobalSummary(): void;
+    /**
+     * Create a simple progress manager (no nested processes)
+     */
+    static createSimple(moduleName: string, total?: number, showConsoleLogs?: boolean): CLIProgressManager;
+    /**
+     * Create a nested progress manager (with sub-processes)
+     */
+    static createNested(moduleName: string, showConsoleLogs?: boolean): CLIProgressManager;
+    /**
+     * Show a loading spinner before initializing progress
+     */
+    static withLoadingSpinner<T>(message: string, asyncOperation: () => Promise<T>): Promise<T>;
+    private setupGlobalSummaryIntegration;
+    /**
+     * Register process data with summary manager for strategy calculations
+     */
+    private registerProcessDataWithSummary;
+    /**
+     * Set callbacks for external integration
+     */
+    setCallbacks(callbacks: ProgressCallback): void;
+    /**
+     * Convert module name from UPPERCASE to PascalCase
+     */
+    private formatModuleName;
+    /**
+     * Format process name with smart truncation (modules should use short names)
+     */
+    private formatProcessName;
+    /**
+     * Format percentage for consistent alignment (always 3 characters)
+     */
+    private formatPercentage;
+    private initializeProgress;
+    /**
+     * Add a new process to track (for nested progress)
+     */
+    addProcess(processName: string, total: number): this;
+    /**
+     * Update the total for a specific process (for dynamic totals after API calls)
+     */
+    updateProcessTotal(processName: string, newTotal: number): this;
+    /**
+     * Start a specific process
+     */
+    startProcess(processName: string): this;
+    /**
+     * Complete a specific process
+     */
+    completeProcess(processName: string, success?: boolean): this;
+    /**
+     * Update status message
+     */
+    updateStatus(message: string, processName?: string): this;
+    /**
+     * Update progress
+     */
+    tick(success?: boolean, itemName?: string, errorMessage?: string | null, processName?: string): this;
+    /**
+     * Complete the entire module
+     */
+    complete(success?: boolean, error?: string): this;
+    /**
+     * Log message (respects showConsoleLogs mode)
+     */
+    log(msg: string): void;
+    /**
+     * Stop all progress indicators
+     */
+    stop(): void;
+    private printSummary;
+    /**
+     * Get the current failure count
+     */
+    getFailureCount(): number;
+}
+export {};

package/lib/progress-summary/cli-progress-manager.js

@@ -0,0 +1,530 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const cli_progress_1 = tslib_1.__importDefault(require("cli-progress"));
+const summary_manager_1 = tslib_1.__importDefault(require("./summary-manager"));
+const __1 = require("..");
+const progress_strategy_1 = require("./progress-strategy");
+class CLIProgressManager {
+    constructor({ showConsoleLogs = false, total = 0, moduleName = 'Module', enableNestedProgress = false, } = {}) {
+        this.showConsoleLogs = showConsoleLogs;
+        this.total = total;
+        this.moduleName = moduleName;
+        this.enableNestedProgress = enableNestedProgress;
+        this.successCount = 0;
+        this.failureCount = 0;
+        this.failures = [];
+        this.spinner = null;
+        this.progressBar = null;
+        this.processes = new Map();
+        this.multiBar = null;
+        this.currentProcess = null;
+        this.callbacks = {};
+        this.branchName = '';
+        this.initializeProgress();
+        this.setupGlobalSummaryIntegration();
+    }
+    /**
+     * Initialize global summary manager for the entire operation
+     */
+    static initializeGlobalSummary(operationName, branchName, headerTitle) {
+        var _a;
+        CLIProgressManager.globalSummary = new summary_manager_1.default({ operationName, context: { branchName } });
+        // Only show header if console logs are disabled (progress UI mode)
+        if (!((_a = __1.configHandler.get('log')) === null || _a === void 0 ? void 0 : _a.showConsoleLogs)) {
+            CLIProgressManager.displayOperationHeader(branchName, headerTitle);
+        }
+        return CLIProgressManager.globalSummary;
+    }
+    /**
+     * Display operation header with branch information
+     */
+    static displayOperationHeader(branchName, headerTitle) {
+        if (!headerTitle)
+            return;
+        const safeBranchName = branchName || 'main';
+        const branchInfo = headerTitle || `${safeBranchName === null || safeBranchName === void 0 ? void 0 : safeBranchName.toUpperCase()} CONTENT`;
+        console.log('\n' + chalk_1.default.bold('='.repeat(80)));
+        if (branchInfo) {
+            console.log(chalk_1.default.bold.white(`                   ${branchInfo}`));
+        }
+        console.log(chalk_1.default.bold('='.repeat(80)) + '\n');
+    }
+    /**
+     * Print the final summary for all modules using strategies
+     */
+    static printGlobalSummary() {
+        if (!CLIProgressManager.globalSummary) {
+            return;
+        }
+        // Apply strategy-based corrections before printing
+        CLIProgressManager.applyStrategyCorrections();
+        // Print the final summary
+        CLIProgressManager.globalSummary.printFinalSummary();
+    }
+    /**
+     * Apply strategy-based corrections to module data
+     */
+    static applyStrategyCorrections() {
+        if (!CLIProgressManager.globalSummary)
+            return;
+        const modules = Array.from(CLIProgressManager.globalSummary.getModules().values());
+        modules.forEach((module) => {
+            // Check if this module has a registered strategy
+            if (progress_strategy_1.ProgressStrategyRegistry.has(module.name)) {
+                const strategy = progress_strategy_1.ProgressStrategyRegistry.get(module.name);
+                // Create a processes map from module data if available
+                const processesMap = new Map();
+                // If module has process data, populate the map
+                if (module.processes && Array.isArray(module.processes)) {
+                    module.processes.forEach((processData) => {
+                        if (processData.processName) {
+                            processesMap.set(processData.processName, processData);
+                        }
+                    });
+                }
+                // Calculate corrected progress using strategy
+                const correctedResult = strategy.calculate(processesMap);
+                if (correctedResult) {
+                    // Update module with corrected counts
+                    module.totalItems = correctedResult.total;
+                    module.successCount = correctedResult.success;
+                    module.failureCount = correctedResult.failures;
+                }
+            }
+        });
+    }
+    /**
+     * Clear global summary (for cleanup)
+     */
+    static clearGlobalSummary() {
+        CLIProgressManager.globalSummary = null;
+    }
+    /**
+     * Create a simple progress manager (no nested processes)
+     */
+    static createSimple(moduleName, total, showConsoleLogs = false) {
+        return new CLIProgressManager({
+            moduleName: moduleName.toUpperCase(),
+            total: total || 0,
+            showConsoleLogs,
+            enableNestedProgress: false,
+        });
+    }
+    /**
+     * Create a nested progress manager (with sub-processes)
+     */
+    static createNested(moduleName, showConsoleLogs = false) {
+        return new CLIProgressManager({
+            moduleName: moduleName.toUpperCase(),
+            total: 0,
+            showConsoleLogs,
+            enableNestedProgress: true,
+        });
+    }
+    /**
+     * Show a loading spinner before initializing progress
+     */
+    static async withLoadingSpinner(message, asyncOperation) {
+        const spinner = (0, ora_1.default)(message).start();
+        try {
+            const result = await asyncOperation();
+            spinner.stop();
+            return result;
+        }
+        catch (error) {
+            spinner.stop();
+            throw error;
+        }
+    }
+    setupGlobalSummaryIntegration() {
+        var _a, _b;
+        // Auto-register with global summary if it exists
+        if (CLIProgressManager.globalSummary) {
+            this.setCallbacks({
+                onModuleStart: (name) => {
+                    var _a, _b;
+                    (_a = CLIProgressManager.globalSummary) === null || _a === void 0 ? void 0 : _a.registerModule(name, this.total);
+                    (_b = CLIProgressManager.globalSummary) === null || _b === void 0 ? void 0 : _b.startModule(name);
+                },
+                onModuleComplete: (name, success, error) => {
+                    var _a;
+                    // Register process data with summary manager before completing
+                    this.registerProcessDataWithSummary(name);
+                    (_a = CLIProgressManager.globalSummary) === null || _a === void 0 ? void 0 : _a.completeModule(name, success, error);
+                },
+                onProgress: (name, success, itemName, error) => {
+                    var _a;
+                    (_a = CLIProgressManager.globalSummary) === null || _a === void 0 ? void 0 : _a.updateModuleProgress(name, success, itemName, error);
+                },
+            });
+            // Trigger module start
+            (_b = (_a = this.callbacks).onModuleStart) === null || _b === void 0 ? void 0 : _b.call(_a, this.moduleName);
+        }
+    }
+    /**
+     * Register process data with summary manager for strategy calculations
+     */
+    registerProcessDataWithSummary(moduleName) {
+        if (!CLIProgressManager.globalSummary)
+            return;
+        // Register each process with the summary manager
+        this.processes.forEach((processData, processName) => {
+            var _a;
+            (_a = CLIProgressManager.globalSummary) === null || _a === void 0 ? void 0 : _a.registerProcessData(moduleName, processName, {
+                processName,
+                total: processData.total,
+                current: processData.current,
+                successCount: processData.successCount,
+                failureCount: processData.failureCount,
+                status: processData.status,
+                failures: processData.failures,
+            });
+        });
+    }
+    /**
+     * Set callbacks for external integration
+     */
+    setCallbacks(callbacks) {
+        this.callbacks = Object.assign(Object.assign({}, this.callbacks), callbacks);
+    }
+    /**
+     * Convert module name from UPPERCASE to PascalCase
+     */
+    formatModuleName(name) {
+        return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+    }
+    /**
+     * Format process name with smart truncation (modules should use short names)
+     */
+    formatProcessName(processName) {
+        const cleaned = processName.trim();
+        if (cleaned.length <= 20) {
+            return cleaned;
+        }
+        return cleaned.length <= 20 ? cleaned : cleaned.substring(0, 20) + '...';
+    }
+    /**
+     * Format percentage for consistent alignment (always 3 characters)
+     */
+    formatPercentage(percentage) {
+        if (percentage === 100) {
+            return '100';
+        }
+        else if (percentage >= 10) {
+            return ` ${percentage}`;
+        }
+        else {
+            return `  ${percentage}`;
+        }
+    }
+    initializeProgress() {
+        if (this.showConsoleLogs) {
+            return;
+        }
+        if (this.enableNestedProgress) {
+            // Initialize multi-bar for nested progress tracking
+            this.multiBar = new cli_progress_1.default.MultiBar({
+                clearOnComplete: false,
+                hideCursor: true,
+                format: ' {label} |' + chalk_1.default.cyan('{bar}') + '| {percentage}% | {value}/{total} | {status}',
+                barCompleteChar: '\u2588',
+                barIncompleteChar: '\u2591',
+            }, cli_progress_1.default.Presets.shades_classic);
+            if (!this.showConsoleLogs) {
+                console.log(chalk_1.default.bold.cyan(`\n${this.moduleName}:`));
+            }
+        }
+        else if (this.total > 0) {
+            if (!this.showConsoleLogs) {
+                console.log(chalk_1.default.bold.cyan(`\n${this.moduleName}:`));
+            }
+            this.progressBar = new cli_progress_1.default.SingleBar({
+                format: ' {label} |' + chalk_1.default.cyan('{bar}') + '| {percentage}% | {value}/{total} | {status}',
+                barCompleteChar: '\u2588',
+                barIncompleteChar: '\u2591',
+                hideCursor: true,
+            });
+            const formattedName = this.formatModuleName(this.moduleName);
+            const displayName = formattedName.length > 20 ? formattedName.substring(0, 17) + '...' : formattedName;
+            this.progressBar.start(this.total, 0, {
+                label: chalk_1.default.gray(`   └─ ${displayName}`.padEnd(25)),
+                status: chalk_1.default.gray('Starting...'),
+                percentage: '  0',
+            });
+        }
+        else {
+            this.spinner = (0, ora_1.default)(`${chalk_1.default.bold(this.moduleName)}: Processing...`).start();
+        }
+    }
+    /**
+     * Add a new process to track (for nested progress)
+     */
+    addProcess(processName, total) {
+        if (!this.enableNestedProgress || !this.multiBar)
+            return this;
+        const process = {
+            name: processName,
+            total,
+            current: 0,
+            status: 'pending',
+            successCount: 0,
+            failureCount: 0,
+            failures: [],
+        };
+        if (!this.showConsoleLogs) {
+            const displayName = this.formatProcessName(processName);
+            const indentedLabel = `  ├─ ${displayName}`.padEnd(25);
+            process.progressBar = this.multiBar.create(total, 0, {
+                label: chalk_1.default.gray(indentedLabel),
+                status: chalk_1.default.gray('Pending'),
+                percentage: '  0',
+            });
+        }
+        this.processes.set(processName, process);
+        return this;
+    }
+    /**
+     * Update the total for a specific process (for dynamic totals after API calls)
+     */
+    updateProcessTotal(processName, newTotal) {
+        if (!this.enableNestedProgress)
+            return this;
+        const process = this.processes.get(processName);
+        if (process) {
+            process.total = newTotal;
+            if (process.progressBar && !this.showConsoleLogs) {
+                // Update the progress bar with the new total
+                process.progressBar.setTotal(newTotal);
+            }
+        }
+        return this;
+    }
+    /**
+     * Start a specific process
+     */
+    startProcess(processName) {
+        if (!this.enableNestedProgress)
+            return this;
+        const process = this.processes.get(processName);
+        if (process) {
+            process.status = 'active';
+            if (!this.showConsoleLogs && process.progressBar) {
+                const displayName = this.formatProcessName(processName);
+                const indentedLabel = `  ├─ ${displayName}`.padEnd(25);
+                process.progressBar.update(0, {
+                    label: chalk_1.default.yellow(indentedLabel),
+                    status: chalk_1.default.yellow('Processing'),
+                    percentage: '  0',
+                });
+            }
+            this.currentProcess = processName;
+        }
+        return this;
+    }
+    /**
+     * Complete a specific process
+     */
+    completeProcess(processName, success = true) {
+        if (!this.enableNestedProgress)
+            return this;
+        const process = this.processes.get(processName);
+        if (process) {
+            process.status = success ? 'completed' : 'failed';
+            if (!this.showConsoleLogs && process.progressBar) {
+                const percentage = Math.round((process.current / process.total) * 100);
+                const formattedPercentage = this.formatPercentage(percentage);
+                const statusText = success
+                    ? chalk_1.default.green(`✓ Complete (${process.successCount}/${process.current})`)
+                    : chalk_1.default.red(`✗ Failed (${process.successCount}/${process.current})`);
+                const displayName = this.formatProcessName(processName);
+                const indentedLabel = `  ├─ ${displayName}`.padEnd(25);
+                process.progressBar.update(process.total, {
+                    label: success ? chalk_1.default.green(indentedLabel) : chalk_1.default.red(indentedLabel),
+                    status: statusText,
+                    percentage: formattedPercentage,
+                });
+            }
+        }
+        return this;
+    }
+    /**
+     * Update status message
+     */
+    updateStatus(message, processName) {
+        if (!this.showConsoleLogs) {
+            if (this.enableNestedProgress && processName) {
+                const process = this.processes.get(processName);
+                if (process && process.progressBar) {
+                    const percentage = Math.round((process.current / process.total) * 100);
+                    const formattedPercentage = this.formatPercentage(percentage);
+                    const displayName = this.formatProcessName(processName);
+                    const indentedLabel = `  ├─ ${displayName}`.padEnd(25);
+                    process.progressBar.update(process.current, {
+                        label: chalk_1.default.yellow(indentedLabel),
+                        status: chalk_1.default.yellow(message),
+                        percentage: formattedPercentage,
+                    });
+                }
+            }
+            else if (this.progressBar) {
+                const percentage = Math.round(this.progressBar.getProgress() * 100);
+                const formattedPercentage = this.formatPercentage(percentage);
+                const formattedName = this.formatModuleName(this.moduleName);
+                const displayName = formattedName.length > 20 ? formattedName.substring(0, 17) + '...' : formattedName;
+                this.progressBar.update(this.progressBar.getProgress() * this.total, {
+                    label: chalk_1.default.yellow(`   └─ ${displayName}`.padEnd(25)),
+                    status: chalk_1.default.yellow(message),
+                    percentage: formattedPercentage,
+                });
+            }
+            else if (this.spinner) {
+                this.spinner.text = `${chalk_1.default.bold(this.moduleName)}: ${message}`;
+            }
+        }
+        return this;
+    }
+    /**
+     * Update progress
+     */
+    tick(success = true, itemName = '', errorMessage = null, processName) {
+        var _a, _b;
+        const targetProcess = processName || this.currentProcess;
+        if (success) {
+            this.successCount++;
+        }
+        else {
+            this.failureCount++;
+            this.failures.push({
+                item: itemName,
+                error: errorMessage,
+                process: targetProcess || undefined,
+            });
+        }
+        // Trigger callback
+        (_b = (_a = this.callbacks).onProgress) === null || _b === void 0 ? void 0 : _b.call(_a, this.moduleName, success, itemName, errorMessage || undefined);
+        // Update nested progress if enabled and console logs are disabled
+        if (this.enableNestedProgress && targetProcess) {
+            const process = this.processes.get(targetProcess);
+            if (process) {
+                process.current++;
+                if (success) {
+                    process.successCount++;
+                }
+                else {
+                    process.failureCount++;
+                    process.failures.push({ item: itemName, error: errorMessage });
+                }
+                // Only update progress bar if console logs are disabled
+                if (!this.showConsoleLogs && process.progressBar) {
+                    const percentage = Math.round((process.current / process.total) * 100);
+                    const formattedPercentage = this.formatPercentage(percentage);
+                    const statusText = `${process.successCount}✓ ${process.failureCount}✗`;
+                    const displayName = this.formatProcessName(targetProcess);
+                    const indentedLabel = `  ├─ ${displayName}`.padEnd(25);
+                    process.progressBar.increment(1, {
+                        label: chalk_1.default.cyan(indentedLabel),
+                        status: chalk_1.default.cyan(statusText),
+                        percentage: formattedPercentage,
+                    });
+                }
+            }
+        }
+        else {
+            // Update single progress bar or spinner only if console logs are disabled
+            if (!this.showConsoleLogs) {
+                if (this.progressBar) {
+                    const percentage = Math.round(((this.successCount + this.failureCount) / this.total) * 100);
+                    const formattedPercentage = this.formatPercentage(percentage);
+                    const totalProcessed = this.successCount + this.failureCount;
+                    // Show completion status when finished, otherwise show running count
+                    const statusText = totalProcessed >= this.total
+                        ? this.failureCount === 0
+                            ? chalk_1.default.green(`✓ Complete (${this.successCount}/${totalProcessed})`)
+                            : chalk_1.default.yellow(`✓ Complete (${this.successCount}/${totalProcessed})`)
+                        : chalk_1.default.cyan(`${this.successCount}✓ ${this.failureCount}✗`);
+                    const labelColor = totalProcessed >= this.total ? (this.failureCount === 0 ? chalk_1.default.green : chalk_1.default.yellow) : chalk_1.default.cyan;
+                    const formattedName = this.formatModuleName(this.moduleName);
+                    const displayName = formattedName.length > 20 ? formattedName.substring(0, 17) + '...' : formattedName;
+                    this.progressBar.increment(1, {
+                        label: labelColor(`   └─ ${displayName}`.padEnd(25)),
+                        status: statusText,
+                        percentage: formattedPercentage,
+                    });
+                }
+                else if (this.spinner) {
+                    const total = this.successCount + this.failureCount;
+                    this.spinner.text = `${chalk_1.default.bold(this.moduleName)}: ${total} items (${this.successCount}✓ ${this.failureCount}✗)`;
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * Complete the entire module
+     */
+    complete(success = true, error) {
+        var _a, _b;
+        this.stop();
+        (_b = (_a = this.callbacks).onModuleComplete) === null || _b === void 0 ? void 0 : _b.call(_a, this.moduleName, success, error);
+        return this;
+    }
+    /**
+     * Log message (respects showConsoleLogs mode)
+     */
+    log(msg) {
+        if (this.showConsoleLogs) {
+            console.log(msg);
+        }
+    }
+    /**
+     * Stop all progress indicators
+     */
+    stop() {
+        // Only stop progress bars if they were initialized (console logs disabled)
+        if (!this.showConsoleLogs) {
+            if (this.multiBar) {
+                this.multiBar.stop();
+            }
+            if (this.progressBar) {
+                this.progressBar.stop();
+            }
+            if (this.spinner) {
+                this.spinner.stop();
+            }
+            this.printSummary();
+        }
+    }
+    printSummary() {
+        if (!this.enableNestedProgress) {
+            // Simple summary for single progress
+            this.log('\n' + chalk_1.default.bold(`${this.moduleName} Summary:`));
+            this.log(`✓ Success: ${chalk_1.default.green(this.successCount)}`);
+            this.log(`✗ Failures: ${chalk_1.default.red(this.failureCount)}`);
+            return;
+        }
+        // Detailed summary for nested progress
+        this.log('\n' + chalk_1.default.bold(`${this.moduleName} Detailed Summary:`));
+        for (const [processName, process] of this.processes) {
+            const status = process.status === 'completed'
+                ? '✓'
+                : process.status === 'failed'
+                    ? '✗'
+                    : process.status === 'active'
+                        ? '●'
+                        : '○';
+            this.log(`  ${status} ${processName}: ${process.successCount}✓ ${process.failureCount}✗ (${process.current}/${process.total})`);
+        }
+        this.log(`\nOverall: ${this.successCount}✓ ${this.failureCount}✗`);
+    }
+    /**
+     * Get the current failure count
+     */
+    getFailureCount() {
+        return this.failureCount;
+    }
+}
+exports.default = CLIProgressManager;
+CLIProgressManager.globalSummary = null;

package/lib/progress-summary/index.d.ts

@@ -0,0 +1,4 @@
+import SummaryManager from './summary-manager';
+import CLIProgressManager from './cli-progress-manager';
+import { PrimaryProcessStrategy, CustomProgressStrategy, ProgressStrategyRegistry, DefaultProgressStrategy } from './progress-strategy';
+export { SummaryManager, CLIProgressManager, PrimaryProcessStrategy, CustomProgressStrategy, ProgressStrategyRegistry, DefaultProgressStrategy, };

package/lib/progress-summary/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultProgressStrategy = exports.ProgressStrategyRegistry = exports.CustomProgressStrategy = exports.PrimaryProcessStrategy = exports.CLIProgressManager = exports.SummaryManager = void 0;
+const tslib_1 = require("tslib");
+const summary_manager_1 = tslib_1.__importDefault(require("./summary-manager"));
+exports.SummaryManager = summary_manager_1.default;
+const cli_progress_manager_1 = tslib_1.__importDefault(require("./cli-progress-manager"));
+exports.CLIProgressManager = cli_progress_manager_1.default;
+const progress_strategy_1 = require("./progress-strategy");
+Object.defineProperty(exports, "PrimaryProcessStrategy", { enumerable: true, get: function () { return progress_strategy_1.PrimaryProcessStrategy; } });
+Object.defineProperty(exports, "CustomProgressStrategy", { enumerable: true, get: function () { return progress_strategy_1.CustomProgressStrategy; } });
+Object.defineProperty(exports, "ProgressStrategyRegistry", { enumerable: true, get: function () { return progress_strategy_1.ProgressStrategyRegistry; } });
+Object.defineProperty(exports, "DefaultProgressStrategy", { enumerable: true, get: function () { return progress_strategy_1.DefaultProgressStrategy; } });

package/lib/progress-summary/progress-strategy.d.ts

@@ -0,0 +1,25 @@
+import { ProcessProgress, ProgressResult } from '../interfaces';
+export interface ProgressCalculationStrategy {
+    calculate(processes: Map<string, ProcessProgress>): ProgressResult | null;
+}
+export declare class DefaultProgressStrategy implements ProgressCalculationStrategy {
+    calculate(): ProgressResult | null;
+}
+export declare class PrimaryProcessStrategy implements ProgressCalculationStrategy {
+    private primaryProcessName;
+    constructor(primaryProcessName: string);
+    calculate(processes: Map<string, ProcessProgress>): ProgressResult | null;
+}
+export declare class CustomProgressStrategy implements ProgressCalculationStrategy {
+    private calculator;
+    constructor(calculator: (processes: Map<string, ProcessProgress>) => ProgressResult | null);
+    calculate(processes: Map<string, ProcessProgress>): ProgressResult | null;
+}
+export declare class ProgressStrategyRegistry {
+    private static strategies;
+    static register(moduleName: string, strategy: ProgressCalculationStrategy): void;
+    static get(moduleName: string): ProgressCalculationStrategy;
+    static clear(): void;
+    static has(moduleName: string): boolean;
+    static getAllRegistered(): string[];
+}

package/lib/progress-summary/progress-strategy.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressStrategyRegistry = exports.CustomProgressStrategy = exports.PrimaryProcessStrategy = exports.DefaultProgressStrategy = void 0;
+class DefaultProgressStrategy {
+    calculate() {
+        return null; // Use default aggregated counting
+    }
+}
+exports.DefaultProgressStrategy = DefaultProgressStrategy;
+class PrimaryProcessStrategy {
+    constructor(primaryProcessName) {
+        this.primaryProcessName = primaryProcessName;
+    }
+    calculate(processes) {
+        const primaryProcess = processes.get(this.primaryProcessName);
+        if (!primaryProcess)
+            return null;
+        return {
+            total: primaryProcess.total,
+            success: primaryProcess.successCount,
+            failures: primaryProcess.failureCount
+        };
+    }
+}
+exports.PrimaryProcessStrategy = PrimaryProcessStrategy;
+class CustomProgressStrategy {
+    constructor(calculator) {
+        this.calculator = calculator;
+    }
+    calculate(processes) {
+        return this.calculator(processes);
+    }
+}
+exports.CustomProgressStrategy = CustomProgressStrategy;
+// Registry
+class ProgressStrategyRegistry {
+    static register(moduleName, strategy) {
+        this.strategies.set(moduleName.toUpperCase(), strategy);
+    }
+    static get(moduleName) {
+        return this.strategies.get(moduleName.toUpperCase()) || new DefaultProgressStrategy();
+    }
+    static clear() {
+        this.strategies.clear();
+    }
+    static has(moduleName) {
+        return this.strategies.has(moduleName.toUpperCase());
+    }
+    static getAllRegistered() {
+        return Array.from(this.strategies.keys());
+    }
+}
+exports.ProgressStrategyRegistry = ProgressStrategyRegistry;
+ProgressStrategyRegistry.strategies = new Map();

package/lib/progress-summary/summary-manager.d.ts

@@ -0,0 +1,24 @@
+import { ModuleResult, SummaryOptions } from '../interfaces/index';
+export default class SummaryManager {
+    private modules;
+    private operationName;
+    private context;
+    private operationStartTime;
+    private branchName;
+    constructor({ operationName, context }: SummaryOptions);
+    getModules(): Map<string, ModuleResult>;
+    registerModule(moduleName: string, totalItems?: number): void;
+    startModule(moduleName: string): void;
+    completeModule(moduleName: string, success?: boolean, error?: string): void;
+    /**
+     * Register process data for strategy calculations
+     */
+    registerProcessData(moduleName: string, processName: string, processData: any): void;
+    updateModuleProgress(moduleName: string, success: boolean, itemName: string, error?: string): void;
+    printFinalSummary(): void;
+    private printFailureSummaryWithLogReference;
+    private getStatusIcon;
+    private formatDuration;
+    private calculateSuccessRate;
+    private formatSuccessRate;
+}

package/lib/progress-summary/summary-manager.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class SummaryManager {
+    constructor({ operationName, context }) {
+        this.modules = new Map();
+        this.operationName = operationName;
+        this.context = context;
+        this.operationStartTime = Date.now();
+        this.branchName = context.branchName || '';
+    }
+    getModules() {
+        return this.modules;
+    }
+    registerModule(moduleName, totalItems = 0) {
+        this.modules.set(moduleName, {
+            name: moduleName,
+            status: 'pending',
+            totalItems,
+            successCount: 0,
+            failureCount: 0,
+            failures: [],
+            processes: [],
+        });
+    }
+    startModule(moduleName) {
+        const module = this.modules.get(moduleName);
+        if (module) {
+            module.status = 'running';
+            module.startTime = Date.now();
+        }
+    }
+    completeModule(moduleName, success = true, error) {
+        const module = this.modules.get(moduleName);
+        if (module) {
+            module.status = success ? 'completed' : 'failed';
+            module.endTime = Date.now();
+            if (!success && error) {
+                module.failures.push({ item: 'module', error });
+            }
+        }
+    }
+    /**
+     * Register process data for strategy calculations
+     */
+    registerProcessData(moduleName, processName, processData) {
+        const module = this.modules.get(moduleName);
+        if (module) {
+            if (!module.processes) {
+                module.processes = [];
+            }
+            const existingIndex = module.processes.findIndex((p) => p.processName === processName);
+            if (existingIndex >= 0) {
+                module.processes[existingIndex] = Object.assign({ processName }, processData);
+            }
+            else {
+                module.processes.push(Object.assign({ processName }, processData));
+            }
+        }
+    }
+    updateModuleProgress(moduleName, success, itemName, error) {
+        const module = this.modules.get(moduleName);
+        if (module) {
+            if (success) {
+                module.successCount++;
+            }
+            else {
+                module.failureCount++;
+                if (error) {
+                    module.failures.push({ item: itemName, error });
+                }
+            }
+        }
+    }
+    printFinalSummary() {
+        const operationEndTime = Date.now();
+        const totalDuration = operationEndTime - this.operationStartTime;
+        // Overall Statistics
+        const totalModules = this.modules.size;
+        const completedModules = Array.from(this.modules.values()).filter((m) => m.status === 'completed').length;
+        const failedModules = Array.from(this.modules.values()).filter((m) => m.status === 'failed').length;
+        const totalItems = Array.from(this.modules.values()).reduce((sum, m) => sum + m.successCount + m.failureCount, 0);
+        const totalSuccess = Array.from(this.modules.values()).reduce((sum, m) => sum + m.successCount, 0);
+        const totalFailures = Array.from(this.modules.values()).reduce((sum, m) => sum + m.failureCount, 0);
+        console.log('\n' + chalk_1.default.bold('='.repeat(80)));
+        console.log('\n' + chalk_1.default.bold('Overall Statistics:'));
+        console.log(`  Total ${this.operationName} Time: ${chalk_1.default.cyan(this.formatDuration(totalDuration))}`);
+        console.log(`  Modules Processed: ${chalk_1.default.cyan(completedModules)}/${chalk_1.default.cyan(totalModules)}`);
+        console.log(`  Items Processed: ${chalk_1.default.green(totalSuccess)} success, ${chalk_1.default.red(totalFailures)} failed of ${chalk_1.default.cyan(totalItems)} total`);
+        console.log(`  Success Rate: ${chalk_1.default.cyan(this.calculateSuccessRate(totalSuccess, totalItems))}%`);
+        // Module Details
+        console.log('\n' + chalk_1.default.bold('Module Details:'));
+        console.log(chalk_1.default.gray('-'.repeat(80)));
+        Array.from(this.modules.values()).forEach((module) => {
+            const status = this.getStatusIcon(module.status);
+            const totalCount = module.successCount + module.failureCount;
+            const duration = module.endTime && module.startTime ? this.formatDuration(module.endTime - module.startTime) : 'N/A';
+            const successRate = this.calculateSuccessRate(module.successCount, totalCount);
+            console.log(`${status} ${module.name.padEnd(20)} | ` +
+                `${String(module.successCount).padStart(4)}/${String(totalCount).padStart(4)} items | ` +
+                `${this.formatSuccessRate(successRate).padStart(6)} | ` +
+                `${duration.padStart(8)}`);
+        });
+        // Final Status
+        console.log('\n' + chalk_1.default.bold('Final Status:'));
+        if (failedModules === 0) {
+            console.log(chalk_1.default.bold.green(`🎉 ${this.operationName} completed successfully!`));
+        }
+        else if (completedModules > 0) {
+            console.log(chalk_1.default.bold.yellow(`⚠️  ${this.operationName} completed with ${failedModules} failed modules`));
+        }
+        else {
+            console.log(chalk_1.default.bold.red(`❌ ${this.operationName} failed`));
+        }
+        console.log(chalk_1.default.bold('='.repeat(80)));
+        console.log(chalk_1.default.bold('='.repeat(80)));
+        // Simple failure summary with log reference
+        this.printFailureSummaryWithLogReference();
+    }
+    printFailureSummaryWithLogReference() {
+        const modulesWithFailures = Array.from(this.modules.values()).filter((m) => m.failures.length > 0);
+        if (modulesWithFailures.length === 0)
+            return;
+        const totalFailures = modulesWithFailures.reduce((sum, m) => sum + m.failures.length, 0);
+        console.log('\n' + chalk_1.default.bold.red('Failure Summary:'));
+        console.log(chalk_1.default.red('-'.repeat(50)));
+        modulesWithFailures.forEach((module) => {
+            console.log(`${chalk_1.default.bold.red('✗')} ${chalk_1.default.bold(module.name)}: ${chalk_1.default.red(module.failures.length)} failures`);
+            // Show just first 2-3 failures briefly
+            const preview = module.failures.slice(0, 2);
+            preview.forEach((failure) => {
+                console.log(`    • ${chalk_1.default.gray(failure.item)}`);
+            });
+            if (module.failures.length > 2) {
+                console.log(`    ${chalk_1.default.gray(`... and ${module.failures.length - 2} more`)}`);
+            }
+        });
+        console.log(chalk_1.default.blue('\n📋 For detailed error information, check the log files:'));
+        //console.log(chalk.blue(`   ${getLogPath()}`));
+        console.log(chalk_1.default.gray('   Recent errors are logged with full context and stack traces.'));
+    }
+    getStatusIcon(status) {
+        switch (status) {
+            case 'completed':
+                return chalk_1.default.green('✓');
+            case 'failed':
+                return chalk_1.default.red('✗');
+            case 'running':
+                return chalk_1.default.yellow('●');
+            case 'pending':
+                return chalk_1.default.gray('○');
+            default:
+                return chalk_1.default.gray('?');
+        }
+    }
+    formatDuration(ms) {
+        if (ms < 1000)
+            return `${ms}ms`;
+        if (ms < 60000)
+            return `${(ms / 1000).toFixed(1)}s`;
+        return `${(ms / 60000).toFixed(1)}m`;
+    }
+    calculateSuccessRate(success, total) {
+        if (total === 0)
+            return '0';
+        return ((success / total) * 100).toFixed(1);
+    }
+    formatSuccessRate(rate) {
+        if (rate === '100.0') {
+            return '100%';
+        }
+        else if (parseFloat(rate) >= 10) {
+            return `${rate}%`;
+        }
+        else {
+            return ` ${rate}%`;
+        }
+    }
+}
+exports.default = SummaryManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-utilities",
-  "version": "1.14.2",
+  "version": "1.15.0",
   "description": "Utilities for contentstack projects",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",