@mocoto/mahoraga 0.14.8 → 0.14.9

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

@@ -1,38 +1,12 @@
-// @mahoraga-disable problema-documentacao ml-deep-nesting
-// SPDX-License-Identifier: MIT
-// Justificativa: funções estão tipadas, detector está identificando falsos positivos
-/**
- * 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
- * Exemplos: type annotation em interface, generic constraints, etc
- *
- * IMPORTANTE: NÃO ignora type assertions (as any) - esses são CRÍTICOS
- * e devem ser detectados separadamente como tipo-inseguro-any-assertion.
- *
- * CORREÇÃO APLICADA (2025-11-03):
- * Removida detecção de `as any` que estava ignorando type assertions.
- * Type assertions NÃO são legítimos - são exatamente o que queremos detectar!
- *
- * Ver: docs/reports/DEBUG-TYPE-SAFETY-DETECTOR-2025-11-03.md
- */
 export function isTypeScriptContext(code, position) {
     const context = code.substring(Math.max(0, position - 50), position + 50);
-    // NÃO ignorar type assertions - eles são CRÍTICOS e detectados separadamente
-    // O código abaixo foi removido para que as type assertions sejam sempre detectadas
-    // Tipo de retorno de função genérica (isso ainda pode ser legítimo em alguns casos)
     if (/<[^>]*>\s*\([^)]*\)\s*:\s*(any|unknown)/.test(context)) {
         return true;
     }
     return false;
 }
-/**
- * Verifica se é arquivo legado ou vendor
- */
 export function isLegacyOrVendorFile(fileCaminho) {
     if (!fileCaminho) {
         return false;
@@ -40,106 +14,69 @@ export function isLegacyOrVendorFile(fileCaminho) {
     const legacyPadroes = ['/legacy/', '/legado/', '/vendor/', '/node_modules/', '/dist/', '/build/', '.d.ts', '.min.js'];
     return legacyPadroes.some(pattern => fileCaminho.includes(pattern));
 }
-/**
- * Verifica se unknown está sendo usado em contexto apropriado
- * Contextos apropriados: entrada genérica, APIs externas, deserialização
- */
 export function isUnknownInGenericContext(code, position) {
     const context = code.substring(Math.max(0, position - 200), position + 100);
-    // Função genérica com tipo T
     if (/function\s+\w+<T[^>]*>/.test(context)) {
         return true;
     }
-    // Deserialização (JSON.parse, etc)
     if (/JSON\.parse|deserialize|decode/.test(context)) {
         return true;
     }
-    // API externa ou fetch
     if (/fetch|axios|request|response\.data/.test(context)) {
         return true;
     }
-    // Funções de persistência/serialização que aceitam dados genéricos
     if (/salvar|persist|save|store|write.*:\s*\([^)]*dados:\s*unknown/.test(context)) {
         return true;
     }
-    // Record<string, unknown> - padrão legítimo para objetos genéricos
     if (/Record<\s*string\s*,\s*unknown\s*>/.test(context)) {
         return true;
     }
-    // Array<unknown> ou unknown[] - arrays genéricos
     if (/Array<\s*unknown\s*>|unknown\s*\[\]/.test(context)) {
         return true;
     }
-    // Parâmetros opcionais genéricos (estilo?: unknown, options?: unknown)
     if (/\w+\?\s*:\s*unknown/.test(context)) {
         return true;
-    } // Type guard function que retorna type predicate
+    }
     if (/function\s+\w+\([^)]*:\s*unknown\)[^:]*:\s*\w+\s+is\s+\w+/.test(context)) {
         return true;
     }
     return false;
 }
-/**
- * Verifica se any está em declaração de função genérica
- * Nesses casos, pode ser legítimo dependendo do contexto
- */
 export function isAnyInGenericFunction(code, position) {
     const context = code.substring(Math.max(0, position - 300), position + 100);
-    // Função de callback genérica
     if (/callback\s*:\s*\([^)]*:\s*any/.test(context)) {
         return true;
     }
-    // Event handler genérico
     if (/on\w+\s*:\s*\([^)]*:\s*any/.test(context)) {
         return true;
     }
     return false;
 }
