@silasfmartins/testhub 1.0.0

package/dist/src/utils/PDFEvidenceGenerator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PDF Evidence Generator - Sistema Simplificado
+ * Gera relatorios PDF simples baseado nas evidencias coletadas
+ * TestHUB Team
+ * version 2.0.0
+ */
+export declare class PDFEvidenceGenerator {
+    /**
+     * Gera PDF organizando evidencias dos projetos consumidores
+     */
+    static generatePDF(): Promise<void>;
+    /**
+     * Conta screenshots em uma pasta
+     */
+    private static countScreenshots;
+    /**
+     * Gera HTML simples para PDF
+     */
+    private static generateSimplePDFHTML;
+}

package/dist/src/utils/PDFEvidenceGenerator.js

@@ -0,0 +1,156 @@
+/**
+ * PDF Evidence Generator - Sistema Simplificado
+ * Gera relatorios PDF simples baseado nas evidencias coletadas
+ * TestHUB Team
+ * version 2.0.0
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Logger } from './Logger.js';
+export class PDFEvidenceGenerator {
+    /**
+     * Gera PDF organizando evidencias dos projetos consumidores
+     */
+    static async generatePDF() {
+        try {
+            Logger.info('PDFGenerator: Iniciando geracao de PDF simplificado...');
+            Logger.info('Sistema simplificado - apenas contagem de evidencias');
+            // Sistema simplificado - apenas contar evidencias
+            const userHome = process.env.USERPROFILE || process.env.HOME || '';
+            const webPath = path.join(userHome, 'PlayWright', 'test-simplifique-e2e', 'test-results', 'web-screenshots');
+            const mobilePath = path.join(userHome, 'PlayWright', 'mobile', 'test-results', 'mobile-screenshots');
+            let totalScreenshots = 0;
+            const projects = [];
+            if (fs.existsSync(webPath)) {
+                const webFiles = PDFEvidenceGenerator.countScreenshots(webPath);
+                totalScreenshots += webFiles;
+                projects.push({ type: 'Web', count: webFiles, path: webPath });
+                Logger.info(`Web: ${webFiles} screenshot(s)`);
+            }
+            if (fs.existsSync(mobilePath)) {
+                const mobileFiles = PDFEvidenceGenerator.countScreenshots(mobilePath);
+                totalScreenshots += mobileFiles;
+                projects.push({ type: 'Mobile', count: mobileFiles, path: mobilePath });
+                Logger.info(`Mobile: ${mobileFiles} screenshot(s)`);
+            }
+            Logger.info(`PDFGenerator Total: ${totalScreenshots} evidencias encontradas`);
+            if (totalScreenshots === 0) {
+                Logger.info('Nenhuma evidencia encontrada para gerar PDF');
+                return;
+            }
+            // Gerar HTML simples para PDF
+            const html = PDFEvidenceGenerator.generateSimplePDFHTML(projects, totalScreenshots);
+            // ✅ 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 como HTML em playwright-report
+            const outputPath = path.join(playwrightReportDir, 'relatorio-evidencias-pdf.html');
+            fs.writeFileSync(outputPath, html, 'utf8');
+            Logger.info(`PDFGenerator: Relatorio PDF HTML gerado: ${outputPath}`);
+        }
+        catch (error) {
+            Logger.error('Erro ao gerar PDF de evidencias', error);
+        }
+    }
+    /**
+     * Conta screenshots em uma pasta
+     */
+    static countScreenshots(folderPath) {
+        try {
+            if (!fs.existsSync(folderPath)) {
+                return 0;
+            }
+            const files = fs.readdirSync(folderPath);
+            return files.filter((file) => /\.(png|jpg|jpeg)$/i.test(file)).length;
+        }
+        catch (error) {
+            Logger.warning(`Erro ao contar screenshots em ${folderPath}: ${error}`);
+            return 0;
+        }
+    }
+    /**
+     * Gera HTML simples para PDF
+     */
+    static generateSimplePDFHTML(projects, total) {
+        const timestamp = new Date().toLocaleString('pt-BR');
+        const htmlContent = `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Relatorio PDF de Evidencias - AutoCore</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { 
+            font-family: Arial, sans-serif; 
+            background: #f5f7fa; 
+            color: #2d3748; 
+            padding: 20px;
+        }
+        .container { 
+            max-width: 800px; 
+            margin: 0 auto; 
+            background: white; 
+            padding: 2rem; 
+            border-radius: 12px; 
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1); 
+        }
+        .header { 
+            text-align: center; 
+            margin-bottom: 2rem; 
+            border-bottom: 2px solid #e2e8f0; 
+            padding-bottom: 1rem; 
+        }
+        .project { 
+            margin: 1rem 0; 
+            padding: 1rem; 
+            background: #f8fafc; 
+            border-left: 4px solid #4299e1; 
+            border-radius: 4px; 
+        }
+        .summary { 
+            background: #e6fffa; 
+            padding: 1rem; 
+            border-radius: 8px; 
+            margin-top: 2rem; 
+            text-align: center; 
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>Relatorio de Evidencias (PDF)</h1>
+            <p>Sistema AutoCore - Organizador de Evidencias</p>
+            <p><small>Gerado em: ${timestamp}</small></p>
+        </div>
+        
+        <h2>Resumo por Projeto</h2>
+        
+        ${projects
+            .map((project) => `
+        <div class="project">
+            <h3>${project.type}</h3>
+            <p><strong>Evidencias encontradas:</strong> ${project.count} screenshot(s)</p>
+            <p><small>Pasta: ${project.path}</small></p>
+        </div>
+        `)
+            .join('')}
+        
+        <div class="summary">
+            <h3>Total Geral</h3>
+            <p><strong>${total} evidencias coletadas</strong> de ${projects.length} projeto(s)</p>
+        </div>
+        
+        <div style="margin-top: 2rem; text-align: center; font-size: 0.9em; color: #666;">
+            <p>AutoCore coleta e organiza evidencias dos projetos consumidores</p>
+            <p>Para visualizar as evidencias, consulte o relatorio HTML detalhado</p>
+        </div>
+    </div>
+</body>
+</html>`;
+        return htmlContent;
+    }
+}

