@mocoto/mahoraga 0.14.0 → 0.14.1

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

@@ -1,10 +1,19 @@
+// 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();
-export async function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
+/**
+ * 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),
@@ -14,6 +23,7 @@ export async function analyzeTypeUsage(match, fullCode, fileCaminho, ast) {
         ast,
         code: fullCode
     };
+    // 2. Extrair nome da variável
     const varNome = extractVariableName(match, fullCode);
     if (!varNome) {
         return {
@@ -26,6 +36,7 @@ export async 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 {
@@ -38,19 +49,27 @@ export async 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 async function analyzeUnknownUsage(match, fullCode, fileCaminho, ast) {
-    const analysis = await analyzeTypeUsage(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()}`;
     }
     return analysis;
 }
-//# sourceMappingURL=type-analyzer.js.map

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

@@ -1,33 +1,52 @@
+// 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) {
-        return `@types/types`;
+        // Retornar caminho do alias existente
+        return `@types/types`; // Usar export centralizado
     }
+    // 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('');
@@ -43,10 +62,17 @@ 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
@@ -62,17 +88,23 @@ 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;
+            return; // Já existe
         }
+        // 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}
@@ -83,10 +115,16 @@ 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 {
@@ -96,10 +134,12 @@ 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);
@@ -107,14 +147,20 @@ 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],
@@ -124,6 +170,7 @@ function extractTypesFromFile(content, fileCaminho) {
             domain: extractDomain(fileCaminho)
         });
     }
+    // Types
     while ((match = typeRegex.exec(content)) !== null) {
         types.push({
             name: match[1],
@@ -135,4 +182,3 @@ function extractTypesFromFile(content, fileCaminho) {
     }
     return types;
 }
-//# sourceMappingURL=type-creator.js.map

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

@@ -1,4 +1,14 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable tipo-literal-inline-complexo
+// Justificativa: tipos locais para inferência de tipos
+/**
+ * Módulo de inferência de tipos
+ * Infere tipos primitivos e cria interfaces para objetos complexos
+ */
 import { toKebabCase } from './context-analyzer.js';
+/**
+ * Infere tipo baseado em padrões de uso
+ */
 export function inferTypeFromUsage(varNome, patterns, _filePath) {
     const result = {
         confidence: 0,
@@ -8,31 +18,37 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         typeDefinition: '',
         suggestedPath: ''
     };
+    // Tipo primitivo: string
     if (patterns.allUsagesAreString) {
         result.inferredTipo = 'string';
         result.isSimpleType = true;
         result.confidence = 95;
         return result;
     }
+    // Tipo primitivo: number
     if (patterns.allUsagesAreNumber) {
         result.inferredTipo = 'number';
         result.isSimpleType = true;
         result.confidence = 95;
         return result;
     }
+    // Tipo primitivo: boolean
     if (patterns.allUsagesAreBoolean) {
         result.inferredTipo = 'boolean';
         result.isSimpleType = true;
         result.confidence = 95;
         return result;
     }
+    // Array
     if (patterns.isArray) {
+        // Tentar inferir tipo do array
         const elementTipo = inferArrayElementType(patterns);
         result.inferredTipo = `${elementTipo}[]`;
         result.isSimpleType = elementTipo === 'string' || elementTipo === 'number' || elementTipo === 'boolean';
         result.confidence = 85;
         return result;
     }
+    // Function
     if (patterns.isFunction) {
         result.inferredTipo = 'Function';
         result.isSimpleType = true;
@@ -40,6 +56,7 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.suggestion = 'Considere usar tipo de função específico: (param: T) => R';
         return result;
     }
+    // Objeto complexo
     if (patterns.hasObjectStructure && patterns.objectProperties) {
         const inferredInterface = inferInterfaceFromProperties(varNome, patterns.objectProperties);
         result.inferredTipo = inferredInterface.name;
@@ -52,6 +69,7 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.requiresImport = true;
         return result;
     }
+    // Type guards encontrados
     if (patterns.hasTypeGuards && patterns.typeGuards) {
         const guardTipo = extractTypeFromGuards(patterns.typeGuards);
         result.inferredTipo = guardTipo.type;
@@ -59,6 +77,7 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.confidence = guardTipo.confidence;
         return result;
     }
+    // União de tipos detectada
     if (patterns.unionTypes && patterns.unionTypes.length > 0) {
         result.inferredTipo = patterns.unionTypes.join(' | ');
         result.isSimpleType = false;
@@ -66,11 +85,15 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.suggestion = 'Considere criar type alias para união complexa';
         return result;
     }
+    // Não conseguiu inferir
     result.inferredTipo = 'unknown';
     result.confidence = 30;
     result.suggestion = 'Adicione type guards ou crie tipo dedicado manualmente';
     return result;
 }
