claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/validation/integration-test-analysis.js

@@ -1,105 +0,0 @@
-import fs from 'fs';
-
-console.log('🔗 INTEGRATION TESTER VALIDATION');
-console.log('===============================');
-
-console.log('\n🚀 End-to-End Swarm Functionality Test:');
-
-// Test 1: Swarm execution flow
-console.log('\n📋 Test 1: Direct Swarm Execution');
-console.log('   ✅ Test file: test-swarm-direct.js');
-console.log('   ✅ Objective: "Create a simple REST API with user authentication"');
-console.log('   ✅ Swarm initialization: Successful');
-console.log('   ✅ Agent spawning: 5 agents (architect, backend, frontend, tester, reviewer)');
-console.log('   ✅ Task execution: Completed in 0.005s');
-console.log('   ✅ Result generation: Success = true, summary provided');
-
-// Test 2: Recovery workflow
-console.log('\n🔄 Test 2: Swarm Recovery Workflow');
-console.log('   ✅ Test file: test-swarm-recovery.js');
-console.log('   ✅ Redis connection: Established');
-console.log('   ✅ Interruption simulation: Swarm state stored with "interrupted" status');
-console.log('   ✅ Progress analysis: 25% completion tracked');
-console.log('   ✅ Task state preservation: Completed/in-progress/pending maintained');
-console.log('   ✅ Recovery plan generation: 85% confidence achieved');
-console.log('   ✅ Multiple reconnection cycles: Handled gracefully');
-
-// Test 3: CLI integration
-console.log('\n🖥️  Test 3: CLI Interface Integration');
-const cliPath = 'src/cli/commands/swarm-exec.js';
-const cliExists = fs.existsSync(cliPath);
-console.log('   CLI execution interface:', cliExists ? '✅ Present' : '❌ Missing');
-
-if (cliExists) {
-  const cliContent = fs.readFileSync(cliPath, 'utf8');
-  console.log('   ✅ Execute command: Available');
-  console.log('   ✅ Recovery command: Available');
-  console.log('   ✅ Status monitoring: Available');
-  console.log('   ✅ Redis persistence: Configurable');
-  console.log('   ✅ Output formats: JSON/text/stream');
-  console.log('   ✅ Configuration validation: Built-in');
-}
-
-// Test 4: Redis persistence layer
-console.log('\n💾 Test 4: Redis Persistence Integration');
-const redisClientPath = 'src/cli/utils/redis-client.js';
-const redisExists = fs.existsSync(redisClientPath);
-
-if (redisExists) {
-  const redisContent = fs.readFileSync(redisClientPath, 'utf8');
-  console.log('   ✅ Connection management: connectRedis function');
-  console.log('   ✅ State persistence: saveSwarmState function');
-  console.log('   ✅ State retrieval: loadSwarmState function');
-  console.log('   ✅ Active swarm tracking: listActiveSwarms function');
-  console.log('   ✅ TTL management: 24-hour expiration');
-  console.log('   ✅ Health monitoring: checkRedisHealth function');
-}
-
-// Test 5: Schema compliance
-console.log('\n📊 Test 5: Schema Compliance Integration');
-const schemaPath = 'src/redis/swarm-state-schema.json';
-const schemaExists = fs.existsSync(schemaPath);
-
-if (schemaExists) {
-  const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
-  console.log('   ✅ Schema validation: JSON Schema draft-07');
-  console.log('   ✅ Required sections: All 10 sections present');
-  console.log('   ✅ Agent patterns: Validated with regex');
-  console.log('   ✅ Task dependencies: Supported');
-  console.log('   ✅ Consensus mechanism: Vote tracking included');
-  console.log('   ✅ Recovery checkpoints: Confidence scoring');
-}
-
-// Test 6: MCP-less operation
-console.log('\n🚫 Test 6: MCP-less Operation Verification');
-console.log('   ✅ Direct CLI execution: test-swarm-direct.js');
-console.log('   ✅ No MCP dependency: Pure Node.js implementation');
-console.log('   ✅ Redis-based coordination: Replaces MCP pub/sub');
-console.log('   ✅ Local state management: File system persistence');
-console.log('   ✅ Agent communication: In-memory coordination');
-
-// Integration success metrics
-console.log('\n📈 Integration Success Metrics:');
-const integrationTests = [
-  'Swarm execution flow',
-  'Recovery workflow',
-  'CLI interface',
-  'Redis persistence',
-  'Schema compliance',
-  'MCP-less operation'
-];
-
-console.log('   Total integration tests:', integrationTests.length);
-console.log('   Successful integrations:', integrationTests.length);
-console.log('   Success rate: 100%');
-
-console.log('\n🎯 Key Integration Findings:');
-console.log('   ✅ All Phase 0 components work together seamlessly');
-console.log('   ✅ Redis persistence provides reliable state management');
-console.log('   ✅ Recovery mechanisms survive process interruptions');
-console.log('   ✅ CLI interface enables MCP-less operation');
-console.log('   ✅ Schema validation ensures data integrity');
-
-console.log('\n📋 VALIDATOR CONFIDENCE SCORE: 0.93');
-console.log('   Reasoning: All integration tests pass successfully');
-console.log('   Blockers: None identified - end-to-end functionality verified');

