@mocoto/mahoraga 0.14.0 → 0.14.1

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

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable tipo-literal-inline-complexo
+// Justificativa: tipos locais usados internamente para parsing de caminhos
 import fsSync from 'node:fs';
 import path from 'node:path';
 const _TOP_DIRS = new Set(['analysts', 'arquitetos', 'cli', 'guardian', 'nucleo', 'reports', 'tipos', 'auto']);
@@ -16,30 +19,34 @@ 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) {
     const absTs = pathFromAlias(`${aliasBase}.ts`, srcRoot);
     const absJs = pathFromAlias(`${aliasBase}.js`, srcRoot);
-    if (exists(absTs))
+    if (exists(absTs)) {
         return `${aliasBase}.ts`;
-    if (exists(absJs))
+    }
+    if (exists(absJs)) {
         return `${aliasBase}.js`;
+    }
     return `${aliasBase}.ts`;
 }
 export function rewriteToAlias(spec, ctx) {
     const posixSpec = toPosix(spec);
     if (posixSpec.startsWith('@') || /^([a-zA-Z]+:|node:|[a-zA-Z0-9_-]+)$/.test(posixSpec)) {
-        if (!posixSpec.startsWith('@'))
+        if (!posixSpec.startsWith('@')) {
             return {
                 changed: false,
                 value: spec
             };
+        }
         const withoutExt = posixSpec.replace(/\.(ts|js|mjs|cjs|tsx|jsx)$/i, '');
         let mapped = LEGADO_ALIAS_MAPA.get(withoutExt);
-        if (!mapped && withoutExt.startsWith('@cli/src/'))
+        if (!mapped && withoutExt.startsWith('@cli/src/')) {
             mapped = withoutExt;
+        }
         if (mapped) {
             const withExt = pickExtForAlias(mapped, ctx.srcRoot);
             return {
@@ -62,29 +69,33 @@ export function transformCodeForTests(code, ctx) {
     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)
+        if (!result.changed) {
             return metrica;
+        }
         changed = true;
         return `${p1}${delimitadorString}${result.value}${delimitadorString}`;
     });
     code = code.replace(/(import\s*)(["'])([^"']+?)\2/g, (metrica, p1, delimitadorString, spec) => {
         const result = rewrite(spec);
-        if (!result.changed)
+        if (!result.changed) {
             return metrica;
+        }
         changed = true;
         return `${p1}${delimitadorString}${result.value}${delimitadorString}`;
     });
     code = code.replace(/(import\s*\()(\s*["'])([^"']+?)(["']\s*\))/g, (metrica, p1, q1, spec, q2) => {
         const result = rewrite(spec);
-        if (!result.changed)
+        if (!result.changed) {
             return metrica;
+        }
         changed = true;
         return `${p1}${q1}${result.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)
+        if (!result.changed) {
             return metrica;
+        }
         changed = true;
         return `${p1}${q1}${result.value}${q2}${comma}`;
     });
@@ -93,4 +104,3 @@ export function transformCodeForTests(code, ctx) {
         changed
     };
 }
-//# sourceMappingURL=rewrite-testes-aliases.js.map

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

@@ -1,4 +1,6 @@
+// SPDX-License-Identifier: MIT
 import { isInStringOrComment } from '../../shared/helpers/index.js';
+// Constantes de limites e valores de threshold
 export const LIMITES = {
     ASCII_EXTENDED_MIN: 128,
     CARACTERES_INCOMUNS_PADRAO: 10,
@@ -8,11 +10,13 @@ export const LIMITES = {
 };
 export const INTERVALOS_UNICODE_COMUNS = [[0x0080, 0x00FF], [0x0100, 0x017F], [0x0180, 0x024F], [0x0250, 0x02AF], [0x02B0, 0x02FF], [0x0300, 0x036F], [0x0370, 0x03FF], [0x0400, 0x04FF], [0x2000, 0x206F], [0x2070, 0x209F], [0x20A0, 0x20CF], [0x2100, 0x214F], [0x2190, 0x21FF], [0x2200, 0x22FF], [0x2500, 0x257F], [0x2580, 0x259F], [0x25A0, 0x25FF], [0x2600, 0x26FF], [0x2700, 0x27BF], [0x3000, 0x30FF], [0x4E00, 0x9FFF], [0xAC00, 0xD7AF], [0xFE00, 0xFE0F], [0xFF00, 0xFFEF], [0x1F300, 0x1F5FF], [0x1F600, 0x1F64F], [0x1F680, 0x1F6FF], [0x1F700, 0x1F77F], [0x1F780, 0x1F7FF], [0x1F800, 0x1F8FF], [0x1F900, 0x1F9FF], [0x1FA00, 0x1FA6F], [0x1FA70, 0x1FAFF], [0xE0001, 0xE0001], [0xE0020, 0xE007F]];
 export function isCaractereComum(code) {
-    if (code >= 0xD800 && code <= 0xDFFF)
+    if (code >= 0xD800 && code <= 0xDFFF) {
         return true;
+    }
     for (const [inicio, fim] of INTERVALOS_UNICODE_COMUNS) {
-        if (code >= inicio && code <= fim)
+        if (code >= inicio && code <= fim) {
             return true;
+        }
     }
     return false;
 }
@@ -71,6 +75,9 @@ export const CONFIGURACAO_PADRAO = {
     detectarCaracteresIncomuns: true,
     limiteCaracteresIncomuns: LIMITES.CARACTERES_INCOMUNS_PADRAO
 };
+/**
+ * Normaliza caracteres Unicode comuns para seus equivalentes ASCII.
+ */
 export function normalizeUnicode(input) {
     let normalized = input.normalize('NFKC');
     let changed = false;
@@ -85,15 +92,23 @@ export function normalizeUnicode(input) {
         changed
     };
 }
+/**
+ * Verifica se a posição está em contexto TypeScript onde ':' ou outros podem ser válidos.
+ */
 export function isTypeScriptContext(src, index) {
     const before = src.substring(Math.max(0, index - LIMITES.CONTEXTO_TYPESCRIPT_LOOKBACK), index);
     const after = src.substring(index, Math.min(src.length, index + LIMITES.CONTEXTO_TYPESCRIPT_LOOKAHEAD));
     const tsPadroes = [/\?\s*:\s*$/,
+        // Ternário: a ? b :
         /:\s*\?/,
+        // Tipo opcional: prop?: string
         /\(\?\s*:\s*$/,
+        // Non-capturing group: (?:
         /interface\s+\w+\s*{/,
+        // Interface declaration
         /type\s+\w+\s*=/,
-        /<[^>]*$/
+        // Type alias
+        /<[^>]*$/ // Generics: Array<Type>
     ];
     return tsPadroes.some(pattern => pattern.test(before) || pattern.test(after));
 }
@@ -110,47 +125,61 @@ function isMarkdownOrCodePattern(text, index, matchStr) {
     if (/^{-{3,}}/.test(line.trim()) || /^\*{3,}\*/.test(line.trim())) {
         return true;
     }
+    // Ignorar blockquote markdown: > no início da linha
     if (/^>\s?/.test(line) && posInLine === 0) {
         return true;
     }
+    // Ignorar lista não-ordenada markdown: - ou * no início da linha
     if (/^[-*]\s/.test(line) && posInLine === 0) {
         return true;
     }
+    // Ignorar lista ordenada markdown: 1. 2. etc
     if (/^\d+\.\s/.test(line) && posInLine === 0) {
         return true;
     }
     const beforeInLine = line.substring(0, posInLine);
     const afterInLine = line.substring(posInLine + matchStr.length);
     if (matchStr[0] === '*') {
-        const openStars = (beforeInLine.match(/\*/g) || []).length;
-        const closeStars = (afterInLine.match(/\*/g) || []).length;
-        if (openStars % 2 === 1 && closeStars >= 1)
+        const openStars = (beforeInLine.match(/\*/g) ?? []).length;
+        const closeStars = (afterInLine.match(/\*/g) ?? []).length;
+        if (openStars % 2 === 1 && closeStars >= 1) {
             return true;
-        if (/\*\*[^*]*$/.test(beforeInLine) && /^[^*]*\*\*/.test(afterInLine))
+        }
+        if (/\*\*[^*]*$/.test(beforeInLine) && /^[^*]*\*\*/.test(afterInLine)) {
             return true;
+        }
     }
     if (matchStr[0] === '_') {
-        const openUnders = (beforeInLine.match(/_/g) || []).length;
-        const closeUnders = (afterInLine.match(/_/g) || []).length;
-        if (openUnders % 2 === 1 && closeUnders >= 1)
+        const openUnders = (beforeInLine.match(/_/g) ?? []).length;
+        const closeUnders = (afterInLine.match(/_/g) ?? []).length;
+        if (openUnders % 2 === 1 && closeUnders >= 1) {
             return true;
+        }
     }
-    if (matchStr[0] === '-' && /^-{3,}$/.test(matchStr))
+    if (matchStr[0] === '-' && /^-{3,}$/.test(matchStr)) {
         return true;
+    }
     if (matchStr === '--' || matchStr === '::' || matchStr === '**') {
         return true;
     }
+    // Ignorar linhas de tabela markdown: |---|---|
     if (/^\|.*\|$/.test(line.trim())) {
         return true;
     }
+    // Ignorar comandos com : sem espaço (licenses:notice, namespace:name)
     if (matchStr === ':' && /^[\w-]+:[\w./@-]+/.test(afterInLine.trimStart())) {
         return true;
     }
+    // CLI flags: --flag, --option=value
     if (matchStr === '--' && /^-\w/.test(afterInLine)) {
         return true;
     }
     return false;
 }
+/**
+ * Colapsa pontuação repetida (ex: .. -> .) respeitando contextos de string, comentário e TypeScript.
+ * Mantém até 3 caracteres para .!? (ex: !!! -> !!!), colapsa outros para único.
+ */
 export function collapseRepeatedPunct(string) {
     let count = 0;
     const { text: protectedStr, placeholders } = protectSequences(string);
@@ -189,6 +218,9 @@ export function collapseRepeatedPunct(string) {
         count
     };
 }
+/**
+ * Corrige espaçamento básico ao redor de pontuações comuns.
+ */
 export function fixSpacingAroundPunct(string) {
     const { text: protected_s, placeholders } = protectSequences(string);
     const t1 = protected_s.replace(SPACE_BEFORE_PUNCT_RE, '$1');
@@ -204,12 +236,16 @@ export function fixSpacingAroundPunct(string) {
         count
     };
 }
+/**
+ * Detecta caracteres fora do range ASCII comum.
+ */
 export function detectUncommonChars(text, limite) {
     const issues = [];
     let pos = 0;
     for (const ch of text) {
-        if (issues.length >= (limite ?? Infinity))
+        if (issues.length >= (limite ?? Infinity)) {
             break;
+        }
         const code = ch.codePointAt(0) ?? 0;
         if (code >= LIMITES.ASCII_EXTENDED_MIN && !isCaractereComum(code)) {
             const name = (() => {
@@ -243,6 +279,9 @@ export function detectUncommonChars(text, limite) {
     }
     return issues;
 }
+/**
+ * Executa a análise completa de pontuação e formatação em um texto.
+ */
 export function analisarTexto(src, config = CONFIGURACAO_PADRAO) {
     const problemas = [];
     const isMarkdown = src.includes('# ') || src.includes('## ') || /^---$/.test(src.trim().split('\n')[0] || '');
@@ -291,6 +330,9 @@ export function analisarTexto(src, config = CONFIGURACAO_PADRAO) {
     }
     return problemas;
 }
+/**
+ * Calcula o número da linha para uma dada posição.
+ */
 export function calcularLinha(src, posOrIndex, match) {
     if (typeof posOrIndex === 'number') {
         return src.substring(0, posOrIndex).split('\n').length;
@@ -303,4 +345,3 @@ export function calcularLinha(src, posOrIndex, match) {
     }
     return 1;
 }
-//# sourceMappingURL=scoring-shared.js.map

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

@@ -1,80 +1,144 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable problema-documentacao
+// 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
+ */
 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)
+    if (!fileCaminho) {
         return false;
+    }
     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 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;
@@ -89,6 +153,7 @@ export function extractLineContext(code, position) {
     return '';
 }
 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',
@@ -96,6 +161,7 @@ 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',
@@ -103,6 +169,7 @@ 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',
@@ -110,6 +177,7 @@ 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',
@@ -117,6 +185,7 @@ 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',
@@ -124,6 +193,7 @@ 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',
@@ -132,6 +202,7 @@ 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 {
@@ -150,6 +221,7 @@ 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',
@@ -159,6 +231,7 @@ 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',
@@ -167,6 +240,7 @@ 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',
@@ -174,6 +248,7 @@ 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',
@@ -182,6 +257,7 @@ 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',
@@ -189,6 +265,7 @@ 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',
@@ -196,6 +273,9 @@ 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',
@@ -203,6 +283,7 @@ 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',
@@ -210,6 +291,7 @@ 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',
@@ -217,6 +299,7 @@ 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',
@@ -224,6 +307,7 @@ 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',
@@ -231,6 +315,7 @@ 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 {
@@ -249,6 +334,7 @@ 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',
@@ -258,6 +344,7 @@ 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',
@@ -267,6 +354,7 @@ 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',
@@ -275,7 +363,9 @@ 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',
@@ -285,6 +375,7 @@ 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',
@@ -293,6 +384,7 @@ 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',
@@ -300,6 +392,7 @@ 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 (/(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)) {
@@ -310,6 +403,7 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
             };
         }
     }
+    // Getter de keys com validação - 95% legítimo
     if (/value\s*:\s*unknown/.test(lineContext) && /Object\.keys/.test(contextoAmplo)) {
         return {
             categoria: 'legitimo',
@@ -317,6 +411,7 @@ 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',
@@ -324,6 +419,7 @@ 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: 60,
@@ -332,4 +428,3 @@ export function categorizarUnknown(code, fileCaminho, lineContext) {
         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']
     };
 }
-//# sourceMappingURL=context-analyzer.js.map

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

@@ -1,7 +1,11 @@
+// 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';
 export * from './type-inference.js';
 export * from './type-validator.js';
 export * from './usage-analyzer.js';
-//# sourceMappingURL=index.js.map