claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

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

@@ -27,7 +27,7 @@ export class PerformanceTest {
       this.testAsyncOperationQueue,
       this.testMemoryOperations,
       this.testConcurrentTaskExecution,
-      this.testPerformanceOptimizer
+      this.testPerformanceOptimizer,
     ];
 
     for (const test of tests) {
@@ -49,7 +49,7 @@ export class PerformanceTest {
 
     const hiveMind = new HiveMindCore({
       name: 'test-batch-spawn',
-      maxWorkers: 10
+      maxWorkers: 10,
     });
 
     await hiveMind.initialize();
@@ -66,11 +66,11 @@ export class PerformanceTest {
     const sequentialStart = performance.now();
     for (let i = 0; i < agentTypes.length; i++) {
       // Simulate individual spawning time
-      await new Promise(resolve => setTimeout(resolve, 200));
+      await new Promise((resolve) => setTimeout(resolve, 200));
     }
     const sequentialTime = performance.now() - sequentialStart;
 
-    const improvement = ((sequentialTime - batchTime) / sequentialTime * 100).toFixed(2);
+    const improvement = (((sequentialTime - batchTime) / sequentialTime) * 100).toFixed(2);
 
     this.results.push({
       test: 'Batch Agent Spawning',
@@ -78,10 +78,12 @@ export class PerformanceTest {
       sequentialTime: sequentialTime.toFixed(2) + 'ms',
       improvement: improvement + '%',
       agentsSpawned: batchResults.length,
-      status: improvement > 50 ? 'PASS' : 'WARN'
+      status: improvement > 50 ? 'PASS' : 'WARN',
     });
 
-    console.log(`  ✅ Batch: ${batchTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`);
+    console.log(
+      `  ✅ Batch: ${batchTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`,
+    );
 
     await hiveMind.shutdown();
   }
@@ -93,13 +95,13 @@ export class PerformanceTest {
     console.log('⚡ Testing Async Operation Queue...');
 
     const optimizer = new PerformanceOptimizer({
-      asyncQueueConcurrency: 5
+      asyncQueueConcurrency: 5,
     });
 
     const operations = [];
     for (let i = 0; i < 20; i++) {
       operations.push(async () => {
-        await new Promise(resolve => setTimeout(resolve, Math.random() * 100 + 50));
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 + 50));
         return `Operation ${i} completed`;
       });
     }
@@ -107,7 +109,7 @@ export class PerformanceTest {
     // Test parallel execution
     const parallelStart = performance.now();
     const parallelResults = await Promise.all(
-      operations.map(op => optimizer.optimizeAsyncOperation(op))
+      operations.map((op) => optimizer.optimizeAsyncOperation(op)),
     );
     const parallelTime = performance.now() - parallelStart;
 
@@ -119,7 +121,7 @@ export class PerformanceTest {
     }
     const sequentialTime = performance.now() - sequentialStart;
 
-    const improvement = ((sequentialTime - parallelTime) / sequentialTime * 100).toFixed(2);
+    const improvement = (((sequentialTime - parallelTime) / sequentialTime) * 100).toFixed(2);
 
     this.results.push({
       test: 'Async Operation Queue',
@@ -127,10 +129,12 @@ export class PerformanceTest {
       sequentialTime: sequentialTime.toFixed(2) + 'ms',
       improvement: improvement + '%',
       operationsProcessed: operations.length,
-      status: improvement > 60 ? 'PASS' : 'WARN'
+      status: improvement > 60 ? 'PASS' : 'WARN',
     });
 
-    console.log(`  ✅ Parallel: ${parallelTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`);
+    console.log(
+      `  ✅ Parallel: ${parallelTime.toFixed(2)}ms | Sequential: ${sequentialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`,
+    );
 
     await optimizer.close();
   }
@@ -144,12 +148,14 @@ export class PerformanceTest {
     // 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}` };
-    });
+    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;
@@ -157,11 +163,11 @@ export class PerformanceTest {
     // Simulate without pooling
     const serialStart = performance.now();
     for (let i = 0; i < 100; i++) {
-      await new Promise(resolve => setTimeout(resolve, Math.random() * 15 + 5));
+      await new Promise((resolve) => setTimeout(resolve, Math.random() * 15 + 5));
     }
     const serialTime = performance.now() - serialStart;
 
-    const improvement = ((serialTime - pooledTime) / serialTime * 100).toFixed(2);
+    const improvement = (((serialTime - pooledTime) / serialTime) * 100).toFixed(2);
 
     this.results.push({
       test: 'Memory Operations',
@@ -169,10 +175,12 @@ export class PerformanceTest {
       serialTime: serialTime.toFixed(2) + 'ms',
       improvement: improvement + '%',
       operationsProcessed: 100,
-      status: improvement > 25 ? 'PASS' : 'WARN'
+      status: improvement > 25 ? 'PASS' : 'WARN',
     });
 
-    console.log(`  ✅ Pooled: ${pooledTime.toFixed(2)}ms | Serial: ${serialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`);
+    console.log(
+      `  ✅ Pooled: ${pooledTime.toFixed(2)}ms | Serial: ${serialTime.toFixed(2)}ms | Improvement: ${improvement}%\n`,
+    );
   }
 
   /**
@@ -183,7 +191,7 @@ export class PerformanceTest {
 
     const hiveMind = new HiveMindCore({
       name: 'test-concurrent-tasks',
-      maxWorkers: 8
+      maxWorkers: 8,
     });
 
     await hiveMind.initialize();
@@ -197,20 +205,20 @@ export class PerformanceTest {
       'Analyze performance metrics',
       'Research best practices',
       'Optimize database queries',
-      'Document API endpoints'
+      '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)
+    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));
-    
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
     const concurrentTime = performance.now() - concurrentStart;
 
     // Get final status
@@ -222,10 +230,12 @@ export class PerformanceTest {
       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'
+      status: status.tasks.total === tasks.length ? 'PASS' : 'WARN',
     });
 
-    console.log(`  ✅ Tasks: ${status.tasks.total} | Workers: ${status.workers.length} | Time: ${concurrentTime.toFixed(2)}ms\n`);
+    console.log(
+      `  ✅ Tasks: ${status.tasks.total} | Workers: ${status.workers.length} | Time: ${concurrentTime.toFixed(2)}ms\n`,
+    );
 
     await hiveMind.shutdown();
   }
@@ -239,7 +249,7 @@ export class PerformanceTest {
     const optimizer = new PerformanceOptimizer({
       enableAsyncQueue: true,
       enableBatchProcessing: true,
-      enableAutoTuning: true
+      enableAutoTuning: true,
     });
 
     // Test cache optimization
@@ -251,7 +261,7 @@ export class PerformanceTest {
     const cacheStart = performance.now();
     await optimizer.optimizeWithCache(cacheKey, async () => {
       cacheMisses++;
-      await new Promise(resolve => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, 100));
       return 'cached-value';
     });
 
@@ -259,7 +269,7 @@ export class PerformanceTest {
     for (let i = 0; i < 5; i++) {
       await optimizer.optimizeWithCache(cacheKey, async () => {
         cacheMisses++;
-        await new Promise(resolve => setTimeout(resolve, 100));
+        await new Promise((resolve) => setTimeout(resolve, 100));
         return 'cached-value';
       });
       cacheHits++;
@@ -269,17 +279,17 @@ export class PerformanceTest {
     // 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 new Promise((resolve) => setTimeout(resolve, 50));
+            return items.map((item) => ({ processed: item.id }));
+          },
+        ),
       );
     }
 
@@ -294,10 +304,12 @@ export class PerformanceTest {
       cacheHitRate: ((cacheHits / (cacheHits + cacheMisses)) * 100).toFixed(2) + '%',
       batchTime: batchTime.toFixed(2) + 'ms',
       batchesProcessed: stats.batchProcessor.batchesProcessed,
-      status: stats.cache.hitRate > 50 ? 'PASS' : 'WARN'
+      status: stats.cache.hitRate > 50 ? 'PASS' : 'WARN',
     });
 
-    console.log(`  ✅ Cache Hit Rate: ${((cacheHits / (cacheHits + cacheMisses)) * 100).toFixed(2)}% | Batches: ${stats.batchProcessor.batchesProcessed}\n`);
+    console.log(
+      `  ✅ Cache Hit Rate: ${((cacheHits / (cacheHits + cacheMisses)) * 100).toFixed(2)}% | Batches: ${stats.batchProcessor.batchesProcessed}\n`,
+    );
 
     await optimizer.close();
   }
@@ -307,7 +319,7 @@ export class PerformanceTest {
    */
   generateReport() {
     console.log('📊 Performance Test Results');
-    console.log('=' .repeat(80));
+    console.log('='.repeat(80));
 
     let totalPassed = 0;
     let totalTests = this.results.length;
@@ -315,22 +327,22 @@ export class PerformanceTest {
     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 {
@@ -339,9 +351,9 @@ export class PerformanceTest {
 
     // Performance summary
     const improvements = this.results
-      .filter(r => r.improvement)
-      .map(r => parseFloat(r.improvement));
-    
+      .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)}%`);
@@ -358,4 +370,4 @@ export default PerformanceTest;
 if (import.meta.url === `file://${process.argv[1]}`) {
   const testRunner = new PerformanceTest();
   testRunner.runTestSuite().catch(console.error);
-}
+}