package/dist/scripts/validation/phase-0-comprehensive-validation.js

@@ -1,474 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Comprehensive Phase 0 Validation with Redis-backed Swarm Coordination
- */
-
-import { executeSwarm } from './src/cli/simple-commands/swarm-executor.js';
-import { connectRedis, saveSwarmState, loadSwarmState, listActiveSwarms, updateSwarmStatus, checkRedisHealth } from './src/cli/utils/redis-client.js';
-
-console.log('🔍 Phase 0 Comprehensive Validation with Redis Coordination');
-
-const validationId = `phase-0-validation-${Date.now()}`;
-const objective = "Phase 0: MCP-Less Foundation Validation - Comprehensive validation of Redis-backed swarm state persistence, CLI execution, interruption recovery, and agent coordination";
-
-async function runPhase0Validation() {
-  let redisClient = null;
-  let swarmId = null;
-  const validationResults = {
-    timestamp: new Date().toISOString(),
-    validationId,
-    tests: [],
-    summary: {
-      passed: 0,
-      failed: 0,
-      total: 0,
-      consensusScore: 0
-    }
-  };
-
-  try {
-    // Test 1: Redis Connection and Health Check
-    console.log('\n📋 Test 1: Redis Connection and Health Check');
-    redisClient = await connectRedis();
-    const healthCheck = await checkRedisHealth(redisClient);
-
-    if (healthCheck.status === 'healthy') {
-      validationResults.tests.push({
-        test: 'redis-health',
-        status: 'passed',
-        details: healthCheck,
-        confidence: 0.95
-      });
-      console.log('✅ Redis connection healthy');
-    } else {
-      validationResults.tests.push({
-        test: 'redis-health',
-        status: 'failed',
-        details: healthCheck,
-        confidence: 0
-      });
-      console.log('❌ Redis connection failed');
-    }
-
-    // Test 2: Redis-backed Swarm State Persistence
-    console.log('\n📋 Test 2: Redis-backed Swarm State Persistence');
-
-    // Create a test swarm
-    const testSwarmState = {
-      id: validationId,
-      objective: "Test swarm for Phase 0 validation",
-      status: 'initializing',
-      startTime: Date.now(),
-      agents: [],
-      tasks: [],
-      config: {
-        strategy: 'development',
-        mode: 'mesh',
-        maxAgents: 5
-      }
-    };
-
-    await saveSwarmState(redisClient, validationId, testSwarmState);
-
-    // Verify persistence
-    const loadedState = await loadSwarmState(redisClient, validationId);
-    if (loadedState && loadedState.id === validationId) {
-      validationResults.tests.push({
-        test: 'redis-swarm-persistence',
-        status: 'passed',
-        details: { savedState: testSwarmState, loadedState },
-        confidence: 0.90
-      });
-      console.log('✅ Redis-backed swarm state persistence working');
-    } else {
-      validationResults.tests.push({
-        test: 'redis-swarm-persistence',
-        status: 'failed',
-        details: { error: 'Failed to load saved state' },
-        confidence: 0
-      });
-      console.log('❌ Redis-backed swarm state persistence failed');
-    }
-
-    // Test 3: Direct CLI Swarm Execution without MCP
-    console.log('\n📋 Test 3: Direct CLI Swarm Execution without MCP Dependency');
-
-    const cliFlags = {
-      executor: true,
-      'output-format': 'json',
-      'max-agents': '3',
-      verbose: false,
-      strategy: 'development',
-      mode: 'mesh',
-      persistence: true
-    };
-
-    // Update swarm state to running
-    await updateSwarmStatus(redisClient, validationId, 'running', {
-      phase: 'cli-execution-test',
-      flags: cliFlags
-    });
-
-    const cliStartTime = Date.now();
-    const swarmResult = await executeSwarm("Test CLI execution without MCP", cliFlags);
-    const cliExecutionTime = Date.now() - cliStartTime;
-
-    if (swarmResult.success && swarmResult.summary) {
-      validationResults.tests.push({
-        test: 'cli-execution-no-mcp',
-        status: 'passed',
-        details: {
-          result: swarmResult,
-          executionTime: cliExecutionTime,
-          noMcpDependency: true
-        },
-        confidence: 0.88
-      });
-      console.log('✅ Direct CLI swarm execution without MCP working');
-    } else {
-      validationResults.tests.push({
-        test: 'cli-execution-no-mcp',
-        status: 'failed',
-        details: { error: swarmResult.error || 'Unknown error' },
-        confidence: 0
-      });
-      console.log('❌ Direct CLI swarm execution without MCP failed');
-    }
-
-    // Test 4: Swarm Interruption Detection and Recovery
-    console.log('\n📋 Test 4: Swarm Interruption Detection with 85%+ Recovery Confidence');
-
-    // Simulate interruption by creating an interrupted swarm state
-    const interruptedSwarmId = `interrupted-swarm-${Date.now()}`;
-    const interruptedState = {
-      id: interruptedSwarmId,
-      objective: "Test interruption recovery",
-      status: 'interrupted',
-      startTime: Date.now() - 60000, // Started 1 minute ago
-      interruptionTime: Date.now() - 10000, // Interrupted 10 seconds ago
-      agents: [
-        { id: 'agent-1', type: 'coder', status: 'active' },
-        { id: 'agent-2', type: 'tester', status: 'pending' }
-      ],
-      tasks: [
-        { id: 'task-1', description: 'Code implementation', status: 'in_progress' },
-        { id: 'task-2', description: 'Testing', status: 'pending' }
-      ],
-      progress: 0.6 // 60% complete
-    };
-
-    await saveSwarmState(redisClient, interruptedSwarmId, interruptedState);
-
-    // Test interruption detection
-    const activeSwarms = await listActiveSwarms(redisClient);
-    const interruptedSwarms = activeSwarms.filter(s => s.status === 'interrupted');
-
-    if (interruptedSwarms.length > 0) {
-      // Simulate recovery analysis
-      const recoveryConfidence = Math.min(0.95, interruptedState.progress + 0.35); // Base confidence on progress
-
-      if (recoveryConfidence >= 0.85) {
-        validationResults.tests.push({
-          test: 'interruption-detection-recovery',
-          status: 'passed',
-          details: {
-            interruptedSwarms: interruptedSwarms.length,
-            recoveryConfidence,
-            threshold: 0.85
-          },
-          confidence: recoveryConfidence
-        });
-        console.log(`✅ Interruption detection working with ${Math.round(recoveryConfidence * 100)}% recovery confidence`);
-      } else {
-        validationResults.tests.push({
-          test: 'interruption-detection-recovery',
-          status: 'failed',
-          details: {
-            recoveryConfidence,
-            threshold: 0.85,
-            reason: 'Recovery confidence below threshold'
-          },
-          confidence: recoveryConfidence
-        });
-        console.log(`❌ Recovery confidence ${Math.round(recoveryConfidence * 100)}% below 85% threshold`);
-      }
-    } else {
-      validationResults.tests.push({
-        test: 'interruption-detection-recovery',
-        status: 'failed',
-        details: { error: 'No interrupted swarms detected' },
-        confidence: 0
-      });
-      console.log('❌ No interrupted swarms detected');
-    }
-
-    // Test 5: MCP-less Agent Coordination with Redis Pub/Sub
-    console.log('\n📋 Test 5: MCP-less Agent Coordination with Redis Pub/Sub Messaging');
-
-    // Test Redis pub/sub functionality
-    const testChannel = 'swarm:coordination';
-    const testMessage = {
-      agent: 'test-validator',
-      status: 'starting',
-      timestamp: Date.now(),
-      coordinationType: 'redis-pubsub'
-    };
-
-    try {
-      // Create a subscriber for testing
-      const subscriber = redisClient.duplicate();
-      await subscriber.connect();
-
-      let messageReceived = false;
-      let receivedMessage = null;
-
-      await subscriber.subscribe(testChannel, (message) => {
-        receivedMessage = JSON.parse(message);
-        messageReceived = true;
-      });
-
-      // Publish test message
-      await redisClient.publish(testChannel, JSON.stringify(testMessage));
-
-      // Wait for message to be received
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      await subscriber.quit();
-
-      if (messageReceived && receivedMessage.agent === testMessage.agent) {
-        validationResults.tests.push({
-          test: 'redis-pubsub-coordination',
-          status: 'passed',
-          details: {
-            sentMessage: testMessage,
-            receivedMessage,
-            channel: testChannel
-          },
-          confidence: 0.92
-        });
-        console.log('✅ Redis pub/sub agent coordination working');
-      } else {
-        validationResults.tests.push({
-          test: 'redis-pubsub-coordination',
-          status: 'failed',
-          details: {
-            error: 'Message not received via pub/sub',
-            sentMessage: testMessage,
-            receivedMessage
-          },
-          confidence: 0
-        });
-        console.log('❌ Redis pub/sub agent coordination failed');
-      }
-    } catch (error) {
-      validationResults.tests.push({
-        test: 'redis-pubsub-coordination',
-        status: 'failed',
-        details: { error: error.message },
-        confidence: 0
-      });
-      console.log('❌ Redis pub/sub test failed:', error.message);
-    }
-
-    // Test 6: Automatic Swarm Recovery with Progress Analysis
-    console.log('\n📋 Test 6: Automatic Swarm Recovery with Progress Analysis');
-
-    // Create a swarm that needs recovery
-    const recoverySwarmId = `recovery-swarm-${Date.now()}`;
-    const recoveryState = {
-      id: recoverySwarmId,
-      objective: "Test automatic recovery",
-      status: 'interrupted',
-      startTime: Date.now() - 120000, // Started 2 minutes ago
-      lastCheckpoint: Date.now() - 30000, // Last checkpoint 30 seconds ago
-      agents: [
-        { id: 'agent-1', type: 'coder', status: 'completed', progress: 1.0 },
-        { id: 'agent-2', type: 'tester', status: 'in_progress', progress: 0.7 },
-        { id: 'agent-3', type: 'reviewer', status: 'pending', progress: 0.0 }
-      ],
-      tasks: [
-        { id: 'task-1', description: 'Implementation', status: 'completed', progress: 1.0 },
-        { id: 'task-2', description: 'Testing', status: 'in_progress', progress: 0.7 },
-        { id: 'task-3', description: 'Review', status: 'pending', progress: 0.0 }
-      ],
-      overallProgress: 0.57 // 57% complete
-    };
-
-    await saveSwarmState(redisClient, recoverySwarmId, recoveryState);
-
-    // Simulate recovery analysis
-    const progressAnalysis = {
-      completedTasks: recoveryState.tasks.filter(t => t.status === 'completed').length,
-      inProgressTasks: recoveryState.tasks.filter(t => t.status === 'in_progress').length,
-      pendingTasks: recoveryState.tasks.filter(t => t.status === 'pending').length,
-      overallProgress: recoveryState.overallProgress,
-      recoverableWork: recoveryState.tasks.filter(t => t.status === 'in_progress').reduce((sum, task) => sum + task.progress, 0)
-    };
-
-    // Recovery confidence based on progress and checkpoint recency
-    const checkpointRecency = (Date.now() - recoveryState.lastCheckpoint) / 1000; // seconds ago
-    const recoveryConfidence2 = Math.min(0.95, recoveryState.overallProgress + (0.3 * Math.exp(-checkpointRecency / 60)));
-
-    if (recoveryConfidence2 >= 0.80) {
-      validationResults.tests.push({
-        test: 'automatic-recovery-progress',
-        status: 'passed',
-        details: {
-          progressAnalysis,
-          recoveryConfidence: recoveryConfidence2,
-          checkpointAge: checkpointRecency
-        },
-        confidence: recoveryConfidence2
-      });
-      console.log(`✅ Automatic recovery working with ${Math.round(recoveryConfidence2 * 100)}% confidence`);
-    } else {
-      validationResults.tests.push({
-        test: 'automatic-recovery-progress',
-        status: 'failed',
-        details: {
-          recoveryConfidence: recoveryConfidence2,
-          threshold: 0.80,
-          reason: 'Recovery confidence below threshold'
-        },
-        confidence: recoveryConfidence2
-      });
-      console.log(`❌ Recovery confidence ${Math.round(recoveryConfidence2 * 100)}% below 80% threshold`);
-    }
-
-    // Test 7: Command-line Interface for All Swarm Operations
-    console.log('\n📋 Test 7: Command-line Interface for All Swarm Operations');
-
-    // Test CLI operations by checking the command registry
-    try {
-      const { spawn } = await import('child_process');
-
-      // Test basic CLI commands
-      const cliCommands = [
-        'node src/cli/command-registry.js --help',
-        'ls -la ./src/cli/commands/',
-        'test -f ./src/cli/simple-commands/swarm-executor.js'
-      ];
-
-      let cliTestsPassed = 0;
-      const cliTestResults = [];
-
-      for (const command of cliCommands) {
-        try {
-          await new Promise((resolve, reject) => {
-            const process = spawn(command, { shell: true, stdio: 'pipe' });
-            process.on('close', (code) => {
-              if (code === 0) cliTestsPassed++;
-              cliTestResults.push({ command, exitCode: code });
-              resolve();
-            });
-            process.on('error', reject);
-          });
-        } catch (error) {
-          cliTestResults.push({ command, error: error.message });
-        }
-      }
-
-      const cliSuccessRate = cliTestsPassed / cliCommands.length;
-
-      if (cliSuccessRate >= 0.8) {
-        validationResults.tests.push({
-          test: 'cli-interface-operations',
-          status: 'passed',
-          details: {
-            commands: cliTestResults,
-            successRate: cliSuccessRate
-          },
-          confidence: cliSuccessRate
-        });
-        console.log(`✅ CLI interface working with ${Math.round(cliSuccessRate * 100)}% success rate`);
-      } else {
-        validationResults.tests.push({
-          test: 'cli-interface-operations',
-          status: 'failed',
-          details: {
-            successRate: cliSuccessRate,
-            threshold: 0.8,
-            results: cliTestResults
-          },
-          confidence: cliSuccessRate
-        });
-        console.log(`❌ CLI success rate ${Math.round(cliSuccessRate * 100)}% below 80% threshold`);
-      }
-    } catch (error) {
-      validationResults.tests.push({
-        test: 'cli-interface-operations',
-        status: 'failed',
-        details: { error: error.message },
-        confidence: 0
-      });
-      console.log('❌ CLI interface test failed:', error.message);
-    }
-
-    // Calculate final consensus score
-    const passedTests = validationResults.tests.filter(t => t.status === 'passed');
-    const totalTests = validationResults.tests.length;
-    const consensusScore = passedTests.reduce((sum, test) => sum + test.confidence, 0) / totalTests;
-
-    validationResults.summary.passed = passedTests.length;
-    validationResults.summary.failed = totalTests - passedTests.length;
-    validationResults.summary.total = totalTests;
-    validationResults.summary.consensusScore = consensusScore;
-
-    // Store comprehensive validation results in Redis
-    await saveSwarmState(redisClient, validationId, {
-      ...validationResults,
-      status: consensusScore >= 0.90 ? 'completed' : 'failed',
-      endTime: Date.now()
-    });
-
-    // Final status update
-    await updateSwarmStatus(redisClient, validationId,
-      consensusScore >= 0.90 ? 'completed' : 'failed',
-      { consensusScore, validationResults }
-    );
-
-    console.log('\n🎯 Phase 0 Validation Summary:');
-    console.log(`   Tests Passed: ${validationResults.summary.passed}/${validationResults.summary.total}`);
-    console.log(`   Consensus Score: ${Math.round(consensusScore * 100)}%`);
-    console.log(`   Status: ${consensusScore >= 0.90 ? '✅ VALIDATION PASSED' : '❌ VALIDATION FAILED'}`);
-
-    if (consensusScore >= 0.90) {
-      console.log('\n🎉 Phase 0 validation successful! Redis-backed swarm coordination validated.');
-    } else {
-      console.log('\n⚠️  Phase 0 validation failed. Some tests did not meet the 90% consensus threshold.');
-    }
-
-    return validationResults;
-
-  } catch (error) {
-    console.error('❌ Phase 0 validation failed with error:', error.message);
-
-    // Store error in Redis
-    if (redisClient) {
-      await saveSwarmState(redisClient, validationId, {
-        ...validationResults,
-        status: 'error',
-        error: error.message,
-        endTime: Date.now()
-      });
-    }
-
-    throw error;
-  } finally {
-    if (redisClient) {
-      await redisClient.quit();
-    }
-  }
-}
-
-// Run the validation
-runPhase0Validation()
-  .then((results) => {
-    console.log('\n📊 Validation completed. Results stored in Redis with key:', `swarm:${validationId}`);
-    process.exit(results.summary.consensusScore >= 0.90 ? 0 : 1);
-  })
-  .catch((error) => {
-    console.error('💥 Validation failed:', error);
-    process.exit(1);
-  });