qa360 2.2.7 → 2.2.10

package/cli/dist/core/pack/validator.js

@@ -20,7 +20,15 @@ export class PackValidator {
         // Load schema (ES modules compatible)
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = dirname(__filename);
-        const schemaPath = join(__dirname, '../../schemas/pack.schema.json');
+        // Try multiple paths to handle both development and bundled environments
+        let schemaPath = join(__dirname, '../../schemas/pack.schema.json');
+        try {
+            readFileSync(schemaPath, 'utf8');
+        }
+        catch {
+            // Fallback for bundled environment (cli/dist/core/pack/*.js)
+            schemaPath = join(__dirname, '../schemas/pack.schema.json');
+        }
         this.schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
         this.ajv.addSchema(this.schema, 'pack-v1');
     }

package/cli/dist/core/pack-v2/migrator.d.ts

@@ -47,6 +47,7 @@ export declare class PackMigrator {
     private findSecretInEnv;
     /**
      * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
      */
     private sanitizeGateName;
     /**

package/cli/dist/core/pack-v2/migrator.js

@@ -424,8 +424,33 @@ export class PackMigrator {
     }
     /**
      * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
      */
     sanitizeGateName(gate) {
+        // Handle edge case where gate might be an object from YAML parsing
+        if (typeof gate !== 'string') {
+            // If gate is an object, try to extract a name
+            if (gate && typeof gate === 'object') {
+                // Try common property names
+                const possibleName = gate.name || gate.id || gate.gate;
+                if (typeof possibleName === 'string') {
+                    gate = possibleName;
+                }
+                else {
+                    // Fallback: stringify the object keys
+                    const keys = Object.keys(gate);
+                    if (keys.length === 1) {
+                        gate = keys[0];
+                    }
+                    else {
+                        throw new Error(`Invalid gate format: expected string, got object with keys: ${keys.join(', ')}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Invalid gate format: expected string, got ${typeof gate}`);
+            }
+        }
         // Map v1 gate names to v2 conventions
         const nameMap = {
             'api_smoke': 'smoke',

package/cli/dist/core/pack-v2/validator.js

@@ -370,7 +370,8 @@ export class PackValidatorV2 {
             // Validate auth profile reference
             if (gate.auth) {
                 // Will be validated against profiles in auth section
-                if (!gate.adapter?.includes('api') && !gate.adapter?.includes('ui')) {
+                const adapter = typeof gate.adapter === 'string' ? gate.adapter : '';
+                if (adapter && !adapter.includes('api') && !adapter.includes('ui')) {
                     warnings.push({
                         code: 'QP2V019',
                         message: `Auth profile specified but adapter may not support auth`,
@@ -593,7 +594,7 @@ export class PackValidatorV2 {
             return { errors, warnings };
         }
         // Check for API gate with api auth but no auth profile
-        const apiGates = Object.entries(pack.gates).filter(([_, g]) => g.adapter?.includes('api'));
+        const apiGates = Object.entries(pack.gates).filter(([_, g]) => typeof g.adapter === 'string' && g.adapter.includes('api'));
         if (apiGates.length > 0 && !pack.auth?.api && !pack.auth?.profiles) {
             warnings.push({
                 code: 'QP2V034',
@@ -603,7 +604,7 @@ export class PackValidatorV2 {
             });
         }
         // Check for UI gate with ui auth but no auth profile
-        const uiGates = Object.entries(pack.gates).filter(([_, g]) => g.adapter?.includes('ui'));
+        const uiGates = Object.entries(pack.gates).filter(([_, g]) => typeof g.adapter === 'string' && g.adapter.includes('ui'));
         if (uiGates.length > 0 && !pack.auth?.ui && !pack.auth?.profiles) {
             warnings.push({
                 code: 'QP2V035',

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.2.4",
+  "version": "2.2.10",
   "description": "QA360 Proof CLI - Quality as Cryptographic Proof",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.2.7",
+  "version": "2.2.10",
   "description": "Transform software testing into verifiable, signed, and traceable proofs",
   "type": "module",
   "packageManager": "pnpm@9.12.2",

package/cli/dist/core/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/core/coverage/analyzer.js

@@ -1,415 +0,0 @@
-/**
- * Coverage Analyzer
- *
- * Analyzes coverage data to provide insights, trends, and recommendations.
- */
-/**
- * Coverage Analyzer class
- */
-export class CoverageAnalyzer {
-    history = new Map();
-    /**
-     * Analyze coverage and generate insights
-     */
-    analyze(result, threshold) {
-        const thresholdsMet = this.checkThresholds(result.metrics, threshold);
-        const gaps = this.findGaps(result.files, threshold);
-        const topFiles = this.getTopFiles(result.files);
-        return {
-            runId: `run_${Date.now()}`,
-            timestamp: Date.now(),
-            metrics: result.metrics,
-            byGate: { [result.gate]: result.metrics },
-            topFiles,
-            gaps: gaps.slice(0, 10), // Top 10 gaps
-            thresholdsMet,
-            thresholdViolations: gaps.map(g => g.path)
-        };
-    }
-    /**
-     * Check if coverage meets thresholds
-     */
-    checkThresholds(metrics, threshold) {
-        if (!threshold) {
-            return true;
-        }
-        if (threshold.scope === 'per-file') {
-            // Per-file thresholds checked separately
-            return true;
-        }
-        if (threshold.line !== undefined && metrics.lineCoverage < threshold.line) {
-            return false;
-        }
-        if (threshold.branch !== undefined && metrics.branchCoverage < threshold.branch) {
-            return false;
-        }
-        if (threshold.function !== undefined && metrics.functionCoverage < threshold.function) {
-            return false;
-        }
-        if (threshold.statement !== undefined && metrics.statementCoverage < threshold.statement) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Check if a single file meets thresholds
-     */
-    checkFileThresholds(file, threshold) {
-        if (!threshold) {
-            return true;
-        }
-        if (threshold.line !== undefined && file.lineCoverage < threshold.line) {
-            return false;
-        }
-        if (threshold.branch !== undefined && file.branchCoverage < threshold.branch) {
-            return false;
-        }
-        if (threshold.function !== undefined && file.functionCoverage < threshold.function) {
-            return false;
-        }
-        if (threshold.statement !== undefined && file.statementCoverage < threshold.statement) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Find coverage gaps
-     */
-    findGaps(files, threshold) {
-        const gaps = [];
-        const targetLine = threshold?.line ?? 80;
-        const targetBranch = threshold?.branch ?? 70;
-        const targetFunction = threshold?.function ?? 75;
-        for (const [path, file] of Object.entries(files)) {
-            const minTarget = Math.min(targetLine, targetBranch, targetFunction);
-            const avgCoverage = (file.lineCoverage + file.branchCoverage + file.functionCoverage) / 3;
-            if (avgCoverage < minTarget) {
-                gaps.push({
-                    path,
-                    currentCoverage: avgCoverage,
-                    targetCoverage: minTarget,
-                    gap: minTarget - avgCoverage,
-                    priority: this.calculatePriority(file, minTarget),
-                    effort: this.estimateEffort(file),
-                    uncoveredCount: file.uncoveredLines.length,
-                    suggestions: this.generateSuggestions(file)
-                });
-            }
-        }
-        // Sort by gap size, then priority
-        gaps.sort((a, b) => {
-            if (a.priority !== b.priority) {
-                const priorityOrder = { high: 0, medium: 1, low: 2 };
-                return priorityOrder[a.priority] - priorityOrder[b.priority];
-            }
-            return b.gap - a.gap;
-        });
-        return gaps;
-    }
-    /**
-     * Calculate priority for covering a file
-     */
-    calculatePriority(file, target) {
-        const gap = target - file.lineCoverage;
-        // High priority: large gap in important files
-        if (gap > 30) {
-            return 'high';
-        }
-        // Medium priority: moderate gap
-        if (gap > 10) {
-            return 'medium';
-        }
-        return 'low';
-    }
-    /**
-     * Estimate effort to cover a file
-     */
-    estimateEffort(file) {
-        const complexity = file.totalBranches + file.totalFunctions;
-        const uncoveredRatio = file.uncoveredLines.length / Math.max(file.totalLines, 1);
-        if (complexity > 100 || uncoveredRatio > 0.5) {
-            return 'high';
-        }
-        if (complexity > 30 || uncoveredRatio > 0.2) {
-            return 'medium';
-        }
-        return 'low';
-    }
-    /**
-     * Generate test suggestions for a file
-     */
-    generateSuggestions(file) {
-        const suggestions = [];
-        if (file.uncoveredLines.length > 0) {
-            const lineRanges = this.groupConsecutiveNumbers(file.uncoveredLines);
-            suggestions.push(`Add tests covering lines: ${lineRanges.slice(0, 3).join(', ')}`);
-        }
-        if (file.branchCoverage < file.lineCoverage) {
-            suggestions.push('Add tests for all branch conditions (true/false paths)');
-        }
-        if (file.functionCoverage < 100) {
-            suggestions.push('Add tests for uncovered functions');
-        }
-        if (file.totalFunctions === 0) {
-            suggestions.push('Consider splitting large functions into smaller, testable units');
-        }
-        return suggestions;
-    }
-    /**
-     * Group consecutive numbers into ranges
-     */
-    groupConsecutiveNumbers(numbers) {
-        if (numbers.length === 0)
-            return [];
-        const sorted = [...numbers].sort((a, b) => a - b);
-        const ranges = [];
-        let start = sorted[0];
-        let prev = sorted[0];
-        for (let i = 1; i < sorted.length; i++) {
-            if (sorted[i] === prev + 1) {
-                prev = sorted[i];
-            }
-            else {
-                ranges.push(start === prev ? `${start}` : `${start}-${prev}`);
-                start = sorted[i];
-                prev = sorted[i];
-            }
-        }
-        ranges.push(start === prev ? `${start}` : `${start}-${prev}`);
-        return ranges;
-    }
-    /**
-     * Get top and bottom files by coverage
-     */
-    getTopFiles(files, limit = 5) {
-        const fileArray = Object.entries(files).map(([path, file]) => ({
-            path,
-            coverage: file.lineCoverage,
-            type: 'best'
-        }));
-        // Sort by coverage
-        fileArray.sort((a, b) => b.coverage - a.coverage);
-        const result = [];
-        // Best files
-        for (let i = 0; i < Math.min(limit, fileArray.length); i++) {
-            result.push({ ...fileArray[i], type: 'best' });
-        }
-        // Worst files
-        for (let i = fileArray.length - 1; i >= Math.max(fileArray.length - limit, 0); i--) {
-            result.push({ path: fileArray[i].path, coverage: fileArray[i].coverage, type: 'worst' });
-        }
-        return result;
-    }
-    /**
-     * Compare two coverage results
-     */
-    compare(baseResult, compareResult) {
-        const baseFiles = baseResult.files;
-        const compareFiles = compareResult.files;
-        const improved = [];
-        const regressed = [];
-        const newFiles = [];
-        const removedFiles = [];
-        // Check all files in base
-        for (const [path, baseFile] of Object.entries(baseFiles)) {
-            const compareFile = compareFiles[path];
-            if (!compareFile) {
-                removedFiles.push(path);
-                continue;
-            }
-            const delta = compareFile.lineCoverage - baseFile.lineCoverage;
-            if (delta > 0.5) {
-                improved.push({
-                    path,
-                    before: baseFile.lineCoverage,
-                    after: compareFile.lineCoverage,
-                    delta
-                });
-            }
-            else if (delta < -0.5) {
-                regressed.push({
-                    path,
-                    before: baseFile.lineCoverage,
-                    after: compareFile.lineCoverage,
-                    delta
-                });
-            }
-        }
-        // Find new files
-        for (const path of Object.keys(compareFiles)) {
-            if (!baseFiles[path]) {
-                newFiles.push(path);
-            }
-        }
-        // Calculate overall change
-        const overallChange = compareResult.metrics.lineCoverage - baseResult.metrics.lineCoverage;
-        return {
-            baseRunId: `base_${baseResult.timestamp}`,
-            compareRunId: `compare_${compareResult.timestamp}`,
-            improved,
-            regressed,
-            newFiles,
-            removedFiles,
-            overallChange
-        };
-    }
-    /**
-     * Add historical coverage data
-     */
-    addHistory(key, data) {
-        if (!this.history.has(key)) {
-            this.history.set(key, []);
-        }
-        const history = this.history.get(key);
-        history.push(data);
-        // Keep only last 100 entries
-        if (history.length > 100) {
-            history.shift();
-        }
-    }
-    /**
-     * Get coverage trends
-     */
-    getTrends(key, type = 'line', limit = 30) {
-        const history = this.history.get(key) || [];
-        const sorted = history
-            .sort((a, b) => a.timestamp - b.timestamp)
-            .slice(-limit);
-        const trends = [];
-        let previousValue = 0;
-        for (const entry of sorted) {
-            let value;
-            switch (type) {
-                case 'line':
-                    value = entry.metrics.lineCoverage;
-                    break;
-                case 'branch':
-                    value = entry.metrics.branchCoverage;
-                    break;
-                case 'function':
-                    value = entry.metrics.functionCoverage;
-                    break;
-                case 'statement':
-                    value = entry.metrics.statementCoverage;
-                    break;
-            }
-            trends.push({
-                runId: entry.runId,
-                timestamp: entry.timestamp,
-                coverage: value,
-                type,
-                change: value - previousValue
-            });
-            previousValue = value;
-        }
-        return trends;
-    }
-    /**
-     * Calculate trend direction
-     */
-    getTrendDirection(trends) {
-        if (trends.length < 3) {
-            return 'stable';
-        }
-        const recent = trends.slice(-5);
-        const avgChange = recent.reduce((sum, t) => sum + t.change, 0) / recent.length;
-        if (avgChange > 1)
-            return 'improving';
-        if (avgChange < -1)
-            return 'declining';
-        return 'stable';
-    }
-    /**
-     * Predict future coverage based on trends
-     */
-    predictCoverage(key, type = 'line', targetCoverage) {
-        const trends = this.getTrends(key, type, 20);
-        if (trends.length < 5) {
-            return {
-                predictedReach: null,
-                projectedCoverage: trends[trends.length - 1]?.coverage || 0,
-                confidence: 'low'
-            };
-        }
-        // Simple linear regression
-        const n = trends.length;
-        let sumX = 0;
-        let sumY = 0;
-        let sumXY = 0;
-        let sumXX = 0;
-        for (let i = 0; i < n; i++) {
-            const x = i;
-            const y = trends[i].coverage;
-            sumX += x;
-            sumY += y;
-            sumXY += x * y;
-            sumXX += x * x;
-        }
-        const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-        const intercept = (sumY - slope * sumX) / n;
-        const currentCoverage = trends[n - 1].coverage;
-        const avgCoverage = sumY / n;
-        const variance = trends.reduce((sum, t) => sum + Math.pow(t.coverage - avgCoverage, 2), 0) / n;
-        // Determine confidence based on variance
-        let confidence;
-        if (variance < 25)
-            confidence = 'high';
-        else if (variance < 100)
-            confidence = 'medium';
-        else
-            confidence = 'low';
-        // Project coverage for next run
-        const projectedCoverage = currentCoverage + slope;
-        // Predict when target will be reached
-        let predictedReach = null;
-        if (slope > 0.1) {
-            const runsNeeded = (targetCoverage - currentCoverage) / slope;
-            if (runsNeeded > 0 && runsNeeded < 100) {
-                predictedReach = Date.now() + runsNeeded * 24 * 60 * 60 * 1000; // Assume daily runs
-            }
-        }
-        return { predictedReach, projectedCoverage, confidence };
-    }
-    /**
-     * Generate coverage summary text
-     */
-    generateSummary(metrics) {
-        const parts = [];
-        parts.push(`Line Coverage: ${metrics.lineCoverage.toFixed(1)}%`);
-        parts.push(`Branch Coverage: ${metrics.branchCoverage.toFixed(1)}%`);
-        parts.push(`Function Coverage: ${metrics.functionCoverage.toFixed(1)}%`);
-        if (metrics.totalFiles > 0) {
-            parts.push(`Files: ${metrics.filesWithCoverage}/${metrics.totalFiles}`);
-        }
-        return parts.join(' | ');
-    }
-    /**
-     * Format coverage percentage with color indicator
-     */
-    formatCoverage(percentage, threshold = 80) {
-        if (percentage >= threshold) {
-            return `✓ ${percentage.toFixed(1)}%`;
-        }
-        else if (percentage >= threshold - 10) {
-            return `⚠ ${percentage.toFixed(1)}%`;
-        }
-        return `✗ ${percentage.toFixed(1)}%`;
-    }
-    /**
-     * Clear history
-     */
-    clearHistory(key) {
-        if (key) {
-            this.history.delete(key);
-        }
-        else {
-            this.history.clear();
-        }
-    }
-}
-/**
- * Create a coverage analyzer
- */
-export function createCoverageAnalyzer() {
-    return new CoverageAnalyzer();
-}

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

@@ -1,74 +0,0 @@
-/**
- * Coverage Collector
- *
- * Collects coverage data from various test sources.
- * Supports Jest, Vitest, Cypress, Playwright, and LCOV formats.
- */
-import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageConfig } from './types.js';
-/**
- * Coverage Collector class
- */
-export declare class CoverageCollector {
-    private config;
-    constructor(config?: Partial<CoverageConfig>);
-    /**
-     * Collect coverage from a file path (auto-detect format)
-     */
-    collectFromFile(filePath: string): Promise<CoverageResult | null>;
-    /**
-     * Collect coverage from LCOV format
-     */
-    collectFromLcov(filePath: string): Promise<CoverageResult | null>;
-    /**
-     * Collect coverage from JSON format (Vitest/Istanbul)
-     */
-    collectFromJson(filePath: string): Promise<CoverageResult | null>;
-    /**
-     * Collect coverage from Istanbul format
-     */
-    collectFromIstanbul(filePath: string): Promise<CoverageResult | null>;
-    /**
-     * Parse LCOV format content
-     */
-    private parseLcov;
-    /**
-     * Convert LCOV record to FileCoverage
-     */
-    private convertLcovToFileCoverage;
-    /**
-     * Convert Vitest coverage data to FileCoverage
-     */
-    private convertVitestToFileCoverage;
-    /**
-     * Convert Istanbul coverage data to FileCoverage
-     */
-    private convertIstanbulToFileCoverage;
-    /**
-     * Calculate aggregate metrics from file coverage data
-     */
-    calculateMetrics(files: Record<string, FileCoverage>): CoverageMetrics;
-    /**
-     * Detect coverage format from file path
-     */
-    private detectFormat;
-    /**
-     * Filter files based on include/exclude patterns
-     */
-    filterFiles(files: Record<string, FileCoverage>): Record<string, FileCoverage>;
-    /**
-     * Match path against glob pattern
-     */
-    private matchPattern;
-    /**
-     * Merge multiple coverage results
-     */
-    mergeCoverageResults(results: CoverageResult[]): CoverageResult;
-    /**
-     * Update configuration
-     */
-    updateConfig(updates: Partial<CoverageConfig>): void;
-}
-/**
- * Create a coverage collector with default config
- */
-export declare function createCoverageCollector(config?: Partial<CoverageConfig>): CoverageCollector;