qa360 2.2.14 → 2.2.18

package/cli/dist/core/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;

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

@@ -0,0 +1,459 @@
+/**
+ * Coverage Collector
+ *
+ * Collects coverage data from various test sources.
+ * Supports Jest, Vitest, Cypress, Playwright, and LCOV formats.
+ */
+import { createDefaultCoverageConfig } from './config.js';
+/**
+ * Coverage Collector class
+ */
+export class CoverageCollector {
+    config;
+    constructor(config) {
+        this.config = { ...createDefaultCoverageConfig(), ...config };
+    }
+    /**
+     * Collect coverage from a file path (auto-detect format)
+     */
+    async collectFromFile(filePath) {
+        const format = this.detectFormat(filePath);
+        switch (format) {
+            case 'lcov':
+                return this.collectFromLcov(filePath);
+            case 'json':
+                return this.collectFromJson(filePath);
+            case 'istanbul':
+                return this.collectFromIstanbul(filePath);
+            default:
+                return null;
+        }
+    }
+    /**
+     * Collect coverage from LCOV format
+     */
+    async collectFromLcov(filePath) {
+        try {
+            const fs = await import('node:fs/promises');
+            const content = await fs.readFile(filePath, 'utf-8');
+            const records = this.parseLcov(content);
+            if (records.length === 0) {
+                return null;
+            }
+            const files = {};
+            for (const record of records) {
+                files[record.file] = this.convertLcovToFileCoverage(record);
+            }
+            return {
+                source: 'lcov',
+                gate: 'unknown',
+                files,
+                metrics: this.calculateMetrics(files),
+                format: 'lcov',
+                timestamp: Date.now()
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Collect coverage from JSON format (Vitest/Istanbul)
+     */
+    async collectFromJson(filePath) {
+        try {
+            const fs = await import('node:fs/promises');
+            const content = await fs.readFile(filePath, 'utf-8');
+            const data = JSON.parse(content);
+            const files = {};
+            // Handle Vitest format
+            if (data.result && typeof data.result === 'object') {
+                for (const [filePath, coverageData] of Object.entries(data.result)) {
+                    if (typeof coverageData === 'object' && coverageData !== null) {
+                        files[filePath] = this.convertVitestToFileCoverage(filePath, coverageData);
+                    }
+                }
+                return {
+                    source: 'vitest',
+                    gate: 'unknown',
+                    files,
+                    metrics: this.calculateMetrics(files),
+                    format: 'json',
+                    timestamp: Date.now()
+                };
+            }
+            // Handle Istanbul format
+            if (typeof data === 'object' && !data.result) {
+                for (const [filePath, coverageData] of Object.entries(data)) {
+                    if (typeof coverageData === 'object' && coverageData !== null) {
+                        files[filePath] = this.convertIstanbulToFileCoverage(filePath, coverageData);
+                    }
+                }
+                return {
+                    source: 'istanbul',
+                    gate: 'unknown',
+                    files,
+                    metrics: this.calculateMetrics(files),
+                    format: 'istanbul',
+                    timestamp: Date.now()
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Collect coverage from Istanbul format
+     */
+    async collectFromIstanbul(filePath) {
+        return this.collectFromJson(filePath);
+    }
+    /**
+     * Parse LCOV format content
+     */
+    parseLcov(content) {
+        const records = [];
+        const lines = content.split('\n');
+        let currentRecord = null;
+        for (const line of lines) {
+            if (line.startsWith('SF:')) {
+                // Start of new file record
+                currentRecord = {
+                    file: line.substring(3),
+                    lines: {},
+                    branches: {},
+                    functions: {}
+                };
+                records.push(currentRecord);
+            }
+            else if (currentRecord) {
+                if (line.startsWith('DA:')) {
+                    // Line data: DA:<line>,<count>
+                    const [, lineNum, count] = line.match(/^DA:(\d+),(\d+)$/) || [];
+                    if (lineNum) {
+                        currentRecord.lines[parseInt(lineNum, 10)] = parseInt(count, 10);
+                    }
+                }
+                else if (line.startsWith('BRDA:')) {
+                    // Branch data: BRDA:<line>,<block>,<branch>,<count>
+                    const parts = line.substring(5).split(',');
+                    if (parts.length >= 4) {
+                        const lineNum = parts[0];
+                        const branchId = `${lineNum}-${parts[1]}-${parts[2]}`;
+                        const count = parts[3] === '-' ? 0 : parseInt(parts[3], 10);
+                        if (!currentRecord.branches[lineNum]) {
+                            currentRecord.branches[lineNum] = [];
+                        }
+                        currentRecord.branches[lineNum].push(count);
+                    }
+                }
+                else if (line.startsWith('FN:')) {
+                    // Function data: FN:<line>,<function name>
+                    const parts = line.substring(3).split(',');
+                    if (parts.length >= 2) {
+                        currentRecord.functions[parts[1]] = 0;
+                    }
+                }
+                else if (line.startsWith('FNDA:')) {
+                    // Function execution data: FNDA:<count>,<function name>
+                    const parts = line.substring(5).split(',');
+                    if (parts.length >= 2) {
+                        currentRecord.functions[parts[1]] = parseInt(parts[0], 10);
+                    }
+                }
+            }
+        }
+        return records;
+    }
+    /**
+     * Convert LCOV record to FileCoverage
+     */
+    convertLcovToFileCoverage(record) {
+        const lineNumbers = Object.keys(record.lines).map(Number);
+        const totalLines = lineNumbers.length > 0 ? Math.max(...lineNumbers) : 0;
+        const coveredLines = Object.values(record.lines).filter(c => c > 0).length;
+        // Count branches
+        let totalBranches = 0;
+        let coveredBranches = 0;
+        const branchesByLine = {};
+        for (const [lineNum, branchCounts] of Object.entries(record.branches)) {
+            const line = parseInt(lineNum, 10);
+            const branches = branchCounts;
+            totalBranches += branches.length;
+            coveredBranches += branches.filter(c => c > 0).length;
+            branchesByLine[line] = branches.map((count, idx) => ({
+                index: idx,
+                count,
+                location: { start: { line, column: 0 }, end: { line, column: 0 } }
+            }));
+        }
+        // Count functions
+        const totalFunctions = Object.keys(record.functions).length;
+        const coveredFunctions = Object.values(record.functions).filter(f => f > 0).length;
+        // Uncovered lines
+        const uncoveredLines = Object.entries(record.lines)
+            .filter(([, count]) => count === 0)
+            .map(([line]) => parseInt(line, 10));
+        const partiallyCoveredLines = Object.entries(record.lines)
+            .filter(([, count]) => count > 0 && count < 10) // Low execution count
+            .map(([line]) => parseInt(line, 10));
+        return {
+            path: record.file,
+            totalLines,
+            coveredLines,
+            lineCoverage: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
+            totalBranches,
+            coveredBranches,
+            branchCoverage: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
+            totalFunctions,
+            coveredFunctions,
+            functionCoverage: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
+            totalStatements: totalLines, // Approximation
+            coveredStatements: coveredLines,
+            statementCoverage: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
+            uncoveredLines,
+            partiallyCoveredLines,
+            branchesByLine
+        };
+    }
+    /**
+     * Convert Vitest coverage data to FileCoverage
+     */
+    convertVitestToFileCoverage(filePath, data) {
+        const s = data.s || { total: 0, covered: 0, pct: 0 };
+        const b = data.b || {};
+        const f = data.f || {};
+        const stmt = data.statementMap || {};
+        const branchMap = data.branchMap || {};
+        // Calculate line coverage from statement map
+        const lines = new Set();
+        const coveredLines = new Set();
+        for (const [idx, stmtInfo] of Object.entries(stmt)) {
+            if (stmtInfo && typeof stmtInfo === 'object') {
+                const start = stmtInfo.start;
+                const end = stmtInfo.end;
+                if (start && end) {
+                    for (let i = start.line; i <= end.line; i++) {
+                        lines.add(i);
+                    }
+                }
+            }
+            const count = s[parseInt(idx)];
+            if (count > 0 && stmtInfo) {
+                const start = stmtInfo.start;
+                const end = stmtInfo.end;
+                if (start && end) {
+                    for (let i = start.line; i <= end.line; i++) {
+                        coveredLines.add(i);
+                    }
+                }
+            }
+        }
+        // Calculate branch coverage
+        let totalBranches = 0;
+        let coveredBranches = 0;
+        const branchesByLine = {};
+        for (const [idx, branches] of Object.entries(b)) {
+            if (Array.isArray(branches)) {
+                const branchInfo = branchMap[parseInt(idx)];
+                const line = branchInfo?.line || 0;
+                totalBranches += branches.length;
+                coveredBranches += branches.filter((c) => c > 0).length;
+                branchesByLine[line] = branches.map((count, idx) => ({
+                    index: idx,
+                    count,
+                    location: { start: { line, column: 0 }, end: { line, column: 0 } }
+                }));
+            }
+        }
+        // Calculate function coverage
+        const totalFunctions = Object.keys(f).length;
+        const coveredFunctions = Object.values(f).filter((c) => typeof c === 'number' && c > 0).length;
+        const totalLines = lines.size;
+        const coveredLinesCount = coveredLines.size;
+        const uncoveredLines = Array.from(lines).filter(l => !coveredLines.has(l));
+        return {
+            path: filePath,
+            totalLines,
+            coveredLines: coveredLinesCount,
+            lineCoverage: s.pct || 0,
+            totalBranches,
+            coveredBranches,
+            branchCoverage: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
+            totalFunctions,
+            coveredFunctions,
+            functionCoverage: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
+            totalStatements: s.total || 0,
+            coveredStatements: s.covered || 0,
+            statementCoverage: s.pct || 0,
+            uncoveredLines,
+            partiallyCoveredLines: [],
+            branchesByLine
+        };
+    }
+    /**
+     * Convert Istanbul coverage data to FileCoverage
+     */
+    convertIstanbulToFileCoverage(filePath, data) {
+        return this.convertVitestToFileCoverage(filePath, data);
+    }
+    /**
+     * Calculate aggregate metrics from file coverage data
+     */
+    calculateMetrics(files) {
+        const fileArray = Object.values(files);
+        const threshold = this.config.thresholds.line || 80;
+        if (fileArray.length === 0) {
+            return {
+                lineCoverage: 0,
+                branchCoverage: 0,
+                functionCoverage: 0,
+                statementCoverage: 0,
+                totalFiles: 0,
+                filesWithCoverage: 0,
+                filesMeetingThreshold: 0,
+                totalLines: 0,
+                coveredLines: 0,
+                timestamp: Date.now()
+            };
+        }
+        let totalLines = 0;
+        let coveredLines = 0;
+        let totalBranches = 0;
+        let coveredBranches = 0;
+        let totalFunctions = 0;
+        let coveredFunctions = 0;
+        let totalStatements = 0;
+        let coveredStatements = 0;
+        let filesMeetingThreshold = 0;
+        for (const file of fileArray) {
+            totalLines += file.totalLines;
+            coveredLines += file.coveredLines;
+            totalBranches += file.totalBranches;
+            coveredBranches += file.coveredBranches;
+            totalFunctions += file.totalFunctions;
+            coveredFunctions += file.coveredFunctions;
+            totalStatements += file.totalStatements;
+            coveredStatements += file.coveredStatements;
+            if (file.lineCoverage >= threshold) {
+                filesMeetingThreshold++;
+            }
+        }
+        return {
+            lineCoverage: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
+            branchCoverage: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
+            functionCoverage: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
+            statementCoverage: totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0,
+            totalFiles: fileArray.length,
+            filesWithCoverage: fileArray.filter(f => f.totalLines > 0).length,
+            filesMeetingThreshold,
+            totalLines,
+            coveredLines,
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * Detect coverage format from file path
+     */
+    detectFormat(filePath) {
+        if (filePath.endsWith('.json')) {
+            return 'json';
+        }
+        if (filePath.endsWith('.lcov') || filePath.endsWith('.info')) {
+            return 'lcov';
+        }
+        if (filePath.includes('coverage') && filePath.endsWith('.json')) {
+            return 'istanbul';
+        }
+        return 'unknown';
+    }
+    /**
+     * Filter files based on include/exclude patterns
+     */
+    filterFiles(files) {
+        const filtered = {};
+        const isIncluded = (path) => {
+            // Check exclude patterns first
+            for (const pattern of this.config.exclude) {
+                if (this.matchPattern(path, pattern)) {
+                    return false;
+                }
+            }
+            // Check include patterns
+            if (this.config.include.length === 0) {
+                return true; // No include filters means all
+            }
+            for (const pattern of this.config.include) {
+                if (this.matchPattern(path, pattern)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        for (const [path, coverage] of Object.entries(files)) {
+            if (isIncluded(path)) {
+                filtered[path] = coverage;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Match path against glob pattern
+     */
+    matchPattern(path, pattern) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.').replace(/\//g, '\\/') + '$');
+        return regex.test(path);
+    }
+    /**
+     * Merge multiple coverage results
+     */
+    mergeCoverageResults(results) {
+        const mergedFiles = {};
+        for (const result of results) {
+            for (const [path, file] of Object.entries(result.files)) {
+                if (!mergedFiles[path]) {
+                    mergedFiles[path] = { ...file };
+                }
+                else {
+                    // Merge coverage data
+                    const existing = mergedFiles[path];
+                    // For lines, take the max execution count
+                    const uncoveredLines = new Set([
+                        ...existing.uncoveredLines,
+                        ...file.uncoveredLines
+                    ]);
+                    // Update totals (approximate merging)
+                    mergedFiles[path] = {
+                        ...existing,
+                        uncoveredLines: Array.from(uncoveredLines),
+                        lineCoverage: Math.max(existing.lineCoverage, file.lineCoverage),
+                        branchCoverage: Math.max(existing.branchCoverage, file.branchCoverage),
+                        functionCoverage: Math.max(existing.functionCoverage, file.functionCoverage)
+                    };
+                }
+            }
+        }
+        return {
+            source: 'custom',
+            gate: 'merged',
+            files: mergedFiles,
+            metrics: this.calculateMetrics(mergedFiles),
+            format: 'json',
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+}
+/**
+ * Create a coverage collector with default config
+ */
+export function createCoverageCollector(config) {
+    return new CoverageCollector(config);
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Coverage Configuration
+ *
+ * Default configuration and factory functions for coverage analytics.
+ */
+import type { CoverageConfig, CoverageThreshold } from './types.js';
+/**
+ * Create default coverage configuration
+ */
+export declare function createDefaultCoverageConfig(): CoverageConfig;
+/**
+ * Create strict coverage configuration (enterprise/production)
+ */
+export declare function createStrictCoverageConfig(): CoverageConfig;
+/**
+ * Create relaxed coverage configuration (development/prototyping)
+ */
+export declare function createRelaxedCoverageConfig(): CoverageConfig;
+/**
+ * Parse coverage threshold from string format
+ * Supported formats:
+ * - "80" (line coverage only)
+ * - "line:80,branch:70"
+ * - "{line:80,branch:70,function:75}"
+ */
+export declare function parseCoverageThreshold(input: string): CoverageThreshold;
+/**
+ * Format coverage threshold as string
+ */
+export declare function formatCoverageThreshold(threshold: CoverageThreshold): string;
+/**
+ * Validate coverage configuration
+ */
+export declare function validateCoverageConfig(config: CoverageConfig): {
+    valid: boolean;
+    errors: string[];
+};