-/**
- * Extrai domínio do arquivo baseado no caminho
- */
 export function getDomainFromFilePath(fileCaminho) {
     const match = fileCaminho.match(/src\/([\w-]+)\//);
     if (match) {
         return match[1];
     }
-    // Fallback para 'shared' se não conseguir determinar
     return 'shared';
 }
-/**
- * Converte PascalCase/camelCase para kebab-case
- */
 export function toKebabCase(str) {
     return str.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase();
 }
-/**
- * Verifica se é arquivo de definição de tipos (.d.ts)
- */
 export function isDefinitionFile(fileCaminho) {
     return fileCaminho.endsWith('.d.ts');
 }
-/**
- * Verifica se é arquivo TypeScript
- */
 export function isTypeScriptFile(fileCaminho) {
     return fileCaminho.endsWith('.ts') || fileCaminho.endsWith('.tsx');
 }
-/**
- * Extrai nome da variável/parâmetro do match
- */
 export function extractVariableName(match, code) {
     const position = match.index ?? 0;
     const before = code.substring(Math.max(0, position - 100), position + match[0].length);
-    // Padrão: nome: any ou nome: unknown
     const varMatch = before.match(/(\w+)\s*:\s*(?:any|unknown)\b/);
     if (varMatch) {
         return varMatch[1];
     }
     return null;
 }
-/**
- * Extrai contexto da linha onde o match ocorre
- */
 export function extractLineContext(code, position) {
     const lines = code.split('\n');
     let pos = 0;
@@ -161,7 +98,6 @@ function hasInternalValidation(code, lineContext) {
     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)) {
         return {
             categoria: 'legitimo',
@@ -169,7 +105,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Type guard padrão TypeScript - unknown é a escolha correta'
         };
     }
-    // Catch blocks - 100% legítimo
     if (/catch\s*\(\s*\w+\s*:\s*unknown\s*\)/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -177,7 +112,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Catch block padrão TypeScript - unknown é recomendado'
         };
     }
-    // Índice extensível [k: string]: unknown - 100% legítimo
     if (/\[\s*\w+\s*:\s*string\s*\]\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -185,7 +119,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Índice extensível - permite propriedades adicionais'
         };
     }
-    // Record<string, unknown> ou Map<*, unknown> - 100% legítimo
     if (/Record<[^,]+,\s*unknown>/.test(lineContext) || /Map<[^,]+,\s*unknown>/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -193,7 +126,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Objeto genérico - Record/Map com unknown é apropriado'
         };
     }
-    // Array<unknown> ou unknown[] - 100% legítimo
     if (/Array<unknown>/.test(lineContext) || /unknown\[\]/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -201,7 +133,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Array genérico - unknown[] é apropriado'
         };
     }
-    // Parâmetro opcional com unknown - 95% legítimo
     if (/\w+\?\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -210,7 +141,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             sugestao: 'Considere usar tipo mais específico se o uso for conhecido'
         };
     }
-    // Guardian related - análise detalhada
     if (/guardian\s*:\s*unknown/.test(lineContext) || fileCaminho.includes('guardian')) {
         if (lineContext.includes('detalhes') || lineContext.includes('erros') || lineContext.includes('Error')) {
             return {
@@ -229,7 +159,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             variantes: ['interface GuardianResult { status: "ok" | "erro"; baseline?: Baseline; drift?: Drift }', 'type GuardianOutput = SuccessResult | ErrorResult (discriminated union)', 'Usar zod/io-ts para validação runtime + tipos']
         };
     }
-    // AST/Babel nodes - 80% melhorável
     if (/\bast\s*:\s*unknown/.test(lineContext) || /\bnode\s*:\s*unknown/.test(lineContext) || lineContext.includes('NodePath')) {
         return {
             categoria: 'melhoravel',
@@ -239,7 +168,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             variantes: ['Node (AST node genérico do Babel)', 'NodePath<Node> (para traverse)', 'File | Program | Statement | Expression (tipos específicos)']
         };
     }
-    // Funções de serialização/persistência - 95% legítimo
     if (/salvar|persist|save|store|write|serialize|stringify/.test(lineContext) && /dados\s*:\s*unknown|value\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -248,7 +176,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             sugestao: 'Se formato for conhecido, use tipo genérico: <T = unknown>(dados: T) => ...'
         };
     }
