qa360 2.1.7 → 2.2.0

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

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

@@ -1,37 +0,0 @@
-/**
- * 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[];
-};

package/dist/core/core/coverage/config.js

@@ -1,156 +0,0 @@
-/**
- * Coverage Configuration
- *
- * Default configuration and factory functions for coverage analytics.
- */
-/**
- * Create default coverage configuration
- */
-export function createDefaultCoverageConfig() {
-    return {
-        enabled: true,
-        thresholds: {
-            line: 80,
-            branch: 70,
-            function: 75,
-            statement: 80,
-            scope: 'global',
-            files: {}
-        },
-        failOnThreshold: false,
-        include: [
-            'src/**/*.ts',
-            'src/**/*.js',
-            'lib/**/*.ts',
-            'lib/**/*.js'
-        ],
-        exclude: [
-            '**/*.test.ts',
-            '**/*.test.js',
-            '**/*.spec.ts',
-            '**/*.spec.js',
-            '**/node_modules/**',
-            '**/dist/**',
-            '**/build/**',
-            '**/*.d.ts',
-            '**/*.config.*',
-            '**/mock*/**',
-            '**/__tests__/**',
-            '**/__mocks__/**'
-        ],
-        reportFormats: ['json', 'lcov'],
-        sources: ['jest', 'vitest', 'cypress', 'playwright', 'istanbul', 'lcov'],
-        storeInVault: true,
-        trackTrends: true
-    };
-}
-/**
- * Create strict coverage configuration (enterprise/production)
- */
-export function createStrictCoverageConfig() {
-    return {
-        ...createDefaultCoverageConfig(),
-        thresholds: {
-            line: 90,
-            branch: 85,
-            function: 88,
-            statement: 90,
-            scope: 'per-file',
-            files: {}
-        },
-        failOnThreshold: true
-    };
-}
-/**
- * Create relaxed coverage configuration (development/prototyping)
- */
-export function createRelaxedCoverageConfig() {
-    return {
-        ...createDefaultCoverageConfig(),
-        thresholds: {
-            line: 60,
-            branch: 50,
-            function: 55,
-            statement: 60,
-            scope: 'global',
-            files: {}
-        },
-        failOnThreshold: false
-    };
-}
-/**
- * Parse coverage threshold from string format
- * Supported formats:
- * - "80" (line coverage only)
- * - "line:80,branch:70"
- * - "{line:80,branch:70,function:75}"
- */
-export function parseCoverageThreshold(input) {
-    // JSON format
-    if (input.startsWith('{')) {
-        try {
-            return JSON.parse(input);
-        }
-        catch {
-            return createDefaultCoverageConfig().thresholds;
-        }
-    }
-    // Key:value format
-    if (input.includes(':')) {
-        const result = {};
-        for (const part of input.split(',')) {
-            const [key, value] = part.split(':');
-            const numValue = parseInt(value, 10);
-            if (!isNaN(numValue) && ['line', 'branch', 'function', 'statement'].includes(key)) {
-                result[key] = numValue;
-            }
-        }
-        return Object.keys(result).length > 0 ? result : createDefaultCoverageConfig().thresholds;
-    }
-    // Simple number (line coverage)
-    const numValue = parseInt(input, 10);
-    if (!isNaN(numValue)) {
-        return { line: numValue };
-    }
-    return createDefaultCoverageConfig().thresholds;
-}
-/**
- * Format coverage threshold as string
- */
-export function formatCoverageThreshold(threshold) {
-    const parts = [];
-    if (threshold.line !== undefined)
-        parts.push(`line:${threshold.line}`);
-    if (threshold.branch !== undefined)
-        parts.push(`branch:${threshold.branch}`);
-    if (threshold.function !== undefined)
-        parts.push(`function:${threshold.function}`);
-    if (threshold.statement !== undefined)
-        parts.push(`statement:${threshold.statement}`);
-    return parts.join(',') || 'line:80';
-}
-/**
- * Validate coverage configuration
- */
-export function validateCoverageConfig(config) {
-    const errors = [];
-    if (config.thresholds.line !== undefined && (config.thresholds.line < 0 || config.thresholds.line > 100)) {
-        errors.push('Line coverage threshold must be between 0 and 100');
-    }
-    if (config.thresholds.branch !== undefined && (config.thresholds.branch < 0 || config.thresholds.branch > 100)) {
-        errors.push('Branch coverage threshold must be between 0 and 100');
-    }
-    if (config.thresholds.function !== undefined && (config.thresholds.function < 0 || config.thresholds.function > 100)) {
-        errors.push('Function coverage threshold must be between 0 and 100');
-    }
-    if (config.thresholds.statement !== undefined && (config.thresholds.statement < 0 || config.thresholds.statement > 100)) {
-        errors.push('Statement coverage threshold must be between 0 and 100');
-    }
-    if (config.include.length === 0) {
-        errors.push('At least one include pattern is required');
-    }
-    return {
-        valid: errors.length === 0,
-        errors
-    };
-}

package/dist/core/core/coverage/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * QA360 Coverage Analytics Module
- *
- * Exports all coverage analytics functionality.
- */
-export type { CoverageType, CoverageSource, FileCoverage, BranchInfo, CoverageMetrics, CoverageThreshold, CoverageResult, CoverageTrend, CoverageGap, CoverageComparison, CoverageConfig, TestCoverageMap, CoverageReport } from './types.js';
-export { createDefaultCoverageConfig, createStrictCoverageConfig, createRelaxedCoverageConfig, parseCoverageThreshold, formatCoverageThreshold, validateCoverageConfig } from './config.js';
-export { CoverageCollector, createCoverageCollector } from './collector.js';
-export { CoverageAnalyzer, createCoverageAnalyzer } from './analyzer.js';
-export { CoverageVault } from './vault.js';
-export { createDefaultCoverageConfig as createCoverageConfig } from './config.js';

package/dist/core/core/coverage/index.js

@@ -1,15 +0,0 @@
-/**
- * QA360 Coverage Analytics Module
- *
- * Exports all coverage analytics functionality.
- */
-// Config
-export { createDefaultCoverageConfig, createStrictCoverageConfig, createRelaxedCoverageConfig, parseCoverageThreshold, formatCoverageThreshold, validateCoverageConfig } from './config.js';
-// Collector
-export { CoverageCollector, createCoverageCollector } from './collector.js';
-// Analyzer
-export { CoverageAnalyzer, createCoverageAnalyzer } from './analyzer.js';
-// Vault integration
-export { CoverageVault } from './vault.js';
-// Re-exports for convenience
-export { createDefaultCoverageConfig as createCoverageConfig } from './config.js';