claude-flow-novice 2.3.5 → 2.3.6

package/dist/scripts/build/performance-monitor.js

@@ -1,869 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Unified Performance Monitor - Consolidates 4+ performance scripts
- * Phase 12: Script Consolidation - Performance Testing & Monitoring
- *
- * Consolidates:
- * - performance-test-runner.js
- * - performance-monitor.js
- * - performance-monitoring.js
- * - build-monitor.js
- * - optimize-performance.js
- */
-
-import { promises as fs } from 'fs';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import path from 'path';
-import { EventEmitter } from 'events';
-
-const execAsync = promisify(exec);
-
-class UnifiedPerformanceMonitor extends EventEmitter {
-    constructor() {
-        super();
-        this.version = '1.0.0';
-        this.monitoring = false;
-        this.startTime = Date.now();
-        this.metrics = {
-            build: { attempts: 0, successes: 0, failures: 0, avgTime: 0 },
-            performance: { tests: 0, passed: 0, failed: 0, avgDuration: 0 },
-            system: { cpu: [], memory: [], load: [] },
-            errors: { total: 0, byType: {}, recent: [] }
-        };
-        this.thresholds = {
-            buildTime: 300000, // 5 minutes
-            memoryUsage: 1024, // MB
-            cpuUsage: 80, // percentage
-            errorRate: 0.1 // 10%
-        };
-        this.reportFile = null;
-        this.logFile = null;
-        this.setupLogging();
-    }
-
-    setupLogging() {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        this.reportFile = `reports/performance-${timestamp}.json`;
-        this.logFile = `logs/performance-${timestamp}.log`;
-
-        // Ensure directories exist
-        this.ensureDirectories();
-    }
-
-    async ensureDirectories() {
-        await fs.mkdir('reports', { recursive: true });
-        await fs.mkdir('logs', { recursive: true });
-        await fs.mkdir('.tmp-performance', { recursive: true });
-    }
-
-    log(message, level = 'info') {
-        const timestamp = new Date().toISOString();
-        const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
-
-        console.log(logEntry);
-
-        if (this.logFile) {
-            fs.appendFile(this.logFile, logEntry + '\n').catch(() => {});
-        }
-    }
-
-    // Performance Test Runner (from performance-test-runner.js)
-    async runPerformanceTests(type = 'basic', options = {}) {
-        this.log(`🚀 Starting performance tests: ${type}`);
-
-        const testConfigs = {
-            basic: {
-                name: 'basic-cli-operations',
-                description: 'Basic CLI command performance',
-                duration: 30000,
-                concurrency: 5,
-                targetThroughput: 10,
-                maxLatency: 1000
-            },
-            load: {
-                name: 'load-test-swarm',
-                description: 'Load test for swarm operations',
-                duration: 300000,
-                concurrency: parseInt(process.env.LOAD_TEST_CONCURRENCY || '50'),
-                targetThroughput: 100,
-                maxLatency: 2000
-            },
-            stress: {
-                name: 'stress-test-agents',
-                description: 'Stress test for agent spawning',
-                duration: 600000,
-                concurrency: parseInt(process.env.STRESS_TEST_MAX_CONCURRENCY || '200'),
-                targetThroughput: 50,
-                maxLatency: 5000
-            },
-            endurance: {
-                name: 'endurance-test-memory',
-                description: 'Endurance test for memory stability',
-                duration: parseInt(process.env.ENDURANCE_TEST_DURATION || '3600000'),
-                concurrency: parseInt(process.env.ENDURANCE_TEST_CONCURRENCY || '25'),
-                targetThroughput: 20,
-                maxLatency: 3000
-            }
-        };
-
-        const config = testConfigs[type];
-        if (!config) {
-            throw new Error(`Unknown test type: ${type}`);
-        }
-
-        const startTime = Date.now();
-        const results = {
-            config,
-            startTime,
-            endTime: null,
-            duration: null,
-            metrics: {
-                operations: 0,
-                successful: 0,
-                failed: 0,
-                avgLatency: 0,
-                maxLatency: 0,
-                throughput: 0,
-                errors: []
-            },
-            systemMetrics: {
-                cpu: { avg: 0, max: 0, samples: [] },
-                memory: { avg: 0, max: 0, samples: [] },
-                network: { in: 0, out: 0 }
-            }
-        };
-
-        try {
-            // Warmup phase
-            this.log('🔥 Warmup phase...');
-            await this.runWarmup(config);
-
-            // Main test phase
-            this.log(`🏃 Running ${type} performance test...`);
-            const testResult = await this.executePerformanceTest(config);
-
-            results.endTime = Date.now();
-            results.duration = results.endTime - startTime;
-            results.metrics = testResult;
-
-            // Collect system metrics
-            const systemMetrics = await this.collectSystemMetrics();
-            results.systemMetrics = systemMetrics;
-
-            // Validate against thresholds
-            const validation = this.validateResults(results);
-            results.validation = validation;
-
-            this.log(`✅ Performance test completed: ${type}`);
-            this.log(`📊 Operations: ${results.metrics.operations}`);
-            this.log(`📊 Success rate: ${((results.metrics.successful / results.metrics.operations) * 100).toFixed(2)}%`);
-            this.log(`📊 Avg latency: ${results.metrics.avgLatency.toFixed(2)}ms`);
-
-            // Update internal metrics
-            this.metrics.performance.tests++;
-            if (validation.passed) {
-                this.metrics.performance.passed++;
-            } else {
-                this.metrics.performance.failed++;
-            }
-
-            // Save results
-            await this.saveResults(results);
-
-            return results;
-
-        } catch (error) {
-            this.log(`❌ Performance test failed: ${error.message}`, 'error');
-            this.metrics.performance.failed++;
-            throw error;
-        }
-    }
-
-    async runWarmup(config) {
-        const warmupDuration = Math.min(config.duration * 0.1, 30000); // 10% of test duration, max 30s
-        const warmupOps = Math.ceil(config.concurrency * 2);
-
-        for (let i = 0; i < warmupOps; i++) {
-            try {
-                await this.simulateOperation('warmup');
-            } catch (err) {
-                // Ignore warmup errors
-            }
-        }
-
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-
-    async executePerformanceTest(config) {
-        const operations = [];
-        const startTime = Date.now();
-        const endTime = startTime + config.duration;
-        let operationCount = 0;
-
-        const metrics = {
-            operations: 0,
-            successful: 0,
-            failed: 0,
-            latencies: [],
-            errors: []
-        };
-
-        // Start monitoring
-        const monitorInterval = setInterval(async () => {
-            const sysMetrics = await this.getSystemSnapshot();
-            this.metrics.system.cpu.push(sysMetrics.cpu);
-            this.metrics.system.memory.push(sysMetrics.memory);
-        }, 5000);
-
-        try {
-            while (Date.now() < endTime) {
-                const batchPromises = [];
-
-                // Create batch of concurrent operations
-                for (let i = 0; i < config.concurrency && Date.now() < endTime; i++) {
-                    batchPromises.push(this.executeOperation(operationCount++));
-                }
-
-                // Wait for batch completion
-                const batchResults = await Promise.allSettled(batchPromises);
-
-                // Process results
-                for (const result of batchResults) {
-                    metrics.operations++;
-
-                    if (result.status === 'fulfilled') {
-                        metrics.successful++;
-                        metrics.latencies.push(result.value.latency);
-                    } else {
-                        metrics.failed++;
-                        metrics.errors.push(result.reason.message);
-                    }
-                }
-
-                // Throttle based on target throughput
-                const expectedOperations = ((Date.now() - startTime) / 1000) * config.targetThroughput;
-                if (metrics.operations > expectedOperations) {
-                    await new Promise(resolve => setTimeout(resolve, 100));
-                }
-            }
-
-        } finally {
-            clearInterval(monitorInterval);
-        }
-
-        // Calculate final metrics
-        metrics.avgLatency = metrics.latencies.length > 0 ?
-            metrics.latencies.reduce((a, b) => a + b, 0) / metrics.latencies.length : 0;
-
-        metrics.maxLatency = metrics.latencies.length > 0 ?
-            Math.max(...metrics.latencies) : 0;
-
-        metrics.throughput = metrics.operations / ((Date.now() - startTime) / 1000);
-
-        return metrics;
-    }
-
-    async executeOperation(operationId) {
-        const startTime = Date.now();
-
-        try {
-            // Simulate different types of operations
-            const operationType = this.selectOperationType();
-            await this.simulateOperation(operationType);
-
-            const latency = Date.now() - startTime;
-            return { operationId, latency, success: true };
-
-        } catch (error) {
-            const latency = Date.now() - startTime;
-            throw { operationId, latency, success: false, error: error.message };
-        }
-    }
-
-    selectOperationType() {
-        const operations = ['cli-command', 'swarm-spawn', 'agent-task', 'file-operation', 'memory-operation'];
-        return operations[Math.floor(Math.random() * operations.length)];
-    }
-
-    async simulateOperation(type) {
-        switch (type) {
-            case 'cli-command':
-                return this.simulateCLICommand();
-            case 'swarm-spawn':
-                return this.simulateSwarmSpawn();
-            case 'agent-task':
-                return this.simulateAgentTask();
-            case 'file-operation':
-                return this.simulateFileOperation();
-            case 'memory-operation':
-                return this.simulateMemoryOperation();
-            case 'warmup':
-                return new Promise(resolve => setTimeout(resolve, Math.random() * 100));
-            default:
-                throw new Error(`Unknown operation type: ${type}`);
-        }
-    }
-
-    async simulateCLICommand() {
-        // Simulate CLI command execution
-        const delay = 50 + Math.random() * 200; // 50-250ms
-        await new Promise(resolve => setTimeout(resolve, delay));
-
-        if (Math.random() < 0.05) { // 5% failure rate
-            throw new Error('CLI command failed');
-        }
-
-        return { type: 'cli-command', duration: delay };
-    }
-
-    async simulateSwarmSpawn() {
-        // Simulate swarm spawning operation
-        const delay = 100 + Math.random() * 500; // 100-600ms
-        await new Promise(resolve => setTimeout(resolve, delay));
-
-        if (Math.random() < 0.02) { // 2% failure rate
-            throw new Error('Swarm spawn failed');
-        }
-
-        return { type: 'swarm-spawn', duration: delay };
-    }
-
-    async simulateAgentTask() {
-        // Simulate agent task execution
-        const delay = 200 + Math.random() * 800; // 200-1000ms
-        await new Promise(resolve => setTimeout(resolve, delay));
-
-        if (Math.random() < 0.03) { // 3% failure rate
-            throw new Error('Agent task failed');
-        }
-
-        return { type: 'agent-task', duration: delay };
-    }
-
-    async simulateFileOperation() {
-        // Simulate file I/O operation
-        try {
-            const tempFile = `.tmp-performance/test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.tmp`;
-            const data = 'x'.repeat(1000 + Math.random() * 10000); // 1-11KB
-
-            await fs.writeFile(tempFile, data);
-            await fs.readFile(tempFile);
-            await fs.unlink(tempFile);
-
-            return { type: 'file-operation', size: data.length };
-
-        } catch (error) {
-            throw new Error(`File operation failed: ${error.message}`);
-        }
-    }
-
-    async simulateMemoryOperation() {
-        // Simulate memory-intensive operation
-        const arraySize = 1000 + Math.random() * 10000;
-        const data = new Array(arraySize).fill(0).map(() => Math.random());
-
-        // Perform some operations
-        data.sort();
-        const sum = data.reduce((a, b) => a + b, 0);
-
-        return { type: 'memory-operation', arraySize, sum };
-    }
-
-    // Build Monitor (from build-monitor.js)
-    async startBuildMonitoring(options = {}) {
-        this.log('🐝 Starting build monitoring...');
-
-        const { interval = 30000, continuous = false } = options;
-        this.monitoring = true;
-
-        while (this.monitoring) {
-            try {
-                const buildResult = await this.checkBuildStatus();
-                this.processBuildResult(buildResult);
-
-                if (!continuous) {
-                    break;
-                }
-
-                await new Promise(resolve => setTimeout(resolve, interval));
-
-            } catch (error) {
-                this.log(`❌ Build monitoring error: ${error.message}`, 'error');
-                this.metrics.errors.total++;
-            }
-        }
-    }
-
-    async checkBuildStatus() {
-        const startTime = Date.now();
-
-        try {
-            const { stdout, stderr } = await execAsync('npm run build 2>&1');
-            const buildOutput = stderr || stdout;
-            const errors = this.parseBuildErrors(buildOutput);
-
-            const buildTime = Date.now() - startTime;
-
-            this.metrics.build.attempts++;
-
-            const result = {
-                timestamp: new Date().toISOString(),
-                buildTime,
-                errorCount: errors.length,
-                errors,
-                success: errors.length === 0,
-                output: buildOutput
-            };
-
-            if (result.success) {
-                this.metrics.build.successes++;
-            } else {
-                this.metrics.build.failures++;
-            }
-
-            this.metrics.build.avgTime =
-                ((this.metrics.build.avgTime * (this.metrics.build.attempts - 1)) + buildTime) /
-                this.metrics.build.attempts;
-
-            return result;
-
-        } catch (error) {
-            this.metrics.build.failures++;
-            throw error;
-        }
-    }
-
-    parseBuildErrors(output) {
-        if (!output) return [];
-
-        const errorLines = output.split('\n').filter(line =>
-            line.includes('error TS') ||
-            line.includes('Error:') ||
-            line.includes('✘ [ERROR]')
-        );
-
-        return errorLines.map(line => {
-            const tsMatch = line.match(/([^:]+):\s*error\s+TS(\d+):\s*(.+)/);
-            if (tsMatch) {
-                return {
-                    type: 'typescript',
-                    file: tsMatch[1],
-                    code: tsMatch[2],
-                    message: tsMatch[3]
-                };
-            }
-
-            return {
-                type: 'general',
-                message: line.trim()
-            };
-        });
-    }
-
-    processBuildResult(result) {
-        if (result.success) {
-            this.log(`✅ Build successful (${result.buildTime}ms)`);
-        } else {
-            this.log(`❌ Build failed with ${result.errorCount} errors`, 'error');
-
-            // Track error types
-            for (const error of result.errors) {
-                const errorType = error.code || error.type || 'unknown';
-                this.metrics.errors.byType[errorType] =
-                    (this.metrics.errors.byType[errorType] || 0) + 1;
-            }
-
-            this.metrics.errors.recent = result.errors.slice(-10); // Keep last 10 errors
-        }
-
-        // Emit events for external handlers
-        this.emit('buildResult', result);
-
-        if (result.buildTime > this.thresholds.buildTime) {
-            this.emit('buildSlow', result);
-        }
-    }
-
-    // System Metrics Collection
-    async collectSystemMetrics() {
-        try {
-            const metrics = {
-                timestamp: Date.now(),
-                cpu: await this.getCPUUsage(),
-                memory: await this.getMemoryUsage(),
-                disk: await this.getDiskUsage(),
-                network: await this.getNetworkUsage(),
-                processes: await this.getProcessInfo()
-            };
-
-            return metrics;
-
-        } catch (error) {
-            this.log(`Warning: Could not collect system metrics: ${error.message}`, 'warn');
-            return null;
-        }
-    }
-
-    async getSystemSnapshot() {
-        try {
-            return {
-                cpu: await this.getCPUUsage(),
-                memory: await this.getMemoryUsage(),
-                timestamp: Date.now()
-            };
-        } catch (error) {
-            return { cpu: 0, memory: 0, timestamp: Date.now() };
-        }
-    }
-
-    async getCPUUsage() {
-        try {
-            if (process.platform === 'linux') {
-                const { stdout } = await execAsync("top -bn1 | grep 'Cpu(s)' | awk '{print $2}' | cut -d'%' -f1");
-                return parseFloat(stdout.trim()) || 0;
-            } else if (process.platform === 'darwin') {
-                const { stdout } = await execAsync("top -l 1 -n 0 | grep 'CPU usage' | awk '{print $3}' | cut -d'%' -f1");
-                return parseFloat(stdout.trim()) || 0;
-            } else {
-                // Windows or fallback
-                return 0;
-            }
-        } catch (error) {
-            return 0;
-        }
-    }
-
-    async getMemoryUsage() {
-        try {
-            const usage = process.memoryUsage();
-            return {
-                rss: Math.round(usage.rss / 1024 / 1024), // MB
-                heapTotal: Math.round(usage.heapTotal / 1024 / 1024),
-                heapUsed: Math.round(usage.heapUsed / 1024 / 1024),
-                external: Math.round(usage.external / 1024 / 1024)
-            };
-        } catch (error) {
-            return { rss: 0, heapTotal: 0, heapUsed: 0, external: 0 };
-        }
-    }
-
-    async getDiskUsage() {
-        try {
-            if (process.platform !== 'win32') {
-                const { stdout } = await execAsync("df -h . | tail -1 | awk '{print $5}' | cut -d'%' -f1");
-                return parseInt(stdout.trim()) || 0;
-            }
-            return 0;
-        } catch (error) {
-            return 0;
-        }
-    }
-
-    async getNetworkUsage() {
-        // Simplified network usage - would need more complex implementation for real metrics
-        return { in: 0, out: 0 };
-    }
-
-    async getProcessInfo() {
-        try {
-            const { stdout } = await execAsync('ps aux | grep node | grep -v grep | wc -l');
-            return {
-                nodeProcesses: parseInt(stdout.trim()) || 0
-            };
-        } catch (error) {
-            return { nodeProcesses: 0 };
-        }
-    }
-
-    // Results validation
-    validateResults(results) {
-        const validation = {
-            passed: true,
-            issues: [],
-            score: 100
-        };
-
-        // Check latency
-        if (results.metrics.avgLatency > results.config.maxLatency) {
-            validation.passed = false;
-            validation.issues.push(`Average latency ${results.metrics.avgLatency.toFixed(2)}ms exceeds threshold ${results.config.maxLatency}ms`);
-            validation.score -= 20;
-        }
-
-        // Check throughput
-        const actualThroughput = results.metrics.operations / (results.duration / 1000);
-        if (actualThroughput < results.config.targetThroughput * 0.8) {
-            validation.passed = false;
-            validation.issues.push(`Throughput ${actualThroughput.toFixed(2)} ops/s below 80% of target ${results.config.targetThroughput} ops/s`);
-            validation.score -= 15;
-        }
-
-        // Check success rate
-        const successRate = results.metrics.successful / results.metrics.operations;
-        if (successRate < 0.95) {
-            validation.passed = false;
-            validation.issues.push(`Success rate ${(successRate * 100).toFixed(2)}% below 95%`);
-            validation.score -= 25;
-        }
-
-        // Check system metrics
-        if (results.systemMetrics && results.systemMetrics.memory.max > this.thresholds.memoryUsage) {
-            validation.issues.push(`Peak memory usage ${results.systemMetrics.memory.max}MB exceeds threshold`);
-            validation.score -= 10;
-        }
-
-        validation.score = Math.max(0, validation.score);
-        return validation;
-    }
-
-    // Results management
-    async saveResults(results) {
-        try {
-            // Save detailed results
-            await fs.writeFile(this.reportFile, JSON.stringify(results, null, 2));
-
-            // Save summary
-            const summary = {
-                timestamp: results.startTime,
-                test: results.config.name,
-                duration: results.duration,
-                operations: results.metrics.operations,
-                successRate: (results.metrics.successful / results.metrics.operations * 100).toFixed(2),
-                avgLatency: results.metrics.avgLatency.toFixed(2),
-                throughput: results.metrics.throughput.toFixed(2),
-                passed: results.validation.passed,
-                score: results.validation.score
-            };
-
-            const summaryFile = 'reports/performance-summary.json';
-            let summaries = [];
-
-            try {
-                const existing = await fs.readFile(summaryFile, 'utf8');
-                summaries = JSON.parse(existing);
-            } catch (err) {
-                // File doesn't exist, start fresh
-            }
-
-            summaries.push(summary);
-
-            // Keep only last 100 results
-            if (summaries.length > 100) {
-                summaries = summaries.slice(-100);
-            }
-
-            await fs.writeFile(summaryFile, JSON.stringify(summaries, null, 2));
-
-            this.log(`📊 Results saved to ${this.reportFile}`);
-
-        } catch (error) {
-            this.log(`❌ Failed to save results: ${error.message}`, 'error');
-        }
-    }
-
-    // Report generation
-    async generateReport(options = {}) {
-        const { format = 'summary', timeframe = '24h' } = options;
-
-        this.log(`📋 Generating ${format} report for ${timeframe}...`);
-
-        try {
-            const summaryFile = 'reports/performance-summary.json';
-            const summaries = JSON.parse(await fs.readFile(summaryFile, 'utf8'));
-
-            // Filter by timeframe
-            const cutoff = Date.now() - this.parseTimeframe(timeframe);
-            const filtered = summaries.filter(s => s.timestamp > cutoff);
-
-            if (format === 'summary') {
-                return this.generateSummaryReport(filtered);
-            } else if (format === 'detailed') {
-                return this.generateDetailedReport(filtered);
-            } else if (format === 'json') {
-                return filtered;
-            }
-
-        } catch (error) {
-            this.log(`❌ Failed to generate report: ${error.message}`, 'error');
-            return null;
-        }
-    }
-
-    generateSummaryReport(data) {
-        if (data.length === 0) {
-            return 'No performance data found for the specified timeframe.';
-        }
-
-        const avgScore = data.reduce((sum, d) => sum + d.score, 0) / data.length;
-        const passed = data.filter(d => d.passed).length;
-        const failed = data.length - passed;
-
-        let report = '\n📊 Performance Summary Report\n';
-        report += '================================\n\n';
-        report += `Total Tests: ${data.length}\n`;
-        report += `Passed: ${passed} (${(passed/data.length*100).toFixed(1)}%)\n`;
-        report += `Failed: ${failed} (${(failed/data.length*100).toFixed(1)}%)\n`;
-        report += `Average Score: ${avgScore.toFixed(1)}/100\n\n`;
-
-        // Test type breakdown
-        const byType = {};
-        data.forEach(d => {
-            byType[d.test] = (byType[d.test] || 0) + 1;
-        });
-
-        report += 'Test Distribution:\n';
-        Object.entries(byType).forEach(([test, count]) => {
-            report += `  ${test}: ${count}\n`;
-        });
-
-        // Recent performance
-        const recent = data.slice(-5);
-        report += '\nRecent Performance:\n';
-        recent.forEach(d => {
-            const status = d.passed ? '✅' : '❌';
-            report += `  ${status} ${d.test}: ${d.score}/100 (${d.successRate}% success)\n`;
-        });
-
-        return report;
-    }
-
-    generateDetailedReport(data) {
-        // More detailed analysis would go here
-        return this.generateSummaryReport(data) + '\n\nDetailed metrics available in JSON format.';
-    }
-
-    parseTimeframe(timeframe) {
-        const unit = timeframe.slice(-1);
-        const value = parseInt(timeframe.slice(0, -1));
-
-        switch (unit) {
-            case 'h': return value * 60 * 60 * 1000;
-            case 'd': return value * 24 * 60 * 60 * 1000;
-            case 'w': return value * 7 * 24 * 60 * 60 * 1000;
-            default: return 24 * 60 * 60 * 1000; // Default 24h
-        }
-    }
-
-    // Control methods
-    stopMonitoring() {
-        this.monitoring = false;
-        this.log('🛑 Monitoring stopped');
-    }
-
-    getMetrics() {
-        return {
-            ...this.metrics,
-            uptime: Date.now() - this.startTime,
-            monitoring: this.monitoring
-        };
-    }
-
-    printUsage() {
-        console.log('Unified Performance Monitor v' + this.version);
-        console.log('Comprehensive performance testing and monitoring utility');
-        console.log('');
-        console.log('Usage: node performance-monitor.js [command] [options]');
-        console.log('');
-        console.log('Commands:');
-        console.log('  test [type]      Run performance tests (basic|load|stress|endurance)');
-        console.log('  monitor          Start build monitoring');
-        console.log('  report [format]  Generate performance report (summary|detailed|json)');
-        console.log('  metrics          Show current metrics');
-        console.log('  help             Show this help');
-        console.log('');
-        console.log('Options:');
-        console.log('  --continuous     Run monitoring continuously');
-        console.log('  --interval N     Monitoring interval in ms (default: 30000)');
-        console.log('  --timeframe T    Report timeframe (24h|7d|30d, default: 24h)');
-        console.log('  --format F       Report format (summary|detailed|json)');
-        console.log('  --dry-run        Show what would be done');
-        console.log('');
-        console.log('Examples:');
-        console.log('  node performance-monitor.js test basic');
-        console.log('  node performance-monitor.js monitor --continuous');
-        console.log('  node performance-monitor.js report --format detailed --timeframe 7d');
-        console.log('  node performance-monitor.js metrics');
-    }
-}
-
-// Main execution
-async function main() {
-    const args = process.argv.slice(2);
-    const monitor = new UnifiedPerformanceMonitor();
-
-    if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
-        monitor.printUsage();
-        process.exit(0);
-    }
-
-    const command = args[0];
-    const options = {};
-
-    // Parse options
-    for (let i = 1; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--continuous') {
-            options.continuous = true;
-        } else if (arg === '--interval') {
-            options.interval = parseInt(args[++i]) || 30000;
-        } else if (arg === '--timeframe') {
-            options.timeframe = args[++i] || '24h';
-        } else if (arg === '--format') {
-            options.format = args[++i] || 'summary';
-        } else if (arg === '--dry-run') {
-            options.dryRun = true;
-        } else if (!arg.startsWith('--') && command === 'test') {
-            options.testType = arg;
-        }
-    }
-
-    try {
-        switch (command) {
-            case 'test':
-                const testType = options.testType || 'basic';
-                const result = await monitor.runPerformanceTests(testType, options);
-                console.log(`\n🎯 Test Result: ${result.validation.passed ? 'PASSED' : 'FAILED'}`);
-                console.log(`📊 Score: ${result.validation.score}/100`);
-                break;
-
-            case 'monitor':
-                await monitor.startBuildMonitoring(options);
-                break;
-
-            case 'report':
-                const report = await monitor.generateReport(options);
-                console.log(report);
-                break;
-
-            case 'metrics':
-                const metrics = monitor.getMetrics();
-                console.log(JSON.stringify(metrics, null, 2));
-                break;
-
-            default:
-                console.error(`Unknown command: ${command}`);
-                monitor.printUsage();
-                process.exit(1);
-        }
-
-        // Coordination hook
-        try {
-            await execAsync('npx claude-flow@alpha hooks post-edit --file "performance-monitor" --memory-key "swarm/phase12/performance"');
-        } catch (err) {
-            // Ignore hook errors
-        }
-
-    } catch (error) {
-        console.error('❌ Error:', error.message);
-        process.exit(1);
-    }
-}
-
-// Execute if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    main();
-}
-
-export { UnifiedPerformanceMonitor };