-    // Funções de validação genéricas - 95% legítimo
     if (/validar|validate|check|assert|guard/.test(lineContext) && /\w+\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -256,7 +183,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Função de validação - recebe unknown e valida tipo'
         };
     }
-    // Acesso dinâmico protegido (safeGet) - 95% legítimo
     if (/safeGet|tryGet|getProperty/.test(lineContext) && /:\s*unknown/.test(lineContext) && !/:\s*unknown\)/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -265,7 +191,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             sugestao: 'Validar tipo após obter valor: const val = safeGet(...); if (typeof val === ...)'
         };
     }
-    // Replacer functions em JSON - 95% legítimo
     if (/replacer|reviver/.test(lineContext) && /\w+\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -273,7 +198,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Replacer/reviver do JSON - unknown é esperado'
         };
     }
-    // Wrappers de AST/parsing - 95% legítimo
     if (/wrap|parse|transform/.test(lineContext) && /ast\s*:\s*unknown|rawAst\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -281,9 +205,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Wrapper de parser - AST de origem desconhecida'
         };
     }
-    // Funções de error handling - 95% legítimo
-    // Cobre padrões em português (erro), inglês (error/err/e) e funções
-    // como detalheErro, handlerError, tratarErro, etc.
     if (/error\s*:\s*unknown|err\s*:\s*unknown|e\s*:\s*unknown|erro\s*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -291,7 +212,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Error handling - error pode ser de qualquer tipo em catch/callbacks'
         };
     }
-    // Funções de detalhamento/extração de erro - 95% legítimo
     if (/detalhe\w*\s*\([^)]*\w+\s*:\s*unknown/.test(lineContext) && /erro|error|err|exception|fail/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -299,7 +219,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Função de extração de detalhes de erro - unknown é esperado'
         };
     }
-    // Mock/test utilities - 95% legítimo
     if (/mock|vitest|expect|args\s*:\s*unknown\[\]/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -307,7 +226,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Test utilities - tipos genéricos de framework de testes'
         };
     }
-    // CLI options/callbacks - 95% legítimo quando vem de framework
     if (/opts\s*:\s*unknown|options\s*:\s*unknown/.test(lineContext) && (fileCaminho.includes('cli') || /aplicar|process|handle/.test(lineContext))) {
         return {
             categoria: 'legitimo',
@@ -315,7 +233,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'CLI framework callback - opts validado downstream'
         };
     }
-    // Propriedades de índice dinâmico em type assertions - 95% legítimo
     if (/as\s+unknown\s+as\s+\{[^}]*:\s*unknown/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -323,7 +240,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Type assertion para acesso dinâmico - padrão de compatibilidade'
         };
     }
