@silasfmartins/testhub 1.0.0

package/dist/src/utils/EvidenceReportGenerator.js

@@ -0,0 +1,799 @@
+/**
+ * 📸 Organizador de Evidências do AutoCore
+ * @description Coleta e organiza screenshots já gerados pelos projetos consumidores (Web/Mobile)
+ * @author TestHUB Team
+ * @version 1.0.0
+ *
+ * ⚠️ IMPORTANTE: Este projeto AutoCore NÃO gera evidências
+ * Ele apenas coleta e organiza evidências dos projetos consumidores:
+ * - Web: C:\Users\{user}\PlayWright\test-simplifique-e2e\test-results\web-screenshots\
+ * - Mobile: C:\Users\{user}\PlayWright\mobile\test-results\mobile-screenshots\
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export class EvidenceReportGenerator {
+    /**
+     * 🎯 Detectar o tipo do projeto atual baseado nas pastas de evidências
+     *
+     * ℹ️ AutoCore trabalha no projeto atual e verifica se há:
+     * - Web: test-results/web-screenshots/
+     * - Mobile: test-results/mobile-screenshots/
+     */
+    static detectCurrentProjectType() {
+        const currentDir = process.cwd();
+        const testResultsPath = path.join(currentDir, 'test-results');
+        if (!fs.existsSync(testResultsPath)) {
+            console.log('⚠️ Pasta test-results não encontrada no projeto atual');
+            return null;
+        }
+        // Verificar se é projeto Mobile
+        const mobileScreenshotsPath = path.join(testResultsPath, 'mobile-screenshots');
+        if (fs.existsSync(mobileScreenshotsPath)) {
+            console.log(`🎯 Projeto Mobile detectado: ${currentDir}`);
+            return {
+                path: currentDir,
+                type: 'Mobile',
+                screenshotFolder: 'mobile-screenshots',
+            };
+        }
+        // Verificar se é projeto Web
+        const webScreenshotsPath = path.join(testResultsPath, 'web-screenshots');
+        if (fs.existsSync(webScreenshotsPath)) {
+            console.log(`🎯 Projeto Web detectado: ${currentDir}`);
+            return {
+                path: currentDir,
+                type: 'Web',
+                screenshotFolder: 'web-screenshots',
+            };
+        }
+        console.log('⚠️ Nenhuma pasta de screenshots específica encontrada (web-screenshots ou mobile-screenshots)');
+        return null;
+    }
+    /**
+     * 🔍 Coleta screenshots em uma pasta específica do projeto consumidor
+     */
+    static async findScreenshotsInDirectory(directoryPath, projectType) {
+        const screenshots = [];
+        try {
+            if (!fs.existsSync(directoryPath)) {
+                return screenshots;
+            }
+            const files = fs.readdirSync(directoryPath, { withFileTypes: true });
+            for (const file of files) {
+                const fullPath = path.join(directoryPath, file.name);
+                if (file.isDirectory()) {
+                    // Busca recursiva em subpastas
+                    const subScreenshots = await EvidenceReportGenerator.findScreenshotsInDirectory(fullPath, projectType);
+                    screenshots.push(...subScreenshots);
+                }
+                else if (file.isFile() && /\.(png|jpg|jpeg)$/i.test(file.name)) {
+                    const stats = fs.statSync(fullPath);
+                    const testName = EvidenceReportGenerator.extractTestName(fullPath, projectType);
+                    // 🔧 CORRIGIDO: Caminho relativo à pasta playwright-report
+                    const playwrightReportDir = path.join(process.cwd(), 'playwright-report');
+                    const relativePath = path
+                        .relative(playwrightReportDir, fullPath)
+                        .replace(/\\/g, '/');
+                    const base64 = EvidenceReportGenerator.convertImageToBase64(fullPath);
+                    screenshots.push({
+                        fileName: file.name,
+                        fullPath,
+                        relativePath,
+                        testName,
+                        timestamp: stats.mtime,
+                        size: stats.size,
+                        base64,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao escanear pasta ${directoryPath}:`, error);
+        }
+        return screenshots;
+    }
+    /**
+     * ✅ Gera relatório de evidências procurando screenshots nas pastas padrão
+     */
+    static async generateEvidenceReport() {
+        try {
+            // 🎯 DETECTAR TIPO DO PROJETO ATUAL
+            const currentProject = EvidenceReportGenerator.detectCurrentProjectType();
+            if (!currentProject) {
+                await EvidenceReportGenerator.generateEmptyReport();
+                return;
+            }
+            // 🔍 PROCURAR SCREENSHOTS NO PROJETO ATUAL
+            let allScreenshots = [];
+            console.log(`🔍 Coletando evidências de ${currentProject.type}: ${currentProject.path}`);
+            const testResultsPath = path.join(currentProject.path, 'test-results');
+            const screenshotPath = path.join(testResultsPath, currentProject.screenshotFolder);
+            console.log(`📂 Verificando: ${screenshotPath}`);
+            if (fs.existsSync(screenshotPath)) {
+                const projectScreenshots = await EvidenceReportGenerator.findScreenshotsInDirectory(screenshotPath, currentProject.type);
+                allScreenshots = allScreenshots.concat(projectScreenshots);
+                console.log(`📸 Coletados ${projectScreenshots.length} screenshot(s) de ${currentProject.type}`);
+            }
+            else {
+                console.log(`⚠️ Pasta de evidências não encontrada: ${screenshotPath}`);
+            }
+            if (allScreenshots.length === 0) {
+                await EvidenceReportGenerator.generateEmptyReport();
+                return;
+            }
+            // Gerar relatório HTML
+            const html = EvidenceReportGenerator.generateHTML(allScreenshots);
+            // ✅ CORRIGIDO: Criar pasta playwright-report se não existir
+            const playwrightReportDir = path.join(process.cwd(), 'playwright-report');
+            if (!fs.existsSync(playwrightReportDir)) {
+                fs.mkdirSync(playwrightReportDir, { recursive: true });
+            }
+            // ✅ CORRIGIDO: Salvar relatório APENAS em playwright-report
+            const reportPath = path.join(playwrightReportDir, 'relatorio-evidencias.html');
+            fs.writeFileSync(reportPath, html, 'utf-8');
+        }
+        catch (error) {
+            console.warn('⚠️ [EvidenceReportGenerator] Erro ao gerar relatório:', error);
+        }
+    }
+    /**
+     * ✅ Procura screenshots em diretórios específicos
+     */
+    static async findScreenshots(directories) {
+        const screenshots = [];
+        for (const dir of directories) {
+            if (!fs.existsSync(dir))
+                continue;
+            try {
+                const files = EvidenceReportGenerator.findFilesRecursively(dir, /\.(png|jpg|jpeg)$/i);
+                for (const filePath of files) {
+                    try {
+                        const stats = fs.statSync(filePath);
+                        const fileName = path.basename(filePath);
+                        // 🔧 CORRIGIDO: Caminho relativo à pasta playwright-report
+                        const playwrightReportDir = path.join(process.cwd(), 'playwright-report');
+                        const relativePath = path
+                            .relative(playwrightReportDir, filePath)
+                            .replace(/\\/g, '/');
+                        // Extrair nome do teste do caminho ou nome do arquivo
+                        const testName = EvidenceReportGenerator.extractTestName(filePath, 'Legacy');
+                        // 🆕 Converter imagem para base64
+                        const base64 = EvidenceReportGenerator.convertImageToBase64(filePath);
+                        screenshots.push({
+                            fileName,
+                            fullPath: filePath,
+                            relativePath,
+                            testName,
+                            timestamp: stats.mtime,
+                            size: stats.size,
+                            base64, // 🆕 Incluir base64 no objeto
+                        });
+                    }
+                    catch (fileError) {
+                        // Ignorar erros de arquivos individuais
+                    }
+                }
+            }
+            catch (dirError) {
+                // Ignorar erros de diretórios
+            }
+        }
+        // Ordenar por timestamp (mais recentes primeiro)
+        screenshots.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return screenshots;
+    }
+    /**
+     * 🆕 Converte imagem para base64
+     */
+    static convertImageToBase64(imagePath) {
+        try {
+            const imageBuffer = fs.readFileSync(imagePath);
+            const ext = path.extname(imagePath).toLowerCase();
+            let mimeType = 'image/png';
+            if (ext === '.jpg' || ext === '.jpeg') {
+                mimeType = 'image/jpeg';
+            }
+            else if (ext === '.gif') {
+                mimeType = 'image/gif';
+            }
+            else if (ext === '.webp') {
+                mimeType = 'image/webp';
+            }
+            const base64 = imageBuffer.toString('base64');
+            return `data:${mimeType};base64,${base64}`;
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao converter imagem para base64: ${imagePath}`, error);
+            return ''; // Retornar string vazia em caso de erro
+        }
+    }
+    /**
+     * ✅ Encontra arquivos recursivamente
+     */
+    static findFilesRecursively(dir, pattern) {
+        const files = [];
+        try {
+            const items = fs.readdirSync(dir);
+            for (const item of items) {
+                const itemPath = path.join(dir, item);
+                const stats = fs.statSync(itemPath);
+                if (stats.isDirectory()) {
+                    files.push(...EvidenceReportGenerator.findFilesRecursively(itemPath, pattern));
+                }
+                else if (pattern.test(item)) {
+                    files.push(itemPath);
+                }
+            }
+        }
+        catch (error) {
+            // Ignorar erros de acesso
+        }
+        return files;
+    }
+    /**
+     * ✅ Extrai nome do teste do caminho ou nome do arquivo
+     */
+    static extractTestName(fullPath, projectType) {
+        // Tentar extrair do caminho
+        const pathParts = fullPath.split(/[/\\]/);
+        const fileName = path.basename(fullPath);
+        // 🔍 Para projetos Web/Mobile, procurar padrões específicos
+        if (projectType === 'Web' || projectType === 'Mobile') {
+            // Procurar por partes que parecem nomes de teste no caminho
+            for (let i = pathParts.length - 1; i >= 0; i--) {
+                const part = pathParts[i];
+                if (part.includes('test') ||
+                    part.includes('spec') ||
+                    part.includes('CT') ||
+                    part.includes('-chromium') ||
+                    part.includes('-webkit')) {
+                    return part
+                        .replace(/-chromium|-webkit|-firefox/gi, '')
+                        .replace(/^\d+/, '')
+                        .trim();
+                }
+            }
+        }
+        // Fallback: usar nome do arquivo sem extensão
+        return (fileName
+            .replace(/\.(png|jpg|jpeg)$/i, '')
+            .replace(/-\d+$/, '')
+            .trim() || 'Teste não identificado');
+    }
+    /**
+     * ✅ Gera HTML do relatório com recursos avançados (igual HTMLTemplate)
+     */
+    static generateHTML(screenshots) {
+        const groupedByTest = EvidenceReportGenerator.groupScreenshotsByTest(screenshots);
+        const totalTests = Object.keys(groupedByTest).length;
+        const totalScreenshots = screenshots.length;
+        const totalSize = screenshots.reduce((sum, s) => sum + s.size, 0);
+        // Estatísticas por tipo de projeto
+        const projectStats = {
+            Web: screenshots.filter((s) => s.fullPath.includes('web-screenshots'))
+                .length,
+            Mobile: screenshots.filter((s) => s.fullPath.includes('mobile-screenshots')).length,
+            Other: screenshots.filter((s) => !(s.fullPath.includes('web-screenshots') ||
+                s.fullPath.includes('mobile-screenshots'))).length,
+        };
+        return `
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>📸 Relatório de Evidências - TestHUB</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/jspdf/2.5.1/jspdf.umd.min.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/xlsx@0.18.5/dist/xlsx.full.min.js"></script>
+  <style>
+    body { font-family: 'Inter', sans-serif; background-color: #0f172a; color: #f1f5f9; min-height: 100vh; }
+    .light-mode { background-color: #f9fafb !important; color: #222 !important; }
+    .card { background: #1e293b; border-radius: 1rem; padding: 1.5rem; box-shadow: 0 2px 8px #0002; }
+    .light-mode .card { background: #fff; color: #222; }
+    .btn { background: #334155; color: #fff; border: none; border-radius: 8px; padding: 0.5rem 1.2rem; font-weight: 600; cursor: pointer; margin-bottom: 0.25rem; transition: background 0.2s; }
+    .btn:hover { background: #475569; }
+    .light-mode .btn { background: #e2e8f0; color: #222; }
+    .chart-card { background: #1e293b; border-radius: 1rem; padding: 1rem; margin-bottom: 1.5rem; }
+    .light-mode .chart-card { background: #fff; }
+    .header-bar { background: #1e293b; padding: 1rem 2rem; border-radius: 1rem 1rem 0 0; margin-bottom: 1.5rem; display: flex; align-items: center; justify-content: space-between; }
+    .header-bar .header-title { font-size: 2rem; font-weight: 700; color: #fbbf24; }
+    .header-bar .header-meta { font-size: 1rem; color: #f1f5f9; }
+    .light-mode .header-bar { background: #f1f5f9; color: #222; }
+    .light-mode .header-title { color: #b45309; }
+    .light-mode .header-meta { color: #222 !important; }
+    .footer-bar { background: #1e293b; color: #fbbf24; padding: 1rem 2rem; border-radius: 0 0 1rem 1rem; margin-top: 2rem; text-align: center; font-size: 1rem; }
+    .light-mode .footer-bar { background: #f1f5f9; color: #b45309; }
+    .footer-bar a { color: #fbbf24; text-decoration: underline; }
+    .light-mode .footer-bar a { color: #b45309; }
+    .evidence-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 1rem; }
+    .evidence-item { background: #334155; border-radius: 8px; overflow: hidden; transition: transform 0.2s; }
+    .evidence-item:hover { transform: scale(1.02); }
+    .light-mode .evidence-item { background: #f1f5f9; }
+    .evidence-img { width: 100%; height: 200px; object-fit: contain; background: #475569; cursor: pointer; }
+    .light-mode .evidence-img { background: #e2e8f0; }
+    .evidence-info { padding: 1rem; }
+    .evidence-title { font-weight: 600; margin-bottom: 0.5rem; }
+    .evidence-meta { font-size: 0.875rem; color: #94a3b8; }
+    .light-mode .evidence-meta { color: #64748b; }
+    .test-section { margin-bottom: 2rem; }
+    .test-header { background: #334155; padding: 1rem; border-radius: 8px 8px 0 0; cursor: pointer; display: flex; justify-content: between; align-items: center; }
+    .light-mode .test-header { background: #e2e8f0; }
+    .test-content { background: #1e293b; padding: 1rem; border-radius: 0 0 8px 8px; }
+    .light-mode .test-content { background: #f8fafc; }
+    .modal { display: none; position: fixed; z-index: 1000; left: 0; top: 0; width: 100%; height: 100%; background-color: rgba(0,0,0,0.9); }
+    .modal-content { margin: auto; display: block; width: 90%; max-width: 1200px; max-height: 90%; }
+    .modal img { width: 100%; height: auto; }
+    .close { position: absolute; top: 15px; right: 35px; color: #f1f1f1; font-size: 40px; font-weight: bold; cursor: pointer; }
+    .close:hover { color: #bbb; }
+    @media (max-width: 768px) {
+      .grid-cols-2, .grid-cols-3 { grid-template-columns: 1fr !important; }
+      .header-bar { flex-direction: column; text-align: center; }
+      .header-meta { margin-top: 0.5rem; }
+    }
+  </style>
+</head>
+<body id="body-root">
+  <div class="header-bar">
+    <div class="header-title">📸 Relatório de Evidências</div>
+    <div class="header-meta">
+      <span>Total: <strong>${totalScreenshots}</strong></span> |
+      <span>Testes: <strong>${totalTests}</strong></span> |
+      <span>Tamanho: <strong>${EvidenceReportGenerator.formatFileSize(totalSize)}</strong></span> |
+      <span>Data: <strong>${new Date().toLocaleString('pt-BR')}</strong></span>
+    </div>
+  </div>
+  
+  <div class="flex gap-2 mb-6 justify-end mr-6">
+    <button id="toggle-theme" class="btn" type="button" title="Alternar tema">🌙 Tema</button>
+    <button id="export-pdf" class="btn" type="button" title="Exportar PDF">📄 PDF</button>
+    <button id="export-csv" class="btn" type="button" title="Exportar CSV">📑 CSV</button>
+    <button id="export-json" class="btn" type="button" title="Exportar JSON">🗒️ JSON</button>
+    <button id="export-xlsx" class="btn" type="button" title="Exportar XLSX">📊 XLSX</button>
+  </div>
+  
+  <div id="report-root" class="max-w-7xl mx-auto p-6" style="background:inherit;">
+    <h1 class="text-4xl font-bold mb-2">📸 Evidências Capturadas</h1>
+    <p class="text-slate-400 mb-6">Screenshots organizados por teste executado</p>
+
+    <!-- Estatísticas -->
+    <div class="grid grid-cols-1 md:grid-cols-4 gap-4 mb-8">
+      <div class="card flex flex-col items-center">
+        <span class="text-2xl font-bold text-blue-400">${totalTests}</span>
+        <span class="text-slate-400">Testes</span>
+      </div>
+      <div class="card flex flex-col items-center">
+        <span class="text-2xl font-bold text-green-400">${totalScreenshots}</span>
+        <span class="text-green-400">Screenshots</span>
+      </div>
+      <div class="card flex flex-col items-center">
+        <span class="text-2xl font-bold text-purple-400">${projectStats.Web}</span>
+        <span class="text-purple-400">Web</span>
+      </div>
+      <div class="card flex flex-col items-center">
+        <span class="text-2xl font-bold text-orange-400">${projectStats.Mobile}</span>
+        <span class="text-orange-400">Mobile</span>
+      </div>
+    </div>
+
+    <!-- Gráficos -->
+    <div class="grid grid-cols-1 md:grid-cols-2 gap-6 mb-8">
+      <div class="chart-card">
+        <h3 class="text-lg font-bold mb-4 text-center">📊 Screenshots por Tipo</h3>
+        <canvas id="chart-tipos" height="200"></canvas>
+      </div>
+      <div class="chart-card">
+        <h3 class="text-lg font-bold mb-4 text-center">🗓️ Screenshots por Teste</h3>
+        <canvas id="chart-testes" height="200"></canvas>
+      </div>
+    </div>
+
+    <!-- Evidências por Teste -->
+    ${Object.entries(groupedByTest)
+            .map(([testName, testScreenshots], index) => `
+    <div class="test-section">
+      <div class="test-header" onclick="toggleTestSection('test-${index}')">
+        <div class="flex items-center gap-3">
+          <span class="text-2xl">🧪</span>
+          <div>
+            <h3 class="text-lg font-bold">${testName}</h3>
+            <p class="text-sm text-slate-400">${testScreenshots.length} screenshot(s) • Última captura: ${testScreenshots[0].timestamp.toLocaleString('pt-BR')}</p>
+          </div>
+        </div>
+        <span class="text-2xl transform transition-transform" id="arrow-test-${index}">▼</span>
+      </div>
+      <div class="test-content" id="test-${index}">
+        <div class="evidence-grid">
+          ${testScreenshots
+            .map((screenshot) => `
+          <div class="evidence-item">
+            <img src="${screenshot.base64 || screenshot.relativePath}" alt="${screenshot.fileName}" class="evidence-img" onclick="openModal('${screenshot.base64 || screenshot.relativePath}', '${screenshot.fileName}')" loading="lazy">
+            <div class="evidence-info">
+              <div class="evidence-title">${screenshot.fileName}</div>
+              <div class="evidence-meta">
+                ${EvidenceReportGenerator.formatFileSize(screenshot.size)} • 
+                ${screenshot.timestamp.toLocaleString('pt-BR')}
+              </div>
+            </div>
+          </div>
+          `)
+            .join('')}
+        </div>
+      </div>
+    </div>
+    `)
+            .join('')}
+  </div>
+
+  <!-- Modal para visualizar imagens -->
+  <div id="imageModal" class="modal">
+    <span class="close" onclick="closeModal()">&times;</span>
+    <div class="modal-content">
+      <img id="modalImg" src="" alt="">
+    </div>
+  </div>
+
+  <div class="footer-bar">
+    Desenvolvido por <strong>TestHUB AutoCore</strong> &mdash; Sistema de Organização de Evidências.<br>
+    <span>Relatório gerado automaticamente • Screenshots coletados dos projetos consumidores</span>
+  </div>
+
+  <script>
+    // Toggle de tema
+    document.getElementById('toggle-theme').onclick = () => {
+      document.getElementById('body-root').classList.toggle('light-mode')
+      document.querySelector('.header-bar').classList.toggle('light-mode')
+      document.querySelector('.footer-bar').classList.toggle('light-mode')
+      document.querySelectorAll('.card').forEach(card => card.classList.toggle('light-mode'))
+      document.querySelectorAll('.chart-card').forEach(card => card.classList.toggle('light-mode'))
+      document.querySelectorAll('.evidence-item').forEach(item => item.classList.toggle('light-mode'))
+      document.querySelectorAll('.test-header').forEach(header => header.classList.toggle('light-mode'))
+      document.querySelectorAll('.test-content').forEach(content => content.classList.toggle('light-mode'))
+      document.querySelectorAll('.evidence-img').forEach(img => img.classList.toggle('light-mode'))
+      document.querySelectorAll('.evidence-meta').forEach(meta => meta.classList.toggle('light-mode'))
+      
+      const meta = document.querySelector('.header-meta')
+      if (document.getElementById('body-root').classList.contains('light-mode')) {
+        meta && (meta.style.color = '#222')
+      } else {
+        meta && (meta.style.color = '#f1f5f9')
+      }
+    }
+
+    // Toggle de seções de teste
+    function toggleTestSection(testId) {
+      const testContent = document.getElementById(testId)
+      const arrow = document.getElementById('arrow-' + testId)
+      
+      if (testContent.style.display === 'none') {
+        testContent.style.display = 'block'
+        arrow.style.transform = 'rotate(180deg)'
+      } else {
+        testContent.style.display = 'none'
+        arrow.style.transform = 'rotate(0deg)'
+      }
+    }
+
+    // Modal de imagens
+    function openModal(src, alt) {
+      document.getElementById('imageModal').style.display = 'block'
+      document.getElementById('modalImg').src = src
+      document.getElementById('modalImg').alt = alt
+    }
+
+    function closeModal() {
+      document.getElementById('imageModal').style.display = 'none'
+    }
+
+    // Fechar modal ao clicar fora da imagem
+    window.onclick = function(event) {
+      const modal = document.getElementById('imageModal')
+      if (event.target == modal) {
+        closeModal()
+      }
+    }
+
+    // Dados para exportação
+    function getEvidenceData() {
+      const data = []
+      ${Object.entries(groupedByTest)
+            .map(([testName, testScreenshots]) => `
+      ${testScreenshots
+            .map((screenshot) => `
+      data.push({
+        teste: '${testName}',
+        arquivo: '${screenshot.fileName}',
+        tamanho: '${EvidenceReportGenerator.formatFileSize(screenshot.size)}',
+        timestamp: '${screenshot.timestamp.toLocaleString('pt-BR')}',
+        caminho: '${screenshot.relativePath}'
+      })
+      `)
+            .join('')}
+      `)
+            .join('')}
+      return data
+    }
+
+    // Exportação PDF
+    document.getElementById('export-pdf').onclick = async () => {
+      console.log('🔵 [PDF] Botão clicado - Iniciando geração do PDF de evidências...')
+      
+      const element = document.getElementById('report-root')
+      if (!element) {
+        console.error('❌ [PDF] Elemento report-root não encontrado!')
+        alert('❌ Erro: Elemento do relatório não encontrado!')
+        return
+      }
+      
+      const hasImages = element.querySelectorAll('img').length > 0
+      if (hasImages) {
+        console.log('📸 [PDF] Imagens detectadas - usando base64 para garantir renderização offline')
+      }
+      
+      // Verificar se jsPDF está carregado
+      if (typeof jspdf === 'undefined') {
+        console.error('❌ [PDF] jsPDF não está carregado!')
+        alert('❌ Erro: Biblioteca jsPDF não carregada. Recarregue a página.')
+        return
+      }
+      console.log('✅ [PDF] jsPDF carregado com sucesso')
+      
+      // 🆕 EXPANDIR TODAS AS SEÇÕES antes de gerar PDF
+      const allSections = document.querySelectorAll('[id^="test-"]')
+      const allArrows = document.querySelectorAll('[id^="arrow-test-"]')
+      const originalStates = []
+      
+      allSections.forEach((section, index) => {
+        originalStates.push(section.style.display)
+        section.style.display = 'block'
+        if (allArrows[index]) {
+          allArrows[index].style.transform = 'rotate(180deg)'
+        }
+      })
+
+      // ✅ Aguardar imagens carregarem (já estão em base64)
+      const images = element.querySelectorAll('img')
+      console.log('📸 Total de imagens encontradas:', images.length)
+      
+      await Promise.all(Array.from(images).map(img => {
+        if (img.complete) return Promise.resolve()
+        return new Promise(resolve => {
+          img.onload = resolve
+          img.onerror = resolve
+          setTimeout(resolve, 2000)
+        })
+      }))
+      
+      console.log('✅ Imagens carregadas (base64 embutido)')
+      await new Promise(resolve => setTimeout(resolve, 300))
+
+      // Preparar elemento para PDF
+      const originalBg = element.style.background
+      const originalColor = element.style.color
+      element.style.background = '#fff'
+      element.style.color = '#222'
+
+      // Reduzir gráficos para PDF
+      document.querySelectorAll('.chart-card canvas').forEach((canvas) => {
+        canvas.style.width = '300px'
+        canvas.style.height = '150px'
+        canvas.style.transform = 'scale(0.85)'
+      })
+
+      console.log('📄 [PDF] Iniciando geração do PDF...')
+      
+      try {
+        // Usar html2canvas para capturar o conteúdo como imagem
+        const canvas = await html2canvas(element, {
+          scale: 2,
+          useCORS: false,
+          allowTaint: true,
+          backgroundColor: '#fff',
+          logging: false,
+          imageTimeout: 0
+        })
+        
+        // Criar PDF com jsPDF
+        const { jsPDF } = jspdf
+        const pdf = new jsPDF({
+          orientation: 'portrait',
+          unit: 'mm',
+          format: 'a4'
+        })
+        
+        const imgData = canvas.toDataURL('image/jpeg', 0.98)
+        const imgWidth = 210 // A4 width in mm
+        const pageHeight = 297 // A4 height in mm
+        const imgHeight = (canvas.height * imgWidth) / canvas.width
+        let heightLeft = imgHeight
+        let position = 0
+        
+        // Adicionar primeira página
+        pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight)
+        heightLeft -= pageHeight
+        
+        // Adicionar páginas extras se necessário
+        while (heightLeft > 0) {
+          position = heightLeft - imgHeight
+          pdf.addPage()
+          pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight)
+          heightLeft -= pageHeight
+        }
+        
+        // Salvar PDF
+        pdf.save('relatorio-evidencias.pdf')
+        
+        console.log('✅ PDF gerado com sucesso!')
+        alert('✅ PDF gerado com sucesso! Verifique sua pasta de Downloads.')
+      } catch (error) {
+        console.error('❌ Erro ao gerar PDF:', error)
+        alert('❌ Erro ao gerar PDF: ' + (error.message || error))
+      } finally {
+        // Restaurar estilos e estados originais
+        element.style.background = originalBg
+        element.style.color = originalColor
+        
+        document.querySelectorAll('.chart-card canvas').forEach((canvas) => {
+          canvas.style.width = ''
+          canvas.style.height = ''
+          canvas.style.transform = ''
+        })
+
+        // Restaurar estados das seções
+        allSections.forEach((section, index) => {
+          section.style.display = originalStates[index] || 'none'
+          if (allArrows[index] && originalStates[index] === 'none') {
+            allArrows[index].style.transform = 'rotate(0deg)'
+          }
+        })
+      }
+    }
+
+    // Exportação CSV
+    document.getElementById('export-csv').onclick = () => {
+      const data = getEvidenceData()
+      const csv = [
+        ['Teste', 'Arquivo', 'Tamanho', 'Timestamp', 'Caminho'],
+        ...data.map(d => [d.teste, d.arquivo, d.tamanho, d.timestamp, d.caminho])
+      ].map(e => e.join(';')).join('\\n')
+      const blob = new Blob([csv], { type: 'text/csv' })
+      const a = document.createElement('a')
+      a.href = URL.createObjectURL(blob)
+      a.download = 'evidencias.csv'
+      a.click()
+    }
+
+    // Exportação JSON
+    document.getElementById('export-json').onclick = () => {
+      const blob = new Blob([JSON.stringify(getEvidenceData(), null, 2)], { type: 'application/json' })
+      const a = document.createElement('a')
+      a.href = URL.createObjectURL(blob)
+      a.download = 'evidencias.json'
+      a.click()
+    }
+
+    // Exportação XLSX
+    document.getElementById('export-xlsx').onclick = () => {
+      const ws = XLSX.utils.json_to_sheet(getEvidenceData())
+      const wb = XLSX.utils.book_new()
+      XLSX.utils.book_append_sheet(wb, ws, 'Evidencias')
+      XLSX.writeFile(wb, 'evidencias.xlsx')
+    }
+
+    // Gráfico de tipos
+    new Chart(document.getElementById('chart-tipos'), {
+      type: 'doughnut',
+      data: {
+        labels: ['Web', 'Mobile', 'Outros'],
+        datasets: [{
+          data: [${projectStats.Web}, ${projectStats.Mobile}, ${projectStats.Other}],
+          backgroundColor: ['#3b82f6', '#f59e0b', '#10b981'],
+          borderWidth: 2,
+          borderColor: '#1e293b'
+        }]
+      },
+      options: {
+        responsive: true,
+        plugins: {
+          legend: { position: 'bottom' }
+        }
+      }
+    })
+
+    // Gráfico de testes
+    new Chart(document.getElementById('chart-testes'), {
+      type: 'bar',
+      data: {
+        labels: [${Object.keys(groupedByTest)
+            .map((name) => `'${name.substring(0, 20)}...'`)
+            .join(', ')}],
+        datasets: [{
+          label: 'Screenshots',
+          data: [${Object.values(groupedByTest)
+            .map((screenshots) => screenshots.length)
+            .join(', ')}],
+          backgroundColor: '#3b82f6',
+          borderColor: '#1e40af',
+          borderWidth: 1
+        }]
+      },
+      options: {
+        responsive: true,
+        scales: {
+          y: { beginAtZero: true }
+        },
+        plugins: {
+          legend: { display: false }
+        }
+      }
+    })
+  </script>
+</body>
+</html>`;
+    }
+    /**
+     * ✅ Agrupa screenshots por teste
+     */
+    static groupScreenshotsByTest(screenshots) {
+        const grouped = {};
+        for (const screenshot of screenshots) {
+            if (!grouped[screenshot.testName]) {
+                grouped[screenshot.testName] = [];
+            }
+            grouped[screenshot.testName].push(screenshot);
+        }
+        return grouped;
+    }
+    /**
+     * ✅ Formata tamanho de arquivo
+     */
+    static formatFileSize(bytes) {
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        if (bytes === 0)
+            return '0 B';
+        const i = Math.floor(Math.log(bytes) / Math.log(1024));
+        return `${(bytes / 1024 ** i).toFixed(1)} ${sizes[i]}`;
+    }
+    /**
+     * ✅ Gera relatório vazio quando não há evidências nos projetos consumidores
+     */
+    static async generateEmptyReport() {
+        const html = `
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>📸 Organizador de Evidências - AutoCore</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: #f5f7fa; color: #2d3748; }
+        .container { max-width: 800px; margin: 0 auto; padding: 20px; text-align: center; }
+        .empty-state { background: white; padding: 4rem 2rem; border-radius: 12px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .empty-state h1 { font-size: 2rem; color: #667eea; margin-bottom: 1rem; }
+        .empty-state p { color: #718096; font-size: 1.1rem; margin-bottom: 0.5rem; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="empty-state">
+            <h1>📸 Relatório de Evidências</h1>
+            <p>Nenhum screenshot foi encontrado nas pastas do projeto.</p>
+            <p>Screenshots são automaticamente capturados durante a execução dos testes.</p>
+            <p><strong>Pastas verificadas:</strong> playwright-report, test-results, reports, evidence, screenshots</p>
+        </div>
+    </div>
+</body>
+</html>`;
+        // ✅ CORRIGIDO: Criar pasta playwright-report se não existir
+        const playwrightReportDir = path.join(process.cwd(), 'playwright-report');
+        if (!fs.existsSync(playwrightReportDir)) {
+            fs.mkdirSync(playwrightReportDir, { recursive: true });
+        }
+        // ✅ CORRIGIDO: Salvar relatório em playwright-report
+        const reportPath = path.join(playwrightReportDir, 'relatorio-evidencias.html');
+        fs.writeFileSync(reportPath, html, 'utf-8');
+    }
+}