qa360 2.2.6 → 2.2.9

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

@@ -1,415 +0,0 @@
-/**
- * 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/core/coverage/collector.d.ts

@@ -1,74 +0,0 @@
-/**
- * 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;