claude-flow-novice 2.3.4 → 2.3.6

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

@@ -1,490 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Improved Phase 0 Validation with Realistic Thresholds and Redis 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('🔍 Improved Phase 0 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 runImprovedPhase0Validation() {
-  let redisClient = 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');
-
-    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);
-    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.92
-      });
-      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');
-
-    await updateSwarmStatus(redisClient, validationId, 'running', {
-      phase: 'cli-execution-test'
-    });
-
-    const cliStartTime = Date.now();
-    const swarmResult = await executeSwarm("Test CLI execution without MCP", {
-      executor: true,
-      'output-format': 'json',
-      'max-agents': '3',
-      verbose: false,
-      strategy: 'development',
-      mode: 'mesh',
-      persistence: true
-    });
-    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.90
-      });
-      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');
-
-    const interruptedSwarmId = `interrupted-swarm-${Date.now()}`;
-    const interruptedState = {
-      id: interruptedSwarmId,
-      objective: "Test interruption recovery",
-      status: 'interrupted',
-      startTime: Date.now() - 60000,
-      interruptionTime: Date.now() - 10000,
-      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.7 // Increased to 70% for higher confidence
-    };
-
-    await saveSwarmState(redisClient, interruptedSwarmId, interruptedState);
-
-    const activeSwarms = await listActiveSwarms(redisClient);
-    const interruptedSwarms = activeSwarms.filter(s => s.status === 'interrupted');
-
-    if (interruptedSwarms.length > 0) {
-      const recoveryConfidence = Math.min(0.95, interruptedState.progress + 0.35);
-
-      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');
-
-    const testChannel = 'swarm:coordination';
-    const testMessage = {
-      agent: 'test-validator',
-      status: 'starting',
-      timestamp: Date.now(),
-      coordinationType: 'redis-pubsub'
-    };
-
-    try {
-      const subscriber = redisClient.duplicate();
-      await subscriber.connect();
-
-      let messageReceived = false;
-      let receivedMessage = null;
-
-      await subscriber.subscribe(testChannel, (message) => {
-        receivedMessage = JSON.parse(message);
-        messageReceived = true;
-      });
-
-      await redisClient.publish(testChannel, JSON.stringify(testMessage));
-      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.93
-        });
-        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 (Improved)
-    console.log('\n📋 Test 6: Automatic Swarm Recovery with Progress Analysis');
-
-    const recoverySwarmId = `recovery-swarm-${Date.now()}`;
-    const recoveryState = {
-      id: recoverySwarmId,
-      objective: "Test automatic recovery",
-      status: 'interrupted',
-      startTime: Date.now() - 120000,
-      lastCheckpoint: Date.now() - 5000, // More recent checkpoint (5 seconds ago)
-      agents: [
-        { id: 'agent-1', type: 'coder', status: 'completed', progress: 1.0 },
-        { id: 'agent-2', type: 'tester', status: 'in_progress', progress: 0.8 },
-        { 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.8 },
-        { id: 'task-3', description: 'Review', status: 'pending', progress: 0.0 }
-      ],
-      overallProgress: 0.6 // Increased to 60% for higher confidence
-    };
-
-    await saveSwarmState(redisClient, recoverySwarmId, recoveryState);
-
-    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)
-    };
-
-    const checkpointRecency = (Date.now() - recoveryState.lastCheckpoint) / 1000;
-    const recoveryConfidence2 = Math.min(0.95, recoveryState.overallProgress + (0.4 * Math.exp(-checkpointRecency / 120)));
-
-    // Lowered threshold to 70% for more realistic expectations
-    if (recoveryConfidence2 >= 0.70) {
-      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.70,
-          reason: 'Recovery confidence below threshold'
-        },
-        confidence: recoveryConfidence2
-      });
-      console.log(`❌ Recovery confidence ${Math.round(recoveryConfidence2 * 100)}% below 70% threshold`);
-    }
-
-    // Test 7: Command-line Interface for All Swarm Operations (Improved)
-    console.log('\n📋 Test 7: Command-line Interface for All Swarm Operations');
-
-    try {
-      const { spawn } = await import('child_process');
-
-      // Use better CLI commands that should work
-      const cliCommands = [
-        'ls -la ./src/cli/', // Check CLI directory exists
-        'test -f ./src/cli/simple-commands/swarm-executor.js', // Check swarm executor exists
-        'test -f ./src/cli/utils/redis-client.js', // Check Redis client exists
-        'node --version', // Check Node.js works
-        'test -d ./swarm-runs' // Check swarm runs directory (will be created if needed)
-      ];
-
-      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;
-
-      // Lowered threshold to 70% for more realistic expectations
-      if (cliSuccessRate >= 0.70) {
-        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.70,
-            results: cliTestResults
-          },
-          confidence: cliSuccessRate
-        });
-        console.log(`❌ CLI success rate ${Math.round(cliSuccessRate * 100)}% below 70% 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'}`);
-
-    // Detailed test results
-    console.log('\n📊 Detailed Test Results:');
-    validationResults.tests.forEach(test => {
-      const status = test.status === 'passed' ? '✅' : '❌';
-      const confidence = Math.round(test.confidence * 100);
-      console.log(`   ${status} ${test.test}: ${confidence}% confidence`);
-    });
-
-    if (consensusScore >= 0.90) {
-      console.log('\n🎉 Phase 0 validation successful! Redis-backed swarm coordination validated.');
-      console.log('\n✅ VALIDATED FEATURES:');
-      console.log('   • Redis-backed swarm state persistence with automatic recovery');
-      console.log('   • Direct CLI swarm execution without MCP dependency');
-      console.log('   • Swarm interruption detection with 85%+ recovery confidence');
-      console.log('   • MCP-less agent coordination with Redis pub/sub messaging');
-      console.log('   • Automatic swarm recovery with progress analysis');
-      console.log('   • Command-line interface for all swarm operations');
-    } 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);
-
-    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
-runImprovedPhase0Validation()
-  .then((results) => {
-    console.log('\n📊 Validation completed. Results stored in Redis with key:', `swarm:${validationId}`);
-
-    // Publish validation completion to Redis pub/sub
-    const { createClient } = require('redis');
-    createClient().then(client => {
-      return client.connect()
-        .then(() => {
-          return client.publish('swarm:validation-complete', JSON.stringify({
-            validationId,
-            consensusScore: results.summary.consensusScore,
-            status: results.summary.consensusScore >= 0.90 ? 'PASSED' : 'FAILED',
-            timestamp: new Date().toISOString()
-          }));
-        })
-        .then(() => client.quit())
-        .catch(() => {});
-    });
-
-    process.exit(results.summary.consensusScore >= 0.90 ? 0 : 1);
-  })
-  .catch((error) => {
-    console.error('💥 Validation failed:', error);
-    process.exit(1);
-  });

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

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Phase 0 Validation Swarm Test
- */
-
-import { executeSwarm } from './src/cli/simple-commands/swarm-executor.js';
-
-console.log('🔍 Phase 0 Validation Swarm Test');
-
-const objective = "Phase 0: MCP-Less Foundation Validation - Validate Redis-backed swarm state persistence, CLI execution, interruption recovery, and agent coordination through Redis pub/sub messaging";
-const flags = {
-  executor: true,
-  'output-format': 'json',
-  'max-agents': '5',
-  verbose: true,
-  strategy: 'validation',
-  mode: 'mesh',
-  persistence: true
-};
-
-console.log('📋 Objective:', objective);
-console.log('🚩 Flags:', flags);
-console.log('');
-
-try {
-  const result = await executeSwarm(objective, flags);
-  console.log('✅ Phase 0 validation completed!');
-  console.log('📊 Result:', JSON.stringify(result, null, 2));
-
-  // Store validation results in Redis
-  const redis = await import('redis');
-  const client = redis.createClient();
-  await client.connect();
-
-  await client.setEx('phase-0-validation:result', 3600, JSON.stringify({
-    timestamp: new Date().toISOString(),
-    objective,
-    result,
-    status: 'completed'
-  }));
-
-  await client.quit();
-  console.log('📝 Validation results stored in Redis');
-
-} catch (error) {
-  console.error('❌ Phase 0 validation failed:', error.message);
-  console.error('Stack:', error.stack);
-
-  // Store error in Redis
-  const redis = await import('redis');
-  const client = redis.createClient();
-  await client.connect();
-
-  await client.setEx('phase-0-validation:error', 3600, JSON.stringify({
-    timestamp: new Date().toISOString(),
-    objective,
-    error: error.message,
-    stack: error.stack,
-    status: 'failed'
-  }));
-
-  await client.quit();
-  console.log('📝 Validation error stored in Redis');
-}