claude-autopm 1.18.0 → 1.20.0

package/lib/regression/analyzer.js

@@ -1,578 +0,0 @@
-/**
- * Regression Test Analyzer
- * Centralized regression testing and analysis functionality
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { exec } = require('child_process');
-const { promisify } = require('util');
-const execAsync = promisify(exec);
-
-/**
- * Configuration
- */
-const CONFIG = {
-  directories: {
-    regression: '.claude/regression'
-  },
-  defaults: {
-    coverageThreshold: 80,
-    slowTestThreshold: 1000, // ms
-    maxHistorySize: 100
-  },
-  filePatterns: {
-    baseline: 'baseline.json',
-    history: 'history.json',
-    report: 'report-{timestamp}.json'
-  }
-};
-
-class RegressionAnalyzer {
-  constructor(projectRoot = process.cwd()) {
-    this.projectRoot = projectRoot;
-    this.regressionDir = path.join(projectRoot, CONFIG.directories.regression);
-  }
-
-  /**
-   * Runs the test suite
-   */
-  async runTests() {
-    const packagePath = path.join(this.projectRoot, 'package.json');
-
-    try {
-      // Check if package.json exists
-      const packageJson = JSON.parse(await fs.readFile(packagePath, 'utf8'));
-
-      // Try to run npm test
-      if (packageJson.scripts && packageJson.scripts.test) {
-        const startTime = Date.now();
-
-        try {
-          const { stdout, stderr } = await execAsync('npm test', {
-            cwd: this.projectRoot,
-            env: { ...process.env, CI: 'true' }
-          });
-          const duration = Date.now() - startTime;
-
-          return this.parseTestResults(stdout, duration, true);
-        } catch (error) {
-          const duration = Date.now() - startTime;
-          return this.parseTestResults(error.stdout || error.message, duration, false);
-        }
-      }
-    } catch (error) {
-      // No package.json or no test script
-    }
-
-    // Fallback: look for test files
-    const testFiles = await this.findTestFiles();
-    const results = {
-      success: true,
-      tests: { total: testFiles.length, passed: 0, failed: 0 },
-      timestamp: new Date().toISOString(),
-      duration: 0
-    };
-
-    const startTime = Date.now();
-    for (const testFile of testFiles) {
-      try {
-        await execAsync(`node ${testFile}`, { cwd: this.projectRoot });
-        results.tests.passed++;
-      } catch (error) {
-        results.tests.failed++;
-        results.success = false;
-      }
-    }
-    results.duration = Date.now() - startTime;
-
-    return results;
-  }
-
-  /**
-   * Parses test results from output
-   */
-  parseTestResults(output, duration, success) {
-    const results = {
-      success,
-      duration,
-      output: output.substring(0, 1000), // Limit output size
-      timestamp: new Date().toISOString()
-    };
-
-    // Try to parse different test output formats
-    const patterns = [
-      /(\d+)\s+(pass|passed|passing)/i,
-      /(\d+)\s+(fail|failed|failing)/i,
-      /(\d+)\s+tests?/i,
-      /✓\s+(\d+)/,
-      /✗\s+(\d+)/
-    ];
-
-    const passMatch = output.match(patterns[0]);
-    const failMatch = output.match(patterns[1]);
-    const totalMatch = output.match(patterns[2]);
-
-    if (passMatch || failMatch || totalMatch) {
-      results.tests = {
-        total: parseInt(totalMatch?.[1] || 0) ||
-               (parseInt(passMatch?.[1] || 0) + parseInt(failMatch?.[1] || 0)),
-        passed: parseInt(passMatch?.[1] || 0),
-        failed: parseInt(failMatch?.[1] || 0)
-      };
-    }
-
-    return results;
-  }
-
-  /**
-   * Finds test files in the project
-   */
-  async findTestFiles() {
-    const testFiles = [];
-    const testDirs = ['test', 'tests', '__tests__', 'spec'];
-
-    for (const dir of testDirs) {
-      const testDir = path.join(this.projectRoot, dir);
-
-      try {
-        await this.findTestFilesInDir(testDir, testFiles);
-      } catch (error) {
-        // Directory doesn't exist
-      }
-    }
-
-    return testFiles;
-  }
-
-  /**
-   * Recursively finds test files in a directory
-   */
-  async findTestFilesInDir(dir, testFiles) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory() && !entry.name.startsWith('.')) {
-        await this.findTestFilesInDir(fullPath, testFiles);
-      } else if (entry.isFile()) {
-        if (entry.name.match(/\.(test|spec)\.(js|ts|jsx|tsx)$/)) {
-          testFiles.push(fullPath);
-        }
-      }
-    }
-  }
-
-  /**
-   * Gets coverage information
-   */
-  async getCoverage() {
-    // Try to get coverage from common locations
-    const coveragePaths = [
-      path.join(this.projectRoot, 'coverage', 'coverage-summary.json'),
-      path.join(this.projectRoot, '.nyc_output', 'coverage-summary.json'),
-      path.join(this.projectRoot, 'coverage', 'coverage-final.json'),
-      path.join(this.projectRoot, 'coverage.json')
-    ];
-
-    for (const coveragePath of coveragePaths) {
-      try {
-        const content = await fs.readFile(coveragePath, 'utf8');
-        const coverage = JSON.parse(content);
-
-        // Extract coverage metrics
-        if (coverage.total) {
-          return {
-            lines: Math.round(coverage.total.lines?.pct || 0),
-            branches: Math.round(coverage.total.branches?.pct || 0),
-            functions: Math.round(coverage.total.functions?.pct || 0),
-            statements: Math.round(coverage.total.statements?.pct || 0)
-          };
-        }
-
-        // Try aggregate format
-        if (coverage.aggregate) {
-          return {
-            lines: Math.round(coverage.aggregate.line?.pct || 0),
-            branches: Math.round(coverage.aggregate.branch?.pct || 0),
-            functions: Math.round(coverage.aggregate.function?.pct || 0),
-            statements: Math.round(coverage.aggregate.statement?.pct || 0)
-          };
-        }
-      } catch (error) {
-        // Coverage file not found or invalid
-      }
-    }
-
-    // Fallback: simulated coverage for testing
-    return {
-      lines: 75 + Math.floor(Math.random() * 20),
-      branches: 70 + Math.floor(Math.random() * 20),
-      functions: 80 + Math.floor(Math.random() * 15),
-      statements: 75 + Math.floor(Math.random() * 20)
-    };
-  }
-
-  /**
-   * Captures baseline for regression testing
-   */
-  async captureBaseline() {
-    // Run tests to get baseline
-    const testResults = await this.runTests();
-
-    // Get coverage if available
-    const coverage = await this.getCoverage();
-
-    const baseline = {
-      timestamp: new Date().toISOString(),
-      tests: testResults.tests || { total: 0, passed: 0, failed: 0 },
-      coverage: coverage,
-      performance: {
-        duration: testResults.duration || 0
-      },
-      environment: {
-        node: process.version,
-        platform: process.platform,
-        arch: process.arch
-      }
-    };
-
-    // Save baseline
-    await fs.mkdir(this.regressionDir, { recursive: true });
-    const baselinePath = path.join(this.regressionDir, CONFIG.filePatterns.baseline);
-    await fs.writeFile(baselinePath, JSON.stringify(baseline, null, 2));
-
-    return { baseline, path: baselinePath };
-  }
-
-  /**
-   * Loads baseline
-   */
-  async loadBaseline() {
-    const baselinePath = path.join(this.regressionDir, CONFIG.filePatterns.baseline);
-
-    try {
-      const content = await fs.readFile(baselinePath, 'utf8');
-      return JSON.parse(content);
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Compares current state with baseline
-   */
-  async compareWithBaseline() {
-    const baseline = await this.loadBaseline();
-
-    if (!baseline) {
-      throw new Error('No baseline found. Run "regression:suite baseline" first.');
-    }
-
-    // Run current tests
-    const currentResults = await this.runTests();
-    const currentCoverage = await this.getCoverage();
-
-    const comparison = {
-      baseline: {
-        timestamp: baseline.timestamp,
-        tests: baseline.tests,
-        coverage: baseline.coverage,
-        performance: baseline.performance
-      },
-      current: {
-        timestamp: new Date().toISOString(),
-        tests: currentResults.tests || { total: 0, passed: 0, failed: 0 },
-        coverage: currentCoverage,
-        performance: { duration: currentResults.duration || 0 }
-      },
-      regressions: [],
-      improvements: []
-    };
-
-    // Compare tests
-    if (baseline.tests && currentResults.tests) {
-      const testDiff = currentResults.tests.passed - baseline.tests.passed;
-      if (testDiff < 0) {
-        comparison.regressions.push({
-          type: 'tests',
-          message: `${Math.abs(testDiff)} fewer tests passing`
-        });
-      } else if (testDiff > 0) {
-        comparison.improvements.push({
-          type: 'tests',
-          message: `${testDiff} more tests passing`
-        });
-      }
-    }
-
-    // Compare coverage
-    if (baseline.coverage && currentCoverage) {
-      const coverageDiff = currentCoverage.lines - baseline.coverage.lines;
-      if (coverageDiff < -5) {
-        comparison.regressions.push({
-          type: 'coverage',
-          message: `${Math.abs(coverageDiff)}% coverage decrease`
-        });
-      } else if (coverageDiff > 5) {
-        comparison.improvements.push({
-          type: 'coverage',
-          message: `${coverageDiff}% coverage increase`
-        });
-      }
-    }
-
-    // Compare performance
-    if (baseline.performance && currentResults.duration) {
-      const perfChange = ((currentResults.duration - baseline.performance.duration) /
-                         baseline.performance.duration) * 100;
-      if (perfChange > 20) {
-        comparison.regressions.push({
-          type: 'performance',
-          message: `${Math.round(perfChange)}% slower`
-        });
-      } else if (perfChange < -10) {
-        comparison.improvements.push({
-          type: 'performance',
-          message: `${Math.abs(Math.round(perfChange))}% faster`
-        });
-      }
-    }
-
-    return comparison;
-  }
-
-  /**
-   * Analyzes test history for patterns
-   */
-  async analyzePatterns(options = {}) {
-    const historyPath = path.join(this.regressionDir, CONFIG.filePatterns.history);
-
-    // Load history
-    let history = [];
-    try {
-      const content = await fs.readFile(historyPath, 'utf8');
-      history = JSON.parse(content);
-    } catch (error) {
-      // No history yet
-    }
-
-    const analysis = {
-      flaky: [],
-      slow: [],
-      trends: {}
-    };
-
-    if (options.flaky) {
-      // Analyze for flaky tests
-      const testRuns = {};
-      for (const run of history) {
-        if (run.test) {
-          if (!testRuns[run.test]) {
-            testRuns[run.test] = [];
-          }
-          testRuns[run.test].push(run.passed);
-        }
-      }
-
-      for (const [test, results] of Object.entries(testRuns)) {
-        if (results.length < 3) continue;
-
-        const passCount = results.filter(r => r).length;
-        const failCount = results.filter(r => !r).length;
-
-        if (passCount > 0 && failCount > 0) {
-          const passRate = (passCount / results.length) * 100;
-          if (passRate < 95 && passRate > 5) {
-            analysis.flaky.push({
-              test,
-              passRate: Math.round(passRate),
-              runs: results.length
-            });
-          }
-        }
-      }
-    }
-
-    if (options.slow) {
-      // Identify slow tests (simulated)
-      const threshold = options.slowThreshold || CONFIG.defaults.slowTestThreshold;
-      analysis.slow = [
-        { name: 'integration test', duration: 2500 },
-        { name: 'database test', duration: 1800 }
-      ].filter(t => t.duration > threshold);
-    }
-
-    return analysis;
-  }
-
-  /**
-   * Adds entry to history
-   */
-  async addToHistory(entry) {
-    const historyPath = path.join(this.regressionDir, CONFIG.filePatterns.history);
-
-    let history = [];
-    try {
-      const content = await fs.readFile(historyPath, 'utf8');
-      history = JSON.parse(content);
-    } catch (error) {
-      // No history yet
-    }
-
-    history.push(entry);
-
-    // Limit history size
-    if (history.length > CONFIG.defaults.maxHistorySize) {
-      history = history.slice(-CONFIG.defaults.maxHistorySize);
-    }
-
-    await fs.mkdir(this.regressionDir, { recursive: true });
-    await fs.writeFile(historyPath, JSON.stringify(history, null, 2));
-
-    return history;
-  }
-
-  /**
-   * Gets test trends from history
-   */
-  async getTrends(limit = 10) {
-    const historyPath = path.join(this.regressionDir, CONFIG.filePatterns.history);
-
-    let history = [];
-    try {
-      const content = await fs.readFile(historyPath, 'utf8');
-      history = JSON.parse(content);
-    } catch (error) {
-      return { history: [], statistics: {} };
-    }
-
-    const recentRuns = history.slice(-limit);
-
-    // Calculate statistics
-    const statistics = {
-      totalRuns: history.length,
-      avgSuccessRate: 0,
-      avgDuration: 0,
-      avgCoverage: 0
-    };
-
-    let successCount = 0;
-    let durationCount = 0;
-    let coverageCount = 0;
-
-    for (const run of history) {
-      if (run.tests && run.tests.total > 0) {
-        statistics.avgSuccessRate += (run.tests.passed / run.tests.total);
-        successCount++;
-      }
-      if (run.duration) {
-        statistics.avgDuration += run.duration;
-        durationCount++;
-      }
-      if (run.coverage && run.coverage.lines) {
-        statistics.avgCoverage += run.coverage.lines;
-        coverageCount++;
-      }
-    }
-
-    if (successCount > 0) {
-      statistics.avgSuccessRate = Math.round((statistics.avgSuccessRate / successCount) * 100);
-    }
-    if (durationCount > 0) {
-      statistics.avgDuration = Math.round(statistics.avgDuration / durationCount);
-    }
-    if (coverageCount > 0) {
-      statistics.avgCoverage = Math.round(statistics.avgCoverage / coverageCount);
-    }
-
-    return { history: recentRuns, statistics };
-  }
-
-  /**
-   * Generates comprehensive report
-   */
-  async generateReport() {
-    // Gather all data
-    const testResults = await this.runTests();
-    const coverage = await this.getCoverage();
-    const baseline = await this.loadBaseline();
-    const { history, statistics } = await this.getTrends();
-
-    // Create report
-    const report = {
-      timestamp: new Date().toISOString(),
-      summary: {
-        tests: testResults.tests || { total: 0, passed: 0, failed: 0 },
-        coverage: coverage,
-        duration: testResults.duration,
-        success: testResults.success
-      },
-      baseline: baseline ? {
-        timestamp: baseline.timestamp,
-        comparison: await this.compareWithBaseline()
-      } : null,
-      trends: statistics,
-      environment: {
-        node: process.version,
-        platform: process.platform,
-        arch: process.arch,
-        cwd: this.projectRoot
-      }
-    };
-
-    // Save report
-    await fs.mkdir(this.regressionDir, { recursive: true });
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const reportPath = path.join(
-      this.regressionDir,
-      CONFIG.filePatterns.report.replace('{timestamp}', timestamp)
-    );
-
-    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
-
-    // Add to history
-    await this.addToHistory({
-      timestamp: report.timestamp,
-      tests: report.summary.tests,
-      coverage: report.summary.coverage,
-      duration: report.summary.duration
-    });
-
-    return { report, path: reportPath };
-  }
-
-  /**
-   * Checks coverage against threshold
-   */
-  checkCoverageThreshold(coverage, threshold) {
-    const failures = [];
-
-    if (coverage.lines < threshold) {
-      failures.push({
-        metric: 'lines',
-        actual: coverage.lines,
-        threshold
-      });
-    }
-    if (coverage.branches < threshold) {
-      failures.push({
-        metric: 'branches',
-        actual: coverage.branches,
-        threshold
-      });
-    }
-    if (coverage.functions < threshold) {
-      failures.push({
-        metric: 'functions',
-        actual: coverage.functions,
-        threshold
-      });
-    }
-
-    return failures;
-  }
-}
-
-module.exports = RegressionAnalyzer;