claude-flow-novice 2.2.4 → 2.2.5

package/scripts/build/performance-monitor.js

@@ -0,0 +1,869 @@
+#!/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 };