tutanus 0.12.0

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

@@ -0,0 +1,138 @@
+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';
+export async function createTypeDefinition(analysis, sourceFilePath) {
+    const domain = extractDomain(sourceFilePath);
+    const fileNome = toKebabCase(analysis.typeName);
+    const typeCaminho = buildTypesFsPath(path.posix.join(domain, `${fileNome}.ts`));
+    const existing = await findExistingType(analysis.typeName);
+    if (existing) {
+        return `@types/types`;
+    }
+    const dir = path.dirname(typeCaminho);
+    await fs.mkdir(dir, {
+        recursive: true
+    });
+    const content = generateTypeFileContent(analysis, sourceFilePath);
+    try {
+        await fs.writeFile(typeCaminho, content, { encoding: 'utf-8', flag: 'wx' });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'EEXIST') {
+            return `@types/types`;
+        }
+        throw err;
+    }
+    await addExportToIndex(domain, fileNome);
+    return `@types/types`;
+}
+export async function findExistingType(typeName) {
+    try {
+        const tiposDir = buildTypesFsPath('');
+        const types = await scanTypesDirectory(tiposDir);
+        for (const type of types) {
+            if (type.name === typeName) {
+                return type;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isSameType(type1, type2) {
+    const normalize = (str) => str.replace(/\s+/g, ' ').trim();
+    return normalize(type1.definition) === normalize(type2);
+}
+function generateTypeFileContent(analysis, sourceFilePath) {
+    const date = new Date().toISOString();
+    return `// SPDX-License-Identifier: MIT
+/**
+ * Tipo gerado automaticamente
+ * Origem: ${sourceFilePath}
+ * Confiança: ${analysis.confidence}%
+ * Data: ${date}
+ *
+ * @generated by tutanus fix-any-to-proper-type
+ */
+
+${analysis.typeDefinition}
+`;
+}
+async function addExportToIndex(domain, fileNome) {
+    const indexCaminho = buildTypesFsPath(path.posix.join(domain, 'index.ts'));
+    try {
+        const content = await fs.readFile(indexCaminho, 'utf-8');
+        const exportStatement = `export * from './${fileNome}.js';`;
+        if (content.includes(exportStatement)) {
+            return;
+        }
+        await fs.appendFile(indexCaminho, `${exportStatement}\n`, 'utf-8');
+    }
+    catch {
+        const header = `// SPDX-License-Identifier: MIT
+/**
+ * Exports do domínio ${domain}
+ */
+
+`;
+        const exportStatement = `export * from './${fileNome}.js';\n`;
+        await fs.writeFile(indexCaminho, header + exportStatement, 'utf-8');
+    }
+}
+function extractDomain(fileCaminho) {
+    const match = fileCaminho.match(/src[\\/]([\w-]+)[\\/]/);
+    return match ? match[1] : 'shared';
+}
+async function scanTypesDirectory(dir) {
+    const types = [];
+    try {
+        const entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const entry of entries) {
+            const fullCaminho = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const subTipos = await scanTypesDirectory(fullCaminho);
+                types.push(...subTipos);
+            }
+            else if (entry.name.endsWith('.ts') && entry.name !== 'index.ts') {
+                const content = await fs.readFile(fullCaminho, 'utf-8');
+                const extractedTipos = extractTypesFromFile(content, fullCaminho);
+                types.push(...extractedTipos);
+            }
+        }
+    }
+    catch {
+    }
+    return types;
+}
+function extractTypesFromFile(content, fileCaminho) {
+    const types = [];
+    const interfaceRegex = /export\s+interface\s+(\w+)\s*{([^}]*)}/g;
+    const typeRegex = /export\s+type\s+(\w+)\s*=\s*([^;]+);/g;
+    let match;
+    while ((match = interfaceRegex.exec(content)) !== null) {
+        types.push({
+            name: match[1],
+            path: fileCaminho,
+            definition: match[0],
+            isExported: true,
+            domain: extractDomain(fileCaminho)
+        });
+    }
+    while ((match = typeRegex.exec(content)) !== null) {
+        types.push({
+            name: match[1],
+            path: fileCaminho,
+            definition: match[0],
+            isExported: true,
+            domain: extractDomain(fileCaminho)
+        });
+    }
+    return types;
+}
+//# sourceMappingURL=type-creator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-creator.js","sourceRoot":"","sources":["../../../../src/analysts/corrections/type-safety/type-creator.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: MIT\n/**\n * Sistema de criação de arquivos de tipos\n * Cria tipos no diretório configurado (conventions.typesDirectory) com organização correta\n */\n\nimport { promises as fs } from 'node:fs';\nimport path from 'node:path';\n\nimport { buildTypesFsPath } from '@core/config';\n\nimport type { ExistingType, TypeAnalysis } from '@';\n\nimport { toKebabCase } from './context-analyzer.js';\n\n/**\n * Cria definição de tipo no diretório configurado (conventions.typesDirectory)\n */\nexport async function createTypeDefinition(analysis: TypeAnalysis, sourceFilePath: string): Promise<string> {\n  const domain = extractDomain(sourceFilePath);\n  const fileNome = toKebabCase(analysis.typeName);\n  const typeCaminho = buildTypesFsPath(path.posix.join(domain, `${fileNome}.ts`));\n\n  // Verificar se tipo já existe\n  const existing = await findExistingType(analysis.typeName);\n  if (existing) {\n    // Retornar caminho do alias existente\n    return `@types/types`; // Usar export centralizado\n  }\n\n  // Criar diretório se não existir (recursive é idempotente)\n  const dir = path.dirname(typeCaminho);\n  await fs.mkdir(dir, {\n    recursive: true\n  });\n\n  // Gerar conteúdo do arquivo\n  const content = generateTypeFileContent(analysis, sourceFilePath);\n\n  // Escrever arquivo com flag 'wx' para evitar condição de corrida TOCTOU\n  try {\n    await fs.writeFile(typeCaminho, content, { encoding: 'utf-8', flag: 'wx' });\n  } catch (err) {\n    const code = (err as NodeJS.ErrnoException).code;\n    if (code === 'EEXIST') {\n      // Tipo já foi criado concorrentemente, retornar alias\n      return `@types/types`;\n    }\n    throw err;\n  }\n\n  // Adicionar export ao index.ts do domínio\n  await addExportToIndex(domain, fileNome);\n\n  // Retornar alias de import\n  return `@types/types`;\n}\n\n/**\n * Busca tipo existente no diretório configurado (conventions.typesDirectory)\n */\nexport async function findExistingType(typeName: string): Promise<ExistingType | null> {\n  try {\n    const tiposDir = buildTypesFsPath('');\n    const types = await scanTypesDirectory(tiposDir);\n    for (const type of types) {\n      if (type.name === typeName) {\n        return type;\n      }\n    }\n    return null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Verifica se dois tipos são iguais\n */\nexport function isSameType(type1: ExistingType, type2: string): boolean {\n  // Simplificado - em produção, usar parser para comparação estrutural\n  const normalize = (str: string) => str.replace(/\\s+/g, ' ').trim();\n  return normalize(type1.definition) === normalize(type2);\n}\n\n/**\n * Gera conteúdo do arquivo de tipo\n */\nfunction generateTypeFileContent(analysis: TypeAnalysis, sourceFilePath: string): string {\n  const date = new Date().toISOString();\n  return `// SPDX-License-Identifier: MIT\n/**\n * Tipo gerado automaticamente\n * Origem: ${sourceFilePath}\n * Confiança: ${analysis.confidence}%\n * Data: ${date}\n *\n * @generated by tutanus fix-any-to-proper-type\n */\n\n${analysis.typeDefinition}\n`;\n}\n\n/**\n * Adiciona export ao index.ts do domínio\n */\nasync function addExportToIndex(domain: string, fileNome: string): Promise<void> {\n  const indexCaminho = buildTypesFsPath(path.posix.join(domain, 'index.ts'));\n  try {\n    const content = await fs.readFile(indexCaminho, 'utf-8');\n\n    // Verificar se export já existe\n    const exportStatement = `export * from './${fileNome}.js';`;\n    if (content.includes(exportStatement)) {\n      return; // Já existe\n    }\n\n    // Adicionar export\n    await fs.appendFile(indexCaminho, `${exportStatement}\\n`, 'utf-8');\n  } catch {\n    // Criar index.ts se não existir\n    const header = `// SPDX-License-Identifier: MIT\n/**\n * Exports do domínio ${domain}\n */\n\n`;\n    const exportStatement = `export * from './${fileNome}.js';\\n`;\n    await fs.writeFile(indexCaminho, header + exportStatement, 'utf-8');\n  }\n}\n\n/**\n * Extrai domínio do caminho do arquivo\n */\nfunction extractDomain(fileCaminho: string): string {\n  const match = fileCaminho.match(/src[\\\\/]([\\w-]+)[\\\\/]/);\n  return match ? match[1] : 'shared';\n}\n\n/**\n * Escaneia diretório de tipos\n */\nasync function scanTypesDirectory(dir: string): Promise<ExistingType[]> {\n  const types: ExistingType[] = [];\n  try {\n    const entries = await fs.readdir(dir, {\n      withFileTypes: true\n    });\n    for (const entry of entries) {\n      const fullCaminho = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        // Recursivo\n        const subTipos = await scanTypesDirectory(fullCaminho);\n        types.push(...subTipos);\n      } else if (entry.name.endsWith('.ts') && entry.name !== 'index.ts') {\n        // Ler arquivo e extrair tipos\n        const content = await fs.readFile(fullCaminho, 'utf-8');\n        const extractedTipos = extractTypesFromFile(content, fullCaminho);\n        types.push(...extractedTipos);\n      }\n    }\n  } catch {\n    // Ignorar erros\n  }\n  return types;\n}\n\n/**\n * Extrai tipos de um arquivo\n */\nfunction extractTypesFromFile(content: string, fileCaminho: string): ExistingType[] {\n  const types: ExistingType[] = [];\n\n  // Regex simples para encontrar interfaces e types exportados\n  const interfaceRegex = /export\\s+interface\\s+(\\w+)\\s*{([^}]*)}/g;\n  const typeRegex = /export\\s+type\\s+(\\w+)\\s*=\\s*([^;]+);/g;\n  let match;\n\n  // Interfaces\n  while ((match = interfaceRegex.exec(content)) !== null) {\n    types.push({\n      name: match[1],\n      path: fileCaminho,\n      definition: match[0],\n      isExported: true,\n      domain: extractDomain(fileCaminho)\n    });\n  }\n\n  // Types\n  while ((match = typeRegex.exec(content)) !== null) {\n    types.push({\n      name: match[1],\n      path: fileCaminho,\n      definition: match[0],\n      isExported: true,\n      domain: extractDomain(fileCaminho)\n    });\n  }\n  return types;\n}"]}

package/dist/analysts/corrections/type-safety/type-inference.d.ts

@@ -0,0 +1,12 @@
+import type { InferredInterface, PropertyUsage, TypeAnalysis, UsagePattern } from '../../../types/index.js';
+export declare function inferTypeFromUsage(varNome: string, patterns: UsagePattern, _filePath: string): TypeAnalysis;
+export declare function inferInterfaceFromProperties(varNome: string, properties: PropertyUsage[]): InferredInterface;
+export declare function extractTypeFromGuards(typeGuards: Array<{
+    type: string;
+    inferredTipo: string;
+    confidence: number;
+}>): {
+    type: string;
+    confidence: number;
+};
+//# sourceMappingURL=type-inference.d.ts.map

package/dist/analysts/corrections/type-safety/type-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-inference.d.ts","sourceRoot":"","sources":["../../../../src/analysts/corrections/type-safety/type-inference.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,CAAC;AAOtF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CA0F3G;AAKD,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,iBAAiB,CAc5G;AAKD,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,KAAK,CAAC;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,GAAG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAyBA"}

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

@@ -0,0 +1,139 @@
+import { toKebabCase } from './context-analyzer.js';
+export function inferTypeFromUsage(varNome, patterns, _filePath) {
+    const result = {
+        confidence: 0,
+        inferredTipo: 'unknown',
+        isSimpleType: false,
+        typeName: '',
+        typeDefinition: '',
+        suggestedPath: ''
+    };
+    if (patterns.allUsagesAreString) {
+        result.inferredTipo = 'string';
+        result.isSimpleType = true;
+        result.confidence = 95;
+        return result;
+    }
+    if (patterns.allUsagesAreNumber) {
+        result.inferredTipo = 'number';
+        result.isSimpleType = true;
+        result.confidence = 95;
+        return result;
+    }
+    if (patterns.allUsagesAreBoolean) {
+        result.inferredTipo = 'boolean';
+        result.isSimpleType = true;
+        result.confidence = 95;
+        return result;
+    }
+    if (patterns.isArray) {
+        const elementTipo = inferArrayElementType(patterns);
+        result.inferredTipo = `${elementTipo}[]`;
+        result.isSimpleType = elementTipo === 'string' || elementTipo === 'number' || elementTipo === 'boolean';
+        result.confidence = 85;
+        return result;
+    }
+    if (patterns.isFunction) {
+        result.inferredTipo = 'Function';
+        result.isSimpleType = true;
+        result.confidence = 80;
+        result.suggestion = 'Considere usar tipo de função específico: (param: T) => R';
+        return result;
+    }
+    if (patterns.hasObjectStructure && patterns.objectProperties) {
+        const inferredInterface = inferInterfaceFromProperties(varNome, patterns.objectProperties);
+        result.inferredTipo = inferredInterface.name;
+        result.typeName = inferredInterface.name;
+        result.typeDefinition = inferredInterface.definition;
+        result.isSimpleType = false;
+        result.confidence = inferredInterface.confidence;
+        result.suggestedPath = `${toKebabCase(inferredInterface.name)}.ts`;
+        result.createdNewType = true;
+        result.requiresImport = true;
+        return result;
+    }
+    if (patterns.hasTypeGuards && patterns.typeGuards) {
+        const guardTipo = extractTypeFromGuards(patterns.typeGuards);
+        result.inferredTipo = guardTipo.type;
+        result.isSimpleType = isPrimitiveType(guardTipo.type);
+        result.confidence = guardTipo.confidence;
+        return result;
+    }
+    if (patterns.unionTypes && patterns.unionTypes.length > 0) {
+        result.inferredTipo = patterns.unionTypes.join(' | ');
+        result.isSimpleType = false;
+        result.confidence = 70;
+        result.suggestion = 'Considere criar type alias para união complexa';
+        return result;
+    }
+    result.inferredTipo = 'unknown';
+    result.confidence = 30;
+    result.suggestion = 'Adicione type guards ou crie tipo dedicado manualmente';
+    return result;
+}
+export function inferInterfaceFromProperties(varNome, properties) {
+    const interfaceNome = toPascalCase(varNome);
+    const confidence = calculateInterfaceConfidence(properties);
+    const propertiesCodigo = properties.map(prop => {
+        const optional = prop.isOptional ? '?' : '';
+        return `  ${prop.name}${optional}: ${prop.inferredTipo};`;
+    }).join('\n');
+    const definition = `export interface ${interfaceNome} {\n${propertiesCodigo}\n}`;
+    return {
+        name: interfaceNome,
+        definition,
+        confidence,
+        properties
+    };
+}
+export function extractTypeFromGuards(typeGuards) {
+    if (typeGuards.length === 0) {
+        return {
+            type: 'unknown',
+            confidence: 0
+        };
+    }
+    const types = typeGuards.map(grupo => grupo.inferredTipo);
+    const uniqueTipos = [...new Set(types)];
+    if (uniqueTipos.length === 1) {
+        const avgConfidence = typeGuards.reduce((sum, grupo) => sum + grupo.confidence, 0) / typeGuards.length;
+        return {
+            type: uniqueTipos[0],
+            confidence: avgConfidence
+        };
+    }
+    const avgConfidence = typeGuards.reduce((sum, grupo) => sum + grupo.confidence, 0) / typeGuards.length;
+    return {
+        type: uniqueTipos.join(' | '),
+        confidence: avgConfidence * 0.9
+    };
+}
+function calculateInterfaceConfidence(properties) {
+    if (properties.length === 0) {
+        return 30;
+    }
+    const avgConfidence = properties.reduce((sum, prop) => sum + prop.confidence, 0) / properties.length;
+    let bonus = 0;
+    if (properties.length >= 3)
+        bonus = 5;
+    if (properties.length >= 5)
+        bonus = 10;
+    return Math.min(100, Math.round(avgConfidence + bonus));
+}
+function inferArrayElementType(patterns) {
+    if (patterns.allUsagesAreString)
+        return 'string';
+    if (patterns.allUsagesAreNumber)
+        return 'number';
+    if (patterns.allUsagesAreBoolean)
+        return 'boolean';
+    return 'unknown';
+}
+function isPrimitiveType(type) {
+    const primitives = ['string', 'number', 'boolean', 'null', 'undefined', 'symbol', 'bigint'];
+    return primitives.includes(type.toLowerCase());
+}
+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-inference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-inference.js","sourceRoot":"","sources":["../../../../src/analysts/corrections/type-safety/type-inference.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: MIT\n// @tutanus-disable tipo-literal-inline-complexo\n// Justificativa: tipos locais para inferência de tipos\n/**\n * Módulo de inferência de tipos\n * Infere tipos primitivos e cria interfaces para objetos complexos\n */\n\nimport type { InferredInterface, PropertyUsage, TypeAnalysis, UsagePattern } from '@';\n\nimport { toKebabCase } from './context-analyzer.js';\n\n/**\n * Infere tipo baseado em padrões de uso\n */\nexport function inferTypeFromUsage(varNome: string, patterns: UsagePattern, _filePath: string): TypeAnalysis {\n  const result: TypeAnalysis = {\n    confidence: 0,\n    inferredTipo: 'unknown',\n    isSimpleType: false,\n    typeName: '',\n    typeDefinition: '',\n    suggestedPath: ''\n  };\n\n  // Tipo primitivo: string\n  if (patterns.allUsagesAreString) {\n    result.inferredTipo = 'string';\n    result.isSimpleType = true;\n    result.confidence = 95;\n    return result;\n  }\n\n  // Tipo primitivo: number\n  if (patterns.allUsagesAreNumber) {\n    result.inferredTipo = 'number';\n    result.isSimpleType = true;\n    result.confidence = 95;\n    return result;\n  }\n\n  // Tipo primitivo: boolean\n  if (patterns.allUsagesAreBoolean) {\n    result.inferredTipo = 'boolean';\n    result.isSimpleType = true;\n    result.confidence = 95;\n    return result;\n  }\n\n  // Array\n  if (patterns.isArray) {\n    // Tentar inferir tipo do array\n    const elementTipo = inferArrayElementType(patterns);\n    result.inferredTipo = `${elementTipo}[]`;\n    result.isSimpleType = elementTipo === 'string' || elementTipo === 'number' || elementTipo === 'boolean';\n    result.confidence = 85;\n    return result;\n  }\n\n  // Function\n  if (patterns.isFunction) {\n    result.inferredTipo = 'Function';\n    result.isSimpleType = true;\n    result.confidence = 80;\n    result.suggestion = 'Considere usar tipo de função específico: (param: T) => R';\n    return result;\n  }\n\n  // Objeto complexo\n  if (patterns.hasObjectStructure && patterns.objectProperties) {\n    const inferredInterface = inferInterfaceFromProperties(varNome, patterns.objectProperties);\n    result.inferredTipo = inferredInterface.name;\n    result.typeName = inferredInterface.name;\n    result.typeDefinition = inferredInterface.definition;\n    result.isSimpleType = false;\n    result.confidence = inferredInterface.confidence;\n    result.suggestedPath = `${toKebabCase(inferredInterface.name)}.ts`;\n    result.createdNewType = true;\n    result.requiresImport = true;\n    return result;\n  }\n\n  // Type guards encontrados\n  if (patterns.hasTypeGuards && patterns.typeGuards) {\n    const guardTipo = extractTypeFromGuards(patterns.typeGuards);\n    result.inferredTipo = guardTipo.type;\n    result.isSimpleType = isPrimitiveType(guardTipo.type);\n    result.confidence = guardTipo.confidence;\n    return result;\n  }\n\n  // União de tipos detectada\n  if (patterns.unionTypes && patterns.unionTypes.length > 0) {\n    result.inferredTipo = patterns.unionTypes.join(' | ');\n    result.isSimpleType = false;\n    result.confidence = 70;\n    result.suggestion = 'Considere criar type alias para união complexa';\n    return result;\n  }\n\n  // Não conseguiu inferir\n  result.inferredTipo = 'unknown';\n  result.confidence = 30;\n  result.suggestion = 'Adicione type guards ou crie tipo dedicado manualmente';\n  return result;\n}\n\n/**\n * Cria interface baseado em propriedades detectadas\n */\nexport function inferInterfaceFromProperties(varNome: string, properties: PropertyUsage[]): InferredInterface {\n  const interfaceNome = toPascalCase(varNome);\n  const confidence = calculateInterfaceConfidence(properties);\n  const propertiesCodigo = properties.map(prop => {\n    const optional = prop.isOptional ? '?' : '';\n    return `  ${prop.name}${optional}: ${prop.inferredTipo};`;\n  }).join('\\n');\n  const definition = `export interface ${interfaceNome} {\\n${propertiesCodigo}\\n}`;\n  return {\n    name: interfaceNome,\n    definition,\n    confidence,\n    properties\n  };\n}\n\n/**\n * Extrai tipo de type guards\n */\nexport function extractTypeFromGuards(typeGuards: Array<{\n  type: string;\n  inferredTipo: string;\n  confidence: number;\n}>): {\n  type: string;\n  confidence: number;\n} {\n  if (typeGuards.length === 0) {\n    return {\n      type: 'unknown',\n      confidence: 0\n    };\n  }\n\n  // Se todos os guards apontam para o mesmo tipo\n  const types = typeGuards.map(grupo => grupo.inferredTipo);\n  const uniqueTipos = [...new Set(types)];\n  if (uniqueTipos.length === 1) {\n    const avgConfidence = typeGuards.reduce((sum, grupo) => sum + grupo.confidence, 0) / typeGuards.length;\n    return {\n      type: uniqueTipos[0],\n      confidence: avgConfidence\n    };\n  }\n\n  // Múltiplos tipos - criar união\n  const avgConfidence = typeGuards.reduce((sum, grupo) => sum + grupo.confidence, 0) / typeGuards.length;\n  return {\n    type: uniqueTipos.join(' | '),\n    confidence: avgConfidence * 0.9\n  }; // Penalizar união\n}\n\n/**\n * Calcula confiança da interface baseado nas propriedades\n */\nfunction calculateInterfaceConfidence(properties: PropertyUsage[]): number {\n  if (properties.length === 0) {\n    return 30;\n  }\n\n  // Média da confiança das propriedades\n  const avgConfidence = properties.reduce((sum, prop) => sum + prop.confidence, 0) / properties.length;\n\n  // Bonus por número de propriedades (mais propriedades = mais confiável)\n  let bonus = 0;\n  if (properties.length >= 3) bonus = 5;\n  if (properties.length >= 5) bonus = 10;\n  return Math.min(100, Math.round(avgConfidence + bonus));\n}\n\n/**\n * Infere tipo de elemento de array\n */\nfunction inferArrayElementType(patterns: UsagePattern): string {\n  // Simplificado - em produção, analisar elementos do array\n  if (patterns.allUsagesAreString) return 'string';\n  if (patterns.allUsagesAreNumber) return 'number';\n  if (patterns.allUsagesAreBoolean) return 'boolean';\n  return 'unknown';\n}\n\n/**\n * Verifica se é tipo primitivo\n */\nfunction isPrimitiveType(type: string): boolean {\n  const primitives = ['string', 'number', 'boolean', 'null', 'undefined', 'symbol', 'bigint'];\n  return primitives.includes(type.toLowerCase());\n}\n\n/**\n * Converte string para PascalCase\n */\nfunction toPascalCase(str: string): string {\n  return str.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\\s_-]+/).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');\n}"]}

package/dist/analysts/corrections/type-safety/type-validator.d.ts

@@ -0,0 +1,7 @@
+import type { TypeAnalysis, TypeReplacementValidation } from '../../../types/index.js';
+export declare function validateTypeReplacement(originalCode: string, fixedCodigo: string, typeAnalise: TypeAnalysis): Promise<TypeReplacementValidation>;
+export declare function runTypeScriptCompiler(code: string): {
+    hasErrors: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=type-validator.d.ts.map

package/dist/analysts/corrections/type-safety/type-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-validator.d.ts","sourceRoot":"","sources":["../../../../src/analysts/corrections/type-safety/type-validator.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,GAAG,CAAC;AAOjE,wBAAsB,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,GAAG,OAAO,CAAC,yBAAyB,CAAC,CA4CtJ;AAwDD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CA0BA"}

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

@@ -0,0 +1,84 @@
+import { findExistingType, isSameType } from './type-creator.js';
+export async function validateTypeReplacement(originalCode, fixedCodigo, typeAnalise) {
+    const result = {
+        isCompatible: true,
+        expectedType: typeAnalise.inferredTipo,
+        errors: [],
+        warnings: []
+    };
+    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}`);
+        }
+    }
+    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;
+    }
+    if (typeAnalise.requiresImport) {
+        const hasCorrectImport = fixedCodigo.includes(`import type { ${typeAnalise.typeName} }`) || fixedCodigo.includes(`import { type ${typeAnalise.typeName} }`);
+        if (!hasCorrectImport) {
+            result.errors.push(`Import de tipo ${typeAnalise.typeName} não encontrado`);
+            result.isCompatible = false;
+        }
+    }
+    if (typeAnalise.confidence < 60) {
+        result.warnings.push(`Confiança muito baixa (${typeAnalise.confidence}%). Considere revisão manual.`);
+    }
+    const syntaxValidation = validateBasicSyntax(fixedCodigo);
+    if (!syntaxValidation.isValid) {
+        result.errors.push(...syntaxValidation.errors);
+        result.isCompatible = false;
+    }
+    return result;
+}
+function validateTypeUsageCompatibility(code, typeAnalise) {
+    const isCompatible = typeAnalise.confidence >= 70;
+    return {
+        isCompatible,
+        expectedType: typeAnalise.inferredTipo
+    };
+}
+function validateBasicSyntax(code) {
+    const errors = [];
+    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;
+    if (parenContagem !== 0) {
+        errors.push(`Parênteses desbalanceados: diferença de ${Math.abs(parenContagem)}`);
+    }
+    const bracketContagem = (code.match(/\[/g) || []).length - (code.match(/\]/g) || []).length;
+    if (bracketContagem !== 0) {
+        errors.push(`Colchetes desbalanceados: diferença de ${Math.abs(bracketContagem)}`);
+    }
+    return {
+        isValid: errors.length === 0,
+        errors
+    };
+}
+export function runTypeScriptCompiler(code) {
+    const errors = [];
+    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()}`);
+        }
+    }
+    const interfaceRegex = /interface\s+\w+\s*{[^}]*}/g;
+    const interfaces = code.match(interfaceRegex) || [];
+    for (const iface of interfaces) {
+        const properties = iface.match(/\w+\s*\??\s*:\s*[\w\[\]<>|&\s]+;/g);
+        if (!properties) {
+            errors.push(`Interface malformada: ${iface.substring(0, 50)}...`);
+        }
+    }
+    return {
+        hasErrors: errors.length > 0,
+        errors
+    };
+}
+//# sourceMappingURL=type-validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-validator.js","sourceRoot":"","sources":["../../../../src/analysts/corrections/type-safety/type-validator.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: MIT\n/**\n * Validação de tipos criados/modificados\n * Verifica compatibilidade e compilação TypeScript\n */\n\nimport type { TypeAnalysis, TypeReplacementValidation } from '@';\n\nimport { findExistingType, isSameType } from './type-creator.js';\n\n/**\n * Valida substituição de tipo (any/unknown → specific)\n */\nexport async function validateTypeReplacement(originalCode: string, fixedCodigo: string, typeAnalise: TypeAnalysis): Promise<TypeReplacementValidation> {\n  const result: TypeReplacementValidation = {\n    isCompatible: true,\n    expectedType: typeAnalise.inferredTipo,\n    errors: [],\n    warnings: []\n  };\n\n  // 1. Verificar se tipo criado já existe com definição diferente\n  if (typeAnalise.createdNewType) {\n    const existingTipo = await findExistingType(typeAnalise.typeName);\n    if (existingTipo && !isSameType(existingTipo, typeAnalise.typeDefinition)) {\n      result.warnings.push(`Tipo ${typeAnalise.typeName} já existe com definição diferente. ` + `Verifique conflito em ${existingTipo.path}`);\n    }\n  }\n\n  // 2. Verificar se tipo inferido é compatível com uso\n  const usageValidation = validateTypeUsageCompatibility(fixedCodigo, typeAnalise);\n  if (!usageValidation.isCompatible) {\n    result.errors.push(`Tipo inferido ${typeAnalise.inferredTipo} incompatível com uso detectado. ` + `Esperado: ${usageValidation.expectedType}`);\n    result.isCompatible = false;\n  }\n\n  // 3. Verificar se import foi adicionado corretamente\n  if (typeAnalise.requiresImport) {\n    const hasCorrectImport = fixedCodigo.includes(`import type { ${typeAnalise.typeName} }`) || fixedCodigo.includes(`import { type ${typeAnalise.typeName} }`);\n    if (!hasCorrectImport) {\n      result.errors.push(`Import de tipo ${typeAnalise.typeName} não encontrado`);\n      result.isCompatible = false;\n    }\n  }\n\n  // 4. Verificar confiança mínima\n  if (typeAnalise.confidence < 60) {\n    result.warnings.push(`Confiança muito baixa (${typeAnalise.confidence}%). Considere revisão manual.`);\n  }\n\n  // 5. Validar sintaxe básica do código modificado\n  const syntaxValidation = validateBasicSyntax(fixedCodigo);\n  if (!syntaxValidation.isValid) {\n    result.errors.push(...syntaxValidation.errors);\n    result.isCompatible = false;\n  }\n  return result;\n}\n\n/**\n * Valida compatibilidade do tipo inferido com uso real\n */\nfunction validateTypeUsageCompatibility(code: string, typeAnalise: TypeAnalysis): {\n  isCompatible: boolean;\n  expectedType: string;\n} {\n  // Simplificado - em produção, usar TypeScript compiler API\n  // para verificação completa\n\n  // Por enquanto, considerar compatível se confiança >= 70%\n  const isCompatible = typeAnalise.confidence >= 70;\n  return {\n    isCompatible,\n    expectedType: typeAnalise.inferredTipo\n  };\n}\n\n/**\n * Valida sintaxe básica do código\n */\nfunction validateBasicSyntax(code: string): {\n  isValid: boolean;\n  errors: string[];\n} {\n  const errors: string[] = [];\n\n  // Verificar balanceamento de chaves\n  const braceContagem = (code.match(/{/g) || []).length - (code.match(/}/g) || []).length;\n  if (braceContagem !== 0) {\n    errors.push(`Chaves desbalanceadas: diferença de ${Math.abs(braceContagem)}`);\n  }\n\n  // Verificar balanceamento de parênteses\n  const parenContagem = (code.match(/\\(/g) || []).length - (code.match(/\\)/g) || []).length;\n  if (parenContagem !== 0) {\n    errors.push(`Parênteses desbalanceados: diferença de ${Math.abs(parenContagem)}`);\n  }\n\n  // Verificar balanceamento de colchetes\n  const bracketContagem = (code.match(/\\[/g) || []).length - (code.match(/\\]/g) || []).length;\n  if (bracketContagem !== 0) {\n    errors.push(`Colchetes desbalanceados: diferença de ${Math.abs(bracketContagem)}`);\n  }\n  return {\n    isValid: errors.length === 0,\n    errors\n  };\n}\n\n/**\n * Simula compilação TypeScript (simplificado)\n * Em produção, usar TypeScript compiler API\n */\nexport function runTypeScriptCompiler(code: string): {\n  hasErrors: boolean;\n  errors: string[];\n} {\n  // Simplificado - validações básicas\n  const errors: string[] = [];\n\n  // Verificar imports malformados\n  const importLines = code.split('\\n').filter(line => line.trim().startsWith('import'));\n  for (const line of importLines) {\n    if (!line.includes('from') && !line.includes('=')) {\n      errors.push(`Import malformado: ${line.trim()}`);\n    }\n  }\n\n  // Verificar sintaxe de interface\n  const interfaceRegex = /interface\\s+\\w+\\s*{[^}]*}/g;\n  const interfaces = code.match(interfaceRegex) || [];\n  for (const iface of interfaces) {\n    // Verificar propriedades\n    const properties = iface.match(/\\w+\\s*\\??\\s*:\\s*[\\w\\[\\]<>|&\\s]+;/g);\n    if (!properties) {\n      errors.push(`Interface malformada: ${iface.substring(0, 50)}...`);\n    }\n  }\n  return {\n    hasErrors: errors.length > 0,\n    errors\n  };\n}"]}

package/dist/analysts/corrections/type-safety/usage-analyzer.d.ts

@@ -0,0 +1,5 @@
+import type { Node } from '@babel/types';
+import type { UsagePattern, VariableUsage } from '../../../types/index.js';
+export declare function findVariableUsages(varNome: string, ast: Node | null): VariableUsage[];
+export declare function analyzeUsagePatterns(usages: VariableUsage[]): UsagePattern;
+//# sourceMappingURL=usage-analyzer.d.ts.map

package/dist/analysts/corrections/type-safety/usage-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/analysts/corrections/type-safety/usage-analyzer.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,KAAK,EAAqC,YAAY,EAAE,aAAa,EAAE,MAAM,GAAG,CAAC;AAKxF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,aAAa,EAAE,CAiCrF;AAKD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,YAAY,CAsD1E"}