@mocoto/mahoraga 0.14.1 → 0.14.3

package/dist/analysts/corrections/quick-fixes/fix-any-to-proper-type.js

@@ -10,9 +10,10 @@ import { analyzeTypeUsage } from '../type-safety/type-analyzer.js';
 import { createTypeDefinition } from '../type-safety/type-creator.js';
 import { validateTypeReplacement } from '../type-safety/type-validator.js';
 const { MENSAGENS_CORRECAO_TIPOS } = getMessages();
+const CONFIANCA_MEDIA = 60;
 const CONFIANCA_NIVEIS = {
     HIGH: 85,
-    MEDIUM: 60,
+    MEDIUM: CONFIANCA_MEDIA,
     DEFAULT: 70
 };
 export const fixAnyToProperTipo = {
@@ -62,66 +63,7 @@ export async function fixAnyToProperTypeAsync(match, fullCode, fileCaminho, ast)
         const typeAnalise = analyzeTypeUsage(match, fullCode, fileCaminho, ast);
         // 2. Estratégia baseada em confiança
         if (typeAnalise.confidence >= CONFIANCA_NIVEIS.HIGH) {
-            // ALTA CONFIANÇA: Aplicar tipo automaticamente
-            if (typeAnalise.isSimpleType) {
-                // Tipo primitivo: substituir diretamente
-                const fixedCodigo = fullCode.replace(match[0], `: ${typeAnalise.inferredTipo}`);
-                // Validar resultado
-                const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
-                if (!validation.isCompatible) {
-                    return {
-                        code: fullCode,
-                        applied: false,
-                        reason: `Validação falhou: ${validation.errors.join(', ')}`,
-                        warnings: validation.warnings.map(dimensaoLargura => ({
-                            type: 'unsafe-type',
-                            message: dimensaoLargura,
-                            suggestion: 'Revise manualmente'
-                        }))
-                    };
-                }
-                return {
-                    code: fixedCodigo,
-                    applied: true,
-                    warnings: validation.warnings.map(dimensaoLargura => ({
-                        type: 'type-suggestion',
-                        message: dimensaoLargura,
-                        suggestion: MENSAGENS_CORRECAO_TIPOS.validacao.revisar
-                    }))
-                };
-            }
-            else {
-                // Tipo complexo: criar interface
-                const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
-                const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
-                // Adicionar import no topo e substituir any
-                const lines = fullCode.split('\n');
-                const importIndex = findImportInsertionPoint(lines);
-                lines.splice(importIndex, 0, importStatement);
-                let fixedCodigo = lines.join('\n');
-                fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
-                // Validar resultado
-                const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
-                if (!validation.isCompatible) {
-                    return {
-                        code: fullCode,
-                        applied: false,
-                        reason: `Validação falhou: ${validation.errors.join(', ')}`
-                    };
-                }
-                return {
-                    code: fixedCodigo,
-                    applied: true,
-                    additionalChanges: [{
-                            type: 'add-import',
-                            content: importStatement
-                        }, {
-                            type: 'create-type-file',
-                            content: typeAnalise.typeDefinition,
-                            path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
-                        }]
-                };
-            }
+            return await applyHighConfidenceAnyFix(match, fullCode, fileCaminho, typeAnalise);
         }
         else if (typeAnalise.confidence >= CONFIANCA_NIVEIS.MEDIUM) {
             // MÉDIA CONFIANÇA: Sugerir mas não aplicar
@@ -162,6 +104,60 @@ export async function fixAnyToProperTypeAsync(match, fullCode, fileCaminho, ast)
         };
     }
 }
