@silasfmartins/testhub 1.0.0

package/dist/src/hubdocs/DirectStatementInterceptor.js

@@ -0,0 +1,243 @@
+/**
+ * 🎯 SISTEMA DIRETO DE INTERCEPTAÇÃO V2
+ *
+ * Sistema simplificado que intercepta DIRETAMENTE as classes Statement do usuário
+ * Foca apenas no que funciona, sem complexidade desnecessária
+ */
+import { StatementTracker } from './StatementTracker.js';
+class DirectStatementInterceptor {
+    static initialized = false;
+    static interceptedClasses = new Set();
+    /**
+     * 🚀 Inicializar interceptação direta
+     */
+    static initialize() {
+        if (DirectStatementInterceptor.initialized)
+            return;
+        DirectStatementInterceptor.initialized = true;
+        console.log('🎯 [DirectInterceptor] Inicializando sistema direto...');
+        // 1. Interceptar imediatamente qualquer classe que contenha "Statement" no nome
+        DirectStatementInterceptor.interceptGlobalClasses();
+        // 2. 🆕 NOVA: Interceptar instanciações dinâmicas com 'new'
+        DirectStatementInterceptor.setupNewInterceptor();
+        // 3. Configurar interceptação via constructor hooks
+        DirectStatementInterceptor.setupConstructorHooks();
+        // 4. Configurar scanner contínuo para novas classes
+        DirectStatementInterceptor.setupContinuousScanner();
+        console.log('✅ [DirectInterceptor] Sistema direto ativo!');
+    }
+    /**
+     * 🆕 INTERCEPTAR INSTANCIAÇÕES DINÂMICAS - VERSÃO SIMPLIFICADA
+     */
+    static setupNewInterceptor() {
+        console.log('🎯 [DirectInterceptor] Configurando interceptação agressiva de instanciações...');
+        // Scanner mais agressivo para capturar classes que são carregadas dinamicamente
+        const aggressiveScanInterval = setInterval(() => {
+            DirectStatementInterceptor.aggressiveScanForStatements();
+        }, 500); // Scan a cada 500ms - muito mais frequente
+        // Scanner por módulos carregados
+        const moduleScanInterval = setInterval(() => {
+            DirectStatementInterceptor.scanLoadedModules();
+        }, 1000);
+        // Limpar scanners após 20 segundos
+        setTimeout(() => {
+            clearInterval(aggressiveScanInterval);
+            clearInterval(moduleScanInterval);
+            console.log('🎯 [DirectInterceptor] Scanners agressivos finalizados');
+        }, 20_000);
+        console.log('✅ [DirectInterceptor] Interceptação agressiva configurada');
+    }
+    /**
+     * 🔍 Scan agressivo por classes Statement (mais frequente)
+     */
+    static aggressiveScanForStatements() {
+        // Escanear propriedades globais
+        for (const name of Object.getOwnPropertyNames(globalThis)) {
+            if (name.startsWith('Statements') &&
+                !DirectStatementInterceptor.interceptedClasses.has(name)) {
+                try {
+                    const obj = globalThis[name];
+                    if (typeof obj === 'function') {
+                        console.log(`🆕 [DirectInterceptor] CLASSE STATEMENT DETECTADA: ${name}`);
+                        DirectStatementInterceptor.interceptClass(obj, name);
+                    }
+                }
+                catch (error) {
+                    // Ignorar erros
+                }
+            }
+        }
+        // Escanear também no global object
+        if (typeof global !== 'undefined') {
+            for (const name of Object.getOwnPropertyNames(global)) {
+                if (name.startsWith('Statements') &&
+                    !DirectStatementInterceptor.interceptedClasses.has(name)) {
+                    try {
+                        const obj = global[name];
+                        if (typeof obj === 'function') {
+                            console.log(`🆕 [DirectInterceptor] CLASSE STATEMENT DETECTADA (global): ${name}`);
+                            DirectStatementInterceptor.interceptClass(obj, name);
+                        }
+                    }
+                    catch (error) {
+                        // Ignorar erros
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 🔍 Escanear módulos carregados
+     */
+    static scanLoadedModules() {
+        // Tentar acessar require.cache se disponível (Node.js)
+        try {
+            if (typeof require !== 'undefined' && require.cache) {
+                for (const modulePath of Object.keys(require.cache)) {
+                    if (modulePath.includes('Statement') && modulePath.includes('.js')) {
+                        const moduleExports = require.cache[modulePath]?.exports;
+                        if (moduleExports && typeof moduleExports === 'object') {
+                            for (const [exportName, exportValue] of Object.entries(moduleExports)) {
+                                if (exportName.startsWith('Statements') &&
+                                    typeof exportValue === 'function' &&
+                                    !DirectStatementInterceptor.interceptedClasses.has(exportName)) {
+                                    console.log(`🆕 [DirectInterceptor] CLASSE DO MÓDULO DETECTADA: ${exportName}`);
+                                    DirectStatementInterceptor.interceptClass(exportValue, exportName);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // require.cache pode não estar disponível em todos os ambientes
+        }
+    }
+    /**
+     * 🔍 Interceptar classes globais existentes
+     */
+    static interceptGlobalClasses() {
+        // Buscar em globalThis por qualquer classe que termine com Statement
+        Object.getOwnPropertyNames(globalThis).forEach((name) => {
+            try {
+                const obj = globalThis[name];
+                if (typeof obj === 'function' &&
+                    name.includes('Statement') &&
+                    !name.includes('Base')) {
+                    console.log(`🎯 [DirectInterceptor] Classe encontrada: ${name}`);
+                    DirectStatementInterceptor.interceptClass(obj, name);
+                }
+            }
+            catch (error) {
+                // Ignorar erros
+            }
+        });
+    }
+    /**
+     * 🏗️ Setup de hooks simplificado
+     */
+    static setupConstructorHooks() {
+        // Sistema simplificado - apenas logging
+        console.log('🎯 [DirectInterceptor] Hooks configurados (modo simplificado)');
+    }
+    /**
+     * 🔄 Scanner contínuo para novas classes
+     */
+    static setupContinuousScanner() {
+        const scanInterval = setInterval(() => {
+            DirectStatementInterceptor.scanForNewClasses();
+        }, 2000);
+        // Limpar após 30 segundos para não consumir recursos
+        setTimeout(() => {
+            clearInterval(scanInterval);
+            console.log('🎯 [DirectInterceptor] Scanner contínuo finalizado');
+        }, 30_000);
+    }
+    /**
+     * 🔍 Escanear por novas classes
+     */
+    static scanForNewClasses() {
+        Object.getOwnPropertyNames(globalThis).forEach((name) => {
+            if (name.includes('Statement') &&
+                !name.includes('Base') &&
+                !DirectStatementInterceptor.interceptedClasses.has(name)) {
+                try {
+                    const obj = globalThis[name];
+                    if (typeof obj === 'function') {
+                        console.log(`🎯 [DirectInterceptor] Nova classe detectada no scan: ${name}`);
+                        DirectStatementInterceptor.interceptClass(obj, name);
+                    }
+                }
+                catch (error) {
+                    // Ignorar erros
+                }
+            }
+        });
+    }
+    /**
+     * 🎯 Interceptar uma classe específica
+     */
+    static interceptClass(StatementClass, className) {
+        if (DirectStatementInterceptor.interceptedClasses.has(className))
+            return;
+        DirectStatementInterceptor.interceptedClasses.add(className);
+        console.log(`🔥 [DirectInterceptor] Interceptando ${className}...`);
+        try {
+            // Interceptar todos os métodos do prototype
+            const prototype = StatementClass.prototype;
+            if (!prototype)
+                return;
+            const methodNames = Object.getOwnPropertyNames(prototype);
+            for (const methodName of methodNames) {
+                if (methodName === 'constructor' || methodName.startsWith('_'))
+                    continue;
+                try {
+                    const originalMethod = prototype[methodName];
+                    if (typeof originalMethod !== 'function')
+                        continue;
+                    // Criar wrapper do método
+                    prototype[methodName] = async function (...args) {
+                        console.log(`🎯 [DirectInterceptor] Executando ${className}.${methodName}`);
+                        // Registrar início do CT
+                        const timestamp = StatementTracker.startStatement(className, methodName);
+                        try {
+                            // Executar método original
+                            const result = await originalMethod.apply(this, args);
+                            // Registrar sucesso
+                            StatementTracker.finishStatement(timestamp, true);
+                            console.log(`✅ [DirectInterceptor] ${className}.${methodName} concluído com sucesso`);
+                            return result;
+                        }
+                        catch (error) {
+                            // Registrar falha
+                            StatementTracker.finishStatement(timestamp, false, String(error));
+                            console.log(`❌ [DirectInterceptor] ${className}.${methodName} falhou: ${error}`);
+                            throw error;
+                        }
+                    };
+                    console.log(`✅ [DirectInterceptor] Método ${className}.${methodName} interceptado`);
+                }
+                catch (error) {
+                    console.log(`⚠️ [DirectInterceptor] Erro ao interceptar ${className}.${methodName}:`, error);
+                }
+            }
+            console.log(`🎯 [DirectInterceptor] Classe ${className} completamente interceptada!`);
+        }
+        catch (error) {
+            console.log(`❌ [DirectInterceptor] Erro ao interceptar classe ${className}:`, error);
+        }
+    }
+    /**
+     * 📊 Status do interceptor
+     */
+    static getStatus() {
+        return {
+            initialized: DirectStatementInterceptor.initialized,
+            interceptedClasses: Array.from(DirectStatementInterceptor.interceptedClasses),
+        };
+    }
+}
+export { DirectStatementInterceptor };
+// Auto-inicialização (uma única vez, guardada por flag interna)
+DirectStatementInterceptor.initialize();

package/dist/src/hubdocs/ExecutionTracker.d.ts

@@ -0,0 +1,107 @@
+/**
+ * 🔍 ExecutionTracker - Interceptador Principal
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+import type { APICall, DBQuery, DocsConfig, ExecutionData, MobileAction, SSHCommand, UIAction } from './types.js';
+export declare class ExecutionTracker {
+    private static isExecutingInternal;
+    /**
+     * 🔗 HOOK: Notificar StatementTracker sobre ações executadas
+     */
+    private static notifyStatementTracker;
+    /**
+     * ✅ NOVO: Obter versão atual do AutoCore (com proteção contra recursão)
+     */
+    private static getAutoCoreVersion;
+    private static data;
+    private static config;
+    private static tempDir;
+    private static dataFile;
+    /**
+     * ✅ Inicializar o tracker
+     */
+    static initialize(projectName?: string, projectType?: string): void;
+    /**
+     * ✅ NOVO: Detectar nome do projeto a partir do caminho
+     */
+    private static detectProjectNameFromPath;
+    /**
+     * ✅ NOVO: Detectar tipo de projeto automaticamente
+     */
+    private static detectProjectType;
+    /**
+     * 🌐 Rastrear chamada de API
+     */
+    static trackAPI(call: APICall): void;
+    /**
+     * 🔄 Atualizar resultado de API específica
+     */
+    static updateAPIResult(docId: string, response?: any, statusCode?: number, error?: any): void;
+    /**
+     * 🖥️ Rastrear comando SSH
+     */
+    static trackSSH(command: SSHCommand): void;
+    /**
+     * 🔄 Atualizar resultado de comando SSH específico
+     */
+    static updateSSHResult(command: string, timestamp: string, success: boolean, duration: number, exitCode?: number, error?: string): void;
+    /**
+     * 🗄️ Rastrear query de banco
+     */
+    static trackDB(query: DBQuery): void;
+    /**
+     * 🔄 Atualizar resultado de query de banco específica
+     */
+    static updateDBResult(query: string, timestamp: string, success: boolean, duration: number, error?: string, resultCount?: number): void;
+    /**
+     * 🎨 Rastrear ação de UI
+     */
+    static trackUI(action: UIAction): void;
+    /**
+     * 📱 Rastrear ação mobile
+     */
+    static trackMobile(action: MobileAction): void;
+    /**
+     * 📊 Atualizar estatísticas de testes
+     */
+    static updateTestStats(total: number, passed: number, failed: number): void;
+    /**
+     * 💾 Salvar dados em arquivo temporário (COM PROTEÇÃO CONTRA PERDA)
+     */
+    private static saveToFile;
+    /**
+     * 📖 Recuperar dados do arquivo
+     */
+    static loadFromFile(): ExecutionData | null;
+    /**
+     * 📋 Obter dados atuais (COM PROTEÇÃO CONTRA PERDA)
+     */
+    static getData(): ExecutionData;
+    /**
+     * 🏁 Finalizar execução (PRESERVA TODOS OS DADOS)
+     */
+    static finalize(): void;
+    /**
+     * 🧹 Limpar dados (APENAS EM DESENVOLVIMENTO - NUNCA EM PRODUÇÃO)
+     */
+    static reset(): void;
+    /**
+     * ⚙️ Configurar opções
+     */
+    static configure(config: Partial<DocsConfig>): void;
+    /**
+     * 📊 Obter configuração atual
+     */
+    static getConfig(): DocsConfig;
+    /**
+     * 📈 Obter estatísticas rápidas
+     */
+    static getStats(): {
+        totalActions: number;
+        categories: {
+            name: string;
+            count: number;
+        }[];
+        duration: number;
+    };
+}