-    // Callbacks/handlers genéricos - análise contextual
     if (/(opts|options|params|args)\s*:\s*unknown/.test(lineContext)) {
         if (fileCaminho.includes('cli') || fileCaminho.includes('comando')) {
             return {
@@ -342,7 +258,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             variantes: ['interface FunctionOptions { timeout?: number; verbose?: boolean; ... }', 'Partial<KnownConfig> (se for subset de config)', 'Usar tipo genérico com constraint: <T extends BaseOptions>']
         };
     }
-    // Filter/map com unknown - 75% melhorável
     if (/filter\s*\(/.test(lineContext) || /map\s*\(/.test(lineContext)) {
         return {
             categoria: 'melhoravel',
@@ -352,7 +267,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             variantes: ['Especificar tipo do array: items: Item[] em vez de items: unknown[]', 'Usar generics: function filter<T>(items: T[], predicate: (item: T) => boolean)', 'Inferir do contexto: const typed = items as KnownType[]']
         };
     }
-    // Relatórios/fragmentação - 70% melhorável
     if (fileCaminho.includes('relatorio') || fileCaminho.includes('fragmentar') || lineContext.includes('Manifest')) {
         return {
             categoria: 'melhoravel',
@@ -362,7 +276,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             variantes: ['interface RelatorioCompleto { summary: Summary; detalhes: Detalhe[]; ... }', 'interface ManifestPart { id: string; tipo: string; conteudo: unknown }', 'type RelatorioJson = { version: string; data: Record<string, unknown> }']
         };
     }
-    // Compatibilidade de módulos - 95% legítimo
     if (fileCaminho.includes('chalk-safe') || /import\s*\(/.test(lineContext)) {
         return {
             categoria: 'legitimo',
@@ -371,9 +284,7 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             sugestao: 'Pode adicionar type assertion após validação runtime'
         };
     }
-    // Análise de contexto amplo quando específico falha
     const contextoAmplo = code.substring(Math.max(0, lineContext.length - 300), lineContext.length + 200);
-    // Verifica se há validação/type guard próximo
     if (/typeof\s+\w+\s*===/.test(contextoAmplo) || /instanceof/.test(contextoAmplo) || /is\w+\(/.test(contextoAmplo)) {
         return {
             categoria: 'melhoravel',
@@ -383,7 +294,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             variantes: ['Extrair validações para type guard reutilizável', 'Usar biblioteca de validação (zod, yup, io-ts) para runtime + types', 'Criar branded types se for validação complexa']
         };
     }
-    // Import dinâmico - 95% legítimo
     if (/\b(mod|module)\s*:\s*unknown\b/.test(lineContext) && /\bimport\s*\(/.test(contextoAmplo)) {
         return {
             categoria: 'legitimo',
@@ -392,7 +302,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             sugestao: 'Validar estrutura após import se necessário'
         };
     }
-    // Função de análise com type guard (isAstNode, etc) - 95% legítimo
     if (/(node|ast|tree)\s*:\s*unknown/.test(lineContext) && /is\w+\(/.test(contextoAmplo)) {
         return {
             categoria: 'legitimo',
@@ -400,7 +309,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Análise de AST/nodo com type guard - unknown + narrowing é padrão correto'
         };
     }
-    // Função de análise com validação interna - 90% legítimo
     if (hasInternalValidation(code, lineContext)) {
         return {
             categoria: 'legitimo',
@@ -408,7 +316,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             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)) {
         return {
             categoria: 'legitimo',
@@ -416,7 +323,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Função utilitária que recebe unknown e valida com typeof antes de usar'
         };
     }
-    // Função de validação/narrowing com retorno type predicate - 100% legítimo
     if (/:\s*unknown\)\s*:\s*\w+\s+is\s+/.test(contextoAmplo)) {
         return {
             categoria: 'legitimo',
@@ -424,7 +330,6 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             motivo: 'Type guard function - unknown é o tipo correto para a entrada'
         };
     }
-    // Default: melhorável com análise incerta
     return {
         categoria: 'melhoravel',
         confianca: CONFIANCA_PADRAO,

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

@@ -1,8 +1,3 @@
-// SPDX-License-Identifier: MIT
-/**
- * Sistema de Type Safety Auto-Fix
- * Exports principais
- */
 export * from './context-analyzer.js';
 export * from './type-analyzer.js';
 export * from './type-creator.js';

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

@@ -1,19 +1,10 @@
-// SPDX-License-Identifier: MIT
-/**
- * Analisador principal de tipos
- * Integra context-analyzer, usage-analyzer e type-inference
- */
 import { getTypesDirectoryDisplay } from '../../../core/config/index.js';
 import { getMessages } from '../../../core/messages/index.js';
 import { extractVariableName, getDomainFromFilePath, isDefinitionFile, isLegacyOrVendorFile, isTypeScriptFile } from './context-analyzer.js';
 import { inferTypeFromUsage } from './type-inference.js';
 import { analyzeUsagePatterns, findVariableUsages } from './usage-analyzer.js';
 const { MENSAGENS_CORRECAO_TIPOS } = getMessages();
-/**
- * Analisa uso de any/unknown e infere tipo correto
- */
 export function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
-    // 1. Criar contexto de inferência
     const context = {
         fileCaminho,
         domain: getDomainFromFilePath(fileCaminho),
@@ -23,7 +14,6 @@ export function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
         ast,
         code: fullCode
     };
-    // 2. Extrair nome da variável
     const varNome = extractVariableName(match, fullCode);
     if (!varNome) {
         return {
@@ -36,7 +26,6 @@ export function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
             suggestion: MENSAGENS_CORRECAO_TIPOS.erros.extrairNome
         };
     }
-    // 3. Encontrar usos da variável no AST
     const usages = findVariableUsages(varNome, ast);
     if (usages.length === 0) {
         return {
@@ -49,25 +38,16 @@ export function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
             suggestion: MENSAGENS_CORRECAO_TIPOS.erros.variavelNaoUsada
         };
     }
-    // 4. Analisar padrões de uso
     const patterns = analyzeUsagePatterns(usages);
-    // 5. Inferir tipo baseado nos padrões
     const typeAnalise = inferTypeFromUsage(varNome, patterns, fileCaminho);
-    // 6. Ajustar suggestedPath com domínio correto
     if (typeAnalise.suggestedPath) {
         typeAnalise.suggestedPath = `${context.domain}/${typeAnalise.suggestedPath}`;
     }
     return typeAnalise;
 }
-/**
- * Analisa uso de unknown com foco em type guards
- */
 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()}`;
     }

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

@@ -1,52 +1,33 @@
-// SPDX-License-Identifier: MIT
-/**
- * Sistema de criação de arquivos de tipos
- * Cria tipos no diretório configurado (conventions.typesDirectory) com organização correta
- */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { buildTypesFsPath } from '../../../core/config/index.js';
 import { toKebabCase } from './context-analyzer.js';
-/**
- * Cria definição de tipo no diretório configurado (conventions.typesDirectory)
- */
 export async function createTypeDefinition(analysis, sourceFilePath) {
     const domain = extractDomain(sourceFilePath);
     const fileNome = toKebabCase(analysis.typeName);
     const typeCaminho = buildTypesFsPath(path.posix.join(domain, `${fileNome}.ts`));
-    // Verificar se tipo já existe
     const existing = await findExistingType(analysis.typeName);
     if (existing) {
-        // Retornar caminho do alias existente
-        return `@types/types`; // Usar export centralizado
+        return `@types/types`;
     }
-    // Criar diretório se não existir (recursive é idempotente)
     const dir = path.dirname(typeCaminho);
     await fs.mkdir(dir, {
         recursive: true
     });
-    // Gerar conteúdo do arquivo
     const content = generateTypeFileContent(analysis, sourceFilePath);
-    // Escrever arquivo com flag 'wx' para evitar condição de corrida TOCTOU
     try {
         await fs.writeFile(typeCaminho, content, { encoding: 'utf-8', flag: 'wx' });
     }
     catch (err) {
         const code = err.code;
         if (code === 'EEXIST') {
-            // Tipo já foi criado concorrentemente, retornar alias
             return `@types/types`;
         }
         throw err;
     }
-    // Adicionar export ao index.ts do domínio
     await addExportToIndex(domain, fileNome);
-    // Retornar alias de import
     return `@types/types`;
 }
-/**
- * Busca tipo existente no diretório configurado (conventions.typesDirectory)
- */
 export async function findExistingType(typeName) {
     try {
         const tiposDir = buildTypesFsPath('');
@@ -62,17 +43,10 @@ export async function findExistingType(typeName) {
         return null;
     }
 }
-/**
- * Verifica se dois tipos são iguais
- */
 export function isSameType(type1, type2) {
-    // Simplificado - em produção, usar parser para comparação estrutural
     const normalize = (str) => str.replace(/\s+/g, ' ').trim();
     return normalize(type1.definition) === normalize(type2);
 }
-/**
- * Gera conteúdo do arquivo de tipo
- */
 function generateTypeFileContent(analysis, sourceFilePath) {
     const date = new Date().toISOString();
     return `// SPDX-License-Identifier: MIT
@@ -88,23 +62,17 @@ function generateTypeFileContent(analysis, sourceFilePath) {
 ${analysis.typeDefinition}
 `;
 }
-/**
- * Adiciona export ao index.ts do domínio
- */
 async function addExportToIndex(domain, fileNome) {
     const indexCaminho = buildTypesFsPath(path.posix.join(domain, 'index.ts'));
     try {
         const content = await fs.readFile(indexCaminho, 'utf-8');
-        // Verificar se export já existe
         const exportStatement = `export * from './${fileNome}.js';`;
         if (content.includes(exportStatement)) {
-            return; // Já existe
+            return;
         }
-        // Adicionar export
         await fs.appendFile(indexCaminho, `${exportStatement}\n`, 'utf-8');
     }
     catch {
-        // Criar index.ts se não existir
         const header = `// SPDX-License-Identifier: MIT
 /**
  * Exports do domínio ${domain}
@@ -115,16 +83,10 @@ async function addExportToIndex(domain, fileNome) {
         await fs.writeFile(indexCaminho, header + exportStatement, 'utf-8');
     }
 }
-/**
- * Extrai domínio do caminho do arquivo
- */
 function extractDomain(fileCaminho) {
     const match = fileCaminho.match(/src[\\/]([\w-]+)[\\/]/);
     return match ? match[1] : 'shared';
 }
-/**
- * Escaneia diretório de tipos
- */
 async function scanTypesDirectory(dir) {
     const types = [];
     try {
@@ -134,12 +96,10 @@ async function scanTypesDirectory(dir) {
         for (const entry of entries) {
             const fullCaminho = path.join(dir, entry.name);
             if (entry.isDirectory()) {
-                // Recursivo
                 const subTipos = await scanTypesDirectory(fullCaminho);
                 types.push(...subTipos);
             }
             else if (entry.name.endsWith('.ts') && entry.name !== 'index.ts') {
-                // Ler arquivo e extrair tipos
                 const content = await fs.readFile(fullCaminho, 'utf-8');
                 const extractedTipos = extractTypesFromFile(content, fullCaminho);
                 types.push(...extractedTipos);
@@ -147,20 +107,14 @@ async function scanTypesDirectory(dir) {
         }
     }
     catch {
-        // Ignorar erros
     }
     return types;
 }
-/**
- * Extrai tipos de um arquivo
- */
 function extractTypesFromFile(content, fileCaminho) {
     const types = [];
-    // Regex simples para encontrar interfaces e types exportados
     const interfaceRegex = /export\s+interface\s+(\w+)\s*{([^}]*)}/g;
     const typeRegex = /export\s+type\s+(\w+)\s*=\s*([^;]+);/g;
     let match;
-    // Interfaces
     while ((match = interfaceRegex.exec(content)) !== null) {
         types.push({
             name: match[1],
@@ -170,7 +124,6 @@ function extractTypesFromFile(content, fileCaminho) {
             domain: extractDomain(fileCaminho)
         });
     }
-    // Types
     while ((match = typeRegex.exec(content)) !== null) {
         types.push({
             name: match[1],