qa360 2.2.20 → 2.3.1

package/cli/dist/core/auth/oauth2-provider.js

@@ -1,114 +0,0 @@
-/**
- * OAuth2 Authentication Provider
- *
- * Handles OAuth2 authentication with support for:
- * - Client credentials grant
- * - Password grant (resource owner)
- * - Authorization code grant (requires pre-issued code)
- */
-import { authCache, createCacheKey } from './index.js';
-export class OAuth2Provider {
-    type = 'oauth2';
-    async authenticate(config) {
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first
-        if (config.cache?.enabled !== false) {
-            const cached = authCache.get(cacheKey);
-            if (cached) {
-                return { success: true, credentials: cached };
-            }
-        }
-        // Prepare token request based on grant type
-        const grantType = config.grant_type || 'client_credentials';
-        const body = {
-            grant_type: grantType,
-            client_id: config.client_id,
-        };
-        // Add client secret for most grants (except some implicit flows)
-        if (config.client_secret) {
-            body.client_secret = config.client_secret;
-        }
-        // Grant-specific parameters
-        if (grantType === 'password') {
-            if (!config.username || !config.password) {
-                return {
-                    success: false,
-                    error: 'Username and password required for password grant'
-                };
-            }
-            body.username = config.username;
-            body.password = config.password;
-        }
-        if (config.scopes && config.scopes.length > 0) {
-            body.scope = config.scopes.join(' ');
-        }
-        try {
-            const response = await fetch(config.token_url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                },
-                body: new URLSearchParams(body).toString(),
-            });
-            if (!response.ok) {
-                const error = await response.text().catch(() => 'Unknown error');
-                return {
-                    success: false,
-                    error: `OAuth2 token request failed: ${response.status} ${error}`
-                };
-            }
-            const data = await response.json();
-            const token = data.access_token;
-            if (!token) {
-                return {
-                    success: false,
-                    error: 'No access_token in OAuth2 response'
-                };
-            }
-            const credentials = {
-                type: 'oauth2',
-                headers: {
-                    'Authorization': `Bearer ${token}`
-                }
-            };
-            // Calculate expiration
-            let expiresAt;
-            if (data.expires_in) {
-                expiresAt = Date.now() + data.expires_in * 1000;
-            }
-            // Cache if enabled
-            if (config.cache?.enabled !== false) {
-                const ttl = config.cache?.ttl || data.expires_in || 3600;
-                authCache.set(cacheKey, credentials, ttl);
-            }
-            return {
-                success: true,
-                credentials,
-                expiresAt
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `OAuth2 request failed: ${error.message}`
-            };
-        }
-    }
-    async refresh(config) {
-        // For OAuth2, refresh is typically the same as authenticate
-        // unless we have a refresh token (which we don't store currently)
-        return this.authenticate(config);
-    }
-    clear(config) {
-        const key = this.getCacheKey(config);
-        authCache.clear(key);
-        return Promise.resolve();
-    }
-    async validate(config) {
-        const key = this.getCacheKey(config);
-        return authCache.has(key);
-    }
-    getCacheKey(config) {
-        return createCacheKey('oauth2', config.client_id);
-    }
-}

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

@@ -1,101 +0,0 @@
-/**
- * Coverage Analyzer
- *
- * Analyzes coverage data to provide insights, trends, and recommendations.
- */
-import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageTrend, CoverageGap, CoverageComparison, CoverageThreshold, CoverageType, CoverageReport } from './types.js';
-/**
- * Historical coverage data point
- */
-interface HistoricalCoverage {
-    runId: string;
-    timestamp: number;
-    metrics: CoverageMetrics;
-}
-/**
- * Coverage Analyzer class
- */
-export declare class CoverageAnalyzer {
-    private history;
-    /**
-     * Analyze coverage and generate insights
-     */
-    analyze(result: CoverageResult, threshold?: CoverageThreshold): CoverageReport;
-    /**
-     * Check if coverage meets thresholds
-     */
-    checkThresholds(metrics: CoverageMetrics, threshold?: CoverageThreshold): boolean;
-    /**
-     * Check if a single file meets thresholds
-     */
-    checkFileThresholds(file: FileCoverage, threshold?: CoverageThreshold): boolean;
-    /**
-     * Find coverage gaps
-     */
-    findGaps(files: Record<string, FileCoverage>, threshold?: CoverageThreshold): CoverageGap[];
-    /**
-     * Calculate priority for covering a file
-     */
-    private calculatePriority;
-    /**
-     * Estimate effort to cover a file
-     */
-    private estimateEffort;
-    /**
-     * Generate test suggestions for a file
-     */
-    private generateSuggestions;
-    /**
-     * Group consecutive numbers into ranges
-     */
-    private groupConsecutiveNumbers;
-    /**
-     * Get top and bottom files by coverage
-     */
-    getTopFiles(files: Record<string, FileCoverage>, limit?: number): Array<{
-        path: string;
-        coverage: number;
-        type: 'best' | 'worst';
-    }>;
-    /**
-     * Compare two coverage results
-     */
-    compare(baseResult: CoverageResult, compareResult: CoverageResult): CoverageComparison;
-    /**
-     * Add historical coverage data
-     */
-    addHistory(key: string, data: HistoricalCoverage): void;
-    /**
-     * Get coverage trends
-     */
-    getTrends(key: string, type?: CoverageType, limit?: number): CoverageTrend[];
-    /**
-     * Calculate trend direction
-     */
-    getTrendDirection(trends: CoverageTrend[]): 'improving' | 'stable' | 'declining';
-    /**
-     * Predict future coverage based on trends
-     */
-    predictCoverage(key: string, type: CoverageType | undefined, targetCoverage: number): {
-        predictedReach: number | null;
-        projectedCoverage: number;
-        confidence: 'high' | 'medium' | 'low';
-    };
-    /**
-     * Generate coverage summary text
-     */
-    generateSummary(metrics: CoverageMetrics): string;
-    /**
-     * Format coverage percentage with color indicator
-     */
-    formatCoverage(percentage: number, threshold?: number): string;
-    /**
-     * Clear history
-     */
-    clearHistory(key?: string): void;
-}
-/**
- * Create a coverage analyzer
- */
-export declare function createCoverageAnalyzer(): CoverageAnalyzer;
-export {};

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