qa360 2.2.1 → 2.2.13

package/cli/dist/core/coverage/analyzer.js

@@ -0,0 +1,415 @@
+/**
+ * Coverage Analyzer
+ *
+ * Analyzes coverage data to provide insights, trends, and recommendations.
+ */
+/**
+ * Coverage Analyzer class
+ */
+export class CoverageAnalyzer {
+    history = new Map();
+    /**
+     * Analyze coverage and generate insights
+     */
+    analyze(result, threshold) {
+        const thresholdsMet = this.checkThresholds(result.metrics, threshold);
+        const gaps = this.findGaps(result.files, threshold);
+        const topFiles = this.getTopFiles(result.files);
+        return {
+            runId: `run_${Date.now()}`,
+            timestamp: Date.now(),
+            metrics: result.metrics,
+            byGate: { [result.gate]: result.metrics },
+            topFiles,
+            gaps: gaps.slice(0, 10), // Top 10 gaps
+            thresholdsMet,
+            thresholdViolations: gaps.map(g => g.path)
+        };
+    }
+    /**
+     * Check if coverage meets thresholds
+     */
+    checkThresholds(metrics, threshold) {
+        if (!threshold) {
+            return true;
+        }
+        if (threshold.scope === 'per-file') {
+            // Per-file thresholds checked separately
+            return true;
+        }
+        if (threshold.line !== undefined && metrics.lineCoverage < threshold.line) {
+            return false;
+        }
+        if (threshold.branch !== undefined && metrics.branchCoverage < threshold.branch) {
+            return false;
+        }
+        if (threshold.function !== undefined && metrics.functionCoverage < threshold.function) {
+            return false;
+        }
+        if (threshold.statement !== undefined && metrics.statementCoverage < threshold.statement) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a single file meets thresholds
+     */
+    checkFileThresholds(file, threshold) {
+        if (!threshold) {
+            return true;
+        }
+        if (threshold.line !== undefined && file.lineCoverage < threshold.line) {
+            return false;
+        }
+        if (threshold.branch !== undefined && file.branchCoverage < threshold.branch) {
+            return false;
+        }
+        if (threshold.function !== undefined && file.functionCoverage < threshold.function) {
+            return false;
+        }
+        if (threshold.statement !== undefined && file.statementCoverage < threshold.statement) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Find coverage gaps
+     */
+    findGaps(files, threshold) {
+        const gaps = [];
+        const targetLine = threshold?.line ?? 80;
+        const targetBranch = threshold?.branch ?? 70;
+        const targetFunction = threshold?.function ?? 75;
+        for (const [path, file] of Object.entries(files)) {
+            const minTarget = Math.min(targetLine, targetBranch, targetFunction);
+            const avgCoverage = (file.lineCoverage + file.branchCoverage + file.functionCoverage) / 3;
+            if (avgCoverage < minTarget) {
+                gaps.push({
+                    path,
+                    currentCoverage: avgCoverage,
+                    targetCoverage: minTarget,
+                    gap: minTarget - avgCoverage,
+                    priority: this.calculatePriority(file, minTarget),
+                    effort: this.estimateEffort(file),
+                    uncoveredCount: file.uncoveredLines.length,
+                    suggestions: this.generateSuggestions(file)
+                });
+            }
+        }
+        // Sort by gap size, then priority
+        gaps.sort((a, b) => {
+            if (a.priority !== b.priority) {
+                const priorityOrder = { high: 0, medium: 1, low: 2 };
+                return priorityOrder[a.priority] - priorityOrder[b.priority];
+            }
+            return b.gap - a.gap;
+        });
+        return gaps;
+    }
+    /**
+     * Calculate priority for covering a file
+     */
+    calculatePriority(file, target) {
+        const gap = target - file.lineCoverage;
+        // High priority: large gap in important files
+        if (gap > 30) {
+            return 'high';
+        }
+        // Medium priority: moderate gap
+        if (gap > 10) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Estimate effort to cover a file
+     */
+    estimateEffort(file) {
+        const complexity = file.totalBranches + file.totalFunctions;
+        const uncoveredRatio = file.uncoveredLines.length / Math.max(file.totalLines, 1);
+        if (complexity > 100 || uncoveredRatio > 0.5) {
+            return 'high';
+        }
+        if (complexity > 30 || uncoveredRatio > 0.2) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Generate test suggestions for a file
+     */
+    generateSuggestions(file) {
+        const suggestions = [];
+        if (file.uncoveredLines.length > 0) {
+            const lineRanges = this.groupConsecutiveNumbers(file.uncoveredLines);
+            suggestions.push(`Add tests covering lines: ${lineRanges.slice(0, 3).join(', ')}`);
+        }
+        if (file.branchCoverage < file.lineCoverage) {
+            suggestions.push('Add tests for all branch conditions (true/false paths)');
+        }
+        if (file.functionCoverage < 100) {
+            suggestions.push('Add tests for uncovered functions');
+        }
+        if (file.totalFunctions === 0) {
+            suggestions.push('Consider splitting large functions into smaller, testable units');
+        }
+        return suggestions;
+    }
+    /**
+     * Group consecutive numbers into ranges
+     */
+    groupConsecutiveNumbers(numbers) {
+        if (numbers.length === 0)
+            return [];
+        const sorted = [...numbers].sort((a, b) => a - b);
+        const ranges = [];
+        let start = sorted[0];
+        let prev = sorted[0];
+        for (let i = 1; i < sorted.length; i++) {
+            if (sorted[i] === prev + 1) {
+                prev = sorted[i];
+            }
+            else {
+                ranges.push(start === prev ? `${start}` : `${start}-${prev}`);
+                start = sorted[i];
+                prev = sorted[i];
+            }
+        }
+        ranges.push(start === prev ? `${start}` : `${start}-${prev}`);
+        return ranges;
+    }
+    /**
+     * Get top and bottom files by coverage
+     */
+    getTopFiles(files, limit = 5) {
+        const fileArray = Object.entries(files).map(([path, file]) => ({
+            path,
+            coverage: file.lineCoverage,
+            type: 'best'
+        }));
+        // Sort by coverage
+        fileArray.sort((a, b) => b.coverage - a.coverage);
+        const result = [];
+        // Best files
+        for (let i = 0; i < Math.min(limit, fileArray.length); i++) {
+            result.push({ ...fileArray[i], type: 'best' });
+        }
+        // Worst files
+        for (let i = fileArray.length - 1; i >= Math.max(fileArray.length - limit, 0); i--) {
+            result.push({ path: fileArray[i].path, coverage: fileArray[i].coverage, type: 'worst' });
+        }
+        return result;
+    }
+    /**
+     * Compare two coverage results
+     */
+    compare(baseResult, compareResult) {
+        const baseFiles = baseResult.files;
+        const compareFiles = compareResult.files;
+        const improved = [];
+        const regressed = [];
+        const newFiles = [];
+        const removedFiles = [];
+        // Check all files in base
+        for (const [path, baseFile] of Object.entries(baseFiles)) {
+            const compareFile = compareFiles[path];
+            if (!compareFile) {
+                removedFiles.push(path);
+                continue;
+            }
+            const delta = compareFile.lineCoverage - baseFile.lineCoverage;
+            if (delta > 0.5) {
+                improved.push({
+                    path,
+                    before: baseFile.lineCoverage,
+                    after: compareFile.lineCoverage,
+                    delta
+                });
+            }
+            else if (delta < -0.5) {
+                regressed.push({
+                    path,
+                    before: baseFile.lineCoverage,
+                    after: compareFile.lineCoverage,
+                    delta
+                });
+            }
+        }
+        // Find new files
+        for (const path of Object.keys(compareFiles)) {
+            if (!baseFiles[path]) {
+                newFiles.push(path);
+            }
+        }
+        // Calculate overall change
+        const overallChange = compareResult.metrics.lineCoverage - baseResult.metrics.lineCoverage;
+        return {
+            baseRunId: `base_${baseResult.timestamp}`,
+            compareRunId: `compare_${compareResult.timestamp}`,
+            improved,
+            regressed,
+            newFiles,
+            removedFiles,
+            overallChange
+        };
+    }
+    /**
+     * Add historical coverage data
+     */
+    addHistory(key, data) {
+        if (!this.history.has(key)) {
+            this.history.set(key, []);
+        }
+        const history = this.history.get(key);
+        history.push(data);
+        // Keep only last 100 entries
+        if (history.length > 100) {
+            history.shift();
+        }
+    }
+    /**
+     * Get coverage trends
+     */
+    getTrends(key, type = 'line', limit = 30) {
+        const history = this.history.get(key) || [];
+        const sorted = history
+            .sort((a, b) => a.timestamp - b.timestamp)
+            .slice(-limit);
+        const trends = [];
+        let previousValue = 0;
+        for (const entry of sorted) {
+            let value;
+            switch (type) {
+                case 'line':
+                    value = entry.metrics.lineCoverage;
+                    break;
+                case 'branch':
+                    value = entry.metrics.branchCoverage;
+                    break;
+                case 'function':
+                    value = entry.metrics.functionCoverage;
+                    break;
+                case 'statement':
+                    value = entry.metrics.statementCoverage;
+                    break;
+            }
+            trends.push({
+                runId: entry.runId,
+                timestamp: entry.timestamp,
+                coverage: value,
+                type,
+                change: value - previousValue
+            });
+            previousValue = value;
+        }
+        return trends;
+    }
+    /**
+     * Calculate trend direction
+     */
+    getTrendDirection(trends) {
+        if (trends.length < 3) {
+            return 'stable';
+        }
+        const recent = trends.slice(-5);
+        const avgChange = recent.reduce((sum, t) => sum + t.change, 0) / recent.length;
+        if (avgChange > 1)
+            return 'improving';
+        if (avgChange < -1)
+            return 'declining';
+        return 'stable';
+    }
+    /**
+     * Predict future coverage based on trends
+     */
+    predictCoverage(key, type = 'line', targetCoverage) {
+        const trends = this.getTrends(key, type, 20);
+        if (trends.length < 5) {
+            return {
+                predictedReach: null,
+                projectedCoverage: trends[trends.length - 1]?.coverage || 0,
+                confidence: 'low'
+            };
+        }
+        // Simple linear regression
+        const n = trends.length;
+        let sumX = 0;
+        let sumY = 0;
+        let sumXY = 0;
+        let sumXX = 0;
+        for (let i = 0; i < n; i++) {
+            const x = i;
+            const y = trends[i].coverage;
+            sumX += x;
+            sumY += y;
+            sumXY += x * y;
+            sumXX += x * x;
+        }
+        const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+        const intercept = (sumY - slope * sumX) / n;
+        const currentCoverage = trends[n - 1].coverage;
+        const avgCoverage = sumY / n;
+        const variance = trends.reduce((sum, t) => sum + Math.pow(t.coverage - avgCoverage, 2), 0) / n;
+        // Determine confidence based on variance
+        let confidence;
+        if (variance < 25)
+            confidence = 'high';
+        else if (variance < 100)
+            confidence = 'medium';
+        else
+            confidence = 'low';
+        // Project coverage for next run
+        const projectedCoverage = currentCoverage + slope;
+        // Predict when target will be reached
+        let predictedReach = null;
+        if (slope > 0.1) {
+            const runsNeeded = (targetCoverage - currentCoverage) / slope;
+            if (runsNeeded > 0 && runsNeeded < 100) {
+                predictedReach = Date.now() + runsNeeded * 24 * 60 * 60 * 1000; // Assume daily runs
+            }
+        }
+        return { predictedReach, projectedCoverage, confidence };
+    }
+    /**
+     * Generate coverage summary text
+     */
+    generateSummary(metrics) {
+        const parts = [];
+        parts.push(`Line Coverage: ${metrics.lineCoverage.toFixed(1)}%`);
+        parts.push(`Branch Coverage: ${metrics.branchCoverage.toFixed(1)}%`);
+        parts.push(`Function Coverage: ${metrics.functionCoverage.toFixed(1)}%`);
+        if (metrics.totalFiles > 0) {
+            parts.push(`Files: ${metrics.filesWithCoverage}/${metrics.totalFiles}`);
+        }
+        return parts.join(' | ');
+    }
+    /**
+     * Format coverage percentage with color indicator
+     */
+    formatCoverage(percentage, threshold = 80) {
+        if (percentage >= threshold) {
+            return `✓ ${percentage.toFixed(1)}%`;
+        }
+        else if (percentage >= threshold - 10) {
+            return `⚠ ${percentage.toFixed(1)}%`;
+        }
+        return `✗ ${percentage.toFixed(1)}%`;
+    }
+    /**
+     * Clear history
+     */
+    clearHistory(key) {
+        if (key) {
+            this.history.delete(key);
+        }
+        else {
+            this.history.clear();
+        }
+    }
+}
+/**
+ * Create a coverage analyzer
+ */
+export function createCoverageAnalyzer() {
+    return new CoverageAnalyzer();
+}

package/cli/dist/core/coverage/collector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Coverage Collector
+ *
+ * Collects coverage data from various test sources.
+ * Supports Jest, Vitest, Cypress, Playwright, and LCOV formats.
+ */
+import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageConfig } from './types.js';
+/**
+ * Coverage Collector class
+ */
+export declare class CoverageCollector {
+    private config;
+    constructor(config?: Partial<CoverageConfig>);
+    /**
+     * Collect coverage from a file path (auto-detect format)
+     */
+    collectFromFile(filePath: string): Promise<CoverageResult | null>;
+    /**
+     * Collect coverage from LCOV format
+     */
+    collectFromLcov(filePath: string): Promise<CoverageResult | null>;
+    /**
+     * Collect coverage from JSON format (Vitest/Istanbul)
+     */
+    collectFromJson(filePath: string): Promise<CoverageResult | null>;
+    /**
+     * Collect coverage from Istanbul format
+     */
+    collectFromIstanbul(filePath: string): Promise<CoverageResult | null>;
+    /**
+     * Parse LCOV format content
+     */
+    private parseLcov;
+    /**
+     * Convert LCOV record to FileCoverage
+     */
+    private convertLcovToFileCoverage;
+    /**
+     * Convert Vitest coverage data to FileCoverage
+     */
+    private convertVitestToFileCoverage;
+    /**
+     * Convert Istanbul coverage data to FileCoverage
+     */
+    private convertIstanbulToFileCoverage;
+    /**
+     * Calculate aggregate metrics from file coverage data
+     */
+    calculateMetrics(files: Record<string, FileCoverage>): CoverageMetrics;
+    /**
+     * Detect coverage format from file path
+     */
+    private detectFormat;
+    /**
+     * Filter files based on include/exclude patterns
+     */
+    filterFiles(files: Record<string, FileCoverage>): Record<string, FileCoverage>;
+    /**
+     * Match path against glob pattern
+     */
+    private matchPattern;
+    /**
+     * Merge multiple coverage results
+     */
+    mergeCoverageResults(results: CoverageResult[]): CoverageResult;
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<CoverageConfig>): void;
+}
+/**
+ * Create a coverage collector with default config
+ */
+export declare function createCoverageCollector(config?: Partial<CoverageConfig>): CoverageCollector;