claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

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

@@ -24,7 +24,7 @@ class AsyncOperationQueue {
       processed: 0,
       failures: 0,
       avgProcessingTime: 0,
-      totalProcessingTime: 0
+      totalProcessingTime: 0,
     };
   }
 
@@ -36,11 +36,11 @@ class AsyncOperationQueue {
         resolve,
         reject,
         addedAt: Date.now(),
-        id: `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+        id: `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
       };
 
       // Insert based on priority (higher priority first)
-      const insertIndex = this.queue.findIndex(item => item.priority < priority);
+      const insertIndex = this.queue.findIndex((item) => item.priority < priority);
       if (insertIndex === -1) {
         this.queue.push(queueItem);
       } else {
@@ -67,10 +67,7 @@ class AsyncOperationQueue {
         setTimeout(() => reject(new Error('Operation timeout')), this.timeout);
       });
 
-      const result = await Promise.race([
-        item.operation(),
-        timeoutPromise
-      ]);
+      const result = await Promise.race([item.operation(), timeoutPromise]);
 
       const processingTime = performance.now() - startTime;
       this._updateMetrics(processingTime, true);
@@ -100,12 +97,16 @@ class AsyncOperationQueue {
   getMetrics() {
     return {
       ...this.metrics,
-      successRate: this.metrics.processed > 0 
-        ? ((this.metrics.processed - this.metrics.failures) / this.metrics.processed * 100).toFixed(2)
-        : 100,
+      successRate:
+        this.metrics.processed > 0
+          ? (
+              ((this.metrics.processed - this.metrics.failures) / this.metrics.processed) *
+              100
+            ).toFixed(2)
+          : 100,
       queueSize: this.queue.length,
       running: this.running,
-      utilization: (this.running / this.maxConcurrency * 100).toFixed(2)
+      utilization: ((this.running / this.maxConcurrency) * 100).toFixed(2),
     };
   }
 }