package/dist/src/utils/SpecFileAnalyzer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 🔍 ANALISADOR DE ARQUIVOS .SPEC.TS
+ *
+ * Detecta automaticamente CNs (Casos de Negócio) e CTs (Casos de Teste)
+ * a partir do arquivo .spec.ts que está sendo executado.
+ */
+export type SpecAnalysisResult = {
+    cn: string | null;
+    ct: string | null;
+    statementClasses: string[];
+    filePath: string;
+};
+/**
+ * 🔍 Analisa o arquivo .spec.ts atual e extrai CNs, CTs e classes Statement
+ */
+export declare function analyzeCurrentSpecFile(): SpecAnalysisResult;
+/**
+ * 🔍 Analisa um arquivo .spec.ts específico
+ */
+export declare function analyzeSpecFile(testFile: string): SpecAnalysisResult;
+/**
+ * 🧹 Limpa o cache
+ */
+export declare function clearSpecAnalysisCache(): void;
+/**
+ * 📊 Obtém estatísticas do cache
+ */
+export declare function getSpecAnalysisCacheStats(): {
+    size: number;
+    keys: string[];
+};
+/**
+ * 🎯 Obtém resultado específico do cache
+ */
+export declare function getCachedSpecAnalysis(filePath: string): SpecAnalysisResult | null;

package/dist/src/utils/SpecFileAnalyzer.js

