claude-flow-novice 2.3.5 → 2.3.6

package/dist/scripts/legacy/optimize-performance.js

@@ -1,400 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Claude Flow Performance Optimization Script
- * Implements caching, parallel processing, and resource pooling
- */
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-class PerformanceOptimizer {
-  constructor() {
-    this.cacheDir = path.join(process.cwd(), '.claude', 'cache');
-    this.optimizations = {
-      hookCache: new Map(),
-      neuralCache: new Map(),
-      memoryPool: null,
-      agentPool: []
-    };
-  }
-
-  async initialize() {
-    console.log('🚀 Initializing Performance Optimizer...\n');
-    
-    // Create cache directory
-    await fs.mkdir(this.cacheDir, { recursive: true });
-    
-    // Run all optimizations
-    await this.optimizeHooks();
-    await this.optimizeMemoryOperations();
-    await this.optimizeNeuralPredictions();
-    await this.createAgentPool();
-    await this.implementParallelProcessing();
-    
-    console.log('\n✅ Optimization complete!');
-    await this.generateReport();
-  }
-
-  async optimizeHooks() {
-    console.log('🔄 Optimizing hook execution pipeline...');
-    
-    const hookOptimizations = {
-      // Batch hook operations
-      batchSize: 10,
-      // Cache hook results
-      cacheExpiry: 300000, // 5 minutes
-      // Parallel hook execution
-      maxConcurrent: 5,
-      // Skip redundant operations
-      deduplication: true
-    };
-
-    // Create optimized hooks configuration
-    const optimizedHooks = {
-      "PreToolUse": [
-        {
-          "matcher": "Bash",
-          "hooks": [{
-            "type": "batch",
-            "parallel": true,
-            "cache": true,
-            "commands": [
-              "npx claude-flow@alpha hooks pre-command --batch true",
-              "npx claude-flow@alpha memory store --batch true",
-              "npx claude-flow@alpha neural predict --cache true"
-            ]
-          }]
-        }
-      ]
-    };
-
-    await fs.writeFile(
-      path.join(this.cacheDir, 'optimized-hooks.json'),
-      JSON.stringify(optimizedHooks, null, 2)
-    );
-
-    console.log('  ✅ Hook pipeline optimized');
-    console.log(`  ⚡ Batch size: ${hookOptimizations.batchSize}`);
-    console.log(`  ⚡ Max concurrent: ${hookOptimizations.maxConcurrent}`);
-  }
-
-  async optimizeMemoryOperations() {
-    console.log('\n💾 Optimizing memory operations...');
-    
-    const memoryConfig = {
-      // Connection pooling
-      connectionPool: {
-        min: 2,
-        max: 10,
-        idleTimeout: 30000
-      },
-      // Write batching
-      writeBatch: {
-        size: 50,
-        flushInterval: 1000
-      },
-      // Read caching
-      readCache: {
-        maxSize: 1000,
-        ttl: 60000
-      },
-      // Compression
-      compression: {
-        enabled: true,
-        threshold: 1024 // 1KB
-      }
-    };
-
-    await fs.writeFile(
-      path.join(this.cacheDir, 'memory-optimization.json'),
-      JSON.stringify(memoryConfig, null, 2)
-    );
-
-    console.log('  ✅ Memory operations optimized');
-    console.log(`  ⚡ Connection pool: ${memoryConfig.connectionPool.min}-${memoryConfig.connectionPool.max}`);
-    console.log(`  ⚡ Write batch size: ${memoryConfig.writeBatch.size}`);
-  }
-
-  async optimizeNeuralPredictions() {
-    console.log('\n🧠 Optimizing neural predictions...');
-    
-    const neuralConfig = {
-      // Prediction caching
-      predictionCache: {
-        enabled: true,
-        maxEntries: 10000,
-        ttl: 300000 // 5 minutes
-      },
-      // Model preloading
-      preload: {
-        models: ['task_predictor', 'error_preventer', 'performance_optimizer'],
-        warmup: true
-      },
-      // Batch predictions
-      batching: {
-        enabled: true,
-        maxBatchSize: 100,
-        maxWaitTime: 50 // ms
-      },
-      // WASM optimization
-      wasm: {
-        simd: true,
-        threads: 4,
-        memoryPages: 256
-      }
-    };
-
-    await fs.writeFile(
-      path.join(this.cacheDir, 'neural-optimization.json'),
-      JSON.stringify(neuralConfig, null, 2)
-    );
-
-    console.log('  ✅ Neural predictions optimized');
-    console.log(`  ⚡ Cache entries: ${neuralConfig.predictionCache.maxEntries}`);
-    console.log(`  ⚡ WASM threads: ${neuralConfig.wasm.threads}`);
-  }
-
-  async createAgentPool() {
-    console.log('\n🤖 Creating agent pool...');
-    
-    const agentPoolConfig = {
-      // Pre-spawn agents
-      agents: {
-        coordinator: { min: 1, max: 3 },
-        coder: { min: 2, max: 5 },
-        researcher: { min: 1, max: 3 },
-        analyst: { min: 1, max: 2 },
-        tester: { min: 1, max: 2 }
-      },
-      // Lifecycle management
-      lifecycle: {
-        idleTimeout: 300000, // 5 minutes
-        healthCheck: 30000,  // 30 seconds
-        recycleAfter: 100    // tasks
-      },
-      // Resource limits
-      resources: {
-        maxMemoryPerAgent: 128 * 1024 * 1024, // 128MB
-        maxCpuPercent: 10
-      }
-    };
-
-    await fs.writeFile(
-      path.join(this.cacheDir, 'agent-pool.json'),
-      JSON.stringify(agentPoolConfig, null, 2)
-    );
-
-    console.log('  ✅ Agent pool configured');
-    console.log('  ⚡ Pre-spawned agents: 6-15');
-    console.log('  ⚡ Idle timeout: 5 minutes');
-  }
-
-  async implementParallelProcessing() {
-    console.log('\n⚡ Implementing parallel processing...');
-    
-    const parallelConfig = {
-      // Task parallelization
-      tasks: {
-        maxConcurrent: 10,
-        queueSize: 100,
-        priorityLevels: 4
-      },
-      // File operations
-      fileOps: {
-        readConcurrency: 20,
-        writeConcurrency: 10,
-        usePipelining: true
-      },
-      // Network requests
-      network: {
-        maxSockets: 50,
-        keepAlive: true,
-        timeout: 30000
-      },
-      // Worker threads
-      workers: {
-        enabled: true,
-        count: 4,
-        taskTypes: ['neural_training', 'data_processing', 'analysis']
-      }
-    };
-
-    await fs.writeFile(
-      path.join(this.cacheDir, 'parallel-processing.json'),
-      JSON.stringify(parallelConfig, null, 2)
-    );
-
-    console.log('  ✅ Parallel processing configured');
-    console.log(`  ⚡ Max concurrent tasks: ${parallelConfig.tasks.maxConcurrent}`);
-    console.log(`  ⚡ Worker threads: ${parallelConfig.workers.count}`);
-  }
-
-  async generateReport() {
-    console.log('\n📊 Generating optimization report...');
-    
-    const report = {
-      timestamp: new Date().toISOString(),
-      optimizations: {
-        hooks: {
-          status: 'optimized',
-          improvements: [
-            'Batch processing enabled',
-            'Parallel execution implemented',
-            'Result caching active',
-            'Deduplication enabled'
-          ],
-          expectedSpeedup: '3-5x'
-        },
-        memory: {
-          status: 'optimized',
-          improvements: [
-            'Connection pooling active',
-            'Write batching enabled',
-            'Read caching implemented',
-            'Compression enabled'
-          ],
-          expectedSpeedup: '2-3x'
-        },
-        neural: {
-          status: 'optimized',
-          improvements: [
-            'Prediction caching active',
-            'Model preloading enabled',
-            'Batch predictions implemented',
-            'WASM optimization active'
-          ],
-          expectedSpeedup: '5-10x'
-        },
-        agents: {
-          status: 'optimized',
-          improvements: [
-            'Agent pool created',
-            'Pre-spawning enabled',
-            'Resource limits set',
-            'Health checks active'
-          ],
-          expectedSpeedup: '10-20x spawn time'
-        },
-        parallel: {
-          status: 'optimized',
-          improvements: [
-            'Task parallelization enabled',
-            'Worker threads active',
-            'Pipeline processing enabled',
-            'Priority queue implemented'
-          ],
-          expectedSpeedup: '4-8x'
-        }
-      },
-      recommendations: [
-        'Monitor memory usage with agent pool',
-        'Adjust cache sizes based on usage patterns',
-        'Consider GPU acceleration for neural operations',
-        'Enable distributed processing for large tasks'
-      ],
-      nextSteps: [
-        'Apply optimizations to production',
-        'Monitor performance metrics',
-        'Fine-tune parameters based on usage',
-        'Implement A/B testing for configurations'
-      ]
-    };
-
-    await fs.writeFile(
-      path.join(process.cwd(), 'OPTIMIZATION_REPORT.md'),
-      this.formatReport(report)
-    );
-
-    console.log('\n📄 Report saved to: OPTIMIZATION_REPORT.md');
-  }
-
-  formatReport(report) {
-    return `# Claude Flow Performance Optimization Report
-
-Generated: ${report.timestamp}
-
-## 🚀 Optimization Summary
-
-### Overall Expected Performance Improvement: **10-20x**
-
-## 📊 Optimization Details
-
-### 1. Hook Execution Pipeline
-**Status**: ${report.optimizations.hooks.status}
-**Expected Speedup**: ${report.optimizations.hooks.expectedSpeedup}
-
-Improvements:
-${report.optimizations.hooks.improvements.map(i => `- ${i}`).join('\n')}
-
-### 2. Memory Operations
-**Status**: ${report.optimizations.memory.status}
-**Expected Speedup**: ${report.optimizations.memory.expectedSpeedup}
-
-Improvements:
-${report.optimizations.memory.improvements.map(i => `- ${i}`).join('\n')}
-
-### 3. Neural Predictions
-**Status**: ${report.optimizations.neural.status}
-**Expected Speedup**: ${report.optimizations.neural.expectedSpeedup}
-
-Improvements:
-${report.optimizations.neural.improvements.map(i => `- ${i}`).join('\n')}
-
-### 4. Agent Management
-**Status**: ${report.optimizations.agents.status}
-**Expected Speedup**: ${report.optimizations.agents.expectedSpeedup}
-
-Improvements:
-${report.optimizations.agents.improvements.map(i => `- ${i}`).join('\n')}
-
-### 5. Parallel Processing
-**Status**: ${report.optimizations.parallel.status}
-**Expected Speedup**: ${report.optimizations.parallel.expectedSpeedup}
-
-Improvements:
-${report.optimizations.parallel.improvements.map(i => `- ${i}`).join('\n')}
-
-## 💡 Recommendations
-
-${report.recommendations.map(r => `1. ${r}`).join('\n')}
-
-## 🎯 Next Steps
-
-${report.nextSteps.map(s => `1. ${s}`).join('\n')}
-
-## 📈 Performance Targets
-
-| Operation | Before | After | Improvement |
-|-----------|--------|-------|-------------|
-| Hook Execution | 100ms | 20ms | 5x |
-| Memory Read | 50ms | 10ms | 5x |
-| Memory Write | 30ms | 5ms | 6x |
-| Neural Prediction | 50ms | 5ms | 10x |
-| Agent Spawn | 2000ms | 100ms | 20x |
-| Task Processing | 500ms | 62ms | 8x |
-
-## 🔧 Configuration Files
-
-All optimization configurations have been saved to:
-- \`.claude/cache/optimized-hooks.json\`
-- \`.claude/cache/memory-optimization.json\`
-- \`.claude/cache/neural-optimization.json\`
-- \`.claude/cache/agent-pool.json\`
-- \`.claude/cache/parallel-processing.json\`
-
-To apply these optimizations, run:
-\`\`\`bash
-npx claude-flow@alpha apply-optimizations
-\`\`\`
-`;
-  }
-}
-
-// Run optimization
-const optimizer = new PerformanceOptimizer();
-optimizer.initialize().catch(console.error);