+/**
+ * Cria interface baseado em propriedades detectadas
+ */
 export function inferInterfaceFromProperties(varNome, properties) {
     const interfaceNome = toPascalCase(varNome);
     const confidence = calculateInterfaceConfidence(properties);
@@ -86,6 +109,9 @@ export function inferInterfaceFromProperties(varNome, properties) {
         properties
     };
 }
+/**
+ * Extrai tipo de type guards
+ */
 export function extractTypeFromGuards(typeGuards) {
     if (typeGuards.length === 0) {
         return {
@@ -93,6 +119,7 @@ export function extractTypeFromGuards(typeGuards) {
             confidence: 0
         };
     }
+    // Se todos os guards apontam para o mesmo tipo
     const types = typeGuards.map(grupo => grupo.inferredTipo);
     const uniqueTipos = [...new Set(types)];
     if (uniqueTipos.length === 1) {
@@ -102,38 +129,58 @@ export function extractTypeFromGuards(typeGuards) {
             confidence: avgConfidence
         };
     }
+    // Múltiplos tipos - criar união
     const avgConfidence = typeGuards.reduce((sum, grupo) => sum + grupo.confidence, 0) / typeGuards.length;
     return {
         type: uniqueTipos.join(' | '),
         confidence: avgConfidence * 0.9
-    };
+    }; // Penalizar união
 }
+/**
+ * Calcula confiança da interface baseado nas propriedades
+ */
 function calculateInterfaceConfidence(properties) {
     if (properties.length === 0) {
         return 30;
     }
+    // Média da confiança das propriedades
     const avgConfidence = properties.reduce((sum, prop) => sum + prop.confidence, 0) / properties.length;
+    // Bonus por número de propriedades (mais propriedades = mais confiável)
     let bonus = 0;
-    if (properties.length >= 3)
+    if (properties.length >= 3) {
         bonus = 5;
-    if (properties.length >= 5)
+    }
+    if (properties.length >= 5) {
         bonus = 10;
+    }
     return Math.min(100, Math.round(avgConfidence + bonus));
 }
+/**
+ * Infere tipo de elemento de array
+ */
 function inferArrayElementType(patterns) {
-    if (patterns.allUsagesAreString)
+    // Simplificado - em produção, analisar elementos do array
+    if (patterns.allUsagesAreString) {
         return 'string';
-    if (patterns.allUsagesAreNumber)
+    }
+    if (patterns.allUsagesAreNumber) {
         return 'number';
-    if (patterns.allUsagesAreBoolean)
+    }
+    if (patterns.allUsagesAreBoolean) {
         return 'boolean';
+    }
     return 'unknown';
 }
+/**
+ * Verifica se é tipo primitivo
+ */
 function isPrimitiveType(type) {
     const primitives = ['string', 'number', 'boolean', 'null', 'undefined', 'symbol', 'bigint'];
     return primitives.includes(type.toLowerCase());
 }
+/**
+ * Converte string para PascalCase
+ */
 function toPascalCase(str) {
     return str.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\s_-]+/).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
 }
-//# sourceMappingURL=type-inference.js.map

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

@@ -1,4 +1,12 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Validação de tipos criados/modificados
+ * Verifica compatibilidade e compilação TypeScript
+ */
 import { findExistingType, isSameType } from './type-creator.js';
