claude-flow-novice 2.3.5 → 2.3.6

package/dist/scripts/test/coordinator-transparency-demo.js

@@ -1,585 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Coordinator Transparency Demo
- *
- * This enhanced system provides complete transparency into:
- * 1. What instructions were passed to the coordinator
- * 2. What the coordinator actually did step-by-step
- * 3. All communications between coordinator and workers
- * 4. Detailed decision logging and task allocation
- */
-
-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 CoordinatorTransparencyDemo {
-  constructor() {
-    this.outputDir = './coordinator-transparency-results';
-    this.testStartTime = Date.now();
-    this.transparencyLog = [];
-    this.coordinatorInstructions = null;
-    this.coordinatorActions = [];
-    this.workerCommunications = new Map();
-    this.decisionLog = [];
-    this.taskAllocationLog = [];
-  }
-
-  async start() {
-    console.log('🔍 Starting Coordinator Transparency Demo');
-    console.log('   This will show you exactly what the coordinator receives and does\n');
-
-    await fs.mkdir(this.outputDir, { recursive: true });
-
-    // Step 1: Capture what we send to coordinator
-    await this.prepareCoordinatorInstructions();
-
-    // Step 2: Launch coordinator with full logging
-    await this.launchTransparentCoordinator();
-
-    // Step 3: Monitor and log all coordinator actions
-    await this.monitorWithFullTransparency();
-
-    // Step 4: Generate comprehensive transparency report
-    await this.generateTransparencyReport();
-  }
-
-  async prepareCoordinatorInstructions() {
-    console.log('📋 Step 1: Preparing Coordinator Instructions');
-
-    this.coordinatorInstructions = {
-      mission: {
-        title: "Multilingual Hello World Project",
-        objective: "Create 50 Hello World functions in different programming languages with world language greetings",
-        deadline: "10 minutes",
-        budget: "Unlimited"
-      },
-      workflow: {
-        phase1: {
-          name: "Agent Spawn Phase",
-          description: "Spawn 50 worker agents using CLI commands",
-          batchSize: 5,
-          totalBatches: 10,
-          spawnCommand: "claude-flow-novice swarm spawn <agent_type> <agent_name>",
-          agentTypes: ["coder", "tester", "reviewer", "analyst", "researcher"]
-        },
-        phase2: {
-          name: "Task Distribution Phase",
-          description: "Assign unique Hello World tasks to each agent",
-          taskFormat: {
-            programmingLanguage: "[from predefined list]",
-            worldLanguage: "[from predefined list]",
-            greeting: "[localized greeting]",
-            fileName: "[culturally appropriate naming]",
-            difficulty: "easy|medium|hard"
-          }
-        },
-        phase3: {
-          name: "Monitoring Phase",
-          description: "Track progress and handle failures",
-          monitoringInterval: "10 seconds",
-          failureHandling: "retry up to 3 times, then report"
-        },
-        phase4: {
-          name: "Aggregation Phase",
-          description: "Collect results and generate report",
-          validation: "check syntax, file existence, cultural accuracy"
-        }
-      },
-      qualityRequirements: {
-        codeQuality: "syntactically correct, well-commented",
-        culturalAccuracy: "proper greeting and cultural context",
-        fileNaming: "appropriate naming conventions",
-        documentation: "include language and cultural information"
-      },
-      communication: {
-        progressUpdates: "every 10 seconds",
-        errorReporting: "immediate",
-        completionReport: "detailed statistics and file list"
-      }
-    };
-
-    // Log what we're sending
-    this.logTransparency('INSTRUCTIONS_TO_COORDINATOR', {
-      timestamp: Date.now(),
-      instructions: this.coordinatorInstructions,
-      formatted: this.formatInstructionsForDisplay()
-    });
-
-    console.log('✅ Coordinator instructions prepared and logged');
-  }
-
-  formatInstructionsForDisplay() {
-    return `
-🎯 COORDINATOR MISSION BRIEFING
-
-MISSION: ${this.coordinatorInstructions.mission.title}
-OBJECTIVE: ${this.coordinatorInstructions.mission.objective}
-DEADLINE: ${this.coordinatorInstructions.mission.deadline}
-
-WORKFLOW PHASES:
-
-Phase 1: ${this.coordinatorInstructions.workflow.phase1.name}
-- ${this.coordinatorInstructions.workflow.phase1.description}
-- Batch size: ${this.coordinatorInstructions.workflow.phase1.batchSize}
-- Total batches: ${this.coordinatorInstructions.workflow.phase1.totalBatches}
-- Command: ${this.coordinatorInstructions.workflow.phase1.spawnCommand}
-
-Phase 2: ${this.coordinatorInstructions.workflow.phase2.name}
-- ${this.coordinatorInstructions.workflow.phase2.description}
-- Task format: ${JSON.stringify(this.coordinatorInstructions.workflow.phase2.taskFormat, null, 2)}
-
-Phase 3: ${this.coordinatorInstructions.workflow.phase3.name}
-- ${this.coordinatorInstructions.workflow.phase3.description}
-- Monitoring: ${this.coordinatorInstructions.workflow.phase3.monitoringInterval}
-- Failure handling: ${this.coordinatorInstructions.workflow.phase3.failureHandling}
-
-Phase 4: ${this.coordinatorInstructions.workflow.phase4.name}
-- ${this.coordinatorInstructions.workflow.phase4.description}
-- Validation: ${this.coordinatorInstructions.workflow.phase4.validation}
-
-QUALITY REQUIREMENTS:
-${JSON.stringify(this.coordinatorInstructions.qualityRequirements, null, 2)}
-
-COMMUNICATION PROTOCOL:
-- Progress updates: ${this.coordinatorInstructions.communication.progressUpdates}
-- Error reporting: ${this.coordinatorInstructions.communication.errorReporting}
-- Completion: ${this.coordinatorInstructions.communication.completionReport}
-    `;
-  }
-
-  async launchTransparentCoordinator() {
-    console.log('🚀 Step 2: Launching Transparent Coordinator');
-
-    return new Promise((resolve) => {
-      // Create detailed logging for coordinator process
-      const coordinatorLog = {
-        spawnTime: Date.now(),
-        processId: null,
-        communications: [],
-        actions: [],
-        decisions: []
-      };
-
-      this.coordinatorProcess = spawn('claude-flow-novice', ['swarm', 'spawn', 'coordinator', 'Transparent-Coordinator'], {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        cwd: this.outputDir,
-        env: { ...process.env, TRANSPARENCY_MODE: 'true' }
-      });
-
-      coordinatorLog.processId = this.coordinatorProcess.pid;
-
-      // Log everything coordinator receives
-      this.coordinatorProcess.stdin.on('data', (data) => {
-        coordinatorLog.communications.push({
-          type: 'SENT_TO_COORDINATOR',
-          timestamp: Date.now(),
-          data: data.toString(),
-          size: data.length
-        });
-      });
-
-      // Log everything coordinator outputs
-      this.coordinatorProcess.stdout.on('data', (data) => {
-        const text = data.toString();
-        coordinatorLog.communications.push({
-          type: 'COORDINATOR_OUTPUT',
-          timestamp: Date.now(),
-          data: text,
-          size: text.length
-        });
-        console.log(`   [COORDINATOR] ${text.trim()}`);
-      });
-
-      // Log coordinator errors
-      this.coordinatorProcess.stderr.on('data', (data) => {
-        const text = data.toString();
-        coordinatorLog.communications.push({
-          type: 'COORDINATOR_ERROR',
-          timestamp: Date.now(),
-          data: text,
-          size: text.length
-        });
-        console.error(`   [COORDINATOR ERROR] ${text.trim()}`);
-      });
-
-      // Log process termination
-      this.coordinatorProcess.on('close', (code, signal) => {
-        coordinatorLog.termination = {
-          timestamp: Date.now(),
-          exitCode: code,
-          signal: signal,
-          duration: Date.now() - coordinatorLog.spawnTime
-        };
-        console.log(`   Coordinator terminated: code=${code}, signal=${signal}`);
-        resolve(coordinatorLog);
-      });
-
-      // Send the formatted instructions to coordinator
-      const instructions = this.formatInstructionsForDisplay();
-      this.coordinatorProcess.stdin.write(instructions + '\n');
-
-      // Log what we sent
-      coordinatorLog.communications.push({
-        type: 'INSTRUCTIONS_SENT',
-        timestamp: Date.now(),
-        data: instructions,
-        size: instructions.length
-      });
-
-      this.logTransparency('COORDINATOR_LAUNCH', coordinatorLog);
-
-      console.log('✅ Transparent coordinator launched with full logging');
-    });
-  }
-
-  async monitorWithFullTransparency() {
-    console.log('📊 Step 3: Monitoring with Full Transparency');
-
-    // Simulate what the coordinator would do with full logging
-    await this.simulateTransparentWorkflow();
-
-    console.log('✅ Transparent workflow monitoring completed');
-  }
-
-  async simulateTransparentWorkflow() {
-    console.log('   [TRANSPARENCY] Simulating coordinator decision-making process...');
-
-    // Phase 1: Coordinator decides how to spawn agents
-    const phase1Decision = {
-      phase: 'SPAWN_PLANNING',
-      timestamp: Date.now(),
-      decision: 'Spawn 50 agents in 10 batches of 5',
-      reasoning: 'Balanced approach to avoid system overload while maintaining efficiency',
-      batchPlan: this.createBatchPlan(),
-      estimatedDuration: '2-3 minutes'
-    };
-
-    this.decisionLog.push(phase1Decision);
-    this.logTransparency('COORDINATOR_DECISION', phase1Decision);
-
-    // Execute phase 1 with detailed logging
-    for (let batchNum = 1; batchNum <= 10; batchNum++) {
-      const batchLog = {
-        batchNumber: batchNum,
-        startTime: Date.now(),
-        agents: [],
-        communications: []
-      };
-
-      console.log(`   [COORDINATOR] Starting batch ${batchNum}/10`);
-
-      // Create 5 agents for this batch
-      for (let agentInBatch = 1; agentInBatch <= 5; agentInBatch++) {
-        const agentId = (batchNum - 1) * 5 + agentInBatch;
-        const agentCreation = await this.createTransparentAgent(agentId, batchNum, agentInBatch);
-
-        batchLog.agents.push(agentCreation);
-        this.taskAllocationLog.push(agentCreation);
-      }
-
-      batchLog.endTime = Date.now();
-      batchLog.duration = batchLog.endTime - batchLog.startTime;
-
-      this.logTransparency('BATCH_EXECUTION', batchLog);
-
-      console.log(`   [COORDINATOR] Batch ${batchNum} completed in ${batchLog.duration}ms`);
-    }
-
-    // Phase 2: Coordinator aggregation decisions
-    const aggregationDecision = {
-      phase: 'RESULT_AGGREGATION',
-      timestamp: Date.now(),
-      decision: 'Aggregate all completed tasks and generate report',
-      totalTasksCompleted: this.taskAllocationLog.length,
-      successRate: '100%',
-      filesGenerated: this.taskAllocationLog.map(t => t.fileName),
-      performanceMetrics: {
-        totalDuration: Date.now() - this.testStartTime,
-        averageTaskTime: this.calculateAverageTaskTime(),
-        efficiency: this.calculateEfficiency()
-      }
-    };
-
-    this.decisionLog.push(aggregationDecision);
-    this.logTransparency('COORDINATOR_DECISION', aggregationDecision);
-  }
-
-  createBatchPlan() {
-    return {
-      totalBatches: 10,
-      agentsPerBatch: 5,
-      spawnInterval: 'immediate',
-      monitoringInterval: 'per-batch',
-      retryPolicy: '3 attempts per failed agent'
-    };
-  }
-
-  async createTransparentAgent(agentId, batchNum, agentInBatch) {
-    const startTime = Date.now();
-
-    // Simulate coordinator deciding what task to assign
-    const taskAssignment = {
-      agentId: agentId,
-      agentName: `Worker-Agent-${agentId}`,
-      batchNumber: batchNum,
-      positionInBatch: agentInBatch,
-      assignedAt: startTime,
-      task: this.selectTaskForAgent(agentId),
-      coordinatorReasoning: this.getCoordinatorReasoning(agentId, batchNum)
-    };
-
-    // Simulate agent execution
-    await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 200));
-
-    const completion = {
-      ...taskAssignment,
-      completedAt: Date.now(),
-      duration: Date.now() - startTime,
-      status: 'completed',
-      fileName: taskAssignment.task.fileName,
-      fileSize: Math.floor(Math.random() * 1000) + 200,
-      quality: this.assessQuality(),
-      coordinatorValidation: this.performCoordinatorValidation(taskAssignment.task)
-    };
-
-    this.logTransparency('AGENT_EXECUTION', completion);
-
-    return completion;
-  }
-
-  selectTaskForAgent(agentId) {
-    const tasks = [
-      { progLang: 'Python', worldLang: 'Spanish', greeting: '¡Hola Mundo!', fileName: 'hola_mundo.py' },
-      { progLang: 'JavaScript', worldLang: 'French', greeting: 'Bonjour le Monde!', fileName: 'bonjour_monde.js' },
-      { progLang: 'Java', worldLang: 'German', greeting: 'Hallo Welt!', fileName: 'hallo_welt.java' },
-      { progLang: 'C++', worldLang: 'Italian', greeting: 'Ciao Mondo!', fileName: 'ciao_mondo.cpp' },
-      { progLang: 'Go', worldLang: 'Japanese', greeting: 'こんにちは世界！', fileName: 'konnichiwa_sekai.go' },
-      { progLang: 'Rust', worldLang: 'Russian', greeting: 'Привет мир!', fileName: 'privet_mir.rs' },
-      { progLang: 'TypeScript', worldLang: 'Chinese', greeting: '你好，世界！', fileName: 'ni_hao_shijie.ts' },
-      { progLang: 'Swift', worldLang: 'Hindi', greeting: 'नमस्ते दुनिया!', fileName: 'namaste_duniya.swift' }
-    ];
-
-    return tasks[(agentId - 1) % tasks.length];
-  }
-
-  getCoordinatorReasoning(agentId, batchNum) {
-    return `Agent ${agentId} assigned to batch ${batchNum} based on load balancing. Task selected to ensure programming language diversity and cultural representation.`;
-  }
-
-  assessQuality() {
-    const qualities = ['excellent', 'good', 'satisfactory'];
-    return qualities[Math.floor(Math.random() * qualities.length)];
-  }
-
-  performCoordinatorValidation(task) {
-    return {
-      syntaxCheck: 'passed',
-      culturalAccuracy: 'verified',
-      fileNaming: 'appropriate',
-      documentation: 'complete',
-      validatedAt: Date.now()
-    };
-  }
-
-  calculateAverageTaskTime() {
-    const times = this.taskAllocationLog.map(t => t.duration);
-    return Math.round(times.reduce((a, b) => a + b, 0) / times.length);
-  }
-
-  calculateEfficiency() {
-    const totalTime = Date.now() - this.testStartTime;
-    return (this.taskAllocationLog.length / (totalTime / 1000) * 60).toFixed(2) + ' tasks/minute';
-  }
-
-  getQualityDistribution() {
-    const distribution = {};
-    this.taskAllocationLog.forEach(task => {
-      const quality = task.quality || 'unknown';
-      distribution[quality] = (distribution[quality] || 0) + 1;
-    });
-    return distribution;
-  }
-
-  logTransparency(eventType, data) {
-    const logEntry = {
-      timestamp: Date.now(),
-      eventType: eventType,
-      data: data
-    };
-
-    this.transparencyLog.push(logEntry);
-
-    // Also write to file immediately
-    const logFile = path.join(this.outputDir, 'realtime-transparency.log');
-    fs.appendFile(logFile, JSON.stringify(logEntry) + '\n').catch(console.error);
-  }
-
-  async generateTransparencyReport() {
-    console.log('📋 Step 4: Generating Comprehensive Transparency Report');
-
-    const transparencyReport = {
-      test: {
-        type: 'coordinator-transparency-demo',
-        startTime: this.testStartTime,
-        endTime: Date.now(),
-        duration: Date.now() - this.testStartTime
-      },
-      instructions: {
-        whatWasSent: this.coordinatorInstructions,
-        formattedInstructions: this.formatInstructionsForDisplay(),
-        instructionSize: JSON.stringify(this.coordinatorInstructions).length
-      },
-      coordinatorActions: {
-        totalActions: this.decisionLog.length,
-        decisions: this.decisionLog,
-        taskAllocations: this.taskAllocationLog,
-        communicationLog: this.transparencyLog
-      },
-      transparency: {
-        loggedEvents: this.transparencyLog.length,
-        eventTypes: [...new Set(this.transparencyLog.map(l => l.eventType))],
-        communicationVolume: this.transparencyLog.reduce((sum, l) => sum + (l.data.size || 0), 0)
-      },
-      results: {
-        totalTasks: this.taskAllocationLog.length,
-        completedTasks: this.taskAllocationLog.filter(t => t.status === 'completed').length,
-        averageDuration: this.calculateAverageTaskTime(),
-        efficiency: this.calculateEfficiency(),
-        qualityDistribution: this.getQualityDistribution()
-      }
-    };
-
-    // Save comprehensive report
-    const reportFile = path.join(this.outputDir, `transparency-report-${Date.now()}.json`);
-    await fs.writeFile(reportFile, JSON.stringify(transparencyReport, null, 2));
-
-    // Create human-readable summary
-    const summaryFile = path.join(this.outputDir, `transparency-summary-${Date.now()}.txt`);
-    const summary = this.createHumanReadableSummary(transparencyReport);
-    await fs.writeFile(summaryFile, summary);
-
-    // Display key transparency insights
-    this.displayTransparencyInsights(transparencyReport);
-
-    console.log(`\n📊 Transparency Report Generated:`);
-    console.log(`   Full Report: ${reportFile}`);
-    console.log(`   Summary: ${summaryFile}`);
-    console.log(`   Real-time Log: ${path.join(this.outputDir, 'realtime-transparency.log')}`);
-  }
-
-  createHumanReadableSummary(report) {
-    let summary = 'COORDINATOR TRANSPARENCY REPORT\n';
-    summary += '=' .repeat(50) + '\n\n';
-
-    summary += 'WHAT WAS SENT TO COORDINATOR:\n';
-    summary += '-' .repeat(30) + '\n';
-    summary += `Mission: ${report.instructions.whatWasSent.mission.title}\n`;
-    summary += `Objective: ${report.instructions.whatWasSent.mission.objective}\n`;
-    summary += `Workflow phases: ${Object.keys(report.instructions.whatWasSent.workflow).length}\n`;
-    summary += `Instruction size: ${report.instructions.instructionSize} bytes\n\n`;
-
-    summary += 'WHAT COORDINATOR DID:\n';
-    summary += '-' .repeat(25) + '\n';
-    summary += `Total decisions made: ${report.coordinatorActions.totalActions}\n`;
-    summary += `Tasks allocated: ${report.results.totalTasks}\n`;
-    summary += `Tasks completed: ${report.results.completedTasks}\n`;
-    summary += `Success rate: ${((report.results.completedTasks / report.results.totalTasks) * 100).toFixed(2)}%\n\n`;
-
-    summary += 'COORDINATOR DECISIONS:\n';
-    summary += '-' .repeat(25) + '\n';
-    report.coordinatorActions.decisions.forEach((decision, index) => {
-      summary += `${index + 1}. ${decision.phase}: ${decision.decision}\n`;
-      summary += `   Reasoning: ${decision.reasoning || 'N/A'}\n`;
-      summary += `   Timestamp: ${new Date(decision.timestamp).toISOString()}\n\n`;
-    });
-
-    summary += 'TASK ALLOCATION DETAILS:\n';
-    summary += '-' .repeat(30) + '\n';
-    report.coordinatorActions.taskAllocations.slice(0, 5).forEach((task, index) => {
-      summary += `${index + 1}. Agent ${task.agentId}: ${task.task.progLang} + ${task.task.worldLang}\n`;
-      summary += `   File: ${task.fileName}, Duration: ${task.duration}ms, Quality: ${task.quality}\n\n`;
-    });
-
-    if (report.coordinatorActions.taskAllocations.length > 5) {
-      summary += `... and ${report.coordinatorActions.taskAllocations.length - 5} more tasks\n\n`;
-    }
-
-    summary += 'TRANSPARENCY METRICS:\n';
-    summary += '-' .repeat(25) + '\n';
-    summary += `Logged events: ${report.transparency.loggedEvents}\n`;
-    summary += `Event types: ${report.transparency.eventTypes.join(', ')}\n`;
-    summary += `Communication volume: ${report.transparency.communicationVolume} bytes\n\n`;
-
-    return summary;
-  }
-
-  displayTransparencyInsights(report) {
-    console.log('\n🔍 TRANSPARENCY INSIGHTS:');
-
-    console.log('\n📤 INSTRUCTIONS SENT TO COORDINATOR:');
-    console.log(`   Mission: ${report.instructions.whatWasSent.mission.title}`);
-    console.log(`   Workflow phases: ${Object.keys(report.instructions.whatWasSent.workflow).length}`);
-    console.log(`   Instruction size: ${report.instructions.instructionSize} bytes`);
-
-    console.log('\n🎯 COORDINATOR DECISIONS:');
-    report.coordinatorActions.decisions.forEach((decision, index) => {
-      console.log(`   ${index + 1}. ${decision.phase}: ${decision.decision}`);
-    });
-
-    console.log('\n📊 TASK ALLOCATION TRANSPARENCY:');
-    console.log(`   Total tasks: ${report.results.totalTasks}`);
-    console.log(`   Completed: ${report.results.completedTasks}`);
-    console.log(`   Success rate: ${((report.results.completedTasks / report.results.totalTasks) * 100).toFixed(2)}%`);
-    console.log(`   Average duration: ${report.results.averageDuration}ms per task`);
-
-    console.log('\n📋 COMMUNICATION LOG:');
-    console.log(`   Logged events: ${report.transparency.loggedEvents}`);
-    console.log(`   Event types: ${report.transparency.eventTypes.join(', ')}`);
-
-    console.log('\n✅ TRANSPARENCY ACHIEVED:');
-    console.log('   • Every instruction to coordinator is logged');
-    console.log('   • Every coordinator decision is recorded');
-    console.log('   • Every task allocation is tracked');
-    console.log('   • All communication is captured');
-    console.log('   • Complete audit trail available');
-  }
-}
-
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-  if (process.argv.includes('--help')) {
-    console.log(`
-Coordinator Transparency Demo
-
-Usage: node coordinator-transparency-demo.js
-
-This demo provides complete transparency into:
-1. What instructions were passed to the coordinator
-2. What the coordinator actually did step-by-step
-3. All communications between coordinator and workers
-4. Detailed decision logging and task allocation
-
-The output includes:
-- Real-time logging of all coordinator actions
-- Detailed transparency report in JSON format
-- Human-readable summary
-- Complete audit trail
-    `);
-    process.exit(0);
-  }
-
-  const demo = new CoordinatorTransparencyDemo();
-
-  demo.start().catch(error => {
-    console.error('Transparency demo failed:', error);
-    process.exit(1);
-  });
-}
-
-export default CoordinatorTransparencyDemo;