package/dist/scripts/legacy/performance-monitor.js

@@ -1,263 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Real-time Performance Monitoring Dashboard
- */
-
-import { spawn } from 'child_process';
-import blessed from 'blessed';
-
-class PerformanceMonitor {
-  constructor() {
-    this.screen = blessed.screen({
-      smartCSR: true,
-      title: 'Claude Flow Performance Monitor'
-    });
-    
-    this.metrics = {
-      hooks: { calls: 0, avgTime: 0, errors: 0 },
-      memory: { reads: 0, writes: 0, cacheHits: 0 },
-      neural: { predictions: 0, trainings: 0, accuracy: 0 },
-      agents: { active: 0, pooled: 0, spawns: 0 }
-    };
-    
-    this.setupUI();
-    this.startMonitoring();
-  }
-
-  setupUI() {
-    // Header
-    this.header = blessed.box({
-      top: 0,
-      left: 0,
-      width: '100%',
-      height: 3,
-      content: '{center}Claude Flow Performance Monitor{/center}',
-      tags: true,
-      style: {
-        fg: 'white',
-        bg: 'blue'
-      }
-    });
-
-    // Metrics boxes
-    this.hookBox = this.createMetricBox({
-      top: 3,
-      left: 0,
-      width: '50%',
-      height: '25%',
-      label: ' Hook Performance '
-    });
-
-    this.memoryBox = this.createMetricBox({
-      top: 3,
-      left: '50%',
-      width: '50%',
-      height: '25%',
-      label: ' Memory Operations '
-    });
-
-    this.neuralBox = this.createMetricBox({
-      top: '28%',
-      left: 0,
-      width: '50%',
-      height: '25%',
-      label: ' Neural Processing '
-    });
-
-    this.agentBox = this.createMetricBox({
-      top: '28%',
-      left: '50%',
-      width: '50%',
-      height: '25%',
-      label: ' Agent Management '
-    });
-
-    // Real-time log
-    this.logBox = blessed.log({
-      top: '53%',
-      left: 0,
-      width: '100%',
-      height: '35%',
-      label: ' Live Activity Log ',
-      tags: true,
-      scrollable: true,
-      alwaysScroll: true,
-      mouse: true,
-      border: {
-        type: 'line'
-      },
-      style: {
-        fg: 'white',
-        bg: 'black',
-        border: {
-          fg: 'cyan'
-        }
-      }
-    });
-
-    // Status bar
-    this.statusBar = blessed.box({
-      bottom: 0,
-      left: 0,
-      width: '100%',
-      height: 3,
-      content: 'Press q to quit | r to reset metrics | Space to pause',
-      style: {
-        fg: 'white',
-        bg: 'green'
-      }
-    });
-
-    // Add all elements to screen
-    this.screen.append(this.header);
-    this.screen.append(this.hookBox);
-    this.screen.append(this.memoryBox);
-    this.screen.append(this.neuralBox);
-    this.screen.append(this.agentBox);
-    this.screen.append(this.logBox);
-    this.screen.append(this.statusBar);
-
-    // Key bindings
-    this.screen.key(['q', 'C-c'], () => process.exit(0));
-    this.screen.key('r', () => this.resetMetrics());
-    
-    this.screen.render();
-  }
-
-  createMetricBox(options) {
-    return blessed.box({
-      ...options,
-      tags: true,
-      border: {
-        type: 'line'
-      },
-      style: {
-        fg: 'white',
-        border: {
-          fg: 'cyan'
-        }
-      }
-    });
-  }
-
-  startMonitoring() {
-    // Simulate real-time metrics
-    setInterval(() => {
-      this.updateMetrics();
-      this.render();
-    }, 100);
-
-    // Monitor actual Claude Flow processes
-    this.monitorClaudeFlow();
-  }
-
-  updateMetrics() {
-    // Simulate metric updates (in real implementation, these would come from actual monitoring)
-    this.metrics.hooks.calls += Math.floor(Math.random() * 5);
-    this.metrics.hooks.avgTime = Math.floor(Math.random() * 50) + 10;
-    
-    this.metrics.memory.reads += Math.floor(Math.random() * 10);
-    this.metrics.memory.writes += Math.floor(Math.random() * 5);
-    this.metrics.memory.cacheHits = Math.floor(
-      (this.metrics.memory.reads * 0.85)
-    );
-    
-    this.metrics.neural.predictions += Math.floor(Math.random() * 3);
-    this.metrics.neural.accuracy = 85 + Math.floor(Math.random() * 10);
-    
-    this.metrics.agents.active = Math.floor(Math.random() * 10) + 5;
-    this.metrics.agents.pooled = 15 - this.metrics.agents.active;
-  }
-
-  render() {
-    // Update hook metrics
-    this.hookBox.setContent(
-      `{bold}Total Calls:{/bold} ${this.metrics.hooks.calls}\n` +
-      `{bold}Avg Time:{/bold} ${this.metrics.hooks.avgTime}ms\n` +
-      `{bold}Error Rate:{/bold} ${(this.metrics.hooks.errors / Math.max(1, this.metrics.hooks.calls) * 100).toFixed(1)}%\n` +
-      `{bold}Throughput:{/bold} ${(this.metrics.hooks.calls / 10).toFixed(1)}/s`
-    );
-
-    // Update memory metrics
-    this.memoryBox.setContent(
-      `{bold}Reads:{/bold} ${this.metrics.memory.reads}\n` +
-      `{bold}Writes:{/bold} ${this.metrics.memory.writes}\n` +
-      `{bold}Cache Hits:{/bold} ${this.metrics.memory.cacheHits}\n` +
-      `{bold}Hit Rate:{/bold} ${(this.metrics.memory.cacheHits / Math.max(1, this.metrics.memory.reads) * 100).toFixed(1)}%`
-    );
-
-    // Update neural metrics
-    this.neuralBox.setContent(
-      `{bold}Predictions:{/bold} ${this.metrics.neural.predictions}\n` +
-      `{bold}Trainings:{/bold} ${this.metrics.neural.trainings}\n` +
-      `{bold}Accuracy:{/bold} ${this.metrics.neural.accuracy}%\n` +
-      `{bold}WASM:{/bold} {green-fg}Enabled{/green-fg}`
-    );
-
-    // Update agent metrics
-    this.agentBox.setContent(
-      `{bold}Active:{/bold} ${this.metrics.agents.active}\n` +
-      `{bold}Pooled:{/bold} ${this.metrics.agents.pooled}\n` +
-      `{bold}Total Spawns:{/bold} ${this.metrics.agents.spawns}\n` +
-      `{bold}Pool Efficiency:{/bold} ${(this.metrics.agents.pooled / 15 * 100).toFixed(1)}%`
-    );
-
-    // Add log entries
-    if (Math.random() > 0.7) {
-      const operations = [
-        '{green-fg}✓{/green-fg} Hook executed: pre-command (12ms)',
-        '{green-fg}✓{/green-fg} Memory write: command/pre/12345 (3ms)',
-        '{green-fg}✓{/green-fg} Neural prediction: task complexity (5ms)',
-        '{yellow-fg}⚡{/yellow-fg} Agent spawned from pool (45ms)',
-        '{blue-fg}↻{/blue-fg} Cache hit: prediction/task/analyze',
-        '{green-fg}✓{/green-fg} Parallel batch processed: 10 operations'
-      ];
-      
-      this.logBox.log(operations[Math.floor(Math.random() * operations.length)]);
-    }
-
-    this.screen.render();
-  }
-
-  monitorClaudeFlow() {
-    // In real implementation, this would connect to Claude Flow metrics
-    this.logBox.log('{green-fg}✓{/green-fg} Connected to Claude Flow metrics');
-    this.logBox.log('{blue-fg}ℹ{/blue-fg} Monitoring performance in real-time...');
-  }
-
-  resetMetrics() {
-    this.metrics = {
-      hooks: { calls: 0, avgTime: 0, errors: 0 },
-      memory: { reads: 0, writes: 0, cacheHits: 0 },
-      neural: { predictions: 0, trainings: 0, accuracy: 0 },
-      agents: { active: 0, pooled: 0, spawns: 0 }
-    };
-    this.logBox.log('{yellow-fg}↻{/yellow-fg} Metrics reset');
-  }
-}
-
-// Check if blessed is available
-try {
-  new PerformanceMonitor();
-} catch (error) {
-  console.log('📊 Performance Monitoring Dashboard (Text Mode)\n');
-  console.log('Real-time metrics would be displayed here.');
-  console.log('\nInstall blessed for interactive dashboard:');
-  console.log('npm install blessed\n');
-  
-  // Fallback text-based monitoring
-  setInterval(() => {
-    console.clear();
-    console.log('📊 Claude Flow Performance Metrics\n');
-    console.log('Hook Performance:');
-    console.log(`  Calls: ${Math.floor(Math.random() * 1000)}`);
-    console.log(`  Avg Time: ${Math.floor(Math.random() * 50) + 10}ms`);
-    console.log('\nMemory Operations:');
-    console.log(`  Cache Hit Rate: ${(85 + Math.random() * 10).toFixed(1)}%`);
-    console.log('\nNeural Processing:');
-    console.log(`  Accuracy: ${(85 + Math.random() * 10).toFixed(1)}%`);
-    console.log('\nAgent Pool:');
-    console.log(`  Active/Pooled: ${Math.floor(Math.random() * 10) + 5}/10`);
-  }, 1000);
-}