@@ -116,12 +117,12 @@ class AsyncOperationQueue {
 class BatchProcessor extends EventEmitter {
   constructor(config = {}) {
     super();
-    
+
     this.config = {
       maxBatchSize: config.maxBatchSize || 50,
       flushInterval: config.flushInterval || 1000,
       maxWaitTime: config.maxWaitTime || 5000,
-      ...config
+      ...config,
     };
 
     this.batches = new Map();
@@ -130,7 +131,7 @@ class BatchProcessor extends EventEmitter {
       batchesProcessed: 0,
       itemsProcessed: 0,
       avgBatchSize: 0,
-      avgProcessingTime: 0
+      avgProcessingTime: 0,
     };
 
     this._startPeriodicFlush();
@@ -141,7 +142,7 @@ class BatchProcessor extends EventEmitter {
       this.batches.set(batchKey, {
         items: [],
         processor,
-        createdAt: Date.now()
+        createdAt: Date.now(),
       });
 
       // Set timeout for this batch
@@ -173,7 +174,7 @@ class BatchProcessor extends EventEmitter {
     // Clear timer and remove from maps
     const timer = this.timers.get(batchKey);
     if (timer) clearTimeout(timer);
-    
+
     this.timers.delete(batchKey);
     this.batches.delete(batchKey);
 
@@ -187,8 +188,8 @@ class BatchProcessor extends EventEmitter {
       this.metrics.batchesProcessed++;
       this.metrics.itemsProcessed += batch.items.length;
       this.metrics.avgBatchSize = this.metrics.itemsProcessed / this.metrics.batchesProcessed;
-      this.metrics.avgProcessingTime = 
-        (this.metrics.avgProcessingTime * (this.metrics.batchesProcessed - 1) + processingTime) / 
+      this.metrics.avgProcessingTime =
+        (this.metrics.avgProcessingTime * (this.metrics.batchesProcessed - 1) + processingTime) /
         this.metrics.batchesProcessed;
 
       // Resolve individual item promises
@@ -202,14 +203,13 @@ class BatchProcessor extends EventEmitter {
         batchKey,
         itemCount: batch.items.length,
         processingTime,
-        results
+        results,
       });
 
       return results;
-
     } catch (error) {
       // Reject individual item promises
-      batch.items.forEach(item => {
+      batch.items.forEach((item) => {
         if (item._reject) {
           item._reject(error);
         }
@@ -223,7 +223,7 @@ class BatchProcessor extends EventEmitter {
   _startPeriodicFlush() {
     setInterval(() => {
       const now = Date.now();
-      
+
       for (const [batchKey, batch] of this.batches.entries()) {
         // Flush batches that have been waiting too long
         if (now - batch.createdAt > this.config.flushInterval) {
@@ -237,15 +237,17 @@ class BatchProcessor extends EventEmitter {
     return {
       ...this.metrics,
       pendingBatches: this.batches.size,
-      pendingItems: Array.from(this.batches.values())
-        .reduce((sum, batch) => sum + batch.items.length, 0)
+      pendingItems: Array.from(this.batches.values()).reduce(
+        (sum, batch) => sum + batch.items.length,
+        0,
+      ),
     };
   }
 
   close() {
     // Process all remaining batches
     const batchKeys = Array.from(this.batches.keys());
-    return Promise.all(batchKeys.map(key => this._processBatch(key)));
+    return Promise.all(batchKeys.map((key) => this._processBatch(key)));
   }
 }
 
@@ -263,18 +265,18 @@ export class PerformanceOptimizer extends EventEmitter {
       asyncQueueConcurrency: config.asyncQueueConcurrency || 10,
       batchMaxSize: config.batchMaxSize || 50,
       metricsInterval: config.metricsInterval || 30000,
-      ...config
+      ...config,
     };
 
     this.asyncQueue = new AsyncOperationQueue(
       this.config.asyncQueueConcurrency,
-      this.config.asyncTimeout || 30000
+      this.config.asyncTimeout || 30000,
     );
 
     this.batchProcessor = new BatchProcessor({
       maxBatchSize: this.config.batchMaxSize,
       flushInterval: this.config.batchFlushInterval || 1000,
-      maxWaitTime: this.config.batchMaxWaitTime || 5000
+      maxWaitTime: this.config.batchMaxWaitTime || 5000,
     });
 
     this.metrics = {
@@ -282,13 +284,13 @@ export class PerformanceOptimizer extends EventEmitter {
         asyncOperations: 0,
         batchOperations: 0,
         cacheHits: 0,
-        performanceGains: []
+        performanceGains: [],
       },
       system: {
         cpuUsage: 0,
         memoryUsage: 0,
-        throughput: 0
-      }
+        throughput: 0,
+      },
     };
 
     this.cache = new Map();
@@ -320,13 +322,13 @@ export class PerformanceOptimizer extends EventEmitter {
     }
 
     const startTime = performance.now();
-    
+
     try {
       const result = await this.asyncQueue.add(operation, options.priority || 5);
-      
+
       const executionTime = performance.now() - startTime;
       this.metrics.optimizations.asyncOperations++;
-      
+
       // Track performance gain vs baseline
       if (this.performanceBaseline) {
         const gain = Math.max(0, this.performanceBaseline.avgAsyncTime - executionTime);
@@ -356,19 +358,20 @@ export class PerformanceOptimizer extends EventEmitter {
   /**
    * Optimized caching with automatic expiration
    */
-  async optimizeWithCache(key, operation, ttl = 300000) { // 5 minutes default
+  async optimizeWithCache(key, operation, ttl = 300000) {
+    // 5 minutes default
     const cached = this.cache.get(key);
-    
+
     if (cached && Date.now() - cached.timestamp < ttl) {
       this.metrics.optimizations.cacheHits++;
       return cached.value;
     }
 
     const result = await operation();
-    
+
     this.cache.set(key, {
       value: result,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     });
 
     // Clean old cache entries periodically
@@ -384,17 +387,17 @@ export class PerformanceOptimizer extends EventEmitter {
    */
   async optimizeMemoryOperation(operation, connectionPool) {
     const startTime = performance.now();
-    
+
     let connection = null;
     try {
       connection = await connectionPool.acquire();
       const result = await operation(connection);
-      
+
       const executionTime = performance.now() - startTime;
-      
+
       // Track connection efficiency
-      this.metrics.system.throughput = 
-        (this.metrics.system.throughput * 0.9) + (1000 / executionTime * 0.1);
+      this.metrics.system.throughput =
+        this.metrics.system.throughput * 0.9 + (1000 / executionTime) * 0.1;
 
       return result;
     } finally {
@@ -413,11 +416,7 @@ export class PerformanceOptimizer extends EventEmitter {
     const results = [];
 
     for (const group of groups) {
-      const batchResult = await this.optimizeBatchOperation(
-        'agent_spawn',
-        group,
-        spawnFunction
-      );
+      const batchResult = await this.optimizeBatchOperation('agent_spawn', group, spawnFunction);
       results.push(...(Array.isArray(batchResult) ? batchResult : [batchResult]));
     }
 
@@ -431,13 +430,13 @@ export class PerformanceOptimizer extends EventEmitter {
     const complexity = {
       low: ['coordinator'],
       medium: ['coder', 'tester', 'documenter'],
-      high: ['researcher', 'analyst', 'architect', 'optimizer', 'reviewer']
+      high: ['researcher', 'analyst', 'architect', 'optimizer', 'reviewer'],
     };
 
     const groups = [];
-    
+
     Object.entries(complexity).forEach(([level, types]) => {
-      const groupAgents = agentTypes.filter(type => types.includes(type));
+      const groupAgents = agentTypes.filter((type) => types.includes(type));
       if (groupAgents.length > 0) {
         groups.push(groupAgents);
       }
@@ -456,24 +455,27 @@ export class PerformanceOptimizer extends EventEmitter {
     // Adjust async queue concurrency based on utilization
     if (queueMetrics.utilization > 90 && this.asyncQueue.maxConcurrency < 20) {
       this.asyncQueue.maxConcurrency += 2;
-      this.emit('auto_tune', { 
-        type: 'concurrency_increased', 
-        newValue: this.asyncQueue.maxConcurrency 
+      this.emit('auto_tune', {
+        type: 'concurrency_increased',
+        newValue: this.asyncQueue.maxConcurrency,
       });
     } else if (queueMetrics.utilization < 30 && this.asyncQueue.maxConcurrency > 5) {
       this.asyncQueue.maxConcurrency = Math.max(5, this.asyncQueue.maxConcurrency - 1);
-      this.emit('auto_tune', { 
-        type: 'concurrency_decreased', 
-        newValue: this.asyncQueue.maxConcurrency 
+      this.emit('auto_tune', {
+        type: 'concurrency_decreased',
+        newValue: this.asyncQueue.maxConcurrency,
       });
     }
 
     // Adjust batch sizes based on processing efficiency
     if (batchMetrics.avgBatchSize > 30 && batchMetrics.avgProcessingTime > 5000) {
-      this.batchProcessor.config.maxBatchSize = Math.max(20, this.batchProcessor.config.maxBatchSize - 5);
-      this.emit('auto_tune', { 
-        type: 'batch_size_decreased', 
-        newValue: this.batchProcessor.config.maxBatchSize 
+      this.batchProcessor.config.maxBatchSize = Math.max(
+        20,
+        this.batchProcessor.config.maxBatchSize - 5,
+      );
+      this.emit('auto_tune', {
+        type: 'batch_size_decreased',
+        newValue: this.batchProcessor.config.maxBatchSize,
       });
     }
   }
@@ -484,11 +486,11 @@ export class PerformanceOptimizer extends EventEmitter {
   _cleanCache() {
     const now = Date.now();
     const entries = Array.from(this.cache.entries());
-    
+
     // Remove oldest 20% of entries
     entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
     const toRemove = Math.floor(entries.length * 0.2);
-    
+
     for (let i = 0; i < toRemove; i++) {
       this.cache.delete(entries[i][0]);
     }
@@ -504,8 +506,10 @@ export class PerformanceOptimizer extends EventEmitter {
 
     // Estimate throughput based on recent operations
     const queueMetrics = this.asyncQueue.getMetrics();
-    this.metrics.system.throughput = queueMetrics.processed > 0 ? 
-      (queueMetrics.processed / (queueMetrics.avgProcessingTime / 1000)).toFixed(2) : 0;
+    this.metrics.system.throughput =
+      queueMetrics.processed > 0
+        ? (queueMetrics.processed / (queueMetrics.avgProcessingTime / 1000)).toFixed(2)
+        : 0;
   }
 
   /**
@@ -518,11 +522,16 @@ export class PerformanceOptimizer extends EventEmitter {
       batchProcessor: this.batchProcessor.getMetrics(),
       cache: {
         size: this.cache.size,
-        hitRate: this.metrics.optimizations.cacheHits > 0 ? 
-          (this.metrics.optimizations.cacheHits / 
-           (this.metrics.optimizations.asyncOperations + this.metrics.optimizations.cacheHits) * 100).toFixed(2) 
-          : 0
-      }
+        hitRate:
+          this.metrics.optimizations.cacheHits > 0
+            ? (
+                (this.metrics.optimizations.cacheHits /
+                  (this.metrics.optimizations.asyncOperations +
+                    this.metrics.optimizations.cacheHits)) *
+                100
+              ).toFixed(2)
+            : 0,
+      },
     };
   }
 
@@ -540,7 +549,7 @@ export class PerformanceOptimizer extends EventEmitter {
         priority: 'high',
         message: 'Consider increasing async queue concurrency',
         currentValue: this.asyncQueue.maxConcurrency,
-        suggestedValue: this.asyncQueue.maxConcurrency + 3
+        suggestedValue: this.asyncQueue.maxConcurrency + 3,
       });
     }
 
@@ -549,7 +558,7 @@ export class PerformanceOptimizer extends EventEmitter {
         type: 'caching',
         priority: 'medium',
         message: 'Cache hit rate is low, consider increasing cache TTL or size',
-        currentHitRate: stats.cache.hitRate
+        currentHitRate: stats.cache.hitRate,
       });
     }
 
@@ -558,7 +567,7 @@ export class PerformanceOptimizer extends EventEmitter {
         type: 'batching',
         priority: 'medium',
         message: 'Batch sizes are small, consider increasing batch wait time',
-        avgBatchSize: stats.batchProcessor.avgBatchSize
+        avgBatchSize: stats.batchProcessor.avgBatchSize,
       });
     }
 
@@ -571,9 +580,9 @@ export class PerformanceOptimizer extends EventEmitter {
         keyMetrics: {
           throughput: stats.optimizer.system.throughput,
           efficiency: stats.asyncQueue.successRate,
-          utilization: stats.asyncQueue.utilization
-        }
-      }
+          utilization: stats.asyncQueue.utilization,
+        },
+      },
     };
   }
 
@@ -585,11 +594,11 @@ export class PerformanceOptimizer extends EventEmitter {
       Math.min(100, parseFloat(stats.asyncQueue.successRate)),
       Math.min(100, 100 - parseFloat(stats.asyncQueue.utilization)), // Lower utilization is better
       Math.min(100, parseFloat(stats.cache.hitRate)),
-      Math.min(100, stats.batchProcessor.avgBatchSize / this.config.batchMaxSize * 100)
+      Math.min(100, (stats.batchProcessor.avgBatchSize / this.config.batchMaxSize) * 100),
     ];
 
     const avgScore = factors.reduce((sum, score) => sum + score, 0) / factors.length;
-    
+
     if (avgScore >= 80) return 'excellent';
     if (avgScore >= 60) return 'good';
     if (avgScore >= 40) return 'fair';
@@ -606,4 +615,4 @@ export class PerformanceOptimizer extends EventEmitter {
   }
 }
 
-export default PerformanceOptimizer;
+export default PerformanceOptimizer;