claude-flow-novice 2.3.1 → 2.3.3

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

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