@silasfmartins/testhub 1.0.0

package/dist/src/hubdocs/HubDocs.js

@@ -0,0 +1,3586 @@
+/**
+ * 📚 HubDocs - Sistema Principal de Documentação Automática (Versão Funcional)
+ * @silasfmartins/testhub - Auto Documentation System v1.1.51
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import * as yaml from 'js-yaml';
+import { ExecutionTracker } from './ExecutionTracker.js';
+import { StatementTracker } from './StatementTracker.js';
+import { Logger } from '../utils/Logger.js';
+export class AutoDocs {
+    static initialized = false;
+    static finalizationExecuted = false;
+    static config = {
+        enabled: true,
+        categories: ['api', 'ssh', 'db', 'ui', 'mobile'],
+        outputDir: './docs',
+        includeRequestBody: true,
+        includeResponseBody: true,
+        generateSwagger: true,
+        includeScreenshots: true,
+        maxScreenshotSize: 1920,
+        projectName: 'Test Hub',
+    };
+    /**
+     * 🚀 Inicializar o sistema AutoDocs
+     */
+    static async initialize(options) {
+        try {
+            if (AutoDocs.initialized) {
+                return;
+            }
+            // Aplicar configurações personalizadas
+            if (options?.config) {
+                AutoDocs.config = { ...AutoDocs.config, ...options.config };
+            }
+            if (options?.outputDir) {
+                AutoDocs.config.outputDir = options.outputDir;
+            }
+            if (options?.projectName) {
+                AutoDocs.config.projectName = options.projectName;
+            }
+            // Detectar tipo de projeto automaticamente
+            const projectType = AutoDocs.detectProjectType({
+                apis: [],
+                ssh: [],
+                db: [],
+                ui: [],
+                mobile: [],
+            });
+            // Garantir que o diretório de saída existe
+            await AutoDocs.ensureOutputDir();
+            // Inicializar ExecutionTracker
+            ExecutionTracker.initialize(AutoDocs.config.projectName, projectType);
+            // 🎯 REGISTRO GLOBAL para ApiActions
+            AutoDocs.registerGlobally();
+            AutoDocs.initialized = true;
+        }
+        catch (error) {
+            Logger.error('❌ AutoDocs: Erro na inicialização:', error);
+        }
+    }
+    /**
+     * 📖 Gerar documentação completa
+     */
+    static async generateDocs() {
+        // ✅ EVITAR EXECUÇÃO MÚLTIPLA
+        if (AutoDocs.finalizationExecuted) {
+            Logger.info('📚 AutoDocs: Documentação já foi gerada, pulando...');
+            return;
+        }
+        if (!AutoDocs.initialized) {
+            await AutoDocs.initialize();
+        }
+        try {
+            Logger.info('📚 AutoDocs: Iniciando geração de documentação...');
+            // Marcar como executado ANTES de começar
+            AutoDocs.finalizationExecuted = true;
+            // ✅ CRÍTICO: Finalizar coleta de dados PRIMEIRO
+            ExecutionTracker.finalize();
+            // ✅ NOVO: Forçar carregamento do arquivo persistido para evitar dados zerados
+            Logger.info('📊 AutoDocs: Forçando carregamento dos dados do arquivo...');
+            const fileData = ExecutionTracker.loadFromFile();
+            if (fileData) {
+                // Usar dados do arquivo diretamente
+                const data = fileData;
+                if (AutoDocs.hasDataToGenerate(data)) {
+                    Logger.info('📊 AutoDocs: Dados encontrados, gerando documentação...');
+                    // Gerar relatório HTML principal
+                    await AutoDocs.generateHTMLReport(data);
+                    // Gerar Swagger se habilitado e há APIs
+                    if (AutoDocs.config.generateSwagger && data.apis.length > 0) {
+                        Logger.info(`📋 AutoDocs: Gerando Swagger para ${data.apis.length} APIs...`);
+                        await AutoDocs.generateSwaggerDocs(data.apis);
+                    }
+                    Logger.success(`📚 AutoDocs: Documentação gerada com sucesso em ${AutoDocs.config.outputDir}`);
+                    Logger.info(`📊 Estatísticas: ${data.apis.length} APIs, ${data.ssh.length} SSH, ${data.db.length} DB, ${data.ui.length} UI, ${data.mobile.length} Mobile`);
+                }
+                else {
+                    Logger.info('📚 AutoDocs: Nenhum dado encontrado para gerar documentação');
+                    Logger.info('💡 AutoDocs: Execute seus testes para capturar dados automaticamente');
+                    // ✅ GERAR ARQUIVO BÁSICO MESMO SEM DADOS
+                    await AutoDocs.generateEmptyDocsReport();
+                    Logger.success('✅ Arquivo de documentação básico gerado!');
+                }
+            }
+            else {
+                Logger.info('📚 AutoDocs: Arquivo de dados não encontrado');
+                Logger.info('💡 AutoDocs: Execute seus testes para capturar dados automaticamente');
+                // ✅ GERAR ARQUIVO BÁSICO MESMO SEM DADOS
+                await AutoDocs.generateEmptyDocsReport();
+                Logger.success('✅ Arquivo de documentação básico gerado!');
+            }
+        }
+        catch (error) {
+            Logger.error('❌ AutoDocs: Erro na geração de documentação:', error);
+        }
+    }
+    /**
+     * 📄 Gerar relatório HTML principal
+     */
+    static async generateHTMLReport(data) {
+        try {
+            const htmlContent = AutoDocs.generateHTMLContent(data);
+            const outputPath = path.join(AutoDocs.config.outputDir, 'index.html');
+            await fs.promises.writeFile(outputPath, htmlContent, 'utf-8');
+            Logger.info(`📄 Relatório HTML gerado: ${outputPath}`);
+            // ℹ️ Visualização por CTs removida - agora está no relatório unificado
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao gerar HTML:', error);
+        }
+    }
+    /**
+     * 📄 Gerar documentação básica quando não há dados
+     */
+    static async generateEmptyDocsReport() {
+        try {
+            const htmlContent = AutoDocs.generateEmptyHTMLContent();
+            const outputPath = path.join(AutoDocs.config.outputDir, 'index.html');
+            await fs.promises.writeFile(outputPath, htmlContent, 'utf-8');
+            Logger.info(`📄 Documentação básica gerada: ${outputPath}`);
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao gerar documentação básica:', error);
+        }
+    }
+    /**
+     * 🔄 Reset do sistema (APENAS EM DESENVOLVIMENTO)
+     */
+    static reset() {
+        // ✅ PROTEÇÃO: Só permitir reset em desenvolvimento ou com confirmação explícita
+        const isProduction = process.env.NODE_ENV === 'production';
+        const forceReset = process.env.FORCE_AUTODOCS_RESET === 'true';
+        if (isProduction && !forceReset) {
+            Logger.warning('⚠️ AutoDocs.reset: Ignorado em produção. Use FORCE_AUTODOCS_RESET=true se necessário');
+            return;
+        }
+        Logger.warning('⚠️ AutoDocs.reset: RESETANDO SISTEMA - Esta ação limpará todos os dados!');
+        AutoDocs.initialized = false;
+        AutoDocs.finalizationExecuted = false;
+        // ✅ NOVO: Só resetar ExecutionTracker se explicitamente solicitado
+        if (forceReset) {
+            ExecutionTracker.reset();
+            Logger.info('📚 AutoDocs.reset: ExecutionTracker também foi resetado');
+        }
+        else {
+            Logger.info('📚 AutoDocs.reset: ExecutionTracker preservado (use FORCE_AUTODOCS_RESET=true para resetar tudo)');
+        }
+        Logger.info('📚 AutoDocs: Sistema resetado');
+    }
+    // 🎯 Métodos de interceptação FUNCIONAIS
+    /**
+     * 🌐 Interceptar chamada de API
+     * DESABILITADO: Evita duplicação com ApiActions que já faz interceptação
+     */
+    static async interceptAPI(operation, endpoint, config) {
+        // ✅ CRÍTICO: Retornar ID vazio para evitar duplicação
+        // O sistema ExecutionTracker via ApiActions já faz todo o trabalho
+        Logger.info('🔄 AutoDocs.interceptAPI: Delegando para ExecutionTracker via ApiActions');
+        return `autodocs-delegated-${Date.now()}`;
+    }
+    /**
+     * 🔄 Atualizar resultado de API
+     * DESABILITADO: Evita duplicação com ExecutionTracker
+     */
+    static async updateAPIResult(docId, response, statusCode, error) {
+        // ✅ CRÍTICO: Não fazer update duplicado
+        // O ExecutionTracker via ApiActions já faz todo o trabalho
+        Logger.info('🔄 AutoDocs.updateAPIResult: Delegando para ExecutionTracker via ApiActions');
+        return;
+    }
+    /**
+     * 🎯 Registrar AutoDocs globalmente para ApiActions
+     */
+    static registerGlobally() {
+        const APIACTIONS_CHECK_DELAY = 1000;
+        try {
+            // Registrar no global para ApiActions
+            ;
+            global.AutoDocs = AutoDocs;
+            globalThis.AutoDocs = AutoDocs;
+            // ✅ INTERCEPTAÇÃO AUTOMÁTICA DE FETCH: Capturar todas as requisições HTTP
+            AutoDocs.setupFetchInterception();
+            // ✅ CRÍTICO: Verificar se ApiActions está disponível e conectar
+            setTimeout(() => {
+                try {
+                    const apiActions = global.ApiActions ||
+                        globalThis.ApiActions;
+                    if (apiActions) {
+                        process.stdout.write('✅ AutoDocs: ApiActions detectado, sistema pronto para interceptação\n');
+                    }
+                    else {
+                        // Não exibir warning, pois fetch já está interceptado e funciona
+                    }
+                }
+                catch {
+                    // Silencioso - não precisa mostrar erro
+                }
+            }, APIACTIONS_CHECK_DELAY);
+        }
+        catch (error) {
+            process.stderr.write(`⚠️ AutoDocs: Erro ao registrar globalmente: ${error}\n`);
+        }
+    }
+    /**
+     * 🔗 Configurar interceptação automática de fetch
+     * DESABILITADO: Para evitar duplicação com ApiActions
+     */
+    static setupFetchInterception() {
+        // ✅ CRÍTICO: Desabilitar interceptação de fetch para evitar duplicação
+        // O ApiActions já faz todo o trabalho de tracking/documentação
+        return;
+    }
+    /**
+     * 🎯 Verificar se URL deve ser interceptada
+     * CORRIGIDO: Não interceptar URLs que já são processadas pelo ApiActions
+     */
+    static shouldInterceptURL(url) {
+        // ✅ CRÍTICO: Não interceptar URLs de API externas que já passam pelo ApiActions
+        // ApiActions já faz o tracking completo, então não precisamos duplicar
+        if (url.includes('api-qa1.telefonica.com.br') ||
+            url.includes('telefonica.com') ||
+            url.includes('.com.br/') ||
+            url.includes('/api/') ||
+            url.includes('/v1/') ||
+            url.includes('opportunity')) {
+            return false; // Deixar o ApiActions gerenciar essas URLs
+        }
+        // Interceptar apenas URLs específicas que não passam pelo ApiActions
+        return (url.includes('localhost:') &&
+            (url.includes('/internal/') ||
+                url.includes('/health') ||
+                url.includes('/metrics')));
+    }
+    /**
+     * 🔄 Processar fetch interceptado
+     */
+    static async handleInterceptedFetch(originalFetch, args, method, url, init) {
+        let docId = null;
+        try {
+            docId = await AutoDocs.interceptAPI(method, url, {
+                method,
+                headers: init?.headers,
+                payload: init?.body,
+                url,
+            });
+        }
+        catch {
+            // Falhou na interceptação, continuar sem documentar
+        }
+        try {
+            const response = await originalFetch(...args);
+            // Atualizar documentação com resposta
+            if (docId) {
+                await AutoDocs.updateFetchResponse(docId, response);
+            }
+            return response;
+        }
+        catch (error) {
+            // Atualizar com erro se documentando
+            if (docId) {
+                await AutoDocs.updateFetchError(docId, error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * 📥 Atualizar resposta do fetch
+     */
+    static async updateFetchResponse(docId, response) {
+        try {
+            const responseText = await response.clone().text();
+            let responseData = responseText;
+            try {
+                responseData = JSON.parse(responseText);
+            }
+            catch {
+                // Não é JSON, usar como string
+            }
+            await AutoDocs.updateAPIResult(docId, responseData, response.status);
+        }
+        catch {
+            // Falhou na atualização, continuar
+        }
+    }
+    /**
+     * ❌ Atualizar erro do fetch
+     */
+    static async updateFetchError(docId, error) {
+        try {
+            await AutoDocs.updateAPIResult(docId, { error: String(error) }, 0);
+        }
+        catch {
+            // Falhou na atualização de erro, continuar
+        }
+    }
+    /**
+     * 🔧 NOVO: Método para forçar geração da documentação
+     */
+    static async forceGenerate() {
+        Logger.info('🔄 AutoDocs: Forçando geração de documentação...');
+        try {
+            // Verificar dados antes de gerar
+            const data = ExecutionTracker.getData();
+            Logger.info('🔍 AutoDocs: Dados disponíveis antes da geração:');
+            Logger.info(`   📋 APIs: ${data.apis.length}`);
+            Logger.info(`   🖥️ SSH: ${data.ssh.length}`);
+            Logger.info(`   🗄️ DB: ${data.db.length}`);
+            Logger.info(`   🎨 UI: ${data.ui.length}`);
+            Logger.info(`   📱 Mobile: ${data.mobile.length}`);
+            // Se não há dados, verificar se há arquivo temporário
+            if (data.apis.length === 0) {
+                const tempData = ExecutionTracker.loadFromFile();
+                if (tempData && tempData.apis.length > 0) {
+                    Logger.info(`📁 AutoDocs: Encontrados ${tempData.apis.length} APIs no arquivo temporário`);
+                }
+                else {
+                    Logger.info('❌ AutoDocs: Nenhum dado encontrado para gerar documentação');
+                    Logger.info('💡 AutoDocs: Execute alguns testes com ApiActions primeiro');
+                }
+            }
+            await AutoDocs.generateDocs();
+        }
+        catch (error) {
+            Logger.error('❌ AutoDocs: Erro na geração forçada:', error);
+        }
+    }
+    /**
+     * 🖥️ Interceptar comando SSH
+     */
+    static async interceptSSH(command, host, details) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('ssh'))) {
+            return;
+        }
+        const sshCommand = {
+            command,
+            output: '',
+            host: host || process.env.SSH_HOST || 'unknown',
+            user: details?.user || process.env.SSH_USER || 'unknown',
+            timestamp: new Date().toISOString(),
+            testName: AutoDocs.getCurrentTestName(),
+            duration: 0,
+            success: false,
+            error: undefined,
+        };
+        ExecutionTracker.trackSSH(sshCommand);
+    }
+    /**
+     * 🗄️ Interceptar query de banco
+     */
+    static interceptDB(query, params, dbType, description, serviceName) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('db'))) {
+            return;
+        }
+        const dbQuery = {
+            testName: AutoDocs.getCurrentTestName(),
+            environment: process.env.NODE_ENV || 'development',
+            query: query.trim(),
+            params: params || [],
+            type: AutoDocs.detectQueryType(query),
+            database: dbType || 'oracle',
+            timestamp: new Date().toISOString(),
+            duration: 0,
+            success: undefined, // ✅ CORRIGIDO: Começar com undefined para melhor detecção
+            error: undefined,
+            description: description || undefined,
+            serviceName: serviceName || undefined,
+        };
+        Logger.info(`🗄️ [HubDocs] Interceptando query: ${query.substring(0, 50)}...`);
+        ExecutionTracker.trackDB(dbQuery);
+    }
+    /**
+     * 🔄 Atualizar resultado de query de banco
+     */
+    static updateDBResult(query, timestamp, success, duration, error, resultCount) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('db')))
+            return;
+        Logger.info(`🔄 [HubDocs] updateDBResult chamado: success=${success}, duration=${duration}ms, error=${error}`);
+        ExecutionTracker.updateDBResult(query, timestamp, success, duration, error, resultCount);
+    }
+    /**
+     * 🔄 Atualizar resultado de comando SSH
+     */
+    static updateSSHResult(command, timestamp, success, duration, exitCode, error) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('ssh')))
+            return;
+        ExecutionTracker.updateSSHResult(command, timestamp, success, duration, exitCode, error);
+    }
+    /**
+     * 🎨 Interceptar ação de UI
+     */
+    static async interceptUI(action, element, url, details) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('ui'))) {
+            return;
+        }
+        const uiAction = {
+            testName: AutoDocs.getCurrentTestName(),
+            action,
+            element: element || 'unknown',
+            selector: element || 'unknown', // O seletor é o element passado
+            description: details?.description || action, // 🆕 Capturar description dos details
+            page: url || details?.url || 'unknown',
+            timestamp: new Date().toISOString(),
+            success: false,
+            duration: 0,
+            screenshot: details?.screenshot,
+            error: undefined,
+        };
+        ExecutionTracker.trackUI(uiAction);
+    }
+    /**
+     * 🆕 Atualizar status de sucesso de uma ação UI
+     */
+    static updateActionSuccess(action, element, success, duration, error) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('ui'))) {
+            return;
+        }
+        try {
+            const data = ExecutionTracker.getData();
+            // Encontrar a última ação UI que corresponde ao action e element
+            for (let i = data.ui.length - 1; i >= 0; i--) {
+                const uiAction = data.ui[i];
+                if (uiAction.action === action && uiAction.selector === element) {
+                    uiAction.success = success;
+                    uiAction.duration = duration;
+                    if (error) {
+                        uiAction.error = error;
+                    }
+                    // Forçar save usando método interno
+                    ExecutionTracker['saveToFile']();
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            // Ignorar erros para não quebrar funcionalidade principal
+        }
+    }
+    /**
+     * 📱 Interceptar ação mobile
+     */
+    static async interceptMobile(action, element, platform, details) {
+        if (!(AutoDocs.config.enabled && AutoDocs.config.categories.includes('mobile'))) {
+            return;
+        }
+        const mobileAction = {
+            testName: AutoDocs.getCurrentTestName(),
+            action,
+            element: element || 'unknown',
+            device: details?.device || 'unknown',
+            platform: platform || 'Android',
+            timestamp: new Date().toISOString(),
+            value: details?.value,
+            coordinates: details?.coordinates,
+        };
+        ExecutionTracker.trackMobile(mobileAction);
+    }
+    /**
+     * 🧹 Extrair nome limpo do CT removendo logs excessivos
+     */
+    static extractCleanCTName(ctName) {
+        if (!ctName)
+            return 'CT Sem Nome';
+        // Se tem menos de 50 caracteres, retorna completo
+        if (ctName.length <= 50)
+            return ctName;
+        // Tentar extrair apenas a parte do CT sem logs
+        const lines = ctName.split('\n');
+        if (lines.length > 0) {
+            const firstLine = lines[0].trim();
+            // Se a primeira linha parece ser um ID de CT, usar ela
+            if (firstLine.includes('CT') || firstLine.length < 100) {
+                return firstLine;
+            }
+        }
+        // Procurar por padrões específicos de CT
+        const ctMatch = ctName.match(/CT\d+\s*-\s*([^[\n{(]+)/i);
+        if (ctMatch)
+            return ctMatch[0].trim();
+        // Procurar por método - descrição (sem logs)
+        const methodMatch = ctName.match(/(\w+\(\)\s*-\s*[^[\n{(]{1,80})/i);
+        if (methodMatch)
+            return methodMatch[1].trim();
+        // Como último recurso, pegar apenas os primeiros 50 caracteres
+        return `${ctName.substring(0, 50)}...`;
+    }
+    /**
+     * 🔐 Escapar HTML para segurança
+     */
+    static escapeHtml(text) {
+        if (!text) {
+            return '';
+        }
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;')
+            .replace(/\n/g, '<br>');
+    }
+    /**
+     * 🖼️ Resolve caminho de imagem para data URI quando possível
+     */
+    static resolveImageSource(imagePath) {
+        if (!imagePath) {
+            return null;
+        }
+        const trimmed = imagePath.trim();
+        if (!trimmed) {
+            return null;
+        }
+        if (/^data:image\//i.test(trimmed) || /^https?:\/\//i.test(trimmed)) {
+            return trimmed;
+        }
+        const normalized = trimmed
+            .replace(/^file:\/\//i, '')
+            .replace(/\\/g, path.sep);
+        const candidates = new Set();
+        if (path.isAbsolute(normalized)) {
+            candidates.add(path.normalize(normalized));
+        }
+        else {
+            candidates.add(path.normalize(normalized));
+            candidates.add(path.join(process.cwd(), normalized));
+            candidates.add(path.join(process.cwd(), 'playwright-report', normalized));
+            candidates.add(path.join(process.cwd(), 'test-results', normalized));
+        }
+        for (const candidate of candidates) {
+            try {
+                if (fs.existsSync(candidate)) {
+                    const buffer = fs.readFileSync(candidate);
+                    return AutoDocs.toDataUri(candidate, buffer);
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ [HubDocs] Falha ao embutir imagem (${candidate}): ${error}`);
+            }
+        }
+        return trimmed;
+    }
+    /**
+     * 🧪 Converte buffer de imagem em data URI
+     */
+    static toDataUri(filePath, buffer) {
+        const mime = AutoDocs.detectMimeType(filePath);
+        return `data:${mime};base64,${buffer.toString('base64')}`;
+    }
+    /**
+     * 🎨 Detecta MIME-Type básico pelo sufixo do arquivo
+     */
+    static detectMimeType(filePath) {
+        switch (path.extname(filePath).toLowerCase()) {
+            case '.jpg':
+            case '.jpeg':
+                return 'image/jpeg';
+            case '.gif':
+                return 'image/gif';
+            case '.webp':
+                return 'image/webp';
+            case '.svg':
+                return 'image/svg+xml';
+            default:
+                return 'image/png';
+        }
+    }
+    // 🔧 Métodos utilitários
+    /**
+     * 🔍 Detectar versão do AutoCore instalada dinamicamente
+     */
+    static getProjectVersion() {
+        try {
+            // ✅ CORRIGIDO: Usar fs e path já importados no topo do arquivo
+            // Primeiro, tentar obter informações do projeto do usuário
+            const root = process.cwd();
+            const pkgPath = path.join(root, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                // Obter nome do projeto do usuário
+                const projectName = pkg.name || 'Projeto Test HUB';
+                // Obter versão do AutoCore instalada (igual ao UnifiedHtmlGenerator e ExecutionTracker)
+                const autocoreVersion = pkg.dependencies?.['@silasfmartins/testhub'] ||
+                    pkg.devDependencies?.['@silasfmartins/testhub'] ||
+                    '1.1.X';
+                Logger.info(`📦 HUBDocs: Projeto ${projectName} usando Test HUB ${autocoreVersion}`);
+                return `TestHub@${autocoreVersion}`;
+            }
+            // Fallback: tentar buscar em diretórios pai
+            let currentDir = root;
+            let attempts = 0;
+            const maxAttempts = 3;
+            while (attempts < maxAttempts) {
+                const packagePath = path.join(currentDir, 'package.json');
+                if (fs.existsSync(packagePath)) {
+                    const packageContent = fs.readFileSync(packagePath, 'utf8');
+                    const packageData = JSON.parse(packageContent);
+                    const autocoreVersion = packageData.dependencies?.['@silasfmartins/testhub'] ||
+                        packageData.devDependencies?.['@silasfmartins/testhub'] ||
+                        '1.1.X';
+                    Logger.info(`📦 HUBDocs: Test Hub ${autocoreVersion} detectado em ${packagePath}`);
+                    return `Test Hub@${autocoreVersion}`;
+                }
+                // Subir um nível no diretório
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir)
+                    break; // Chegou na raiz
+                currentDir = parentDir;
+                attempts++;
+            }
+            // Fallback para versão padrão
+            Logger.warning('⚠️ AutoDocs: package.json não encontrado, usando versão padrão');
+            return 'Test Hub@1.1.X';
+        }
+        catch (error) {
+            Logger.warning(`⚠️ AutoDocs: Erro ao detectar versão do Test Hub: ${error instanceof Error ? error.message : String(error)}`);
+            return 'Test Hub@1.1.X';
+        }
+    }
+    /**
+     * 🎨 Gerar conteúdo HTML com dados usando TailwindCSS e funcionalidades completas
+     */
+    static generateHTMLContent(data) {
+        if (!data || Object.keys(data).length === 0) {
+            return AutoDocs.generateEmptyHTMLContent();
+        }
+        // 🔧 Detectar versão dinâmica do projeto local
+        const projectVersion = AutoDocs.getProjectVersion();
+        // 🤖 Detectar categorias automaticamente
+        const detectedCategories = AutoDocs.detectProjectCategories(data.apis || []);
+        const categoryOverview = Object.entries(detectedCategories)
+            .filter(([key]) => key !== 'outras')
+            .map(([key, catData]) => `${catData.icon} ${key.charAt(0).toUpperCase() + key.slice(1)}`)
+            .join(', ');
+        const timestamp = new Date().toLocaleString('pt-BR');
+        const totalItems = (data.apis?.length || 0) +
+            (data.ssh?.length || 0) +
+            (data.db?.length || 0) +
+            (data.ui?.length || 0) +
+            (data.mobile?.length || 0);
+        return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>📚 ${AutoDocs.config.projectName} - HubDocs Inteligente</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: #111827 !important; }
+        .card { background: #1e293b; border-radius: 1rem; padding: 1.5rem; box-shadow: 0 2px 8px #0002; color: #f1f5f9; }
+        .light-mode .card { background: #fff; color: #111827; border: 1px solid #e5e7eb; }
+        .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: #374151; color: #fff; border: 1px solid #d1d5db; }
+        .light-mode .btn:hover { background: #4b5563; }
+        .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: #f3f4f6; color: #111827; border: 1px solid #e5e7eb; }
+        .light-mode .header-title { color: #d97706; }
+        .light-mode .header-meta { color: #374151 !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: #f3f4f6; color: #d97706; border: 1px solid #e5e7eb; }
+        .footer-bar a { color: #fbbf24; text-decoration: underline; }
+        .light-mode .footer-bar a { color: #d97706; font-weight: 600; }
+        .method-badge { display: inline-block; padding: 4px 12px; border-radius: 9999px; font-size: 12px; font-weight: 600; color: white; }
+        .method-get { background: #10b981; }
+        .method-post { background: #3b82f6; }
+        .method-put { background: #f59e0b; }
+        .method-delete { background: #ef4444; }
+        .method-patch { background: #8b5cf6; }
+        .status-badge { display: inline-block; padding: 4px 12px; border-radius: 9999px; font-size: 12px; font-weight: 600; }
+        @media (max-width: 900px) {
+            .grid-cols-2, .grid-cols-3, .grid-cols-4, .grid-cols-5 { grid-template-columns: 1fr !important; }
+        }
+    </style>
+</head>
+<body id="body-root" class="min-h-screen bg-slate-900 text-slate-100">
+    <div class="header-bar">
+        <div>
+            <h1 class="header-title">📚 ${AutoDocs.config.projectName} - HubDocs Inteligente</h1>
+            <p class="header-meta">🤖 Categorização Inteligente: ${categoryOverview || 'Sistema Adaptativo'}</p>
+        </div>
+        <div class="flex gap-2">
+            <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>
+
+    <div id="report-root" class="max-w-7xl mx-auto p-6" style="background:inherit;">
+        <!-- Overview Cards -->
+        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-5 gap-6 mb-8">
+            <div class="card bg-gradient-to-br from-green-600 to-green-700">
+                <h3 class="text-3xl font-bold text-white">${data.apis?.length || 0}</h3>
+                <p class="text-green-100">🌐 APIs Inteligentes</p>
+            </div>
+            <div class="card bg-gradient-to-br from-blue-600 to-blue-700">
+                <h3 class="text-3xl font-bold text-white">${data.ssh?.length || 0}</h3>
+                <p class="text-blue-100">🖥️ Comandos SSH</p>
+            </div>
+            <div class="card bg-gradient-to-br from-purple-600 to-purple-700">
+                <h3 class="text-3xl font-bold text-white">${data.db?.length || 0}</h3>
+                <p class="text-purple-100">🗄️ Queries Database</p>
+            </div>
+            <div class="card bg-gradient-to-br from-orange-600 to-orange-700">
+                <h3 class="text-3xl font-bold text-white">${data.ui?.length || 0}</h3>
+                <p class="text-orange-100">🎨 Ações UI</p>
+            </div>
+            <div class="card bg-gradient-to-br from-pink-600 to-pink-700">
+                <h3 class="text-3xl font-bold text-white">${data.mobile?.length || 0}</h3>
+                <p class="text-pink-100">📱 Ações Mobile</p>
+            </div>
+        </div>
+
+        <!-- Intelligent System Info -->
+        <div class="card mb-8 bg-gradient-to-r from-blue-600 to-purple-600">
+            <h3 class="text-xl font-bold text-white mb-4">🤖 Sistema de Categorização Inteligente</h3>
+            <div class="text-white space-y-2">
+                <p><span class="font-semibold">📊 Total de Itens:</span> ${totalItems}</p>
+                <p><span class="font-semibold">🎯 Categorias Detectadas:</span> ${categoryOverview || 'Analisando padrões...'}</p>
+                <p><span class="font-semibold">🕐 Gerado em:</span> ${timestamp}</p>
+                <p class="text-sm text-blue-100 mt-3">✨ Sistema adapta-se automaticamente aos padrões dos seus testes, detectando categorias empresariais como Customer, Billing, Catalog, Simulation, Workflow e mais!</p>
+            </div>
+        </div>
+
+        <!-- Agrupamento Inteligente por Categoria -->
+        ${AutoDocs.generateGroupedSections(data)}
+    </div>
+
+    <div class="footer-bar">
+        Desenvolvido por <strong>HubDocs Inteligente (${projectVersion})</strong> &mdash; Sistema de Categorização Automática com IA.<br>
+        <span>Documentação gerada automaticamente em ${timestamp}. <a href="#" onclick="alert('Sistema AutoDocs: Categorização inteligente baseada em padrões empresariais')">📚 Sobre a IA</a></span>
+    </div>
+
+    <script>
+        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'))
+            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')
+            }
+        }
+
+        // 🆕 Função para expandir/colapsar seções
+        function toggleSection(sectionKey) {
+            const section = document.getElementById('section-' + sectionKey)
+            const btn = document.getElementById('btn-' + sectionKey)
+            
+            if (section && btn) {
+                if (section.style.display === 'none') {
+                    section.style.display = 'block'
+                    btn.innerHTML = '📋 Ocultar'
+                } else {
+                    section.style.display = 'none'
+                    btn.innerHTML = '📋 Detalhes'
+                }
+            }
+        }
+
+        function getAllData() {
+            return {
+                apis: ${JSON.stringify(data.apis || [])},
+                ssh: ${JSON.stringify(data.ssh || [])},
+                db: ${JSON.stringify(data.db || [])},
+                ui: ${JSON.stringify(data.ui || [])},
+                mobile: ${JSON.stringify(data.mobile || [])},
+                detectedCategories: ${JSON.stringify(detectedCategories)},
+                timestamp: '${timestamp}',
+                projectName: '${AutoDocs.config.projectName}'
+            }
+        }
+
+        document.getElementById('export-pdf').onclick = async () => {
+            console.log('🔵 [PDF] Botão clicado - Iniciando geração do PDF do AutoDocs...');
+            
+            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 - preparando incorporação em base64 para ambiente 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 originalStates = {
+              groups: [],
+              apis: [],
+              screenshots: []
+            };
+            
+            // Expandir todos os grupos/seções colapsáveis
+            const allGroups = element.querySelectorAll('[id*="group-"], [id*="section-"], [id*="action-"]');
+            allGroups.forEach((group) => {
+              originalStates.groups.push(group.style.display);
+              group.style.display = 'block';
+            });
+
+            // Expandir detalhes de APIs
+            const allApiDetails = element.querySelectorAll('.api-details, .ssh-details, .db-details, .mobile-details');
+            allApiDetails.forEach((detail) => {
+              originalStates.apis.push(detail.style.display);
+              detail.style.display = 'block';
+            });
+
+            // Aguardar imagens carregarem
+            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');
+            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';
+
+            console.log('📄 [PDF] Iniciando geração do PDF...');
+            
+            try {
+              // Usar html2canvas para capturar o conteúdo
+              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;
+              const pageHeight = 297;
+              const imgHeight = (canvas.height * imgWidth) / canvas.width;
+              let heightLeft = imgHeight;
+              let position = 0;
+              
+              pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight);
+              heightLeft -= pageHeight;
+              
+              while (heightLeft > 0) {
+                position = heightLeft - imgHeight;
+                pdf.addPage();
+                pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight);
+                heightLeft -= pageHeight;
+              }
+              
+              pdf.save('autodocs-inteligente.pdf');
+              
+              console.log('✅ PDF do AutoDocs gerado com sucesso!');
+              alert('✅ PDF do AutoDocs gerado com sucesso! Verifique sua pasta de Downloads.');
+            } catch (error) {
+              console.error('❌ Erro ao gerar PDF do AutoDocs:', error);
+              alert('❌ Erro ao gerar PDF: ' + error.message);
+            } finally {
+              // Restaurar estilos originais
+              element.style.background = originalBg;
+              element.style.color = originalColor;
+
+              // Restaurar estados originais das seções
+              allGroups.forEach((group, index) => {
+                group.style.display = originalStates.groups[index] || '';
+              });
+
+              allApiDetails.forEach((detail, index) => {
+                detail.style.display = originalStates.apis[index] || '';
+              });
+            }
+          };
+
+        document.getElementById('export-csv').onclick = () => {
+            const allData = getAllData()
+            const csvData = []
+            
+            // Headers
+            csvData.push(['Tipo', 'Nome', 'URL/Comando', 'Status', 'Duração', 'Teste', 'Timestamp'])
+            
+            // APIs
+            allData.apis.forEach(api => {
+                csvData.push(['API', api.testName, api.url, api.success ? 'Sucesso' : 'Erro', api.duration + 'ms', api.testName, new Date(api.timestamp).toLocaleString('pt-BR')])
+            })
+            
+            // SSH
+            allData.ssh.forEach(ssh => {
+                csvData.push(['SSH', ssh.command, ssh.host, ssh.success ? 'Sucesso' : 'Erro', ssh.duration + 'ms', ssh.testName, new Date(ssh.timestamp).toLocaleString('pt-BR')])
+            })
+            
+            const csv = csvData.map(row => row.join(';')).join('\\n')
+            const blob = new Blob([csv], { type: 'text/csv' })
+            const a = document.createElement('a')
+            a.href = URL.createObjectURL(blob)
+            a.download = 'autodocs-inteligente.csv'
+            a.click()
+        }
+
+        document.getElementById('export-json').onclick = () => {
+            const blob = new Blob([JSON.stringify(getAllData(), null, 2)], { type: 'application/json' })
+            const a = document.createElement('a')
+            a.href = URL.createObjectURL(blob)
+            a.download = 'autodocs-inteligente.json'
+            a.click()
+        }
+
+        document.getElementById('export-xlsx').onclick = () => {
+            try {
+                const allData = getAllData()
+                const workbook = XLSX.utils.book_new()
+                let hasData = false
+                
+                // Sheet APIs
+                if (allData.apis && allData.apis.length > 0) {
+                    const apiSheet = XLSX.utils.json_to_sheet(allData.apis.map(api => ({
+                        'Teste': api.testName || 'N/A',
+                        'Método': api.method || 'N/A',
+                        'URL': api.url || 'N/A',
+                        'Status Code': api.statusCode || 'N/A',
+                        'Sucesso': api.success ? 'Sim' : 'Não',
+                        'Duração (ms)': api.duration || 0,
+                        'Ambiente': api.environment || 'N/A',
+                        'Timestamp': new Date(api.timestamp).toLocaleString('pt-BR')
+                    })))
+                    XLSX.utils.book_append_sheet(workbook, apiSheet, 'APIs')
+                    hasData = true
+                }
+                
+                // Sheet SSH
+                if (allData.ssh && allData.ssh.length > 0) {
+                    const sshSheet = XLSX.utils.json_to_sheet(allData.ssh.map(ssh => ({
+                        'Teste': ssh.testName || 'N/A',
+                        'Comando': ssh.command || 'N/A',
+                        'Host': ssh.host || 'N/A',
+                        'Usuário': ssh.user || 'N/A',
+                        'Sucesso': ssh.success ? 'Sim' : 'Não',
+                        'Duração (ms)': ssh.duration || 0,
+                        'Timestamp': new Date(ssh.timestamp).toLocaleString('pt-BR')
+                    })))
+                    XLSX.utils.book_append_sheet(workbook, sshSheet, 'SSH')
+                    hasData = true
+                }
+                
+                // Sheet Database
+                if (allData.db && allData.db.length > 0) {
+                    const dbSheet = XLSX.utils.json_to_sheet(allData.db.map(db => ({
+                        'Teste': db.testName || 'N/A',
+                        'Query': db.query ? db.query.substring(0, 100) : 'N/A',
+                        'Tipo': db.type || 'N/A',
+                        'Database': db.database || 'N/A',
+                        'Sucesso': db.success ? 'Sim' : 'Não',
+                        'Duração (ms)': db.duration || 0,
+                        'Resultado Count': db.resultCount || 0,
+                        'Timestamp': new Date(db.timestamp).toLocaleString('pt-BR')
+                    })))
+                    XLSX.utils.book_append_sheet(workbook, dbSheet, 'Database')
+                    hasData = true
+                }
+                
+                // Sheet UI
+                if (allData.ui && allData.ui.length > 0) {
+                    const uiSheet = XLSX.utils.json_to_sheet(allData.ui.map(ui => ({
+                        'Teste': ui.testName || 'N/A',
+                        'Ação': ui.action || 'N/A',
+                        'Elemento': ui.element || 'N/A',
+                        'Página': ui.page || 'N/A',
+                        'Sucesso': ui.success ? 'Sim' : 'Não',
+                        'Duração (ms)': ui.duration || 0,
+                        'Timestamp': new Date(ui.timestamp).toLocaleString('pt-BR')
+                    })))
+                    XLSX.utils.book_append_sheet(workbook, uiSheet, 'UI')
+                    hasData = true
+                }
+                
+                // Sheet Mobile
+                if (allData.mobile && allData.mobile.length > 0) {
+                    const mobileSheet = XLSX.utils.json_to_sheet(allData.mobile.map(mobile => ({
+                        'Teste': mobile.testName || 'N/A',
+                        'Ação': mobile.action || 'N/A',
+                        'Elemento': mobile.element || 'N/A',
+                        'Device': mobile.device || 'N/A',
+                        'Platform': mobile.platform || 'N/A',
+                        'Timestamp': new Date(mobile.timestamp).toLocaleString('pt-BR')
+                    })))
+                    XLSX.utils.book_append_sheet(workbook, mobileSheet, 'Mobile')
+                    hasData = true
+                }
+                
+                // Verificar se há dados
+                if (!hasData) {
+                    alert('⚠️ Nenhum dado disponível para exportar. Execute testes primeiro!')
+                    return
+                }
+                
+                // Gerar arquivo
+                XLSX.writeFile(workbook, 'autodocs-inteligente.xlsx')
+                console.log('✅ XLSX gerado com sucesso!')
+            } catch (error) {
+                console.error('❌ Erro ao gerar XLSX:', error)
+                alert('❌ Erro ao gerar XLSX: ' + error.message)
+            }
+        }
+
+        // ✅ NOVA FUNÇÃO: Carregar e renderizar CNs e CTs do ct-execution-data.json
+        async function loadCtData() {
+            try {
+                const response = await fetch('./ct-execution-data.json')
+                if (!response.ok) {
+                    document.getElementById('cn-container').innerHTML = \`
+                        <div class="bg-yellow-900/20 border border-yellow-600 rounded p-4">
+                            <p class="text-yellow-400">⚠️ Nenhum arquivo <strong>ct-execution-data.json</strong> encontrado.</p>
+                            <p class="text-gray-400 text-sm mt-2">Execute testes primeiro para gerar os dados.</p>
+                        </div>
+                    \`
+                    return
+                }
+                
+                const ctData = await response.json()
+                
+                // ✅ SUPORTAR ESTRUTURA NOVA: { tests: [{ cts: [...] }] }
+                let ctArray = []
+                if (ctData.tests && Array.isArray(ctData.tests)) {
+                    // Nova estrutura: extrair todos os CTs de todos os testes
+                    ctData.tests.forEach(test => {
+                        if (test.cts && Array.isArray(test.cts)) {
+                            ctArray.push(...test.cts.map(ct => ({
+                                ...ct,
+                                cn: test.testName || ct.cn || 'Sem CN'
+                            })))
+                        }
+                    })
+                } else {
+                    // Estrutura antiga (fallback): Object.values
+                    ctArray = Object.values(ctData)
+                }
+                
+                if (ctArray.length === 0) {
+                    document.getElementById('cn-container').innerHTML = \`
+                        <div class="bg-gray-800 rounded p-4">
+                            <p class="text-gray-400">📊 Nenhum CT executado ainda.</p>
+                        </div>
+                    \`
+                    return
+                }
+                
+                // Agrupar CTs por CN (Cenário de Negócio)
+                const cnMap = {}
+                ctArray.forEach(ct => {
+                    const cnName = ct.cn || 'Sem CN'
+                    if (!cnMap[cnName]) {
+                        cnMap[cnName] = {
+                            name: cnName,
+                            cts: [],
+                            totalPassed: 0,
+                            totalFailed: 0,
+                            totalSkipped: 0,
+                            totalRunning: 0,
+                            totalDuration: 0
+                        }
+                    }
+                    cnMap[cnName].cts.push(ct)
+                    if (ct.status === 'passed') cnMap[cnName].totalPassed++
+                    if (ct.status === 'failed') cnMap[cnName].totalFailed++
+                    if (ct.status === 'skipped') cnMap[cnName].totalSkipped++
+                    if (ct.status === 'running') cnMap[cnName].totalRunning++
+                    cnMap[cnName].totalDuration += (ct.duration || 0)
+                })
+                
+                // Renderizar CNs
+                const cnHtml = Object.values(cnMap).map((cn, cnIdx) => \`
+                    <div class="bg-slate-800 rounded-lg p-4 border-l-4 \${cn.totalFailed > 0 ? 'border-red-500' : cn.totalPassed === cn.cts.length ? 'border-green-500' : 'border-yellow-500'}">
+                        <div class="flex items-start justify-between mb-3">
+                            <div class="flex-1">
+                                <h4 class="text-lg font-bold text-cyan-400">\${cnIdx + 1}. \${cn.name}</h4>
+                                <div class="flex gap-3 mt-2 text-sm">
+                                    <span class="text-green-400">✅ \${cn.totalPassed} Passed</span>
+                                    <span class="text-red-400">❌ \${cn.totalFailed} Failed</span>
+                                    <span class="text-yellow-400">⚠️ \${cn.totalSkipped} Skipped</span>
+                                    \${cn.totalRunning > 0 ? \`<span class="text-blue-400">🔄 \${cn.totalRunning} Running</span>\` : ''}
+                                    <span class="text-gray-400">⏱️ \${cn.totalDuration}ms total</span>
+                                </div>
+                            </div>
+                            <button onclick="toggleCn('cn-\${cnIdx}')" id="btn-cn-\${cnIdx}" class="btn text-xs" type="button">📋 Ver CTs (\${cn.cts.length})</button>
+                        </div>
+                        <div id="cn-\${cnIdx}" style="display: none;" class="space-y-2 mt-4">
+                            \${cn.cts.map((ct, ctIdx) => \`
+                                <div class="bg-slate-700 rounded p-3">
+                                    <div class="flex items-start justify-between">
+                                        <div class="flex-1">
+                                            <div class="flex items-center gap-2">
+                                                <span class="\${ct.status === 'passed' ? 'text-green-400' : ct.status === 'failed' ? 'text-red-400' : ct.status === 'skipped' ? 'text-yellow-400' : 'text-blue-400'} text-lg">
+                                                    \${ct.status === 'passed' ? '✅' : ct.status === 'failed' ? '❌' : ct.status === 'skipped' ? '⚠️' : '🔄'}
+                                                </span>
+                                                <span class="font-mono text-sm text-yellow-300">\${ct.id || 'CT' + (ctIdx + 1)}</span>
+                                                <span class="text-gray-300">\${ct.name}</span>
+                                            </div>
+                                            <div class="flex items-center gap-3 mt-2 text-xs">
+                                                <span class="\${ct.duration > 5000 ? 'text-red-400' : ct.duration > 2000 ? 'text-yellow-400' : 'text-green-400'}">
+                                                    ⏱️ \${ct.duration || 0}ms
+                                                </span>
+                                                \${ct.statements && ct.statements.length > 0 ? \`<span class="text-cyan-400">📝 \${ct.statements.length} Statements</span>\` : ''}
+                                                \${ct.executedActions && ct.executedActions.length > 0 ? \`<span class="text-purple-400">🎬 \${ct.executedActions.length} Actions</span>\` : ''}
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                            \`).join('')}
+                        </div>
+                    </div>
+                \`).join('')
+                
+                document.getElementById('cn-container').innerHTML = cnHtml
+            } catch (error) {
+                console.error('Erro ao carregar ct-execution-data.json:', error)
+                document.getElementById('cn-container').innerHTML = \`
+                    <div class="bg-red-900/20 border border-red-600 rounded p-4">
+                        <p class="text-red-400">❌ Erro ao carregar dados dos CTs.</p>
+                        <p class="text-gray-400 text-sm mt-2">\${error.message}</p>
+                    </div>
+                \`
+            }
+        }
+        
+        function toggleCn(cnId) {
+            const section = document.getElementById(cnId)
+            const btn = document.getElementById('btn-' + cnId)
+            if (section && btn) {
+                if (section.style.display === 'none') {
+                    section.style.display = 'block'
+                    btn.innerHTML = btn.innerHTML.replace('Ver CTs', 'Ocultar CTs')
+                } else {
+                    section.style.display = 'none'
+                    btn.innerHTML = btn.innerHTML.replace('Ocultar CTs', 'Ver CTs')
+                }
+            }
+        }
+        
+        // Carregar CTs automaticamente ao abrir a página
+        loadCtData()
+
+        // Load saved theme
+        const savedTheme = localStorage.getItem('theme');
+        if (savedTheme === 'light') {
+            document.getElementById('toggle-theme').click()
+        }
+    </script>
+</body>
+</html>`;
+    }
+    /**
+     * 🤖 Detectar tipo de projeto automaticamente
+     */
+    static detectProjectType(data) {
+        const hasAPIs = data.apis && data.apis.length > 0;
+        const hasSSH = data.ssh && data.ssh.length > 0;
+        const hasDB = data.db && data.db.length > 0;
+        const hasUI = data.ui && data.ui.length > 0;
+        const hasMobile = data.mobile && data.mobile.length > 0;
+        const components = [];
+        if (hasAPIs)
+            components.push('API');
+        if (hasSSH)
+            components.push('SSH');
+        if (hasDB)
+            components.push('Banco');
+        if (hasUI)
+            components.push('Frontend');
+        if (hasMobile)
+            components.push('Mobile');
+        if (components.length === 1)
+            return components[0];
+        if (components.length > 1)
+            return 'Mixed';
+        return 'Unknown';
+    }
+    /**
+     * 🔧 Detectar tipo de query SQL
+     */
+    static detectQueryType(query) {
+        const upperQuery = query.trim().toUpperCase();
+        if (upperQuery.startsWith('SELECT'))
+            return 'SELECT';
+        if (upperQuery.startsWith('INSERT'))
+            return 'INSERT';
+        if (upperQuery.startsWith('UPDATE'))
+            return 'UPDATE';
+        if (upperQuery.startsWith('DELETE'))
+            return 'DELETE';
+        if (upperQuery.startsWith('CREATE'))
+            return 'DDL';
+        if (upperQuery.startsWith('DROP'))
+            return 'DDL';
+        if (upperQuery.startsWith('ALTER'))
+            return 'DDL';
+        return 'OTHER';
+    }
+    /**
+     * 🔧 Verificar se há dados para gerar
+     */
+    static hasDataToGenerate(data) {
+        return (data.apis.length > 0 ||
+            data.ssh.length > 0 ||
+            data.db.length > 0 ||
+            data.ui.length > 0 ||
+            data.mobile.length > 0);
+    }
+    /**
+     * 📝 Obter nome do teste atual
+     */
+    static getCurrentTestName() {
+        try {
+            // Definir tipos para as propriedades globais
+            const globalAny = global;
+            // Para Playwright Test Runner
+            if (globalAny.testInfo?.title) {
+                return globalAny.testInfo.title;
+            }
+            // Para Jest/Vitest
+            if (globalAny.expect?.getState) {
+                const state = globalAny.expect.getState();
+                if (state?.currentTestName) {
+                    return state.currentTestName;
+                }
+            }
+            // Para WebDriverIO
+            if (globalAny.browser?.testName) {
+                return globalAny.browser.testName;
+            }
+            // Fallback genérico
+            const stack = new Error('test-name-detection').stack;
+            if (stack) {
+                const testMatch = stack.match(/at.*\/(.*\.(?:test|spec)\.(?:js|ts))/);
+                if (testMatch?.[1]) {
+                    return testMatch[1];
+                }
+            }
+            return 'unknown-test';
+        }
+        catch {
+            return 'unknown-test';
+        }
+    }
+    /**
+     * 📊 Gerar seções agrupadas inteligentemente
+     */
+    static generateGroupedSections(data) {
+        const sections = [];
+        // Agrupar por prioridade e relevância
+        const groupOrder = [
+            {
+                key: 'apis',
+                data: data.apis || [],
+                title: '🌐 APIs & Endpoints',
+                generator: 'generateAPISection',
+            },
+            {
+                key: 'ssh',
+                data: data.ssh || [],
+                title: '🖥️ Comandos SSH',
+                generator: 'generateSSHSection',
+            },
+            {
+                key: 'db',
+                data: data.db || [],
+                title: '🗄️ Consultas Database',
+                generator: 'generateDBSection',
+            },
+            {
+                key: 'ui',
+                data: data.ui || [],
+                title: '🎨 Interface de Usuário',
+                generator: 'generateUISection',
+            },
+            {
+                key: 'mobile',
+                data: data.mobile || [],
+                title: '📱 Ações Mobile',
+                generator: 'generateMobileSection',
+            },
+        ];
+        let hasAnyData = false;
+        const groupedContent = groupOrder
+            .map((group) => {
+            if (group.data.length === 0)
+                return '';
+            hasAnyData = true;
+            // Determinar estatísticas do grupo
+            const successCount = group.data.filter((item) => item.success !== false).length;
+            const successRate = ((successCount / group.data.length) * 100).toFixed(1);
+            // Agrupar por teste se disponível
+            const byTest = group.data.reduce((acc, item) => {
+                const testName = item.testName || 'Teste não identificado';
+                if (!acc[testName])
+                    acc[testName] = [];
+                acc[testName].push(item);
+                return acc;
+            }, {});
+            const testCount = Object.keys(byTest).length;
+            return `
+        <div class="card mb-8" style="border-left: 4px solid ${AutoDocs.getGroupColor(group.key)}">
+          <div class="flex items-center justify-between mb-6">
+            <div>
+              <h2 class="text-2xl font-bold mb-2" style="color: ${AutoDocs.getGroupColor(group.key)}">
+                ${group.title}
+              </h2>
+              <div class="flex items-center gap-4 text-sm text-gray-400">
+                <span>📊 ${group.data.length} itens</span>
+                <span>🧪 ${testCount} teste${testCount > 1 ? 's' : ''}</span>
+                <span class="flex items-center gap-1">
+                  <span class="${successRate === '100.0' ? 'text-green-400' : Number.parseFloat(successRate) >= 80 ? 'text-yellow-400' : 'text-red-400'}">
+                    ${successRate === '100.0' ? '✅' : Number.parseFloat(successRate) >= 80 ? '⚠️' : '❌'} ${successRate}% sucesso
+                  </span>
+                </span>
+              </div>
+            </div>
+            <button onclick="toggleSection('${group.key}')" class="btn text-sm">
+              <span id="btn-${group.key}">📋 Detalhes</span>
+            </button>
+          </div>
+          
+          <!-- Resumo por Teste -->
+          <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4 mb-6">
+            ${Object.entries(byTest)
+                .map(([testName, items]) => {
+                const totalDuration = items.reduce((sum, item) => sum + (item.duration || 0), 0);
+                return `
+              <div class="bg-gray-800 rounded-lg p-4">
+                <h4 class="font-semibold text-blue-400 mb-2 truncate" title="${testName}">
+                  🧪 ${testName}
+                </h4>
+                <div class="text-sm text-gray-300">
+                  <div class="flex justify-between mb-1">
+                    <span>Total:</span>
+                    <span class="font-mono">${items.length}</span>
+                  </div>
+                  <div class="flex justify-between mb-1">
+                    <span>Sucesso:</span>
+                    <span class="font-mono text-green-400">${items.filter((i) => i.success !== false).length}</span>
+                  </div>
+                  <div class="flex justify-between mb-1">
+                    <span>Taxa:</span>
+                    <span class="font-mono ${((items.filter((i) => i.success !== false).length / items.length) * 100) >= 80 ? 'text-green-400' : 'text-yellow-400'}">
+                      ${((items.filter((i) => i.success !== false).length / items.length) * 100).toFixed(1)}%
+                    </span>
+                  </div>
+                  <div class="flex justify-between">
+                    <span>⏱️ Duração:</span>
+                    <span class="font-mono text-blue-400">${(totalDuration / 1000).toFixed(2)}s</span>
+                  </div>
+                </div>
+              </div>
+              `;
+            })
+                .join('')}
+          </div>
+          
+          <!-- Seção detalhada (colapsável) -->
+          <div id="section-${group.key}" style="display: none;">
+            ${AutoDocs[group.generator](group.data)}
+          </div>
+        </div>
+      `;
+        })
+            .filter((section) => section !== '');
+        if (!hasAnyData) {
+            return `
+        <div class="card text-center py-12">
+          <div class="text-6xl mb-4">📄</div>
+          <h2 class="text-2xl font-bold text-gray-400 mb-2">Nenhum dado encontrado</h2>
+          <p class="text-gray-500">Execute alguns testes para ver a documentação automática aparecer aqui!</p>
+        </div>
+      `;
+        }
+        return groupedContent.join('');
+    }
+    /**
+     * 🎨 Obter cor do grupo
+     */
+    static getGroupColor(groupKey) {
+        const colors = {
+            apis: '#10b981', // verde
+            ssh: '#3b82f6', // azul
+            db: '#8b5cf6', // roxo
+            ui: '#f59e0b', // laranja
+            mobile: '#ec4899', // rosa
+        };
+        return colors[groupKey] || '#6b7280';
+    }
+    /**
+     * 📊 Gerar overview do projeto
+     */
+    static generateProjectOverview(projectType, data, detectedCategories) {
+        const typeIcons = {
+            API: '🌐',
+            SSH: '🖥️',
+            Banco: '🗄️',
+            Frontend: '🎨',
+            Mobile: '📱',
+            Mixed: '🔧',
+            Unknown: '❓',
+        };
+        const categoryCount = Object.keys(detectedCategories).length;
+        const apiCategories = Object.entries(detectedCategories)
+            .filter(([key]) => key !== 'outras')
+            .map(([key, data]) => `${data.icon} ${key.charAt(0).toUpperCase() + key.slice(1)}`)
+            .join(', ');
+        return `
+      <div class="card mb-6">
+        <h2 class="text-2xl font-bold text-blue-400 mb-4 flex items-center gap-3">
+          ${typeIcons[projectType] || '🔧'} Project Overview - ${projectType}
+        </h2>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+          <div>
+            <h3 class="text-lg font-semibold text-green-400 mb-3">📋 Componentes Detectados</h3>
+            <div class="space-y-2">
+              ${data.apis.length > 0 ? `<div class="flex items-center gap-2"><span class="text-green-400">✅</span> APIs (${data.apis.length})</div>` : ''}
+              ${data.ssh.length > 0 ? `<div class="flex items-center gap-2"><span class="text-green-400">✅</span> SSH (${data.ssh.length})</div>` : ''}
+              ${data.db.length > 0 ? `<div class="flex items-center gap-2"><span class="text-green-400">✅</span> Banco (${data.db.length})</div>` : ''}
+              ${data.ui.length > 0 ? `<div class="flex items-center gap-2"><span class="text-green-400">✅</span> Frontend (${data.ui.length})</div>` : ''}
+              ${data.mobile.length > 0 ? `<div class="flex items-center gap-2"><span class="text-green-400">✅</span> Mobile (${data.mobile.length})</div>` : ''}
+            </div>
+          </div>
+          ${data.apis.length > 0
+            ? `
+          <div>
+            <h3 class="text-lg font-semibold text-purple-400 mb-3">🤖 Categorias API Detectadas</h3>
+            <p class="text-slate-400 text-sm mb-2">Sistema inteligente detectou ${categoryCount} categorias:</p>
+            <div class="text-sm text-slate-300">
+              ${apiCategories || 'Nenhuma categoria específica detectada'}
+            </div>
+          </div>
+          `
+            : ''}
+        </div>
+      </div>
+    `;
+    }
+    /**
+     * 🧭 Gerar menu de navegação
+     */
+    static generateNavigationMenu(data) {
+        const sections = [];
+        if (data.apis.length > 0)
+            sections.push({ id: 'apis', name: '🌐 APIs', count: data.apis.length });
+        if (data.ssh.length > 0)
+            sections.push({ id: 'ssh', name: '🖥️ SSH', count: data.ssh.length });
+        if (data.db.length > 0)
+            sections.push({ id: 'database', name: '🗄️ Banco', count: data.db.length });
+        if (data.ui.length > 0)
+            sections.push({
+                id: 'frontend',
+                name: '🎨 Frontend',
+                count: data.ui.length,
+            });
+        if (data.mobile.length > 0)
+            sections.push({
+                id: 'mobile',
+                name: '📱 Mobile',
+                count: data.mobile.length,
+            });
+        if (sections.length === 0)
+            return '';
+        return `
+      <div class="card mb-6">
+        <h3 class="text-lg font-semibold text-yellow-400 mb-4">🧭 Navegação Rápida</h3>
+        <div class="flex flex-wrap gap-3">
+          ${sections
+            .map((section) => `
+            <button onclick="jumpToSection('${section.id}')" class="btn bg-slate-700 hover:bg-slate-600">
+              ${section.name} (${section.count})
+            </button>
+          `)
+            .join('')}
+        </div>
+      </div>
+    `;
+    }
+    /**
+     * 📊 Gerar estatísticas gerais
+     */
+    static generateOverallStats(data) {
+        const totalItems = data.apis.length +
+            data.ssh.length +
+            data.db.length +
+            data.ui.length +
+            data.mobile.length;
+        const successfulAPIs = data.apis.filter((api) => api.success).length;
+        const failedAPIs = data.apis.length - successfulAPIs;
+        const successRate = data.apis.length > 0
+            ? Math.round((successfulAPIs / data.apis.length) * 100)
+            : 0;
+        return `
+      <div class="card mb-8">
+        <h3 class="text-2xl font-bold text-green-400 mb-6">📊 Estatísticas Gerais do Projeto</h3>
+        <div class="grid grid-cols-1 md:grid-cols-4 gap-4">
+          <div class="bg-blue-800 rounded-lg p-4 text-center">
+            <div class="text-3xl font-bold text-white">${totalItems}</div>
+            <div class="text-blue-200 text-sm">Total de Testes</div>
+          </div>
+          <div class="bg-green-800 rounded-lg p-4 text-center">
+            <div class="text-3xl font-bold text-white">${successfulAPIs}</div>
+            <div class="text-green-200 text-sm">APIs Sucesso</div>
+          </div>
+          <div class="bg-red-800 rounded-lg p-4 text-center">
+            <div class="text-3xl font-bold text-white">${failedAPIs}</div>
+            <div class="text-red-200 text-sm">APIs Falha</div>
+          </div>
+          <div class="bg-purple-800 rounded-lg p-4 text-center">
+            <div class="text-3xl font-bold text-white">${successRate}%</div>
+            <div class="text-purple-200 text-sm">Taxa de Sucesso</div>
+          </div>
+        </div>
+      </div>
+    `;
+    }
+    /**
+          <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-5 gap-6 mb-8">
+              <div class="card bg-gradient-to-br from-green-600 to-green-700">
+                  <h3 class="text-3xl font-bold text-white">${data.apis.length}</h3>
+                  <p class="text-green-100">🌐 APIs Documentadas</p>
+              </div>
+              <div class="card bg-gradient-to-br from-blue-600 to-blue-700">
+                  <h3 class="text-3xl font-bold text-white">${data.ssh.length}</h3>
+                  <p class="text-blue-100">🖥️ Comandos SSH</p>
+              </div>
+              <div class="card bg-gradient-to-br from-purple-600 to-purple-700">
+                  <h3 class="text-3xl font-bold text-white">${data.db.length}</h3>
+                  <p class="text-purple-100">🗄️ Queries Database</p>
+              </div>
+              <div class="card bg-gradient-to-br from-orange-600 to-orange-700">
+                  <h3 class="text-3xl font-bold text-white">${data.ui.length}</h3>
+                  <p class="text-orange-100">🎨 Ações UI</p>
+              </div>
+              <div class="card bg-gradient-to-br from-pink-600 to-pink-700">
+                  <h3 class="text-3xl font-bold text-white">${data.mobile.length}</h3>
+                  <p class="text-pink-100">📱 Ações Mobile</p>
+              </div>
+          </div>
+  
+          ${AutoDocs.generateAPISection(data.apis)}
+          ${AutoDocs.generateSSHSection(data.ssh)}
+          ${AutoDocs.generateDBSection(data.db)}
+          ${AutoDocs.generateUISection(data.ui)}
+          ${AutoDocs.generateMobileSection(data.mobile)}
+  
+          <!-- Footer -->
+          <div class="footer-bar">
+              <p>Documentação gerada automaticamente pelo AutoDocs (${projectVersion}) em ${new Date().toLocaleString('pt-BR')}</p>
+          </div>
+      </div>
+  
+      <script>
+          function toggleTheme() {
+              document.body.classList.toggle('light-mode');
+              localStorage.setItem('theme', document.body.classList.contains('light-mode') ? 'light' : 'dark');
+          }
+  
+          function exportData(format) {
+              const data = ${JSON.stringify(data)};
+              
+              if (format === 'pdf') {
+                  const element = document.querySelector('.container');
+                  
+                  html2canvas(element, {
+                      scale: 2,
+                      useCORS: false,
+                      allowTaint: true,
+                      backgroundColor: '#fff'
+                  }).then(canvas => {
+                      const { jsPDF } = jspdf;
+                      const pdf = new jsPDF({
+                          orientation: 'portrait',
+                          unit: 'in',
+                          format: 'letter'
+                      });
+                      
+                      const imgData = canvas.toDataURL('image/jpeg', 0.98);
+                      const imgWidth = 8.5;
+                      const pageHeight = 11;
+                      const imgHeight = (canvas.height * imgWidth) / canvas.width;
+                      let heightLeft = imgHeight;
+                      let position = 0;
+                      
+                      pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight);
+                      heightLeft -= pageHeight;
+                      
+                      while (heightLeft > 0) {
+                          position = heightLeft - imgHeight;
+                          pdf.addPage();
+                          pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight);
+                          heightLeft -= pageHeight;
+                      }
+                      
+                      pdf.save('${AutoDocs.config.projectName}_autodocs.pdf');
+                  });
+              } else if (format === 'json') {
+                  const dataStr = JSON.stringify(data, null, 2);
+                  const dataBlob = new Blob([dataStr], {type: 'application/json'});
+                  const url = URL.createObjectURL(dataBlob);
+                  const link = document.createElement('a');
+                  link.href = url;
+                  link.download = '${AutoDocs.config.projectName}_autodocs.json';
+                  link.click();
+              }
+          }
+  
+          // Load saved theme
+          const savedTheme = localStorage.getItem('theme');
+          if (savedTheme === 'light') {
+              document.body.classList.add('light-mode');
+          }
+      </script>
+  </body>
+  </html>`
+    }
+  
+    /**
+     * 📊 Gerar visualização por CTs (Cenários de Teste)
+     * CORRIGIDO: Usar a mesma estratégia do UnifiedReportManager
+     */
+    static async generateCTViewHTMLContent(data) {
+        // 🔧 CORREÇÃO: Usar a mesma abordagem do UnifiedReportManager
+        Logger.info('📊 HubDocs: Coletando dados dos CTs...');
+        // Busca direta do StatementTracker (mesma estratégia do UnifiedReportManager)
+        const allExecutions = StatementTracker.getExecutions();
+        const totalTests = Array.from(allExecutions.values()).length;
+        Logger.info(`📊 HubDocs: Total de testes encontrados: ${totalTests}`);
+        let totalCTs = 0;
+        let passedCTs = 0;
+        let failedCTs = 0;
+        let skippedCTs = 0;
+        let runningCTs = 0;
+        const ctsByTest = new Map();
+        if (totalTests > 0) {
+            Logger.success('✅ HubDocs: Processando testes e seus CTs...');
+            // ✅ CORREÇÃO: Cada execution tem um array de CTs dentro
+            Array.from(allExecutions.values()).forEach((testExecution) => {
+                const testName = testExecution.testName || 'Teste Geral';
+                const cts = testExecution.cts || [];
+                Logger.info(`📋 HubDocs: Teste "${testName}" tem ${cts.length} CTs`);
+                if (!ctsByTest.has(testName)) {
+                    ctsByTest.set(testName, []);
+                }
+                // Processar cada CT do teste
+                cts.forEach((ct, ctIndex) => {
+                    const ctData = {
+                        ctId: `CT${(totalCTs + 1).toString().padStart(3, '0')}`,
+                        ctName: ct.name || ct.ctName || 'Unknown CT',
+                        ctOrder: ctIndex + 1,
+                        status: ct.status,
+                        duration: ct.duration || 0,
+                        timestamp: ct.startTime
+                            ? new Date(ct.startTime).toISOString()
+                            : new Date().toISOString(),
+                        error: ct.error,
+                        className: ct.name?.split('.')[0] || 'Unknown',
+                        methodName: ct.name?.split('.')[1] || ct.name || 'unknown',
+                        statements: ct.statements || [], // ✅ NOVO: Incluir Statements
+                        executedActions: ct.executedActions || [], // ✅ NOVO: Incluir Actions do CT
+                        logs: ct.logs || [], // ✅ NOVO: Incluir Logs do CT
+                    };
+                    ctsByTest.get(testName).push(ctData);
+                    totalCTs++;
+                    // ✅ CORRIGIDO: Tratar "running" como "failed" para contadores
+                    const finalStatus = ct.status === 'running' ? 'failed' : ct.status;
+                    switch (finalStatus) {
+                        case 'passed':
+                            passedCTs++;
+                            break;
+                        case 'failed':
+                            failedCTs++;
+                            break;
+                        case 'skipped':
+                            skippedCTs++;
+                            break;
+                    }
+                });
+            });
+            Logger.success(`✅ HubDocs CTs: Total=${totalCTs}, Passou=${passedCTs}, Falhou=${failedCTs}, Skipped=${skippedCTs}`);
+        }
+        else {
+            Logger.warning('⚠️ HubDocs: Nenhum teste encontrado no StatementTracker');
+        }
+        const timestamp = new Date().toLocaleString('pt-BR');
+        return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>📋 ${AutoDocs.config.projectName} - Visualização por CTs</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        body { font-family: 'Inter', sans-serif; background-color: #0f172a; color: #f1f5f9; min-height: 100vh; }
+        .light-mode { background-color: #f9fafb !important; color: #111827 !important; }
+        .card { background: #1e293b; border-radius: 1rem; padding: 1.5rem; box-shadow: 0 2px 8px #0002; color: #f1f5f9; }
+        .light-mode .card { background: #fff; color: #111827; border: 1px solid #e5e7eb; }
+        .btn { background: #334155; color: #fff; border: none; border-radius: 8px; padding: 0.5rem 1.2rem; font-weight: 600; cursor: pointer; margin: 0.25rem; transition: background 0.2s; }
+        .btn:hover { background: #475569; }
+        .light-mode .btn { background: #374151; color: #fff; }
+        .status-pass { color: #22c55e; font-weight: 700; }
+        .status-fail { color: #ef4444; font-weight: 700; }
+        .status-skip { color: #fbbf24; font-weight: 700; }
+        .status-running { color: #8b5cf6; font-weight: 700; }
+        .ct-card { background: #1e293b; border-radius: 0.5rem; padding: 1rem; margin: 0.5rem 0; border-left: 4px solid #3b82f6; }
+        .ct-card.passed { border-left-color: #22c55e; }
+        .ct-card.failed { border-left-color: #ef4444; }
+        .ct-card.skipped { border-left-color: #fbbf24; }
+        .ct-card.running { border-left-color: #8b5cf6; }
+        .light-mode .ct-card { background: #f8fafc; color: #111827; }
+        .test-section { background: #0f172a; border-radius: 1rem; padding: 1.5rem; margin: 1rem 0; border: 1px solid #374151; }
+        .light-mode .test-section { background: #ffffff; border-color: #e5e7eb; color: #111827; }
+        .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; }
+        .light-mode .header-bar { background: #f3f4f6; border: 1px solid #e5e7eb; }
+        .light-mode .header-title { color: #d97706; }
+        .btn-sm { padding: 0.25rem 0.75rem; font-size: 0.75rem; }
+        .bg-blue-600 { background-color: #2563eb; }
+        .bg-blue-600:hover { background-color: #1d4ed8; }
+        .hidden { display: none; }
+        .overflow-x-auto { overflow-x: auto; }
+        .break-all { word-break: break-all; }
+        .whitespace-pre-wrap { white-space: pre-wrap; }
+    </style>
+</head>
+<body id="body-root">
+    <div class="header-bar">
+        <div class="header-title">📋 Visualização por CTs</div>
+        <div class="flex gap-2">
+            <button onclick="window.location.href='index.html'" class="btn">📚 Visão Tradicional</button>
+            <button id="toggle-theme" class="btn">🌙 Tema</button>
+        </div>
+    </div>
+
+    <div class="max-w-7xl mx-auto p-6">
+        <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">${totalCTs}</span>
+                <span class="text-slate-400">Total CTs</span>
+            </div>
+            <div class="card flex flex-col items-center">
+                <span class="text-2xl font-bold text-green-400">${passedCTs}</span>
+                <span class="text-green-400">Passou</span>
+            </div>
+            <div class="card flex flex-col items-center">
+                <span class="text-2xl font-bold text-red-400">${failedCTs}</span>
+                <span class="text-red-400">Falhou</span>
+            </div>
+            <div class="card flex flex-col items-center">
+                <span class="text-2xl font-bold text-yellow-400">${skippedCTs}</span>
+                <span class="text-yellow-400">Pulado</span>
+            </div>
+        </div>
+
+        ${Array.from(ctsByTest.entries())
+            .map(([testName, ctList]) => `
+            <div class="test-section">
+                <h2 class="text-2xl font-bold mb-4 text-blue-400">
+                    🧪 ${testName}
+                    <span class="text-sm font-normal text-gray-400">
+                        (${ctList.filter((ct) => ct.status === 'passed').length}/${ctList.length} CTs - ${(ctList.reduce((sum, ct) => sum + (ct.duration || 0), 0) / 1000).toFixed(2)}s)
+                    </span>
+                </h2>
+                
+                <div class="grid grid-cols-1 gap-3">
+                    ${ctList
+            .map((ct, index) => `
+                        <div class="ct-card ${ct.status}">
+                            <div class="flex justify-between items-start">
+                                <div class="flex-1">
+                                    <div class="font-mono text-sm text-blue-300">CT #${ct.ctOrder || index + 1}</div>
+                                    <div class="font-semibold text-lg mb-2">${AutoDocs.extractCleanCTName(ct.ctName)}</div>
+                                    <div class="text-sm text-gray-300">
+                                        <span class="mr-4">📦 ${ct.className}</span>
+                                        <span>⏱️ ${((ct.duration || 0) / 1000).toFixed(2)}s</span>
+                                    </div>
+                                    
+                                    ${ct.statements && ct.statements.length > 0
+            ? `
+                                        <div class="mt-3 p-3 bg-slate-800 rounded">
+                                            <div class="font-semibold text-sm mb-2 text-blue-300">📝 Statements (${ct.statements.length}):</div>
+                                            ${ct.statements
+                .map((stmt, stmtIdx) => `
+                                                <div class="ml-4 text-xs text-slate-300 py-1 border-l-2 border-slate-600 pl-2">
+                                                    ${stmtIdx + 1}. ${stmt.className || ''}.${stmt.methodName || stmt.name || 'unknown'}
+                                                    <span class="ml-2 ${stmt.status === 'passed' ? 'text-green-400' : stmt.status === 'failed' ? 'text-red-400' : 'text-yellow-400'}">
+                                                        (${stmt.status === 'passed' ? '✅' : stmt.status === 'failed' ? '❌' : '⏳'} ${stmt.duration ? stmt.duration + 'ms' : '0ms'})
+                                                    </span>
+                                                    ${stmt.error ? `<div class="text-red-400 text-xs mt-1">❌ ${AutoDocs.escapeHtml(stmt.error)}</div>` : ''}
+                                                </div>
+                                            `)
+                .join('')}
+                                        </div>
+                                    `
+            : ''}
+                                    
+                                    ${ct.executedActions &&
+            ct.executedActions.length > 0
+            ? `
+                                        <div class="mt-3 p-3 bg-slate-800 rounded">
+                                            <div class="font-semibold text-sm mb-2 text-purple-300">🎬 Actions (${ct.executedActions.length}):</div>
+                                            ${ct.executedActions
+                .map((action, actIdx) => `
+                                                <div class="ml-4 text-xs text-slate-300 py-1">
+                                                    ${actIdx + 1}. [${action.type}] ${action.description}
+                                                    <span class="ml-2 ${action.success ? 'text-green-400' : 'text-red-400'}">
+                                                        (${action.success ? '✅' : '❌'} ${action.duration ? action.duration + 'ms' : ''})
+                                                    </span>
+                                                </div>
+                                            `)
+                .join('')}
+                                        </div>
+                                    `
+            : ''}
+                                    
+                                    ${ct.logs && ct.logs.length > 0
+            ? `
+                                        <div class="mt-3 p-3 bg-slate-800 rounded">
+                                            <div class="flex justify-between items-center mb-2">
+                                                <div class="font-semibold text-sm text-cyan-300">📋 Logs (${ct.logs.length}):</div>
+                                                <button 
+                                                    onclick="toggleLogs('logs-${testName.replace(/[^a-zA-Z0-9]/g, '')}-${index}')" 
+                                                    id="btn-logs-${testName.replace(/[^a-zA-Z0-9]/g, '')}-${index}"
+                                                    class="btn btn-sm bg-slate-600 hover:bg-slate-700 text-xs"
+                                                >
+                                                    👁️ Ver Logs
+                                                </button>
+                                            </div>
+                                            <div id="logs-${testName.replace(/[^a-zA-Z0-9]/g, '')}-${index}" class="hidden max-h-96 overflow-y-auto">
+                                                ${ct.logs
+                .map((log, logIdx) => `
+                                                    <div class="text-xs text-slate-300 py-1 font-mono border-l-2 border-slate-600 pl-2 hover:bg-slate-700">
+                                                        <span class="text-slate-500">${logIdx + 1}.</span> ${AutoDocs.escapeHtml(log.replace('[LOG] ', ''))}
+                                                    </div>
+                                                `)
+                .join('')}
+                                            </div>
+                                        </div>
+                                    `
+            : ''}
+                                    
+                                    ${ct.ctName && ct.ctName.length > 50
+            ? `
+                                        <div class="mt-3">
+                                            <button 
+                                                onclick="toggleCTDetails('ct-details-${testName.replace(/[^a-zA-Z0-9]/g, '')}-${index}')" 
+                                                class="btn btn-sm bg-blue-600 hover:bg-blue-700 text-xs"
+                                            >
+                                                📋 Ver Detalhes
+                                            </button>
+                                            <div id="ct-details-${testName.replace(/[^a-zA-Z0-9]/g, '')}-${index}" class="hidden mt-3 p-3 bg-slate-800 rounded border-l-4 border-blue-500">
+                                                <div class="text-sm text-slate-300">
+                                                    <strong>🔍 Detalhes Completos:</strong>
+                                                    <pre class="mt-2 text-xs whitespace-pre-wrap break-all overflow-x-auto bg-slate-900 p-2 rounded">${AutoDocs.escapeHtml(ct.ctName)}</pre>
+                                                </div>
+                                            </div>
+                                        </div>
+                                    `
+            : ''}
+                                </div>
+                                <div class="text-right">
+                                    <div class="
+                                        ${ct.status === 'passed'
+            ? 'status-pass'
+            : ct.status === 'failed'
+                ? 'status-fail'
+                : ct.status === 'skipped'
+                    ? 'status-skip'
+                    : 'status-running'}
+                                    ">
+                                        ${ct.status === 'passed'
+            ? '✅ PASS'
+            : ct.status === 'failed'
+                ? '❌ FAIL'
+                : ct.status === 'skipped'
+                    ? '⏭️ SKIP'
+                    : '🔄 RUNNING'}
+                                    </div>
+                                </div>
+                            </div>
+                            ${ct.error
+            ? `
+                                <div class="mt-3 p-3 bg-red-900 bg-opacity-50 rounded border-l-4 border-red-500">
+                                    <div class="text-red-300 text-sm">
+                                        <strong>❌ Erro:</strong> ${AutoDocs.escapeHtml(ct.error)}
+                                    </div>
+                                </div>
+                            `
+            : ''}
+                        </div>
+                    `)
+            .join('')}
+                </div>
+            </div>
+        `)
+            .join('')}
+
+        ${totalCTs === 0
+            ? `
+            <div class="card text-center">
+                <h3 class="text-xl font-bold mb-4">📋 Nenhum CT Encontrado</h3>
+                <p class="text-gray-400 mb-4">Execute seus testes com statements para ver os CTs aqui.</p>
+                <p class="text-sm text-gray-500">
+                    Os CTs são capturados automaticamente quando você usa:
+                    <code class="bg-gray-800 px-2 py-1 rounded">await new StatementXXX().method()</code>
+                </p>
+            </div>
+        `
+            : ''}
+    </div>
+
+    <div class="bg-slate-800 text-amber-400 p-4 text-center mt-8">
+        Desenvolvido por <strong>Test HUB</strong> | Visualização por CTs gerada em ${timestamp}
+    </div>
+
+    <script>
+        document.getElementById('toggle-theme').onclick = () => {
+            document.getElementById('body-root').classList.toggle('light-mode')
+            document.querySelector('.header-bar').classList.toggle('light-mode')
+            document.querySelectorAll('.card').forEach(el => el.classList.toggle('light-mode'))
+            document.querySelectorAll('.ct-card').forEach(el => el.classList.toggle('light-mode'))
+            document.querySelectorAll('.test-section').forEach(el => el.classList.toggle('light-mode'))
+        }
+
+        // Função para expandir/recolher detalhes do CT
+        function toggleCTDetails(elementId) {
+            const element = document.getElementById(elementId)
+            const button = element?.previousElementSibling
+            
+            if (element) {
+                if (element.classList.contains('hidden')) {
+                    element.classList.remove('hidden')
+                    if (button) button.textContent = '📋 Ocultar Detalhes'
+                } else {
+                    element.classList.add('hidden')
+                    if (button) button.textContent = '📋 Ver Detalhes'
+                }
+            }
+        }
+
+        // ✅ NOVO: Função para expandir/recolher logs do CT
+        function toggleLogs(elementId) {
+            const element = document.getElementById(elementId)
+            const button = document.getElementById('btn-' + elementId)
+            
+            if (element && button) {
+                if (element.classList.contains('hidden')) {
+                    element.classList.remove('hidden')
+                    button.textContent = '👁️ Ocultar Logs'
+                } else {
+                    element.classList.add('hidden')
+                    button.textContent = '👁️ Ver Logs'
+                }
+            }
+        }
+    </script>
+</body>
+</html>`;
+    }
+    /**
+     * �🎨 Gerar conteúdo HTML vazio
+     */
+    static generateEmptyHTMLContent() {
+        const timestamp = new Date().toISOString();
+        return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>📚 ${AutoDocs.config.projectName} - Documentação AutoDocs</title>
+    <style>
+        body { font-family: 'Inter', sans-serif; background-color: #0f172a; color: #f1f5f9; min-height: 100vh; }
+        .light-mode { background-color: #f9fafb !important; color: #111827 !important; }
+        .card { background: #1e293b; border-radius: 1rem; padding: 1.5rem; box-shadow: 0 2px 8px #0002; color: #f1f5f9; }
+        .light-mode .card { background: #fff; color: #111827; border: 1px solid #e5e7eb; }
+        .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: #374151; color: #fff; border: 1px solid #d1d5db; }
+        .light-mode .btn:hover { background: #4b5563; }
+        .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: #f3f4f6; color: #111827; border: 1px solid #e5e7eb; }
+        .light-mode .header-title { color: #d97706; }
+        .light-mode .header-meta { color: #374151 !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: #f3f4f6; color: #d97706; border: 1px solid #e5e7eb; }
+    </style>
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="min-h-screen bg-slate-900 text-slate-100">
+    <div class="container mx-auto px-4 py-8 max-w-7xl">
+        <!-- Header -->
+        <div class="header-bar">
+            <div>
+                <h1 class="header-title">📚 ${AutoDocs.config.projectName}</h1>
+            </div>
+            <div class="flex gap-2">
+                <button onclick="toggleTheme()" class="btn">🌙/☀️ Tema</button>
+            </div>
+        </div>
+
+        <!-- Empty State -->
+        <div class="text-center py-16">
+            <div class="card max-w-2xl mx-auto">
+                <h2 class="text-3xl font-bold text-green-400 mb-6">🚀 Sistema AutoDocs Ativo</h2>
+                <p class="text-slate-300 mb-8">O sistema de documentação automática está funcionando corretamente!</p>
+                
+                <div class="bg-slate-700 p-6 rounded-lg border-l-4 border-green-400 mb-8">
+                    <h3 class="text-xl font-bold text-green-400 mb-4">📊 Como funciona</h3>
+                    <p class="text-slate-300 mb-4">O AutoDocs detecta automaticamente e documenta:</p>
+                    <ul class="text-left space-y-2 text-slate-300">
+                        <li class="flex items-center gap-2"><span class="text-green-400">🌐</span> Chamadas de API</li>
+                        <li class="flex items-center gap-2"><span class="text-cyan-400">🖥️</span> Comandos SSH</li>
+                        <li class="flex items-center gap-2"><span class="text-purple-400">🗄️</span> Queries de banco de dados</li>
+                        <li class="flex items-center gap-2"><span class="text-indigo-400">🎨</span> Ações de interface (UI)</li>
+                        <li class="flex items-center gap-2"><span class="text-pink-400">📱</span> Interações mobile</li>
+                    </ul>
+                </div>
+
+                <div class="bg-gradient-to-r from-green-600 to-blue-600 p-6 rounded-lg text-white">
+                    <p class="text-lg font-semibold">Execute seus testes para ver a documentação sendo gerada automaticamente!</p>
+                </div>
+            </div>
+        </div>
+
+        <!-- Footer -->
+        <div class="footer-bar">
+            <p>Documentação gerada automaticamente pelo AutoDocs (${AutoDocs.getProjectVersion()}) em ${new Date(timestamp).toLocaleString('pt-BR')}</p>
+        </div>
+    </div>
+
+    <script>
+        function toggleTheme() {
+            document.body.classList.toggle('light-mode');
+            localStorage.setItem('theme', document.body.classList.contains('light-mode') ? 'light' : 'dark');
+        }
+
+        // Load saved theme
+        const savedTheme = localStorage.getItem('theme');
+        if (savedTheme === 'light') {
+            document.body.classList.add('light-mode');
+        }
+    </script>
+</body>
+</html>`;
+    }
+    /**
+     * 🌐 Gerar seção de APIs com detalhes completos
+     */
+    static generateAPISection(apis) {
+        if (apis.length === 0) {
+            return '';
+        }
+        // 🤖 Detectar categorias automaticamente baseado nos endpoints executados
+        const detectedCategories = AutoDocs.detectProjectCategories(apis);
+        // Categorizar APIs usando detecção inteligente
+        const categorizedApis = apis.reduce((acc, api) => {
+            const category = AutoDocs.categorizeEndpointDynamic(api.url, detectedCategories);
+            if (!acc[category]) {
+                acc[category] = [];
+            }
+            acc[category].push(api);
+            return acc;
+        }, {});
+        // Gerar seções categorizadas
+        const categorySections = Object.entries(categorizedApis)
+            .map(([category, categoryApis]) => {
+            const categoryKey = category.toLowerCase();
+            const config = detectedCategories[categoryKey] || detectedCategories['outras'];
+            const apiItems = categoryApis
+                .map((api) => {
+                const statusIcon = api.success ? '✅' : '❌';
+                const durationColor = api.duration > 5000 ? 'text-orange-400' : 'text-green-400';
+                return `
+          <div class="card bg-slate-800 hover:bg-slate-700 transition-all duration-200 transform hover:-translate-y-1">
+            <div class="flex flex-wrap items-center justify-between mb-4">
+              <div class="flex items-center gap-3">
+                <span class="method-badge method-${api.method.toLowerCase()}">${api.method}</span>
+                <span class="font-mono text-blue-300 font-semibold break-all">${api.url}</span>
+              </div>
+              <span class="status-badge ${api.success ? 'bg-green-600' : 'bg-red-600'} text-white px-3 py-1 rounded-full text-sm">
+                ${statusIcon} ${api.statusCode}
+              </span>
+            </div>
+            
+            <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-4 text-sm">
+              <div class="flex items-center gap-2 text-slate-300">
+                <span>📝</span>
+                <span>Teste: <span class="text-yellow-400">${api.testName}</span></span>
+              </div>
+              <div class="flex items-center gap-2 text-slate-300">
+                <span>🌍</span>
+                <span>Ambiente: <span class="text-blue-400">${api.environment}</span></span>
+              </div>
+              <div class="flex items-center gap-2 text-slate-300">
+                <span>⏱️</span>
+                <span>Duração: <span class="${durationColor}">${api.duration}ms</span></span>
+              </div>
+            </div>
+
+            ${api.headers && Object.keys(api.headers).length > 0
+                    ? `
+            <details class="mb-4">
+              <summary class="cursor-pointer font-semibold text-purple-400 hover:text-purple-300 transition-colors">
+                📤 Headers da Requisição
+              </summary>
+              <pre class="bg-slate-900 text-purple-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${JSON.stringify(api.headers, null, 2)}</pre>
+            </details>
+            `
+                    : ''}
+
+            ${api.payload
+                    ? `
+            <details class="mb-4">
+              <summary class="cursor-pointer font-semibold text-green-400 hover:text-green-300 transition-colors">
+                📋 Payload da Requisição (Exemplo Real)
+              </summary>
+              <pre class="bg-slate-900 text-green-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${JSON.stringify(api.payload, null, 2)}</pre>
+            </details>
+            `
+                    : ''}
+
+            ${api.response
+                    ? `
+            <details class="mb-4">
+              <summary class="cursor-pointer font-semibold text-blue-400 hover:text-blue-300 transition-colors">
+                📥 Resposta da API (Exemplo Real)
+              </summary>
+              <pre class="bg-slate-900 text-blue-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${JSON.stringify(api.response, null, 2)}</pre>
+            </details>
+            `
+                    : ''}
+
+            ${api.error
+                    ? `
+            <details class="mb-4">
+              <summary class="cursor-pointer font-semibold text-red-400 hover:text-red-300 transition-colors">
+                ❌ Erro
+              </summary>
+              <div class="bg-red-900 border border-red-700 text-red-300 p-4 rounded-lg mt-2">
+                <pre class="text-sm font-mono overflow-x-auto">${api.error}</pre>
+              </div>
+            </details>
+            `
+                    : ''}
+
+            <div class="text-xs text-slate-400 mt-4 pt-4 border-t border-slate-700">
+              🕐 ${new Date(api.timestamp).toLocaleString('pt-BR')}
+            </div>
+          </div>
+        `;
+            })
+                .join('');
+            const successCount = categoryApis.filter((api) => api.success).length;
+            const failureCount = categoryApis.length - successCount;
+            return `
+        <div class="mb-8 category-section">
+          <h3 class="text-xl font-bold text-blue-400 mb-4 flex items-center gap-3 border-l-4 border-blue-400 pl-4">
+            ${config.icon} ${category} (${categoryApis.length} APIs)
+          </h3>
+          <p class="text-slate-400 mb-4 italic">${config.description}</p>
+          <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
+            <div class="bg-green-800 rounded-lg p-3">
+              <div class="text-green-200 text-sm">✅ Sucessos</div>
+              <div class="text-lg font-bold text-white">${successCount}</div>
+            </div>
+            <div class="bg-red-800 rounded-lg p-3">
+              <div class="text-red-200 text-sm">❌ Falhas</div>
+              <div class="text-lg font-bold text-white">${failureCount}</div>
+            </div>
+          </div>
+          <div class="space-y-4">
+            ${apiItems}
+          </div>
+        </div>
+      `;
+        })
+            .join('');
+        const totalSuccessCount = apis.filter((api) => api.success).length;
+        const totalFailureCount = apis.length - totalSuccessCount;
+        const avgDuration = apis.reduce((sum, api) => sum + (api.duration || 0), 0) / apis.length;
+        // Gerar overview das categorias detectadas
+        const categoryOverview = Object.entries(detectedCategories)
+            .filter(([key]) => key !== 'outras')
+            .map(([key, data]) => `<span class="inline-block bg-slate-700 px-3 py-1 rounded-full text-sm text-slate-300 mr-2 mb-2">${data.icon} ${key.charAt(0).toUpperCase() + key.slice(1)}</span>`)
+            .join('');
+        return `
+      <div class="mb-8">
+        <h2 class="text-3xl font-bold text-green-400 mb-6 flex items-center gap-3 border-l-4 border-green-400 pl-4">
+          🌐 APIs Documentadas - Detecção Inteligente (${apis.length} total)
+        </h2>
+        
+        <div class="bg-slate-800 rounded-lg p-4 mb-6">
+          <h4 class="text-lg font-semibold text-blue-400 mb-3">🤖 Categorias Detectadas Automaticamente:</h4>
+          <div class="flex flex-wrap">
+            ${categoryOverview}
+          </div>
+        </div>
+        
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-8">
+          <div class="bg-green-800 rounded-lg p-4">
+            <div class="text-green-200 text-sm">✅ Total Sucessos</div>
+            <div class="text-3xl font-bold text-white">${totalSuccessCount}</div>
+          </div>
+          <div class="bg-red-800 rounded-lg p-4">
+            <div class="text-red-200 text-sm">❌ Total Falhas</div>
+            <div class="text-3xl font-bold text-white">${totalFailureCount}</div>
+          </div>
+          <div class="bg-blue-800 rounded-lg p-4">
+            <div class="text-blue-200 text-sm">⏱️ Tempo Médio</div>
+            <div class="text-3xl font-bold text-white">${Math.round(avgDuration)}ms</div>
+          </div>
+        </div>
+        
+        ${categorySections}
+      </div>
+    `;
+    }
+    /**
+     * 🖥️ Gerar seção SSH com detalhes completos
+     */
+    static generateSSHSection(sshCommands) {
+        if (sshCommands.length === 0) {
+            return '';
+        }
+        // 🚫 Filtrar comandos técnicos que não são verdadeiros CTs
+        const filteredSSHCommands = sshCommands.filter((ssh) => {
+            const command = ssh.command?.toLowerCase() || '';
+            // Filtrar comandos técnicos (read, write, connect, etc.)
+            const technicalCommands = [
+                'read:',
+                'write:',
+                'connect:',
+                'disconnect:',
+                'execute:',
+                'setup:',
+                'init:',
+                'cleanup:',
+            ];
+            return !technicalCommands.some((tech) => command.startsWith(tech));
+        });
+        if (filteredSSHCommands.length === 0) {
+            return '';
+        }
+        const sshItems = filteredSSHCommands
+            .map((ssh) => {
+            // ✅ CORRIGIR: Tratar success undefined como sucesso (se não tem error)
+            const isSuccess = ssh.success !== false && !ssh.error;
+            const statusIcon = isSuccess ? '✅' : '❌';
+            const durationColor = (ssh.duration || 0) > 3000 ? 'text-orange-400' : 'text-green-400';
+            return `
+        <div class="card bg-slate-800 hover:bg-slate-700 transition-all duration-200 transform hover:-translate-y-1">
+          <div class="flex flex-wrap items-center justify-between mb-4">
+            <div class="flex items-center gap-3">
+              <span class="bg-cyan-600 text-white px-3 py-1 rounded-full text-sm font-bold">SSH</span>
+              <span class="font-mono text-cyan-300 font-semibold break-all">🖥️ ${ssh.command}</span>
+            </div>
+            <span class="status-badge ${isSuccess ? 'bg-green-600' : 'bg-red-600'} text-white px-3 py-1 rounded-full text-sm">
+              ${statusIcon} ${isSuccess ? 'Sucesso' : 'Erro'}
+            </span>
+          </div>
+          
+          <div class="grid grid-cols-1 md:grid-cols-4 gap-4 mb-4 text-sm">
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>🖥️</span>
+              <span>Host: <span class="text-cyan-400">${ssh.host}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>👤</span>
+              <span>Usuário: <span class="text-blue-400">${ssh.user}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>📝</span>
+              <span>Teste: <span class="text-yellow-400">${ssh.testName}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>⏱️</span>
+              <span>Duração: <span class="${durationColor}">${ssh.duration || 0}ms</span></span>
+            </div>
+          </div>
+
+          ${ssh.output
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-green-400 hover:text-green-300 transition-colors">
+              📤 Output do Comando
+            </summary>
+            <pre class="bg-slate-900 text-green-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${ssh.output}</pre>
+          </details>
+          `
+                : ''}
+
+          ${ssh.error
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-red-400 hover:text-red-300 transition-colors">
+              ❌ Erro
+            </summary>
+            <div class="bg-red-900 border border-red-700 text-red-300 p-4 rounded-lg mt-2">
+              <pre class="text-sm font-mono overflow-x-auto">${ssh.error}</pre>
+            </div>
+          </details>
+          `
+                : ''}
+
+          <div class="text-xs text-slate-400 mt-4 pt-4 border-t border-slate-700">
+            🕐 ${new Date(ssh.timestamp).toLocaleString('pt-BR')}
+          </div>
+        </div>
+      `;
+        })
+            .join('');
+        // ✅ CORRIGIR: Contar sucessos considerando success undefined como sucesso
+        const successCount = filteredSSHCommands.filter((ssh) => ssh.success !== false && !ssh.error).length;
+        const failureCount = filteredSSHCommands.length - successCount;
+        return `
+      <div class="mb-8">
+        <h2 class="text-2xl font-bold text-cyan-400 mb-6 flex items-center gap-3 border-l-4 border-cyan-400 pl-4">
+          🖥️ Comandos SSH (${filteredSSHCommands.length})
+        </h2>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
+          <div class="bg-green-800 rounded-lg p-4">
+            <div class="text-green-200 text-sm">✅ Sucessos</div>
+            <div class="text-2xl font-bold text-white">${successCount}</div>
+          </div>
+          <div class="bg-red-800 rounded-lg p-4">
+            <div class="text-red-200 text-sm">❌ Falhas</div>
+            <div class="text-2xl font-bold text-white">${failureCount}</div>
+          </div>
+        </div>
+        <div class="space-y-6">
+          ${sshItems}
+        </div>
+      </div>
+    `;
+    }
+    /**
+     * 🎨 Obter classe TailwindCSS para tipo de query
+     */
+    static getQueryTypeBadgeClass(type) {
+        switch (type.toUpperCase()) {
+            case 'SELECT':
+                return 'bg-green-600';
+            case 'INSERT':
+                return 'bg-blue-600';
+            case 'UPDATE':
+                return 'bg-orange-600';
+            case 'DELETE':
+                return 'bg-red-600';
+            case 'CREATE':
+                return 'bg-purple-600';
+            case 'ALTER':
+                return 'bg-yellow-600';
+            case 'DROP':
+                return 'bg-red-800';
+            default:
+                return 'bg-gray-600';
+        }
+    }
+    /**
+     * 🗄️ Gerar seção Database com detalhes completos
+     */
+    static generateDBSection(dbQueries) {
+        if (dbQueries.length === 0) {
+            return '';
+        }
+        const dbItems = dbQueries
+            .map((db) => {
+            // ✅ CORRIGIDO: Melhorar detecção de sucesso
+            // Se success não está definido, assumir sucesso se não há erro e há duração
+            const isSuccess = db.success !== undefined ? db.success : !db.error && db.duration > 0;
+            Logger.info(`🗄️ [HubDocs] Query: ${db.query.substring(0, 30)}... | success: ${db.success} | error: ${db.error} | duration: ${db.duration} | isSuccess: ${isSuccess}`);
+            const statusIcon = isSuccess ? '✅' : '❌';
+            const typeColor = AutoDocs.getQueryTypeBadgeClass(db.type);
+            const queryPreview = db.query.length > 100 ? `${db.query.substring(0, 100)}...` : db.query;
+            const durationColor = db.duration > 2000 ? 'text-orange-400' : 'text-green-400';
+            return `
+        <div class="card bg-slate-800 hover:bg-slate-700 transition-all duration-200 transform hover:-translate-y-1">
+          <div class="flex flex-wrap items-center justify-between mb-4">
+            <div class="flex items-center gap-3">
+              <span class="${typeColor} text-white px-3 py-1 rounded-full text-sm font-bold">${db.type}</span>
+              <span class="font-mono text-purple-300 font-semibold break-all">${queryPreview}</span>
+            </div>
+            <span class="status-badge ${isSuccess ? 'bg-green-600' : 'bg-red-600'} text-white px-3 py-1 rounded-full text-sm">
+              ${statusIcon} ${isSuccess ? 'Sucesso' : 'Erro'}
+            </span>
+          </div>
+          
+          ${db.description
+                ? `
+          <div class="mb-4 p-3 bg-slate-900 rounded-lg border-l-4 border-blue-500">
+            <div class="flex items-start gap-2">
+              <span class="text-blue-400 text-lg flex-shrink-0">📖</span>
+              <div>
+                <p class="text-slate-300 text-sm font-medium">Descrição do Serviço</p>
+                <p class="text-blue-300 text-base mt-1">${db.description}</p>
+              </div>
+            </div>
+          </div>
+          `
+                : ''}
+          
+          <div class="grid grid-cols-1 md:grid-cols-4 gap-4 mb-4 text-sm">
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>🗄️</span>
+              <span>Database: <span class="text-purple-400">${db.database}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>📝</span>
+              <span>Teste: <span class="text-yellow-400">${db.testName}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>🌍</span>
+              <span>Ambiente: <span class="text-blue-400">${db.environment}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>⏱️</span>
+              <span>Duração: <span class="${durationColor}">${db.duration || 0}ms</span></span>
+            </div>
+            ${db.serviceName
+                ? `
+            <div class="flex items-center gap-2 text-slate-300 md:col-span-2">
+              <span>🔧</span>
+              <span>Serviço: <span class="text-cyan-400">${db.serviceName}</span></span>
+            </div>
+            `
+                : ''}
+          </div>
+
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-purple-400 hover:text-purple-300 transition-colors">
+              📋 Query Completa
+            </summary>
+            <pre class="bg-slate-900 text-purple-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${db.query}</pre>
+          </details>
+
+          ${db.params && db.params.length > 0
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-orange-400 hover:text-orange-300 transition-colors">
+              🔧 Parâmetros
+            </summary>
+            <pre class="bg-slate-900 text-orange-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${JSON.stringify(db.params, null, 2)}</pre>
+          </details>
+          `
+                : ''}
+
+          ${db.error && !isSuccess
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-red-400 hover:text-red-300 transition-colors">
+              ❌ Erro
+            </summary>
+            <div class="bg-red-900 border border-red-700 text-red-300 p-4 rounded-lg mt-2">
+              <pre class="text-sm font-mono overflow-x-auto">${db.error}</pre>
+            </div>
+          </details>
+          `
+                : ''}
+
+          <div class="text-xs text-slate-400 mt-4 pt-4 border-t border-slate-700">
+            🕐 ${new Date(db.timestamp).toLocaleString('pt-BR')}
+          </div>
+        </div>
+      `;
+        })
+            .join('');
+        // ✅ CORRIGIDO: Usar lógica melhorada de detecção de sucesso
+        const successCount = dbQueries.filter((db) => db.success !== undefined ? db.success : !db.error && db.duration > 0).length;
+        const failureCount = dbQueries.length - successCount;
+        const avgDuration = dbQueries.reduce((sum, db) => sum + (db.duration || 0), 0) /
+            dbQueries.length;
+        return `
+      <div class="mb-8">
+        <h2 class="text-2xl font-bold text-purple-400 mb-6 flex items-center gap-3 border-l-4 border-purple-400 pl-4">
+          🗄️ Queries Database (${dbQueries.length})
+        </h2>
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+          <div class="bg-green-800 rounded-lg p-4">
+            <div class="text-green-200 text-sm">✅ Sucessos</div>
+            <div class="text-2xl font-bold text-white">${successCount}</div>
+          </div>
+          <div class="bg-red-800 rounded-lg p-4">
+            <div class="text-red-200 text-sm">❌ Falhas</div>
+            <div class="text-2xl font-bold text-white">${failureCount}</div>
+          </div>
+          <div class="bg-orange-800 rounded-lg p-4">
+            <div class="text-orange-200 text-sm">⏱️ Tempo médio</div>
+            <div class="text-2xl font-bold text-white">${Math.round(avgDuration)}ms</div>
+          </div>
+        </div>
+        <div class="space-y-6">
+          ${dbItems}
+        </div>
+      </div>
+    `;
+    }
+    /**
+     * 🎨 Obter classe TailwindCSS para ação de UI
+     */
+    static getUIActionBadgeClass(action) {
+        switch (action.toLowerCase()) {
+            case 'click':
+                return 'bg-blue-600';
+            case 'type':
+            case 'fill':
+                return 'bg-green-600';
+            case 'navigate':
+                return 'bg-purple-600';
+            case 'wait':
+                return 'bg-yellow-600';
+            case 'scroll':
+                return 'bg-indigo-600';
+            case 'hover':
+                return 'bg-cyan-600';
+            case 'select':
+                return 'bg-orange-600';
+            default:
+                return 'bg-gray-600';
+        }
+    }
+    /**
+     * 🎨 Gerar seção UI com detalhes completos
+     */
+    static generateUISection(uiActions) {
+        if (uiActions.length === 0) {
+            return '';
+        }
+        const uiItems = uiActions
+            .map((ui) => {
+            const statusIcon = ui.success ? '✅' : '❌';
+            const actionColor = AutoDocs.getUIActionBadgeClass(ui.action);
+            const durationColor = ui.duration > 2000 ? 'text-orange-400' : 'text-green-400';
+            const screenshotSrc = AutoDocs.resolveImageSource(ui.screenshot);
+            return `
+        <div class="card bg-slate-800 hover:bg-slate-700 transition-all duration-200 transform hover:-translate-y-1">
+          <div class="flex flex-wrap items-center justify-between mb-4">
+            <div class="flex items-center gap-3">
+              <span class="${actionColor} text-white px-3 py-1 rounded-full text-sm font-bold">${ui.action}</span>
+              <span class="font-mono text-indigo-300 font-semibold break-all">${ui.element}</span>
+              ${ui.methodName && ui.methodName !== 'unknown-method'
+                ? `
+                <span class="bg-purple-600 text-white px-2 py-1 rounded text-xs">📋 ${ui.methodName}</span>
+              `
+                : ''}
+            </div>
+            <span class="status-badge ${ui.success ? 'bg-green-600' : 'bg-red-600'} text-white px-3 py-1 rounded-full text-sm">
+              ${statusIcon} ${ui.success ? 'Sucesso' : 'Erro'}
+            </span>
+          </div>
+          
+          <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-4 text-sm">
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>🌐</span>
+              <span>Página: <span class="text-indigo-400">${ui.page}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>📝</span>
+              <span>Teste: <span class="text-yellow-400">${ui.testName}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>⏱️</span>
+              <span>Duração: <span class="${durationColor}">${ui.duration || 0}ms</span></span>
+            </div>
+          </div>
+
+          ${ui.selector
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-indigo-400 hover:text-indigo-300 transition-colors">
+              🎯 Seletor
+              ${ui.selectorType ? `<span class="ml-2 bg-cyan-600 text-white px-2 py-1 rounded text-xs">${ui.selectorType}</span>` : ''}
+            </summary>
+            <pre class="bg-slate-900 text-indigo-300 p-4 rounded-lg mt-2 overflow-x-auto text-sm font-mono">${ui.selector}</pre>
+          </details>
+          `
+                : ''}
+
+          ${screenshotSrc
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-green-400 hover:text-green-300 transition-colors">
+              📸 Screenshot
+            </summary>
+            <div class="mt-2">
+              <img src="${screenshotSrc}" alt="Screenshot da ação" class="max-w-full rounded-lg border border-slate-600">
+            </div>
+          </details>
+          `
+                : ''}
+
+          ${ui.error
+                ? `
+          <details class="mb-4">
+            <summary class="cursor-pointer font-semibold text-red-400 hover:text-red-300 transition-colors">
+              ❌ Erro
+            </summary>
+            <div class="bg-red-900 border border-red-700 text-red-300 p-4 rounded-lg mt-2">
+              <pre class="text-sm font-mono overflow-x-auto">${ui.error}</pre>
+            </div>
+          </details>
+          `
+                : ''}
+
+          <div class="text-xs text-slate-400 mt-4 pt-4 border-t border-slate-700">
+            🕐 ${new Date(ui.timestamp).toLocaleString('pt-BR')}
+          </div>
+        </div>
+      `;
+        })
+            .join('');
+        const successCount = uiActions.filter((ui) => ui.success).length;
+        const failureCount = uiActions.length - successCount;
+        return `
+      <div class="mb-8">
+        <h2 class="text-2xl font-bold text-indigo-400 mb-6 flex items-center gap-3 border-l-4 border-indigo-400 pl-4">
+          🎨 Ações UI (${uiActions.length})
+        </h2>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
+          <div class="bg-green-800 rounded-lg p-4">
+            <div class="text-green-200 text-sm">✅ Sucessos</div>
+            <div class="text-2xl font-bold text-white">${successCount}</div>
+          </div>
+          <div class="bg-red-800 rounded-lg p-4">
+            <div class="text-red-200 text-sm">❌ Falhas</div>
+            <div class="text-2xl font-bold text-white">${failureCount}</div>
+          </div>
+        </div>
+        <div class="space-y-6">
+          ${uiItems}
+        </div>
+      </div>
+    `;
+    }
+    /**
+     * 📱 Gerar seção Mobile com detalhes completos
+     */
+    static generateMobileSection(mobileActions) {
+        if (mobileActions.length === 0) {
+            return '';
+        }
+        const mobileItems = mobileActions
+            .map((mobile) => {
+            const platformColor = mobile.platform === 'iOS' ? 'bg-blue-600' : 'bg-green-600';
+            const actionColor = AutoDocs.getMobileActionBadgeClass(mobile.action);
+            const screenshotSrc = AutoDocs.resolveImageSource(mobile.screenshot);
+            return `
+        <div class="card bg-slate-800 hover:bg-slate-700 transition-all duration-200 transform hover:-translate-y-1">
+          <div class="flex flex-wrap items-center gap-3 mb-4">
+            <span class="${platformColor} text-white px-3 py-1 rounded-full text-sm font-bold">${mobile.platform}</span>
+            <span class="${actionColor} text-white px-3 py-1 rounded-full text-sm font-bold">${mobile.action}</span>
+            <span class="font-mono text-pink-300 font-semibold break-all">${mobile.element}</span>
+          </div>
+          
+          <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-4 text-sm">
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>📱</span>
+              <span>Device: <span class="text-pink-400">${mobile.device}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>📝</span>
+              <span>Teste: <span class="text-yellow-400">${mobile.testName}</span></span>
+            </div>
+            <div class="flex items-center gap-2 text-slate-300">
+              <span>🕐</span>
+              <span>Timestamp: <span class="text-blue-400">${new Date(mobile.timestamp).toLocaleString('pt-BR')}</span></span>
+            </div>
+          </div>
+
+          ${mobile.value
+                ? `
+          <div class="bg-slate-700 p-3 rounded-lg mb-4">
+            <div class="flex items-center gap-2 text-slate-300">
+              <span class="text-green-400">💬</span>
+              <span>Valor: <span class="text-green-300 font-mono">${mobile.value}</span></span>
+            </div>
+          </div>
+          `
+                : ''}
+
+          ${mobile.coordinates
+                ? `
+          <div class="bg-slate-700 p-3 rounded-lg mb-4">
+            <div class="flex items-center gap-2 text-slate-300">
+              <span class="text-orange-400">📍</span>
+              <span>Coordenadas: <span class="text-orange-300 font-mono">x: ${mobile.coordinates.x}, y: ${mobile.coordinates.y}</span></span>
+            </div>
+          </div>
+          `
+                : ''}
+
+          ${screenshotSrc
+                ? `
+          <div class="bg-slate-700 p-3 rounded-lg mb-4">
+            <div class="flex items-center gap-2 text-slate-300 mb-3">
+              <span class="text-purple-400">📸</span>
+              <span>Screenshot da Ação:</span>
+            </div>
+            <div class="bg-slate-600 p-2 rounded-lg">
+              <img 
+                src="${screenshotSrc}" 
+                alt="Screenshot da ação ${mobile.action} no elemento ${mobile.element}"
+                class="w-full max-w-md mx-auto rounded-lg shadow-lg cursor-pointer hover:shadow-xl transition-shadow duration-200"
+                onclick="window.open(this.src, '_blank')"
+                loading="lazy"
+              />
+              <p class="text-xs text-slate-400 text-center mt-2">Clique na imagem para visualizar em tamanho completo</p>
+            </div>
+          </div>
+          `
+                : ''}
+        </div>
+      `;
+        })
+            .join('');
+        return `
+      <div class="mb-8">
+        <h2 class="text-2xl font-bold text-pink-400 mb-6 flex items-center gap-3 border-l-4 border-pink-400 pl-4">
+          📱 Ações Mobile (${mobileActions.length})
+        </h2>
+        <div class="space-y-6">
+          ${mobileItems}
+        </div>
+      </div>
+    `;
+    }
+    /**
+     * 🎨 Obter classe TailwindCSS para ação mobile
+     */
+    static getMobileActionBadgeClass(action) {
+        switch (action.toLowerCase()) {
+            case 'tap':
+                return 'bg-green-600';
+            case 'type':
+                return 'bg-blue-600';
+            case 'swipe':
+                return 'bg-orange-600';
+            case 'scroll':
+                return 'bg-purple-600';
+            case 'wait':
+                return 'bg-yellow-600';
+            case 'pinch':
+                return 'bg-red-600';
+            case 'rotate':
+                return 'bg-indigo-600';
+            default:
+                return 'bg-gray-600';
+        }
+    }
+    /**
+     * 🎨 Obter cor do tipo de query
+     */
+    static getQueryTypeColor(type) {
+        const colors = {
+            SELECT: '#2196F3',
+            INSERT: '#4CAF50',
+            UPDATE: '#FF9800',
+            DELETE: '#f44336',
+            DDL: '#9C27B0',
+            OTHER: '#607D8B',
+        };
+        return colors[type] || colors.OTHER;
+    }
+    /**
+     * 🎨 Obter cor da ação UI
+     */
+    static getUIActionColor(action) {
+        const colors = {
+            click: '#4CAF50',
+            type: '#2196F3',
+            wait: '#FF9800',
+            navigate: '#9C27B0',
+            validate: '#00BCD4',
+        };
+        return colors[action.toLowerCase()] || '#607D8B';
+    }
+    /**
+     * 🎨 Obter cor da ação mobile
+     */
+    static getMobileActionColor(action) {
+        const colors = {
+            tap: '#4CAF50',
+            type: '#2196F3',
+            swipe: '#FF9800',
+            scroll: '#9C27B0',
+            wait: '#607D8B',
+        };
+        return colors[action.toLowerCase()] || '#795548';
+    }
+    /**
+     * 📋 Gerar documentação Swagger detalhada
+     */
+    static async generateSwaggerDocs(apis) {
+        try {
+            const swaggerDoc = {
+                openapi: '3.0.0',
+                info: {
+                    title: `${AutoDocs.config.projectName} - API Documentation`,
+                    version: '1.0.0',
+                    description: 'Documentação automática gerada pelo AutoDocs durante execução dos testes',
+                    contact: {
+                        name: 'Test Hub Framework',
+                        url: 'http://brtlvlty0559pl:3002/',
+                    },
+                },
+                servers: AutoDocs.extractServers(apis),
+                paths: AutoDocs.generateDetailedSwaggerPaths(apis),
+                components: {
+                    schemas: AutoDocs.generateSwaggerSchemas(apis),
+                    securitySchemes: {
+                        ApiKeyAuth: {
+                            type: 'apiKey',
+                            in: 'header',
+                            name: 'X-API-Key',
+                        },
+                        BearerAuth: {
+                            type: 'http',
+                            scheme: 'bearer',
+                        },
+                    },
+                },
+                tags: AutoDocs.generateSwaggerTags(apis),
+            };
+            const outputPath = path.join(AutoDocs.config.outputDir, 'swagger.json');
+            await fs.promises.writeFile(outputPath, JSON.stringify(swaggerDoc, null, 2), 'utf-8');
+            // Gerar também versão YAML
+            const yamlPath = path.join(AutoDocs.config.outputDir, 'openapi.yaml');
+            const yamlContent = AutoDocs.convertToYaml(swaggerDoc);
+            await fs.promises.writeFile(yamlPath, yamlContent, 'utf-8');
+            Logger.info(`📋 Swagger gerado: ${outputPath}`);
+            Logger.info(`📋 OpenAPI YAML gerado: ${yamlPath}`);
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao gerar Swagger:', error);
+        }
+    }
+    /**
+     * 🖥️ Extrair servidores das URLs das APIs
+     */
+    static extractServers(apis) {
+        const servers = new Set();
+        apis.forEach((api) => {
+            try {
+                // 🎯 Lidar com URLs relativas e absolutas
+                if (api.url.startsWith('http://') || api.url.startsWith('https://')) {
+                    const url = new URL(api.url);
+                    servers.add(`${url.protocol}//${url.host}`);
+                }
+                // URLs relativas não têm servidor, ignorar
+            }
+            catch {
+                // Ignorar URLs inválidas
+            }
+        });
+        return Array.from(servers).map((server) => ({
+            url: server,
+            description: 'Servidor detectado automaticamente',
+        }));
+    }
+    /**
+     * 🛤️ Gerar paths detalhados do Swagger
+     */
+    static generateDetailedSwaggerPaths(apis) {
+        const paths = {};
+        apis.forEach((api) => {
+            try {
+                // 🎯 Lidar com URLs relativas e absolutas
+                let pathKey;
+                if (api.url.startsWith('http://') || api.url.startsWith('https://')) {
+                    // URL absoluta - extrair pathname
+                    const url = new URL(api.url);
+                    pathKey = url.pathname || '/unknown';
+                }
+                else {
+                    // URL relativa - usar diretamente (remover query string se houver)
+                    pathKey = api.url.split('?')[0] || '/unknown';
+                }
+                const method = api.method.toLowerCase();
+                if (!paths[pathKey]) {
+                    paths[pathKey] = {};
+                }
+                paths[pathKey][method] = {
+                    summary: `${api.method} ${pathKey}`,
+                    description: `Detectado no teste: ${api.testName}\\nExecução: ${api.timestamp}`,
+                    tags: [AutoDocs.categorizeEndpoint(pathKey)],
+                    parameters: AutoDocs.extractParameters(api),
+                    requestBody: api.payload
+                        ? {
+                            content: {
+                                'application/json': {
+                                    schema: AutoDocs.inferSchema(api.payload),
+                                    example: api.payload,
+                                },
+                            },
+                        }
+                        : undefined,
+                    responses: {
+                        [api.statusCode || '200']: {
+                            description: api.success ? 'Sucesso' : 'Erro',
+                            content: api.response
+                                ? {
+                                    'application/json': {
+                                        schema: AutoDocs.inferSchema(api.response),
+                                        example: api.response,
+                                    },
+                                }
+                                : undefined,
+                        },
+                    },
+                    'x-test-info': {
+                        testName: api.testName,
+                        environment: api.environment,
+                        duration: `${api.duration}ms`,
+                        success: api.success,
+                        timestamp: api.timestamp,
+                    },
+                };
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro ao processar API para Swagger: ${api.url} ${error}`);
+            }
+        });
+        return paths;
+    }
+    /**
+     * 📊 Gerar schemas do Swagger baseado nos dados
+     */
+    static generateSwaggerSchemas(apis) {
+        const schemas = {};
+        apis.forEach((api) => {
+            // Schema do payload
+            if (api.payload) {
+                const schemaName = AutoDocs.generateSchemaName(api.url, 'Request');
+                schemas[schemaName] = AutoDocs.inferSchema(api.payload);
+            }
+            // Schema da response
+            if (api.response) {
+                const schemaName = AutoDocs.generateSchemaName(api.url, 'Response');
+                schemas[schemaName] = AutoDocs.inferSchema(api.response);
+            }
+        });
+        return schemas;
+    }
+    /**
+     * 🏷️ Gerar tags do Swagger
+     */
+    static generateSwaggerTags(apis) {
+        const tags = new Set();
+        apis.forEach((api) => {
+            try {
+                // 🎯 Lidar com URLs relativas e absolutas
+                let pathname;
+                if (api.url.startsWith('http://') || api.url.startsWith('https://')) {
+                    const url = new URL(api.url);
+                    pathname = url.pathname;
+                }
+                else {
+                    pathname = api.url.split('?')[0]; // URL relativa
+                }
+                const tag = AutoDocs.categorizeEndpoint(pathname);
+                tags.add(tag);
+            }
+            catch {
+                tags.add('Geral');
+            }
+        });
+        // 🏷️ Descrições detalhadas para cada categoria
+        const tagDescriptions = {
+            Cliente: 'APIs relacionadas a consulta e gestão de dados do cliente, produtos associados, contratos e histórico',
+            Catalogo: 'APIs para consulta de produtos, dispositivos, portfolios, preços e ofertas disponíveis',
+            Fatura: 'APIs para consulta de faturas, cobranças e downloads de documentos financeiros',
+            Simulação: 'APIs para criação, consulta e gestão de simulações de venda e negociação',
+            Documentação: 'APIs para geração de documentos, contratos e processos de aceite digital',
+            Workflow: 'APIs para gestão de processos de aprovação, esteira de tramitação e solicitações de serviço',
+            Auxiliar: 'APIs auxiliares para consultas de operadoras, endereços e validações gerais',
+            Autenticação: 'APIs para autenticação, autorização e gestão de tokens',
+            Monitoramento: 'APIs para health checks, status do sistema e monitoramento',
+            Geral: 'APIs gerais e não categorizadas',
+        };
+        return Array.from(tags).map((tag) => ({
+            name: tag,
+            description: tagDescriptions[tag] || `Endpoints da categoria ${tag}`,
+        }));
+    }
+    /**
+     * 🤖 Detectar categorias automaticamente baseado nos endpoints executados
+     */
+    static detectProjectCategories(apis) {
+        const urlPatterns = {};
+        // Analisar todas as URLs para detectar padrões
+        apis.forEach((api) => {
+            const url = api.url.toLowerCase();
+            const pathSegments = url
+                .split('/')
+                .filter((segment) => segment && !segment.includes('http'));
+            pathSegments.forEach((segment) => {
+                // Remover números e IDs para detectar padrões
+                const cleanSegment = segment
+                    .replace(/\d+/g, '')
+                    .replace(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/g, '');
+                if (cleanSegment.length > 2) {
+                    if (!urlPatterns[cleanSegment]) {
+                        urlPatterns[cleanSegment] = [];
+                    }
+                    urlPatterns[cleanSegment].push(url);
+                }
+            });
+        });
+        // Detectar categorias baseado na frequência e padrões conhecidos
+        const detectedCategories = {};
+        // Padrões empresariais conhecidos
+        const knownPatterns = {
+            customer: {
+                variations: ['customer', 'customers', 'cliente', 'clientes'],
+                icon: '👥',
+                description: 'Operações relacionadas ao gerenciamento de clientes e dados corporativos',
+            },
+            catalog: {
+                variations: [
+                    'catalog',
+                    'catalogo',
+                    'products',
+                    'devices',
+                    'portfolio',
+                    'offers',
+                    'producttypecode',
+                    'typetrading',
+                ],
+                icon: '📦',
+                description: 'Gestão de produtos, dispositivos e portfólio de ofertas',
+            },
+            billing: {
+                variations: ['billing', 'invoices', 'fatura', 'faturas', 'cobranca'],
+                icon: '💰',
+                description: 'Processos de faturamento e gestão de pagamentos',
+            },
+            simulation: {
+                variations: ['simulation', 'simulations', 'simulacao', 'simulacoes'],
+                icon: '🎯',
+                description: 'Simulações de vendas e análises comerciais',
+            },
+            file: {
+                variations: [
+                    'file',
+                    'files',
+                    'document',
+                    'documents',
+                    'documentacao',
+                    'upload',
+                ],
+                icon: '📄',
+                description: 'Gestão de arquivos e documentação',
+            },
+            workflow: {
+                variations: [
+                    'workflow',
+                    'approval',
+                    'esteira',
+                    'tramitacao',
+                    'servicerequest',
+                ],
+                icon: '🔄',
+                description: 'Processos de aprovação e fluxos de trabalho',
+            },
+            account: {
+                variations: ['account', 'accounts', 'conta', 'contas', 'sobjects'],
+                icon: '🏢',
+                description: 'Gestão de contas e informações corporativas',
+            },
+            service: {
+                variations: ['service', 'services', 'servico', 'servicos', 'ss'],
+                icon: '🛠️',
+                description: 'Serviços e requisições de suporte',
+            },
+            order: {
+                variations: ['order', 'orders', 'pedido', 'pedidos'],
+                icon: '📋',
+                description: 'Gestão de pedidos e ordens',
+            },
+            address: {
+                variations: ['address', 'addresses', 'endereco', 'enderecos'],
+                icon: '📍',
+                description: 'Gestão de endereços e localização',
+            },
+            auth: {
+                variations: ['auth', 'login', 'token', 'authentication'],
+                icon: '🔐',
+                description: 'Autenticação e autorização',
+            },
+            monitoring: {
+                variations: ['health', 'status', 'ping', 'monitor'],
+                icon: '📊',
+                description: 'Monitoramento e status do sistema',
+            },
+        };
+        // Detectar categorias baseado nos padrões encontrados
+        for (const [segment, urls] of Object.entries(urlPatterns)) {
+            if (urls.length >= 1) {
+                // Se aparecer pelo menos uma vez
+                for (const [categoryKey, categoryData] of Object.entries(knownPatterns)) {
+                    if (categoryData.variations.some((variation) => segment.includes(variation) || variation.includes(segment))) {
+                        if (!detectedCategories[categoryKey]) {
+                            detectedCategories[categoryKey] = {
+                                pattern: categoryData.variations,
+                                description: categoryData.description,
+                                icon: categoryData.icon,
+                            };
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        // Se não encontrou categorias específicas, criar categorias genéricas baseadas nos segmentos mais comuns
+        if (Object.keys(detectedCategories).length === 0) {
+            const sortedSegments = Object.entries(urlPatterns)
+                .sort(([, a], [, b]) => b.length - a.length)
+                .slice(0, 5);
+            sortedSegments.forEach(([segment, urls], index) => {
+                detectedCategories[segment] = {
+                    pattern: [segment],
+                    description: `Operações relacionadas a ${segment}`,
+                    icon: ['🔵', '🟢', '🟡', '🟠', '🔴'][index] || '⚪',
+                };
+            });
+        }
+        // Adicionar categoria "Outras" para endpoints não categorizados
+        detectedCategories['outras'] = {
+            pattern: [],
+            description: 'Outros endpoints não categorizados',
+            icon: '⚡',
+        };
+        return detectedCategories;
+    }
+    /**
+     * 🏷️ Categorizar endpoint com base nas categorias detectadas dinamicamente
+     */
+    static categorizeEndpointDynamic(url, detectedCategories) {
+        const lowerUrl = url.toLowerCase();
+        // Verificar contra categorias detectadas automaticamente
+        for (const [categoryName, categoryData] of Object.entries(detectedCategories)) {
+            if (categoryName === 'outras')
+                continue; // Pular a categoria "outras" na verificação
+            if (categoryData.pattern.some((pattern) => lowerUrl.includes(`/${pattern}/`) ||
+                lowerUrl.includes(`/${pattern}`) ||
+                lowerUrl.includes(pattern))) {
+                return categoryName.charAt(0).toUpperCase() + categoryName.slice(1);
+            }
+        }
+        return 'Outras';
+    }
+    /**
+     * 🎯 Categorizar endpoint
+     */
+    static categorizeEndpoint(path) {
+        // 🏢 Categorização baseada nos padrões da empresa
+        // Cliente - Operações relacionadas ao cliente
+        if (path.includes('/customers/') || path.includes('/customer/'))
+            return 'Cliente';
+        // Catálogo - Produtos, devices, portfolios, preços
+        if (path.includes('/products/') ||
+            path.includes('/devices/') ||
+            path.includes('/portfolio/') ||
+            path.includes('/productType') ||
+            path.includes('/typeTrading') ||
+            path.includes('/offersCatalog'))
+            return 'Catalogo';
+        // Fatura - Faturas e cobranças
+        if (path.includes('/invoices/') ||
+            path.includes('/billing/') ||
+            path.includes('/payment/'))
+            return 'Fatura';
+        // Simulação - Simulações de venda e negociação
+        if (path.includes('/simulacoes/') ||
+            path.includes('/simulation/') ||
+            path.includes('/quote/'))
+            return 'Simulação';
+        // Documentação - Geração de documentos e contratos
+        if (path.includes('/documentation/') ||
+            path.includes('/documents/') ||
+            path.includes('/gerarDocumentacao') ||
+            path.includes('/aceite') ||
+            path.includes('/gedoc'))
+            return 'Documentação';
+        // Workflow - Processos de aprovação e esteira
+        if (path.includes('/workflow/') ||
+            path.includes('/approval/') ||
+            path.includes('/esteira') ||
+            path.includes('/solicitacoes'))
+            return 'Workflow';
+        // Auxiliar - Serviços de apoio e consultas gerais
+        if (path.includes('/auxiliares/') ||
+            path.includes('/operadoras/') ||
+            path.includes('/geographicAddress') ||
+            path.includes('/validate'))
+            return 'Auxiliar';
+        // Autenticação
+        if (path.includes('/auth/') ||
+            path.includes('/login/') ||
+            path.includes('/token/'))
+            return 'Autenticação';
+        // Health checks e monitoramento
+        if (path.includes('/health') ||
+            path.includes('/status') ||
+            path.includes('/ping'))
+            return 'Monitoramento';
+        // Fallback genérico
+        return 'Geral';
+    }
+    /**
+     * 📄 Converter para YAML
+     */
+    static convertToYaml(obj) {
+        try {
+            // Limpar dados problemáticos antes da conversão
+            const cleanedObj = AutoDocs.cleanObjectForYaml(obj, false);
+            // Usar biblioteca js-yaml para conversão correta
+            const yamlContent = yaml.dump(cleanedObj, {
+                indent: 2,
+                lineWidth: -1,
+                noRefs: true,
+                sortKeys: false,
+                quotingType: '"',
+                forceQuotes: false,
+                noCompatMode: true,
+            });
+            return `# OpenAPI Specification
+# Gerado automaticamente pelo AutoDocs
+
+${yamlContent}`;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao converter para YAML:', error);
+            // Fallback para conversão simples
+            return `# OpenAPI Specification
+# Gerado automaticamente pelo AutoDocs
+
+openapi: "3.0.0"
+info:
+  title: "API Documentation"
+  version: "1.0.0"
+  description: "Erro na conversão YAML - ${error}"
+`;
+        }
+    }
+    /**
+     * 🧹 Limpar objeto para conversão YAML
+     */
+    static cleanObjectForYaml(obj, isPathsSection = false) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (typeof obj === 'string') {
+            // Limpar caracteres problemáticos em strings
+            return obj
+                .replace(/\\/g, '\\\\') // Escapar barras invertidas
+                .replace(/\n/g, '\\n') // Escapar quebras de linha
+                .replace(/\t/g, '\\t') // Escapar tabs
+                .replace(/\r/g, '\\r'); // Escapar carriage returns
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => AutoDocs.cleanObjectForYaml(item, false));
+        }
+        if (typeof obj === 'object') {
+            const cleaned = {};
+            Object.keys(obj).forEach((key) => {
+                // 🔧 CORREÇÃO: Preservar paths do OpenAPI intactos
+                let cleanKey;
+                if (isPathsSection && key.startsWith('/')) {
+                    // Para paths do OpenAPI, manter o formato original
+                    cleanKey = key;
+                }
+                else if (key === 'paths') {
+                    // Quando encontrar a seção paths, marcar para tratamento especial
+                    cleaned[key] = AutoDocs.cleanObjectForYaml(obj[key], true);
+                    return;
+                }
+                else {
+                    // Para outras chaves, limpar normalmente
+                    cleanKey = key.replace(/[^\w\-_]/g, '_');
+                }
+                cleaned[cleanKey] = AutoDocs.cleanObjectForYaml(obj[key], false);
+            });
+            return cleaned;
+        }
+        return obj;
+    }
+    /**
+     * 🔍 Inferir schema de um objeto
+     * ✅ CORRIGIDO: Tipos válidos OpenAPI 3.0 (array, boolean, integer, number, object, string)
+     * ✅ CORRIGIDO: required só é adicionado se tiver pelo menos 1 item
+     */
+    static inferSchema(obj) {
+        // 🔧 null -> string com nullable: true (OpenAPI 3.0 não suporta type: 'null')
+        if (obj === null || obj === undefined) {
+            return { type: 'string', nullable: true };
+        }
+        if (typeof obj === 'string')
+            return { type: 'string', example: obj };
+        if (typeof obj === 'number') {
+            // Verificar se é inteiro ou decimal
+            return Number.isInteger(obj)
+                ? { type: 'integer', example: obj }
+                : { type: 'number', example: obj };
+        }
+        if (typeof obj === 'boolean')
+            return { type: 'boolean', example: obj };
+        if (Array.isArray(obj)) {
+            return {
+                type: 'array',
+                items: obj.length > 0 ? AutoDocs.inferSchema(obj[0]) : { type: 'string' },
+            };
+        }
+        if (typeof obj === 'object') {
+            const properties = {};
+            const keys = Object.keys(obj);
+            keys.forEach((key) => {
+                properties[key] = AutoDocs.inferSchema(obj[key]);
+            });
+            // 🔧 FIX: required só é adicionado se tiver pelo menos 1 item (OpenAPI exige min 1)
+            const schema = {
+                type: 'object',
+                properties,
+            };
+            // Só adicionar required se tiver itens
+            if (keys.length > 0) {
+                schema.required = keys;
+            }
+            return schema;
+        }
+        return { type: 'string' };
+    }
+    /**
+     * 📝 Gerar nome de schema
+     * ✅ CORRIGIDO: Sanitiza caracteres inválidos (OpenAPI só permite A-Z a-z 0-9 - . _)
+     */
+    static generateSchemaName(url, suffix) {
+        try {
+            // 🎯 Lidar com URLs relativas e absolutas
+            let pathname;
+            if (url.startsWith('http://') || url.startsWith('https://')) {
+                const urlObj = new URL(url);
+                pathname = urlObj.pathname;
+            }
+            else {
+                pathname = url.split('?')[0]; // URL relativa
+            }
+            const pathParts = pathname.split('/').filter((p) => p);
+            let name = pathParts.length > 0 ? pathParts[pathParts.length - 1] : 'Unknown';
+            // 🔧 FIX: Sanitizar nome - OpenAPI só permite: A-Z a-z 0-9 - . _
+            // Substituir caracteres inválidos (|, %, @, #, etc.) por underscore
+            name = AutoDocs.sanitizeSchemaName(name);
+            return `${name}${suffix}`;
+        }
+        catch {
+            return `Unknown${suffix}`;
+        }
+    }
+    /**
+     * 🔧 Sanitizar nome de schema para OpenAPI
+     * OpenAPI só permite: A-Z a-z 0-9 - . _
+     */
+    static sanitizeSchemaName(name) {
+        // Decodificar URL encoding primeiro (%7C -> |)
+        let decoded = name;
+        try {
+            decoded = decodeURIComponent(name);
+        }
+        catch {
+            // Se falhar, usar o nome original
+        }
+        // Substituir caracteres inválidos por underscore
+        // Caracteres válidos: A-Z a-z 0-9 - . _
+        return decoded
+            .replace(/[|]/g, '_OR_') // | -> _OR_
+            .replace(/@/g, '_AT_') // @ -> _AT_
+            .replace(/#/g, '_HASH_') // # -> _HASH_
+            .replace(/%/g, '_PCT_') // % -> _PCT_
+            .replace(/[^A-Za-z0-9._-]/g, '_') // Outros inválidos -> _
+            .replace(/_+/g, '_') // Múltiplos underscores -> um só
+            .replace(/^_|_$/g, ''); // Remover underscores no início/fim
+    }
+    /**
+     * 🔧 Extrair parâmetros da API
+     */
+    static extractParameters(api) {
+        const parameters = [];
+        try {
+            // 🎯 Lidar com URLs relativas e absolutas
+            let searchParams;
+            if (api.url.startsWith('http://') || api.url.startsWith('https://')) {
+                const url = new URL(api.url);
+                searchParams = url.searchParams;
+            }
+            else {
+                // URL relativa - extrair query string manualmente
+                const queryString = api.url.split('?')[1];
+                searchParams = new URLSearchParams(queryString || '');
+            }
+            // Query parameters
+            searchParams.forEach((value, key) => {
+                parameters.push({
+                    name: key,
+                    in: 'query',
+                    schema: { type: 'string' },
+                    example: value,
+                });
+            });
+            // Headers importantes
+            if (api.headers) {
+                Object.keys(api.headers).forEach((header) => {
+                    if (!['content-type', 'user-agent', 'accept'].includes(header.toLowerCase())) {
+                        parameters.push({
+                            name: header,
+                            in: 'header',
+                            schema: { type: 'string' },
+                            example: api.headers[header],
+                        });
+                    }
+                });
+            }
+        }
+        catch {
+            // Ignorar erros de parsing
+        }
+        return parameters;
+    }
+    /**
+     * 🛤️ Gerar paths do Swagger
+     */
+    static generateSwaggerPaths(apis) {
+        const paths = {};
+        apis.forEach((api) => {
+            const pathKey = api.url.replace(/https?:\/\/[^/]+/, '') || '/unknown';
+            const method = api.method.toLowerCase();
+            if (!paths[pathKey]) {
+                paths[pathKey] = {};
+            }
+            paths[pathKey][method] = {
+                summary: `${api.method} ${pathKey}`,
+                description: `Detectado no teste: ${api.testName}`,
+                responses: {
+                    [api.statusCode || '200']: {
+                        description: 'Response',
+                    },
+                },
+            };
+        });
+        return paths;
+    }
+    static async ensureOutputDir() {
+        try {
+            await fs.promises.mkdir(AutoDocs.config.outputDir, { recursive: true });
+        }
+        catch (error) {
+            Logger.warning(`⚠️ AutoDocs: Erro ao criar diretório de saída: ${error}`);
+        }
+    }
+}
+// 🚀 AUTO-INICIALIZAÇÃO COMPLETA: Sistema totalmente automático
+try {
+    // Evitar múltiplas inicializações - usar flag global
+    const globalFlag = 'AUTOCORE_AUTODOCS_INITIALIZED';
+    const isAlreadyInitialized = global[globalFlag] === true;
+    if (!isAlreadyInitialized) {
+        // Detectar ambiente Playwright/Teste de forma mais robusta
+        const isPlaywrightEnvironment = process.env.PLAYWRIGHT_TEST_BASE_URL !== undefined ||
+            process.env.PWTEST_SKIP_TEST_OUTPUT !== undefined ||
+            process.env.NODE_ENV === 'test' ||
+            process.env.VITEST === 'true' ||
+            process.env.JEST_WORKER_ID !== undefined ||
+            typeof globalThis.test === 'function' ||
+            typeof globalThis.expect === 'function' ||
+            typeof globalThis.it === 'function' ||
+            typeof globalThis.describe === 'function' ||
+            process.argv.some((arg) => arg.includes('playwright') ||
+                arg.includes('vitest') ||
+                arg.includes('jest'));
+        if (isPlaywrightEnvironment) {
+            // Marcar como inicializado globalmente
+            ;
+            global[globalFlag] = true;
+            // Auto-inicialização no próximo tick
+            process.nextTick(async () => {
+                try {
+                    await AutoDocs.initialize({
+                        projectName: process.env.npm_package_name || 'Test Hub',
+                        outputDir: './docs',
+                        config: {
+                            enabled: true,
+                            categories: ['api', 'ssh', 'db', 'ui', 'mobile'],
+                            generateSwagger: true,
+                            includeRequestBody: true,
+                            includeResponseBody: true,
+                        },
+                    });
+                }
+                catch (error) {
+                    process.stderr.write(` ⚠️ AutoDocs: Erro na auto-inicialização: ${error}\n`);
+                }
+            });
+            // Auto-finalização quando o processo termina - APENAS UMA VEZ
+            const globalFlagFinalization = 'AUTOCORE_AUTODOCS_FINALIZED';
+            const autoFinalize = async () => {
+                if (global[globalFlagFinalization] === true) {
+                    return; // Evitar execuções duplicadas
+                }
+                ;
+                global[globalFlagFinalization] = true;
+                try {
+                    process.stdout.write('🏁 AutoDocs: Finalizando e gerando documentação automática...\n');
+                    await AutoDocs.generateDocs();
+                    process.stdout.write('✅ AutoDocs: Documentação gerada automaticamente em ./docs\n');
+                }
+                catch (error) {
+                    process.stderr.write(`❌ AutoDocs: Erro na finalização automática: ${error}\n`);
+                }
+            };
+            // Hook de finalização única - evitar múltiplas execuções
+            process.once('beforeExit', autoFinalize);
+        }
+    }
+}
+catch {
+    // Ignorar erros de auto-inicialização silenciosamente
+}