qa360 1.4.5 → 2.0.1

package/dist/commands/regression.js

@@ -0,0 +1,340 @@
+/**
+ * QA360 Regression Command
+ *
+ * CLI command for regression detection and analysis.
+ */
+import { Command } from 'commander';
+import { createRegressionDetector, createRegressionTrendAnalyzer } from '../core/index.js';
+export const regressionCommand = new Command('regression');
+regressionCommand.description('Regression detection and analysis');
+// Detect regressions
+regressionCommand
+    .command('detect')
+    .description('Detect regressions by comparing current metrics to baseline')
+    .option('--baseline <file>', 'Baseline metrics JSON file')
+    .option('--current <file>', 'Current metrics JSON file')
+    .option('--run-id <id>', 'Current run ID')
+    .option('--gate <name>', 'Gate name')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const detector = createRegressionDetector();
+    // Demo: Create baseline from simulated data
+    const baselineData = [];
+    for (let i = 0; i < 30; i++) {
+        baselineData.push({
+            timestamp: Date.now() - (30 - i) * 3600000,
+            value: 100 + Math.random() * 10,
+            runId: `run_${i}`
+        });
+    }
+    detector.updateBaseline('api_latency_p95', baselineData);
+    detector.updateBaseline('pass_rate', baselineData.map(d => ({
+        ...d,
+        value: 95 + Math.random() * 3
+    })));
+    detector.updateBaseline('line_coverage', baselineData.map(d => ({
+        ...d,
+        value: 80 + Math.random() * 2
+    })));
+    // Simulate current metrics with one regression
+    const currentMetrics = {
+        api_latency_p95: 145, // 45% increase - regression!
+        pass_rate: 94,
+        line_coverage: 79.5
+    };
+    const regressions = detector.detectRegressions(currentMetrics, options.runId || 'current', options.gate || 'api_smoke');
+    if (options.json) {
+        console.log(JSON.stringify(regressions, null, 2));
+        return;
+    }
+    console.log('\n🔍 Regression Detection Results\n');
+    console.log(`Run ID: ${options.runId || 'current'}`);
+    console.log(`Gate: ${options.gate || 'api_smoke'}\n`);
+    if (regressions.length === 0) {
+        console.log('✅ No regressions detected!\n');
+        return;
+    }
+    console.log(`Detected ${regressions.length} regression(s):\n`);
+    for (const reg of regressions) {
+        const icon = getSeverityIcon(reg.severity);
+        const arrow = reg.direction === 'worse' ? '↑' : '↓';
+        const changeStr = reg.percentChange > 0 ? '+' : '';
+        console.log(`  ${icon} ${reg.metricName}`);
+        console.log(`      Type: ${reg.type}`);
+        console.log(`      Severity: ${reg.severity.toUpperCase()}`);
+        console.log(`      Baseline: ${reg.baselineValue.toFixed(2)} → Current: ${reg.currentValue.toFixed(2)}`);
+        console.log(`      Change: ${arrow} ${changeStr}${reg.percentChange.toFixed(1)}% (${reg.absoluteChange.toFixed(2)})`);
+        console.log(`      Confidence: ${(reg.confidence * 100).toFixed(1)}%`);
+        console.log(`      Component: ${reg.affectedComponent}`);
+        console.log(`      Suggestions:`);
+        for (const suggestion of reg.suggestions) {
+            console.log(`        - ${suggestion}`);
+        }
+        console.log('');
+    }
+});
+// Analyze trends
+regressionCommand
+    .command('trend')
+    .description('Analyze metric trends for potential future regressions')
+    .option('--metric <name>', 'Metric name to analyze')
+    .option('--points <n>', 'Number of data points to use', '30')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const analyzer = createRegressionTrendAnalyzer();
+    const metricName = options.metric || 'api_latency_p95';
+    // Generate demo trend data
+    const data = [];
+    for (let i = 0; i < parseInt(options.points); i++) {
+        // Slight upward trend (degrading)
+        const trend = i * 0.5;
+        const noise = (Math.random() - 0.5) * 5;
+        data.push({
+            timestamp: Date.now() - (parseInt(options.points) - i) * 3600000,
+            value: 100 + trend + noise,
+            runId: `run_${i}`,
+            metadata: { metric: metricName }
+        });
+    }
+    const trend = analyzer.analyzeTrend(data);
+    if (options.json) {
+        console.log(JSON.stringify(trend, null, 2));
+        return;
+    }
+    console.log('\n📈 Trend Analysis\n');
+    console.log(`Metric: ${metricName}`);
+    console.log(`Data Points: ${data.length}\n`);
+    if (!trend) {
+        console.log('⚠️  Insufficient data for trend analysis\n');
+        return;
+    }
+    const directionIcon = trend.direction === 'degrading' ? '📉' : trend.direction === 'improving' ? '📈' : '➡️';
+    const strengthPercent = Math.round(trend.strength * 100);
+    console.log(`  ${directionIcon} Direction: ${trend.direction.toUpperCase()}`);
+    console.log(`  Strength: ${strengthPercent}% confidence`);
+    if (trend.projected !== undefined) {
+        console.log(`  Projected (7 days): ${trend.projected.toFixed(2)}`);
+    }
+    console.log('');
+});
+// List recent regressions
+regressionCommand
+    .command('list')
+    .description('List recent regressions')
+    .option('--severity <level>', 'Filter by severity')
+    .option('--type <type>', 'Filter by type')
+    .option('--limit <n>', 'Max results', '20')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    // Demo: Generate some regressions
+    const regressions = [
+        {
+            id: 'reg_1',
+            runId: 'run_123',
+            baselineRunId: 'run_100',
+            type: 'performance',
+            severity: 'major',
+            status: 'detected',
+            metricName: 'api_latency_p95',
+            baselineValue: 100,
+            currentValue: 145,
+            absoluteChange: 45,
+            percentChange: 45,
+            significance: 0.001,
+            confidence: 0.999,
+            direction: 'worse',
+            affectedComponent: '/api/users',
+            gate: 'api_smoke',
+            suggestions: ['Investigate recent API changes', 'Profile the endpoint'],
+            timestamp: Date.now() - 3600000
+        },
+        {
+            id: 'reg_2',
+            runId: 'run_123',
+            baselineRunId: 'run_100',
+            type: 'coverage',
+            severity: 'minor',
+            status: 'detected',
+            metricName: 'line_coverage',
+            baselineValue: 82,
+            currentValue: 79.5,
+            absoluteChange: -2.5,
+            percentChange: -3.05,
+            significance: 0.03,
+            confidence: 0.97,
+            direction: 'worse',
+            affectedComponent: 'src/components/',
+            gate: 'ui',
+            suggestions: ['Review deleted test cases'],
+            timestamp: Date.now() - 3600000
+        },
+        {
+            id: 'reg_3',
+            runId: 'run_122',
+            baselineRunId: 'run_99',
+            type: 'quality',
+            severity: 'critical',
+            status: 'resolved',
+            metricName: 'pass_rate',
+            baselineValue: 98,
+            currentValue: 85,
+            absoluteChange: -13,
+            percentChange: -13.27,
+            significance: 0.0001,
+            confidence: 0.9999,
+            direction: 'worse',
+            affectedComponent: 'test/auth',
+            gate: 'unit',
+            suggestions: ['Fix authentication tests'],
+            timestamp: Date.now() - 86400000
+        }
+    ];
+    // Filter
+    let filtered = regressions;
+    if (options.severity) {
+        filtered = filtered.filter(r => r.severity === options.severity);
+    }
+    if (options.type) {
+        filtered = filtered.filter(r => r.type === options.type);
+    }
+    filtered = filtered.slice(0, parseInt(options.limit));
+    if (options.json) {
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+    console.log('\n🔍 Recent Regressions\n');
+    if (filtered.length === 0) {
+        console.log('No regressions found.\n');
+        return;
+    }
+    for (const reg of filtered) {
+        const icon = getSeverityIcon(reg.severity);
+        const statusIcon = reg.status === 'resolved' ? '✅' : reg.status === 'investigating' ? '🔬' : '❗';
+        console.log(`  ${icon} ${statusIcon} ${reg.metricName}`);
+        console.log(`      Severity: ${reg.severity.toUpperCase()} | Status: ${reg.status}`);
+        console.log(`      Type: ${reg.type} | Gate: ${reg.gate}`);
+        console.log(`      ${new Date(reg.timestamp).toISOString()}`);
+        console.log('');
+    }
+});
+// Compare two runs
+regressionCommand
+    .command('compare')
+    .description('Compare two runs for regressions')
+    .option('--baseline <runId>', 'Baseline run ID')
+    .option('--current <runId>', 'Current run ID')
+    .option('--metric <name>', 'Metric to compare')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const analyzer = createRegressionTrendAnalyzer();
+    const metricName = options.metric || 'api_latency';
+    // Generate demo data
+    const baseline = [];
+    const current = [];
+    for (let i = 0; i < 10; i++) {
+        baseline.push({
+            timestamp: Date.now() - (20 - i) * 3600000,
+            value: 100 + Math.random() * 5,
+            runId: options.baseline || `baseline_${i}`
+        });
+    }
+    for (let i = 0; i < 10; i++) {
+        current.push({
+            timestamp: Date.now() - (10 - i) * 3600000,
+            value: 120 + Math.random() * 5, // 20% higher
+            runId: options.current || `current_${i}`
+        });
+    }
+    const regression = analyzer.comparePeriods(baseline, current, metricName);
+    if (options.json) {
+        console.log(JSON.stringify(regression, null, 2));
+        return;
+    }
+    console.log('\n🔍 Regression Comparison\n');
+    console.log(`Metric: ${metricName}`);
+    console.log(`Baseline: ${options.baseline || 'baseline_*'}`);
+    console.log(`Current: ${options.current || 'current_*'}\n`);
+    if (!regression) {
+        console.log('✅ No regression detected!\n');
+        return;
+    }
+    const icon = getSeverityIcon(regression.severity);
+    console.log(`  ${icon} Regression Detected`);
+    console.log(`      Type: ${regression.type}`);
+    console.log(`      Severity: ${regression.severity.toUpperCase()}`);
+    console.log(`      Baseline: ${regression.baselineValue.toFixed(2)} → Current: ${regression.currentValue.toFixed(2)}`);
+    console.log(`      Change: ${regression.percentChange > 0 ? '+' : ''}${regression.percentChange.toFixed(1)}%`);
+    console.log(`      Confidence: ${(regression.confidence * 100).toFixed(1)}%\n`);
+});
+// Show regression statistics
+regressionCommand
+    .command('stats')
+    .description('Show regression statistics')
+    .option('--json', 'Output as JSON')
+    .action(async (_options) => {
+    // Demo statistics
+    const stats = {
+        total: 15,
+        bySeverity: {
+            critical: 2,
+            major: 3,
+            moderate: 5,
+            minor: 3,
+            info: 2
+        },
+        byType: {
+            performance: 5,
+            quality: 4,
+            coverage: 2,
+            reliability: 2,
+            security: 1,
+            api_breaking: 1
+        },
+        byStatus: {
+            detected: 5,
+            investigating: 3,
+            confirmed: 2,
+            resolved: 4,
+            ignored: 1
+        },
+        recent: 3 // Last 7 days
+    };
+    console.log('\n📊 Regression Statistics\n');
+    console.log(`Total Regressions: ${stats.total}`);
+    console.log(`Recent (7 days): ${stats.recent}\n`);
+    console.log('By Severity:');
+    for (const [severity, count] of Object.entries(stats.bySeverity)) {
+        if (count > 0) {
+            const icon = getSeverityIcon(severity);
+            console.log(`  ${icon} ${severity.toUpperCase()}: ${count}`);
+        }
+    }
+    console.log('\nBy Type:');
+    for (const [type, count] of Object.entries(stats.byType)) {
+        if (count > 0) {
+            console.log(`  • ${type}: ${count}`);
+        }
+    }
+    console.log('\nBy Status:');
+    for (const [status, count] of Object.entries(stats.byStatus)) {
+        if (count > 0) {
+            console.log(`  • ${status}: ${count}`);
+        }
+    }
+    console.log('');
+});
+function getSeverityIcon(severity) {
+    switch (severity) {
+        case 'critical':
+            return '🔴';
+        case 'major':
+            return '🟠';
+        case 'moderate':
+            return '🟡';
+        case 'minor':
+            return '🟢';
+        default:
+            return '⚪';
+    }
+}
+export default regressionCommand;

