claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/install/installation-benchmark.js

@@ -1,461 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Installation Time Benchmark
- *
- * Measures actual installation time from scratch
- * Target: <5 minutes for novice users
- */
-
-import { execSync, spawn } from 'child_process';
-import { existsSync, rmSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import chalk from 'chalk';
-import ora from 'ora';
-
-class InstallationBenchmark {
-  constructor(options = {}) {
-    this.iterations = options.iterations || 3;
-    this.cleanInstall = options.cleanInstall !== false;
-    this.verbose = options.verbose || false;
-    this.targetTimeMs = 5 * 60 * 1000; // 5 minutes
-    this.results = [];
-  }
-
-  async run() {
-    console.log(chalk.blue.bold('📊 Installation Benchmark\n'));
-    console.log(chalk.gray(`Running ${this.iterations} installation iterations`));
-    console.log(chalk.gray(`Target: Complete installation in under 5 minutes\n`));
-
-    for (let i = 0; i < this.iterations; i++) {
-      console.log(chalk.cyan(`\n━━━ Iteration ${i + 1}/${this.iterations} ━━━\n`));
-
-      const result = await this.runSingleBenchmark(i + 1);
-      this.results.push(result);
-
-      // Display immediate result
-      this.displayIterationResult(result);
-
-      // Wait between iterations
-      if (i < this.iterations - 1) {
-        console.log(chalk.gray('\n⏳ Waiting 10 seconds before next iteration...\n'));
-        await this.sleep(10000);
-      }
-    }
-
-    // Display summary
-    this.displaySummary();
-
-    return this.results;
-  }
-
-  async runSingleBenchmark(iteration) {
-    const testDir = join(tmpdir(), `claude-flow-bench-${Date.now()}`);
-    const phases = {};
-    const startTime = Date.now();
-
-    try {
-      // Phase 0: Environment setup
-      const phase0Start = Date.now();
-      if (this.cleanInstall) {
-        mkdirSync(testDir, { recursive: true });
-        process.chdir(testDir);
-      }
-      phases.setup = Date.now() - phase0Start;
-
-      // Phase 1: Dependency checks (parallel)
-      const phase1Start = Date.now();
-      const dependencies = await this.checkDependencies();
-      phases.dependencies = Date.now() - phase1Start;
-
-      // Phase 2: Redis installation
-      const phase2Start = Date.now();
-      const redis = await this.measureRedisInstall();
-      phases.redis = Date.now() - phase2Start;
-
-      // Phase 3: Quick-start configuration
-      const phase3Start = Date.now();
-      await this.measureQuickConfig();
-      phases.config = Date.now() - phase3Start;
-
-      // Phase 4: Template deployment
-      const phase4Start = Date.now();
-      await this.measureTemplateDeployment();
-      phases.templates = Date.now() - phase4Start;
-
-      // Phase 5: Validation
-      const phase5Start = Date.now();
-      await this.measureValidation();
-      phases.validation = Date.now() - phase5Start;
-
-      const totalTime = Date.now() - startTime;
-
-      return {
-        iteration,
-        success: true,
-        totalTime,
-        targetMet: totalTime < this.targetTimeMs,
-        phases,
-        dependencies,
-        redis,
-        testDir
-      };
-    } catch (error) {
-      const totalTime = Date.now() - startTime;
-
-      return {
-        iteration,
-        success: false,
-        error: error.message,
-        totalTime,
-        targetMet: false,
-        phases,
-        testDir
-      };
-    } finally {
-      // Cleanup
-      if (this.cleanInstall && existsSync(testDir)) {
-        try {
-          process.chdir(tmpdir());
-          rmSync(testDir, { recursive: true, force: true });
-        } catch (cleanupError) {
-          console.warn(chalk.yellow(`⚠️  Cleanup warning: ${cleanupError.message}`));
-        }
-      }
-    }
-  }
-
-  async checkDependencies() {
-    const checks = {
-      node: this.checkCommand('node --version'),
-      npm: this.checkCommand('npm --version'),
-      redis: this.checkCommand('redis-cli --version'),
-      docker: this.checkCommand('docker --version')
-    };
-
-    const results = {};
-    for (const [name, promise] of Object.entries(checks)) {
-      results[name] = await promise;
-    }
-
-    return results;
-  }
-
-  async checkCommand(command) {
-    const start = Date.now();
-    try {
-      const output = execSync(command, {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 5000
-      }).trim();
-
-      return {
-        available: true,
-        version: output,
-        time: Date.now() - start
-      };
-    } catch (error) {
-      return {
-        available: false,
-        time: Date.now() - start
-      };
-    }
-  }
-
-  async measureRedisInstall() {
-    const start = Date.now();
-
-    try {
-      // Check if Redis is already running
-      try {
-        execSync('redis-cli ping', {
-          encoding: 'utf8',
-          timeout: 2000,
-          stdio: ['pipe', 'pipe', 'pipe']
-        });
-
-        return {
-          method: 'existing',
-          time: Date.now() - start,
-          message: 'Redis already running'
-        };
-      } catch (pingError) {
-        // Redis not running, need to install/start
-      }
-
-      // Try Docker method (fastest)
-      try {
-        execSync('docker ps', { stdio: 'ignore', timeout: 2000 });
-
-        // Check if container exists
-        const existing = execSync('docker ps -a --filter name=claude-flow-bench --format "{{.Names}}"', {
-          encoding: 'utf8',
-          timeout: 2000
-        }).trim();
-
-        if (existing === 'claude-flow-bench') {
-          execSync('docker start claude-flow-bench', { stdio: 'ignore', timeout: 10000 });
-        } else {
-          execSync(
-            'docker run -d --name claude-flow-bench -p 6379:6379 redis:alpine',
-            { stdio: 'ignore', timeout: 60000 }
-          );
-        }
-
-        // Wait for Redis
-        await this.waitForRedis(20);
-
-        return {
-          method: 'docker',
-          time: Date.now() - start,
-          message: 'Redis started in Docker'
-        };
-      } catch (dockerError) {
-        return {
-          method: 'failed',
-          time: Date.now() - start,
-          error: 'Docker not available, Redis installation needed'
-        };
-      }
-    } catch (error) {
-      return {
-        method: 'error',
-        time: Date.now() - start,
-        error: error.message
-      };
-    }
-  }
-
-  async waitForRedis(maxAttempts = 20) {
-    for (let i = 0; i < maxAttempts; i++) {
-      try {
-        const response = execSync('redis-cli ping', {
-          encoding: 'utf8',
-          timeout: 2000,
-          stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-
-        if (response === 'PONG') {
-          return true;
-        }
-      } catch (error) {
-        await this.sleep(1000);
-      }
-    }
-
-    throw new Error('Redis failed to start');
-  }
-
-  async measureQuickConfig() {
-    const start = Date.now();
-
-    // Simulate minimal configuration generation
-    const config = {
-      version: '1.6.6',
-      quickStart: true,
-      redis: { host: 'localhost', port: 6379 }
-    };
-
-    return {
-      time: Date.now() - start,
-      config
-    };
-  }
-
-  async measureTemplateDeployment() {
-    const start = Date.now();
-
-    // Simulate template deployment (would write files in real scenario)
-    const templates = [
-      'CLAUDE.md',
-      '.claude/settings.json',
-      'memory/README.md',
-      'coordination/README.md'
-    ];
-
-    return {
-      time: Date.now() - start,
-      templates: templates.length
-    };
-  }
-
-  async measureValidation() {
-    const start = Date.now();
-
-    // Simulate validation checks
-    const checks = {
-      redis: await this.validateRedis(),
-      files: true,
-      config: true
-    };
-
-    return {
-      time: Date.now() - start,
-      checks
-    };
-  }
-
-  async validateRedis() {
-    try {
-      const response = execSync('redis-cli ping', {
-        encoding: 'utf8',
-        timeout: 2000,
-        stdio: ['pipe', 'pipe', 'pipe']
-      }).trim();
-
-      return response === 'PONG';
-    } catch (error) {
-      return false;
-    }
-  }
-
-  displayIterationResult(result) {
-    const totalSeconds = (result.totalTime / 1000).toFixed(1);
-    const targetSeconds = (this.targetTimeMs / 1000).toFixed(0);
-
-    if (result.success) {
-      console.log(chalk.green(`✅ Iteration ${result.iteration} completed in ${totalSeconds}s`));
-
-      if (result.targetMet) {
-        console.log(chalk.green(`   Target met! (${targetSeconds}s)`));
-      } else {
-        const overBy = ((result.totalTime - this.targetTimeMs) / 1000).toFixed(1);
-        console.log(chalk.yellow(`   Over target by ${overBy}s`));
-      }
-
-      console.log(chalk.gray('\n   Phase breakdown:'));
-      console.log(chalk.gray(`   Setup: ${(result.phases.setup / 1000).toFixed(1)}s`));
-      console.log(chalk.gray(`   Dependencies: ${(result.phases.dependencies / 1000).toFixed(1)}s`));
-      console.log(chalk.gray(`   Redis: ${(result.phases.redis / 1000).toFixed(1)}s (${result.redis.method})`));
-      console.log(chalk.gray(`   Config: ${(result.phases.config / 1000).toFixed(1)}s`));
-      console.log(chalk.gray(`   Templates: ${(result.phases.templates / 1000).toFixed(1)}s`));
-      console.log(chalk.gray(`   Validation: ${(result.phases.validation / 1000).toFixed(1)}s`));
-    } else {
-      console.log(chalk.red(`❌ Iteration ${result.iteration} failed`));
-      console.log(chalk.red(`   Error: ${result.error}`));
-      console.log(chalk.gray(`   Time before failure: ${totalSeconds}s`));
-    }
-  }
-
-  displaySummary() {
-    console.log('\n' + chalk.blue.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    console.log(chalk.blue.bold('📊 BENCHMARK SUMMARY'));
-    console.log(chalk.blue.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-
-    const successful = this.results.filter(r => r.success);
-    const targetMet = successful.filter(r => r.targetMet);
-
-    if (successful.length === 0) {
-      console.log(chalk.red('❌ All iterations failed\n'));
-      return;
-    }
-
-    // Calculate statistics
-    const times = successful.map(r => r.totalTime);
-    const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
-    const minTime = Math.min(...times);
-    const maxTime = Math.max(...times);
-
-    console.log(chalk.cyan('⏱️  Time Statistics:'));
-    console.log(`   Average: ${chalk.bold((avgTime / 1000).toFixed(1) + 's')}`);
-    console.log(`   Minimum: ${chalk.bold((minTime / 1000).toFixed(1) + 's')}`);
-    console.log(`   Maximum: ${chalk.bold((maxTime / 1000).toFixed(1) + 's')}`);
-    console.log(`   Target: ${(this.targetTimeMs / 1000).toFixed(0)}s\n`);
-
-    console.log(chalk.cyan('✅ Success Rate:'));
-    console.log(`   Completed: ${successful.length}/${this.results.length} ${chalk.gray(`(${(successful.length / this.results.length * 100).toFixed(0)}%)`)}`);
-    console.log(`   Target met: ${targetMet.length}/${successful.length} ${chalk.gray(`(${(targetMet.length / successful.length * 100).toFixed(0)}%)`)}\n`);
-
-    // Phase averages
-    const phases = ['setup', 'dependencies', 'redis', 'config', 'templates', 'validation'];
-    const phaseAvg = {};
-
-    for (const phase of phases) {
-      const phaseTimes = successful.map(r => r.phases[phase]).filter(t => t != null);
-      if (phaseTimes.length > 0) {
-        phaseAvg[phase] = phaseTimes.reduce((a, b) => a + b, 0) / phaseTimes.length;
-      }
-    }
-
-    console.log(chalk.cyan('⚙️  Phase Averages:'));
-    for (const [phase, time] of Object.entries(phaseAvg)) {
-      const pct = ((time / avgTime) * 100).toFixed(0);
-      console.log(`   ${phase.padEnd(15)}: ${(time / 1000).toFixed(1)}s ${chalk.gray(`(${pct}%)`)}`);
-    }
-    console.log();
-
-    // Redis methods
-    const redisMethods = successful.map(r => r.redis.method);
-    const redisMethodCounts = redisMethods.reduce((acc, method) => {
-      acc[method] = (acc[method] || 0) + 1;
-      return acc;
-    }, {});
-
-    console.log(chalk.cyan('🔧 Redis Installation Methods:'));
-    for (const [method, count] of Object.entries(redisMethodCounts)) {
-      console.log(`   ${method}: ${count}/${successful.length}`);
-    }
-    console.log();
-
-    // Final verdict
-    const avgSeconds = (avgTime / 1000).toFixed(1);
-    const targetSeconds = (this.targetTimeMs / 1000).toFixed(0);
-
-    if (avgTime < this.targetTimeMs) {
-      console.log(chalk.green.bold(`✅ TARGET MET: Average ${avgSeconds}s < ${targetSeconds}s target\n`));
-    } else {
-      const overBy = ((avgTime - this.targetTimeMs) / 1000).toFixed(1);
-      console.log(chalk.yellow.bold(`⚠️  TARGET EXCEEDED: Average ${avgSeconds}s > ${targetSeconds}s target (over by ${overBy}s)\n`));
-
-      // Recommendations
-      console.log(chalk.cyan('💡 Optimization Recommendations:'));
-      const slowestPhase = Object.entries(phaseAvg).sort((a, b) => b[1] - a[1])[0];
-      console.log(`   - Slowest phase: ${slowestPhase[0]} (${(slowestPhase[1] / 1000).toFixed(1)}s)`);
-
-      if (redisMethods.includes('failed') || redisMethods.includes('error')) {
-        console.log(`   - Improve Redis installation reliability`);
-      }
-
-      if (phaseAvg.redis > 60000) {
-        console.log(`   - Consider Docker-only Redis installation for speed`);
-      }
-
-      if (phaseAvg.dependencies > 10000) {
-        console.log(`   - Optimize parallel dependency checking`);
-      }
-
-      console.log();
-    }
-
-    console.log(chalk.blue.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-  }
-
-  async sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-// CLI execution
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  const options = {
-    iterations: parseInt(args.find(a => a.startsWith('--iterations='))?.split('=')[1] || '3'),
-    cleanInstall: !args.includes('--no-clean'),
-    verbose: args.includes('--verbose') || args.includes('-v')
-  };
-
-  const benchmark = new InstallationBenchmark(options);
-  benchmark.run().then(results => {
-    const avgTime = results.filter(r => r.success).reduce((sum, r) => sum + r.totalTime, 0) / results.filter(r => r.success).length;
-    const targetMet = avgTime < benchmark.targetTimeMs;
-
-    process.exit(targetMet ? 0 : 1);
-  }).catch(error => {
-    console.error(chalk.red(`\n❌ Benchmark error: ${error.message}`));
-    process.exit(1);
-  });
-}
-
-export default InstallationBenchmark;