+async function applyHighConfidenceAnyFix(match, fullCode, fileCaminho, typeAnalise) {
+    if (typeAnalise.isSimpleType) {
+        const fixedCodigo = fullCode.replace(match[0], `: ${typeAnalise.inferredTipo}`);
+        const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
+        if (!validation.isCompatible) {
+            return {
+                code: fullCode,
+                applied: false,
+                reason: `Validação falhou: ${validation.errors.join(', ')}`,
+                warnings: validation.warnings.map(dimensaoLargura => ({
+                    type: 'unsafe-type',
+                    message: dimensaoLargura,
+                    suggestion: 'Revise manualmente'
+                }))
+            };
+        }
+        return {
+            code: fixedCodigo,
+            applied: true,
+            warnings: validation.warnings.map(dimensaoLargura => ({
+                type: 'type-suggestion',
+                message: dimensaoLargura,
+                suggestion: MENSAGENS_CORRECAO_TIPOS.validacao.revisar
+            }))
+        };
+    }
+    const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
+    const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
+    const lines = fullCode.split('\n');
+    const importIndex = findImportInsertionPoint(lines);
+    lines.splice(importIndex, 0, importStatement);
+    let fixedCodigo = lines.join('\n');
+    fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
+    const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
+    if (!validation.isCompatible) {
+        return {
+            code: fullCode,
+            applied: false,
+            reason: `Validação falhou: ${validation.errors.join(', ')}`
+        };
+    }
+    return {
+        code: fixedCodigo,
+        applied: true,
+        additionalChanges: [{
+                type: 'add-import',
+                content: importStatement
+            }, {
+                type: 'create-type-file',
+                content: typeAnalise.typeDefinition,
+                path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
+            }]
+    };
+}
 /**
  * Encontra ponto de inserção para import
  */

package/dist/analysts/corrections/quick-fixes/fix-unknown-to-specific-type.js

@@ -51,36 +51,7 @@ export async function fixUnknownToSpecificTypeAsync(match, fullCode, fileCaminho
         const typeAnalise = await analyzeUnknownUsage(match, fullCode, fileCaminho, ast);
         // 2. Estratégia mais conservadora (requer >= 90% confiança)
         if (typeAnalise.confidence >= 90) {
-            // ALTA CONFIANÇA: Criar interface dedicada
-            const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
-            const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
-            // Adicionar import e substituir unknown
-            const lines = fullCode.split('\n');
-            const importIndex = findImportInsertionPoint(lines);
-            lines.splice(importIndex, 0, importStatement);
-            let fixedCodigo = lines.join('\n');
-            fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
-            // Validar
-            const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
-            if (!validation.isCompatible) {
-                return {
-                    code: fullCode,
-                    applied: false,
-                    reason: `Validação falhou: ${validation.errors.join(', ')}`
-                };
-            }
-            return {
-                code: fixedCodigo,
-                applied: true,
-                additionalChanges: [{
-                        type: 'add-import',
-                        content: importStatement
-                    }, {
-                        type: 'create-type-file',
-                        content: typeAnalise.typeDefinition,
-                        path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
-                    }]
-            };
+            return await applyHighConfidenceUnknownFix(match, fullCode, fileCaminho, typeAnalise);
         }
         else if (typeAnalise.confidence >= 70) {
             // MÉDIA CONFIANÇA: Sugerir tipo
@@ -120,6 +91,35 @@ export async function fixUnknownToSpecificTypeAsync(match, fullCode, fileCaminho
         };
     }
 }
+async function applyHighConfidenceUnknownFix(match, fullCode, fileCaminho, typeAnalise) {
+    const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
+    const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
+    const lines = fullCode.split('\n');
+    const importIndex = findImportInsertionPoint(lines);
+    lines.splice(importIndex, 0, importStatement);
+    let fixedCodigo = lines.join('\n');
+    fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
+    const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
+    if (!validation.isCompatible) {
+        return {
+            code: fullCode,
+            applied: false,
+            reason: `Validação falhou: ${validation.errors.join(', ')}`
+        };
+    }
+    return {
+        code: fixedCodigo,
+        applied: true,
+        additionalChanges: [{
+                type: 'add-import',
+                content: importStatement
+            }, {
+                type: 'create-type-file',
+                content: typeAnalise.typeDefinition,
+                path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
+            }]
+    };
+}
 /**
  * Encontra ponto de inserção para import
  */

package/dist/analysts/corrections/reorganize-barrels.js

@@ -28,6 +28,15 @@ function resolverImportRelativo(arquivoRel, importSpec) {
     const dir = path.posix.dirname(normalizarRel(arquivoRel));
     return path.posix.normalize(path.posix.join(dir, importSpec));
 }
