@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,83 @@
+/**
+ * 🔍 CategoryDetector - Detector Automático de Categorias
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+export interface DetectedCategory {
+    type: 'api' | 'ssh' | 'db' | 'ui' | 'mobile' | 'mixed';
+    confidence: number;
+    indicators: string[];
+    suggestedTitle: string;
+}
+export declare class CategoryDetector {
+    private static readonly API_INDICATORS;
+    private static readonly SSH_INDICATORS;
+    private static readonly DB_INDICATORS;
+    private static readonly UI_INDICATORS;
+    private static readonly MOBILE_INDICATORS;
+    /**
+     * 🎯 Detectar categoria principal do arquivo de teste
+     */
+    static detectFromFile(filePath: string): DetectedCategory;
+    /**
+     * 🔍 Detectar categoria pelo conteúdo
+     */
+    static detectFromContent(content: string, fileName?: string): DetectedCategory;
+    /**
+     * 📁 Detectar categoria pelo nome do arquivo
+     */
+    static detectFromFileName(fileName: string): DetectedCategory;
+    /**
+     * 📊 Detectar múltiplas categorias em um projeto
+     */
+    static detectFromProject(projectPath: string): {
+        [category: string]: string[];
+    };
+    /**
+     * 🔬 Análise principal do conteúdo
+     */
+    private static analyzeContent;
+    /**
+     * 🎯 Calcular pontuação para indicadores
+     */
+    private static calculateScore;
+    /**
+     * 🔍 Encontrar indicadores que fizeram match
+     */
+    private static getMatchedIndicators;
+    /**
+     * 🏷️ Obter indicadores para tipo
+     */
+    private static getIndicatorsForType;
+    /**
+     * 📝 Obter título para tipo
+     */
+    private static getTitleForType;
+    /**
+     * 📁 Encontrar arquivos de teste
+     */
+    private static findTestFiles;
+    /**
+     * 🚫 Verificar se deve pular diretório
+     */
+    private static shouldSkipDirectory;
+    /**
+     * ✅ Verificar se é arquivo de teste
+     */
+    private static isTestFile;
+    /**
+     * 🎯 Criar categoria padrão
+     */
+    private static createDefaultCategory;
+    /**
+     * 📊 Obter estatísticas de detecção
+     */
+    static getDetectionStats(projectPath: string): {
+        totalFiles: number;
+        categorized: {
+            [category: string]: number;
+        };
+        confidence: {
+            [category: string]: number;
+        };
+    };
+}

package/dist/src/hubdocs/CategoryDetector.js

