@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,71 @@
+/**
+ * 🎯 StatementMethodFilter - Sistema Inteligente de Detecção de Métodos Statement
+ *
+ * Sistema mais permissivo que detecta métodos CT mesmo com padrões complexos:
+ * - Métodos com nomes diversos (executeAction, performTask, runOperation, etc.)
+ * - Métodos aninhados em classes complexas
+ * - Métodos gerados dinamicamente
+ * - Padrões de naming variados
+ */
+interface StatementClass {
+    name: string;
+    constructor: any;
+    methods: string[];
+    confidence: number;
+}
+declare class StatementMethodFilter {
+    private static initialized;
+    private static methodPatterns;
+    private static classPatterns;
+    private static excludedMethods;
+    private static nativeClassBlacklist;
+    /**
+     * 🚀 Inicializar filtros inteligentes
+     */
+    static initialize(): void;
+    /**
+     * 📊 Calcular score de um método
+     */
+    static calculateMethodScore(methodName: string, className?: string): number;
+    /**
+     * ✅ Verificar se método é provavelmente um CT
+     * ✅ REATIVADO - Filtrar baseado no nome da classe e método
+     */
+    static isLikelyStatementMethod(methodName: string, className?: string): boolean;
+    /**
+     * 🚫 Verificar se classe é nativa e deve ser ignorada
+     * ✅ REATIVADO - Bloquear classes nativas para evitar stack overflow e CTs falsos
+     */
+    static isNativeClassBlacklisted(className: string): boolean;
+    /**
+     * 🛡️ Análise segura de classe (evita ERR_INVALID_THIS)
+     */
+    static safeAnalyzeClass(classConstructor: any, className: string): StatementClass;
+    /**
+     * �🔍 Analisar classe e extrair métodos CT
+     */
+    static analyzeClass(classConstructor: any, className: string): StatementClass;
+    /**
+     * 🎯 Filtro para todos os métodos de uma classe
+     * ✅ REATIVADO - Usar filtros para bloquear classes nativas e aprovar apenas CTs reais
+     */
+    static filterClassMethods(classConstructor: any, className: string): string[];
+    /**
+     * 📊 Obter estatísticas dos filtros
+     */
+    static getFilterStats(): {
+        patterns: number;
+        classPatterns: number;
+        excludedMethods: number;
+        totalPatterns: number;
+    };
+    /**
+     * 🔧 Adicionar padrão customizado
+     */
+    static addCustomPattern(pattern: RegExp, weight: number, description: string): void;
+    /**
+     * 🎯 Modo debug - mostrar análise detalhada
+     */
+    static debugAnalyzeMethod(methodName: string, className?: string): void;
+}
+export { StatementMethodFilter };

package/dist/src/hubdocs/StatementMethodFilter.js