@@ -0,0 +1,209 @@
+/**
+ * 🔍 ANALISADOR DE ARQUIVOS .SPEC.TS
+ *
+ * Detecta automaticamente CNs (Casos de Negócio) e CTs (Casos de Teste)
+ * a partir do arquivo .spec.ts que está sendo executado.
+ */
+import { TestContext } from '../testContext/TestContext.js';
+import { Logger } from './Logger.js';
+// Regex patterns para performance (definidos no top level)
+const CN_PATTERNS = [
+    // test.describe("CN001_Nome do CN", () => {
+    /test\.describe\s*\(\s*["'`]([^"'`]*CN\d*[^"'`]*)["'`]/,
+    // test.describe('CN001_Nome do CN', () => {
+    /describe\s*\(\s*["'`]([^"'`]*CN\d*[^"'`]*)["'`]/,
+    // Qualquer describe que contenha "CN"
+    /(?:test\.)?describe\s*\(\s*["'`]([^"'`]*CN[^"'`]*)["'`]/,
+];
+const CT_PATTERNS = [
+    // test("CT001_Nome do CT", async () => {
+    /test\s*\(\s*["'`]([^"'`]*CT\d*[^"'`]*)["'`]/,
+    // it("CT001_Nome do CT", async () => {
+    /it\s*\(\s*["'`]([^"'`]*CT\d*[^"'`]*)["'`]/,
+    // Qualquer test que contenha "CT"
+    /(?:test|it)\s*\(\s*["'`]([^"'`]*CT[^"'`]*)["'`]/,
+];
+const cache = new Map();
+/**
+ * 🔍 Analisa o arquivo .spec.ts atual e extrai CNs, CTs e classes Statement
+ */
+export function analyzeCurrentSpecFile() {
+    const testInfo = TestContext.getSafeTestInfo();
+    const filePath = testInfo?.file || 'unknown';
+    // Cache para evitar reprocessamento
+    if (cache.has(filePath)) {
+        return cache.get(filePath);
+    }
+    const result = analyzeSpecFile(filePath);
+    cache.set(filePath, result);
+    return result;
+}
+/**
+ * 🔍 Analisa um arquivo .spec.ts específico
+ */
+export function analyzeSpecFile(testFile) {
+    const result = {
+        cn: null,
+        ct: null,
+        statementClasses: [],
+        filePath: testFile,
+    };
+    try {
+        const content = readSpecFile(testFile);
+        if (!content) {
+            return result;
+        }
+        // Detectar CN (test.describe)
+        result.cn = extractCN(content);
+        // Detectar CT (test)
+        result.ct = extractCT(content);
+        // Detectar classes Statement
+        result.statementClasses = extractStatementClasses(content);
+        if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+            Logger.info(`📋 [SpecFileAnalyzer] Análise de ${testFile}:`);
+            Logger.info(`   📂 CN: ${result.cn || 'não detectado'}`);
+            Logger.info(`   🎯 CT: ${result.ct || 'não detectado'}`);
+            Logger.info(`   📚 Statement Classes: ${result.statementClasses.length} encontradas`);
+        }
+    }
+    catch (error) {
+        if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+            Logger.warning(`⚠️ [SpecFileAnalyzer] Erro ao analisar ${testFile}: ${error}`);
+        }
+    }
+    return result;
+}
+/**
+ * 📖 Lê o conteúdo do arquivo .spec.ts
+ */
+function readSpecFile(testFile) {
+    try {
+        // Obter módulo fs de forma compatível com ESM
+        const fs = getFileSystemModule();
+        if (!fs) {
+            return null;
+        }
+        // Tentar diferentes caminhos para encontrar o arquivo
+        const possiblePaths = [
+            testFile,
+            testFile.replace('C:\\Users\\A0169497\\PlayWright\\comp-autocore-v1\\', './'),
+            `./tests/${testFile.split('\\').pop()}`,
+            `./test/${testFile.split('\\').pop()}`,
+            `./${testFile.split('\\').pop()}`,
+        ];
+        for (const filePath of possiblePaths) {
+            try {
+                if (fs.existsSync?.(filePath)) {
+                    return fs.readFileSync(filePath, 'utf-8');
+                }
+            }
+            catch {
+                // Continua tentando outros caminhos
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 🎯 Extrai o nome do CN (Caso de Negócio) do test.describe
+ */
+function extractCN(content) {
+    for (const pattern of CN_PATTERNS) {
+        const match = content.match(pattern);
+        if (match?.[1]) {
+            return match[1].trim();
+        }
+    }
+    return null;
+}
+/**
+ * 🎯 Extrai o nome do CT (Caso de Teste) do test()
+ */
+function extractCT(content) {
+    for (const pattern of CT_PATTERNS) {
+        const match = content.match(pattern);
+        if (match?.[1]) {
+            return match[1].trim();
+        }
+    }
+    return null;
+}
+/**
+ * 📚 Extrai classes Statement do conteúdo
+ */
+function extractStatementClasses(content) {
+    const detectedClasses = new Set();
+    // 1. Imports diretos: import { StatementsToken } from "..."
+    const importDirectRegex = /import\s*{\s*([^}]*)\s*}\s*from\s*['"]/g;
+    let importMatch;
+    while ((importMatch = importDirectRegex.exec(content)) !== null) {
+        const importedItems = importMatch[1].split(',');
+        importedItems.forEach((item) => {
+            const cleanItem = item.trim();
+            if (cleanItem.includes('Statement') ||
+                cleanItem.startsWith('Statements')) {
+                detectedClasses.add(cleanItem);
+            }
+        });
+    }
+    // 2. Instanciações: new StatementsToken()
+    const newStatementRegex = /new\s+(\w*Statement\w*)\s*\(/g;
+    let newMatch;
+    while ((newMatch = newStatementRegex.exec(content)) !== null) {
+        if (newMatch[1]) {
+            detectedClasses.add(newMatch[1]);
+        }
+    }
+    // 3. Await new: await new StatementsToken()
+    const awaitNewRegex = /await\s+new\s+(\w*Statement\w*)\s*\(/g;
+    let awaitMatch;
+    while ((awaitMatch = awaitNewRegex.exec(content)) !== null) {
+        if (awaitMatch[1]) {
+            detectedClasses.add(awaitMatch[1]);
+        }
+    }
+    // 4. Exports da própria classe: export class StatementsToken
+    const exportClassRegex = /export\s+class\s+(\w*Statement\w*)/g;
+    let exportMatch;
+    while ((exportMatch = exportClassRegex.exec(content)) !== null) {
+        if (exportMatch[1]) {
+            detectedClasses.add(exportMatch[1]);
+        }
+    }
+    return Array.from(detectedClasses);
+}
+/**
+ * 🛠️ Obtém módulo fs compatível com ESM
+ */
+function getFileSystemModule() {
+    try {
+        return globalThis.require?.('fs') || globalThis.fs;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 🧹 Limpa o cache
+ */
+export function clearSpecAnalysisCache() {
+    cache.clear();
+}
+/**
+ * 📊 Obtém estatísticas do cache
+ */
+export function getSpecAnalysisCacheStats() {
+    return {
+        size: cache.size,
+        keys: Array.from(cache.keys()),
+    };
+}
+/**
+ * 🎯 Obtém resultado específico do cache
+ */
+export function getCachedSpecAnalysis(filePath) {
+    return cache.get(filePath) || null;
+}

package/dist/src/utils/StatementInterceptor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 🎯 Utilitário para Interceptar Statements Automaticamente
+ * @description Intercepta dinamicamente classes que começam com "Statements"
+ * @author AutoCore Team
+ * @version 1.0.0
+ */
+/**
+ * 🚀 Instalar interceptação automática para uma classe Statement
+ */
+export declare function interceptStatement<T extends new (...args: any[]) => any>(StatementClass: T): T;
+/**
+ * 🌐 Tentar interceptar todas as classes Statements no global
+ */
+export declare function interceptAllStatements(): void;
+/**
+ * 🔄 Hook para interceptar módulos ES6 importados
+ */
+export declare function setupModuleInterception(): void;

package/dist/src/utils/StatementInterceptor.js

@@ -0,0 +1,87 @@
+/**
+ * 🎯 Utilitário para Interceptar Statements Automaticamente
+ * @description Intercepta dinamicamente classes que começam com "Statements"
+ * @author AutoCore Team
+ * @version 1.0.0
+ */
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { Logger } from './Logger.js';
+/**
+ * 🔍 Proxy handler para interceptar métodos de classes Statements
+ */
+const statementsProxyHandler = {
+    construct(target, args) {
+        const instance = new target(...args);
+        // Interceptar todos os métodos da instância
+        return new Proxy(instance, {
+            get(obj, prop) {
+                const value = obj[prop];
+                // Se é uma função e não é constructor, interceptar
+                if (typeof value === 'function' && prop !== 'constructor') {
+                    return async (...methodArgs) => {
+                        const className = target.name;
+                        const methodName = String(prop);
+                        const timestamp = StatementTracker.startStatement(className, methodName);
+                        try {
+                            const result = await value.apply(obj, methodArgs);
+                            StatementTracker.finishStatement(timestamp, true);
+                            return result;
+                        }
+                        catch (error) {
+                            StatementTracker.finishStatement(timestamp, false, String(error));
+                            throw error;
+                        }
+                    };
+                }
+                return value;
+            },
+        });
+    },
+};
+/**
+ * 🚀 Instalar interceptação automática para uma classe Statement
+ */
+export function interceptStatement(StatementClass) {
+    // Se já foi interceptada, retornar a classe original
+    if (StatementClass.__autocore_intercepted) {
+        return StatementClass;
+    }
+    // Criar um proxy da classe
+    const ProxiedClass = new Proxy(StatementClass, statementsProxyHandler);
+    ProxiedClass.__autocore_intercepted = true;
+    Logger.info(`🎯 Classe ${StatementClass.name} interceptada para rastreamento de CTs`);
+    return ProxiedClass;
+}
+/**
+ * 🌐 Tentar interceptar todas as classes Statements no global
+ */
+export function interceptAllStatements() {
+    try {
+        if (typeof globalThis !== 'undefined') {
+            const globalObj = globalThis;
+            // Procurar por propriedades que começam com "Statements"
+            for (const key of Object.keys(globalObj)) {
+                if (key.startsWith('Statements') &&
+                    typeof globalObj[key] === 'function') {
+                    try {
+                        globalObj[key] = interceptStatement(globalObj[key]);
+                    }
+                    catch (error) {
+                        Logger.warning(`⚠️ Erro ao interceptar ${key}: ${error}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na interceptação automática de Statements: ${error}`);
+    }
+}
+/**
+ * 🔄 Hook para interceptar módulos ES6 importados
+ */
+export function setupModuleInterception() {
+    // Para ES modules, a interceptação é mais complexa
+    // Por enquanto, vamos focar na abordagem manual
+    Logger.info('🔄 Module interception configurado (ES modules)');
+}

package/dist/src/utils/StatementLogger.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 🎯 SOLUÇÃO DEFINITIVA E FUNCIONAL
+ *
+ * Sistema que intercepta automaticamente classes Statements
+ * usando uma abordagem simples e eficaz.
+ */
+/**
+ * 🔥 Sistema de AutoLogs que REALMENTE funciona
+ */
+export declare class StatementLogger {
+    private static ativo;
+    private static interceptedClasses;
+    /**
+     * 🚀 Ativar sistema
+     */
+    static ativar(): void;
+    /**
+     * 🎨 Aplicar logs a uma instância manualmente
+     */
+    static loggar<T extends object>(instance: T): T;
+    /**
+     * 🎯 Interceptar classe globalmente via prototype
+     */
+    static interceptClass<T extends new (...args: any[]) => any>(StatementsClass: T): T;
+}
+/**
+ * 🌟 Função helper para criar Statements com logs
+ */
+export declare function createStatements<T extends object>(StatementsClass: new (...args: any[]) => T, ...args: any[]): T;
+/**
+ * 🔥 Função principal para ativar
+ */
+export declare function ativarStatementLogs(): void;

package/dist/src/utils/StatementLogger.js

@@ -0,0 +1,113 @@
+import { Logger } from './Logger.js';
+/**
+ * 🎯 SOLUÇÃO DEFINITIVA E FUNCIONAL
+ *
+ * Sistema que intercepta automaticamente classes Statements
+ * usando uma abordagem simples e eficaz.
+ */
+/**
+ * 🔥 Sistema de AutoLogs que REALMENTE funciona
+ */
+export class StatementLogger {
+    static ativo = false;
+    static interceptedClasses = new Set();
+    /**
+     * 🚀 Ativar sistema
+     */
+    static ativar() {
+        if (StatementLogger.ativo)
+            return;
+        StatementLogger.ativo = true;
+    }
+    /**
+     * 🎨 Aplicar logs a uma instância manualmente
+     */
+    static loggar(instance) {
+        if (!StatementLogger.ativo)
+            return instance;
+        const className = instance.constructor.name;
+        // Evitar re-wrapping
+        if (instance.__isStatementLogged) {
+            return instance;
+        }
+        const wrappedInstance = new Proxy(instance, {
+            get(target, prop) {
+                const value = Reflect.get(target, prop);
+                if (typeof value === 'function' &&
+                    typeof prop === 'string' &&
+                    !prop.startsWith('_') &&
+                    prop !== 'constructor') {
+                    return async (...args) => {
+                        const startTime = Date.now();
+                        // 🎯 NOVO: Log de início mais visível
+                        Logger.info(`\n┌─`.repeat(40) + '┐');
+                        Logger.info(`│ 🎯 MÉTODO: ${className}.${prop}`);
+                        if (args.length > 0) {
+                            const argStr = args
+                                .map((a) => typeof a === 'string' && a.length > 30
+                                ? `${a.substring(0, 27)}...`
+                                : String(a))
+                                .join(', ');
+                            Logger.info(`│ 📝 Parâmetros: ${argStr}`);
+                        }
+                        Logger.info('└─'.repeat(40) + '┘');
+                        try {
+                            // Executar método original
+                            const result = await value.apply(target, args);
+                            // Log de sucesso
+                            const duration = Date.now() - startTime;
+                            Logger.success(`✅ ${className}.${prop} - Concluído em ${duration}ms`);
+                            Logger.info('═'.repeat(80) + '\n');
+                            return result;
+                        }
+                        catch (error) {
+                            // Log de erro
+                            const duration = Date.now() - startTime;
+                            Logger.error(`❌ ${className}.${prop} - ERRO após ${duration}ms: ${error}`);
+                            Logger.info('═'.repeat(80) + '\n');
+                            throw error;
+                        }
+                    };
+                }
+                return value;
+            },
+        });
+        wrappedInstance.__isStatementLogged = true;
+        return wrappedInstance;
+    }
+    /**
+     * 🎯 Interceptar classe globalmente via prototype
+     */
+    static interceptClass(StatementsClass) {
+        if (!StatementLogger.ativo)
+            return StatementsClass;
+        const className = StatementsClass.name;
+        if (StatementLogger.interceptedClasses.has(className)) {
+            return StatementsClass;
+        }
+        StatementLogger.interceptedClasses.add(className);
+        // Criar proxy do constructor
+        const ProxiedClass = new Proxy(StatementsClass, {
+            construct(target, args) {
+                const instance = new target(...args);
+                Logger.info(`🎯 Auto-interceptado: ${className}`);
+                return StatementLogger.loggar(instance);
+            },
+        });
+        return ProxiedClass;
+    }
+}
+/**
+ * 🌟 Função helper para criar Statements com logs
+ */
+export function createStatements(StatementsClass, ...args) {
+    StatementLogger.ativar();
+    const instance = new StatementsClass(...args);
+    return StatementLogger.loggar(instance);
+}
+/**
+ * 🔥 Função principal para ativar
+ */
+export function ativarStatementLogs() {
+    StatementLogger.ativar();
+}

package/dist/src/utils/StatementsInterceptor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/StatementsInterceptor.js

@@ -0,0 +1 @@
+export {};