claude-flow-novice 2.2.3 → 2.2.5

package/scripts/demo/test-autoscaling-demo.js

@@ -0,0 +1,314 @@
+/**
+ * Auto-Scaling Engine Demo and Test
+ * Demonstrates the Phase 2 Auto-Scaling Engine capabilities
+ */
+
+import AutoScalingEngine from './src/autoscaling/index.js';
+import Redis from 'ioredis';
+
+class AutoScalingDemo {
+  constructor() {
+    this.redis = new Redis();
+    this.engine = null;
+    this.demoMetrics = {
+      startTime: Date.now(),
+      tasksSubmitted: 0,
+      scaleEvents: 0,
+      efficiencyMeasurements: []
+    };
+  }
+
+  async runDemo() {
+    console.log('🚀 Phase 2 Auto-Scaling Engine Demo');
+    console.log('=====================================');
+
+    try {
+      // Initialize and start the engine
+      await this.initializeEngine();
+
+      // Run demonstration scenarios
+      await this.demonstrateBasicScaling();
+      await this.demonstratePredictiveScaling();
+      await this.demonstrateResourceOptimization();
+      await this.demonstratePerformanceBenchmarking();
+
+      // Generate final report
+      await this.generateDemoReport();
+
+    } catch (error) {
+      console.error('Demo failed:', error);
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  async initializeEngine() {
+    console.log('\n📋 Initializing Auto-Scaling Engine...');
+
+    this.engine = AutoScalingEngine.createDevelopment(); // Use development config
+
+    // Set up event listeners
+    this.engine.on('started', () => {
+      console.log('✅ Engine started successfully');
+    });
+
+    this.engine.on('taskAssigned', (data) => {
+      console.log(`📝 Task assigned: ${data.task.id} → Agent ${data.agent.id}`);
+    });
+
+    this.engine.on('scaleUp', (data) => {
+      console.log(`⬆️  Scale up: +${data.agentsAdded} agents (Pool: ${data.newPoolSize})`);
+      this.demoMetrics.scaleEvents++;
+    });
+
+    this.engine.on('scaleDown', (data) => {
+      console.log(`⬇️  Scale down: -${data.agentsRemoved} agents (Pool: ${data.newPoolSize})`);
+      this.demoMetrics.scaleEvents++;
+    });
+
+    this.engine.on('benchmarkUpdate', (data) => {
+      const efficiency = (data.results.efficiency * 100).toFixed(1);
+      const utilization = (data.results.utilization * 100).toFixed(1);
+      console.log(`📊 Performance: Efficiency ${efficiency}%, Utilization ${utilization}%`);
+      this.demoMetrics.efficiencyMeasurements.push({
+        timestamp: Date.now(),
+        efficiency: data.results.efficiency,
+        utilization: data.results.utilization
+      });
+    });
+
+    await this.engine.start();
+    console.log('✅ Engine initialized and started');
+  }
+
+  async demonstrateBasicScaling() {
+    console.log('\n🔧 Demonstrating Basic Reactive Scaling...');
+    console.log('-------------------------------------------');
+
+    // Submit a burst of tasks to trigger scale-up
+    const taskBurst = 8;
+    console.log(`Submitting ${taskBurst} tasks to trigger scale-up...`);
+
+    for (let i = 0; i < taskBurst; i++) {
+      const task = {
+        id: `basic_task_${i}`,
+        type: 'computation',
+        priority: 'normal',
+        resources: {
+          cpu: 15,
+          memory: 50,
+          duration: 30000
+        }
+      };
+
+      try {
+        await this.engine.submitTask(task);
+        this.demoMetrics.tasksSubmitted++;
+        await this.sleep(500); // Small delay between submissions
+      } catch (error) {
+        console.error(`Task ${i} failed:`, error.message);
+      }
+    }
+
+    console.log('Waiting for scaling decisions...');
+    await this.sleep(10000); // Wait for scaling to occur
+  }
+
+  async demonstratePredictiveScaling() {
+    console.log('\n🔮 Demonstrating Predictive Scaling...');
+    console.log('-----------------------------------');
+
+    // Submit tasks with varying patterns to test prediction
+    const patterns = [
+      { count: 3, interval: 1000, priority: 'high' },    // High frequency burst
+      { count: 2, interval: 2000, priority: 'normal' },  // Medium frequency
+      { count: 4, interval: 500, priority: 'low' }       // Low priority burst
+    ];
+
+    for (const pattern of patterns) {
+      console.log(`Submitting ${pattern.count} ${pattern.priority} priority tasks...`);
+
+      for (let i = 0; i < pattern.count; i++) {
+        const task = {
+          id: `predictive_task_${Date.now()}_${i}`,
+          type: 'analysis',
+          priority: pattern.priority,
+          resources: {
+            cpu: pattern.priority === 'high' ? 25 : 10,
+            memory: pattern.priority === 'high' ? 100 : 40,
+            duration: pattern.priority === 'high' ? 20000 : 45000
+          }
+        };
+
+        try {
+          await this.engine.submitTask(task);
+          this.demoMetrics.tasksSubmitted++;
+          await this.sleep(pattern.interval);
+        } catch (error) {
+          console.error(`Predictive task failed:`, error.message);
+        }
+      }
+
+      await this.sleep(5000); // Wait for prediction analysis
+    }
+  }
+
+  async demonstrateResourceOptimization() {
+    console.log('\n⚡ Demonstrating Resource Optimization...');
+    console.log('---------------------------------------');
+
+    // Submit tasks with different resource requirements
+    const resourceIntensiveTasks = [
+      {
+        id: 'cpu_intensive_1',
+        type: 'cpu_intensive',
+        priority: 'high',
+        resources: { cpu: 40, memory: 30, duration: 25000 }
+      },
+      {
+        id: 'memory_intensive_1',
+        type: 'memory_intensive',
+        priority: 'normal',
+        resources: { cpu: 10, memory: 150, duration: 35000 }
+      },
+      {
+        id: 'balanced_task_1',
+        type: 'balanced',
+        priority: 'normal',
+        resources: { cpu: 20, memory: 60, duration: 20000 }
+      }
+    ];
+
+    console.log('Submitting tasks with varying resource requirements...');
+
+    for (const task of resourceIntensiveTasks) {
+      try {
+        const result = await this.engine.submitTask(task);
+        console.log(`✅ Optimized assignment: ${task.id} → ${result.agentId}`);
+        this.demoMetrics.tasksSubmitted++;
+      } catch (error) {
+        console.error(`Resource optimization failed for ${task.id}:`, error.message);
+      }
+    }
+
+    // Wait for optimization to complete
+    await this.sleep(8000);
+  }
+
+  async demonstratePerformanceBenchmarking() {
+    console.log('\n📈 Demonstrating Performance Benchmarking...');
+    console.log('------------------------------------------');
+
+    // Get current performance metrics
+    const status = await this.engine.getStatus();
+
+    console.log('Current Performance Metrics:');
+    console.log(`  • Pool Size: ${status.components.poolManager?.poolSize || 'N/A'}`);
+    console.log(`  • Active Agents: ${status.components.poolManager?.activeAgents || 'N/A'}`);
+    console.log(`  • Efficiency: ${((status.components.performanceBenchmark?.efficiency || 0) * 100).toFixed(1)}%`);
+    console.log(`  • Utilization: ${((status.components.performanceBenchmark?.utilization || 0) * 100).toFixed(1)}%`);
+    console.log(`  • Response Time Score: ${((status.components.performanceBenchmark?.responseTime || 0) * 100).toFixed(1)}%`);
+    console.log(`  • Scaling Performance: ${((status.components.performanceBenchmark?.scalingPerformance || 0) * 100).toFixed(1)}%`);
+
+    // Test performance targets
+    const targets = {
+      efficiency: 0.40,    // 40% target
+      utilization: 0.85,   // 85% target
+      responseTime: 0.80   // 80% score target
+    };
+
+    console.log('\nTarget Achievement Analysis:');
+    for (const [metric, target] of Object.entries(targets)) {
+      const current = status.components.performanceBenchmark?.[metric] || 0;
+      const achieved = current >= target;
+      const percentage = (current * 100).toFixed(1);
+      const targetPercentage = (target * 100).toFixed(1);
+
+      console.log(`  • ${metric}: ${percentage}% (Target: ${targetPercentage}%) ${achieved ? '✅' : '❌'}`);
+    }
+
+    await this.sleep(5000);
+  }
+
+  async generateDemoReport() {
+    console.log('\n📊 Demo Performance Report');
+    console.log('===========================');
+
+    const runtime = Date.now() - this.demoMetrics.startTime;
+    const minutes = Math.floor(runtime / 60000);
+    const seconds = Math.floor((runtime % 60000) / 1000);
+
+    console.log(`Runtime: ${minutes}m ${seconds}s`);
+    console.log(`Tasks Submitted: ${this.demoMetrics.tasksSubmitted}`);
+    console.log(`Scale Events: ${this.demoMetrics.scaleEvents}`);
+
+    if (this.demoMetrics.efficiencyMeasurements.length > 0) {
+      const avgEfficiency = this.demoMetrics.efficiencyMeasurements
+        .reduce((sum, m) => sum + m.efficiency, 0) / this.demoMetrics.efficiencyMeasurements.length;
+      const avgUtilization = this.demoMetrics.efficiencyMeasurements
+        .reduce((sum, m) => sum + m.utilization, 0) / this.demoMetrics.efficiencyMeasurements.length;
+
+      console.log(`Average Efficiency: ${(avgEfficiency * 100).toFixed(1)}%`);
+      console.log(`Average Utilization: ${(avgUtilization * 100).toFixed(1)}%`);
+
+      // Check if targets were met
+      const efficiencyTargetMet = avgEfficiency >= 0.40;
+      const utilizationTargetMet = avgUtilization >= 0.85;
+
+      console.log('\nTarget Achievement:');
+      console.log(`  • 40%+ Efficiency: ${efficiencyTargetMet ? '✅ ACHIEVED' : '❌ NOT ACHIEVED'}`);
+      console.log(`  • 85%+ Utilization: ${utilizationTargetMet ? '✅ ACHIEVED' : '❌ NOT ACHIEVED'}`);
+    }
+
+    // Get final engine status
+    const finalStatus = await this.engine.getStatus();
+    console.log('\nFinal System State:');
+    console.log(`  • Pool Size: ${finalStatus.components.poolManager?.poolSize || 'N/A'}`);
+    console.log(`  • Total Tasks Processed: ${finalStatus.metrics.totalTasksProcessed}`);
+    console.log(`  • Total Scale Events: ${finalStatus.metrics.totalScaleEvents}`);
+
+    console.log('\n✅ Demo completed successfully!');
+  }
+
+  async cleanup() {
+    console.log('\n🧹 Cleaning up...');
+
+    if (this.engine) {
+      await this.engine.stop();
+    }
+
+    if (this.redis) {
+      await this.redis.quit();
+    }
+
+    console.log('✅ Cleanup completed');
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// Run the demo
+async function main() {
+  const demo = new AutoScalingDemo();
+  await demo.runDemo();
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\n🛑 Received SIGINT, shutting down gracefully...');
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.log('\n🛑 Received SIGTERM, shutting down gracefully...');
+  process.exit(0);
+});
+
+// Run if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+export default AutoScalingDemo;

package/scripts/dependency-optimizer.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+/**
+ * Dependency Optimizer
+ *
+ * Analyzes and optimizes npm dependencies for production readiness
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+class DependencyOptimizer {
+  constructor() {
+    this.packageJson = null;
+    this.findings = {
+      production: [],
+      devDependencies: [],
+      optimization: [],
+      security: []
+    };
+  }
+
+  async optimize() {
+    console.log('🔧 Dependency Optimizer');
+    console.log('='.repeat(60));
+
+    try {
+      await this.loadPackageJson();
+      await this.analyzeDependencies();
+      await this.checkSecurity();
+      await this.optimizeTree();
+      await this.generateReport();
+
+      return 0;
+    } catch (error) {
+      console.error(`❌ Optimization failed: ${error.message}`);
+      return 1;
+    }
+  }
+
+  async loadPackageJson() {
+    console.log('\n📦 Loading package.json...');
+    const packagePath = path.join(rootDir, 'package.json');
+    const content = await fs.readFile(packagePath, 'utf8');
+    this.packageJson = JSON.parse(content);
+    console.log(`✅ Loaded: ${this.packageJson.name}@${this.packageJson.version}`);
+  }
+
+  async analyzeDependencies() {
+    console.log('\n🔍 Analyzing dependencies...');
+
+    const prodCount = Object.keys(this.packageJson.dependencies || {}).length;
+    const devCount = Object.keys(this.packageJson.devDependencies || {}).length;
+
+    console.log(`   Production: ${prodCount} packages`);
+    console.log(`   Development: ${devCount} packages`);
+
+    // Check for misplaced dependencies
+    await this.checkMisplacedDependencies();
+
+    // Check for unused dependencies
+    await this.checkUnusedDependencies();
+
+    // Check for duplicate dependencies
+    await this.checkDuplicates();
+
+    // Check for outdated dependencies
+    await this.checkOutdated();
+  }
+
+  async checkMisplacedDependencies() {
+    console.log('\n   Checking for misplaced dependencies...');
+
+    const buildTools = [
+      '@babel/core', '@babel/preset-env', '@swc/cli', '@swc/core',
+      'typescript', 'ts-jest', 'babel-jest', 'jest', 'eslint', 'prettier'
+    ];
+
+    const misplaced = [];
+
+    for (const tool of buildTools) {
+      if (this.packageJson.dependencies && this.packageJson.dependencies[tool]) {
+        misplaced.push({
+          package: tool,
+          type: 'build-tool-in-production',
+          recommendation: `Move ${tool} to devDependencies`
+        });
+      }
+    }
+
+    if (misplaced.length > 0) {
+      this.findings.production.push(...misplaced);
+      console.log(`   ⚠️  ${misplaced.length} misplaced dependencies found`);
+    } else {
+      console.log('   ✅ All dependencies correctly placed');
+    }
+  }
+
+  async checkUnusedDependencies() {
+    console.log('\n   Checking for unused dependencies...');
+
+    try {
+      // This is a basic check - a full check would require tools like depcheck
+      console.log('   ℹ️  Run `npx depcheck` for comprehensive unused dependency analysis');
+    } catch (error) {
+      console.log('   ⚠️  Could not check for unused dependencies');
+    }
+  }
+
+  async checkDuplicates() {
+    console.log('\n   Checking for duplicate dependencies...');
+
+    try {
+      const output = this.runCommand('npm dedupe --dry-run');
+
+      if (output.includes('deduped')) {
+        const matches = output.match(/deduped (\d+)/);
+        const count = matches ? parseInt(matches[1]) : 0;
+
+        if (count > 0) {
+          this.findings.optimization.push({
+            type: 'duplicate-dependencies',
+            count: count,
+            recommendation: 'Run npm dedupe to remove duplicates'
+          });
+          console.log(`   ⚠️  ${count} duplicate dependencies can be optimized`);
+        } else {
+          console.log('   ✅ No duplicate dependencies');
+        }
+      } else {
+        console.log('   ✅ No duplicate dependencies');
+      }
+    } catch (error) {
+      console.log('   ⚠️  Could not check for duplicates');
+    }
+  }
+
+  async checkOutdated() {
+    console.log('\n   Checking for outdated dependencies...');
+
+    try {
+      const output = this.runCommand('npm outdated --json');
+      const outdated = JSON.parse(output || '{}');
+      const count = Object.keys(outdated).length;
+
+      if (count > 0) {
+        this.findings.optimization.push({
+          type: 'outdated-dependencies',
+          count: count,
+          packages: Object.entries(outdated).slice(0, 5).map(([name, info]) => ({
+            name,
+            current: info.current,
+            latest: info.latest
+          })),
+          recommendation: 'Update outdated dependencies with npm update'
+        });
+        console.log(`   ⚠️  ${count} outdated dependencies`);
+      } else {
+        console.log('   ✅ All dependencies up to date');
+      }
+    } catch {
+      console.log('   ✅ Dependency versions current');
+    }
+  }
+
+  async checkSecurity() {
+    console.log('\n🔒 Security Analysis...');
+
+    try {
+      const output = this.runCommand('npm audit --json');
+      const audit = JSON.parse(output);
+      const vulnerabilities = audit.metadata?.vulnerabilities || {};
+
+      const critical = vulnerabilities.critical || 0;
+      const high = vulnerabilities.high || 0;
+      const moderate = vulnerabilities.moderate || 0;
+      const low = vulnerabilities.low || 0;
+
+      console.log(`   Critical: ${critical}`);
+      console.log(`   High: ${high}`);
+      console.log(`   Moderate: ${moderate}`);
+      console.log(`   Low: ${low}`);
+
+      if (critical > 0 || high > 0) {
+        this.findings.security.push({
+          severity: 'high',
+          vulnerabilities: { critical, high, moderate, low },
+          recommendation: 'Run npm audit fix to address vulnerabilities'
+        });
+        console.log('   ❌ Critical/High vulnerabilities found!');
+      } else if (moderate > 0) {
+        this.findings.security.push({
+          severity: 'medium',
+          vulnerabilities: { critical, high, moderate, low },
+          recommendation: 'Consider updating packages with moderate vulnerabilities'
+        });
+        console.log('   ⚠️  Moderate vulnerabilities found');
+      } else {
+        console.log('   ✅ No security vulnerabilities');
+      }
+    } catch (error) {
+      console.log('   ⚠️  Could not run security audit');
+    }
+  }
+
+  async optimizeTree() {
+    console.log('\n⚡ Optimization Options...');
+
+    console.log('   Available optimizations:');
+    console.log('   • npm prune - Remove extraneous packages');
+    console.log('   • npm dedupe - Reduce duplication');
+    console.log('   • npm audit fix - Fix security issues');
+    console.log('   • npm update - Update to latest compatible versions');
+
+    const treeSize = await this.calculateTreeSize();
+    console.log(`\n   Current tree size: ${treeSize}`);
+  }
+
+  async calculateTreeSize() {
+    try {
+      const nodeModules = path.join(rootDir, 'node_modules');
+      const output = this.runCommand(`du -sh ${nodeModules}`);
+      return output.split('\t')[0];
+    } catch {
+      return 'Unknown';
+    }
+  }
+
+  async generateReport() {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 OPTIMIZATION REPORT');
+    console.log('='.repeat(60));
+
+    const totalIssues =
+      this.findings.production.length +
+      this.findings.optimization.length +
+      this.findings.security.length;
+
+    console.log(`\n📈 Summary:`);
+    console.log(`   Total Findings: ${totalIssues}`);
+    console.log(`   Production Issues: ${this.findings.production.length}`);
+    console.log(`   Optimization Opportunities: ${this.findings.optimization.length}`);
+    console.log(`   Security Issues: ${this.findings.security.length}`);
+
+    // Production Dependencies
+    if (this.findings.production.length > 0) {
+      console.log('\n🔴 Production Dependency Issues:');
+      this.findings.production.forEach(finding => {
+        console.log(`   • ${finding.package}: ${finding.recommendation}`);
+      });
+    }
+
+    // Optimizations
+    if (this.findings.optimization.length > 0) {
+      console.log('\n⚡ Optimization Opportunities:');
+      this.findings.optimization.forEach(finding => {
+        console.log(`   • ${finding.type}: ${finding.recommendation}`);
+        if (finding.packages) {
+          finding.packages.forEach(pkg => {
+            console.log(`     - ${pkg.name}: ${pkg.current} → ${pkg.latest}`);
+          });
+        }
+      });
+    }
+
+    // Security
+    if (this.findings.security.length > 0) {
+      console.log('\n🔒 Security Findings:');
+      this.findings.security.forEach(finding => {
+        console.log(`   Severity: ${finding.severity}`);
+        console.log(`   ${finding.recommendation}`);
+      });
+    }
+
+    // Recommendations
+    console.log('\n💡 Recommended Actions:');
+
+    if (this.findings.security.length > 0) {
+      console.log('   1. Run: npm audit fix');
+    }
+
+    if (this.findings.production.length > 0) {
+      console.log('   2. Move build tools to devDependencies');
+    }
+
+    if (this.findings.optimization.length > 0) {
+      console.log('   3. Run: npm dedupe && npm prune');
+      console.log('   4. Run: npm update (review changes carefully)');
+    }
+
+    if (totalIssues === 0) {
+      console.log('   ✅ Dependencies are well optimized!');
+      console.log('   Continue monitoring with regular npm outdated checks');
+    }
+
+    // Save report
+    const report = {
+      timestamp: new Date().toISOString(),
+      package: {
+        name: this.packageJson.name,
+        version: this.packageJson.version
+      },
+      findings: this.findings,
+      summary: {
+        totalIssues,
+        productionIssues: this.findings.production.length,
+        optimizationOpportunities: this.findings.optimization.length,
+        securityIssues: this.findings.security.length
+      }
+    };
+
+    const reportPath = path.join(rootDir, '.claude-flow-novice/dependency-optimization-report.json');
+    await fs.mkdir(path.dirname(reportPath), { recursive: true });
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+
+    console.log(`\n📄 Report saved: .claude-flow-novice/dependency-optimization-report.json`);
+  }
+
+  runCommand(command, options = {}) {
+    try {
+      return execSync(command, {
+        encoding: 'utf8',
+        cwd: rootDir,
+        stdio: 'pipe',
+        ...options
+      });
+    } catch (error) {
+      // Some commands (like npm outdated) return non-zero exit codes
+      return error.stdout || '';
+    }
+  }
+}
+
+// CLI Interface
+async function main() {
+  const optimizer = new DependencyOptimizer();
+  const exitCode = await optimizer.optimize();
+  process.exit(exitCode);
+}
+
+main().catch(error => {
+  console.error('❌ Fatal error:', error);
+  process.exit(1);
+});