+function resolverImportSpec(spec, rel) {
+    if (spec.startsWith('@/')) {
+        return semExt(normalizarRel(`src/${spec.slice(2)}`));
+    }
+    if (spec.startsWith('@')) {
+        return semExt(normalizarRel(`src/${spec.slice(1)}`)).replace(/^src\//, '');
+    }
+    return semExt(resolverImportRelativo(rel, spec));
+}
 function criarMapaMovimentos(mapa, _baseDir) {
     const movimentos = new Map();
     for (const entry of mapa) {
@@ -231,16 +240,7 @@ async function atualizarImportsGlobais(srcDir, movimentos) {
                     if (!isRelative && !isAlias) {
                         continue;
                     }
-                    let resolved;
-                    if (spec.startsWith('@/')) {
-                        resolved = semExt(normalizarRel(`src/${spec.slice(2)}`));
-                    }
-                    else if (spec.startsWith('@')) {
-                        resolved = semExt(normalizarRel(`src/${spec.slice(1)}`)).replace(/^src\//, '');
-                    }
-                    else {
-                        resolved = semExt(resolverImportRelativo(rel, spec));
-                    }
+                    const resolved = resolverImportSpec(spec, rel);
                     const moveDestino = movimentos.get(resolved);
                     if (!moveDestino) {
                         continue;
@@ -301,9 +301,9 @@ async function extrairNomesExportados(srcDir, relPath, visitados = new Set(), pr
                 nomes.add(exportDecl[1]);
             }
             // export { name1, name2 as alias, ... }
-            const exportList = trimmed.match(/^export\s+type\s*\{([^}]+)\}|^export\s*\{([^}]+)\}/);
+            const exportList = trimmed.match(/^export\s+(?:type\s+)?\s*\{([^}]+)\}/);
             if (exportList) {
-                const body = exportList[1] ?? exportList[2];
+                const body = exportList[1];
                 if (body) {
                     body.split(',').forEach(part => {
                         const m = part.trim().match(/^(\w+)(?:\s+as\s+\w+)?$/);
@@ -469,7 +469,7 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
                         if (!match) {
                             return null;
                         }
-                        return { imported: match[1], local: match[2] ?? match[1] };
+                        return { imported: match[1], local: match[2] || match[1] };
                     }).filter((n) => n !== null);
                     const nomesQueFicam = [];
                     const nomesQueMoveram = [];

package/dist/analysts/corrections/rewrite-testes-aliases.js

@@ -19,7 +19,7 @@ function exists(caminho) {
 function pathFromAlias(aliasSpec, srcRoot) {
     const spec = aliasSpec.replace(/^@/, '');
     const parts = spec.split('/');
-    const top = parts.shift();
+    const top = parts?.shift();
     return path.join(srcRoot, top ?? '', parts.join('/'));
 }
 export function pickExtForAlias(aliasBase, srcRoot) {
@@ -67,40 +67,41 @@ export function rewriteToAlias(spec, ctx) {
 export function transformCodeForTests(code, ctx) {
     let changed = false;
     const rewrite = (spec) => rewriteToAlias(spec, ctx);
-    code = code.replace(/(import\s+[^'"\n]+?from\s+)(["'])([^"']+?)\2/g, (metrica, p1, delimitadorString, spec) => {
-        const result = rewrite(spec);
-        if (!result.changed) {
-            return metrica;
+    let result = code;
+    result = result.replace(/(import\s+[^'"\n]+?from\s+)(["'])([^"']+?)\2/g, (substring, p1, delimitadorString, spec) => {
+        const res = rewrite(spec);
+        if (!res.changed) {
+            return substring;
         }
         changed = true;
-        return `${p1}${delimitadorString}${result.value}${delimitadorString}`;
+        return `${p1}${delimitadorString}${res.value}${delimitadorString}`;
     });
-    code = code.replace(/(import\s*)(["'])([^"']+?)\2/g, (metrica, p1, delimitadorString, spec) => {
-        const result = rewrite(spec);
-        if (!result.changed) {
-            return metrica;
+    result = result.replace(/(import\s*)(["'])([^"']+?)\2/g, (substring, p1, delimitadorString, spec) => {
+        const res = rewrite(spec);
+        if (!res.changed) {
+            return substring;
         }
         changed = true;
-        return `${p1}${delimitadorString}${result.value}${delimitadorString}`;
+        return `${p1}${delimitadorString}${res.value}${delimitadorString}`;
     });
-    code = code.replace(/(import\s*\()(\s*["'])([^"']+?)(["']\s*\))/g, (metrica, p1, q1, spec, q2) => {
-        const result = rewrite(spec);
-        if (!result.changed) {
-            return metrica;
+    result = result.replace(/(import\s*\()(\s*["'])([^"']+?)(["']\s*\))/g, (substring, p1, q1, spec, q2) => {
+        const res = rewrite(spec);
+        if (!res.changed) {
+            return substring;
         }
         changed = true;
-        return `${p1}${q1}${result.value}${q2}`;
+        return `${p1}${q1}${res.value}${q2}`;
     });
-    code = code.replace(/(vi\.(?:do)?mock\s*\()(\s*["'])([^"']+?)(["'])(\s*,?)/g, (metrica, p1, q1, spec, q2, comma = '') => {
-        const result = rewrite(spec);
-        if (!result.changed) {
-            return metrica;
+    result = result.replace(/(vi\.(?:do)?mock\s*\()(\s*["'])([^"']+?)(["'])(\s*,?)/g, (substring, p1, q1, spec, q2, comma = '') => {
+        const res = rewrite(spec);
+        if (!res.changed) {
+            return substring;
         }
         changed = true;
-        return `${p1}${q1}${result.value}${q2}${comma}`;
+        return `${p1}${q1}${res.value}${q2}${comma}`;
     });
     return {
-        code,
+        code: result,
         changed
     };
 }

package/dist/analysts/corrections/scoring-shared.js

@@ -236,6 +236,24 @@ export function fixSpacingAroundPunct(string) {
         count
     };
 }
+function getCharacterDisplayName(ch) {
+    try {
+        if (typeof Intl !== 'undefined') {
+            const intlApi = Intl;
+            const DisplayNomesCtor = intlApi.DisplayNames;
+            if (DisplayNomesCtor) {
+                const displayNomes = new DisplayNomesCtor(['en'], {
+                    type: 'language'
+                });
+                return typeof displayNomes.of === 'function' ? displayNomes.of(ch) ?? '' : '';
+            }
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
 /**
  * Detecta caracteres fora do range ASCII comum.
  */
@@ -248,24 +266,7 @@ export function detectUncommonChars(text, limite) {
         }
         const code = ch.codePointAt(0) ?? 0;
         if (code >= LIMITES.ASCII_EXTENDED_MIN && !isCaractereComum(code)) {
-            const name = (() => {
-                try {
-                    if (typeof Intl !== 'undefined') {
-                        const intlApi = Intl;
-                        const DisplayNomesCtor = intlApi.DisplayNames;
-                        if (DisplayNomesCtor) {
-                            const displayNomes = new DisplayNomesCtor(['en'], {
-                                type: 'language'
-                            });
-                            return typeof displayNomes.of === 'function' ? displayNomes.of(ch) ?? '' : '';
-                        }
-                    }
-                    return '';
-                }
-                catch {
-                    return '';
-                }
-            })();
+            const name = getCharacterDisplayName(ch);
             issues.push({
                 tipo: 'caracteres-incomuns',
                 posicao: pos,

package/dist/analysts/corrections/type-safety/context-analyzer.js

@@ -5,6 +5,7 @@
  * Analisador de contexto para Type Safety Auto-Fix
  * Detecta contextos onde any/unknown NÃO devem ser modificados
  */
+const CONFIANCA_PADRAO = 60;
 export { isInComment, isInString, isInStringOrComment } from '../../../shared/helpers/index.js';
 /**
  * Verifica se está em contexto TypeScript específico que deve ser ignorado
@@ -152,6 +153,13 @@ export function extractLineContext(code, position) {
     }
     return '';
 }
+function hasInternalValidation(code, lineContext) {
+    if (!/(analise|result|data|value)\s*:\s*unknown/.test(lineContext)) {
+        return false;
+    }
+    const beforeFunc = code.substring(Math.max(0, lineContext.length - 200), lineContext.length + 100);
+    return /if\s*\(/.test(beforeFunc) || /typeof\s+\w+\s*===/.test(beforeFunc);
+}
 export function categorizarUnknown(code, fileCaminho, lineContext) {
     // Type Guards - 100% legítimo
     if (/:\s*unknown\)\s*:\s*\w+\s+is\s+/.test(lineContext)) {
@@ -393,15 +401,12 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
         };
     }
     // Função de análise com validação interna - 90% legítimo
-    if (/(analise|result|data|value)\s*:\s*unknown/.test(lineContext)) {
-        const beforeFunc = code.substring(Math.max(0, lineContext.length - 200), lineContext.length + 100);
-        if (/if\s*\(/.test(beforeFunc) || /typeof\s+\w+\s*===/.test(beforeFunc)) {
-            return {
-                categoria: 'legitimo',
-                confianca: 90,
-                motivo: 'Parâmetro com validação/narrowing interna - unknown é seguro quando verificado'
-            };
-        }
+    if (hasInternalValidation(code, lineContext)) {
+        return {
+            categoria: 'legitimo',
+            confianca: 90,
+            motivo: 'Parâmetro com validação/narrowing interna - unknown é seguro quando verificado'
+        };
     }
     // Getter de keys com validação - 95% legítimo
     if (/value\s*:\s*unknown/.test(lineContext) && /Object\.keys/.test(contextoAmplo)) {
@@ -422,7 +427,7 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
     // Default: melhorável com análise incerta
     return {
         categoria: 'melhoravel',
-        confianca: 60,
+        confianca: CONFIANCA_PADRAO,
         motivo: 'Tipo unknown genérico - análise contextual limitada',
         sugestao: 'Analisar fluxo de dados para inferir tipo correto',
         variantes: ['Se vem de API externa: definir interface baseada na resposta esperada', 'Se é callback: especificar assinatura da função', 'Se é config/options: criar interface com campos opcionais', 'Se é polimórfico: considerar discriminated union ou generics']

package/dist/analysts/corrections/type-safety/type-analyzer.js

@@ -62,14 +62,14 @@ export function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
 /**
  * Analisa uso de unknown com foco em type guards
  */
-export async function analyzeUnknownUsage(match, fullCode, fileCaminho, ast) {
+export function analyzeUnknownUsage(match, fullCode, fileCaminho, ast) {
     // Mesma lógica de analyzeTypeUsage, mas mais conservador
     const analysis = analyzeTypeUsage(match, fullCode, fileCaminho, ast);
     // Penalizar confiança em 10% para unknown (mais conservador)
     analysis.confidence = Math.max(0, analysis.confidence - 10);
     // Se confiança ainda é baixa, sugerir manter unknown
     if (analysis.confidence < 70) {
-        analysis.suggestion = 'Confiança baixa para substituir unknown. ' + `Considere adicionar type guards ou criar tipo dedicado em ${getTypesDirectoryDisplay()}`;
+        analysis.suggestion = `Confiança baixa para substituir unknown. Considere adicionar type guards ou criar tipo dedicado em ${getTypesDirectoryDisplay()}`;
     }
-    return analysis;
+    return Promise.resolve(analysis);
 }

package/dist/analysts/corrections/type-safety/type-validator.js

@@ -4,6 +4,7 @@
  * Verifica compatibilidade e compilação TypeScript
  */
 import { findExistingType, isSameType } from './type-creator.js';
+const CONFIANCA_MINIMA = 60;
 /**
  * Valida substituição de tipo (any/unknown → specific)
  */
@@ -18,13 +19,13 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
     if (typeAnalise.createdNewType) {
         const existingTipo = await findExistingType(typeAnalise.typeName);
         if (existingTipo && !isSameType(existingTipo, typeAnalise.typeDefinition)) {
-            result.warnings.push(`Tipo ${typeAnalise.typeName} já existe com definição diferente. ` + `Verifique conflito em ${existingTipo.path}`);
+            result.warnings.push(`Tipo ${typeAnalise.typeName} já existe com definição diferente. Verifique conflito em ${existingTipo.path}`);
         }
     }
     // 2. Verificar se tipo inferido é compatível com uso
     const usageValidation = validateTypeUsageCompatibility(fixedCodigo, typeAnalise);
     if (!usageValidation.isCompatible) {
-        result.errors.push(`Tipo inferido ${typeAnalise.inferredTipo} incompatível com uso detectado. ` + `Esperado: ${usageValidation.expectedType}`);
+        result.errors.push(`Tipo inferido ${typeAnalise.inferredTipo} incompatível com uso detectado. Esperado: ${usageValidation.expectedType}`);
         result.isCompatible = false;
     }
     // 3. Verificar se import foi adicionado corretamente
@@ -36,7 +37,7 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
         }
     }
     // 4. Verificar confiança mínima
-    if (typeAnalise.confidence < 60) {
+    if (typeAnalise.confidence < CONFIANCA_MINIMA) {
         result.warnings.push(`Confiança muito baixa (${typeAnalise.confidence}%). Considere revisão manual.`);
     }
     // 5. Validar sintaxe básica do código modificado

package/dist/analysts/corrections/type-safety/usage-analyzer.js

@@ -128,49 +128,46 @@ function extractObjectProperties(usages) {
     }
     return Array.from(propertiesMap.values());
 }
-/**
- * Detecta type guards no código
- */
+function detectTypeofGuard(usage, context, guards) {
+    const match = context.match(/typeof\s+\w+\s*===\s*['"](\w+)['"]/);
+    if (match) {
+        guards.push({
+            type: 'typeof',
+            expression: usage.context,
+            inferredTipo: match[1],
+            confidence: 95
+        });
+    }
+}
+function detectInstanceofGuard(usage, context, guards) {
+    const match = context.match(/\w+\s+instanceof\s+(\w+)/);
+    if (match) {
+        guards.push({
+            type: 'instanceof',
+            expression: usage.context,
+            inferredTipo: match[1],
+            confidence: 95
+        });
+    }
+}
+function detectInGuard(usage, context, guards) {
+    const match = context.match(/['"](\w+)['"]\s+in\s+\w+/);
+    if (match) {
+        guards.push({
+            type: 'in',
+            expression: usage.context,
+            inferredTipo: `{ ${match[1]}: unknown }`,
+            confidence: 80
+        });
+    }
+}
 function detectTypeGuards(usages) {
     const guards = [];
     for (const usage of usages) {
         const context = usage.context.toLowerCase();
-        // typeof guards
-        if (context.includes('typeof')) {
-            const match = context.match(/typeof\s+\w+\s*===\s*['"](\w+)['"]/);
-            if (match) {
-                guards.push({
-                    type: 'typeof',
-                    expression: usage.context,
-                    inferredTipo: match[1],
-                    confidence: 95
-                });
-            }
-        }
-        // instanceof guards
-        if (context.includes('instanceof')) {
-            const match = context.match(/\w+\s+instanceof\s+(\w+)/);
-            if (match) {
-                guards.push({
-                    type: 'instanceof',
-                    expression: usage.context,
-                    inferredTipo: match[1],
-                    confidence: 95
-                });
-            }
-        }
-        // 'in' operator guards
-        if (context.includes(' in ')) {
-            const match = context.match(/['"](\w+)['"]\s+in\s+\w+/);
-            if (match) {
-                guards.push({
-                    type: 'in',
-                    expression: usage.context,
-                    inferredTipo: `{ ${match[1]}: unknown }`,
-                    confidence: 80
-                });
-            }
-        }
+        detectTypeofGuard(usage, context, guards);
+        detectInstanceofGuard(usage, context, guards);
+        detectInGuard(usage, context, guards);
     }
     return guards;
 }
@@ -214,7 +211,7 @@ function extractUsageFromNode(node, varNome) {
  * Extrai informações de MemberExpression
  */
 function extractMemberExpressionUsage(node, varNome) {
-    const property = node.property?.name ?? node.property.value;
+    const property = node.property?.name ?? String(node.property.value);
     return {
         name: varNome,
         nodeType: 'MemberExpression',
@@ -222,7 +219,7 @@ function extractMemberExpressionUsage(node, varNome) {
         column: node.loc?.start?.column ?? 0,
         context: extractNodeContext(node),
         operation: 'access',
-        property: property ? String(property) : undefined
+        property: property || undefined
     };
 }
 /**
@@ -250,7 +247,7 @@ function extractNodeContext(node) {
     }
     if (node.type === 'MemberExpression') {
         const obj = node.object?.name ?? extractNodeContext(node.object);
-        const prop = node.property?.name ?? node.property.value;
+        const prop = node.property?.name ?? String(node.property.value);
         return `${obj}.${prop}`;
     }
     if (node.type === 'CallExpression') {