qa360 2.1.2 → 2.1.4

package/dist/core/types/trust-score.d.ts

@@ -1,69 +0,0 @@
-/**
- * QA360 Trust Score Calculator
- * Calcul du Trust Score pondéré basé sur les résultats des gates
- */
-export interface TrustScoreWeights {
-    ui?: number;
-    api?: number;
-    perf?: number;
-    a11y?: number;
-    sast?: number;
-    deps?: number;
-    secrets?: number;
-    dast?: number;
-}
-export interface GateResult {
-    name: string;
-    success: boolean;
-    score: number;
-    weight: number;
-    details?: {
-        passed?: number;
-        total?: number;
-        duration?: number;
-        errors?: string[];
-    };
-}
-export interface TrustScoreResult {
-    overallScore: number;
-    weightedScore: number;
-    gateResults: GateResult[];
-    weights: TrustScoreWeights;
-    recommendation: 'EXCELLENT' | 'GOOD' | 'ACCEPTABLE' | 'NEEDS_IMPROVEMENT' | 'CRITICAL';
-    summary: {
-        totalGates: number;
-        passedGates: number;
-        failedGates: number;
-        averageScore: number;
-    };
-}
-export declare class TrustScoreCalculator {
-    private static readonly DEFAULT_WEIGHTS;
-    /**
-     * Calculate Trust Score from gate results
-     */
-    static calculateTrustScore(gateResults: Omit<GateResult, 'weight'>[], customWeights?: Partial<TrustScoreWeights>): TrustScoreResult;
-    /**
-     * Get recommendation based on score and results
-     */
-    private static getRecommendation;
-    /**
-     * Generate Trust Score badge
-     */
-    static generateBadge(trustScore: TrustScoreResult): string;
-    /**
-     * Get badge color based on score
-     */
-    private static getBadgeColor;
-    /**
-     * Generate detailed Trust Score report
-     */
-    static generateReport(trustScore: TrustScoreResult): string;
-    /**
-     * Validate weights configuration
-     */
-    static validateWeights(weights: Partial<TrustScoreWeights>): {
-        valid: boolean;
-        errors: string[];
-    };
-}

package/dist/core/types/trust-score.js

