qa360 1.4.5 → 2.0.1

package/dist/commands/coverage.js

@@ -0,0 +1,252 @@
+/**
+ * QA360 Coverage Command
+ *
+ * CLI command for coverage analytics and reporting.
+ */
+import { Command } from 'commander';
+import { existsSync } from 'fs';
+import { CoverageCollector, CoverageAnalyzer, parseCoverageThreshold, formatCoverageThreshold } from '../core/index.js';
+export const coverageCommand = new Command('coverage');
+coverageCommand.description('Coverage analytics and reporting');
+// Show coverage for a specific file or run
+coverageCommand
+    .command('show')
+    .description('Show coverage metrics')
+    .option('-f, --file <path>', 'Coverage file (JSON, LCOV, or Istanbul format)')
+    .option('-r, --run <id>', 'Run ID to fetch from vault')
+    .option('--json', 'Output as JSON')
+    .option('--verbose', 'Show detailed file-by-file coverage')
+    .action(async (options) => {
+    if (!options.file && !options.run) {
+        console.error('Error: Please specify --file or --run');
+        process.exit(1);
+    }
+    const collector = new CoverageCollector();
+    const analyzer = new CoverageAnalyzer();
+    let result;
+    if (options.file) {
+        if (!existsSync(options.file)) {
+            console.error(`Error: File not found: ${options.file}`);
+            process.exit(1);
+        }
+        result = await collector.collectFromFile(options.file);
+        if (!result) {
+            console.error('Error: Could not parse coverage file');
+            process.exit(1);
+        }
+    }
+    else if (options.run) {
+        // TODO: Fetch from vault when vault integration is complete
+        console.error('Error: Vault fetch not yet implemented');
+        process.exit(1);
+    }
+    if (!result)
+        return;
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Print summary
+    console.log('\n📊 Coverage Report\n');
+    console.log(`Line Coverage:     ${analyzer.formatCoverage(result.metrics.lineCoverage)}`);
+    console.log(`Branch Coverage:   ${analyzer.formatCoverage(result.metrics.branchCoverage)}`);
+    console.log(`Function Coverage: ${analyzer.formatCoverage(result.metrics.functionCoverage)}`);
+    console.log(`Statement Coverage: ${analyzer.formatCoverage(result.metrics.statementCoverage)}`);
+    console.log(`\nFiles: ${result.metrics.filesWithCoverage}/${result.metrics.totalFiles}`);
+    if (options.verbose) {
+        console.log('\n📁 File Coverage:\n');
+        const files = Object.entries(result.files)
+            .sort((a, b) => a[1].lineCoverage - b[1].lineCoverage);
+        for (const [path, file] of files) {
+            const status = file.lineCoverage >= 80 ? '✓' : file.lineCoverage >= 60 ? '⚠' : '✗';
+            console.log(`  ${status} ${path}`);
+            console.log(`      Lines: ${file.coveredLines}/${file.totalLines} (${file.lineCoverage.toFixed(1)}%)`);
+            console.log(`      Branches: ${file.coveredBranches}/${file.totalBranches} (${file.branchCoverage.toFixed(1)}%)`);
+            console.log(`      Functions: ${file.coveredFunctions}/${file.totalFunctions} (${file.functionCoverage.toFixed(1)}%)`);
+            if (file.uncoveredLines.length > 0 && file.uncoveredLines.length <= 10) {
+                console.log(`      Uncovered: ${file.uncoveredLines.join(', ')}`);
+            }
+            else if (file.uncoveredLines.length > 10) {
+                console.log(`      Uncovered: ${file.uncoveredLines.slice(0, 10).join(', ')} ... (${file.uncoveredLines.length} total)`);
+            }
+            console.log('');
+        }
+    }
+});
+// Analyze coverage and find gaps
+coverageCommand
+    .command('analyze')
+    .description('Analyze coverage and find gaps')
+    .option('-f, --file <path>', 'Coverage file (JSON, LCOV, or Istanbul format)')
+    .option('-t, --threshold <value>', 'Coverage threshold (default: 80)', '80')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    if (!options.file) {
+        console.error('Error: Please specify --file');
+        process.exit(1);
+    }
+    if (!existsSync(options.file)) {
+        console.error(`Error: File not found: ${options.file}`);
+        process.exit(1);
+    }
+    const collector = new CoverageCollector();
+    const analyzer = new CoverageAnalyzer();
+    const result = await collector.collectFromFile(options.file);
+    if (!result) {
+        console.error('Error: Could not parse coverage file');
+        process.exit(1);
+    }
+    const threshold = parseCoverageThreshold(options.threshold);
+    const report = analyzer.analyze(result, threshold);
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log('\n📊 Coverage Analysis\n');
+    console.log(`Overall Coverage: ${report.metrics.lineCoverage.toFixed(1)}%`);
+    console.log(`Thresholds Met: ${report.thresholdsMet ? '✓ Yes' : '✗ No'}`);
+    console.log(`Files Meeting Threshold: ${report.metrics.filesMeetingThreshold}/${report.metrics.totalFiles}`);
+    if (report.gaps.length > 0) {
+        console.log('\n🔴 Coverage Gaps (files below threshold):\n');
+        for (const gap of report.gaps) {
+            const icon = gap.priority === 'high' ? '🔴' : gap.priority === 'medium' ? '🟡' : '🟢';
+            console.log(`  ${icon} ${gap.path}`);
+            console.log(`      Current: ${gap.currentCoverage.toFixed(1)}% | Target: ${gap.targetCoverage}% | Gap: ${gap.gap.toFixed(1)}%`);
+            console.log(`      Effort: ${gap.effort} | Uncovered: ${gap.uncoveredCount} lines`);
+            if (gap.suggestions.length > 0) {
+                console.log(`      Suggestions:`);
+                for (const suggestion of gap.suggestions) {
+                    console.log(`        - ${suggestion}`);
+                }
+            }
+            console.log('');
+        }
+    }
+    else {
+        console.log('\n✓ All files meet the coverage threshold!\n');
+    }
+});
+// Compare two coverage files
+coverageCommand
+    .command('diff')
+    .description('Compare two coverage files')
+    .option('-b, --base <path>', 'Base coverage file')
+    .option('-c, --compare <path>', 'Comparison coverage file')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    if (!options.base || !options.compare) {
+        console.error('Error: Please specify both --base and --compare');
+        process.exit(1);
+    }
+    if (!existsSync(options.base)) {
+        console.error(`Error: Base file not found: ${options.base}`);
+        process.exit(1);
+    }
+    if (!existsSync(options.compare)) {
+        console.error(`Error: Compare file not found: ${options.compare}`);
+        process.exit(1);
+    }
+    const collector = new CoverageCollector();
+    const analyzer = new CoverageAnalyzer();
+    const baseResult = await collector.collectFromFile(options.base);
+    const compareResult = await collector.collectFromFile(options.compare);
+    if (!baseResult || !compareResult) {
+        console.error('Error: Could not parse coverage files');
+        process.exit(1);
+    }
+    const comparison = analyzer.compare(baseResult, compareResult);
+    if (options.json) {
+        console.log(JSON.stringify(comparison, null, 2));
+        return;
+    }
+    console.log('\n📊 Coverage Comparison\n');
+    console.log(`Overall Change: ${comparison.overallChange >= 0 ? '+' : ''}${comparison.overallChange.toFixed(1)}%`);
+    if (comparison.improved.length > 0) {
+        console.log('\n✅ Improved Files:\n');
+        for (const file of comparison.improved.slice(0, 10)) {
+            console.log(`  ${file.path}`);
+            console.log(`    ${file.before.toFixed(1)}% → ${file.after.toFixed(1)}% (+${file.delta.toFixed(1)}%)`);
+        }
+    }
+    if (comparison.regressed.length > 0) {
+        console.log('\n⚠️ Regressed Files:\n');
+        for (const file of comparison.regressed.slice(0, 10)) {
+            console.log(`  ${file.path}`);
+            console.log(`    ${file.before.toFixed(1)}% → ${file.after.toFixed(1)}% (${file.delta.toFixed(1)}%)`);
+        }
+    }
+    if (comparison.newFiles.length > 0) {
+        console.log('\n🆕 New Files:\n');
+        for (const file of comparison.newFiles.slice(0, 10)) {
+            console.log(`  ${file}`);
+        }
+    }
+    if (comparison.removedFiles.length > 0) {
+        console.log('\n🗑️ Removed Files:\n');
+        for (const file of comparison.removedFiles.slice(0, 10)) {
+            console.log(`  ${file}`);
+        }
+    }
+    console.log('');
+});
+// List coverage files in project
+coverageCommand
+    .command('list')
+    .description('List available coverage files in the project')
+    .action(() => {
+    const coveragePaths = [
+        'coverage/coverage-final.json',
+        'coverage/lcov.info',
+        'coverage/lcov-report/index.html',
+        '.nyc_output/out.json',
+        'coverage/istanbul.json'
+    ];
+    console.log('\n📂 Coverage Files:\n');
+    for (const path of coveragePaths) {
+        const exists = existsSync(path);
+        const status = exists ? '✓' : '✗';
+        console.log(`  ${status} ${path}`);
+    }
+    console.log('');
+});
+// Validate coverage against thresholds
+coverageCommand
+    .command('check')
+    .description('Check if coverage meets thresholds')
+    .option('-f, --file <path>', 'Coverage file (JSON, LCOV, or Istanbul format)')
+    .option('-t, --threshold <value>', 'Coverage threshold (default: line:80,branch:70)', 'line:80,branch:70')
+    .option('--fail', 'Exit with error code if thresholds not met')
+    .action(async (options) => {
+    if (!options.file) {
+        console.error('Error: Please specify --file');
+        process.exit(1);
+    }
+    if (!existsSync(options.file)) {
+        console.error(`Error: File not found: ${options.file}`);
+        process.exit(1);
+    }
+    const collector = new CoverageCollector();
+    const analyzer = new CoverageAnalyzer();
+    const result = await collector.collectFromFile(options.file);
+    if (!result) {
+        console.error('Error: Could not parse coverage file');
+        process.exit(1);
+    }
+    const threshold = parseCoverageThreshold(options.threshold);
+    const passed = analyzer.checkThresholds(result.metrics, threshold);
+    console.log('\n📊 Coverage Check\n');
+    console.log(`Threshold: ${formatCoverageThreshold(threshold)}`);
+    console.log(`Line Coverage: ${result.metrics.lineCoverage.toFixed(1)}% ${result.metrics.lineCoverage >= (threshold.line || 0) ? '✓' : '✗'}`);
+    console.log(`Branch Coverage: ${result.metrics.branchCoverage.toFixed(1)}% ${result.metrics.branchCoverage >= (threshold.branch || 0) ? '✓' : '✗'}`);
+    console.log(`Function Coverage: ${result.metrics.functionCoverage.toFixed(1)}% ${result.metrics.functionCoverage >= (threshold.function || 0) ? '✓' : '✗'}`);
+    if (passed) {
+        console.log('\n✅ All thresholds met!\n');
+    }
+    else {
+        console.log('\n❌ Some thresholds not met!\n');
+        if (options.fail) {
+            process.exit(1);
+        }
+    }
+});
+export default coverageCommand;

package/dist/commands/explain.d.ts

@@ -0,0 +1,27 @@
+/**
+ * QA360 Explain Command
+ *
+ * Advanced error and failure explanations with:
+ * - Static error code database
+ * - AI-powered explanations
+ * - Vault-based historical context
+ * - Flakiness insights
+ *
+ * Usage:
+ *   qa360 explain QX001              # Static error code
+ *   qa360 explain --ai "my test failed"  # AI explanation
+ *   qa360 explain --run run-xxx      # Explain run results
+ *   qa360 explain --gate api_smoke   # Explain gate failure
+ */
+export interface ExplainOptions {
+    ai?: boolean;
+    provider?: string;
+    run?: string;
+    gate?: string;
+    json?: boolean;
+}
+/**
+ * Main explain command
+ */
+export declare function explainCommand(input: string | undefined, options?: ExplainOptions): Promise<void>;
+export default explainCommand;