claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/performance-monitor.js

@@ -1,644 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Performance Monitoring System
- *
- * Comprehensive performance tracking for claude-flow-novice:
- * - Fleet manager performance metrics
- * - Redis coordination latency tracking
- * - Dashboard real-time performance
- * - WASM 40x performance validation
- */
-
-import { performance } from 'perf_hooks';
-import { EventEmitter } from 'events';
-import fs from 'fs/promises';
-import path from 'path';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-
-export class PerformanceMonitor extends EventEmitter {
-    constructor(options = {}) {
-        super();
-
-        this.metricsDir = options.metricsDir || './logs/performance';
-        this.sampleInterval = options.sampleInterval || 1000; // 1 second
-        this.retentionPeriod = options.retentionPeriod || 86400000; // 24 hours
-
-        this.metrics = {
-            fleetManager: [],
-            redis: [],
-            dashboard: [],
-            wasm: [],
-            system: []
-        };
-
-        this.targets = {
-            fleetManager: {
-                agentSpawnTime: 3000, // 3 seconds max
-                taskCompletionRate: 0.95, // 95% success rate
-                resourceUtilization: 0.70 // 70% max CPU/memory
-            },
-            redis: {
-                connectionLatency: 10, // 10ms max
-                commandLatency: 5, // 5ms max
-                memoryUsage: 1024 * 1024 * 100 // 100MB max
-            },
-            dashboard: {
-                responseTime: 200, // 200ms max
-                websocketLatency: 50, // 50ms max
-                maxConnections: 1000 // 1000 concurrent users
-            },
-            wasm: {
-                performanceMultiplier: 40, // 40x target
-                minMultiplier: 30 // 30x minimum acceptable
-            }
-        };
-
-        this.ensureMetricsDir();
-    }
-
-    async ensureMetricsDir() {
-        try {
-            await fs.mkdir(this.metricsDir, { recursive: true });
-        } catch (error) {
-            console.error('Failed to create metrics directory:', error.message);
-        }
-    }
-
-    /**
-     * Monitor Fleet Manager Performance
-     */
-    async monitorFleetManager() {
-        const startTime = performance.now();
-
-        const metrics = {
-            timestamp: new Date().toISOString(),
-            agentSpawn: await this.measureAgentSpawnTime(),
-            taskCompletion: await this.measureTaskCompletionRate(),
-            resourceUsage: await this.measureFleetResourceUsage(),
-            activeAgents: await this.countActiveAgents(),
-            queueDepth: await this.measureQueueDepth()
-        };
-
-        const measurementTime = performance.now() - startTime;
-        metrics.measurementOverhead = Math.round(measurementTime * 100) / 100;
-
-        // Performance assessment
-        metrics.performance = this.assessFleetPerformance(metrics);
-
-        this.metrics.fleetManager.push(metrics);
-        await this.saveMetrics('fleet-manager', metrics);
-        this.emit('fleet:metrics', metrics);
-
-        return metrics;
-    }
-
-    async measureAgentSpawnTime() {
-        // Simulate agent spawn measurement
-        // In production, this would measure actual agent creation time
-        return {
-            average: Math.random() * 2000 + 500, // 0.5-2.5 seconds
-            p50: Math.random() * 1500 + 500,
-            p95: Math.random() * 3000 + 1000,
-            p99: Math.random() * 4000 + 2000,
-            target: this.targets.fleetManager.agentSpawnTime
-        };
-    }
-
-    async measureTaskCompletionRate() {
-        // Simulate task completion measurement
-        return {
-            total: 100,
-            successful: 95,
-            failed: 5,
-            rate: 0.95,
-            target: this.targets.fleetManager.taskCompletionRate
-        };
-    }
-
-    async measureFleetResourceUsage() {
-        return {
-            cpu: Math.random() * 60 + 10, // 10-70%
-            memory: Math.random() * 50 + 20, // 20-70%
-            target: this.targets.fleetManager.resourceUtilization * 100
-        };
-    }
-
-    async countActiveAgents() {
-        // Would query actual agent registry
-        return Math.floor(Math.random() * 50);
-    }
-
-    async measureQueueDepth() {
-        return Math.floor(Math.random() * 20);
-    }
-
-    assessFleetPerformance(metrics) {
-        const scores = {
-            spawnTime: metrics.agentSpawn.average <= this.targets.fleetManager.agentSpawnTime ? 100 : 60,
-            completionRate: metrics.taskCompletion.rate >= this.targets.fleetManager.taskCompletionRate ? 100 : 70,
-            resourceUsage: metrics.resourceUsage.cpu <= this.targets.fleetManager.resourceUtilization * 100 ? 100 : 75
-        };
-
-        const overall = Object.values(scores).reduce((a, b) => a + b, 0) / Object.keys(scores).length;
-
-        return {
-            scores,
-            overall: Math.round(overall),
-            status: overall >= 90 ? 'excellent' : overall >= 75 ? 'good' : overall >= 60 ? 'fair' : 'poor',
-            recommendations: this.generateFleetRecommendations(metrics, scores)
-        };
-    }
-
-    generateFleetRecommendations(metrics, scores) {
-        const recommendations = [];
-
-        if (scores.spawnTime < 100) {
-            recommendations.push({
-                category: 'performance',
-                priority: 'high',
-                message: `Agent spawn time (${metrics.agentSpawn.average.toFixed(0)}ms) exceeds target (${this.targets.fleetManager.agentSpawnTime}ms)`,
-                actions: [
-                    'Pre-warm agent pools',
-                    'Optimize agent initialization code',
-                    'Consider agent caching'
-                ]
-            });
-        }
-
-        if (scores.completionRate < 100) {
-            recommendations.push({
-                category: 'reliability',
-                priority: 'high',
-                message: `Task completion rate (${(metrics.taskCompletion.rate * 100).toFixed(1)}%) below target (${this.targets.fleetManager.taskCompletionRate * 100}%)`,
-                actions: [
-                    'Investigate task failures',
-                    'Improve error handling',
-                    'Add retry mechanisms'
-                ]
-            });
-        }
-
-        if (scores.resourceUsage < 100) {
-            recommendations.push({
-                category: 'optimization',
-                priority: 'medium',
-                message: `Resource utilization high - CPU: ${metrics.resourceUsage.cpu.toFixed(1)}%`,
-                actions: [
-                    'Implement resource throttling',
-                    'Optimize agent workloads',
-                    'Scale infrastructure'
-                ]
-            });
-        }
-
-        return recommendations;
-    }
-
-    /**
-     * Monitor Redis Performance
-     */
-    async monitorRedis() {
-        const startTime = performance.now();
-
-        const metrics = {
-            timestamp: new Date().toISOString(),
-            connection: await this.measureRedisConnectionLatency(),
-            commands: await this.measureRedisCommandLatency(),
-            memory: await this.measureRedisMemoryUsage(),
-            throughput: await this.measureRedisThroughput(),
-            connections: await this.countRedisConnections()
-        };
-
-        const measurementTime = performance.now() - startTime;
-        metrics.measurementOverhead = Math.round(measurementTime * 100) / 100;
-
-        metrics.performance = this.assessRedisPerformance(metrics);
-
-        this.metrics.redis.push(metrics);
-        await this.saveMetrics('redis', metrics);
-        this.emit('redis:metrics', metrics);
-
-        return metrics;
-    }
-
-    async measureRedisConnectionLatency() {
-        // Simulate Redis connection latency measurement
-        return {
-            latency: Math.random() * 15 + 2, // 2-17ms
-            target: this.targets.redis.connectionLatency,
-            status: 'healthy'
-        };
-    }
-
-    async measureRedisCommandLatency() {
-        return {
-            get: Math.random() * 3 + 1, // 1-4ms
-            set: Math.random() * 4 + 1, // 1-5ms
-            pub: Math.random() * 5 + 2, // 2-7ms
-            sub: Math.random() * 5 + 2, // 2-7ms
-            average: Math.random() * 4 + 2, // 2-6ms
-            target: this.targets.redis.commandLatency
-        };
-    }
-
-    async measureRedisMemoryUsage() {
-        return {
-            used: Math.random() * 50 * 1024 * 1024, // 0-50MB
-            peak: Math.random() * 80 * 1024 * 1024, // 0-80MB
-            target: this.targets.redis.memoryUsage,
-            fragmentation: 1.1 + Math.random() * 0.2 // 1.1-1.3
-        };
-    }
-
-    async measureRedisThroughput() {
-        return {
-            opsPerSecond: Math.random() * 10000 + 5000, // 5k-15k ops/sec
-            bandwidth: Math.random() * 10 * 1024 * 1024 // 0-10 MB/s
-        };
-    }
-
-    async countRedisConnections() {
-        return Math.floor(Math.random() * 50 + 10);
-    }
-
-    assessRedisPerformance(metrics) {
-        const scores = {
-            latency: metrics.connection.latency <= this.targets.redis.connectionLatency ? 100 : 70,
-            commands: metrics.commands.average <= this.targets.redis.commandLatency ? 100 : 75,
-            memory: metrics.memory.used <= this.targets.redis.memoryUsage ? 100 : 80
-        };
-
-        const overall = Object.values(scores).reduce((a, b) => a + b, 0) / Object.keys(scores).length;
-
-        return {
-            scores,
-            overall: Math.round(overall),
-            status: overall >= 90 ? 'excellent' : overall >= 75 ? 'good' : 'fair'
-        };
-    }
-
-    /**
-     * Monitor Dashboard Performance
-     */
-    async monitorDashboard() {
-        const startTime = performance.now();
-
-        const metrics = {
-            timestamp: new Date().toISOString(),
-            http: await this.measureHTTPResponseTime(),
-            websocket: await this.measureWebSocketLatency(),
-            rendering: await this.measureRenderingPerformance(),
-            connections: await this.countDashboardConnections(),
-            dataTransfer: await this.measureDataTransferRate()
-        };
-
-        const measurementTime = performance.now() - startTime;
-        metrics.measurementOverhead = Math.round(measurementTime * 100) / 100;
-
-        metrics.performance = this.assessDashboardPerformance(metrics);
-
-        this.metrics.dashboard.push(metrics);
-        await this.saveMetrics('dashboard', metrics);
-        this.emit('dashboard:metrics', metrics);
-
-        return metrics;
-    }
-
-    async measureHTTPResponseTime() {
-        return {
-            average: Math.random() * 150 + 50, // 50-200ms
-            p50: Math.random() * 100 + 40,
-            p95: Math.random() * 250 + 100,
-            p99: Math.random() * 400 + 150,
-            target: this.targets.dashboard.responseTime
-        };
-    }
-
-    async measureWebSocketLatency() {
-        return {
-            latency: Math.random() * 40 + 10, // 10-50ms
-            jitter: Math.random() * 10 + 2, // 2-12ms
-            target: this.targets.dashboard.websocketLatency
-        };
-    }
-
-    async measureRenderingPerformance() {
-        return {
-            fps: Math.random() * 20 + 40, // 40-60 fps
-            frameTime: Math.random() * 8 + 16, // 16-24ms
-            updateLatency: Math.random() * 50 + 50 // 50-100ms
-        };
-    }
-
-    async countDashboardConnections() {
-        return Math.floor(Math.random() * 100 + 10);
-    }
-
-    async measureDataTransferRate() {
-        return {
-            sent: Math.random() * 1024 * 100, // 0-100KB/s
-            received: Math.random() * 1024 * 200 // 0-200KB/s
-        };
-    }
-
-    assessDashboardPerformance(metrics) {
-        const scores = {
-            http: metrics.http.average <= this.targets.dashboard.responseTime ? 100 : 75,
-            websocket: metrics.websocket.latency <= this.targets.dashboard.websocketLatency ? 100 : 80,
-            rendering: metrics.rendering.fps >= 30 ? 100 : 70
-        };
-
-        const overall = Object.values(scores).reduce((a, b) => a + b, 0) / Object.keys(scores).length;
-
-        return {
-            scores,
-            overall: Math.round(overall),
-            status: overall >= 90 ? 'excellent' : overall >= 75 ? 'good' : 'fair'
-        };
-    }
-
-    /**
-     * Monitor WASM Performance
-     */
-    async monitorWASM() {
-        const metrics = {
-            timestamp: new Date().toISOString(),
-            benchmark: await this.runWASMBenchmark(),
-            comparison: await this.compareWASMvsJS(),
-            memory: await this.measureWASMMemory(),
-            optimization: await this.assessWASMOptimization()
-        };
-
-        metrics.performance = this.assessWASMPerformance(metrics);
-
-        this.metrics.wasm.push(metrics);
-        await this.saveMetrics('wasm', metrics);
-        this.emit('wasm:metrics', metrics);
-
-        return metrics;
-    }
-
-    async runWASMBenchmark() {
-        // Simulate WASM benchmark
-        const iterations = 1000000;
-        const wasmTime = Math.random() * 50 + 10; // 10-60ms
-        const jsTime = wasmTime * (35 + Math.random() * 10); // 35-45x slower
-
-        return {
-            iterations,
-            wasmTime,
-            jsTime,
-            speedup: jsTime / wasmTime,
-            target: this.targets.wasm.performanceMultiplier
-        };
-    }
-
-    async compareWASMvsJS() {
-        return {
-            parsing: 38 + Math.random() * 4, // 38-42x
-            execution: 42 + Math.random() * 4, // 42-46x
-            memory: 20 + Math.random() * 10 // 20-30x better
-        };
-    }
-
-    async measureWASMMemory() {
-        return {
-            allocated: Math.random() * 10 * 1024 * 1024, // 0-10MB
-            used: Math.random() * 8 * 1024 * 1024, // 0-8MB
-            peak: Math.random() * 12 * 1024 * 1024 // 0-12MB
-        };
-    }
-
-    async assessWASMOptimization() {
-        return {
-            simd: true,
-            vectorization: true,
-            loopUnrolling: true,
-            optimizationLevel: 'O3',
-            score: 95
-        };
-    }
-
-    assessWASMPerformance(metrics) {
-        const speedup = metrics.benchmark.speedup;
-        const targetMet = speedup >= this.targets.wasm.performanceMultiplier;
-        const minMet = speedup >= this.targets.wasm.minMultiplier;
-
-        return {
-            speedup: Math.round(speedup * 10) / 10,
-            targetMet,
-            minMet,
-            status: targetMet ? 'excellent' : minMet ? 'good' : 'below-target',
-            recommendation: !targetMet ? 'Review WASM optimization settings' : 'Performance target met'
-        };
-    }
-
-    /**
-     * Collect all performance metrics
-     */
-    async collectAllMetrics() {
-        const [fleet, redis, dashboard, wasm] = await Promise.all([
-            this.monitorFleetManager(),
-            this.monitorRedis(),
-            this.monitorDashboard(),
-            this.monitorWASM()
-        ]);
-
-        const comprehensive = {
-            timestamp: new Date().toISOString(),
-            fleetManager: fleet,
-            redis,
-            dashboard,
-            wasm,
-            overall: this.calculateOverallPerformance({ fleet, redis, dashboard, wasm })
-        };
-
-        await this.saveMetrics('comprehensive', comprehensive);
-        this.emit('metrics:comprehensive', comprehensive);
-
-        return comprehensive;
-    }
-
-    calculateOverallPerformance(metrics) {
-        const scores = [
-            metrics.fleet.performance.overall,
-            metrics.redis.performance.overall,
-            metrics.dashboard.performance.overall,
-            metrics.wasm.performance.speedup >= this.targets.wasm.performanceMultiplier ? 100 : 75
-        ];
-
-        const overall = scores.reduce((a, b) => a + b, 0) / scores.length;
-
-        return {
-            score: Math.round(overall),
-            status: overall >= 90 ? 'excellent' : overall >= 75 ? 'good' : overall >= 60 ? 'fair' : 'poor',
-            components: {
-                fleet: metrics.fleet.performance.status,
-                redis: metrics.redis.performance.status,
-                dashboard: metrics.dashboard.performance.status,
-                wasm: metrics.wasm.performance.status
-            }
-        };
-    }
-
-    /**
-     * Save metrics to file
-     */
-    async saveMetrics(type, data) {
-        const filename = path.join(this.metricsDir, `${type}-${Date.now()}.json`);
-
-        try {
-            await fs.writeFile(filename, JSON.stringify(data, null, 2));
-            return filename;
-        } catch (error) {
-            console.error(`Failed to save ${type} metrics:`, error.message);
-            return null;
-        }
-    }
-
-    /**
-     * Start periodic monitoring
-     */
-    startMonitoring(interval = 60000) {
-        console.log(`Starting performance monitoring (interval: ${interval}ms)`);
-
-        this.monitoringInterval = setInterval(async () => {
-            try {
-                await this.collectAllMetrics();
-            } catch (error) {
-                console.error('Monitoring failed:', error.message);
-            }
-        }, interval);
-
-        // Collect immediately
-        this.collectAllMetrics();
-    }
-
-    /**
-     * Stop monitoring
-     */
-    stopMonitoring() {
-        if (this.monitoringInterval) {
-            clearInterval(this.monitoringInterval);
-            console.log('Stopped performance monitoring');
-        }
-    }
-
-    /**
-     * Generate performance report
-     */
-    async generateReport() {
-        const metrics = await this.collectAllMetrics();
-
-        const report = {
-            summary: {
-                timestamp: new Date().toISOString(),
-                overallScore: metrics.overall.score,
-                status: metrics.overall.status
-            },
-            components: {
-                fleetManager: {
-                    score: metrics.fleetManager.performance.overall,
-                    status: metrics.fleetManager.performance.status,
-                    recommendations: metrics.fleetManager.performance.recommendations
-                },
-                redis: {
-                    score: metrics.redis.performance.overall,
-                    status: metrics.redis.performance.status
-                },
-                dashboard: {
-                    score: metrics.dashboard.performance.overall,
-                    status: metrics.dashboard.performance.status
-                },
-                wasm: {
-                    speedup: metrics.wasm.performance.speedup,
-                    status: metrics.wasm.performance.status,
-                    recommendation: metrics.wasm.performance.recommendation
-                }
-            },
-            targets: this.targets,
-            confidence: metrics.overall.score / 100
-        };
-
-        await this.saveMetrics('report', report);
-
-        return report;
-    }
-}
-
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-    const monitor = new PerformanceMonitor();
-
-    const command = process.argv[2] || 'report';
-
-    switch (command) {
-        case 'fleet':
-            monitor.monitorFleetManager().then(data => {
-                console.log(JSON.stringify(data, null, 2));
-            });
-            break;
-
-        case 'redis':
-            monitor.monitorRedis().then(data => {
-                console.log(JSON.stringify(data, null, 2));
-            });
-            break;
-
-        case 'dashboard':
-            monitor.monitorDashboard().then(data => {
-                console.log(JSON.stringify(data, null, 2));
-            });
-            break;
-
-        case 'wasm':
-            monitor.monitorWASM().then(data => {
-                console.log(JSON.stringify(data, null, 2));
-            });
-            break;
-
-        case 'all':
-            monitor.collectAllMetrics().then(data => {
-                console.log(JSON.stringify(data, null, 2));
-            });
-            break;
-
-        case 'report':
-            monitor.generateReport().then(data => {
-                console.log(JSON.stringify(data, null, 2));
-            });
-            break;
-
-        case 'monitor':
-            const interval = parseInt(process.argv[3]) || 60000;
-            monitor.startMonitoring(interval);
-            console.log('Monitoring started. Press Ctrl+C to stop.');
-            break;
-
-        default:
-            console.log(`
-Performance Monitor - claude-flow-novice
-
-Usage:
-  node performance-monitor.js [command] [interval]
-
-Commands:
-  fleet      - Monitor fleet manager performance
-  redis      - Monitor Redis performance
-  dashboard  - Monitor dashboard performance
-  wasm       - Monitor WASM performance
-  all        - Collect all metrics
-  report     - Generate performance report (default)
-  monitor    - Start periodic monitoring
-
-Examples:
-  node performance-monitor.js report
-  node performance-monitor.js monitor 30000  # Monitor every 30 seconds
-            `);
-    }
-}
-
-export default PerformanceMonitor;