@@ -1,191 +0,0 @@
-/**
- * QA360 Trust Score Calculator
- * Calcul du Trust Score pondéré basé sur les résultats des gates
- */
-export class TrustScoreCalculator {
-    static DEFAULT_WEIGHTS = {
-        ui: 20,
-        api: 20,
-        perf: 15,
-        a11y: 10,
-        sast: 15,
-        deps: 10,
-        secrets: 5,
-        dast: 5
-    };
-    /**
-     * Calculate Trust Score from gate results
-     */
-    static calculateTrustScore(gateResults, customWeights) {
-        const weights = { ...this.DEFAULT_WEIGHTS, ...customWeights };
-        // Normalize weights to sum to 100
-        const totalWeight = Object.values(weights).reduce((sum, w) => sum + (w || 0), 0);
-        const normalizedWeights = {};
-        for (const [gate, weight] of Object.entries(weights)) {
-            if (weight && weight > 0) {
-                normalizedWeights[gate] = (weight / totalWeight) * 100;
-            }
-        }
-        // Apply weights to gate results
-        const weightedGateResults = gateResults.map(gate => ({
-            ...gate,
-            weight: normalizedWeights[gate.name] || 0
-        }));
-        // Calculate weighted score
-        let weightedScore = 0;
-        let totalAppliedWeight = 0;
-        for (const gate of weightedGateResults) {
-            if (gate.weight > 0) {
-                weightedScore += (gate.score * gate.weight) / 100;
-                totalAppliedWeight += gate.weight;
-            }
-        }
-        // Normalize if not all gates are present
-        if (totalAppliedWeight > 0 && totalAppliedWeight < 100) {
-            weightedScore = (weightedScore / totalAppliedWeight) * 100;
-        }
-        // Calculate overall score (simple average)
-        const overallScore = gateResults.length > 0
-            ? gateResults.reduce((sum, gate) => sum + gate.score, 0) / gateResults.length
-            : 0;
-        // Calculate summary
-        const summary = {
-            totalGates: gateResults.length,
-            passedGates: gateResults.filter(g => g.success).length,
-            failedGates: gateResults.filter(g => !g.success).length,
-            averageScore: overallScore
-        };
-        // Determine recommendation
-        const recommendation = this.getRecommendation(weightedScore, summary);
-        return {
-            overallScore: Math.round(overallScore),
-            weightedScore: Math.round(weightedScore),
-            gateResults: weightedGateResults,
-            weights: normalizedWeights,
-            recommendation,
-            summary
-        };
-    }
-    /**
-     * Get recommendation based on score and results
-     */
-    static getRecommendation(score, summary) {
-        // Critical if any security gates failed
-        const hasSecurityFailures = summary.failedGates > 0;
-        if (score >= 90 && !hasSecurityFailures) {
-            return 'EXCELLENT';
-        }
-        else if (score >= 80 && !hasSecurityFailures) {
-            return 'GOOD';
-        }
-        else if (score >= 70) {
-            return 'ACCEPTABLE';
-        }
-        else if (score >= 50) {
-            return 'NEEDS_IMPROVEMENT';
-        }
-        else {
-            return 'CRITICAL';
-        }
-    }
-    /**
-     * Generate Trust Score badge
-     */
-    static generateBadge(trustScore) {
-        const score = trustScore.weightedScore;
-        const color = this.getBadgeColor(score);
-        const label = `Trust Score: ${score}%`;
-        return `https://img.shields.io/badge/Trust%20Score-${score}%25-${color}`;
-    }
-    /**
-     * Get badge color based on score
-     */
-    static getBadgeColor(score) {
-        if (score >= 90)
-            return 'brightgreen';
-        if (score >= 80)
-            return 'green';
-        if (score >= 70)
-            return 'yellow';
-        if (score >= 50)
-            return 'orange';
-        return 'red';
-    }
-    /**
-     * Generate detailed Trust Score report
-     */
-    static generateReport(trustScore) {
-        let report = `# QA360 Trust Score Report\n\n`;
-        report += `## Overall Assessment\n`;
-        report += `- **Trust Score**: ${trustScore.weightedScore}% (weighted)\n`;
-        report += `- **Simple Average**: ${trustScore.overallScore}%\n`;
-        report += `- **Recommendation**: ${trustScore.recommendation}\n`;
-        report += `- **Gates Passed**: ${trustScore.summary.passedGates}/${trustScore.summary.totalGates}\n\n`;
-        report += `## Gate Results\n\n`;
-        for (const gate of trustScore.gateResults) {
-            const status = gate.success ? '✅' : '❌';
-            report += `### ${status} ${gate.name.toUpperCase()} Gate\n`;
-            report += `- **Score**: ${gate.score}%\n`;
-            report += `- **Weight**: ${gate.weight.toFixed(1)}%\n`;
-            report += `- **Status**: ${gate.success ? 'PASSED' : 'FAILED'}\n`;
-            if (gate.details) {
-                if (gate.details.passed !== undefined && gate.details.total !== undefined) {
-                    report += `- **Tests**: ${gate.details.passed}/${gate.details.total} passed\n`;
-                }
-                if (gate.details.duration) {
-                    report += `- **Duration**: ${gate.details.duration}ms\n`;
-                }
-                if (gate.details.errors && gate.details.errors.length > 0) {
-                    report += `- **Errors**: ${gate.details.errors.length} found\n`;
-                }
-            }
-            report += '\n';
-        }
-        report += `## Weights Configuration\n\n`;
-        for (const [gate, weight] of Object.entries(trustScore.weights)) {
-            if (weight && weight > 0) {
-                report += `- **${gate.toUpperCase()}**: ${weight.toFixed(1)}%\n`;
-            }
-        }
-        report += `\n## Recommendations\n\n`;
-        switch (trustScore.recommendation) {
-            case 'EXCELLENT':
-                report += `🎉 Excellent quality! Your application meets the highest standards.\n`;
-                break;
-            case 'GOOD':
-                report += `👍 Good quality with minor areas for improvement.\n`;
-                break;
-            case 'ACCEPTABLE':
-                report += `⚠️ Acceptable quality but consider addressing failed gates.\n`;
-                break;
-            case 'NEEDS_IMPROVEMENT':
-                report += `🔧 Significant improvements needed. Focus on failed gates.\n`;
-                break;
-            case 'CRITICAL':
-                report += `🚨 Critical issues found. Immediate attention required.\n`;
-                break;
-        }
-        return report;
-    }
-    /**
-     * Validate weights configuration
-     */
-    static validateWeights(weights) {
-        const errors = [];
-        // Check for negative weights
-        for (const [gate, weight] of Object.entries(weights)) {
-            if (weight !== undefined && weight < 0) {
-                errors.push(`Weight for ${gate} cannot be negative: ${weight}`);
-            }
-        }
-        // Check total weight
-        const totalWeight = Object.values(weights).reduce((sum, w) => sum + (w || 0), 0);
-        if (totalWeight === 0) {
-            errors.push('Total weight cannot be zero');
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
-    }
-}

package/dist/core/vault/cas.d.ts

@@ -1,90 +0,0 @@
-/**
- * QA360 Content-Addressable Storage (CAS)
- * Stores files by their SHA256 hash with deduplication
- */
-export interface CASArtifact {
-    sha256: string;
-    path: string;
-    size: number;
-    exists: boolean;
-}
-export interface CASStats {
-    totalFiles: number;
-    totalBytes: number;
-    orphanedFiles: number;
-    orphanedBytes: number;
-}
-export declare class ContentAddressableStorage {
-    private readonly casRoot;
-    constructor(baseDir: string);
-    /**
-     * Save content to CAS, returns artifact metadata
-     */
-    saveArtifact(content: Buffer, mimeType: string, originalName?: string): Promise<CASArtifact>;
-    /**
-     * Save file to CAS by path
-     */
-    saveFile(filePath: string, mimeType: string): Promise<CASArtifact>;
-    /**
-     * Retrieve content from CAS
-     */
-    getArtifact(sha256: string): Promise<Buffer | null>;
-    /**
-     * Check if artifact exists in CAS
-     */
-    exists(sha256: string): boolean;
-    /**
-     * Get artifact metadata
-     */
-    getArtifactInfo(sha256: string): Promise<{
-        size: number;
-        mtime: Date;
-    } | null>;
-    /**
-     * List all artifacts in CAS
-     */
-    listArtifacts(): Promise<string[]>;
-    /**
-     * Get CAS statistics
-     */
-    getStats(referencedHashes?: Set<string>): Promise<CASStats>;
-    /**
-     * Remove orphaned artifacts
-     */
-    cleanupOrphans(referencedHashes: Set<string>): Promise<{
-        removedFiles: number;
-        freedBytes: number;
-    }>;
-    /**
-     * Calculate SHA256 hash of content
-     */
-    calculateHash(content: Buffer): string;
-    /**
-     * Calculate SHA256 hash of content (static utility)
-     */
-    static hashContent(content: Buffer): string;
-    /**
-     * Get CAS file path for a given hash (with sharding)
-     */
-    private getCASPath;
-    /**
-     * Ensure CAS directory structure exists
-     */
-    private ensureCASDirectory;
-    /**
-     * Clean up empty shard directories
-     */
-    private cleanupEmptyDirectories;
-    /**
-     * Verify artifact integrity
-     */
-    verifyArtifact(sha256: string): Promise<boolean>;
-    /**
-     * Copy artifact to external path
-     */
-    exportArtifact(sha256: string, targetPath: string): Promise<boolean>;
-    /**
-     * Get human-readable size
-     */
-    static formatBytes(bytes: number): string;
-}

package/dist/core/vault/cas.js

@@ -1,261 +0,0 @@
-/**
- * QA360 Content-Addressable Storage (CAS)
- * Stores files by their SHA256 hash with deduplication
- */
-import { createHash } from 'crypto';
-import { promises as fs } from 'fs';
-import { join, dirname } from 'path';
-import { existsSync, mkdirSync, statSync } from 'fs';
-export class ContentAddressableStorage {
-    casRoot;
-    constructor(baseDir) {
-        this.casRoot = join(baseDir, 'cas');
-        this.ensureCASDirectory();
-    }
-    /**
-     * Save content to CAS, returns artifact metadata
-     */
-    async saveArtifact(content, mimeType, originalName) {
-        const sha256 = this.calculateHash(content);
-        const casPath = this.getCASPath(sha256);
-        const size = content.length;
-        // Check if file already exists (deduplication)
-        if (existsSync(casPath)) {
-            return {
-                sha256,
-                path: casPath,
-                size,
-                exists: true
-            };
-        }
-        // Ensure directory exists
-        await fs.mkdir(dirname(casPath), { recursive: true });
-        // Write content atomically
-        const tempPath = `${casPath}.tmp`;
-        await fs.writeFile(tempPath, content);
-        await fs.rename(tempPath, casPath);
-        return {
-            sha256,
-            path: casPath,
-            size,
-            exists: false
-        };
-    }
-    /**
-     * Save file to CAS by path
-     */
-    async saveFile(filePath, mimeType) {
-        const content = await fs.readFile(filePath);
-        const originalName = filePath.split('/').pop();
-        return this.saveArtifact(content, mimeType, originalName);
-    }
-    /**
-     * Retrieve content from CAS
-     */
-    async getArtifact(sha256) {
-        const casPath = this.getCASPath(sha256);
-        if (!existsSync(casPath)) {
-            return null;
-        }
-        return fs.readFile(casPath);
-    }
-    /**
-     * Check if artifact exists in CAS
-     */
-    exists(sha256) {
-        return existsSync(this.getCASPath(sha256));
-    }
-    /**
-     * Get artifact metadata
-     */
-    async getArtifactInfo(sha256) {
-        const casPath = this.getCASPath(sha256);
-        if (!existsSync(casPath)) {
-            return null;
-        }
-        const stats = statSync(casPath);
-        return {
-            size: stats.size,
-            mtime: stats.mtime
-        };
-    }
-    /**
-     * List all artifacts in CAS
-     */
-    async listArtifacts() {
-        const artifacts = [];
-        try {
-            const shards = await fs.readdir(this.casRoot);
-            for (const shard of shards) {
-                if (shard.length !== 2)
-                    continue;
-                const shardPath = join(this.casRoot, shard);
-                const subShards = await fs.readdir(shardPath);
-                for (const subShard of subShards) {
-                    if (subShard.length !== 2)
-                        continue;
-                    const subShardPath = join(shardPath, subShard);
-                    const files = await fs.readdir(subShardPath);
-                    for (const file of files) {
-                        if (file.length === 64) { // SHA256 length
-                            artifacts.push(file);
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // CAS directory might not exist yet
-        }
-        return artifacts;
-    }
-    /**
-     * Get CAS statistics
-     */
-    async getStats(referencedHashes) {
-        const artifacts = await this.listArtifacts();
-        let totalFiles = 0;
-        let totalBytes = 0;
-        let orphanedFiles = 0;
-        let orphanedBytes = 0;
-        for (const sha256 of artifacts) {
-            const info = await this.getArtifactInfo(sha256);
-            if (!info)
-                continue;
-            totalFiles++;
-            totalBytes += info.size;
-            if (referencedHashes && !referencedHashes.has(sha256)) {
-                orphanedFiles++;
-                orphanedBytes += info.size;
-            }
-        }
-        return {
-            totalFiles,
-            totalBytes,
-            orphanedFiles,
-            orphanedBytes
-        };
-    }
-    /**
-     * Remove orphaned artifacts
-     */
-    async cleanupOrphans(referencedHashes) {
-        const artifacts = await this.listArtifacts();
-        let removedFiles = 0;
-        let freedBytes = 0;
-        for (const sha256 of artifacts) {
-            if (referencedHashes.has(sha256)) {
-                continue; // Keep referenced artifacts
-            }
-            const casPath = this.getCASPath(sha256);
-            const info = await this.getArtifactInfo(sha256);
-            if (info) {
-                await fs.unlink(casPath);
-                removedFiles++;
-                freedBytes += info.size;
-            }
-        }
-        // Clean up empty directories
-        await this.cleanupEmptyDirectories();
-        return { removedFiles, freedBytes };
-    }
-    /**
-     * Calculate SHA256 hash of content
-     */
-    calculateHash(content) {
-        return createHash('sha256').update(content).digest('hex');
-    }
-    /**
-     * Calculate SHA256 hash of content (static utility)
-     */
-    static hashContent(content) {
-        return createHash('sha256').update(content).digest('hex');
-    }
-    /**
-     * Get CAS file path for a given hash (with sharding)
-     */
-    getCASPath(sha256) {
-        if (sha256.length !== 64) {
-            throw new Error(`Invalid SHA256 hash: ${sha256}`);
-        }
-        // Shard using first 4 characters: aa/bb/aabbcc...
-        const shard1 = sha256.substring(0, 2);
-        const shard2 = sha256.substring(2, 4);
-        return join(this.casRoot, shard1, shard2, sha256);
-    }
-    /**
-     * Ensure CAS directory structure exists
-     */
-    ensureCASDirectory() {
-        if (!existsSync(this.casRoot)) {
-            mkdirSync(this.casRoot, { recursive: true });
-        }
-    }
-    /**
-     * Clean up empty shard directories
-     */
-    async cleanupEmptyDirectories() {
-        try {
-            const shards = await fs.readdir(this.casRoot);
-            for (const shard of shards) {
-                if (shard.length !== 2)
-                    continue;
-                const shardPath = join(this.casRoot, shard);
-                const subShards = await fs.readdir(shardPath);
-                for (const subShard of subShards) {
-                    if (subShard.length !== 2)
-                        continue;
-                    const subShardPath = join(shardPath, subShard);
-                    const files = await fs.readdir(subShardPath);
-                    if (files.length === 0) {
-                        await fs.rmdir(subShardPath);
-                    }
-                }
-                // Check if shard directory is now empty
-                const remainingSubShards = await fs.readdir(shardPath);
-                if (remainingSubShards.length === 0) {
-                    await fs.rmdir(shardPath);
-                }
-            }
-        }
-        catch (error) {
-            // Ignore cleanup errors
-        }
-    }
-    /**
-     * Verify artifact integrity
-     */
-    async verifyArtifact(sha256) {
-        const content = await this.getArtifact(sha256);
-        if (!content) {
-            return false;
-        }
-        const actualHash = this.calculateHash(content);
-        return actualHash === sha256;
-    }
-    /**
-     * Copy artifact to external path
-     */
-    async exportArtifact(sha256, targetPath) {
-        const content = await this.getArtifact(sha256);
-        if (!content) {
-            return false;
-        }
-        await fs.mkdir(dirname(targetPath), { recursive: true });
-        await fs.writeFile(targetPath, content);
-        return true;
-    }
-    /**
-     * Get human-readable size
-     */
-    static formatBytes(bytes) {
-        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-        let size = bytes;
-        let unitIndex = 0;
-        while (size >= 1024 && unitIndex < units.length - 1) {
-            size /= 1024;
-            unitIndex++;
-        }
-        return `${size.toFixed(1)} ${units[unitIndex]}`;
-    }
-}