@@ -0,0 +1,401 @@
+/**
+ * 🔍 CategoryDetector - Detector Automático de Categorias
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { Logger } from '../utils/Logger.js';
+export class CategoryDetector {
+    static API_INDICATORS = [
+        'fetch',
+        'axios',
+        'request',
+        'post',
+        'get',
+        'put',
+        'delete',
+        'patch',
+        'RestAssured',
+        'given()',
+        'when()',
+        'then()',
+        'ApiActions',
+        'JsonResponse',
+        'REST',
+        'endpoint',
+        'statusCode',
+        'response',
+        'payload',
+        'headers',
+    ];
+    static SSH_INDICATORS = [
+        'ssh',
+        'SSHActions',
+        'SSHClient',
+        'executeCommand',
+        'shell',
+        'terminal',
+        'remote',
+        'host',
+        'server',
+        'linux',
+        'unix',
+        'bash',
+        'sudo',
+        'exec',
+    ];
+    static DB_INDICATORS = [
+        'SELECT',
+        'INSERT',
+        'UPDATE',
+        'DELETE',
+        'CREATE',
+        'DROP',
+        'database',
+        'query',
+        'sql',
+        'BancoActions',
+        'BancoHelper',
+        'connection',
+        'execute',
+        'prepare',
+        'transaction',
+        'mysql',
+        'postgres',
+        'oracle',
+        'sqlserver',
+        'mongodb',
+    ];
+    static UI_INDICATORS = [
+        'page.',
+        'click',
+        'fill',
+        'select',
+        'hover',
+        'navigate',
+        'playwright',
+        'selenium',
+        'WebActions',
+        'element',
+        'locator',
+        'waitFor',
+        'screenshot',
+        'browser',
+        'input',
+        'button',
+        'form',
+        'dialog',
+    ];
+    static MOBILE_INDICATORS = [
+        'appium',
+        'MobileActions',
+        'MobileConnection',
+        'device',
+        'android',
+        'ios',
+        'mobile',
+        'app',
+        'touch',
+        'swipe',
+        'driver',
+        'capabilities',
+        'platform',
+        'simulator',
+        'emulator',
+        'tap',
+        'scroll',
+    ];
+    /**
+     * 🎯 Detectar categoria principal do arquivo de teste
+     */
+    static detectFromFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return CategoryDetector.createDefaultCategory();
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            const fileName = path.basename(filePath);
+            return CategoryDetector.analyzeContent(content, fileName);
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao detectar categoria do arquivo ${filePath}: ${error}`);
+            return CategoryDetector.createDefaultCategory();
+        }
+    }
+    /**
+     * 🔍 Detectar categoria pelo conteúdo
+     */
+    static detectFromContent(content, fileName) {
+        return CategoryDetector.analyzeContent(content, fileName || 'unknown.ts');
+    }
+    /**
+     * 📁 Detectar categoria pelo nome do arquivo
+     */
+    static detectFromFileName(fileName) {
+        const name = fileName.toLowerCase();
+        // Indicadores diretos no nome do arquivo
+        if (name.includes('api') ||
+            name.includes('rest') ||
+            name.includes('endpoint')) {
+            return {
+                type: 'api',
+                confidence: 0.8,
+                indicators: ['filename contains api/rest/endpoint'],
+                suggestedTitle: 'API Tests',
+            };
+        }
+        if (name.includes('ssh') ||
+            name.includes('remote') ||
+            name.includes('server')) {
+            return {
+                type: 'ssh',
+                confidence: 0.8,
+                indicators: ['filename contains ssh/remote/server'],
+                suggestedTitle: 'SSH Tests',
+            };
+        }
+        if (name.includes('db') ||
+            name.includes('database') ||
+            name.includes('sql') ||
+            name.includes('banco')) {
+            return {
+                type: 'db',
+                confidence: 0.8,
+                indicators: ['filename contains db/database/sql/banco'],
+                suggestedTitle: 'Database Tests',
+            };
+        }
+        if (name.includes('ui') ||
+            name.includes('web') ||
+            name.includes('page') ||
+            name.includes('browser')) {
+            return {
+                type: 'ui',
+                confidence: 0.8,
+                indicators: ['filename contains ui/web/page/browser'],
+                suggestedTitle: 'UI Tests',
+            };
+        }
+        if (name.includes('mobile') ||
+            name.includes('app') ||
+            name.includes('android') ||
+            name.includes('ios')) {
+            return {
+                type: 'mobile',
+                confidence: 0.8,
+                indicators: ['filename contains mobile/app/android/ios'],
+                suggestedTitle: 'Mobile Tests',
+            };
+        }
+        return CategoryDetector.createDefaultCategory();
+    }
+    /**
+     * 📊 Detectar múltiplas categorias em um projeto
+     */
+    static detectFromProject(projectPath) {
+        const categories = {
+            api: [],
+            ssh: [],
+            db: [],
+            ui: [],
+            mobile: [],
+            mixed: [],
+        };
+        try {
+            const testFiles = CategoryDetector.findTestFiles(projectPath);
+            for (const file of testFiles) {
+                const detection = CategoryDetector.detectFromFile(file);
+                categories[detection.type].push(file);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao detectar categorias do projeto: ${error}`);
+        }
+        return categories;
+    }
+    /**
+     * 🔬 Análise principal do conteúdo
+     */
+    static analyzeContent(content, fileName) {
+        const scores = {
+            api: CategoryDetector.calculateScore(content, CategoryDetector.API_INDICATORS),
+            ssh: CategoryDetector.calculateScore(content, CategoryDetector.SSH_INDICATORS),
+            db: CategoryDetector.calculateScore(content, CategoryDetector.DB_INDICATORS),
+            ui: CategoryDetector.calculateScore(content, CategoryDetector.UI_INDICATORS),
+            mobile: CategoryDetector.calculateScore(content, CategoryDetector.MOBILE_INDICATORS),
+        };
+        // Adicionar peso baseado no nome do arquivo
+        const fileDetection = CategoryDetector.detectFromFileName(fileName);
+        if (fileDetection.confidence > 0.5 && fileDetection.type !== 'mixed') {
+            scores[fileDetection.type] += 20;
+        }
+        // Encontrar categoria dominante
+        const topCategory = Object.entries(scores).reduce((max, [category, score]) => score > max.score ? { category: category, score } : max, { category: 'mixed', score: 0 });
+        // Verificar se há múltiplas categorias significativas
+        const significantCategories = Object.entries(scores).filter(([_, score]) => score > 10);
+        if (significantCategories.length > 1) {
+            return {
+                type: 'mixed',
+                confidence: 0.7,
+                indicators: significantCategories.map(([cat, score]) => `${cat}: ${score} points`),
+                suggestedTitle: 'Mixed Tests',
+            };
+        }
+        if (topCategory.score < 5) {
+            return CategoryDetector.createDefaultCategory();
+        }
+        return {
+            type: topCategory.category,
+            confidence: Math.min(topCategory.score / 50, 1),
+            indicators: CategoryDetector.getMatchedIndicators(content, CategoryDetector.getIndicatorsForType(topCategory.category)),
+            suggestedTitle: CategoryDetector.getTitleForType(topCategory.category),
+        };
+    }
+    /**
+     * 🎯 Calcular pontuação para indicadores
+     */
+    static calculateScore(content, indicators) {
+        let score = 0;
+        const contentLower = content.toLowerCase();
+        for (const indicator of indicators) {
+            const regex = new RegExp(indicator.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+            const matches = contentLower.match(regex);
+            if (matches) {
+                // Pontuação baseada na frequência, com peso decrescente
+                score += Math.min(matches.length * 2, 10);
+            }
+        }
+        return score;
+    }
+    /**
+     * 🔍 Encontrar indicadores que fizeram match
+     */
+    static getMatchedIndicators(content, indicators) {
+        const contentLower = content.toLowerCase();
+        return indicators
+            .filter((indicator) => contentLower.includes(indicator.toLowerCase()))
+            .slice(0, 5); // Limitar a 5 indicadores
+    }
+    /**
+     * 🏷️ Obter indicadores para tipo
+     */
+    static getIndicatorsForType(type) {
+        switch (type) {
+            case 'api':
+                return CategoryDetector.API_INDICATORS;
+            case 'ssh':
+                return CategoryDetector.SSH_INDICATORS;
+            case 'db':
+                return CategoryDetector.DB_INDICATORS;
+            case 'ui':
+                return CategoryDetector.UI_INDICATORS;
+            case 'mobile':
+                return CategoryDetector.MOBILE_INDICATORS;
+            default:
+                return [];
+        }
+    }
+    /**
+     * 📝 Obter título para tipo
+     */
+    static getTitleForType(type) {
+        const titles = {
+            api: 'API Tests',
+            ssh: 'SSH Commands',
+            db: 'Database Operations',
+            ui: 'UI Interactions',
+            mobile: 'Mobile Actions',
+        };
+        return titles[type] || 'Test Suite';
+    }
+    /**
+     * 📁 Encontrar arquivos de teste
+     */
+    static findTestFiles(projectPath) {
+        const testFiles = [];
+        const searchInDir = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory() &&
+                        !CategoryDetector.shouldSkipDirectory(entry.name)) {
+                        searchInDir(fullPath);
+                    }
+                    else if (entry.isFile() &&
+                        CategoryDetector.isTestFile(entry.name)) {
+                        testFiles.push(fullPath);
+                    }
+                }
+            }
+            catch (error) {
+                // Ignorar diretórios inacessíveis
+            }
+        };
+        searchInDir(projectPath);
+        return testFiles;
+    }
+    /**
+     * 🚫 Verificar se deve pular diretório
+     */
+    static shouldSkipDirectory(dirName) {
+        const skipDirs = [
+            'node_modules',
+            '.git',
+            'dist',
+            'build',
+            'coverage',
+            '.next',
+            '.nuxt',
+            'vendor',
+            '__pycache__',
+            '.pytest_cache',
+        ];
+        return skipDirs.includes(dirName) || dirName.startsWith('.');
+    }
+    /**
+     * ✅ Verificar se é arquivo de teste
+     */
+    static isTestFile(fileName) {
+        const testPatterns = [
+            /\.test\.(ts|js|tsx|jsx)$/,
+            /\.spec\.(ts|js|tsx|jsx)$/,
+            /test.*\.(ts|js|tsx|jsx)$/,
+            /spec.*\.(ts|js|tsx|jsx)$/,
+        ];
+        return testPatterns.some((pattern) => pattern.test(fileName));
+    }
+    /**
+     * 🎯 Criar categoria padrão
+     */
+    static createDefaultCategory() {
+        return {
+            type: 'mixed',
+            confidence: 0.1,
+            indicators: ['no clear indicators found'],
+            suggestedTitle: 'General Tests',
+        };
+    }
+    /**
+     * 📊 Obter estatísticas de detecção
+     */
+    static getDetectionStats(projectPath) {
+        const categories = CategoryDetector.detectFromProject(projectPath);
+        const stats = {
+            totalFiles: 0,
+            categorized: {},
+            confidence: {},
+        };
+        Object.entries(categories).forEach(([category, files]) => {
+            stats.categorized[category] = files.length;
+            stats.totalFiles += files.length;
+            // Calcular confiança média para a categoria
+            if (files.length > 0) {
+                const confidences = files.map((file) => CategoryDetector.detectFromFile(file).confidence);
+                stats.confidence[category] =
+                    confidences.reduce((sum, conf) => sum + conf, 0) / confidences.length;
+            }
+        });
+        return stats;
+    }
+}

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

