claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/hive-mind/performance-test.js

@@ -1,373 +1,289 @@
 /**
  * Performance Test Suite for Hive Mind Optimizations
  * Tests the performance improvements implemented
- */
-
-import { HiveMindCore } from './core.js';
-import { PerformanceOptimizer } from './performance-optimizer.js';
-import { performance } from 'perf_hooks';
-
+ */ import { HiveMindCore } from "./core.js";
+import { PerformanceOptimizer } from "./performance-optimizer.js";
+import { performance } from "perf_hooks";
 /**
  * Performance test runner
- */
-export class PerformanceTest {
-  constructor() {
-    this.results = [];
-    this.baseline = null;
-  }
-
-  /**
+ */ export class PerformanceTest {
+    /**
    * Run complete performance test suite
-   */
-  async runTestSuite() {
-    console.log('🔬 Starting Hive Mind Performance Test Suite...\n');
-
-    const tests = [
-      this.testBatchAgentSpawning,
-      this.testAsyncOperationQueue,
-      this.testMemoryOperations,
-      this.testConcurrentTaskExecution,
-      this.testPerformanceOptimizer,
-    ];
-
-    for (const test of tests) {
-      try {
-        await test.call(this);
-      } catch (error) {
-        console.error(`Test failed: ${test.name}`, error);
-      }
+   */ async runTestSuite() {
+        console.log('🔬 Starting Hive Mind Performance Test Suite...\n');
+        const tests = [
+            this.testBatchAgentSpawning,
+            this.testAsyncOperationQueue,
+            this.testMemoryOperations,
+            this.testConcurrentTaskExecution,
+            this.testPerformanceOptimizer
+        ];
+        for (const test of tests){
+            try {
+                await test.call(this);
+            } catch (error) {
+                console.error(`Test failed: ${test.name}`, error);
+            }
+        }
+        this.generateReport();
     }
-
-    this.generateReport();
-  }
-
-  /**
+    /**
    * Test batch agent spawning performance
-   */
-  async testBatchAgentSpawning() {
-    console.log('🚀 Testing Batch Agent Spawning...');
-
-    const hiveMind = new HiveMindCore({
-      name: 'test-batch-spawn',
-      maxWorkers: 10,
-    });
-
-    await hiveMind.initialize();
-
-    // Test batch spawning vs sequential spawning
-    const agentTypes = ['coder', 'tester', 'analyst', 'researcher', 'architect', 'optimizer'];
-
-    // Batch spawning test
-    const batchStart = performance.now();
-    const batchResults = await hiveMind.spawnWorkers(agentTypes);
-    const batchTime = performance.now() - batchStart;
-
-    // Simulate sequential spawning for comparison
-    const sequentialStart = performance.now();
-    for (let i = 0; i < agentTypes.length; i++) {
-      // Simulate individual spawning time
-      await new Promise((resolve) => setTimeout(resolve, 200));
+   */ async testBatchAgentSpawning() {
+        console.log('🚀 Testing Batch Agent Spawning...');
+        const hiveMind = new HiveMindCore({
+            name: 'test-batch-spawn',
+            maxWorkers: 10
+        });
+        await hiveMind.initialize();
+        // Test batch spawning vs sequential spawning
+        const agentTypes = [
+            'coder',
+            'tester',
+            'analyst',
+            'researcher',
+            'architect',
+            'optimizer'
+        ];
+        // Batch spawning test
+        const batchStart = performance.now();
+        const batchResults = await hiveMind.spawnWorkers(agentTypes);
+        const batchTime = performance.now() - batchStart;
+        // Simulate sequential spawning for comparison
+        const sequentialStart = performance.now();
+        for(let i = 0; i < agentTypes.length; i++){
+            // Simulate individual spawning time
+            await new Promise((resolve)=>setTimeout(resolve, 200));
+        }
+        const sequentialTime = performance.now() - sequentialStart;
+        const improvement = ((sequentialTime - batchTime) / sequentialTime * 100).toFixed(2);
+        this.results.push({
+            test: 'Batch Agent Spawning',
+            batchTime: batchTime.toFixed(2) + 'ms',
+            sequentialTime: sequentialTime.toFixed(2) + 'ms',
+            improvement: improvement + '%',
+            agentsSpawned: batchResults.length,
+            status: improvement > 50 ? 'PASS' : 'WARN'
+        });
+        console.log(`  ✅ Batch: ${batchTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`);
+        await hiveMind.shutdown();
     }
-    const sequentialTime = performance.now() - sequentialStart;
-
-    const improvement = (((sequentialTime - batchTime) / sequentialTime) * 100).toFixed(2);
-
-    this.results.push({
-      test: 'Batch Agent Spawning',
-      batchTime: batchTime.toFixed(2) + 'ms',
-      sequentialTime: sequentialTime.toFixed(2) + 'ms',
-      improvement: improvement + '%',
-      agentsSpawned: batchResults.length,
-      status: improvement > 50 ? 'PASS' : 'WARN',
-    });
-
-    console.log(
-      `  ✅ Batch: ${batchTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`,
-    );
-
-    await hiveMind.shutdown();
-  }
-
-  /**
+    /**
    * Test async operation queue performance
-   */
-  async testAsyncOperationQueue() {
-    console.log('⚡ Testing Async Operation Queue...');
-
-    const optimizer = new PerformanceOptimizer({
-      asyncQueueConcurrency: 5,
-    });
-
-    const operations = [];
-    for (let i = 0; i < 20; i++) {
-      operations.push(async () => {
-        await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 + 50));
-        return `Operation ${i} completed`;
-      });
-    }
-
-    // Test parallel execution
-    const parallelStart = performance.now();
-    const parallelResults = await Promise.all(
-      operations.map((op) => optimizer.optimizeAsyncOperation(op)),
-    );
-    const parallelTime = performance.now() - parallelStart;
-
-    // Test sequential execution for comparison
-    const sequentialStart = performance.now();
-    const sequentialResults = [];
-    for (const op of operations) {
-      sequentialResults.push(await op());
+   */ async testAsyncOperationQueue() {
+        console.log('⚡ Testing Async Operation Queue...');
+        const optimizer = new PerformanceOptimizer({
+            asyncQueueConcurrency: 5
+        });
+        const operations = [];
+        for(let i = 0; i < 20; i++){
+            operations.push(async ()=>{
+                await new Promise((resolve)=>setTimeout(resolve, Math.random() * 100 + 50));
+                return `Operation ${i} completed`;
+            });
+        }
+        // Test parallel execution
+        const parallelStart = performance.now();
+        const parallelResults = await Promise.all(operations.map((op)=>optimizer.optimizeAsyncOperation(op)));
+        const parallelTime = performance.now() - parallelStart;
+        // Test sequential execution for comparison
+        const sequentialStart = performance.now();
+        const sequentialResults = [];
+        for (const op of operations){
+            sequentialResults.push(await op());
+        }
+        const sequentialTime = performance.now() - sequentialStart;
+        const improvement = ((sequentialTime - parallelTime) / sequentialTime * 100).toFixed(2);
+        this.results.push({
+            test: 'Async Operation Queue',
+            parallelTime: parallelTime.toFixed(2) + 'ms',
+            sequentialTime: sequentialTime.toFixed(2) + 'ms',
+            improvement: improvement + '%',
+            operationsProcessed: operations.length,
+            status: improvement > 60 ? 'PASS' : 'WARN'
+        });
+        console.log(`  ✅ Parallel: ${parallelTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`);
+        await optimizer.close();
     }
-    const sequentialTime = performance.now() - sequentialStart;
-
-    const improvement = (((sequentialTime - parallelTime) / sequentialTime) * 100).toFixed(2);
-
-    this.results.push({
-      test: 'Async Operation Queue',
-      parallelTime: parallelTime.toFixed(2) + 'ms',
-      sequentialTime: sequentialTime.toFixed(2) + 'ms',
-      improvement: improvement + '%',
-      operationsProcessed: operations.length,
-      status: improvement > 60 ? 'PASS' : 'WARN',
-    });
-
-    console.log(
-      `  ✅ Parallel: ${parallelTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`,
-    );
-
-    await optimizer.close();
-  }
-
-  /**
+    /**
    * Test memory operations with connection pooling
-   */
-  async testMemoryOperations() {
-    console.log('💾 Testing Memory Operations...');
-
-    // This would test the CollectiveMemory optimizations
-    // For now, we'll simulate the test
-    const pooledStart = performance.now();
-
-    // Simulate 100 memory operations with connection pooling
-    const operations = Array(100)
-      .fill(null)
-      .map(async (_, i) => {
-        await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
-        return { key: `test-${i}`, value: `data-${i}` };
-      });
-
-    await Promise.all(operations);
-    const pooledTime = performance.now() - pooledStart;
-
-    // Simulate without pooling
-    const serialStart = performance.now();
-    for (let i = 0; i < 100; i++) {
-      await new Promise((resolve) => setTimeout(resolve, Math.random() * 15 + 5));
+   */ async testMemoryOperations() {
+        console.log('💾 Testing Memory Operations...');
+        // This would test the CollectiveMemory optimizations
+        // For now, we'll simulate the test
+        const pooledStart = performance.now();
+        // Simulate 100 memory operations with connection pooling
+        const operations = Array(100).fill(null).map(async (_, i)=>{
+            await new Promise((resolve)=>setTimeout(resolve, Math.random() * 10));
+            return {
+                key: `test-${i}`,
+                value: `data-${i}`
+            };
+        });
+        await Promise.all(operations);
+        const pooledTime = performance.now() - pooledStart;
+        // Simulate without pooling
+        const serialStart = performance.now();
+        for(let i = 0; i < 100; i++){
+            await new Promise((resolve)=>setTimeout(resolve, Math.random() * 15 + 5));
+        }
+        const serialTime = performance.now() - serialStart;
+        const improvement = ((serialTime - pooledTime) / serialTime * 100).toFixed(2);
+        this.results.push({
+            test: 'Memory Operations',
+            pooledTime: pooledTime.toFixed(2) + 'ms',
+            serialTime: serialTime.toFixed(2) + 'ms',
+            improvement: improvement + '%',
+            operationsProcessed: 100,
+            status: improvement > 25 ? 'PASS' : 'WARN'
+        });
+        console.log(`  ✅ Pooled: ${pooledTime.toFixed(2)}ms | Serial: ${serialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`);
     }
-    const serialTime = performance.now() - serialStart;
-
-    const improvement = (((serialTime - pooledTime) / serialTime) * 100).toFixed(2);
-
-    this.results.push({
-      test: 'Memory Operations',
-      pooledTime: pooledTime.toFixed(2) + 'ms',
-      serialTime: serialTime.toFixed(2) + 'ms',
-      improvement: improvement + '%',
-      operationsProcessed: 100,
-      status: improvement > 25 ? 'PASS' : 'WARN',
-    });
-
-    console.log(
-      `  ✅ Pooled: ${pooledTime.toFixed(2)}ms | Serial: ${serialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`,
-    );
-  }
-
-  /**
+    /**
    * Test concurrent task execution
-   */
-  async testConcurrentTaskExecution() {
-    console.log('🔄 Testing Concurrent Task Execution...');
-
-    const hiveMind = new HiveMindCore({
-      name: 'test-concurrent-tasks',
-      maxWorkers: 8,
-    });
-
-    await hiveMind.initialize();
-
-    // Spawn workers
-    await hiveMind.spawnWorkers(['coder', 'tester', 'analyst', 'researcher']);
-
-    const tasks = [
-      'Implement user authentication',
-      'Write unit tests',
-      'Analyze performance metrics',
-      'Research best practices',
-      'Optimize database queries',
-      'Document API endpoints',
-    ];
-
-    // Test concurrent task creation and execution
-    const concurrentStart = performance.now();
-    const taskPromises = tasks.map((description) =>
-      hiveMind.createTask(description, Math.floor(Math.random() * 10) + 1),
-    );
-
-    await Promise.all(taskPromises);
-
-    // Wait for tasks to complete (simulated)
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    const concurrentTime = performance.now() - concurrentStart;
-
-    // Get final status
-    const status = hiveMind.getStatus();
-
-    this.results.push({
-      test: 'Concurrent Task Execution',
-      executionTime: concurrentTime.toFixed(2) + 'ms',
-      tasksCreated: status.tasks.total,
-      workersActive: status.workers.length,
-      throughput: (status.tasks.total / (concurrentTime / 1000)).toFixed(2) + ' tasks/sec',
-      status: status.tasks.total === tasks.length ? 'PASS' : 'WARN',
-    });
-
-    console.log(
-      `  ✅ Tasks: ${status.tasks.total} | Workers: ${status.workers.length} | Time: ${concurrentTime.toFixed(2)}ms\n`,
-    );
-
-    await hiveMind.shutdown();
-  }
-
-  /**
-   * Test performance optimizer functionality
-   */
-  async testPerformanceOptimizer() {
-    console.log('📊 Testing Performance Optimizer...');
-
-    const optimizer = new PerformanceOptimizer({
-      enableAsyncQueue: true,
-      enableBatchProcessing: true,
-      enableAutoTuning: true,
-    });
-
-    // Test cache optimization
-    const cacheKey = 'test-cache-key';
-    let cacheHits = 0;
-    let cacheMisses = 0;
-
-    // First call should be a miss
-    const cacheStart = performance.now();
-    await optimizer.optimizeWithCache(cacheKey, async () => {
-      cacheMisses++;
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      return 'cached-value';
-    });
-
-    // Subsequent calls should be hits
-    for (let i = 0; i < 5; i++) {
-      await optimizer.optimizeWithCache(cacheKey, async () => {
-        cacheMisses++;
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        return 'cached-value';
-      });
-      cacheHits++;
+   */ async testConcurrentTaskExecution() {
+        console.log('🔄 Testing Concurrent Task Execution...');
+        const hiveMind = new HiveMindCore({
+            name: 'test-concurrent-tasks',
+            maxWorkers: 8
+        });
+        await hiveMind.initialize();
+        // Spawn workers
+        await hiveMind.spawnWorkers([
+            'coder',
+            'tester',
+            'analyst',
+            'researcher'
+        ]);
+        const tasks = [
+            'Implement user authentication',
+            'Write unit tests',
+            'Analyze performance metrics',
+            'Research best practices',
+            'Optimize database queries',
+            'Document API endpoints'
+        ];
+        // Test concurrent task creation and execution
+        const concurrentStart = performance.now();
+        const taskPromises = tasks.map((description)=>hiveMind.createTask(description, Math.floor(Math.random() * 10) + 1));
+        await Promise.all(taskPromises);
+        // Wait for tasks to complete (simulated)
+        await new Promise((resolve)=>setTimeout(resolve, 2000));
+        const concurrentTime = performance.now() - concurrentStart;
+        // Get final status
+        const status = hiveMind.getStatus();
+        this.results.push({
+            test: 'Concurrent Task Execution',
+            executionTime: concurrentTime.toFixed(2) + 'ms',
+            tasksCreated: status.tasks.total,
+            workersActive: status.workers.length,
+            throughput: (status.tasks.total / (concurrentTime / 1000)).toFixed(2) + ' tasks/sec',
+            status: status.tasks.total === tasks.length ? 'PASS' : 'WARN'
+        });
+        console.log(`  ✅ Tasks: ${status.tasks.total} | Workers: ${status.workers.length} | Time: ${concurrentTime.toFixed(2)}ms\n`);
+        await hiveMind.shutdown();
     }
-    const cacheTime = performance.now() - cacheStart;
-
-    // Test batch processing
-    const batchStart = performance.now();
-    const batchPromises = [];
-
-    for (let i = 0; i < 10; i++) {
-      batchPromises.push(
-        optimizer.optimizeBatchOperation(
-          'test-batch',
-          { id: i, data: `test-${i}` },
-          async (items) => {
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            return items.map((item) => ({ processed: item.id }));
-          },
-        ),
-      );
+    /**
+   * Test performance optimizer functionality
+   */ async testPerformanceOptimizer() {
+        console.log('📊 Testing Performance Optimizer...');
+        const optimizer = new PerformanceOptimizer({
+            enableAsyncQueue: true,
+            enableBatchProcessing: true,
+            enableAutoTuning: true
+        });
+        // Test cache optimization
+        const cacheKey = 'test-cache-key';
+        let cacheHits = 0;
+        let cacheMisses = 0;
+        // First call should be a miss
+        const cacheStart = performance.now();
+        await optimizer.optimizeWithCache(cacheKey, async ()=>{
+            cacheMisses++;
+            await new Promise((resolve)=>setTimeout(resolve, 100));
+            return 'cached-value';
+        });
+        // Subsequent calls should be hits
+        for(let i = 0; i < 5; i++){
+            await optimizer.optimizeWithCache(cacheKey, async ()=>{
+                cacheMisses++;
+                await new Promise((resolve)=>setTimeout(resolve, 100));
+                return 'cached-value';
+            });
+            cacheHits++;
+        }
+        const cacheTime = performance.now() - cacheStart;
+        // Test batch processing
+        const batchStart = performance.now();
+        const batchPromises = [];
+        for(let i = 0; i < 10; i++){
+            batchPromises.push(optimizer.optimizeBatchOperation('test-batch', {
+                id: i,
+                data: `test-${i}`
+            }, async (items)=>{
+                await new Promise((resolve)=>setTimeout(resolve, 50));
+                return items.map((item)=>({
+                        processed: item.id
+                    }));
+            }));
+        }
+        await Promise.all(batchPromises);
+        const batchTime = performance.now() - batchStart;
+        const stats = optimizer.getPerformanceStats();
+        this.results.push({
+            test: 'Performance Optimizer',
+            cacheTime: cacheTime.toFixed(2) + 'ms',
+            cacheHitRate: (cacheHits / (cacheHits + cacheMisses) * 100).toFixed(2) + '%',
+            batchTime: batchTime.toFixed(2) + 'ms',
+            batchesProcessed: stats.batchProcessor.batchesProcessed,
+            status: stats.cache.hitRate > 50 ? 'PASS' : 'WARN'
+        });
+        console.log(`  ✅ Cache Hit Rate: ${(cacheHits / (cacheHits + cacheMisses) * 100).toFixed(2)}% | Batches: ${stats.batchProcessor.batchesProcessed}\n`);
+        await optimizer.close();
     }
-
-    await Promise.all(batchPromises);
-    const batchTime = performance.now() - batchStart;
-
-    const stats = optimizer.getPerformanceStats();
-
-    this.results.push({
-      test: 'Performance Optimizer',
-      cacheTime: cacheTime.toFixed(2) + 'ms',
-      cacheHitRate: ((cacheHits / (cacheHits + cacheMisses)) * 100).toFixed(2) + '%',
-      batchTime: batchTime.toFixed(2) + 'ms',
-      batchesProcessed: stats.batchProcessor.batchesProcessed,
-      status: stats.cache.hitRate > 50 ? 'PASS' : 'WARN',
-    });
-
-    console.log(
-      `  ✅ Cache Hit Rate: ${((cacheHits / (cacheHits + cacheMisses)) * 100).toFixed(2)}% | Batches: ${stats.batchProcessor.batchesProcessed}\n`,
-    );
-
-    await optimizer.close();
-  }
-
-  /**
+    /**
    * Generate comprehensive performance report
-   */
-  generateReport() {
-    console.log('📊 Performance Test Results');
-    console.log('='.repeat(80));
-
-    let totalPassed = 0;
-    let totalTests = this.results.length;
-
-    this.results.forEach((result, index) => {
-      console.log(`\n${index + 1}. ${result.test}`);
-      console.log('-'.repeat(40));
-
-      Object.entries(result).forEach(([key, value]) => {
-        if (key !== 'test' && key !== 'status') {
-          console.log(`   ${key.charAt(0).toUpperCase() + key.slice(1)}: ${value}`);
+   */ generateReport() {
+        console.log('📊 Performance Test Results');
+        console.log('='.repeat(80));
+        let totalPassed = 0;
+        let totalTests = this.results.length;
+        this.results.forEach((result, index)=>{
+            console.log(`\n${index + 1}. ${result.test}`);
+            console.log('-'.repeat(40));
+            Object.entries(result).forEach(([key, value])=>{
+                if (key !== 'test' && key !== 'status') {
+                    console.log(`   ${key.charAt(0).toUpperCase() + key.slice(1)}: ${value}`);
+                }
+            });
+            const statusIcon = result.status === 'PASS' ? '✅' : '⚠️';
+            console.log(`   Status: ${statusIcon} ${result.status}`);
+            if (result.status === 'PASS') totalPassed++;
+        });
+        console.log('\n' + '='.repeat(80));
+        console.log(`📈 Overall Results: ${totalPassed}/${totalTests} tests passed`);
+        if (totalPassed === totalTests) {
+            console.log('🎉 All performance optimizations are working correctly!');
+        } else {
+            console.log('⚠️  Some optimizations may need attention.');
+        }
+        // Performance summary
+        const improvements = this.results.filter((r)=>r.improvement).map((r)=>parseFloat(r.improvement));
+        if (improvements.length > 0) {
+            const avgImprovement = improvements.reduce((a, b)=>a + b, 0) / improvements.length;
+            console.log(`🚀 Average Performance Improvement: ${avgImprovement.toFixed(2)}%`);
         }
-      });
-
-      const statusIcon = result.status === 'PASS' ? '✅' : '⚠️';
-      console.log(`   Status: ${statusIcon} ${result.status}`);
-
-      if (result.status === 'PASS') totalPassed++;
-    });
-
-    console.log('\n' + '='.repeat(80));
-    console.log(`📈 Overall Results: ${totalPassed}/${totalTests} tests passed`);
-
-    if (totalPassed === totalTests) {
-      console.log('🎉 All performance optimizations are working correctly!');
-    } else {
-      console.log('⚠️  Some optimizations may need attention.');
+        console.log('\n🔧 Performance optimization implementation complete!');
     }
-
-    // Performance summary
-    const improvements = this.results
-      .filter((r) => r.improvement)
-      .map((r) => parseFloat(r.improvement));
-
-    if (improvements.length > 0) {
-      const avgImprovement = improvements.reduce((a, b) => a + b, 0) / improvements.length;
-      console.log(`🚀 Average Performance Improvement: ${avgImprovement.toFixed(2)}%`);
+    constructor(){
+        this.results = [];
+        this.baseline = null;
     }
-
-    console.log('\n🔧 Performance optimization implementation complete!');
-  }
 }
-
 // Export for use in tests
 export default PerformanceTest;
-
 // Run tests if executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const testRunner = new PerformanceTest();
-  testRunner.runTestSuite().catch(console.error);
+    const testRunner = new PerformanceTest();
+    testRunner.runTestSuite().catch(console.error);
 }