@wundr.io/cli 1.0.12 → 1.0.14

package/dist/commands/performance-optimizer.js

@@ -0,0 +1,650 @@
+"use strict";
+/**
+ * Performance Optimizer Command - Memory and Concurrency Optimization
+ * Implements intelligent optimization strategies for Wundr platform performance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceOptimizerCommands = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const perf_hooks_1 = require("perf_hooks");
+const process_1 = require("process");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+/**
+ * Memory optimization strategies
+ */
+class MemoryOptimizer {
+    baselineMetrics = null;
+    optimizations = [];
+    async analyzeMemoryUsage() {
+        const results = [];
+        const currentMemory = (0, process_1.memoryUsage)();
+        logger_1.logger.info('Analyzing memory usage patterns...');
+        // Check for memory pressure
+        if (currentMemory.heapUsed / currentMemory.heapTotal > 0.8) {
+            results.push({
+                category: 'memory',
+                description: 'High heap utilization detected',
+                impact: 'high',
+                effort: 'medium',
+                automated: true,
+                applied: false,
+                metrics: {
+                    heapUtilization: currentMemory.heapUsed / currentMemory.heapTotal,
+                    heapUsed: currentMemory.heapUsed,
+                    heapTotal: currentMemory.heapTotal,
+                },
+                recommendations: [
+                    'Enable garbage collection optimization',
+                    'Implement object pooling for frequently created objects',
+                    'Add memory leak detection monitoring',
+                    'Reduce object retention in caches',
+                ],
+            });
+        }
+        // Check for excessive external memory usage
+        if (currentMemory.external > 100 * 1024 * 1024) {
+            // 100MB
+            results.push({
+                category: 'memory',
+                description: 'High external memory usage',
+                impact: 'medium',
+                effort: 'low',
+                automated: true,
+                applied: false,
+                metrics: {
+                    externalMemory: currentMemory.external,
+                    externalMemoryMB: currentMemory.external / (1024 * 1024),
+                },
+                recommendations: [
+                    'Review buffer usage and cleanup',
+                    'Optimize file handling operations',
+                    'Implement streaming for large data processing',
+                ],
+            });
+        }
+        // Check RSS vs heap ratio
+        const rssHeapRatio = currentMemory.rss / currentMemory.heapTotal;
+        if (rssHeapRatio > 2.5) {
+            results.push({
+                category: 'memory',
+                description: 'High RSS to heap ratio indicates memory fragmentation',
+                impact: 'medium',
+                effort: 'high',
+                automated: false,
+                applied: false,
+                metrics: {
+                    rssHeapRatio,
+                    rss: currentMemory.rss,
+                    heapTotal: currentMemory.heapTotal,
+                },
+                recommendations: [
+                    'Consider memory pool allocation strategies',
+                    'Review large object allocations',
+                    'Implement periodic garbage collection hints',
+                ],
+            });
+        }
+        return results;
+    }
+    async optimizeMemoryUsage(optimizations) {
+        for (const opt of optimizations.filter(o => o.automated && !o.applied)) {
+            logger_1.logger.info(`Applying memory optimization: ${opt.description}`);
+            try {
+                switch (opt.category) {
+                    case 'memory':
+                        await this.applyMemoryOptimization(opt);
+                        break;
+                }
+                opt.applied = true;
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to apply optimization: ${opt.description}`, error);
+            }
+        }
+    }
+    async applyMemoryOptimization(opt) {
+        // Force garbage collection if available
+        if (global.gc &&
+            opt.metrics?.['heapUtilization'] &&
+            opt.metrics['heapUtilization'] > 0.8) {
+            global.gc();
+            logger_1.logger.info('Forced garbage collection to reclaim memory');
+        }
+        // Adjust Node.js memory settings if needed
+        if (opt.metrics?.['heapUsed'] &&
+            opt.metrics['heapUsed'] > 1024 * 1024 * 1024) {
+            // 1GB
+            logger_1.logger.warn('Consider increasing Node.js heap size with --max-old-space-size');
+        }
+    }
+}
+/**
+ * Concurrency optimization strategies
+ */
+class ConcurrencyOptimizer {
+    workerThreads = require('os').cpus().length;
+    taskQueues = new Map();
+    activeWorkers = 0;
+    async analyzeConcurrency() {
+        const results = [];
+        logger_1.logger.info('Analyzing concurrency patterns...');
+        // Check CPU core utilization
+        const cpuInfo = (0, process_1.cpuUsage)();
+        const cpuUtilization = (cpuInfo.user + cpuInfo.system) / 1000000; // Convert to seconds
+        if (this.activeWorkers < this.workerThreads * 0.7) {
+            results.push({
+                category: 'concurrency',
+                description: 'Underutilized CPU cores detected',
+                impact: 'high',
+                effort: 'low',
+                automated: true,
+                applied: false,
+                metrics: {
+                    availableCores: this.workerThreads,
+                    activeWorkers: this.activeWorkers,
+                    utilization: this.activeWorkers / this.workerThreads,
+                    cpuUtilization,
+                },
+                recommendations: [
+                    'Increase worker thread pool size',
+                    'Implement parallel task processing',
+                    'Use worker threads for CPU-intensive operations',
+                    'Enable batch processing for multiple tasks',
+                ],
+            });
+        }
+        // Check for task queue bottlenecks
+        for (const [queueName, tasks] of this.taskQueues) {
+            if (tasks.length > 100) {
+                results.push({
+                    category: 'concurrency',
+                    description: `High task queue backlog in ${queueName}`,
+                    impact: 'medium',
+                    effort: 'medium',
+                    automated: true,
+                    applied: false,
+                    metrics: {
+                        queueSize: tasks.length,
+                    },
+                    metadata: {
+                        queueName: queueName,
+                    },
+                    recommendations: [
+                        'Implement backpressure handling',
+                        'Increase queue processing workers',
+                        'Add task prioritization',
+                        'Consider task batching strategies',
+                    ],
+                });
+            }
+        }
+        return results;
+    }
+    async optimizeConcurrency(optimizations) {
+        for (const opt of optimizations.filter(o => o.automated && !o.applied)) {
+            logger_1.logger.info(`Applying concurrency optimization: ${opt.description}`);
+            try {
+                await this.applyConcurrencyOptimization(opt);
+                opt.applied = true;
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to apply optimization: ${opt.description}`, error);
+            }
+        }
+    }
+    async applyConcurrencyOptimization(opt) {
+        if (opt.metrics?.['utilization'] && opt.metrics['utilization'] < 0.7) {
+            // Increase worker thread pool for better CPU utilization
+            const newWorkerCount = Math.min(this.workerThreads, Math.floor(this.workerThreads * 1.2));
+            logger_1.logger.info(`Increasing worker threads from ${this.activeWorkers} to ${newWorkerCount}`);
+            // Implementation would update the actual worker pool
+        }
+    }
+    updateTaskQueue(queueName, tasks) {
+        this.taskQueues.set(queueName, tasks);
+    }
+    updateActiveWorkers(count) {
+        this.activeWorkers = count;
+    }
+}
+/**
+ * Bundle and asset optimization
+ */
+class AssetOptimizer {
+    async analyzeBundleSize(projectPath) {
+        const results = [];
+        try {
+            const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+            if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+                const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+                // Check for large dependencies
+                const dependencies = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies,
+                };
+                const largeDeps = Object.keys(dependencies).filter(dep => {
+                    // This is a simplified check - in reality you'd analyze actual bundle sizes
+                    return (dep.includes('lodash') ||
+                        dep.includes('moment') ||
+                        dep.includes('rxjs'));
+                });
+                if (largeDeps.length > 0) {
+                    results.push({
+                        category: 'memory',
+                        description: 'Large dependencies detected that could be optimized',
+                        impact: 'medium',
+                        effort: 'low',
+                        automated: false,
+                        applied: false,
+                        metrics: {
+                            largeDependencies: largeDeps.length,
+                            totalDependencies: largeDeps.length,
+                        },
+                        metadata: {
+                            dependencies: largeDeps,
+                        },
+                        recommendations: [
+                            'Use tree-shaking to reduce bundle size',
+                            'Replace large libraries with lighter alternatives',
+                            'Implement dynamic imports for non-critical code',
+                            'Use bundle analyzer to identify optimization opportunities',
+                        ],
+                    });
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn('Could not analyze bundle size:', error.message);
+        }
+        return results;
+    }
+}
+/**
+ * Main Performance Optimizer Commands
+ */
+class PerformanceOptimizerCommands {
+    program;
+    configManager;
+    memoryOptimizer = new MemoryOptimizer();
+    concurrencyOptimizer = new ConcurrencyOptimizer();
+    assetOptimizer = new AssetOptimizer();
+    constructor(program, configManager) {
+        this.program = program;
+        this.configManager = configManager;
+        this.registerCommands();
+    }
+    registerCommands() {
+        const optimizeCmd = this.program
+            .command('optimize')
+            .description('optimize performance, memory usage, and concurrency');
+        // Memory optimization
+        optimizeCmd
+            .command('memory')
+            .description('optimize memory usage and detect leaks')
+            .option('--analyze-only', 'only analyze without applying optimizations')
+            .option('--force-gc', 'force garbage collection')
+            .option('--report <path>', 'generate detailed memory report')
+            .action(async (options) => {
+            await this.optimizeMemory(options);
+        });
+        // Concurrency optimization
+        optimizeCmd
+            .command('concurrency')
+            .description('optimize concurrent processing and worker utilization')
+            .option('--analyze-only', 'only analyze without applying optimizations')
+            .option('--workers <count>', 'set number of worker threads')
+            .option('--queue-size <size>', 'set maximum queue size')
+            .action(async (options) => {
+            await this.optimizeConcurrency(options);
+        });
+        // Bundle optimization
+        optimizeCmd
+            .command('bundle')
+            .description('optimize bundle size and asset loading')
+            .option('--analyze', 'analyze bundle composition')
+            .option('--compress', 'enable compression optimizations')
+            .action(async (options) => {
+            await this.optimizeBundle(options);
+        });
+        // Full optimization suite
+        optimizeCmd
+            .command('all')
+            .description('run all optimization analyses and apply safe optimizations')
+            .option('--dry-run', 'show what would be optimized without applying changes')
+            .option('--report <path>', 'generate comprehensive optimization report')
+            .action(async (options) => {
+            await this.optimizeAll(options);
+        });
+        // Performance monitoring
+        optimizeCmd
+            .command('monitor')
+            .description('start real-time performance monitoring')
+            .option('--duration <seconds>', 'monitoring duration', '60')
+            .option('--interval <ms>', 'measurement interval', '1000')
+            .action(async (options) => {
+            await this.startMonitoring(options);
+        });
+        // Benchmarking
+        optimizeCmd
+            .command('benchmark')
+            .description('run performance benchmarks')
+            .option('--scenarios <scenarios>', 'comma-separated list of scenarios')
+            .option('--iterations <count>', 'number of benchmark iterations', '10')
+            .action(async (options) => {
+            await this.runBenchmarks(options);
+        });
+    }
+    async optimizeMemory(options) {
+        try {
+            logger_1.logger.info('🚀 Starting memory optimization...');
+            const optimizations = await this.memoryOptimizer.analyzeMemoryUsage();
+            if (optimizations.length === 0) {
+                logger_1.logger.success('✅ Memory usage is already optimized!');
+                return;
+            }
+            logger_1.logger.info(`Found ${optimizations.length} memory optimization opportunities:`);
+            optimizations.forEach(opt => {
+                const impactColor = opt.impact === 'high'
+                    ? 'red'
+                    : opt.impact === 'medium'
+                        ? 'yellow'
+                        : 'green';
+                console.log(`  ${chalk_1.default[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`);
+            });
+            if (!options.analyzeOnly) {
+                await this.memoryOptimizer.optimizeMemoryUsage(optimizations);
+                const applied = optimizations.filter(o => o.applied).length;
+                logger_1.logger.success(`✅ Applied ${applied} memory optimizations`);
+            }
+            if (options.report) {
+                await this.generateOptimizationReport(optimizations, options.report, 'memory');
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_MEMORY_OPTIMIZATION_FAILED', 'Failed to optimize memory usage', { options }, true);
+        }
+    }
+    async optimizeConcurrency(options) {
+        try {
+            logger_1.logger.info('🚀 Starting concurrency optimization...');
+            if (options.workers) {
+                this.concurrencyOptimizer.updateActiveWorkers(parseInt(options.workers));
+            }
+            const optimizations = await this.concurrencyOptimizer.analyzeConcurrency();
+            if (optimizations.length === 0) {
+                logger_1.logger.success('✅ Concurrency is already optimized!');
+                return;
+            }
+            logger_1.logger.info(`Found ${optimizations.length} concurrency optimization opportunities:`);
+            optimizations.forEach(opt => {
+                const impactColor = opt.impact === 'high'
+                    ? 'red'
+                    : opt.impact === 'medium'
+                        ? 'yellow'
+                        : 'green';
+                console.log(`  ${chalk_1.default[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`);
+            });
+            if (!options.analyzeOnly) {
+                await this.concurrencyOptimizer.optimizeConcurrency(optimizations);
+                const applied = optimizations.filter(o => o.applied).length;
+                logger_1.logger.success(`✅ Applied ${applied} concurrency optimizations`);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CONCURRENCY_OPTIMIZATION_FAILED', 'Failed to optimize concurrency', { options }, true);
+        }
+    }
+    async optimizeBundle(options) {
+        try {
+            logger_1.logger.info('🚀 Starting bundle optimization...');
+            const projectPath = process.cwd();
+            const optimizations = await this.assetOptimizer.analyzeBundleSize(projectPath);
+            if (optimizations.length === 0) {
+                logger_1.logger.success('✅ Bundle is already optimized!');
+                return;
+            }
+            logger_1.logger.info(`Found ${optimizations.length} bundle optimization opportunities:`);
+            optimizations.forEach(opt => {
+                const impactColor = opt.impact === 'high'
+                    ? 'red'
+                    : opt.impact === 'medium'
+                        ? 'yellow'
+                        : 'green';
+                console.log(`  ${chalk_1.default[impactColor](`[${opt.impact.toUpperCase()}]`)} ${opt.description}`);
+                opt.recommendations.forEach(rec => console.log(`    • ${rec}`));
+            });
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BUNDLE_OPTIMIZATION_FAILED', 'Failed to optimize bundle', { options }, true);
+        }
+    }
+    async optimizeAll(options) {
+        try {
+            logger_1.logger.info('🚀 Starting comprehensive performance optimization...');
+            const allOptimizations = [];
+            // Run all optimizations
+            const memoryOpts = await this.memoryOptimizer.analyzeMemoryUsage();
+            const concurrencyOpts = await this.concurrencyOptimizer.analyzeConcurrency();
+            const bundleOpts = await this.assetOptimizer.analyzeBundleSize(process.cwd());
+            allOptimizations.push(...memoryOpts, ...concurrencyOpts, ...bundleOpts);
+            if (allOptimizations.length === 0) {
+                logger_1.logger.success('✅ System is already fully optimized!');
+                return;
+            }
+            // Group by category
+            const grouped = allOptimizations.reduce((acc, opt) => {
+                if (opt && opt.category) {
+                    if (!acc[opt.category]) {
+                        acc[opt.category] = [];
+                    }
+                    acc[opt.category].push(opt);
+                }
+                return acc;
+            }, {});
+            logger_1.logger.info('\n📊 Optimization Summary:');
+            Object.entries(grouped).forEach(([category, opts]) => {
+                console.log(`  ${chalk_1.default.bold(category.toUpperCase())}: ${opts.length} opportunities`);
+            });
+            if (!options.dryRun) {
+                // Apply automated optimizations
+                const automated = allOptimizations.filter(o => o.automated);
+                if (automated.length > 0) {
+                    logger_1.logger.info(`\n🔧 Applying ${automated.length} automated optimizations...`);
+                    for (const opt of automated) {
+                        try {
+                            if (opt.category === 'memory') {
+                                await this.memoryOptimizer.optimizeMemoryUsage([opt]);
+                            }
+                            else if (opt.category === 'concurrency') {
+                                await this.concurrencyOptimizer.optimizeConcurrency([opt]);
+                            }
+                        }
+                        catch (error) {
+                            logger_1.logger.warn(`Failed to apply optimization: ${opt.description}`);
+                        }
+                    }
+                }
+                const applied = allOptimizations.filter(o => o.applied).length;
+                logger_1.logger.success(`✅ Applied ${applied} optimizations automatically`);
+                const manual = allOptimizations.filter(o => !o.automated).length;
+                if (manual > 0) {
+                    logger_1.logger.info(`ℹ️  ${manual} optimizations require manual intervention`);
+                }
+            }
+            if (options.report) {
+                await this.generateOptimizationReport(allOptimizations, options.report, 'comprehensive');
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_COMPREHENSIVE_OPTIMIZATION_FAILED', 'Failed to run comprehensive optimization', { options }, true);
+        }
+    }
+    async startMonitoring(options) {
+        const duration = parseInt(options.duration) * 1000;
+        const interval = parseInt(options.interval);
+        const startTime = Date.now();
+        logger_1.logger.info(`🔍 Starting performance monitoring for ${options.duration} seconds...`);
+        const metrics = [];
+        const monitor = setInterval(() => {
+            const memory = (0, process_1.memoryUsage)();
+            const cpu = (0, process_1.cpuUsage)();
+            const metric = {
+                memory: {
+                    heapUsed: memory.heapUsed,
+                    heapTotal: memory.heapTotal,
+                    external: memory.external,
+                    rss: memory.rss,
+                    freeMemory: 0, // Would implement actual system memory check
+                    totalMemory: 0,
+                },
+                cpu: {
+                    user: cpu.user,
+                    system: cpu.system,
+                    idle: 0,
+                    loadAverage: [0, 0, 0], // Would implement actual load average
+                },
+                performance: {
+                    uptime: process.uptime(),
+                    responseTime: 0, // Would measure actual response times
+                    throughput: 0, // Would measure actual throughput
+                },
+            };
+            metrics.push(metric);
+            // Real-time display
+            const heapMB = (memory.heapUsed / 1024 / 1024).toFixed(2);
+            const rssMB = (memory.rss / 1024 / 1024).toFixed(2);
+            process.stdout.write(`\r💾 Heap: ${heapMB}MB | RSS: ${rssMB}MB | CPU: ${cpu.user}μs`);
+        }, interval);
+        setTimeout(() => {
+            clearInterval(monitor);
+            console.log('\n\n📊 Monitoring completed!');
+            // Calculate averages
+            const avgHeap = metrics.reduce((sum, m) => sum + m.memory.heapUsed, 0) / metrics.length;
+            const avgRSS = metrics.reduce((sum, m) => sum + m.memory.rss, 0) / metrics.length;
+            const peakHeap = Math.max(...metrics.map(m => m.memory.heapUsed));
+            const peakRSS = Math.max(...metrics.map(m => m.memory.rss));
+            console.log('\nMemory Statistics:');
+            console.log(`  Average Heap: ${(avgHeap / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`  Average RSS:  ${(avgRSS / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`  Peak Heap:    ${(peakHeap / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`  Peak RSS:     ${(peakRSS / 1024 / 1024).toFixed(2)} MB`);
+            logger_1.logger.success('Monitoring data collected successfully');
+        }, duration);
+    }
+    async runBenchmarks(options) {
+        try {
+            logger_1.logger.info('🏃‍♂️ Starting performance benchmarks...');
+            const scenarios = options.scenarios
+                ? options.scenarios.split(',')
+                : [
+                    'memory-allocation',
+                    'file-processing',
+                    'concurrent-tasks',
+                    'data-transformation',
+                ];
+            const iterations = parseInt(options.iterations);
+            const results = {};
+            for (const scenario of scenarios) {
+                logger_1.logger.info(`Running ${scenario} benchmark...`);
+                results[scenario] = [];
+                for (let i = 0; i < iterations; i++) {
+                    const startTime = perf_hooks_1.performance.now();
+                    switch (scenario) {
+                        case 'memory-allocation':
+                            await this.benchmarkMemoryAllocation();
+                            break;
+                        case 'file-processing':
+                            await this.benchmarkFileProcessing();
+                            break;
+                        case 'concurrent-tasks':
+                            await this.benchmarkConcurrentTasks();
+                            break;
+                        case 'data-transformation':
+                            await this.benchmarkDataTransformation();
+                            break;
+                    }
+                    const duration = perf_hooks_1.performance.now() - startTime;
+                    results[scenario].push(duration);
+                }
+            }
+            // Display results
+            console.log('\n📊 Benchmark Results:');
+            Object.entries(results).forEach(([scenario, times]) => {
+                const avg = times.reduce((sum, t) => sum + t, 0) / times.length;
+                const min = Math.min(...times);
+                const max = Math.max(...times);
+                console.log(`\n  ${chalk_1.default.bold(scenario)}:`);
+                console.log(`    Average: ${avg.toFixed(2)}ms`);
+                console.log(`    Min:     ${min.toFixed(2)}ms`);
+                console.log(`    Max:     ${max.toFixed(2)}ms`);
+            });
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BENCHMARK_FAILED', 'Failed to run performance benchmarks', { options }, true);
+        }
+    }
+    // Benchmark implementations
+    async benchmarkMemoryAllocation() {
+        // Simulate memory-intensive operations
+        const arrays = [];
+        for (let i = 0; i < 1000; i++) {
+            arrays.push(new Array(1000).fill(Math.random()));
+        }
+        arrays.length = 0; // Clear for GC
+    }
+    async benchmarkFileProcessing() {
+        // Simulate file processing operations
+        const data = Buffer.alloc(1024 * 1024); // 1MB buffer
+        data.fill('A');
+        const processed = data.toString('base64');
+        Buffer.from(processed, 'base64');
+    }
+    async benchmarkConcurrentTasks() {
+        // Simulate concurrent task processing
+        const tasks = Array.from({ length: 100 }, (_, i) => new Promise(resolve => setTimeout(resolve, Math.random() * 10)));
+        await Promise.all(tasks);
+    }
+    async benchmarkDataTransformation() {
+        // Simulate data transformation operations
+        const data = Array.from({ length: 10000 }, (_, i) => ({
+            id: i,
+            value: Math.random(),
+        }));
+        const transformed = data
+            .filter(item => item.value > 0.5)
+            .map(item => ({ ...item, doubled: item.value * 2 }))
+            .reduce((acc, item) => acc + item.doubled, 0);
+    }
+    async generateOptimizationReport(optimizations, reportPath, type) {
+        const report = {
+            timestamp: new Date().toISOString(),
+            type,
+            summary: {
+                total: optimizations.length,
+                automated: optimizations.filter(o => o.automated).length,
+                applied: optimizations.filter(o => o.applied).length,
+                highImpact: optimizations.filter(o => o.impact === 'high').length,
+                criticalImpact: optimizations.filter(o => o.impact === 'critical')
+                    .length,
+            },
+            optimizations: optimizations.map(opt => ({
+                category: opt.category,
+                description: opt.description,
+                impact: opt.impact,
+                effort: opt.effort,
+                automated: opt.automated,
+                applied: opt.applied,
+                recommendations: opt.recommendations,
+                metrics: opt.metrics,
+            })),
+        };
+        await fs_extra_1.default.writeJson(reportPath, report, { spaces: 2 });
+        logger_1.logger.success(`📄 Optimization report saved to ${reportPath}`);
+    }
+}
+exports.PerformanceOptimizerCommands = PerformanceOptimizerCommands;
+//# sourceMappingURL=performance-optimizer.js.map