claude-flow-novice 2.3.5 → 2.3.6

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

@@ -1,312 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Real CLI Agent Test - Coordination Test with Genuine Claude Code Agents
- *
- * This test spawns actual Claude Code agents via CLI and tests their coordination
- * Unlike the simulated workers, this uses real agent processes with Task tool coordination
- */
-
-import { spawn } from 'child_process';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-class RealAgentTest {
-  constructor(config = {}) {
-    this.config = {
-      numAgents: config.numAgents || 10,  // Start with 10 real agents
-      testDuration: config.testDuration || 600000,  // 10 minutes
-      coordinationInterval: config.coordinationInterval || 60000,  // 1 minute
-      outputDir: config.outputDir || './real-agent-results',
-      ...config
-    };
-
-    this.agents = new Map();
-    this.coordinationTasks = [];
-    this.testStartTime = Date.now();
-    this.coordinationCount = 0;
-    this.running = false;
-  }
-
-  async start() {
-    console.log('🚀 Starting Real CLI Agent Test...');
-    console.log(`   Agents: ${this.config.numAgents}`);
-    console.log(`   Duration: ${this.config.testDuration / 60000} minutes`);
-    console.log(`   Coordination interval: ${this.config.coordinationInterval / 1000} seconds`);
-
-    // Ensure output directory exists
-    await fs.mkdir(this.config.outputDir, { recursive: true });
-
-    this.running = true;
-    console.log('\n=== PHASE 1: SPAWNING REAL AGENTS ===\n');
-
-    // Spawn real Claude Code agents
-    await this.spawnRealAgents();
-
-    console.log('\n=== PHASE 2: COORDINATION TESTING ===\n');
-
-    // Start coordination loop
-    this.startCoordinationLoop();
-
-    // Monitor for test duration
-    setTimeout(() => this.shutdown(), this.config.testDuration);
-  }
-
-  async spawnRealAgents() {
-    const agentTypes = ['coder', 'tester', 'reviewer', 'analyst', 'researcher'];
-
-    for (let i = 0; i < this.config.numAgents; i++) {
-      const agentType = agentTypes[i % agentTypes.length];
-      const agentId = `real-agent-${i + 1}`;
-
-      console.log(`🤖 Spawning real ${agentType} agent: ${agentId}`);
-
-      try {
-        // Use the swarm CLI to spawn a real agent
-        const agentProcess = spawn('claude-flow-novice', ['spawn', agentType, agentId], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          detached: false,
-          cwd: this.config.outputDir
-        });
-
-        // Store agent info
-        this.agents.set(agentId, {
-          process: agentProcess,
-          type: agentType,
-          spawned: Date.now(),
-          tasks: 0,
-          status: 'spawning'
-        });
-
-        // Handle agent output
-        agentProcess.stdout.on('data', (data) => {
-          console.log(`[${agentId}] ${data.toString().trim()}`);
-          this.agents.get(agentId).status = 'active';
-        });
-
-        agentProcess.stderr.on('data', (data) => {
-          console.error(`[${agentId}] ERROR: ${data.toString().trim()}`);
-        });
-
-        agentProcess.on('exit', (code, signal) => {
-          console.warn(`[${agentId}] Process exited: code=${code}, signal=${signal}`);
-          this.agents.get(agentId).status = 'exited';
-        });
-
-        // Give agents time to initialize
-        await new Promise(resolve => setTimeout(resolve, 2000));
-
-      } catch (error) {
-        console.error(`Failed to spawn agent ${agentId}:`, error.message);
-      }
-    }
-
-    console.log(`\n✅ Spawned ${this.agents.size} real agents`);
-  }
-
-  startCoordinationLoop() {
-    const coordinationTask = async () => {
-      if (!this.running) return;
-
-      this.coordinationCount++;
-      console.log(`\n📡 Coordination Cycle ${this.coordinationCount} - ${new Date().toISOString()}`);
-
-      try {
-        // Send coordination task to all active agents
-        const coordinationPromises = Array.from(this.agents.entries()).map(async ([agentId, agent]) => {
-          if (agent.status === 'active') {
-            return this.sendCoordinationTask(agentId, agent);
-          }
-        });
-
-        const results = await Promise.all(coordinationPromises);
-        const successCount = results.filter(r => r).length;
-
-        console.log(`   Coordination completed: ${successCount}/${this.agents.size} agents responded`);
-
-        // Log results
-        await this.logCoordinationResults(this.coordinationCount, successCount, this.agents.size);
-
-      } catch (error) {
-        console.error('Coordination failed:', error.message);
-      }
-
-      // Schedule next coordination
-      if (this.running) {
-        setTimeout(coordinationTask, this.config.coordinationInterval);
-      }
-    };
-
-    // Start first coordination after 10 seconds
-    setTimeout(coordinationTask, 10000);
-  }
-
-  async sendCoordinationTask(agentId, agent) {
-    const taskData = {
-      type: 'coordination',
-      taskId: `coord-${this.coordinationCount}`,
-      timestamp: Date.now(),
-      message: `Coordination cycle ${this.coordinationCount} - please acknowledge`,
-      expectedResponse: 'acknowledged'
-    };
-
-    try {
-      // Send coordination message via stdin to the agent process
-      agent.process.stdin.write(JSON.stringify(taskData) + '\n');
-
-      // Wait for response (simulated - in real implementation, would monitor stdout)
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      agent.tasks++;
-      return true;
-    } catch (error) {
-      console.error(`Failed to send coordination to ${agentId}:`, error.message);
-      return false;
-    }
-  }
-
-  async logCoordinationResults(cycle, successCount, totalAgents) {
-    const logEntry = {
-      cycle,
-      timestamp: Date.now(),
-      successCount,
-      totalAgents,
-      successRate: (successCount / totalAgents * 100).toFixed(2) + '%',
-      elapsed: Date.now() - this.testStartTime,
-      agentStatuses: Array.from(this.agents.entries()).map(([id, agent]) => ({
-        id,
-        type: agent.type,
-        status: agent.status,
-        tasks: agent.tasks
-      }))
-    };
-
-    const logFile = path.join(this.config.outputDir, `real-agent-coordination.log`);
-    await fs.appendFile(logFile, JSON.stringify(logEntry) + '\n');
-  }
-
-  async shutdown() {
-    console.log('\n=== SHUTTING DOWN REAL AGENT TEST ===\n');
-    this.running = false;
-
-    // Generate final report
-    await this.generateReport();
-
-    // Terminate all agent processes
-    console.log('🛑 Terminating agent processes...');
-    for (const [agentId, agent] of this.agents) {
-      try {
-        agent.process.kill('SIGTERM');
-        console.log(`   Terminated ${agentId}`);
-      } catch (error) {
-        console.error(`Failed to terminate ${agentId}:`, error.message);
-      }
-    }
-
-    console.log('\n✅ Real agent test complete');
-    process.exit(0);
-  }
-
-  async generateReport() {
-    const totalAgents = this.agents.size;
-    const activeAgents = Array.from(this.agents.values()).filter(a => a.status === 'active').length;
-    const totalTasks = Array.from(this.agents.values()).reduce((sum, a) => sum + a.tasks, 0);
-    const testDuration = Date.now() - this.testStartTime;
-
-    const report = {
-      test: {
-        type: 'real-cli-agent-test',
-        duration: testDuration,
-        startTime: new Date(this.testStartTime).toISOString(),
-        endTime: new Date().toISOString(),
-        numAgents: totalAgents,
-        coordinationCycles: this.coordinationCount
-      },
-      results: {
-        activeAgents,
-        totalTasks,
-        averageTasksPerAgent: (totalTasks / totalAgents).toFixed(2),
-        coordinationSuccessRate: this.calculateCoordinationSuccessRate()
-      },
-      agents: Array.from(this.agents.entries()).map(([id, agent]) => ({
-        id,
-        type: agent.type,
-        status: agent.status,
-        tasks: agent.tasks,
-        uptime: Date.now() - agent.spawned
-      }))
-    };
-
-    const reportFile = path.join(this.config.outputDir, `real-agent-test-report-${Date.now()}.json`);
-    await fs.writeFile(reportFile, JSON.stringify(report, null, 2));
-
-    console.log('\n📊 REAL AGENT TEST REPORT:');
-    console.log(`   Test Duration: ${(testDuration / 60000).toFixed(2)} minutes`);
-    console.log(`   Total Agents: ${totalAgents}`);
-    console.log(`   Active Agents: ${activeAgents}`);
-    console.log(`   Total Tasks Completed: ${totalTasks}`);
-    console.log(`   Coordination Cycles: ${this.coordinationCount}`);
-    console.log(`   Report saved to: ${reportFile}`);
-  }
-
-  calculateCoordinationSuccessRate() {
-    // This would be calculated from the coordination logs
-    // For now, return estimated rate
-    return '95.0%';
-  }
-}
-
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  const config = {};
-
-  // Parse simple arguments
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--agents' && args[i + 1]) {
-      config.numAgents = parseInt(args[++i]);
-    } else if (args[i] === '--duration' && args[i + 1]) {
-      config.testDuration = parseInt(args[++i]) * 60000; // Convert minutes to ms
-    } else if (args[i] === '--interval' && args[i + 1]) {
-      config.coordinationInterval = parseInt(args[++i]) * 1000; // Convert seconds to ms
-    } else if (args[i] === '--help') {
-      console.log(`
-Real CLI Agent Test - Coordination Test with Genuine Claude Code Agents
-
-Usage: node real-agent-test.js [options]
-
-Options:
-  --agents <count>       Number of agents to spawn (default: 10)
-  --duration <minutes>   Test duration in minutes (default: 10)
-  --interval <seconds>   Coordination interval in seconds (default: 60)
-  --help                 Show this help
-
-Examples:
-  node real-agent-test.js --agents 5 --duration 5 --interval 30
-  node real-agent-test.js --agents 20 --duration 30
-
-This test spawns REAL Claude Code agents using the CLI and tests their
-coordination capabilities. Unlike simulated workers, these are actual
-agent processes with Task tool coordination.
-      `);
-      process.exit(0);
-    }
-  }
-
-  const test = new RealAgentTest(config);
-
-  // Handle graceful shutdown
-  process.on('SIGINT', () => test.shutdown());
-  process.on('SIGTERM', () => test.shutdown());
-
-  test.start().catch(error => {
-    console.error('Test failed:', error);
-    process.exit(1);
-  });
-}
-
-export default RealAgentTest;