qa360 2.2.15 → 2.2.20

package/cli/dist/commands/retry.js

@@ -6,7 +6,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import Table from 'cli-table3';
-import { createSmartRetryEngine, RetryStrategy } from '../core/index.js';
+import { createSmartRetryEngine, RetryStrategy } from 'qa360-core';
 /**
  * Display retry statistics in a formatted table
  */

package/cli/dist/commands/run.d.ts

@@ -6,7 +6,7 @@
  *   qa360 run --output ./results
  *   qa360 run --verbose
  */
-import { type Phase3RunResult, type PackConfigV1, type PackConfigV2 } from '../core/index.js';
+import { type Phase3RunResult, type PackConfigV1, type PackConfigV2 } from 'qa360-core';
 /**
  * CLI options for run command
  */

package/cli/dist/commands/run.js

@@ -9,7 +9,7 @@
 import { existsSync } from 'fs';
 import { join, resolve, dirname } from 'path';
 import chalk from 'chalk';
-import { Phase3Runner, PackLoaderV2 } from '../core/index.js';
+import { Phase3Runner, PackLoaderV2 } from 'qa360-core';
 /**
  * Format gates for display (handles both v1 array and v2 object formats)
  */
@@ -150,6 +150,7 @@ export async function runCommand(packArg, options = {}) {
             pack,
             packDir, // Pass pack directory for resolving fixtures
             outputDir,
+            headed: options.headed,
         });
         const result = await runner.run();
         // Step 5: Display results

package/cli/dist/commands/secrets.js

@@ -5,7 +5,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import inquirer from 'inquirer';
-import { SecretsManager, SecretsCrypto } from '../core/index.js';
+import { SecretsManager, SecretsCrypto } from 'qa360-core';
 export class QA360Secrets {
     manager;
     constructor() {

package/cli/dist/commands/serve.js

@@ -3,7 +3,7 @@
  * Démarre le serveur d'observabilité
  */
 import { Command } from 'commander';
-import { QA360Server } from '../core/index.js';
+import { QA360Server } from 'qa360-core';
 export function createServeCommand() {
     return new Command('serve')
         .description('Start QA360 observability server')

package/cli/dist/commands/slo.js

@@ -4,7 +4,7 @@
  * CLI command for SLO/SLI management and reporting.
  */
 import { Command } from 'commander';
-import { SLOTracker, createDefaultSLOConfig, createStrictSLOConfig, createRelaxedSLOConfig, TimeWindows } from '../core/index.js';
+import { SLOTracker, createDefaultSLOConfig, createStrictSLOConfig, createRelaxedSLOConfig, TimeWindows } from 'qa360-core';
 export const sloCommand = new Command('slo');
 sloCommand.description('Service Level Objectives and Indicators management');
 // List all SLOs

package/cli/dist/commands/verify.js

@@ -14,7 +14,7 @@ import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, resolve, basename } from 'path';
 import chalk from 'chalk';
 // Import from core
-import { verifyProofFile, verifyPhase3Proof, VerificationCode, } from '../core/index.js';
+import { verifyProofFile, verifyPhase3Proof, VerificationCode, } from 'qa360-core';
 /**
  * Verify a proof file with automatic format detection
  */

package/cli/dist/core/ai/ollama-provider.js

@@ -32,28 +32,16 @@ export class OllamaProvider {
     }
     async isAvailable() {
         try {
-            // Use a longer timeout (15 seconds) to accommodate slower systems
-            // Ollama can take time to respond, especially on first run or with many models
+            // Use timeout with AbortSignal - wrap for compatibility
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 15000);
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
             const response = await fetch(`${this.baseUrl}/api/tags`, {
                 signal: controller.signal,
             });
             clearTimeout(timeoutId);
             return response.ok;
         }
-        catch (error) {
-            // Log the error for debugging (will be visible in verbose mode)
-            if (error instanceof Error) {
-                if (error.name === 'AbortError') {
-                    // Timeout - Ollama is slow to respond
-                    console.debug(`[Ollama] Connection to ${this.baseUrl} timed out after 15s`);
-                }
-                else {
-                    // Other error (ECONNREFUSED, ENOTFOUND, etc.)
-                    console.debug(`[Ollama] Connection error: ${error.message}`);
-                }
-            }
+        catch {
             return false;
         }
     }

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

@@ -0,0 +1,101 @@
+/**
+ * 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/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();
+}