@@ -0,0 +1,618 @@
+/**
+ * 🎯 StatementMethodFilter - Sistema Inteligente de Detecção de Métodos Statement
+ *
+ * Sistema mais permissivo que detecta métodos CT mesmo com padrões complexos:
+ * - Métodos com nomes diversos (executeAction, performTask, runOperation, etc.)
+ * - Métodos aninhados em classes complexas
+ * - Métodos gerados dinamicamente
+ * - Padrões de naming variados
+ */
+class StatementMethodFilter {
+    static initialized = false;
+    // Padrões de métodos que provavelmente são CTs
+    static methodPatterns = [
+        // 🎯 PADRÕES DO SEU PROJETO - Métodos específicos observados nos logs
+        { pattern: /^getToken$/i, weight: 15, description: 'Token methods' },
+        {
+            pattern: /^consulta/i,
+            weight: 15,
+            description: 'Consulta methods (consultaCobertura, consultaEndereco, etc.)',
+        },
+        { pattern: /^solicita/i, weight: 15, description: 'Solicita methods' },
+        {
+            pattern: /^check/i,
+            weight: 15,
+            description: 'Check methods (checkServiceQualification, etc.)',
+        },
+        { pattern: /^reserva/i, weight: 15, description: 'Reserva methods' },
+        { pattern: /^alocar/i, weight: 15, description: 'Alocar methods' },
+        { pattern: /^configurar$/i, weight: 15, description: 'Configurar methods' },
+        // 🎯 PADRÕES EXPLÍCITOS - Alta prioridade
+        { pattern: /^execute/i, weight: 10, description: 'Execute methods' },
+        { pattern: /^perform/i, weight: 9, description: 'Perform methods' },
+        { pattern: /^run/i, weight: 8, description: 'Run methods' },
+        { pattern: /^process/i, weight: 8, description: 'Process methods' },
+        { pattern: /^handle/i, weight: 7, description: 'Handle methods' },
+        { pattern: /^do/i, weight: 6, description: 'Do methods' },
+        { pattern: /^make/i, weight: 6, description: 'Make methods' },
+        { pattern: /^create/i, weight: 6, description: 'Create methods' },
+        { pattern: /^send/i, weight: 7, description: 'Send methods' },
+        { pattern: /^get/i, weight: 5, description: 'Get methods' },
+        { pattern: /^post/i, weight: 6, description: 'Post methods' },
+        { pattern: /^put/i, weight: 6, description: 'Put methods' },
+        { pattern: /^delete/i, weight: 6, description: 'Delete methods' },
+        // Padrões por tipo de ação
+        {
+            pattern: /login|auth|signin/i,
+            weight: 8,
+            description: 'Authentication methods',
+        },
+        {
+            pattern: /request|call|invoke/i,
+            weight: 7,
+            description: 'Request methods',
+        },
+        {
+            pattern: /query|select|insert|update/i,
+            weight: 7,
+            description: 'Database methods',
+        },
+        {
+            pattern: /click|type|scroll|nav/i,
+            weight: 7,
+            description: 'Web interaction methods',
+        },
+        { pattern: /ssh|command|shell/i, weight: 7, description: 'SSH methods' },
+        {
+            pattern: /mobile|touch|swipe|tap/i,
+            weight: 7,
+            description: 'Mobile methods',
+        },
+        // Padrões genéricos (menos peso)
+        { pattern: /action/i, weight: 5, description: 'Action methods' },
+        { pattern: /operation/i, weight: 5, description: 'Operation methods' },
+        { pattern: /task/i, weight: 5, description: 'Task methods' },
+        { pattern: /step/i, weight: 4, description: 'Step methods' },
+        { pattern: /method/i, weight: 3, description: 'Method methods' },
+        // Qualquer método público (peso baixo mas incluído)
+        { pattern: /^[a-z]/i, weight: 1, description: 'Public methods' },
+    ];
+    // Nomes de classe que provavelmente contêm CTs
+    static classPatterns = [
+        // 🎯 PADRÕES PRINCIPAIS - Seus projetos TypeScript
+        /^Statements/i, // StatementsToken, StatementsConsultaCobertura, etc.
+        /^Statement[A-Z]/i, // StatementAlocarConfigurar, etc.
+        // 🎯 PADRÕES SECUNDÁRIOS - Outros projetos
+        /statement/i,
+        /action/i,
+        /command/i,
+        /operation/i,
+        /task/i,
+        /service/i,
+        /handler/i,
+        /controller/i,
+        /processor/i,
+        /executor/i,
+        /manager/i,
+        /helper/i,
+        /utility/i,
+        /client/i,
+        /api/i,
+        /web/i,
+        /mobile/i,
+        /ssh/i,
+        /database/i,
+        /banco/i,
+    ];
+    // Métodos que definitivamente NÃO são CTs
+    static excludedMethods = new Set([
+        'constructor',
+        'toString',
+        'valueOf',
+        'hasOwnProperty',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'toLocaleString',
+        '__defineGetter__',
+        '__defineSetter__',
+        '__lookupGetter__',
+        '__lookupSetter__',
+        'bind',
+        'call',
+        'apply',
+        'length',
+        'name',
+        'prototype',
+        'then',
+        'catch',
+        'finally', // Promise methods
+        'on',
+        'off',
+        'emit',
+        'addEventListener',
+        'removeEventListener', // Event methods
+    ]);
+    // 🚫 BLACKLIST CRÍTICA: Classes que devem ser SEMPRE bloqueadas (causam stack overflow e CTs falsos)
+    static nativeClassBlacklist = new Set([
+        // 🚫 OBJETOS FUNDAMENTAIS - NUNCA INTERCEPTAR (causam stack overflow)
+        'Object',
+        'Date',
+        'Array',
+        'String',
+        'Number',
+        'Boolean',
+        'Function',
+        'RegExp',
+        'Math',
+        'JSON',
+        'Error',
+        'Promise',
+        'Map',
+        'Set',
+        'WeakMap',
+        'WeakSet',
+        'Symbol',
+        'Proxy',
+        'Reflect',
+        'console',
+        'BigInt',
+        'FinalizationRegistry',
+        'WeakRef',
+        // 🚫 GLOBAL OBJECTS - NUNCA INTERCEPTAR (são utilities globais)
+        'eval',
+        'parseInt',
+        'parseFloat',
+        'isNaN',
+        'isFinite',
+        'encodeURI',
+        'decodeURI',
+        'encodeURIComponent',
+        'decodeURIComponent',
+        'escape',
+        'unescape',
+        // 🚫 GLOBAL FUNCTIONS - NUNCA INTERCEPTAR
+        'clearInterval',
+        'clearTimeout',
+        'setInterval',
+        'setTimeout',
+        'queueMicrotask',
+        'structuredClone',
+        'atob',
+        'btoa',
+        'fetch',
+        // 🚫 NODE.JS INTERNALS - NUNCA INTERCEPTAR (causam erros críticos)
+        'process',
+        'global',
+        'Buffer',
+        'URL',
+        'URLSearchParams',
+        'TextEncoder',
+        'TextDecoder',
+        'AbortController',
+        'AbortSignal',
+        'Event',
+        'EventTarget',
+        'CustomEvent',
+        'Navigator',
+        // 🚫 WEB STREAMS API - CAUSAM ERR_INVALID_THIS (fonte dos erros atuais!)
+        'TransformStream',
+        'TransformStreamDefaultController',
+        'WritableStream',
+        'WritableStreamDefaultController',
+        'WritableStreamDefaultWriter',
+        'ReadableStream',
+        'ReadableStreamDefaultReader',
+        'ReadableStreamBYOBReader',
+        'ReadableStreamBYOBRequest',
+        'ReadableByteStreamController',
+        'ReadableStreamDefaultController',
+        'ByteLengthQueuingStrategy',
+        'CountQueuingStrategy',
+        'TextEncoderStream',
+        'TextDecoderStream',
+        'CompressionStream',
+        'DecompressionStream',
+        // 🚫 FETCH API - CAUSAM ILLEGAL INVOCATION
+        'BroadcastChannel',
+        'MessageChannel',
+        'MessagePort',
+        'MessageEvent',
+        'Blob',
+        'File',
+        'FormData',
+        'Headers',
+        'Request',
+        'Response',
+        'WebSocket',
+        'URLPattern',
+        // 🚫 PERFORMANCE API - CAUSAM ERR_INVALID_ARG_TYPE
+        'Performance',
+        'PerformanceEntry',
+        'PerformanceMark',
+        'PerformanceMeasure',
+        'PerformanceObserver',
+        'PerformanceObserverEntryList',
+        'PerformanceResourceTiming',
+        // 🚫 CRYPTO API - CAUSAM ERR_INVALID_THIS
+        'Crypto',
+        'CryptoKey',
+        'SubtleCrypto',
+        // 🚫 BUFFER E TYPED ARRAYS - CAUSAM INCOMPATIBLE RECEIVER
+        'ArrayBuffer',
+        'SharedArrayBuffer',
+        'DataView',
+        'Int8Array',
+        'Uint8Array',
+        'Uint8ClampedArray',
+        'Int16Array',
+        'Uint16Array',
+        'Int32Array',
+        'Uint32Array',
+        'Float32Array',
+        'Float64Array',
+        'BigInt64Array',
+        'BigUint64Array',
+        // 🚫 ITERATORS - CAUSAM PROBLEMAS RECURSIVOS
+        'Iterator',
+        'AsyncIterator',
+        'Generator',
+        'AsyncGenerator',
+        // 🚫 AUTOCORE INTERNAL CLASSES - EVITAR AUTO-INTERCEPTAÇÃO
+        'ExecutionTracker',
+        'GlobalStatementRegistry',
+        'StatementTracker',
+        'StatementMethodFilter',
+        'CTFallbackSystem',
+        'ES6ModuleInterceptor',
+        'AutoStatementInterceptor',
+        'HubDocs',
+        'CategoryDetector',
+        'SwaggerGenerator',
+        'DirectStatementInterceptor',
+        'GlobalErrorHandler',
+        'TestAnnotations',
+        // 🚫 STATEMENT BASE CLASSES - NÃO SÃO CTs INDIVIDUAIS
+        'BaseStatement',
+        'WebStatement',
+        'SSHStatement',
+        'ApiStatement',
+        'DatabaseStatement',
+        'MobileStatement',
+        'Statement',
+        'TestStatement',
+        // 🚫 AUTODOCS CLASSES - EVITAR LOOPS
+        'AutoDocs',
+        'AutoDocsGenerator',
+        'AutoDocsCore',
+        // 🚫 PLAYWRIGHT/TESTING INTERNALS
+        'Page',
+        'Browser',
+        'BrowserContext',
+        'Playwright',
+        'TestInfo',
+        'Locator',
+        'ElementHandle',
+        'Frame',
+        'Worker',
+        'Dialog',
+        'Download',
+        'FileChooser',
+        'Keyboard',
+        'Mouse',
+        'Touchscreen',
+        'Video',
+        'CDPSession',
+        // 🚫 NODE.JS MODULES - INTERNALS
+        'Module',
+        'require',
+        'exports',
+        '__dirname',
+        '__filename',
+        'fs',
+        'path',
+        'os',
+        'crypto',
+        'http',
+        'https',
+        'net',
+        'dgram',
+        'child_process',
+        'cluster',
+        'stream',
+        'util',
+        'events',
+        // 🚫 JAVASCRIPT ENGINE INTERNALS
+        'Intl',
+        'JSON',
+        'Atomics',
+        'SharedArrayBuffer',
+        'WebAssembly',
+        'AggregateError',
+        'ReferenceError',
+        'SyntaxError',
+        'TypeError',
+        'RangeError',
+        'URIError',
+        'EvalError',
+    ]);
+    /**
+     * 🚀 Inicializar filtros inteligentes
+     */
+    static initialize() {
+        if (StatementMethodFilter.initialized)
+            return;
+        StatementMethodFilter.initialized = true;
+        console.log('🎯 [StatementMethodFilter] Inicializando filtros inteligentes...');
+        console.log(`🎯 [StatementMethodFilter] ${StatementMethodFilter.methodPatterns.length} padrões de método carregados`);
+        console.log(`🎯 [StatementMethodFilter] ${StatementMethodFilter.classPatterns.length} padrões de classe carregados`);
+        console.log(`🎯 [StatementMethodFilter] ${StatementMethodFilter.excludedMethods.size} métodos excluídos`);
+    }
+    /**
+     * 📊 Calcular score de um método
+     */
+    static calculateMethodScore(methodName, className) {
+        if (StatementMethodFilter.excludedMethods.has(methodName)) {
+            return 0;
+        }
+        let totalScore = 0;
+        let matchCount = 0;
+        // Calcular score baseado nos padrões
+        for (const pattern of StatementMethodFilter.methodPatterns) {
+            if (pattern.pattern.test(methodName)) {
+                totalScore += pattern.weight;
+                matchCount++;
+            }
+        }
+        // Bonus se o nome da classe indica Statement/Action
+        if (className) {
+            const classBonus = StatementMethodFilter.classPatterns.some((pattern) => pattern.test(className))
+                ? 5
+                : 0;
+            totalScore += classBonus;
+        }
+        // Penalty para métodos muito curtos (provavelmente não são CTs)
+        if (methodName.length < 3) {
+            totalScore -= 3;
+        }
+        // Bonus para métodos com sufixos típicos
+        if (/^(execute|perform|run|process|handle|do).+/i.test(methodName)) {
+            totalScore += 3;
+        }
+        console.log(`🎯 [StatementMethodFilter] ${className || 'Unknown'}.${methodName}: score=${totalScore} (${matchCount} matches)`);
+        return Math.max(0, totalScore);
+    }
+    /**
+     * ✅ Verificar se método é provavelmente um CT
+     * ✅ REATIVADO - Filtrar baseado no nome da classe e método
+     */
+    static isLikelyStatementMethod(methodName, className) {
+        // Se é classe nativa, sempre rejeitar
+        if (className &&
+            StatementMethodFilter.isNativeClassBlacklisted(className)) {
+            console.log(`🚫 [StatementMethodFilter] MÉTODO REJEITADO: ${className}.${methodName} (classe nativa)`);
+            return false;
+        }
+        // Se o método está na lista de excluídos, rejeitar
+        if (StatementMethodFilter.excludedMethods.has(methodName)) {
+            console.log(`🚫 [StatementMethodFilter] MÉTODO REJEITADO: ${className || 'Unknown'}.${methodName} (método excluído)`);
+            return false;
+        }
+        // Se o nome da classe indica Statement/Action, aprovar tudo
+        if (className &&
+            StatementMethodFilter.classPatterns.some((pattern) => pattern.test(className))) {
+            console.log(`✅ [StatementMethodFilter] MÉTODO APROVADO: ${className}.${methodName} (classe Statement)`);
+            return true;
+        }
+        // Para outras classes, calcular score
+        const score = StatementMethodFilter.calculateMethodScore(methodName, className);
+        const approved = score >= 5; // Score mínimo para aprovar
+        if (approved) {
+            console.log(`✅ [StatementMethodFilter] MÉTODO APROVADO: ${className || 'Unknown'}.${methodName} (score=${score})`);
+        }
+        else {
+            console.log(`🚫 [StatementMethodFilter] MÉTODO REJEITADO: ${className || 'Unknown'}.${methodName} (score=${score})`);
+        }
+        return approved;
+    }
+    /**
+     * 🚫 Verificar se classe é nativa e deve ser ignorada
+     * ✅ REATIVADO - Bloquear classes nativas para evitar stack overflow e CTs falsos
+     */
+    static isNativeClassBlacklisted(className) {
+        const isBlacklisted = StatementMethodFilter.nativeClassBlacklist.has(className);
+        if (isBlacklisted) {
+            console.log(`🚫 [StatementMethodFilter] CLASSE BLOQUEADA (nativa): ${className}`);
+            return true;
+        }
+        console.log(`✅ [StatementMethodFilter] CLASSE PERMITIDA: ${className} (não é nativa)`);
+        return false;
+    }
+    /**
+     * 🛡️ Análise segura de classe (evita ERR_INVALID_THIS)
+     */
+    static safeAnalyzeClass(classConstructor, className) {
+        // Verificar blacklist primeiro
+        if (StatementMethodFilter.isNativeClassBlacklisted(className)) {
+            return {
+                name: className,
+                constructor: classConstructor,
+                methods: [],
+                confidence: 0,
+            };
+        }
+        // Análise normal para outras classes
+        return StatementMethodFilter.analyzeClass(classConstructor, className);
+    }
+    /**
+     * �🔍 Analisar classe e extrair métodos CT
+     */
+    static analyzeClass(classConstructor, className) {
+        const methods = [];
+        let totalConfidence = 0;
+        try {
+            // Analisar métodos static
+            const staticMethods = Object.getOwnPropertyNames(classConstructor)
+                .filter((name) => {
+                try {
+                    return typeof classConstructor[name] === 'function';
+                }
+                catch {
+                    return false; // Ignorar propriedades que causam erro ao acessar
+                }
+            })
+                .filter((name) => !name.startsWith('_'))
+                .filter((name) => name !== 'constructor');
+            staticMethods.forEach((methodName) => {
+                if (StatementMethodFilter.isLikelyStatementMethod(methodName, className)) {
+                    methods.push(`${methodName} (static)`);
+                    totalConfidence += StatementMethodFilter.calculateMethodScore(methodName, className);
+                }
+            });
+            // Analisar métodos do prototype com proteção
+            if (classConstructor.prototype) {
+                const prototypeMethods = Object.getOwnPropertyNames(classConstructor.prototype)
+                    .filter((name) => {
+                    try {
+                        // Verificação segura do tipo
+                        const descriptor = Object.getOwnPropertyDescriptor(classConstructor.prototype, name);
+                        if (!descriptor)
+                            return false;
+                        // Se é getter/setter que pode causar erro, pular
+                        if (descriptor.get || descriptor.set) {
+                            try {
+                                // Tentar acessar apenas se seguro
+                                const testValue = classConstructor.prototype[name];
+                                return typeof testValue === 'function';
+                            }
+                            catch (error) {
+                                console.log(`⚠️ [StatementMethodFilter] Erro ao analisar classe ${className}: ${error.message}`);
+                                return false;
+                            }
+                        }
+                        return typeof classConstructor.prototype[name] === 'function';
+                    }
+                    catch {
+                        return false;
+                    }
+                })
+                    .filter((name) => !name.startsWith('_'))
+                    .filter((name) => name !== 'constructor');
+                prototypeMethods.forEach((methodName) => {
+                    if (StatementMethodFilter.isLikelyStatementMethod(methodName, className)) {
+                        methods.push(`${methodName} (instance)`);
+                        totalConfidence += StatementMethodFilter.calculateMethodScore(methodName, className);
+                    }
+                });
+            }
+            console.log(`🔍 [StatementMethodFilter] Classe ${className}: ${methods.length} métodos CT encontrados`);
+        }
+        catch (error) {
+            console.log(`⚠️ [StatementMethodFilter] Erro ao analisar classe ${className}:`, error.message);
+        }
+        return {
+            name: className,
+            constructor: classConstructor,
+            methods,
+            confidence: methods.length > 0 ? totalConfidence / methods.length : 0,
+        };
+    }
+    /**
+     * 🎯 Filtro para todos os métodos de uma classe
+     * ✅ REATIVADO - Usar filtros para bloquear classes nativas e aprovar apenas CTs reais
+     */
+    static filterClassMethods(classConstructor, className) {
+        // Primeiro verificar se é classe nativa (deve ser bloqueada)
+        if (StatementMethodFilter.isNativeClassBlacklisted(className)) {
+            console.log(`🚫 [StatementMethodFilter] CLASSE BLOQUEADA: ${className} (nativa)`);
+            return [];
+        }
+        console.log(`🔍 [StatementMethodFilter] ANALISANDO CLASSE: ${className}`);
+        const methods = [];
+        try {
+            // Métodos estáticos
+            Object.getOwnPropertyNames(classConstructor).forEach((prop) => {
+                if (typeof classConstructor[prop] === 'function' &&
+                    prop !== 'constructor' &&
+                    prop !== 'name' &&
+                    prop !== 'length' &&
+                    StatementMethodFilter.isLikelyStatementMethod(prop, className)) {
+                    methods.push(prop);
+                }
+            });
+            // Métodos de instância
+            if (classConstructor.prototype) {
+                Object.getOwnPropertyNames(classConstructor.prototype).forEach((prop) => {
+                    try {
+                        if (typeof classConstructor.prototype[prop] === 'function' &&
+                            prop !== 'constructor' &&
+                            StatementMethodFilter.isLikelyStatementMethod(prop, className)) {
+                            methods.push(prop);
+                        }
+                    }
+                    catch (error) {
+                        // Ignorar erros ao acessar propriedades de classes problemáticas
+                        console.log(`⚠️ [StatementMethodFilter] Erro ao analisar ${className}: ${String(error)}`);
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console.log(`⚠️ [StatementMethodFilter] Erro ao analisar ${className}:`, error);
+        }
+        console.log(`🔍 [StatementMethodFilter] Classe ${className}: ${methods.length} métodos CT encontrados`);
+        return methods;
+    }
+    /**
+     * 📊 Obter estatísticas dos filtros
+     */
+    static getFilterStats() {
+        return {
+            patterns: StatementMethodFilter.methodPatterns.length,
+            classPatterns: StatementMethodFilter.classPatterns.length,
+            excludedMethods: StatementMethodFilter.excludedMethods.size,
+            totalPatterns: StatementMethodFilter.methodPatterns.length +
+                StatementMethodFilter.classPatterns.length,
+        };
+    }
+    /**
+     * 🔧 Adicionar padrão customizado
+     */
+    static addCustomPattern(pattern, weight, description) {
+        StatementMethodFilter.methodPatterns.push({ pattern, weight, description });
+        console.log(`🎯 [StatementMethodFilter] Padrão customizado adicionado: ${description}`);
+    }
+    /**
+     * 🎯 Modo debug - mostrar análise detalhada
+     */
+    static debugAnalyzeMethod(methodName, className) {
+        console.log(`\n🔍 [StatementMethodFilter] ANÁLISE DETALHADA: ${className || 'Unknown'}.${methodName}`);
+        if (StatementMethodFilter.excludedMethods.has(methodName)) {
+            console.log('❌ Método na lista de exclusão');
+            return;
+        }
+        let totalScore = 0;
+        const matches = [];
+        StatementMethodFilter.methodPatterns.forEach((pattern) => {
+            if (pattern.pattern.test(methodName)) {
+                matches.push(`${pattern.description}: +${pattern.weight}`);
+                totalScore += pattern.weight;
+            }
+        });
+        if (className) {
+            const classBonus = StatementMethodFilter.classPatterns.some((pattern) => pattern.test(className))
+                ? 5
+                : 0;
+            if (classBonus > 0) {
+                matches.push(`Class bonus: +${classBonus}`);
+                totalScore += classBonus;
+            }
+        }
+        console.log('📊 Matches encontrados:');
+        matches.forEach((match) => console.log(`   ${match}`));
+        console.log(`📊 Score total: ${totalScore}`);
+        console.log(`📊 Resultado: ${totalScore >= 3 ? '✅ APROVADO' : '❌ REJEITADO'}`);
+    }
+}
+// Auto-inicialização
+StatementMethodFilter.initialize();
+export { StatementMethodFilter };