qa360 1.0.1 → 1.0.3

package/dist/commands/report.js

@@ -1,129 +1,121 @@
 /**
- * QA360 Report Command - Signed proof generation
+ * QA360 Report Command - Phase3 Proof Reports
+ * Generates PDF/HTML/JSON reports from Phase3Runner proof files
  */
 import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { createHash, generateKeyPair, sign } from 'crypto';
 import chalk from 'chalk';
 import ora from 'ora';
 export class QA360Reporter {
     qa360Dir = join(process.cwd(), '.qa360');
     runsDir = join(this.qa360Dir, 'runs');
-    keysDir = join(this.qa360Dir, 'keys');
-    privateKeyPath = join(this.keysDir, 'qa360.key');
-    publicKeyPath = join(this.keysDir, 'qa360.pub');
     async generateReport(options = {}) {
-        console.log(chalk.blue('📋 QA360 Report - Génération de preuve\n'));
+        console.log(chalk.blue('📋 QA360 Report - Génération de rapport\n'));
         try {
-            // 1. Load latest run results
-            const runResult = await this.loadRunResults(options.runId);
-            console.log(chalk.green(`📊 Résultats chargés: ${runResult.pack.name}`));
-            // 2. Calculate trust score
-            const trustScore = this.calculateTrustScore(runResult);
-            console.log(chalk.cyan(`🎯 Trust Score: ${trustScore}%`));
-            // 3. Generate reports
+            // 1. Load proof document
+            const proof = await this.loadProofDocument(options.runId);
+            console.log(chalk.green(`📊 Preuve chargée: ${proof.pack.name} (${proof.runId})`));
+            console.log(chalk.cyan(`🎯 Trust Score: ${proof.execution.trustScore}%`));
+            console.log(chalk.gray(`🔏 Signature: ${proof.signature.algorithm}`));
+            // 2. Generate reports
             const outputs = [];
-            if (options.format === 'json' || options.format === 'both' || !options.format) {
-                const jsonPath = await this.generateJsonReport(runResult, trustScore);
+            const format = options.format || 'both';
+            if (format === 'json' || format === 'both') {
+                const jsonPath = await this.generateJsonReport(proof);
                 outputs.push(jsonPath);
             }
-            if (options.format === 'pdf' || options.format === 'both' || !options.format) {
-                const pdfPath = await this.generatePdfReport(runResult, trustScore);
-                outputs.push(pdfPath);
+            if (format === 'html') {
+                const htmlPath = await this.generateHtmlOnlyReport(proof);
+                outputs.push(htmlPath);
             }
-            // 4. Sign if requested
-            if (options.sign) {
-                await this.signReports(outputs, runResult, trustScore);
+            if (format === 'pdf' || format === 'both') {
+                const pdfPath = await this.generatePdfReport(proof);
+                outputs.push(pdfPath);
             }
             return outputs;
         }
         catch (error) {
-            console.error(chalk.red('❌ Erreur lors de la génération:'), error);
+            console.error(chalk.red('❌ Erreur:'), error);
             throw error;
         }
     }
-    async loadRunResults(runId) {
+    /**
+     * Load proof document from Phase3Runner
+     */
+    async loadProofDocument(runId) {
         if (!existsSync(this.runsDir)) {
-            throw new Error('Aucun résultat d\'exécution trouvé. Utilisez \'qa360 run\' d\'abord');
+            throw new Error('Aucune preuve trouvée. Utilisez \'qa360 run\' d\'abord.');
         }
-        let targetDir;
+        let proofPath;
         if (runId) {
-            targetDir = join(this.runsDir, runId);
-            if (!existsSync(targetDir)) {
-                throw new Error(`Run ID non trouvé: ${runId}`);
+            // Search for specific proof
+            proofPath = join(this.runsDir, `${runId}-proof.json`);
+            if (!existsSync(proofPath)) {
+                // Try with partial match
+                const files = readdirSync(this.runsDir).filter(f => f.includes(runId) && f.endsWith('-proof.json'));
+                if (files.length === 0) {
+                    throw new Error(`Preuve non trouvée: ${runId}`);
+                }
+                proofPath = join(this.runsDir, files[0]);
             }
         }
         else {
-            // Get latest run
-            const runs = readdirSync(this.runsDir)
-                .filter(dir => existsSync(join(this.runsDir, dir, 'results.json')))
+            // Find latest proof
+            const proofFiles = readdirSync(this.runsDir)
+                .filter(f => f.endsWith('-proof.json'))
                 .sort()
                 .reverse();
-            if (runs.length === 0) {
-                throw new Error('Aucun résultat d\'exécution trouvé');
+            if (proofFiles.length === 0) {
+                throw new Error('Aucune preuve trouvée.');
             }
-            targetDir = join(this.runsDir, runs[0]);
+            proofPath = join(this.runsDir, proofFiles[0]);
         }
-        const resultsPath = join(targetDir, 'results.json');
-        const content = readFileSync(resultsPath, 'utf8');
+        const content = readFileSync(proofPath, 'utf8');
         return JSON.parse(content);
     }
-    calculateTrustScore(runResult) {
-        const { summary } = runResult;
-        if (summary.total === 0)
-            return 0;
-        // Base score from success rate
-        let score = summary.successRate;
-        // Penalties and bonuses
-        if (summary.failed > 0) {
-            score -= Math.min(20, summary.failed * 5); // -5 points per failure, max -20
-        }
-        if (summary.skipped > summary.total * 0.5) {
-            score -= 10; // -10 if more than 50% skipped
-        }
-        // Bonus for comprehensive testing
-        if (runResult.pack.adapters.length > 2) {
-            score += 5; // +5 for multi-adapter testing
-        }
-        // Duration penalty for very slow tests
-        if (runResult.duration > 300000) { // 5 minutes
-            score -= 5;
-        }
-        return Math.max(0, Math.min(100, Math.round(score)));
+    /**
+     * Trust score is already calculated in proof document
+     */
+    getTrustScore(proof) {
+        return proof.execution.trustScore;
     }
-    async generateJsonReport(runResult, trustScore) {
+    async generateJsonReport(proof) {
         const spinner = ora('Génération rapport JSON...').start();
         try {
             const report = {
                 id: this.generateReportId(),
-                timestamp: new Date().toISOString(),
-                pack: {
-                    name: runResult.pack.name,
-                    version: runResult.pack.version,
-                    description: runResult.pack.description
+                generatedAt: new Date().toISOString(),
+                // Proof data
+                proof: {
+                    runId: proof.runId,
+                    timestamp: proof.timestamp,
+                    version: proof.version
                 },
-                execution: {
-                    timestamp: runResult.timestamp,
-                    duration: runResult.duration,
-                    summary: runResult.summary
+                // Pack info
+                pack: proof.pack,
+                // Execution results
+                execution: proof.execution,
+                // Gates detail
+                gates: proof.gates,
+                // Hooks timing
+                hooks: proof.hooks,
+                // Signature
+                signature: {
+                    algorithm: proof.signature.algorithm,
+                    verified: proof.signature.algorithm.includes('ed25519'),
+                    publicKey: proof.signature.publicKey ?
+                        proof.signature.publicKey.substring(0, 16) + '...' : 'none',
+                    timestamp: proof.signature.timestamp
                 },
-                trustScore,
-                results: runResult.results.map(r => ({
-                    name: r.name,
-                    adapter: r.adapter,
-                    status: r.status,
-                    duration: r.duration,
-                    error: r.error,
-                    output: r.output
-                })),
+                // Report metadata
                 metadata: {
-                    qa360Version: '0.9.0-core',
+                    qa360Version: '1.0.1',
                     platform: process.platform,
                     nodeVersion: process.version,
-                    generatedAt: new Date().toISOString()
+                    reportType: 'json'
                 }
             };
-            const reportPath = join(this.getLatestRunDir(), 'report.json');
+            const reportPath = join(this.runsDir, `${proof.runId}-report.json`);
             writeFileSync(reportPath, JSON.stringify(report, null, 2));
             spinner.succeed(`Rapport JSON généré: ${reportPath}`);
             return reportPath;
@@ -133,21 +125,35 @@ export class QA360Reporter {
             throw error;
         }
     }
-    async generatePdfReport(runResult, trustScore) {
+    async generatePdfReport(proof) {
         const spinner = ora('Génération rapport PDF...').start();
         try {
-            // PDF generation requires Playwright - use @playwright/test if needed
-            // For now, save HTML as PDF placeholder
-            const runDir = this.getLatestRunDir();
-            const htmlPath = join(runDir, 'report.html');
-            const pdfPath = join(runDir, 'proof.pdf');
-            // Generate HTML content
-            const htmlContent = this.generateHtmlReport(runResult, trustScore);
+            const htmlContent = this.generateHtmlReport(proof);
+            const htmlPath = join(this.runsDir, `${proof.runId}-report.html`);
+            const pdfPath = join(this.runsDir, `${proof.runId}-report.pdf`);
+            // Save HTML first
             writeFileSync(htmlPath, htmlContent);
-            // TODO: Implement actual PDF generation with Playwright
-            // For now, just save HTML with .pdf extension as placeholder
-            writeFileSync(pdfPath, htmlContent);
-            spinner.succeed(`Rapport PDF généré: ${pdfPath}`);
+            // Try PDF generation with Playwright
+            try {
+                // @ts-ignore - Dynamic import, Playwright is optional
+                const { chromium } = await import('playwright');
+                const browser = await chromium.launch({ headless: true });
+                const page = await browser.newPage();
+                await page.setContent(htmlContent, { waitUntil: 'networkidle' });
+                await page.pdf({
+                    path: pdfPath,
+                    format: 'A4',
+                    margin: { top: '20px', bottom: '20px', left: '20px', right: '20px' },
+                    printBackground: true
+                });
+                await browser.close();
+                spinner.succeed(`Rapport PDF généré: ${pdfPath}`);
+            }
+            catch (playwrightError) {
+                // Fallback: just keep HTML
+                writeFileSync(pdfPath, htmlContent);
+                spinner.warn(`Rapport HTML généré (Playwright non disponible): ${htmlPath}`);
+            }
             return pdfPath;
         }
         catch (error) {
@@ -155,180 +161,205 @@ export class QA360Reporter {
             throw error;
         }
     }
-    generateHtmlReport(runResult, trustScore) {
-        const { pack, summary, results, duration, timestamp } = runResult;
+    async generateHtmlOnlyReport(proof) {
+        const spinner = ora('Génération rapport HTML...').start();
+        const htmlContent = this.generateHtmlReport(proof);
+        const htmlPath = join(this.runsDir, `${proof.runId}-report.html`);
+        writeFileSync(htmlPath, htmlContent);
+        spinner.succeed(`Rapport HTML généré: ${htmlPath}`);
+        return htmlPath;
+    }
+    generateHtmlReport(proof) {
+        const { pack, execution, gates, signature } = proof;
+        const trustScore = execution.trustScore;
         const trustColor = trustScore >= 80 ? '#22c55e' : trustScore >= 60 ? '#f59e0b' : '#ef4444';
         const trustLabel = trustScore >= 80 ? 'ÉLEVÉ' : trustScore >= 60 ? 'MOYEN' : 'FAIBLE';
+        const signatureStatus = signature.algorithm.includes('ed25519')
+            ? '✅ Signé Ed25519'
+            : '⚠️ Non signé';
+        const passedGates = gates.filter(g => g.success).length;
         return `
 <!DOCTYPE html>
 <html>
 <head>
     <meta charset="UTF-8">
-    <title>QA360 Proof - ${pack.name}</title>
+    <title>QA360 Report - ${pack.name}</title>
     <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; margin: 0; padding: 20px; }
-        .header { text-align: center; border-bottom: 2px solid #3b82f6; padding-bottom: 20px; margin-bottom: 30px; }
-        .logo { font-size: 24px; font-weight: bold; color: #3b82f6; }
-        .title { font-size: 20px; margin: 10px 0; }
-        .trust-score { font-size: 48px; font-weight: bold; color: ${trustColor}; margin: 20px 0; }
-        .trust-label { background: ${trustColor}; color: white; padding: 5px 15px; border-radius: 20px; font-size: 14px; }
-        .summary { display: grid; grid-template-columns: repeat(4, 1fr); gap: 20px; margin: 30px 0; }
-        .metric { text-align: center; padding: 15px; border: 1px solid #e5e7eb; border-radius: 8px; }
-        .metric-value { font-size: 24px; font-weight: bold; margin-bottom: 5px; }
-        .metric-label { font-size: 12px; color: #6b7280; text-transform: uppercase; }
-        .tests { margin: 30px 0; }
-        .test { display: flex; justify-content: space-between; padding: 10px; border-bottom: 1px solid #f3f4f6; }
-        .test-name { font-weight: 500; }
-        .test-status { padding: 2px 8px; border-radius: 4px; font-size: 12px; }
-        .passed { background: #dcfce7; color: #166534; }
-        .failed { background: #fecaca; color: #991b1b; }
-        .skipped { background: #fef3c7; color: #92400e; }
-        .footer { margin-top: 40px; padding-top: 20px; border-top: 1px solid #e5e7eb; font-size: 12px; color: #6b7280; }
-        .qr-placeholder { width: 100px; height: 100px; border: 2px dashed #d1d5db; margin: 20px auto; display: flex; align-items: center; justify-content: center; }
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { 
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; 
+          background: #f8fafc; 
+          color: #1e293b;
+          line-height: 1.6;
+        }
+        .container { max-width: 900px; margin: 0 auto; padding: 40px 20px; }
+        
+        .header { 
+          background: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%);
+          color: white;
+          padding: 40px;
+          border-radius: 16px;
+          text-align: center;
+          margin-bottom: 30px;
+        }
+        .logo { font-size: 28px; font-weight: 800; margin-bottom: 8px; }
+        .subtitle { opacity: 0.9; font-size: 14px; }
+        
+        .trust-card {
+          background: white;
+          border-radius: 16px;
+          padding: 30px;
+          text-align: center;
+          margin-bottom: 30px;
+          box-shadow: 0 4px 6px -1px rgba(0,0,0,0.1);
+        }
+        .trust-score { 
+          font-size: 72px; 
+          font-weight: 800; 
+          color: ${trustColor};
+          line-height: 1;
+        }
+        .trust-label { 
+          display: inline-block;
+          background: ${trustColor}; 
+          color: white; 
+          padding: 6px 16px; 
+          border-radius: 20px; 
+          font-size: 12px;
+          font-weight: 600;
+          margin-top: 10px;
+        }
+        
+        .info-grid {
+          display: grid;
+          grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+          gap: 20px;
+          margin-bottom: 30px;
+        }
+        .info-card {
+          background: white;
+          border-radius: 12px;
+          padding: 20px;
+          box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        .info-label { font-size: 12px; color: #64748b; text-transform: uppercase; font-weight: 600; }
+        .info-value { font-size: 18px; font-weight: 600; margin-top: 4px; }
+        
+        .section {
+          background: white;
+          border-radius: 12px;
+          padding: 24px;
+          margin-bottom: 20px;
+          box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        .section-title { font-size: 18px; font-weight: 600; margin-bottom: 16px; }
+        
+        .gate {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          padding: 12px 0;
+          border-bottom: 1px solid #f1f5f9;
+        }
+        .gate:last-child { border-bottom: none; }
+        .gate-name { font-weight: 500; }
+        .gate-meta { font-size: 12px; color: #64748b; }
+        .gate-status {
+          padding: 4px 12px;
+          border-radius: 6px;
+          font-size: 12px;
+          font-weight: 600;
+        }
+        .status-pass { background: #dcfce7; color: #166534; }
+        .status-fail { background: #fecaca; color: #991b1b; }
+        
+        .signature-box {
+          background: #f8fafc;
+          border: 1px solid #e2e8f0;
+          border-radius: 8px;
+          padding: 16px;
+          font-family: monospace;
+          font-size: 12px;
+          word-break: break-all;
+        }
+        
+        .footer {
+          text-align: center;
+          padding: 20px;
+          color: #64748b;
+          font-size: 12px;
+        }
     </style>
 </head>
 <body>
-    <div class="header">
-        <div class="logo">QA360 CORE</div>
-        <div class="title">Preuve de Qualité Vérifiable</div>
-        <div class="trust-score">${trustScore}%</div>
-        <div class="trust-label">CONFIANCE ${trustLabel}</div>
-    </div>
-
-    <div class="pack-info">
-        <h2>${pack.name}</h2>
-        <p><strong>Version:</strong> ${pack.version}</p>
-        <p><strong>Description:</strong> ${pack.description}</p>
-        <p><strong>Exécuté le:</strong> ${new Date(timestamp).toLocaleString('fr-FR')}</p>
-        <p><strong>Durée:</strong> ${Math.round(duration / 1000)}s</p>
-    </div>
-
-    <div class="summary">
-        <div class="metric">
-            <div class="metric-value" style="color: #3b82f6;">${summary.total}</div>
-            <div class="metric-label">Total Tests</div>
-        </div>
-        <div class="metric">
-            <div class="metric-value" style="color: #22c55e;">${summary.passed}</div>
-            <div class="metric-label">Succès</div>
+    <div class="container">
+        <div class="header">
+            <div class="logo">QA360</div>
+            <div class="subtitle">Preuve de Qualité Cryptographique</div>
         </div>
-        <div class="metric">
-            <div class="metric-value" style="color: #ef4444;">${summary.failed}</div>
-            <div class="metric-label">Échecs</div>
+        
+        <div class="trust-card">
+            <div class="trust-score">${trustScore}%</div>
+            <div class="trust-label">CONFIANCE ${trustLabel}</div>
         </div>
-        <div class="metric">
-            <div class="metric-value" style="color: #f59e0b;">${summary.skipped}</div>
-            <div class="metric-label">Ignorés</div>
+        
+        <div class="info-grid">
+            <div class="info-card">
+                <div class="info-label">Pack</div>
+                <div class="info-value">${pack.name}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">Version</div>
+                <div class="info-value">${pack.version || '1.0.0'}</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">Durée</div>
+                <div class="info-value">${Math.round(execution.duration / 1000)}s</div>
+            </div>
+            <div class="info-card">
+                <div class="info-label">Statut</div>
+                <div class="info-value">${execution.success ? '✅ Succès' : '❌ Échec'}</div>
+            </div>
         </div>
-    </div>
-
-    <div class="tests">
-        <h3>Détail des Tests</h3>
-        ${results.map(test => `
-            <div class="test">
-                <div>
-                    <div class="test-name">${test.name}</div>
-                    <div style="font-size: 12px; color: #6b7280;">${test.adapter} • ${test.duration}ms</div>
+        
+        <div class="section">
+            <div class="section-title">Quality Gates (${passedGates}/${gates.length})</div>
+            ${gates.map(gate => `
+                <div class="gate">
+                    <div>
+                        <div class="gate-name">${gate.gate}</div>
+                        <div class="gate-meta">${gate.adapter} • ${gate.duration}ms</div>
+                    </div>
+                    <div class="gate-status ${gate.success ? 'status-pass' : 'status-fail'}">
+                        ${gate.success ? 'PASS' : 'FAIL'}
+                    </div>
                 </div>
-                <div class="test-status ${test.status}">${this.getStatusLabel(test.status)}</div>
+            `).join('')}
+        </div>
+        
+        <div class="section">
+            <div class="section-title">Signature Cryptographique</div>
+            <p style="margin-bottom: 12px; color: #64748b;">
+                ${signatureStatus} • ${proof.timestamp}
+            </p>
+            <div class="signature-box">
+                <strong>Algorithm:</strong> ${signature.algorithm}<br>
+                <strong>Run ID:</strong> ${proof.runId}<br>
+                <strong>Signature:</strong> ${signature.value.substring(0, 64)}...
             </div>
-        `).join('')}
-    </div>
-
-    <div class="qr-placeholder">
-        QR Code
-        <br>
-        (Phase 2)
-    </div>
-
-    <div class="footer">
-        <p><strong>Signature:</strong> [Signature Ed25519 - Phase 1 implémentation]</p>
-        <p><strong>Généré par:</strong> QA360 Core v0.9.0-core</p>
-        <p><strong>Plateforme:</strong> ${process.platform} ${process.arch}</p>
-        <p><strong>Hash:</strong> ${this.generateContentHash(runResult)}</p>
+        </div>
+        
+        <div class="footer">
+            <p>Généré par QA360 v1.0.1 • ${new Date().toLocaleString('fr-FR')}</p>
+            <p>Vérifiez cette preuve avec: <code>qa360 verify ${proof.runId}</code></p>
+        </div>
     </div>
 </body>
 </html>`;
     }
-    getStatusLabel(status) {
-        switch (status) {
-            case 'passed': return 'SUCCÈS';
-            case 'failed': return 'ÉCHEC';
-            case 'skipped': return 'IGNORÉ';
-            default: return status.toUpperCase();
-        }
-    }
-    generateContentHash(runResult) {
-        const content = JSON.stringify(runResult, null, 0);
-        return createHash('sha256').update(content).digest('hex').substring(0, 16);
-    }
     generateReportId() {
         return 'qa360-' + Date.now().toString(36) + '-' + Math.random().toString(36).substring(2, 8);
     }
-    getLatestRunDir() {
-        const runs = readdirSync(this.runsDir).sort().reverse();
-        return join(this.runsDir, runs[0]);
-    }
-    async signReports(reportPaths, runResult, trustScore) {
-        const spinner = ora('Signature cryptographique...').start();
-        try {
-            // Ensure keys exist
-            await this.ensureKeys();
-            // Read private key
-            const privateKey = readFileSync(this.privateKeyPath, 'utf8');
-            // Create signature payload
-            const payload = {
-                reports: reportPaths.map(path => ({
-                    path: path.split('/').pop(),
-                    hash: this.hashFile(path)
-                })),
-                trustScore,
-                timestamp: new Date().toISOString(),
-                pack: runResult.pack.name
-            };
-            const payloadString = JSON.stringify(payload, null, 0);
-            const signature = sign('sha256', Buffer.from(payloadString), privateKey).toString('base64');
-            // Save signature
-            const signaturePath = join(this.getLatestRunDir(), 'signature.json');
-            writeFileSync(signaturePath, JSON.stringify({
-                payload,
-                signature,
-                algorithm: 'Ed25519',
-                qa360Version: '0.9.0-core'
-            }, null, 2));
-            spinner.succeed(`Signature générée: ${signaturePath}`);
-            console.log(chalk.green(`🔐 Preuve signée cryptographiquement`));
-        }
-        catch (error) {
-            spinner.fail('Échec signature');
-            throw error;
-        }
-    }
-    async ensureKeys() {
-        if (existsSync(this.privateKeyPath) && existsSync(this.publicKeyPath)) {
-            return;
-        }
-        console.log(chalk.yellow('🔑 Génération de la paire de clés Ed25519...'));
-        return new Promise((resolve, reject) => {
-            generateKeyPair('ed25519', {
-                publicKeyEncoding: { type: 'spki', format: 'pem' },
-                privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-            }, (err, publicKey, privateKey) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                writeFileSync(this.publicKeyPath, publicKey);
-                writeFileSync(this.privateKeyPath, privateKey);
-                console.log(chalk.green('✅ Clés générées'));
-                resolve();
-            });
-        });
-    }
-    hashFile(filePath) {
-        const content = readFileSync(filePath);
-        return createHash('sha256').update(content).digest('hex');
-    }
 }
 export async function reportCommand(options = {}) {
     const reporter = new QA360Reporter();
@@ -338,10 +369,7 @@ export async function reportCommand(options = {}) {
         outputs.forEach(path => {
             console.log(chalk.blue(`  📄 ${path}`));
         });
-        if (options.sign) {
-            console.log(chalk.green('\n🔐 Preuve signée et vérifiable'));
-            console.log(chalk.blue('💡 Utilisez "qa360 verify" pour vérifier la signature'));
-        }
+        console.log(chalk.gray('\n💡 Vérifiez la preuve avec: qa360 verify'));
     }
     catch (error) {
         console.error(chalk.red('❌ Échec génération rapport:'), error);