@contentstack/cli-utilities 1.17.4 → 2.0.0-beta.1

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

@@ -0,0 +1,550 @@
+"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.
+     * When showConsoleLogs is enabled, skip the Progress Manager summary block
+     * so output is pure timestamped log lines (per documentation).
+     */
+    static printGlobalSummary() {
+        if (!CLIProgressManager.globalSummary) {
+            return;
+        }
+        // Apply strategy-based corrections before printing
+        CLIProgressManager.applyStrategyCorrections();
+        // Print the final summary
+        CLIProgressManager.globalSummary.printFinalSummary();
+    }
+    /**
+     * Check if there are any failures in the global summary
+     */
+    static hasFailures() {
+        if (!CLIProgressManager.globalSummary) {
+            return false;
+        }
+        return CLIProgressManager.globalSummary.hasFailures();
+    }
+    /**
+     * 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)
+            return this;
+        const process = {
+            name: processName,
+            total,
+            current: 0,
+            status: 'pending',
+            successCount: 0,
+            failureCount: 0,
+            failures: [],
+        };
+        if (!this.showConsoleLogs && this.multiBar) {
+            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 process completed without ticks, update current to reflect completion
+            if (process.current === 0 && process.total > 0) {
+                process.current = process.total;
+                if (process.status === 'completed') {
+                    process.successCount = process.total;
+                }
+            }
+            if (!this.showConsoleLogs && process.progressBar) {
+                const totalProcessed = process.current;
+                const percentage = Math.round((totalProcessed / 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() {
+        // Stop progress bars if they were initialized
+        if (this.multiBar) {
+            this.multiBar.stop();
+        }
+        if (this.progressBar) {
+            this.progressBar.stop();
+        }
+        if (this.spinner) {
+            this.spinner.stop();
+        }
+    }
+    printSummary() {
+        // In console logs mode, use only timestamped log lines (no Progress Manager blocks)
+        if (this.showConsoleLogs) {
+            return;
+        }
+        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,28 @@
+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;
+    /**
+     * Check if there are any failures across all modules
+     */
+    hasFailures(): boolean;
+    private printFailureSummaryWithLogReference;
+    private getStatusIcon;
+    private formatDuration;
+    private calculateSuccessRate;
+    private formatSuccessRate;
+}