claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/test/50-agent-test.js

@@ -1,625 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * 50-Agent Stability Test Orchestrator
- *
- * Spawns and manages 50 agent processes for 8-hour stability testing.
- * Uses /dev/shm for file-based coordination and comprehensive monitoring.
- */
-
-import fs from 'fs';
-import path from 'path';
-import { spawn } from 'child_process';
-import os from 'os';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-class StabilityTestOrchestrator {
-  constructor(options = {}) {
-    this.numAgents = options.numAgents || 50;
-    this.testDuration = options.testDuration || 8 * 60 * 60 * 1000; // 8 hours in ms
-    this.coordinationInterval = options.coordinationInterval || 5 * 60 * 1000; // 5 minutes in ms
-    this.coordinationDir = options.coordinationDir || '/dev/shm/agent-coordination';
-    this.outputDir = options.outputDir || path.join(__dirname, 'stability-results');
-    this.logFile = path.join(this.outputDir, 'stability-test.log');
-    this.metricsFile = path.join(this.outputDir, 'stability-metrics.jsonl');
-
-    this.agents = new Map();
-    this.startTime = Date.now();
-    this.coordinationCount = 0;
-    this.maxCoordinationCycles = Math.floor(this.testDuration / this.coordinationInterval);
-
-    // Metrics tracking
-    this.metrics = {
-      testStartTime: this.startTime,
-      testDuration: this.testDuration,
-      numAgents: this.numAgents,
-      coordinationInterval: this.coordinationInterval,
-      coordinationCycles: 0,
-      agentMetrics: new Map(),
-      systemMetrics: [],
-      crashEvents: [],
-      performanceMetrics: []
-    };
-
-    this.setupDirectories();
-    this.setupSignalHandlers();
-    this.cleanupCoordinationDir();
-  }
-
-  setupDirectories() {
-    try {
-      fs.mkdirSync(this.coordinationDir, { recursive: true });
-      fs.mkdirSync(path.join(this.coordinationDir, 'messages'), { recursive: true });
-      fs.mkdirSync(path.join(this.coordinationDir, 'responses'), { recursive: true });
-      fs.mkdirSync(path.join(this.coordinationDir, 'status'), { recursive: true });
-      fs.mkdirSync(this.outputDir, { recursive: true });
-
-      // Initialize log file
-      fs.writeFileSync(this.logFile, `# 50-Agent Stability Test - ${new Date().toISOString()}\n\n`);
-    } catch (error) {
-      console.error('Failed to create directories:', error.message);
-      process.exit(1);
-    }
-  }
-
-  setupSignalHandlers() {
-    const gracefulShutdown = async (signal) => {
-      this.log(`Received ${signal}, shutting down gracefully...`);
-      await this.shutdownAllAgents();
-      this.generateFinalReport();
-      process.exit(0);
-    };
-
-    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-    process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
-
-    process.on('uncaughtException', (error) => {
-      this.log(`Uncaught exception: ${error.message}`, 'error');
-      this.log(error.stack, 'error');
-      gracefulShutdown('UNCAUGHT_EXCEPTION');
-    });
-
-    process.on('unhandledRejection', (reason, promise) => {
-      this.log(`Unhandled rejection: ${reason}`, 'error');
-      gracefulShutdown('UNHANDLED_REJECTION');
-    });
-  }
-
-  cleanupCoordinationDir() {
-    try {
-      const dirs = ['messages', 'responses', 'status'];
-      dirs.forEach(dir => {
-        const dirPath = path.join(this.coordinationDir, dir);
-        if (fs.existsSync(dirPath)) {
-          const files = fs.readdirSync(dirPath);
-          files.forEach(file => {
-            fs.unlinkSync(path.join(dirPath, file));
-          });
-        }
-      });
-      this.log('Cleaned coordination directory');
-    } catch (error) {
-      this.log(`Error cleaning coordination directory: ${error.message}`, 'error');
-    }
-  }
-
-  log(message, level = 'info') {
-    const timestamp = new Date().toISOString();
-    const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-
-    console.log(logEntry.trim());
-
-    try {
-      fs.appendFileSync(this.logFile, logEntry);
-    } catch (error) {
-      console.error('Failed to write to log file:', error.message);
-    }
-  }
-
-  spawnAgent(agentId) {
-    const agentScript = path.join(__dirname, 'agent-worker.js');
-    const args = [agentScript, agentId.toString(), this.coordinationDir];
-
-    const agentProcess = spawn('node', args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: false
-    });
-
-    const agent = {
-      id: agentId,
-      process: agentProcess,
-      startTime: Date.now(),
-      lastSeen: Date.now(),
-      status: 'starting',
-      responses: 0,
-      errors: 0,
-      memoryUsage: [],
-      responseTimes: [],
-      crashed: false,
-      crashCount: 0
-    };
-
-    // Handle process output
-    agentProcess.stdout.on('data', (data) => {
-      this.log(`[Agent ${agentId}] ${data.toString().trim()}`, 'debug');
-      agent.lastSeen = Date.now();
-    });
-
-    agentProcess.stderr.on('data', (data) => {
-      this.log(`[Agent ${agentId} ERROR] ${data.toString().trim()}`, 'error');
-      agent.errors++;
-      agent.lastSeen = Date.now();
-    });
-
-    agentProcess.on('exit', (code, signal) => {
-      this.log(`[Agent ${agentId}] Process exited with code ${code}, signal ${signal}`, 'warn');
-      agent.crashed = true;
-      agent.crashCount++;
-      agent.exitTime = Date.now();
-
-      const crashEvent = {
-        agentId,
-        exitCode: code,
-        signal,
-        timestamp: Date.now(),
-        uptime: Date.now() - agent.startTime
-      };
-
-      this.metrics.crashEvents.push(crashEvent);
-      this.log(`Crash event recorded for agent ${agentId}`, 'warn');
-
-      // Attempt to restart the agent if not during shutdown
-      if (this.isRunning) {
-        this.log(`Attempting to restart agent ${agentId}...`, 'warn');
-        setTimeout(() => {
-          this.restartAgent(agentId);
-        }, 5000); // Wait 5 seconds before restart
-      }
-    });
-
-    this.agents.set(agentId, agent);
-    this.log(`Spawned agent ${agentId} with PID ${agentProcess.pid}`);
-
-    return agent;
-  }
-
-  restartAgent(agentId) {
-    const oldAgent = this.agents.get(agentId);
-    if (oldAgent) {
-      // Clean up old process
-      try {
-        if (oldAgent.process && !oldAgent.process.killed) {
-          oldAgent.process.kill('SIGTERM');
-        }
-      } catch (error) {
-        this.log(`Error killing old agent ${agentId} process: ${error.message}`, 'error');
-      }
-    }
-
-    this.spawnAgent(agentId);
-  }
-
-  async spawnAllAgents() {
-    this.log(`Spawning ${this.numAgents} agents...`);
-
-    const spawnPromises = [];
-    for (let i = 1; i <= this.numAgents; i++) {
-      spawnPromises.push(
-        new Promise((resolve) => {
-          setTimeout(() => {
-            this.spawnAgent(i);
-            resolve();
-          }, i * 100); // Stagger agent spawns by 100ms
-        })
-      );
-    }
-
-    await Promise.all(spawnPromises);
-    this.log(`All ${this.numAgents} agents spawned`);
-
-    // Wait for agents to initialize
-    this.log('Waiting for agents to initialize...');
-    await new Promise(resolve => setTimeout(resolve, 10000)); // 10 seconds
-  }
-
-  async coordinationCycle() {
-    const cycleStart = Date.now();
-    this.coordinationCount++;
-    this.metrics.coordinationCycles = this.coordinationCount;
-
-    this.log(`Starting coordination cycle ${this.coordinationCount}/${this.maxCoordinationCycles}`);
-
-    const messageId = `coord-${this.coordinationCount}-${Date.now()}`;
-    const messageTypes = ['ping', 'compute', 'memory_test'];
-    const messageType = messageTypes[this.coordinationCount % messageTypes.length];
-
-    const coordinationMessage = {
-      messageId,
-      type: messageType,
-      timestamp: Date.now(),
-      cycle: this.coordinationCount,
-      data: messageType === 'compute' ? { iterations: 1000 + Math.floor(Math.random() * 2000) } :
-            messageType === 'memory_test' ? { size: 1000 + Math.floor(Math.random() * 2000) } :
-            {}
-    };
-
-    // Send coordination messages to all agents
-    const messagePromises = [];
-    for (let agentId = 1; agentId <= this.numAgents; agentId++) {
-      const messageFile = path.join(this.coordinationDir, 'messages', `coordination-${agentId}.json`);
-
-      messagePromises.push(
-        new Promise((resolve) => {
-          try {
-            fs.writeFileSync(messageFile, JSON.stringify(coordinationMessage, null, 2));
-            resolve({ agentId, success: true });
-          } catch (error) {
-            this.log(`Failed to send message to agent ${agentId}: ${error.message}`, 'error');
-            resolve({ agentId, success: false, error: error.message });
-          }
-        })
-      );
-    }
-
-    const messageResults = await Promise.all(messagePromises);
-    const successfulMessages = messageResults.filter(r => r.success).length;
-    this.log(`Sent coordination messages to ${successfulMessages}/${this.numAgents} agents`);
-
-    // Wait for responses
-    const responseWaitTime = 30000; // 30 seconds max wait
-    const responseStart = Date.now();
-
-    const responses = [];
-    while (Date.now() - responseStart < responseWaitTime) {
-      const responseDir = path.join(this.coordinationDir, 'responses');
-      try {
-        const files = fs.readdirSync(responseDir);
-        const responseFiles = files.filter(file => file.includes(messageId));
-
-        for (const file of responseFiles) {
-          try {
-            const filePath = path.join(responseDir, file);
-            const responseData = fs.readFileSync(filePath, 'utf8');
-            fs.unlinkSync(filePath); // Remove after reading
-
-            const response = JSON.parse(responseData);
-            responses.push(response);
-
-            // Update agent metrics
-            const agent = this.agents.get(response.agentId);
-            if (agent) {
-              agent.responses++;
-              agent.responseTimes.push(response.processingTime);
-              agent.memoryUsage.push(response.memory);
-              agent.lastSeen = response.timestamp;
-              agent.status = 'active';
-            }
-
-          } catch (error) {
-            this.log(`Error processing response file ${file}: ${error.message}`, 'error');
-          }
-        }
-
-        if (responses.length >= this.numAgents * 0.8) { // 80% response threshold
-          break;
-        }
-
-      } catch (error) {
-        this.log(`Error reading response directory: ${error.message}`, 'error');
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
-    }
-
-    const cycleDuration = Date.now() - cycleStart;
-    this.log(`Coordination cycle ${this.coordinationCount} completed in ${cycleDuration}ms with ${responses.length} responses`);
-
-    // Record cycle metrics
-    const cycleMetrics = {
-      cycle: this.coordinationCount,
-      timestamp: Date.now(),
-      duration: cycleDuration,
-      messagesSent: successfulMessages,
-      responsesReceived: responses.length,
-      responseRate: responses.length / this.numAgents,
-      averageResponseTime: responses.length > 0 ?
-        responses.reduce((sum, r) => sum + r.processingTime, 0) / responses.length : 0,
-      memoryStats: this.calculateMemoryStats(responses),
-      crashedAgents: Array.from(this.agents.values()).filter(a => a.crashed).length
-    };
-
-    this.metrics.performanceMetrics.push(cycleMetrics);
-    this.writeMetricsLog(cycleMetrics);
-
-    return cycleMetrics;
-  }
-
-  calculateMemoryStats(responses) {
-    if (responses.length === 0) return null;
-
-    const memoryUsages = responses.map(r => r.memory.heapUsed);
-    const memoryGrowthRates = responses.map(r => r.memoryGrowthRate || 0);
-
-    return {
-      average: Math.round(memoryUsages.reduce((a, b) => a + b, 0) / memoryUsages.length),
-      min: Math.min(...memoryUsages),
-      max: Math.max(...memoryUsages),
-      median: this.median(memoryUsages),
-      growthRate: {
-        average: Math.round(memoryGrowthRates.reduce((a, b) => a + b, 0) / memoryGrowthRates.length),
-        max: Math.max(...memoryGrowthRates)
-      }
-    };
-  }
-
-  median(numbers) {
-    const sorted = [...numbers].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 === 0 ?
-      Math.round((sorted[mid - 1] + sorted[mid]) / 2) :
-      sorted[mid];
-  }
-
-  writeMetricsLog(cycleMetrics) {
-    const logEntry = {
-      timestamp: new Date().toISOString(),
-      type: 'coordination_cycle',
-      ...cycleMetrics,
-      systemInfo: {
-        freeMemory: os.freemem(),
-        totalMemory: os.totalmem(),
-        loadAverage: os.loadavg(),
-        uptime: os.uptime()
-      }
-    };
-
-    try {
-      fs.appendFileSync(this.metricsFile, JSON.stringify(logEntry) + '\n');
-    } catch (error) {
-      this.log(`Failed to write metrics: ${error.message}`, 'error');
-    }
-  }
-
-  async runStabilityTest() {
-    this.isRunning = true;
-    this.log(`Starting ${this.numAgents}-agent stability test for ${this.testDuration / 1000 / 60 / 60} hours`);
-    this.log(`Coordination interval: ${this.coordinationInterval / 1000 / 60} minutes`);
-    this.log(`Expected cycles: ${this.maxCoordinationCycles}`);
-
-    await this.spawnAllAgents();
-
-    const testEnd = this.startTime + this.testDuration;
-
-    while (Date.now() < testEnd && this.isRunning) {
-      try {
-        await this.coordinationCycle();
-
-        // Check if we have time for another cycle
-        const timeRemaining = testEnd - Date.now();
-        if (timeRemaining < this.coordinationInterval) {
-          this.log(`Test time remaining (${timeRemaining}ms) less than coordination interval, finishing...`);
-          break;
-        }
-
-        this.log(`Waiting ${this.coordinationInterval / 1000} seconds for next coordination cycle...`);
-        await new Promise(resolve => setTimeout(resolve, this.coordinationInterval));
-
-      } catch (error) {
-        this.log(`Error in coordination cycle: ${error.message}`, 'error');
-        // Continue with next cycle even if one fails
-      }
-    }
-
-    this.log('Stability test completed');
-    await this.shutdownAllAgents();
-    this.generateFinalReport();
-  }
-
-  async shutdownAllAgents() {
-    this.isRunning = false;
-    this.log('Shutting down all agents...');
-
-    const shutdownPromises = [];
-
-    for (const [agentId, agent] of this.agents) {
-      shutdownPromises.push(
-        new Promise((resolve) => {
-          if (agent.process && !agent.process.killed) {
-            agent.process.on('exit', resolve);
-
-            try {
-              agent.process.kill('SIGTERM');
-
-              // Force kill after 10 seconds
-              setTimeout(() => {
-                if (!agent.process.killed) {
-                  agent.process.kill('SIGKILL');
-                }
-                resolve();
-              }, 10000);
-
-            } catch (error) {
-              this.log(`Error shutting down agent ${agentId}: ${error.message}`, 'error');
-              resolve();
-            }
-          } else {
-            resolve();
-          }
-        })
-      );
-    }
-
-    await Promise.all(shutdownPromises);
-    this.log('All agents shut down');
-  }
-
-  generateFinalReport() {
-    const testEndTime = Date.now();
-    const actualTestDuration = testEndTime - this.startTime;
-
-    const report = {
-      summary: {
-        testStartTime: new Date(this.startTime).toISOString(),
-        testEndTime: new Date(testEndTime).toISOString(),
-        actualDuration: actualTestDuration,
-        plannedDuration: this.testDuration,
-        numAgents: this.numAgents,
-        coordinationCycles: this.coordinationCount,
-        plannedCycles: this.maxCoordinationCycles
-      },
-      agentStats: this.calculateAgentStats(),
-      performance: this.calculatePerformanceStats(),
-      crashes: {
-        totalCrashEvents: this.metrics.crashEvents.length,
-        crashRate: this.metrics.crashEvents.length / (this.numAgents * this.coordinationCount),
-        events: this.metrics.crashEvents.slice(0, 10) // First 10 events
-      },
-      acceptanceCriteria: this.checkAcceptanceCriteria()
-    };
-
-    const reportFile = path.join(this.outputDir, 'stability-test-report.json');
-    fs.writeFileSync(reportFile, JSON.stringify(report, null, 2));
-
-    this.log(`Final report generated: ${reportFile}`);
-    this.log(`Test completed: ${report.acceptanceCriteria.passed ? 'PASSED' : 'FAILED'}`);
-
-    return report;
-  }
-
-  calculateAgentStats() {
-    const agents = Array.from(this.agents.values());
-
-    return {
-      totalAgents: agents.length,
-      agentsWithCrashes: agents.filter(a => a.crashCount > 0).length,
-      totalCrashes: agents.reduce((sum, a) => sum + a.crashCount, 0),
-      averageResponses: agents.reduce((sum, a) => sum + a.responses, 0) / agents.length,
-      averageErrors: agents.reduce((sum, a) => sum + a.errors, 0) / agents.length,
-      averageResponseTime: agents.reduce((sum, a) => {
-        const times = a.responseTimes;
-        return sum + (times.length > 0 ? times.reduce((s, t) => s + t, 0) / times.length : 0);
-      }, 0) / agents.length
-    };
-  }
-
-  calculatePerformanceStats() {
-    const cycles = this.metrics.performanceMetrics;
-
-    if (cycles.length === 0) return null;
-
-    const responseRates = cycles.map(c => c.responseRate);
-    const responseTimes = cycles.map(c => c.averageResponseTime);
-    const durations = cycles.map(c => c.duration);
-
-    return {
-      averageResponseRate: responseRates.reduce((a, b) => a + b, 0) / responseRates.length,
-      minResponseRate: Math.min(...responseRates),
-      maxResponseRate: Math.max(...responseRates),
-      averageResponseTime: responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length,
-      averageCycleDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
-      cycleDurationVariance: this.calculateVariance(durations)
-    };
-  }
-
-  calculateVariance(numbers) {
-    const mean = numbers.reduce((a, b) => a + b, 0) / numbers.length;
-    const variance = numbers.reduce((sum, num) => sum + Math.pow(num - mean, 2), 0) / numbers.length;
-    return Math.round(variance);
-  }
-
-  checkAcceptanceCriteria() {
-    const agentStats = this.calculateAgentStats();
-    const performance = this.calculatePerformanceStats();
-
-    const criteria = {
-      memoryGrowth: { threshold: 0.10, actual: 0, passed: true }, // Will be calculated
-      coordinationVariance: { threshold: 0.20, actual: 0, passed: true },
-      criticalCrashes: { threshold: 0, actual: 0, passed: true },
-      completeMetrics: { threshold: true, actual: true, passed: true }
-    };
-
-    // Calculate memory growth (simplified - based on first vs last cycle)
-    if (this.metrics.performanceMetrics.length >= 2) {
-      const firstCycle = this.metrics.performanceMetrics[0];
-      const lastCycle = this.metrics.performanceMetrics[this.metrics.performanceMetrics.length - 1];
-
-      if (firstCycle.memoryStats && lastCycle.memoryStats) {
-        const memoryGrowth = (lastCycle.memoryStats.average - firstCycle.memoryStats.average) / firstCycle.memoryStats.average;
-        criteria.memoryGrowth.actual = Math.round(memoryGrowth * 100) / 100;
-        criteria.memoryGrowth.passed = memoryGrowth <= criteria.memoryGrowth.threshold;
-      }
-    }
-
-    // Calculate coordination time variance
-    if (performance) {
-      const avgDuration = performance.averageCycleDuration;
-      const variance = performance.cycleDurationVariance;
-      const varianceRate = Math.sqrt(variance) / avgDuration;
-
-      criteria.coordinationVariance.actual = Math.round(varianceRate * 100) / 100;
-      criteria.coordinationVariance.passed = varianceRate <= criteria.coordinationVariance.threshold;
-    }
-
-    // Check critical crashes (crashes that prevented test continuation)
-    criteria.criticalCrashes.actual = this.metrics.crashEvents.length;
-    criteria.criticalCrashes.passed = true; // Test continued despite crashes
-
-    // Check metrics completeness
-    criteria.completeMetrics.actual = this.metrics.performanceMetrics.length === this.coordinationCount;
-    criteria.completeMetrics.passed = criteria.completeMetrics.actual;
-
-    const passed = Object.values(criteria).every(c => c.passed);
-
-    return {
-      passed,
-      criteria
-    };
-  }
-}
-
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const options = {
-    numAgents: 50,
-    testDuration: 8 * 60 * 60 * 1000, // 8 hours
-    coordinationInterval: 5 * 60 * 1000 // 5 minutes
-  };
-
-  // Parse command line arguments
-  const args = process.argv.slice(2);
-  for (let i = 0; i < args.length; i += 2) {
-    switch (args[i]) {
-      case '--agents':
-        options.numAgents = parseInt(args[i + 1]);
-        break;
-      case '--duration':
-        options.testDuration = parseInt(args[i + 1]) * 60 * 1000; // minutes to ms
-        break;
-      case '--interval':
-        options.coordinationInterval = parseInt(args[i + 1]) * 1000; // seconds to ms
-        break;
-      case '--coord-dir':
-        options.coordinationDir = args[i + 1];
-        break;
-      case '--output-dir':
-        options.outputDir = args[i + 1];
-        break;
-    }
-  }
-
-  console.log('50-Agent Stability Test Starting...');
-  console.log(`Options:`, JSON.stringify(options, null, 2));
-
-  const orchestrator = new StabilityTestOrchestrator(options);
-
-  orchestrator.runStabilityTest().catch(error => {
-    console.error('Stability test failed:', error);
-    process.exit(1);
-  });
-}
-
-export default StabilityTestOrchestrator;