@@ -0,0 +1,54 @@
+/**
+ * 🎯 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
+ */
+declare class DirectStatementInterceptor {
+    private static initialized;
+    private static interceptedClasses;
+    /**
+     * 🚀 Inicializar interceptação direta
+     */
+    static initialize(): void;
+    /**
+     * 🆕 INTERCEPTAR INSTANCIAÇÕES DINÂMICAS - VERSÃO SIMPLIFICADA
+     */
+    private static setupNewInterceptor;
+    /**
+     * 🔍 Scan agressivo por classes Statement (mais frequente)
+     */
+    private static aggressiveScanForStatements;
+    /**
+     * 🔍 Escanear módulos carregados
+     */
+    private static scanLoadedModules;
+    /**
+     * 🔍 Interceptar classes globais existentes
+     */
+    private static interceptGlobalClasses;
+    /**
+     * 🏗️ Setup de hooks simplificado
+     */
+    private static setupConstructorHooks;
+    /**
+     * 🔄 Scanner contínuo para novas classes
+     */
+    private static setupContinuousScanner;
+    /**
+     * 🔍 Escanear por novas classes
+     */
+    private static scanForNewClasses;
+    /**
+     * 🎯 Interceptar uma classe específica
+     */
+    private static interceptClass;
+    /**
+     * 📊 Status do interceptor
+     */
+    static getStatus(): {
+        initialized: boolean;
+        interceptedClasses: string[];
+    };
+}
+export { DirectStatementInterceptor };