claude-flow-novice 2.3.4 → 2.3.6

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

@@ -1,314 +0,0 @@
-/**
- * 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/dist/scripts/dependency-optimizer.js

@@ -1,349 +0,0 @@
-#!/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);
-});