package/dist/commands/repair.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Repair Commands
+ *
+ * CLI commands for automatic test repair.
+ */
+import { Command } from 'commander';
+/**
+ * Repair analyze command
+ */
+export declare function createRepairAnalyzeCommand(): Command;
+/**
+ * Repair suggest command
+ */
+export declare function createRepairSuggestCommand(): Command;
+/**
+ * Repair fix command
+ */
+export declare function createRepairFixCommand(): Command;
+/**
+ * Repair interactive command
+ */
+export declare function createRepairInteractiveCommand(): Command;
+/**
+ * Create main repair command group
+ */
+export declare function createRepairCommand(): Command;

package/dist/commands/repair.js

@@ -0,0 +1,307 @@
+/**
+ * Repair Commands
+ *
+ * CLI commands for automatic test repair.
+ */
+import { Command } from 'commander';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { TestRepairer, analyzeTestErrors, getQuickFixes } from '../core/index.js';
+/**
+ * Parse test output to extract errors
+ */
+async function parseTestOutput(outputPath) {
+    if (!existsSync(outputPath)) {
+        return { errors: [] };
+    }
+    try {
+        const content = await readFile(outputPath, 'utf-8');
+        const errors = await analyzeTestErrors('', content);
+        return { errors };
+    }
+    catch {
+        return { errors: [] };
+    }
+}
+/**
+ * Simulate running tests and extracting errors
+ */
+async function extractErrorsFromFile(testFile) {
+    if (!existsSync(testFile)) {
+        return [];
+    }
+    try {
+        const content = await readFile(testFile, 'utf-8');
+        // Look for common error patterns in test files
+        const errors = [];
+        // This is a simplified extraction - in production would parse actual test output
+        if (content.includes('expect(') && content.includes('.toBe(')) {
+            // Find assertions that might fail
+            const lines = content.split('\n');
+            lines.forEach((line, index) => {
+                if (line.includes('expect(') && line.includes('.toBe(')) {
+                    // Create a simulated error for demonstration
+                    const match = line.match(/expect\(([^)]+)\)\.toBe\(([^)]+)\)/);
+                    if (match) {
+                        errors.push({
+                            testFile,
+                            testName: `Test at line ${index + 1}`,
+                            line: index + 1,
+                            type: 'assertion_error',
+                            message: `Expected ${match[2]} but received different value`,
+                            context: 'Assertion failed'
+                        });
+                    }
+                }
+            });
+        }
+        return errors;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Repair analyze command
+ */
+export function createRepairAnalyzeCommand() {
+    const cmd = new Command('analyze');
+    cmd
+        .description('Analyze test failures and generate repair suggestions')
+        .argument('<test-file>', 'Path to the test file')
+        .option('-o, --output <path>', 'Path to test output file')
+        .option('-p, --provider <provider>', 'LLM provider (ollama, openai, anthropic, mock)', 'ollama')
+        .option('-j, --json', 'Output in JSON format')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (testFile, options) => {
+        const filePath = resolve(testFile);
+        if (!existsSync(filePath)) {
+            console.error(`Error: Test file not found: ${filePath}`);
+            process.exit(1);
+        }
+        try {
+            // Extract errors from test output or simulate
+            let errors = [];
+            if (options.output) {
+                const result = await parseTestOutput(options.output);
+                errors = result.errors;
+            }
+            if (errors.length === 0) {
+                errors = await extractErrorsFromFile(filePath);
+            }
+            if (errors.length === 0) {
+                console.log('No test errors found to analyze.');
+                console.log('Tip: Provide test output with --output option or run tests first.');
+                return;
+            }
+            // Create repairer
+            const repairer = new TestRepairer({
+                llmProvider: options.provider,
+                verbose: options.verbose
+            });
+            // Analyze
+            const testRunResult = {
+                passed: 0,
+                failed: errors.length,
+                errors,
+                duration: 0
+            };
+            const analysis = await repairer.analyze(filePath, testRunResult);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    testFile: filePath,
+                    errorsFound: errors.length,
+                    autoFixable: analysis.autoFixable,
+                    suggestions: analysis.suggestions,
+                    priority: analysis.priority,
+                    estimatedTime: analysis.estimatedTime
+                }, null, 2));
+            }
+            else {
+                console.log(`\n=== Test Repair Analysis ===`);
+                console.log(`File: ${filePath}`);
+                console.log(`Errors found: ${errors.length}`);
+                console.log(`Auto-fixable: ${analysis.autoFixable}`);
+                console.log(`Priority: ${analysis.priority}`);
+                console.log(`Estimated repair time: ${analysis.estimatedTime}s`);
+                console.log(`\nSuggestions:`);
+                for (const suggestion of analysis.suggestions) {
+                    console.log(`\n  ${suggestion.description}`);
+                    console.log(`  Type: ${suggestion.type}`);
+                    console.log(`  Confidence: ${(suggestion.confidence * 100).toFixed(0)}%`);
+                    console.log(`  Effort: ${suggestion.estimatedEffort}`);
+                    console.log(`  Reason: ${suggestion.reason}`);
+                    if (options.verbose && suggestion.code) {
+                        console.log(`  Code:\n    ${suggestion.code}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+/**
+ * Repair suggest command
+ */
+export function createRepairSuggestCommand() {
+    const cmd = new Command('suggest');
+    cmd
+        .description('Get quick fix suggestions for a test error')
+        .argument('<test-file>', 'Path to the test file')
+        .option('-m, --message <message>', 'Error message')
+        .option('-t, --type <type>', 'Error type (assertion_error, timeout_error, etc.)')
+        .option('-l, --line <number>', 'Line number', '0')
+        .option('-j, --json', 'Output in JSON format')
+        .action(async (testFile, options) => {
+        const filePath = resolve(testFile);
+        if (!options.message) {
+            console.error('Error: --message is required');
+            process.exit(1);
+        }
+        try {
+            const error = {
+                testFile: filePath,
+                testName: 'unknown',
+                line: parseInt(options.line, 10),
+                type: options.type || 'unknown',
+                message: options.message
+            };
+            const suggestions = await getQuickFixes(error);
+            if (options.json) {
+                console.log(JSON.stringify(suggestions, null, 2));
+            }
+            else {
+                console.log(`\n=== Quick Fix Suggestions ===`);
+                console.log(`Error: ${error.message}`);
+                console.log(`Type: ${error.type}\n`);
+                if (suggestions.length === 0) {
+                    console.log('No quick fixes available for this error type.');
+                }
+                else {
+                    for (const suggestion of suggestions) {
+                        console.log(`\n${suggestion.description}`);
+                        console.log(`  Type: ${suggestion.type}`);
+                        console.log(`  Confidence: ${(suggestion.confidence * 100).toFixed(0)}%`);
+                        console.log(`  Code: ${suggestion.code}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to generate suggestions: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+/**
+ * Repair fix command
+ */
+export function createRepairFixCommand() {
+    const cmd = new Command('fix');
+    cmd
+        .description('Apply automatic fixes to failing tests')
+        .argument('<test-file>', 'Path to the test file')
+        .option('-o, --output <path>', 'Path to test output file')
+        .option('-p, --provider <provider>', 'LLM provider (ollama, openai, anthropic, mock)', 'ollama')
+        .option('--apply', 'Actually apply fixes (default: dry-run)')
+        .option('--no-backup', 'Do not create backup before fixing')
+        .option('-j, --json', 'Output in JSON format')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (testFile, options) => {
+        const filePath = resolve(testFile);
+        if (!existsSync(filePath)) {
+            console.error(`Error: Test file not found: ${filePath}`);
+            process.exit(1);
+        }
+        try {
+            // Extract errors
+            let errors = [];
+            if (options.output) {
+                const result = await parseTestOutput(options.output);
+                errors = result.errors;
+            }
+            if (errors.length === 0) {
+                errors = await extractErrorsFromFile(filePath);
+            }
+            if (errors.length === 0) {
+                console.log('No test errors found to fix.');
+                return;
+            }
+            // Create repairer
+            const repairer = new TestRepairer({
+                llmProvider: options.provider,
+                autoApply: options.apply,
+                backup: options.backup !== false,
+                verbose: options.verbose
+            });
+            const testRunResult = {
+                passed: 0,
+                failed: errors.length,
+                errors,
+                duration: 0
+            };
+            console.log(`\n${options.apply ? 'Applying' : 'Previewing'} fixes for ${errors.length} error(s)...`);
+            const report = await repairer.repair(filePath, testRunResult);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    duration: report.duration,
+                    success: report.success,
+                    originalErrors: report.result.originalErrors.length,
+                    remainingErrors: report.result.remainingErrors.length,
+                    fixesApplied: report.result.fixes.length,
+                    iterations: report.result.iterations
+                }, null, 2));
+            }
+            else {
+                console.log(repairer.generateReport(report));
+                if (!options.apply) {
+                    console.log('\n[Dry run mode] Use --apply to actually apply fixes.');
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Fix failed: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+/**
+ * Repair interactive command
+ */
+export function createRepairInteractiveCommand() {
+    const cmd = new Command('interactive');
+    cmd
+        .description('Interactive repair mode')
+        .argument('[test-file]', 'Path to the test file (optional)')
+        .option('-p, --provider <provider>', 'LLM provider (ollama, openai, anthropic, mock)', 'ollama')
+        .action(async (testFile, options) => {
+        console.log('\n=== Interactive Repair Mode ===');
+        console.log('This feature will be available in a future version.');
+        console.log('For now, use: qa360 repair analyze <file> && qa360 repair fix <file> --apply');
+        console.log('\nAvailable commands:');
+        console.log('  qa360 repair analyze <file>  - Analyze test failures');
+        console.log('  qa360 repair suggest <file>   - Get quick fix suggestions');
+        console.log('  qa360 repair fix <file>       - Apply automatic fixes');
+    });
+    return cmd;
+}
+/**
+ * Create main repair command group
+ */
+export function createRepairCommand() {
+    const cmd = new Command('repair');
+    cmd
+        .description('Automatic test repair commands (Phase 7)');
+    cmd.addCommand(createRepairAnalyzeCommand());
+    cmd.addCommand(createRepairSuggestCommand());
+    cmd.addCommand(createRepairFixCommand());
+    cmd.addCommand(createRepairInteractiveCommand());
+    return cmd;
+}