+/**
+ * Valida substituição de tipo (any/unknown → specific)
+ */
 export async function validateTypeReplacement(originalCode, fixedCodigo, typeAnalise) {
     const result = {
         isCompatible: true,
@@ -6,17 +14,20 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
         errors: [],
         warnings: []
     };
+    // 1. Verificar se tipo criado já existe com definição diferente
     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}`);
         }
     }
+    // 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.isCompatible = false;
     }
+    // 3. Verificar se import foi adicionado corretamente
     if (typeAnalise.requiresImport) {
         const hasCorrectImport = fixedCodigo.includes(`import type { ${typeAnalise.typeName} }`) || fixedCodigo.includes(`import { type ${typeAnalise.typeName} }`);
         if (!hasCorrectImport) {
@@ -24,9 +35,11 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
             result.isCompatible = false;
         }
     }
+    // 4. Verificar confiança mínima
     if (typeAnalise.confidence < 60) {
         result.warnings.push(`Confiança muito baixa (${typeAnalise.confidence}%). Considere revisão manual.`);
     }
+    // 5. Validar sintaxe básica do código modificado
     const syntaxValidation = validateBasicSyntax(fixedCodigo);
     if (!syntaxValidation.isValid) {
         result.errors.push(...syntaxValidation.errors);
@@ -34,24 +47,36 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
     }
     return result;
 }
+/**
+ * Valida compatibilidade do tipo inferido com uso real
+ */
 function validateTypeUsageCompatibility(code, typeAnalise) {
+    // Simplificado - em produção, usar TypeScript compiler API
+    // para verificação completa
+    // Por enquanto, considerar compatível se confiança >= 70%
     const isCompatible = typeAnalise.confidence >= 70;
     return {
         isCompatible,
         expectedType: typeAnalise.inferredTipo
     };
 }
+/**
+ * Valida sintaxe básica do código
+ */
 function validateBasicSyntax(code) {
     const errors = [];
-    const braceContagem = (code.match(/{/g) || []).length - (code.match(/}/g) || []).length;
+    // Verificar balanceamento de chaves
+    const braceContagem = (code.match(/{/g) ?? []).length - (code.match(/}/g) ?? []).length;
     if (braceContagem !== 0) {
         errors.push(`Chaves desbalanceadas: diferença de ${Math.abs(braceContagem)}`);
     }
-    const parenContagem = (code.match(/\(/g) || []).length - (code.match(/\)/g) || []).length;
+    // Verificar balanceamento de parênteses
+    const parenContagem = (code.match(/\(/g) ?? []).length - (code.match(/\)/g) ?? []).length;
     if (parenContagem !== 0) {
         errors.push(`Parênteses desbalanceados: diferença de ${Math.abs(parenContagem)}`);
     }
-    const bracketContagem = (code.match(/\[/g) || []).length - (code.match(/\]/g) || []).length;
+    // Verificar balanceamento de colchetes
+    const bracketContagem = (code.match(/\[/g) ?? []).length - (code.match(/\]/g) ?? []).length;
     if (bracketContagem !== 0) {
         errors.push(`Colchetes desbalanceados: diferença de ${Math.abs(bracketContagem)}`);
     }
@@ -60,17 +85,25 @@ function validateBasicSyntax(code) {
         errors
     };
 }
+/**
+ * Simula compilação TypeScript (simplificado)
+ * Em produção, usar TypeScript compiler API
+ */
 export function runTypeScriptCompiler(code) {
+    // Simplificado - validações básicas
     const errors = [];
+    // Verificar imports malformados
     const importLines = code.split('\n').filter(line => line.trim().startsWith('import'));
     for (const line of importLines) {
         if (!line.includes('from') && !line.includes('=')) {
             errors.push(`Import malformado: ${line.trim()}`);
         }
     }
+    // Verificar sintaxe de interface
     const interfaceRegex = /interface\s+\w+\s*{[^}]*}/g;
-    const interfaces = code.match(interfaceRegex) || [];
+    const interfaces = code.match(interfaceRegex) ?? [];
     for (const iface of interfaces) {
+        // Verificar propriedades
         const properties = iface.match(/\w+\s*\??\s*:\s*[\w\[\]<>|&\s]+;/g);
         if (!properties) {
             errors.push(`Interface malformada: ${iface.substring(0, 50)}...`);
@@ -81,4 +114,3 @@ export function runTypeScriptCompiler(code) {
         errors
     };
 }
-//# sourceMappingURL=type-validator.js.map