@silasfmartins/testhub 1.0.0

package/dist/src/hubdocs/ExecutionTracker.js

@@ -0,0 +1,702 @@
+/**
+ * 🔍 ExecutionTracker - Interceptador Principal
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+export class ExecutionTracker {
+    // 🛡️ CRITICAL: Proteção contra recursão infinita
+    static isExecutingInternal = false;
+    /**
+     * 🔗 HOOK: Notificar StatementTracker sobre ações executadas
+     */
+    static notifyStatementTracker(actionType, description, success, duration) {
+        try {
+            // Import dinâmico para evitar dependência circular
+            const { StatementTracker } = require('./StatementTracker.js');
+            StatementTracker.recordAction(actionType, description, success, duration);
+        }
+        catch (error) {
+            // Silencioso - StatementTracker pode não estar disponível
+        }
+    }
+    /**
+     * ✅ NOVO: Obter versão atual do AutoCore (com proteção contra recursão)
+     */
+    static getAutoCoreVersion() {
+        // 🛡️ Evita recursão infinita durante interceptação
+        if (ExecutionTracker.isExecutingInternal) {
+            return '1.1.X'; // Fallback seguro
+        }
+        ExecutionTracker.isExecutingInternal = true;
+        try {
+            const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                return (packageJson.dependencies?.['@silasfmartins/testhub'] ||
+                    packageJson.devDependencies?.['@silasfmartins/testhub'] ||
+                    '1.1.X');
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao ler versão do AutoCore: ${error}`);
+        }
+        finally {
+            ExecutionTracker.isExecutingInternal = false;
+        }
+        return '1.1.X';
+    }
+    static data = {
+        apis: [],
+        ssh: [],
+        db: [],
+        ui: [],
+        mobile: [],
+        metadata: {
+            startTime: new Date().toISOString(),
+            endTime: '',
+            environment: process.env.NODE_ENV || 'development',
+            totalTests: 0,
+            passedTests: 0,
+            failedTests: 0,
+            framework: 'TestHub',
+            version: '1.1.X', // ✅ FIXO INICIALMENTE - será atualizado no initialize()
+            projectName: 'TestHub Project',
+            projectType: 'Mixed',
+            duration: 0,
+        },
+    };
+    static config = {
+        enabled: true,
+        categories: ['api', 'ssh', 'db', 'ui', 'mobile'],
+        outputDir: './docs',
+        includeRequestBody: true,
+        includeResponseBody: true,
+        generateSwagger: true,
+        includeScreenshots: false,
+        maxRequestSize: 10_000, // 10KB
+        maxResponseSize: 50_000, // 50KB
+    };
+    static tempDir = path.resolve(process.cwd(), '.rbqa');
+    static dataFile = path.join(this.tempDir, 'execution-data.json');
+    /**
+     * ✅ Inicializar o tracker
+     */
+    static initialize(projectName, projectType) {
+        // ✅ ATUALIZAR: Versão dinâmica sempre
+        ExecutionTracker.data.metadata.version =
+            ExecutionTracker.getAutoCoreVersion();
+        // ✅ NOVA: Detecção inteligente do nome do projeto
+        const detectedProjectName = projectName ||
+            process.env.npm_package_name ||
+            ExecutionTracker.detectProjectNameFromPath() ||
+            'AutoCore Project';
+        // ✅ NOVA: Detecção inteligente do tipo de projeto
+        const detectedProjectType = projectType || ExecutionTracker.detectProjectType() || 'API';
+        ExecutionTracker.data.metadata.projectName = detectedProjectName;
+        ExecutionTracker.data.metadata.projectType = detectedProjectType;
+        ExecutionTracker.data.metadata.startTime = new Date().toISOString();
+        // Criar diretório temporário
+        if (!fs.existsSync(ExecutionTracker.tempDir)) {
+            fs.mkdirSync(ExecutionTracker.tempDir, { recursive: true });
+        }
+    }
+    /**
+     * ✅ NOVO: Detectar nome do projeto a partir do caminho
+     */
+    static detectProjectNameFromPath() {
+        try {
+            const cwd = process.cwd();
+            const projectName = path.basename(cwd);
+            // Se contém indicadores de projeto de teste API
+            if (projectName.includes('test') ||
+                projectName.includes('api') ||
+                projectName.includes('oss')) {
+                return projectName;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * ✅ NOVO: Detectar tipo de projeto automaticamente
+     */
+    static detectProjectType() {
+        try {
+            const cwd = process.cwd();
+            const projectName = path.basename(cwd).toLowerCase();
+            const packageName = process.env.npm_package_name?.toLowerCase() || '';
+            // Verificar indicadores de API
+            const apiIndicators = [
+                'api',
+                'test-oss-api',
+                'oss-api',
+                'autocore',
+                'rest',
+                'service',
+            ];
+            if (apiIndicators.some((indicator) => projectName.includes(indicator) || packageName.includes(indicator))) {
+                return 'API';
+            }
+            // Verificar indicadores Mobile
+            const mobileIndicators = ['mobile', 'appium', 'android', 'ios'];
+            if (mobileIndicators.some((indicator) => projectName.includes(indicator) || packageName.includes(indicator))) {
+                return 'Mobile';
+            }
+            // Verificar indicadores Frontend
+            const frontendIndicators = ['frontend', 'web', 'ui', 'playwright'];
+            if (frontendIndicators.some((indicator) => projectName.includes(indicator) || packageName.includes(indicator))) {
+                return 'Frontend';
+            }
+            // Padrão para projetos com "test" no nome
+            if (projectName.includes('test') || packageName.includes('test')) {
+                return 'API'; // Assumir API como padrão para projetos de teste
+            }
+            return 'Mixed';
+        }
+        catch {
+            return 'Mixed';
+        }
+    }
+    /**
+     * 🌐 Rastrear chamada de API
+     */
+    static trackAPI(call) {
+        // ✅ CRÍTICO: Auto-inicializar se necessário
+        if (!fs.existsSync(ExecutionTracker.tempDir)) {
+            ExecutionTracker.initialize();
+        }
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('api')))
+            return;
+        // Limitar tamanho de payload/response se configurado
+        if (call.payload &&
+            JSON.stringify(call.payload).length >
+                ExecutionTracker.config.maxRequestSize) {
+            call.payload = {
+                __truncated: true,
+                size: JSON.stringify(call.payload).length,
+            };
+        }
+        if (call.response &&
+            JSON.stringify(call.response).length >
+                ExecutionTracker.config.maxResponseSize) {
+            call.response = {
+                __truncated: true,
+                size: JSON.stringify(call.response).length,
+            };
+        }
+        ExecutionTracker.data.apis.push(call);
+        ExecutionTracker.saveToFile();
+        // 🔗 HOOK: Notificar StatementTracker
+        ExecutionTracker.notifyStatementTracker('API', `${call.method} ${call.url}`, call.success, call.duration);
+    }
+    /**
+     * 🔄 Atualizar resultado de API específica
+     */
+    static updateAPIResult(docId, response, statusCode, error) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('api')))
+            return;
+        try {
+            // Encontrar a API pelo ID
+            const apiIndex = ExecutionTracker.data.apis.findIndex((api) => api.id === docId);
+            if (apiIndex !== -1) {
+                // Atualizar dados da API
+                ExecutionTracker.data.apis[apiIndex].success =
+                    !error && statusCode !== undefined && statusCode < 400;
+                ExecutionTracker.data.apis[apiIndex].statusCode =
+                    statusCode || (error ? 500 : 200);
+                ExecutionTracker.data.apis[apiIndex].error = error
+                    ? String(error)
+                    : null;
+                // Adicionar response se fornecido
+                if (response) {
+                    ExecutionTracker.data.apis[apiIndex].response = response;
+                }
+                // Calcular duração se possível
+                const startTime = new Date(ExecutionTracker.data.apis[apiIndex].timestamp).getTime();
+                ExecutionTracker.data.apis[apiIndex].duration = Date.now() - startTime;
+                ExecutionTracker.saveToFile();
+            }
+            else {
+                console.warn(`📚 ExecutionTracker: API com ID ${docId} não encontrada para atualização`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ ExecutionTracker.updateAPIResult erro crítico: ${error}`);
+            // ✅ NOVO: Mesmo com erro, tentar salvar o que já existe
+            try {
+                ExecutionTracker.saveToFile();
+            }
+            catch (saveError) {
+                console.error(`❌ ExecutionTracker: Falha crítica ao salvar após erro: ${saveError}`);
+            }
+        }
+    }
+    /**
+     * 🖥️ Rastrear comando SSH
+     */
+    static trackSSH(command) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('ssh')))
+            return;
+        ExecutionTracker.data.ssh.push(command);
+        ExecutionTracker.saveToFile();
+        // 🔗 HOOK: Notificar StatementTracker
+        ExecutionTracker.notifyStatementTracker('SSH', command.command, command.success, command.duration);
+    }
+    /**
+     * 🔄 Atualizar resultado de comando SSH específico
+     */
+    static updateSSHResult(command, timestamp, success, duration, exitCode, error) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('ssh')))
+            return;
+        try {
+            // Encontrar o comando SSH pelo command e timestamp (mais preciso)
+            const sshIndex = ExecutionTracker.data.ssh.findIndex((ssh) => ssh.command === command &&
+                Math.abs(new Date(ssh.timestamp).getTime() - new Date(timestamp).getTime()) < 5000);
+            if (sshIndex !== -1) {
+                // Atualizar dados do comando SSH
+                ExecutionTracker.data.ssh[sshIndex].success = success;
+                ExecutionTracker.data.ssh[sshIndex].duration = duration;
+                ExecutionTracker.data.ssh[sshIndex].error = error || undefined;
+                // Atualizar exitCode se fornecido
+                if (exitCode !== undefined) {
+                    ExecutionTracker.data.ssh[sshIndex].exitCode = exitCode;
+                }
+                ExecutionTracker.saveToFile();
+            }
+            else {
+                console.warn('📊 ExecutionTracker: Comando SSH não encontrado para atualização');
+            }
+        }
+        catch (error) {
+            console.error(`❌ ExecutionTracker.updateSSHResult erro crítico: ${error}`);
+            try {
+                ExecutionTracker.saveToFile();
+            }
+            catch (saveError) {
+                console.error(`❌ ExecutionTracker: Falha crítica ao salvar após erro: ${saveError}`);
+            }
+        }
+    }
+    /**
+     * 🗄️ Rastrear query de banco
+     */
+    static trackDB(query) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('db')))
+            return;
+        ExecutionTracker.data.db.push(query);
+        ExecutionTracker.saveToFile();
+        // 🔗 HOOK: Notificar StatementTracker
+        ExecutionTracker.notifyStatementTracker('DB', query.query.substring(0, 50) + '...', query.success, query.duration);
+    }
+    /**
+     * 🔄 Atualizar resultado de query de banco específica
+     */
+    static updateDBResult(query, timestamp, success, duration, error, resultCount) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('db')))
+            return;
+        try {
+            console.log(`🔄 [ExecutionTracker] Tentando atualizar query: ${query.substring(0, 50)}... (success: ${success})`);
+            // Encontrar a query pelo SQL e timestamp (mais preciso)
+            const dbIndex = ExecutionTracker.data.db.findIndex((db) => db.query === query &&
+                Math.abs(new Date(db.timestamp).getTime() - new Date(timestamp).getTime()) < 5000);
+            if (dbIndex !== -1) {
+                console.log(`✅ [ExecutionTracker] Query encontrada no índice ${dbIndex}, atualizando...`);
+                // Atualizar dados da query
+                ExecutionTracker.data.db[dbIndex].success = success;
+                ExecutionTracker.data.db[dbIndex].duration = duration;
+                ExecutionTracker.data.db[dbIndex].error = error || undefined;
+                // Adicionar contagem de resultados se fornecida
+                if (resultCount !== undefined) {
+                    ;
+                    ExecutionTracker.data.db[dbIndex].resultCount = resultCount;
+                    console.log(`📊 [ExecutionTracker] Resultados: ${resultCount} registros`);
+                }
+                ExecutionTracker.saveToFile();
+            }
+            else {
+                console.warn('📊 ExecutionTracker: Query de banco não encontrada para atualização');
+                console.warn(`📊 Queries disponíveis: ${ExecutionTracker.data.db.length}`);
+                if (ExecutionTracker.data.db.length > 0) {
+                    console.warn(`📊 Primeira query: ${ExecutionTracker.data.db[0].query.substring(0, 50)}...`);
+                    console.warn(`📊 Timestamp procurado: ${timestamp}`);
+                    console.warn(`📊 Timestamp primeira: ${ExecutionTracker.data.db[0].timestamp}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ ExecutionTracker.updateDBResult erro crítico: ${error}`);
+            try {
+                ExecutionTracker.saveToFile();
+            }
+            catch (saveError) {
+                console.error(`❌ ExecutionTracker: Falha crítica ao salvar após erro: ${saveError}`);
+            }
+        }
+    }
+    /**
+     * 🎨 Rastrear ação de UI
+     */
+    static trackUI(action) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('ui')))
+            return;
+        ExecutionTracker.data.ui.push(action);
+        ExecutionTracker.saveToFile();
+        // 🔗 HOOK: Notificar StatementTracker
+        ExecutionTracker.notifyStatementTracker('UI', `${action.action} ${action.element || ''}`, action.success, action.duration);
+    }
+    /**
+     * 📱 Rastrear ação mobile
+     */
+    static trackMobile(action) {
+        if (!(ExecutionTracker.config.enabled &&
+            ExecutionTracker.config.categories.includes('mobile')))
+            return;
+        ExecutionTracker.data.mobile.push(action);
+        ExecutionTracker.saveToFile();
+        // 🔗 HOOK: Notificar StatementTracker
+        ExecutionTracker.notifyStatementTracker('MOBILE', `${action.action} ${action.element || ''}`, undefined, undefined);
+    }
+    /**
+     * 📊 Atualizar estatísticas de testes
+     */
+    static updateTestStats(total, passed, failed) {
+        ExecutionTracker.data.metadata.totalTests = total;
+        ExecutionTracker.data.metadata.passedTests = passed;
+        ExecutionTracker.data.metadata.failedTests = failed;
+        ExecutionTracker.saveToFile();
+    }
+    /**
+     * 💾 Salvar dados em arquivo temporário (COM PROTEÇÃO CONTRA PERDA)
+     */
+    static saveToFile() {
+        // 🛡️ CRITICAL: Proteção total contra recursão infinita
+        if (ExecutionTracker.isExecutingInternal) {
+            return; // Sair silenciosamente se já executando
+        }
+        try {
+            // Marcar como executando para evitar recursão
+            ExecutionTracker.isExecutingInternal = true;
+            // Garantir que o diretório existe
+            if (!fs.existsSync(ExecutionTracker.tempDir)) {
+                fs.mkdirSync(ExecutionTracker.tempDir, { recursive: true });
+            }
+            // ✅ PROTEÇÃO: Verificar se há dados antes de salvar
+            const totalItems = ExecutionTracker.data.apis.length +
+                ExecutionTracker.data.ssh.length +
+                ExecutionTracker.data.db.length +
+                ExecutionTracker.data.ui.length +
+                ExecutionTracker.data.mobile.length;
+            // ✅ CRÍTICO: Se arquivo existe e tem dados, mas memória está vazia, CARREGAR do arquivo
+            if (totalItems === 0 && fs.existsSync(ExecutionTracker.dataFile)) {
+                const fileData = ExecutionTracker.loadFromFile();
+                if (fileData &&
+                    (fileData.apis.length > 0 ||
+                        fileData.ssh.length > 0 ||
+                        fileData.db.length > 0 ||
+                        fileData.ui.length > 0 ||
+                        fileData.mobile.length > 0)) {
+                    ExecutionTracker.data = {
+                        ...fileData,
+                        metadata: {
+                            ...fileData.metadata,
+                            // Manter metadados atualizados mas preservar dados
+                            endTime: ExecutionTracker.data.metadata.endTime ||
+                                fileData.metadata.endTime,
+                            duration: ExecutionTracker.data.metadata.duration ||
+                                fileData.metadata.duration,
+                        },
+                    };
+                }
+            }
+            // ✅ NOVO: Detectar versão atual do AutoCore (com proteção)
+            if (!ExecutionTracker.isExecutingInternal) {
+                ExecutionTracker.data.metadata.version =
+                    ExecutionTracker.getAutoCoreVersion();
+            }
+            // ✅ MELHORAR: Detectar tipo de projeto baseado nos dados coletados
+            if (ExecutionTracker.data.apis.length > 0 &&
+                ExecutionTracker.data.ui.length === 0 &&
+                ExecutionTracker.data.mobile.length === 0) {
+                ExecutionTracker.data.metadata.projectType = 'API';
+            }
+            else if (ExecutionTracker.data.ui.length > 0 &&
+                ExecutionTracker.data.mobile.length === 0) {
+                ExecutionTracker.data.metadata.projectType = 'Frontend';
+            }
+            else if (ExecutionTracker.data.mobile.length > 0) {
+                ExecutionTracker.data.metadata.projectType = 'Mobile';
+            }
+            else if (ExecutionTracker.data.ssh.length > 0) {
+                ExecutionTracker.data.metadata.projectType = 'SSH';
+            }
+            else if (ExecutionTracker.data.db.length > 0) {
+                ExecutionTracker.data.metadata.projectType = 'Database';
+            }
+            else if (ExecutionTracker.data.apis.length > 0 &&
+                (ExecutionTracker.data.ui.length > 0 ||
+                    ExecutionTracker.data.mobile.length > 0 ||
+                    ExecutionTracker.data.ssh.length > 0 ||
+                    ExecutionTracker.data.db.length > 0)) {
+                ExecutionTracker.data.metadata.projectType = 'Mixed';
+            }
+            // ✅ NOVO: Atualizar estatísticas em tempo real
+            ExecutionTracker.data.metadata.endTime = new Date().toISOString();
+            ExecutionTracker.data.metadata.duration =
+                new Date().getTime() -
+                    new Date(ExecutionTracker.data.metadata.startTime).getTime();
+            // ✅ PROTEÇÃO MELHORADA: Backup seguro com retry
+            const backupFile = ExecutionTracker.dataFile + '.backup';
+            let backupSuccess = false;
+            // Tentar fazer backup com retry para arquivo ocupado
+            if (fs.existsSync(ExecutionTracker.dataFile)) {
+                for (let retry = 0; retry < 3; retry++) {
+                    try {
+                        // Se backup existe, remover primeiro
+                        if (fs.existsSync(backupFile)) {
+                            fs.unlinkSync(backupFile);
+                        }
+                        // Fazer backup
+                        fs.copyFileSync(ExecutionTracker.dataFile, backupFile);
+                        backupSuccess = true;
+                        break;
+                    }
+                    catch (error) {
+                        if (error.code === 'EBUSY' && retry < 2) {
+                            // Esperar um pouco e tentar novamente (sem async/await para evitar problemas)
+                            const start = Date.now();
+                            while (Date.now() - start < 100) {
+                                // Busy wait for 100ms
+                            }
+                            continue;
+                        }
+                        // Ignorar erros de backup - não é crítico
+                        break;
+                    }
+                }
+            }
+            fs.writeFileSync(ExecutionTracker.dataFile, JSON.stringify(ExecutionTracker.data, null, 2));
+            // Log de debug detalhado
+            const stats = `APIs: ${ExecutionTracker.data.apis.length}, SSH: ${ExecutionTracker.data.ssh.length}, DB: ${ExecutionTracker.data.db.length}, UI: ${ExecutionTracker.data.ui.length}, Mobile: ${ExecutionTracker.data.mobile.length}`;
+            // ✅ VERIFICAÇÃO: Confirmar que arquivo foi salvo corretamente
+            if (fs.existsSync(ExecutionTracker.dataFile)) {
+                const savedSize = fs.statSync(ExecutionTracker.dataFile).size;
+                if (savedSize > 10) {
+                    // Arquivo deve ter pelo menos estrutura mínima
+                    // Remover backup após confirmação
+                    if (fs.existsSync(backupFile)) {
+                        fs.unlinkSync(backupFile);
+                    }
+                }
+                else {
+                    console.warn(`⚠️ ExecutionTracker: Arquivo muito pequeno (${savedSize} bytes), possível problema`);
+                    // Restaurar backup se houver
+                    if (fs.existsSync(backupFile)) {
+                        fs.copyFileSync(backupFile, ExecutionTracker.dataFile);
+                        console.log('🔄 ExecutionTracker: Backup restaurado');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(' ⚠️ AutoDocs: Erro ao salvar dados temporários:', error);
+        }
+        finally {
+            // SEMPRE resetar flag de execução
+            ExecutionTracker.isExecutingInternal = false;
+        }
+    }
+    /**
+     * 📖 Recuperar dados do arquivo
+     */
+    static loadFromFile() {
+        try {
+            if (fs.existsSync(ExecutionTracker.dataFile)) {
+                const fileData = fs.readFileSync(ExecutionTracker.dataFile, 'utf8');
+                const parsedData = JSON.parse(fileData);
+                const stats = `APIs: ${parsedData.apis?.length || 0}, SSH: ${parsedData.ssh?.length || 0}, DB: ${parsedData.db?.length || 0}, UI: ${parsedData.ui?.length || 0}, Mobile: ${parsedData.mobile?.length || 0}`;
+                return parsedData;
+            }
+            console.log('📊 ExecutionTracker.loadFromFile: Arquivo não existe');
+        }
+        catch (error) {
+            console.warn(`⚠️ ExecutionTracker.loadFromFile: Erro ao carregar dados: ${error}`);
+        }
+        return null;
+    }
+    /**
+     * 📋 Obter dados atuais (COM PROTEÇÃO CONTRA PERDA)
+     */
+    static getData() {
+        // ✅ PROTEÇÃO: Verificar se dados em memória estão vazios mas arquivo existe
+        const memoryTotal = ExecutionTracker.data.apis.length +
+            ExecutionTracker.data.ssh.length +
+            ExecutionTracker.data.db.length +
+            ExecutionTracker.data.ui.length +
+            ExecutionTracker.data.mobile.length;
+        // Tentar carregar do arquivo primeiro
+        const fileData = ExecutionTracker.loadFromFile();
+        if (fileData) {
+            const fileTotal = fileData.apis.length +
+                fileData.ssh.length +
+                fileData.db.length +
+                fileData.ui.length +
+                fileData.mobile.length;
+            // ✅ CRÍTICO: Se arquivo tem dados mas memória está vazia, usar arquivo
+            if (fileTotal > 0 && memoryTotal === 0) {
+                ExecutionTracker.data = fileData;
+                return fileData;
+            }
+            // ✅ NOVO: Se arquivo tem mais dados que memória, usar arquivo
+            if (fileTotal > memoryTotal) {
+                ExecutionTracker.data = fileData;
+                return fileData;
+            }
+            // ✅ MESCLAR: Se ambos têm dados, mesclar preservando o que for maior
+            if (fileTotal > 0 && memoryTotal > 0) {
+                // Usar o que tiver mais dados para cada categoria
+                const mergedData = {
+                    apis: fileData.apis.length >= ExecutionTracker.data.apis.length
+                        ? fileData.apis
+                        : ExecutionTracker.data.apis,
+                    ssh: fileData.ssh.length >= ExecutionTracker.data.ssh.length
+                        ? fileData.ssh
+                        : ExecutionTracker.data.ssh,
+                    db: fileData.db.length >= ExecutionTracker.data.db.length
+                        ? fileData.db
+                        : ExecutionTracker.data.db,
+                    ui: fileData.ui.length >= ExecutionTracker.data.ui.length
+                        ? fileData.ui
+                        : ExecutionTracker.data.ui,
+                    mobile: fileData.mobile.length >= ExecutionTracker.data.mobile.length
+                        ? fileData.mobile
+                        : ExecutionTracker.data.mobile,
+                    metadata: {
+                        ...ExecutionTracker.data.metadata,
+                        ...fileData.metadata,
+                        // Preservar contadores mais altos
+                        totalTests: Math.max(ExecutionTracker.data.metadata.totalTests, fileData.metadata.totalTests),
+                        passedTests: Math.max(ExecutionTracker.data.metadata.passedTests, fileData.metadata.passedTests),
+                        failedTests: Math.max(ExecutionTracker.data.metadata.failedTests, fileData.metadata.failedTests),
+                    },
+                };
+                ExecutionTracker.data = mergedData;
+                ExecutionTracker.saveToFile(); // Salvar dados mesclados
+                return mergedData;
+            }
+            return fileData;
+        }
+        // ✅ IMPORTANTE: Sempre salvar antes de retornar
+        if (memoryTotal > 0) {
+            ExecutionTracker.saveToFile();
+        }
+        return ExecutionTracker.data;
+    }
+    /**
+     * 🏁 Finalizar execução (PRESERVA TODOS OS DADOS)
+     */
+    static finalize() {
+        // Preservar dados atuais antes de qualquer alteração
+        const currentData = { ...ExecutionTracker.data };
+        // Apenas atualizar metadados de finalização
+        ExecutionTracker.data.metadata.endTime = new Date().toISOString();
+        ExecutionTracker.data.metadata.duration =
+            new Date(ExecutionTracker.data.metadata.endTime).getTime() -
+                new Date(ExecutionTracker.data.metadata.startTime).getTime();
+        // ✅ SALVAR: Forçar salvamento com dados preservados
+        ExecutionTracker.saveToFile();
+    }
+    /**
+     * 🧹 Limpar dados (APENAS EM DESENVOLVIMENTO - NUNCA EM PRODUÇÃO)
+     */
+    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_EXECUTION_TRACKER_RESET === 'true';
+        if (isProduction && !forceReset) {
+            console.warn('⚠️ ExecutionTracker.reset: Ignorado em produção. Use FORCE_EXECUTION_TRACKER_RESET=true se necessário');
+            return;
+        }
+        console.log('⚠️ ExecutionTracker.reset: LIMPANDO TODOS OS DADOS - Esta ação é irreversível!');
+        // Backup antes de resetar
+        if (fs.existsSync(ExecutionTracker.dataFile)) {
+            const backupFile = ExecutionTracker.dataFile + '.reset-backup-' + Date.now();
+            try {
+                fs.copyFileSync(ExecutionTracker.dataFile, backupFile);
+                console.log(`💾 ExecutionTracker.reset: Backup criado em ${backupFile}`);
+            }
+            catch (error) {
+                console.warn(`⚠️ ExecutionTracker.reset: Falha ao criar backup: ${error}`);
+            }
+        }
+        ExecutionTracker.data = {
+            apis: [],
+            ssh: [],
+            db: [],
+            ui: [],
+            mobile: [],
+            metadata: {
+                startTime: new Date().toISOString(),
+                endTime: '',
+                environment: process.env.NODE_ENV || 'development',
+                totalTests: 0,
+                passedTests: 0,
+                failedTests: 0,
+                framework: '@silasfmartins/testhub',
+                version: ExecutionTracker.getAutoCoreVersion(),
+                projectName: 'AutoCore Project',
+                projectType: 'Mixed',
+                duration: 0,
+            },
+        };
+        // Remover arquivo temporário
+        if (fs.existsSync(ExecutionTracker.dataFile)) {
+            fs.unlinkSync(ExecutionTracker.dataFile);
+        }
+        console.log('🧹 ExecutionTracker.reset: Reset concluído');
+    }
+    /**
+     * ⚙️ Configurar opções
+     */
+    static configure(config) {
+        ExecutionTracker.config = { ...ExecutionTracker.config, ...config };
+    }
+    /**
+     * 📊 Obter configuração atual
+     */
+    static getConfig() {
+        return ExecutionTracker.config;
+    }
+    /**
+     * 📈 Obter estatísticas rápidas
+     */
+    static getStats() {
+        const data = ExecutionTracker.getData();
+        return {
+            totalActions: data.apis.length +
+                data.ssh.length +
+                data.db.length +
+                data.ui.length +
+                data.mobile.length,
+            categories: [
+                { name: 'API', count: data.apis.length },
+                { name: 'SSH', count: data.ssh.length },
+                { name: 'Database', count: data.db.length },
+                { name: 'UI', count: data.ui.length },
+                { name: 'Mobile', count: data.mobile.length },
+            ].filter((cat) => cat.count > 0),
+            duration: data.metadata.duration,
+        };
+    }
+}