claude-flow-novice 2.2.3 → 2.2.5

package/scripts/test/test-comprehensive.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+
+/**
+ * Comprehensive Test Runner for Claude Flow v2.0.0
+ */
+
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.join(__dirname, '..');
+
+// Test configurations
+const testSuites = [
+  {
+    name: 'Unit Tests',
+    command: 'npm',
+    args: ['run', 'test:unit'],
+    description: 'Run all unit tests for individual components',
+    timeout: 120000 // 2 minutes
+  },
+  {
+    name: 'Integration Tests',
+    command: 'npm',
+    args: ['run', 'test:integration'],
+    description: 'Run integration tests for system components',
+    timeout: 300000 // 5 minutes
+  },
+  {
+    name: 'End-to-End Tests',
+    command: 'npm',
+    args: ['run', 'test:e2e'],
+    description: 'Run end-to-end swarm coordination tests',
+    timeout: 600000 // 10 minutes
+  },
+  {
+    name: 'Performance Tests',
+    command: 'npm',
+    args: ['run', 'test:performance'],
+    description: 'Run performance benchmark tests',
+    timeout: 900000 // 15 minutes
+  },
+  {
+    name: 'CLI Tests',
+    command: 'npm',
+    args: ['run', 'test:cli'],
+    description: 'Run CLI command tests',
+    timeout: 180000 // 3 minutes
+  }
+];
+
+// Load tests (optional)
+const loadTests = [
+  {
+    name: 'Swarm Load Test',
+    command: 'node',
+    args: ['scripts/load-test-swarm.js'],
+    description: 'Test swarm coordination under heavy load',
+    timeout: 1200000 // 20 minutes
+  },
+  {
+    name: 'Memory Load Test',
+    command: 'node',
+    args: ['scripts/load-test-memory.js'],
+    description: 'Test memory management under high throughput',
+    timeout: 600000 // 10 minutes
+  }
+];
+
+// Docker tests (optional)
+const dockerTests = [
+  {
+    name: 'Docker Build Test',
+    command: 'docker',
+    args: ['build', '-t', 'claude-flow:test', '.'],
+    description: 'Test Docker image build',
+    timeout: 600000 // 10 minutes
+  },
+  {
+    name: 'Docker Container Test',
+    command: 'docker',
+    args: ['run', '--rm', 'claude-flow:test', 'claude-flow', '--version'],
+    description: 'Test Docker container execution',
+    timeout: 120000 // 2 minutes
+  }
+];
+
+// NPX tests (optional)
+const npxTests = [
+  {
+    name: 'NPX Installation Test',
+    command: 'npm',
+    args: ['pack'],
+    description: 'Test NPX package creation',
+    timeout: 180000 // 3 minutes
+  }
+];
+
+class TestRunner {
+  constructor(options = {}) {
+    this.verbose = options.verbose || false;
+    this.includeLoad = options.load || false;
+    this.includeDocker = options.docker || false;
+    this.includeNpx = options.npx || false;
+    this.parallel = options.parallel || false;
+    this.results = new Map();
+    this.startTime = Date.now();
+  }
+
+  log(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}]`;
+    
+    switch (level) {
+      case 'success':
+        console.log(chalk.green(`${prefix} ✅ ${message}`));
+        break;
+      case 'error':
+        console.log(chalk.red(`${prefix} ❌ ${message}`));
+        break;
+      case 'warning':
+        console.log(chalk.yellow(`${prefix} ⚠️  ${message}`));
+        break;
+      case 'info':
+      default:
+        console.log(chalk.blue(`${prefix} ℹ️  ${message}`));
+        break;
+    }
+  }
+
+  async runTest(test) {
+    this.log(`Starting: ${test.name} - ${test.description}`);
+    
+    const startTime = Date.now();
+    
+    return new Promise((resolve) => {
+      const child = spawn(test.command, test.args, {
+        cwd: projectRoot,
+        stdio: this.verbose ? 'inherit' : 'pipe',
+        shell: process.platform === 'win32'
+      });
+
+      let stdout = '';
+      let stderr = '';
+      
+      if (!this.verbose) {
+        child.stdout?.on('data', (data) => {
+          stdout += data.toString();
+        });
+        
+        child.stderr?.on('data', (data) => {
+          stderr += data.toString();
+        });
+      }
+
+      // Set timeout
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        const result = {
+          name: test.name,
+          success: false,
+          error: 'Test timed out',
+          duration: Date.now() - startTime,
+          stdout: stdout,
+          stderr: stderr
+        };
+        this.results.set(test.name, result);
+        resolve(result);
+      }, test.timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+        
+        const result = {
+          name: test.name,
+          success: code === 0,
+          exitCode: code,
+          duration: duration,
+          stdout: stdout,
+          stderr: stderr
+        };
+        
+        if (code === 0) {
+          this.log(`Completed: ${test.name} (${duration}ms)`, 'success');
+        } else {
+          this.log(`Failed: ${test.name} (exit code: ${code})`, 'error');
+          if (!this.verbose && stderr) {
+            console.log(chalk.red('Error output:'));
+            console.log(stderr);
+          }
+        }
+        
+        this.results.set(test.name, result);
+        resolve(result);
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        const result = {
+          name: test.name,
+          success: false,
+          error: error.message,
+          duration: Date.now() - startTime,
+          stdout: stdout,
+          stderr: stderr
+        };
+        
+        this.log(`Error: ${test.name} - ${error.message}`, 'error');
+        this.results.set(test.name, result);
+        resolve(result);
+      });
+    });
+  }
+
+  async runTestSuite(tests, suiteName) {
+    this.log(`\n🏃‍♂️ Running ${suiteName} (${tests.length} tests)`);
+    
+    if (this.parallel) {
+      const results = await Promise.all(tests.map(test => this.runTest(test)));
+      return results;
+    } else {
+      const results = [];
+      for (const test of tests) {
+        const result = await this.runTest(test);
+        results.push(result);
+        
+        // Short delay between tests
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+      return results;
+    }
+  }
+
+  generateReport() {
+    const totalTime = Date.now() - this.startTime;
+    const results = Array.from(this.results.values());
+    const passed = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+    const total = results.length;
+    
+    console.log('\n' + '='.repeat(80));
+    console.log(chalk.bold.blue('📊 CLAUDE FLOW v2.0.0 TEST REPORT'));
+    console.log('='.repeat(80));
+    
+    console.log(`\n📈 Summary:`);
+    console.log(`   Total Tests: ${total}`);
+    console.log(`   Passed: ${chalk.green(passed)}`);
+    console.log(`   Failed: ${chalk.red(failed)}`);
+    console.log(`   Success Rate: ${chalk.cyan(((passed / total) * 100).toFixed(1))}%`);
+    console.log(`   Total Time: ${chalk.yellow((totalTime / 1000).toFixed(2))}s`);
+    
+    if (failed > 0) {
+      console.log(`\n❌ Failed Tests:`);
+      results.filter(r => !r.success).forEach(result => {
+        console.log(`   • ${chalk.red(result.name)}: ${result.error || `Exit code ${result.exitCode}`}`);
+      });
+    }
+    
+    console.log(`\n✅ Passed Tests:`);
+    results.filter(r => r.success).forEach(result => {
+      console.log(`   • ${chalk.green(result.name)}: ${(result.duration / 1000).toFixed(2)}s`);
+    });
+    
+    // Performance summary
+    const performanceResults = results.filter(r => r.name.includes('Performance'));
+    if (performanceResults.length > 0) {
+      console.log(`\n⚡ Performance Summary:`);
+      performanceResults.forEach(result => {
+        if (result.success) {
+          console.log(`   • ${result.name}: ${chalk.green('PASSED')} (${(result.duration / 1000).toFixed(2)}s)`);
+        } else {
+          console.log(`   • ${result.name}: ${chalk.red('FAILED')}`);
+        }
+      });
+    }
+    
+    console.log('\n' + '='.repeat(80));
+    
+    return {
+      total,
+      passed,
+      failed,
+      successRate: (passed / total) * 100,
+      totalTime,
+      results
+    };
+  }
+
+  async run() {
+    this.log('🚀 Starting Claude Flow v2.0.0 Comprehensive Test Suite');
+    
+    try {
+      // Core test suites
+      await this.runTestSuite(testSuites, 'Core Test Suites');
+      
+      // Optional test suites
+      if (this.includeLoad) {
+        await this.runTestSuite(loadTests, 'Load Tests');
+      }
+      
+      if (this.includeDocker) {
+        await this.runTestSuite(dockerTests, 'Docker Tests');
+      }
+      
+      if (this.includeNpx) {
+        await this.runTestSuite(npxTests, 'NPX Tests');
+      }
+      
+    } catch (error) {
+      this.log(`Test runner error: ${error.message}`, 'error');
+    }
+    
+    const report = this.generateReport();
+    
+    // Exit with appropriate code
+    process.exit(report.failed > 0 ? 1 : 0);
+  }
+}
+
+// CLI handling
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    verbose: args.includes('--verbose') || args.includes('-v'),
+    load: args.includes('--load') || args.includes('-l'),
+    docker: args.includes('--docker') || args.includes('-d'),
+    npx: args.includes('--npx') || args.includes('-n'),
+    parallel: args.includes('--parallel') || args.includes('-p'),
+    help: args.includes('--help') || args.includes('-h')
+  };
+  
+  return options;
+}
+
+function showHelp() {
+  console.log(`
+${chalk.bold.blue('Claude Flow v2.0.0 Comprehensive Test Runner')}
+
+${chalk.bold('Usage:')}
+  node scripts/test-comprehensive.js [options]
+
+${chalk.bold('Options:')}
+  -v, --verbose     Show detailed test output
+  -l, --load        Include load tests
+  -d, --docker      Include Docker tests
+  -n, --npx         Include NPX tests
+  -p, --parallel    Run tests in parallel (faster but less stable)
+  -h, --help        Show this help message
+
+${chalk.bold('Examples:')}
+  node scripts/test-comprehensive.js                    # Run core tests
+  node scripts/test-comprehensive.js --verbose          # Run with detailed output
+  node scripts/test-comprehensive.js --load --docker    # Include load and Docker tests
+  node scripts/test-comprehensive.js --parallel         # Run tests in parallel
+
+${chalk.bold('Test Suites:')}
+  • Unit Tests - Individual component tests
+  • Integration Tests - System integration tests
+  • End-to-End Tests - Complete workflow tests
+  • Performance Tests - Benchmark and load tests
+  • CLI Tests - Command-line interface tests
+  • Load Tests - Heavy load and stress tests (optional)
+  • Docker Tests - Container and deployment tests (optional)
+  • NPX Tests - Package distribution tests (optional)
+`);
+}
+
+// Main execution
+async function main() {
+  const options = parseArgs();
+  
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+  
+  const runner = new TestRunner(options);
+  await runner.run();
+}
+
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('Uncaught Exception:'), error);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error(chalk.red('Unhandled Rejection at:'), promise, chalk.red('reason:'), reason);
+  process.exit(1);
+});
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export default TestRunner;

package/scripts/test/test-coordination-features.ts

@@ -0,0 +1,238 @@
+#!/usr/bin/env -S deno run --allow-all
+
+/**
+ * Test script for advanced coordination features
+ * Demonstrates:
+ * - Resource management and deadlock detection
+ * - Task dependencies and scheduling
+ * - Work stealing and load balancing
+ * - Circuit breakers and fault tolerance
+ */
+
+import { EventBus } from '../src/core/event-bus.ts';
+import { Logger } from '../src/core/logger.js';
+import { CoordinationManager } from '../src/coordination/manager.ts';
+import { Task, SystemEvents } from '../src/utils/types.ts';
+import { delay } from '../src/utils/helpers.ts';
+
+async function testCoordinationFeatures() {
+  console.log('🔄 Testing Claude-Flow Coordination Features\n');
+  
+  const eventBus = new EventBus();
+  const logger = new Logger({ level: 'info', format: 'json', destination: 'console' });
+  
+  const config = {
+    maxRetries: 3,
+    retryDelay: 1000,
+    resourceTimeout: 5000,
+    deadlockDetection: true,
+    priorityLevels: 5,
+  };
+  
+  const coordinator = new CoordinationManager(config, eventBus, logger);
+  
+  try {
+    await coordinator.initialize();
+    console.log('✅ Coordination manager initialized\n');
+    
+    // Test 1: Resource Management
+    console.log('📋 Test 1: Resource Management');
+    console.log('Testing resource acquisition and release...');
+    
+    // Agent 1 acquires resource A
+    await coordinator.acquireResource('resource-A', 'agent-1');
+    console.log('✅ Agent 1 acquired resource A');
+    
+    // Agent 2 tries to acquire resource A (should wait)
+    const acquire2Promise = coordinator.acquireResource('resource-A', 'agent-2');
+    console.log('⏳ Agent 2 waiting for resource A...');
+    
+    // Release after delay
+    setTimeout(async () => {
+      await coordinator.releaseResource('resource-A', 'agent-1');
+      console.log('✅ Agent 1 released resource A');
+    }, 1000);
+    
+    await acquire2Promise;
+    console.log('✅ Agent 2 acquired resource A\n');
+    
+    // Test 2: Task Dependencies
+    console.log('📋 Test 2: Task Dependencies');
+    
+    const parentTask: Task = {
+      id: 'parent-task',
+      type: 'process',
+      description: 'Parent task',
+      priority: 90,
+      dependencies: [],
+      status: 'pending',
+      input: {},
+      createdAt: new Date(),
+    };
+    
+    const childTask: Task = {
+      id: 'child-task',
+      type: 'process',
+      description: 'Child task (depends on parent)',
+      priority: 80,
+      dependencies: ['parent-task'],
+      status: 'pending',
+      input: {},
+      createdAt: new Date(),
+    };
+    
+    await coordinator.assignTask(parentTask, 'agent-1');
+    console.log('✅ Assigned parent task to agent-1');
+    
+    try {
+      await coordinator.assignTask(childTask, 'agent-2');
+    } catch (error) {
+      console.log('✅ Child task correctly blocked by dependency');
+    }
+    
+    // Complete parent task
+    eventBus.emit(SystemEvents.TASK_COMPLETED, {
+      taskId: 'parent-task',
+      result: { data: 'parent result' },
+    });
+    
+    await delay(100);
+    
+    // Now child should be assignable
+    await coordinator.assignTask(childTask, 'agent-2');
+    console.log('✅ Child task assigned after parent completion\n');
+    
+    // Test 3: Deadlock Detection
+    console.log('📋 Test 3: Deadlock Detection');
+    console.log('Creating potential deadlock scenario...');
+    
+    // Agent 3 holds B, wants A
+    await coordinator.acquireResource('resource-B', 'agent-3');
+    const agent3WantsA = coordinator.acquireResource('resource-A', 'agent-3')
+      .catch(() => console.log('✅ Deadlock detected and resolved'));
+    
+    // Agent 2 holds A, wants B (creates cycle)
+    const agent2WantsB = coordinator.acquireResource('resource-B', 'agent-2')
+      .catch(() => console.log('✅ Agent 2 resource request failed'));
+    
+    // Wait for deadlock detection
+    await delay(2000);
+    
+    // Clean up resources
+    await coordinator.releaseResource('resource-A', 'agent-2');
+    await coordinator.releaseResource('resource-B', 'agent-3');
+    console.log('✅ Resources cleaned up\n');
+    
+    // Test 4: Advanced Scheduling
+    console.log('📋 Test 4: Advanced Scheduling Features');
+    coordinator.enableAdvancedScheduling();
+    console.log('✅ Advanced scheduling enabled');
+    
+    // Create tasks with different priorities
+    const highPriorityTask: Task = {
+      id: 'high-priority',
+      type: 'urgent',
+      description: 'High priority task',
+      priority: 100,
+      dependencies: [],
+      status: 'pending',
+      input: {},
+      createdAt: new Date(),
+    };
+    
+    const lowPriorityTask: Task = {
+      id: 'low-priority',
+      type: 'batch',
+      description: 'Low priority task',
+      priority: 10,
+      dependencies: [],
+      status: 'pending',
+      input: {},
+      createdAt: new Date(),
+    };
+    
+    await coordinator.assignTask(lowPriorityTask, 'agent-1');
+    await coordinator.assignTask(highPriorityTask, 'agent-1');
+    console.log('✅ Tasks assigned with priority scheduling\n');
+    
+    // Test 5: Conflict Resolution
+    console.log('📋 Test 5: Conflict Resolution');
+    
+    // Report a resource conflict
+    await coordinator.reportConflict('resource', 'shared-resource', ['agent-1', 'agent-2']);
+    console.log('✅ Resource conflict reported and auto-resolved');
+    
+    // Report a task conflict
+    await coordinator.reportConflict('task', 'disputed-task', ['agent-1', 'agent-2']);
+    console.log('✅ Task conflict reported and auto-resolved\n');
+    
+    // Test 6: Health and Metrics
+    console.log('📋 Test 6: Health Monitoring and Metrics');
+    
+    const health = await coordinator.getHealthStatus();
+    console.log('🏥 Health Status:', health.healthy ? 'Healthy' : 'Unhealthy');
+    
+    const metrics = await coordinator.getCoordinationMetrics();
+    console.log('📊 Coordination Metrics:');
+    console.log(`  Tasks assigned: ${metrics.assigned || 0}`);
+    console.log(`  Resources managed: ${metrics.resources || 0}`);
+    console.log(`  Conflicts resolved: ${metrics.conflicts?.resolved || 0}`);
+    console.log(`  Advanced scheduling: ${metrics.advancedScheduling ? 'Enabled' : 'Disabled'}`);
+    
+    // Test 7: Message Routing
+    console.log('\n📋 Test 7: Inter-Agent Messaging');
+    
+    // Set up message handler
+    let messagesReceived = 0;
+    eventBus.on('message:agent-2', (data: any) => {
+      messagesReceived++;
+      console.log(`✅ Agent 2 received message: ${data.message.content}`);
+    });
+    
+    // Send messages
+    await coordinator.sendMessage('agent-1', 'agent-2', { 
+      type: 'status', 
+      content: 'Task completed' 
+    });
+    
+    await coordinator.sendMessage('agent-1', 'agent-2', { 
+      type: 'data', 
+      content: 'Results available' 
+    });
+    
+    await delay(100);
+    console.log(`✅ Sent and received ${messagesReceived} messages\n`);
+    
+    // Perform maintenance
+    console.log('📋 Performing maintenance...');
+    await coordinator.performMaintenance();
+    console.log('✅ Maintenance completed');
+    
+    // Shutdown
+    await coordinator.shutdown();
+    console.log('\n✅ Coordination manager shut down successfully');
+    
+    // Summary
+    console.log('\n' + '='.repeat(50));
+    console.log('✅ ALL COORDINATION TESTS PASSED!');
+    console.log('='.repeat(50));
+    console.log('\nFeatures tested:');
+    console.log('  ✓ Resource management with mutual exclusion');
+    console.log('  ✓ Task dependencies and scheduling');
+    console.log('  ✓ Deadlock detection and prevention');
+    console.log('  ✓ Advanced scheduling with priorities');
+    console.log('  ✓ Conflict detection and resolution');
+    console.log('  ✓ Health monitoring and metrics');
+    console.log('  ✓ Inter-agent messaging');
+    console.log('  ✓ System maintenance');
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    throw error;
+  }
+}
+
+// Run the test
+if (import.meta.main) {
+  testCoordinationFeatures().catch(console.error);
+}