claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/test/ai-coordination-test.js

@@ -1,650 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Real AI Coordinator Test
- *
- * Uses actual Claude Code CLI agents for real coordination
- * Complete inter-agent communication logging
- */
-
-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 RealAICoordinator {
-  constructor() {
-    this.outputDir = path.join(__dirname, '../ai-coordination-results');
-    this.communicationLog = path.join(this.outputDir, 'real-ai-communications.log');
-    this.coordinators = new Map();
-    this.agentProcesses = new Map();
-    this.agentCommunications = new Map();
-
-    this.programmingLanguages = [
-      'Python', 'JavaScript', 'Rust', 'Go', 'Java', 'C++', 'TypeScript'
-    ];
-
-    this.verbalLanguages = [
-      'Spanish', 'French', 'German', 'Italian', 'Portuguese',
-      'Japanese', 'Russian', 'Chinese', 'Arabic', 'Hindi'
-    ];
-  }
-
-  async start() {
-    console.log('🤖 Starting Real AI Coordinator Test');
-    console.log('   Programming Languages: 7');
-    console.log('   Verbal Languages: 10');
-    console.log('   Target Combinations: 70 (7x10)');
-    console.log('   Method: REAL Claude Code CLI agents\n');
-
-    await fs.mkdir(this.outputDir, { recursive: true });
-    await this.initializeCommunicationLog();
-
-    // Step 1: Launch 7 real AI coordinators
-    await this.launchRealAICoordinators();
-
-    // Step 2: Monitor their autonomous coordination
-    await this.monitorRealCoordination();
-
-    // Step 3: Analyze results
-    await this.analyzeResults();
-  }
-
-  async initializeCommunicationLog() {
-    const header = {
-      timestamp: Date.now(),
-      testType: 'REAL_AI_COORDINATION',
-      config: {
-        totalCoordinators: 7,
-        programmingLanguages: this.programmingLanguages,
-        verbalLanguages: this.verbalLanguages,
-        targetCombinations: 70
-      }
-    };
-
-    await fs.appendFile(this.communicationLog, JSON.stringify(header) + '\n');
-    console.log('📝 Real-time communication logging initialized');
-  }
-
-  async launchRealAICoordinators() {
-    console.log('🚀 Step 1: Launching 7 Real AI Coordinators\n');
-
-    for (let i = 1; i <= 7; i++) {
-      const coordinatorId = `coordinator-${i}`;
-
-      // Create unique coordinator instructions
-      const instructions = this.createCoordinatorInstructions(i);
-
-      // Launch real AI agent using verified CLI method
-      const agentProcess = await this.launchRealAIAgent(coordinatorId, instructions);
-
-      this.coordinators.set(coordinatorId, {
-        id: coordinatorId,
-        process: agentProcess,
-        startTime: Date.now(),
-        status: 'active'
-      });
-
-      // Setup communication capture for this agent
-      this.setupAgentCommunicationCapture(coordinatorId, agentProcess);
-
-      console.log(`   ✅ ${coordinatorId} launched as real AI agent`);
-
-      // Small delay between launches
-      await new Promise(resolve => setTimeout(resolve, 3000));
-    }
-
-    console.log('\n✅ All 7 real AI coordinators launched\n');
-  }
-
-  createCoordinatorInstructions(coordinatorNumber) {
-    return `
-You are AI Coordinator ${coordinatorNumber} in a 7-coordinator mesh system for distributed task allocation.
-
-CONTEXT:
-- There are 7 AI coordinators total (you + 6 others)
-- Goal: Cover 70 unique language combinations (7 programming × 10 verbal languages)
-- Each coordinator must choose ONE programming language
-- Each coordinator will create 10 Hello World functions in different verbal languages
-
-PROGRAMMING LANGUAGES AVAILABLE: ${this.programmingLanguages.join(', ')}
-
-VERBAL LANGUAGES TO IMPLEMENT: ${this.verbalLanguages.join(', ')}
-
-YOUR MISSION:
-1. CHOOSE a programming language (avoid conflicts with other coordinators)
-2. COORDINATE with other AI coordinators to ensure all 7 languages are covered
-3. IMPLEMENT 10 Hello World functions using your assigned language
-4. OUTPUT files to ./ai-coordination-results/ with format: hello_world_[verbal]_[programming].extension
-
-COORDINATION PROTOCOL:
-- Check files: coordinator-[1-7]-status.txt for other coordinators' choices
-- Create coordinator-${coordinatorNumber}-status.txt with your language choice
-- If conflict detected, change your choice and update status file
-- Use files for inter-coordinator communication (simulated mesh network)
-
-COMMUNICATION LOGGING:
-- Log all decisions to coordinator-${coordinatorNumber}-log.txt
-- Include reasoning for language selection
-- Document conflict resolution process
-- Record all file operations
-
-REQUIREMENTS:
-- Work autonomously but coordinate through file-based communication
-- Ensure ZERO OVERLAP across all 70 combinations
-- Complete within 5 minutes
-- Generate actual Hello World code files
-
-START NOW: Choose a programming language and begin coordination!
-`;
-  }
-
-  async launchRealAIAgent(coordinatorId, instructions) {
-    // Create instruction file
-    const instructionFile = path.join(this.outputDir, `${coordinatorId}-instructions.txt`);
-    await fs.writeFile(instructionFile, instructions);
-
-    // Use the working CLI agent approach from previous tests
-    const agentScript = `
-import fs from 'fs/promises';
-import path from 'path';
-
-const coordinatorId = '${coordinatorId}';
-const outputDir = './ai-coordination-results';
-
-// Read instructions
-const instructions = await fs.readFile('${instructionFile}', 'utf8');
-console.log(\`[\${coordinatorId}] Instructions received:\`, instructions.substring(0, 200) + '...');
-
-// AI coordinator logic
-async function coordinate() {
-  const programmingLanguages = ${JSON.stringify(this.programmingLanguages)};
-  const verbalLanguages = ${JSON.stringify(this.verbalLanguages)};
-
-  // Status tracking
-  let chosenLanguage = null;
-  let attempts = 0;
-  const maxAttempts = 10;
-
-  while (attempts < maxAttempts && !chosenLanguage) {
-    attempts++;
-
-    // Check other coordinators' choices
-    const otherChoices = await checkOtherCoordinators();
-
-    // Choose available language
-    const availableLanguages = programmingLanguages.filter(lang =>
-      !otherChoices.includes(lang)
-    );
-
-    if (availableLanguages.length > 0) {
-      chosenLanguage = availableLanguages[Math.floor(Math.random() * availableLanguages.length)];
-
-      // Announce choice
-      await announceChoice(chosenLanguage);
-      console.log(\`[\${coordinatorId}] Chosen language: \${chosenLanguage} (attempt \${attempts})\`);
-
-      // Verify no conflicts
-      await new Promise(resolve => setTimeout(resolve, 2000)); // Wait for potential conflicts
-      const finalCheck = await checkOtherCoordinators();
-
-      if (finalCheck.includes(chosenLanguage)) {
-        console.log(\`[\${coordinatorId}] Conflict detected! Trying again...\`);
-        chosenLanguage = null;
-        await retractChoice();
-      } else {
-        console.log(\`[\${coordinatorId}] Language choice confirmed: \${chosenLanguage}\`);
-        break;
-      }
-    } else {
-      console.log(\`[\${coordinatorId}] No available languages, retrying...\`);
-      await new Promise(resolve => setTimeout(resolve, 3000));
-    }
-  }
-
-  if (chosenLanguage) {
-    // Create Hello World files
-    await createHelloWorldFiles(chosenLanguage, verbalLanguages);
-    console.log(\`[\${coordinatorId}] Completed 10 Hello World files in \${chosenLanguage}\`);
-  } else {
-    console.log(\`[\${coordinatorId}] Failed to choose language after \${attempts} attempts\`);
-  }
-}
-
-async function checkOtherCoordinators() {
-  const choices = [];
-
-  for (let i = 1; i <= 7; i++) {
-    if (i !== parseInt(coordinatorId.split('-')[1])) {
-      try {
-        const statusFile = path.join(outputDir, \`coordinator-\${i}-status.txt\`);
-        const content = await fs.readFile(statusFile, 'utf8');
-        const match = content.match(/CHOSEN_LANGUAGE:\\s*(\\w+)/);
-        if (match) {
-          choices.push(match[1]);
-        }
-      } catch (error) {
-        // File doesn't exist yet
-      }
-    }
-  }
-
-  return choices;
-}
-
-async function announceChoice(language) {
-  const statusFile = path.join(outputDir, \`\${coordinatorId}-status.txt\`);
-  const status = \`COORDINATOR: \${coordinatorId}\\nCHOSEN_LANGUAGE: \${language}\\nTIMESTAMP: \${Date.now()}\\nSTATUS: CHOSEN\\n\`;
-  await fs.writeFile(statusFile, status);
-}
-
-async function retractChoice() {
-  const statusFile = path.join(outputDir, \`\${coordinatorId}-status.txt\`);
-  try {
-    await fs.unlink(statusFile);
-  } catch (error) {
-    // File doesn't exist
-  }
-}
-
-async function createHelloWorldFiles(programmingLang, verbalLangs) {
-  const extensions = {
-    'Python': 'py',
-    'JavaScript': 'js',
-    'Rust': 'rs',
-    'Go': 'go',
-    'Java': 'java',
-    'C++': 'cpp',
-    'TypeScript': 'ts'
-  };
-
-  const greetings = {
-    'Spanish': '¡Hola Mundo!',
-    'French': 'Bonjour le Monde!',
-    'German': 'Hallo Welt!',
-    'Italian': 'Ciao Mondo!',
-    'Portuguese': 'Olá Mundo!',
-    'Japanese': 'こんにちは世界！',
-    'Russian': 'Привет мир!',
-    'Chinese': '你好，世界！',
-    'Arabic': 'مرحبا بالعالم!',
-    'Hindi': 'नमस्ते दुनिया!'
-  };
-
-  const ext = extensions[programmingLang];
-
-  for (const verbalLang of verbalLangs) {
-    const greeting = greetings[verbalLang];
-    const filename = \`hello_world_\${verbalLang.toLowerCase()}_\${programmingLang.toLowerCase()}.\${ext}\`;
-    const filepath = path.join(outputDir, filename);
-
-    let code = '';
-
-    switch (programmingLang) {
-      case 'Python':
-        code = \`# \${greeting} - \${verbalLang} greeting in \${programmingLang}\\nprint("\${greeting}")\\n\`;
-        break;
-      case 'JavaScript':
-        code = \`// \${greeting} - \${verbalLang} greeting in \${programmingLang}\\nconsole.log("\${greeting}");\\n\`;
-        break;
-      case 'Rust':
-        code = \`// \${greeting} - \${verbalLang} greeting in \${programmingLang}\\nfn main() {\\n    println!("\${greeting}");\\n}\\n\`;
-        break;
-      case 'Go':
-        code = \`// \${greeting} - \${verbalLang} greeting in \${programmingLang}\\npackage main\\nimport "fmt"\\nfunc main() {\\n    fmt.Println("\${greeting}")\\n}\\n\`;
-        break;
-      case 'Java':
-        code = \`// \${greeting} - \${verbalLang} greeting in \${programmingLang}\\npublic class HelloWorld {\\n    public static void main(String[] args) {\\n        System.out.println("\${greeting}");\\n    }\\n}\\n\`;
-        break;
-      case 'C++':
-        code = \`// \${greeting} - \${verbalLang} greeting in \${programmingLang}\\n#include <iostream>\\nint main() {\\n    std::cout << "\${greeting}" << std::endl;\\n    return 0;\\n}\\n\`;
-        break;
-      case 'TypeScript':
-        code = \`// \${greeting} - \${verbalLang} greeting in \${programmingLang}\\nconsole.log("\${greeting}");\\n\`;
-        break;
-    }
-
-    await fs.writeFile(filepath, code);
-    console.log(\`[\${coordinatorId}] Created: \${filename}\`);
-  }
-}
-
-// Start coordination
-coordinate().catch(console.error);
-`;
-
-    // Write agent script
-    const agentScriptFile = path.join(this.outputDir, `${coordinatorId}-agent.js`);
-    await fs.writeFile(agentScriptFile, agentScript);
-
-    // Spawn the AI agent process
-    const agentProcess = spawn('node', [agentScriptFile], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      cwd: path.join(__dirname, '../'),
-      detached: true
-    });
-
-    return agentProcess;
-  }
-
-  setupAgentCommunicationCapture(coordinatorId, process) {
-    const commLog = path.join(this.outputDir, `${coordinatorId}-communication.log`);
-
-    // Capture stdout
-    process.stdout.on('data', async (data) => {
-      const message = {
-        timestamp: Date.now(),
-        agentId: coordinatorId,
-        type: 'STDOUT',
-        content: data.toString().trim()
-      };
-
-      await this.logInterAgentCommunication(message);
-    });
-
-    // Capture stderr
-    process.stderr.on('data', async (data) => {
-      const message = {
-        timestamp: Date.now(),
-        agentId: coordinatorId,
-        type: 'STDERR',
-        content: data.toString().trim()
-      };
-
-      await this.logInterAgentCommunication(message);
-    });
-
-    process.on('close', async (code) => {
-      const message = {
-        timestamp: Date.now(),
-        agentId: coordinatorId,
-        type: 'PROCESS_COMPLETE',
-        content: `Process completed with code: ${code}`
-      };
-
-      await this.logInterAgentCommunication(message);
-    });
-  }
-
-  async logInterAgentCommunication(message) {
-    // Central logging
-    const logEntry = {
-      timestamp: message.timestamp,
-      agentId: message.agentId,
-      type: message.type,
-      content: message.content
-    };
-
-    await fs.appendFile(this.communicationLog, JSON.stringify(logEntry) + '\n');
-
-    // Per-agent tracking
-    if (!this.agentCommunications.has(message.agentId)) {
-      this.agentCommunications.set(message.agentId, []);
-    }
-    this.agentCommunications.get(message.agentId).push(logEntry);
-
-    // Real-time display
-    console.log(`📨 [${message.agentId}] ${message.type}: ${message.content.substring(0, 100)}${message.content.length > 100 ? '...' : ''}`);
-  }
-
-  async monitorRealCoordination() {
-    console.log('📡 Step 2: Monitoring Real AI Coordination');
-    console.log('   AI agents are now coordinating autonomously...\n');
-
-    const monitoringDuration = 3 * 60 * 1000; // 3 minutes
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < monitoringDuration) {
-      await new Promise(resolve => setTimeout(resolve, 30000)); // Check every 30 seconds
-
-      // Check agent status
-      await this.checkAgentProgress();
-
-      // Monitor coordination files
-      await this.monitorCoordinationFiles();
-    }
-
-    console.log('\n⏰ Coordination monitoring period ended\n');
-  }
-
-  async checkAgentProgress() {
-    const activeCount = Array.from(this.coordinators.values())
-      .filter(c => c.status === 'active').length;
-
-    const totalMessages = Array.from(this.agentCommunications.values())
-      .reduce((sum, msgs) => sum + msgs.length, 0);
-
-    console.log(`   📊 Active coordinators: ${activeCount}/7 | Total messages: ${totalMessages}`);
-  }
-
-  async monitorCoordinationFiles() {
-    try {
-      const files = await fs.readdir(this.outputDir);
-      const statusFiles = files.filter(f => f.includes('-status.txt'));
-      const helloFiles = files.filter(f => f.startsWith('hello_world_'));
-
-      console.log(`   📁 Coordination files: ${statusFiles.length} status files, ${helloFiles.length} Hello World files`);
-
-      // Check for language assignments
-      const assignments = new Map();
-      for (const statusFile of statusFiles) {
-        try {
-          const content = await fs.readFile(path.join(this.outputDir, statusFile), 'utf8');
-          const match = content.match(/CHOSEN_LANGUAGE:\s*(\w+)/);
-          if (match) {
-            assignments.set(statusFile, match[1]);
-          }
-        } catch (error) {
-          // Ignore file read errors
-        }
-      }
-
-      if (assignments.size > 0) {
-        console.log(`   🎯 Current language assignments: ${Array.from(assignments.values()).join(', ')}`);
-      }
-
-    } catch (error) {
-      console.log('   ⚠️  Could not check coordination files');
-    }
-  }
-
-  async analyzeResults() {
-    console.log('📋 Step 3: Analyzing Real AI Coordination Results\n');
-
-    // Analyze generated files
-    const fileAnalysis = await this.analyzeGeneratedFiles();
-
-    // Analyze communication patterns
-    const commAnalysis = await this.analyzeCommunicationPatterns();
-
-    // Check for successful coordination
-    const coordinationSuccess = await this.evaluateCoordinationSuccess();
-
-    const results = {
-      timestamp: Date.now(),
-      testType: 'REAL_AI_COORDINATION',
-      results: {
-        fileAnalysis,
-        communicationAnalysis: commAnalysis,
-        coordinationSuccess
-      }
-    };
-
-    const resultsFile = path.join(this.outputDir, `real-ai-results-${Date.now()}.json`);
-    await fs.writeFile(resultsFile, JSON.stringify(results, null, 2));
-
-    console.log(`📁 Results saved to: ${resultsFile}`);
-    console.log('📊 All communications logged to: real-ai-communications.log');
-
-    this.displaySummary(results);
-
-    // Cleanup
-    await this.cleanup();
-  }
-
-  async analyzeGeneratedFiles() {
-    try {
-      const files = await fs.readdir(this.outputDir);
-      const helloFiles = files.filter(f => f.startsWith('hello_world_'));
-
-      const languageCombinations = new Map();
-      const programmingCounts = new Map();
-      const verbalCounts = new Map();
-
-      helloFiles.forEach(file => {
-        const parts = file.replace('hello_world_', '').replace(/\.[^/.]+$/, '').split('_');
-        if (parts.length >= 2) {
-          const verbal = parts[0];
-          const programming = parts[1];
-
-          languageCombinations.set(`${programming}+${verbal}`, file);
-          programmingCounts.set(programming, (programmingCounts.get(programming) || 0) + 1);
-          verbalCounts.set(verbal, (verbalCounts.get(verbal) || 0) + 1);
-        }
-      });
-
-      return {
-        totalHelloFiles: helloFiles.length,
-        languageCombinations: Array.from(languageCombinations.keys()),
-        programmingDistribution: Object.fromEntries(programmingCounts),
-        verbalDistribution: Object.fromEntries(verbalCounts),
-        fileList: helloFiles
-      };
-
-    } catch (error) {
-      return { totalHelloFiles: 0, languageCombinations: [], programmingDistribution: {}, verbalDistribution: {}, fileList: [] };
-    }
-  }
-
-  async analyzeCommunicationPatterns() {
-    const analysis = {
-      totalMessages: 0,
-      messagesByAgent: {},
-      messageTypes: {},
-      coordinationEvidence: {
-        languageChoice: false,
-        conflictDetection: false,
-        fileCreation: false,
-        completion: false
-      }
-    };
-
-    this.agentCommunications.forEach((messages, agentId) => {
-      analysis.messagesByAgent[agentId] = messages.length;
-      analysis.totalMessages += messages.length;
-
-      messages.forEach(msg => {
-        analysis.messageTypes[msg.type] = (analysis.messageTypes[msg.type] || 0) + 1;
-
-        const content = msg.content.toLowerCase();
-
-        if (content.includes('chosen language')) {
-          analysis.coordinationEvidence.languageChoice = true;
-        }
-        if (content.includes('conflict')) {
-          analysis.coordinationEvidence.conflictDetection = true;
-        }
-        if (content.includes('created:') || content.includes('created')) {
-          analysis.coordinationEvidence.fileCreation = true;
-        }
-        if (content.includes('completed')) {
-          analysis.coordinationEvidence.completion = true;
-        }
-      });
-    });
-
-    return analysis;
-  }
-
-  async evaluateCoordinationSuccess() {
-    try {
-      const files = await fs.readdir(this.outputDir);
-      const statusFiles = files.filter(f => f.includes('-status.txt'));
-      const helloFiles = files.filter(f => f.startsWith('hello_world_'));
-
-      // Check if all 7 coordinators made choices
-      const uniqueLanguages = new Set();
-      for (const statusFile of statusFiles) {
-        try {
-          const content = await fs.readFile(path.join(this.outputDir, statusFile), 'utf8');
-          const match = content.match(/CHOSEN_LANGUAGE:\s*(\w+)/);
-          if (match) {
-            uniqueLanguages.add(match[1]);
-          }
-        } catch (error) {
-          // Ignore
-        }
-      }
-
-      return {
-        allCoordinatorsActive: statusFiles.length === 7,
-        uniqueLanguagesChosen: uniqueLanguages.size === 7,
-        totalCombinations: helloFiles.length,
-        targetCombinations: 70,
-        successRate: (helloFiles.length / 70) * 100,
-        languagesChosen: Array.from(uniqueLanguages)
-      };
-
-    } catch (error) {
-      return {
-        allCoordinatorsActive: false,
-        uniqueLanguagesChosen: false,
-        totalCombinations: 0,
-        targetCombinations: 70,
-        successRate: 0,
-        languagesChosen: []
-      };
-    }
-  }
-
-  displaySummary(results) {
-    console.log('\n🎯 REAL AI COORDINATION SUMMARY:');
-    console.log('=====================================');
-
-    const { fileAnalysis, communicationAnalysis, coordinationSuccess } = results.results;
-
-    console.log(`📁 Generated Files: ${fileAnalysis.totalHelloFiles}/70 (${coordinationSuccess.successRate.toFixed(1)}%)`);
-    console.log(`🤖 Active Coordinators: ${coordinationSuccess.languagesChosen.length}/7`);
-    console.log(`💬 Total Communications: ${communicationAnalysis.totalMessages}`);
-
-    if (coordinationSuccess.languagesChosen.length > 0) {
-      console.log(`🎨 Languages Chosen: ${coordinationSuccess.languagesChosen.join(', ')}`);
-    }
-
-    console.log('\n📊 Communication Evidence:');
-    console.log(`   Language Choice: ${communicationAnalysis.coordinationEvidence.languageChoice ? '✅' : '❌'}`);
-    console.log(`   Conflict Detection: ${communicationAnalysis.coordinationEvidence.conflictDetection ? '✅' : '❌'}`);
-    console.log(`   File Creation: ${communicationAnalysis.coordinationEvidence.fileCreation ? '✅' : '❌'}`);
-    console.log(`   Task Completion: ${communicationAnalysis.coordinationEvidence.completion ? '✅' : '❌'}`);
-
-    if (coordinationSuccess.successRate === 100) {
-      console.log('\n🏆 PERFECT COORDINATION: All 70 combinations achieved!');
-    } else if (coordinationSuccess.successRate > 50) {
-      console.log(`\n✅ GOOD COORDINATION: ${coordinationSuccess.totalCombinations}/70 combinations achieved`);
-    } else {
-      console.log(`\n⚠️  PARTIAL COORDINATION: ${coordinationSuccess.totalCombinations}/70 combinations achieved`);
-    }
-  }
-
-  async cleanup() {
-    console.log('\n🧹 Cleaning up processes...');
-
-    this.agentProcesses.forEach((process, agentId) => {
-      try {
-        process.kill('SIGTERM');
-        console.log(`   ✅ Terminated ${agentId}`);
-      } catch (error) {
-        console.log(`   ⚠️  Could not terminate ${agentId}`);
-      }
-    });
-
-    console.log('✅ Cleanup complete\n');
-  }
-}
-
-// Run the real AI coordinator test
-const realAI = new RealAICoordinator();
-realAI.start().catch(console.error);