@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/corrections/analyst-quick-fixes.js

@@ -8,33 +8,43 @@ export const analistaQuickFixes = {
         return /\.(js|jsx|ts|tsx|mjs|cjs|svg)$/.test(relPath);
     },
     aplicar: (src, relPath, _ast) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const ocorrencias = [];
+        // Buscar quick fixes gerais
         const quickFixes = findQuickFixes(src, undefined, undefined, relPath);
+        // Buscar quick fixes específicos por tipo de problema detectado
         const problemaTipos = ['unhandled-async', 'console-log', 'memory-leak', 'dangerous-html', 'eval-usage', 'complex-regex'];
         for (const problemTipo of problemaTipos) {
             const specificFixes = findQuickFixes(src, problemTipo, undefined, relPath);
             quickFixes.push(...specificFixes);
         }
+        // Remover duplicatas por ID
         const uniqueFixes = quickFixes.filter((fix, index, arr) => arr.findIndex(arquivo => arquivo.id === fix.id) === index);
         for (const fixResultado of uniqueFixes) {
             for (const match of fixResultado.matches) {
-                const beforeMatch = src.substring(0, match.index || 0);
+                // Calcular linha aproximada do match
+                const beforeMatch = src.substring(0, match.index ?? 0);
                 const linha = beforeMatch.split('\n').length;
+                // Gerar preview da correção
                 const previewCorrecao = fixResultado.fix(match, src);
                 const originalLine = src.split('\n')[linha - 1] || '';
                 const fixedLine = previewCorrecao.split('\n')[linha - 1] || '';
+                // Criar sugestão com preview mais detalhado
                 const sugestao = [fixResultado.description, '', `[CHAVE-INGLESA] Correção sugerida:`, `[ERRO] Antes: ${originalLine.trim()}`, `[OK] Depois: ${fixedLine.trim()}`, '', `Confiança: ${fixResultado.confidence}%`, `Categoria: ${fixResultado.category}`, `ID do Fix: ${fixResultado.id}`].join('\n');
+                // Mapear categoria para nível
                 const nivel = mapearCategoriaNivel(fixResultado.category);
+                // Criar ocorrência base
                 const ocorrencia = criarOcorrencia({
                     tipo: 'auto-fix-disponivel',
                     nivel,
-                    mensagem: `${fixResultado.title}`,
+                    mensagem: fixResultado.title,
                     relPath,
                     linha
                 });
-                const ocorrenciaGenerica = ocorrencia;
+                // Adicionar campos extras como propriedades do objeto genérico
+                const ocorrenciaGenerica = ocorrencia; // OcorrenciaGenerica allows extra properties
                 ocorrenciaGenerica.sugestao = sugestao;
                 ocorrenciaGenerica.quickFixId = fixResultado.id;
                 ocorrenciaGenerica.confidence = fixResultado.confidence;
@@ -60,4 +70,3 @@ function mapearCategoriaNivel(category) {
             return 'info';
     }
 }
-//# sourceMappingURL=analyst-quick-fixes.js.map

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

@@ -1,7 +1,8 @@
 import { findQuickFixes } from '../../core/config/auto/index.js';
 import { extrairSupressoes, isRegraSuprimida } from '../../shared/helpers/index.js';
-import { criarOcorrencia } from '../../types/index.js';
 import { analisarTexto, calcularLinha } from './scoring-shared.js';
+import { criarOcorrencia } from '../../types/index.js';
+// ─── Helpers / Config ─────────────────────────────────────────
 function mapearCategoriaNivel(category) {
     switch (category) {
         case 'security':
@@ -15,23 +16,29 @@ function mapearCategoriaNivel(category) {
             return 'info';
     }
 }
+// ─── analistaQuickFixes ───────────────────────────────────────
 export const analistaQuickFixes = {
     nome: 'quick-fixes',
     categoria: 'melhorias',
     descricao: 'Detecta problemas comuns e oferece correções automáticas',
     test: (relPath) => {
+        // Inclui SVGs para permitir quick-fixes seguros (otimização e viewBox)
         return /\.(js|jsx|ts|tsx|mjs|cjs|svg)$/.test(relPath);
     },
     aplicar: (src, relPath, _ast) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const ocorrencias = [];
+        // Quick fixes gerais
         const quickFixes = findQuickFixes(src, undefined, undefined, relPath);
+        // Quick fixes específicos por tipo de problema detectado
         const problemaTipos = ['unhandled-async', 'console-log', 'memory-leak', 'dangerous-html', 'eval-usage', 'complex-regex'];
         for (const problemTipo of problemaTipos) {
             const specificFixes = findQuickFixes(src, problemTipo, undefined, relPath);
             quickFixes.push(...specificFixes);
         }
+        // Remover duplicatas por ID
         const uniqueFixes = quickFixes.filter((fix, index, arr) => arr.findIndex(arquivo => arquivo.id === fix.id) === index);
         for (const fixResultado of uniqueFixes) {
             for (const match of fixResultado.matches) {
@@ -44,7 +51,7 @@ export const analistaQuickFixes = {
                 const ocorrencia = criarOcorrencia({
                     tipo: 'auto-fix-disponivel',
                     nivel,
-                    mensagem: `${fixResultado.title}`,
+                    mensagem: fixResultado.title,
                     relPath,
                     linha
                 });
@@ -61,6 +68,7 @@ export const analistaQuickFixes = {
         return ocorrencias;
     }
 };
+// ─── analistaPontuacao ────────────────────────────────────────
 export const analistaPontuacao = {
     nome: 'pontuacao-fix',
     categoria: 'formatacao',
@@ -69,15 +77,17 @@ export const analistaPontuacao = {
         return /\.(md|txt|mdx)$/.test(relPath);
     },
     aplicar: (src, relPath) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const supressoes = extrairSupressoes(src);
         const problemas = analisarTexto(src);
         const ocorrencias = [];
         for (const problema of problemas) {
             const linha = calcularLinha(src, problema.posicao);
-            if (isRegraSuprimida(problema.tipo, linha, supressoes))
+            if (isRegraSuprimida(problema.tipo, linha, supressoes)) {
                 continue;
+            }
             const linhas = src.split('\n');
             const contexto = linhas[linha - 1] || '';
             const ocorrencia = criarOcorrencia({
@@ -96,5 +106,5 @@ export const analistaPontuacao = {
         return ocorrencias;
     }
 };
+// ─── Exports adicionais ───────────────────────────────────────
 export const analistas = [analistaQuickFixes, analistaPontuacao];
-//# sourceMappingURL=analyst-scoring.js.map

package/dist/analysts/corrections/auto-fix-engine.js

@@ -1,6 +1,15 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Motor de correção automática de tipos inseguros
+ * Aplica correções baseadas em análise de contexto e confiança
+ */
 import { readFileSync, writeFileSync } from 'node:fs';
-export async function aplicarCorrecaoArquivo(arquivo, ocorrencias, config) {
+/**
+ * Aplica correção em um arquivo específico
+ */
+export function aplicarCorrecaoArquivo(arquivo, ocorrencias, config) {
     try {
+        // Filtrar apenas ocorrências que devem ser corrigidas
         const paraCorrigir = ocorrencias.filter(ocorrencia => ocorrencia.categoria === 'corrigir' && ocorrencia.confianca >= config.minConfianca);
         if (paraCorrigir.length === 0) {
             return {
@@ -9,25 +18,32 @@ export async function aplicarCorrecaoArquivo(arquivo, ocorrencias, config) {
                 linhasModificadas: 0
             };
         }
+        // Ler arquivo
         const conteudo = readFileSync(arquivo, 'utf-8');
         const linhas = conteudo.split('\n');
         let modificadas = 0;
-        const ordenadas = [...paraCorrigir].sort((arquivo, base) => (base.ocorrencia.linha || 0) - (arquivo.ocorrencia.linha || 0));
+        // Ordenar por linha (decrescente) para não afetar números de linha
+        const ordenadas = [...paraCorrigir].sort((arquivo, base) => (base.ocorrencia.linha ?? 0) - (arquivo.ocorrencia.linha ?? 0));
         for (const item of ordenadas) {
             const linha = item.ocorrencia.linha;
-            if (!linha || linha < 1 || linha > linhas.length)
+            if (!linha || linha < 1 || linha > linhas.length) {
                 continue;
+            }
             const linhaIdx = linha - 1;
             const linhaOriginal = linhas[linhaIdx];
+            // Aplicar correção baseada no tipo
             let linhaCorrigida = linhaOriginal;
             if (item.ocorrencia.tipo === 'tipo-inseguro-any') {
+                // Substituir any por unknown (seguro por padrão)
                 linhaCorrigida = linhaOriginal.replace(/:\s*any\b/g, ': unknown');
                 linhaCorrigida = linhaCorrigida.replace(/\)\s*:\s*any\b/g, '): unknown');
             }
             else if (item.ocorrencia.tipo === 'tipo-inseguro-any-assertion') {
+                // Substituir as any por unknown (mais seguro)
                 linhaCorrigida = linhaOriginal.replace(/as\s+any\b/g, 'as unknown');
             }
             else if (item.ocorrencia.tipo === 'tipo-inseguro-any-cast') {
+                // Substituir <any> por <unknown>
                 linhaCorrigida = linhaOriginal.replace(/<any>/g, '<unknown>');
             }
             if (linhaCorrigida !== linhaOriginal) {
@@ -35,6 +51,7 @@ export async function aplicarCorrecaoArquivo(arquivo, ocorrencias, config) {
                 modificadas++;
             }
         }
+        // Se não houve modificações, retornar sucesso
         if (modificadas === 0) {
             return {
                 sucesso: true,
@@ -43,6 +60,7 @@ export async function aplicarCorrecaoArquivo(arquivo, ocorrencias, config) {
             };
         }
         const novoConteudo = linhas.join('\n');
+        // Se não é dry-run, escrever arquivo
         if (!config.dryRun) {
             writeFileSync(arquivo, novoConteudo, 'utf-8');
         }
@@ -62,12 +80,15 @@ export async function aplicarCorrecaoArquivo(arquivo, ocorrencias, config) {
         };
     }
 }
-export async function aplicarCorrecoesEmLote(porArquivo, config) {
+/**
+ * Aplica correções em múltiplos arquivos
+ */
+export function aplicarCorrecoesEmLote(porArquivo, config) {
     const resultados = [];
     let sucesso = 0;
     let falhas = 0;
     for (const [arquivo, ocorrencias] of Object.entries(porArquivo)) {
-        const resultado = await aplicarCorrecaoArquivo(arquivo, ocorrencias, config);
+        const resultado = aplicarCorrecaoArquivo(arquivo, ocorrencias, config);
         resultados.push(resultado);
         if (resultado.sucesso && resultado.linhasModificadas > 0) {
             sucesso++;
@@ -82,4 +103,3 @@ export async function aplicarCorrecoesEmLote(porArquivo, config) {
         resultados
     };
 }
-//# sourceMappingURL=auto-fix-engine.js.map

package/dist/analysts/corrections/correction-aggregator-analyst.js

@@ -1,12 +1,14 @@
 import { analistaPontuacao, analistaQuickFixes } from './analyst-scoring.js';
+// Punto de entrada único para correções automáticas
 export const analistaCorrecaoAutomatica = {
     nome: 'correcoes-automaticas',
     categoria: 'melhorias',
     descricao: 'Agrega técnicas de correções automáticas (quick-fixes e correções de pontuação)',
     test: (relPath) => {
+        // Delegamos aos analistas internos - já tipados como Analista
         const quickFixesApplies = typeof analistaQuickFixes.test === 'function' ? analistaQuickFixes.test(relPath) : false;
         const pontuacaoApplies = typeof analistaPontuacao.test === 'function' ? analistaPontuacao.test(relPath) : false;
-        return Boolean(quickFixesApplies || pontuacaoApplies);
+        return (quickFixesApplies || pontuacaoApplies);
     },
     aplicar: (src, relPath, ast) => {
         const ocorrencias = [];
@@ -19,4 +21,3 @@ export const analistaCorrecaoAutomatica = {
         return ocorrencias;
     }
 };
-//# sourceMappingURL=correction-aggregator-analyst.js.map

package/dist/analysts/corrections/corrector-structure.js

@@ -1,23 +1,30 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable tipo-inseguro-unknown tipo-literal-inline-complexo
+// Justificativa: unknown é usado para tipagem defensiva de erros e módulos dinâmicos
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import pLimit from 'p-limit';
 import { config, resolverPluginSeguro } from '../../core/config/index.js';
 import { getMessages } from '../../core/messages/index.js';
 import { importarModuloSeguro } from '../../core/utils/index.js';
 import { reescreverImports } from '../../shared/helpers/index.js';
-import pLimit from 'p-limit';
 import { mapaReversao } from './map-reversion.js';
 const { log, logAuto, CorretorEstruturaExtraMensagens } = getMessages();
 export async function corrigirEstrutura(mapa, fileEntries, baseDir = process.cwd()) {
-    const CONCORRENCIA = Number(config.STRUCTURE_CONCURRENCY ?? 5);
-    const AUTO_CORRECAO = Boolean(config.STRUCTURE_AUTO_FIX);
-    const PLUGINS = config.STRUCTURE_PLUGINS || [];
+    // Captura dinâmica das configs (evita congelar valores em tempo de import)
+    const CONCORRENCIA = config.STRUCTURE_CONCURRENCY;
+    const AUTO_CORRECAO = config.STRUCTURE_AUTO_FIX;
+    const rawPlugins = config.STRUCTURE_PLUGINS ?? [];
+    const PLUGINS = Array.isArray(rawPlugins) ? rawPlugins.filter((p) => typeof p === 'string') : [];
     const ESTRUTURA_CAMADAS = config.ESTRUTURA_CAMADAS;
     const limit = pLimit(CONCORRENCIA);
     await Promise.all(mapa.map(entry => limit(async () => {
         const { arquivo, ideal, atual } = entry;
-        if (!ideal || ideal === atual)
+        if (!ideal || ideal === atual) {
             return;
+        }
         const origem = path.join(baseDir, arquivo);
+        // Preserva o nome do arquivo ao mover para a pasta ideal
         const nomeArquivo = path.basename(arquivo);
         const destino = path.join(baseDir, ideal, nomeArquivo);
         if (!AUTO_CORRECAO) {
@@ -35,9 +42,12 @@ export async function corrigirEstrutura(mapa, fileEntries, baseDir = process.cwd
             return;
         }
         try {
+            // Usa flag 'wx' para escrita exclusiva - falha se o arquivo já existir,
+            // eliminando a condição de corrida TOCTOU entre stat e write
             const conteudo = await fs.readFile(origem, 'utf-8');
             const { novoConteudo } = reescreverImports(conteudo, path.posix.normalize(arquivo.replace(/\\/g, '/')), path.posix.normalize(path.relative(baseDir, destino).replace(/\\/g, '/')));
-            await mapaReversao.registrarMove(arquivo, path.relative(baseDir, destino), entry.motivo || 'Reorganização estrutural', conteudo, novoConteudo, true);
+            // Registra o move no mapa de reversão
+            await mapaReversao.registrarMove(arquivo, path.relative(baseDir, destino), entry.motivo ?? 'Reorganização estrutural', conteudo, novoConteudo, true);
             try {
                 await fs.writeFile(destino, novoConteudo, { encoding: 'utf-8', flag: 'wx' });
             }
@@ -53,23 +63,23 @@ export async function corrigirEstrutura(mapa, fileEntries, baseDir = process.cwd
             log.sucesso(CorretorEstruturaExtraMensagens.movido.replace('{arquivo}', arquivo).replace('{destino}', path.relative(baseDir, destino)));
         }
         catch (err) {
-            const msg = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);
+            const msg = err && typeof err === 'object' && 'message' in err ? String((err).message) : String(err);
             logAuto.corretorErroMover(arquivo, msg);
         }
     })));
     for (const pluginRel of PLUGINS) {
         try {
-            const resolvido = resolverPluginSeguro(baseDir, String(pluginRel));
+            const resolvido = resolverPluginSeguro(baseDir, pluginRel);
             if (resolvido.erro) {
-                logAuto.pluginIgnorado(String(pluginRel), resolvido.erro);
+                logAuto.pluginIgnorado(pluginRel, resolvido.erro);
                 continue;
             }
             const caminhoPlugin = resolvido.caminho;
             if (!caminhoPlugin) {
-                logAuto.caminhoNaoResolvido(String(pluginRel));
+                logAuto.caminhoNaoResolvido(pluginRel);
                 continue;
             }
-            const pluginModule = await importarModuloSeguro(baseDir, String(pluginRel));
+            const pluginModule = await importarModuloSeguro(baseDir, pluginRel);
             let pluginFn;
             if (pluginModule && typeof pluginModule === 'object' && 'default' in pluginModule && typeof pluginModule.default === 'function') {
                 pluginFn = pluginModule.default;
@@ -89,13 +99,12 @@ export async function corrigirEstrutura(mapa, fileEntries, baseDir = process.cwd
         catch (err) {
             let msg = 'erro desconhecido';
             if (err && typeof err === 'object' && 'message' in err && typeof err.message === 'string') {
-                msg = String(err.message);
+                msg = err.message;
             }
             else if (typeof err === 'string') {
                 msg = err;
             }
-            logAuto.pluginFalhou(String(pluginRel), String(msg));
+            logAuto.pluginFalhou(pluginRel, msg);
         }
     }
 }
-//# sourceMappingURL=corrector-structure.js.map

package/dist/analysts/corrections/fix-alias-imports.js

@@ -1,11 +1,12 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-export async function aplicarFixAliasImports(fileCaminho, content) {
-    if (!fileCaminho.endsWith('.ts'))
+export function aplicarFixAliasImports(fileCaminho, content) {
+    if (!fileCaminho.endsWith('.ts')) {
         return {
             changed: false,
             content
         };
+    }
     const out = content.replace(/@types\/types\.js\b/g, 'types');
     return {
         changed: out !== content,
@@ -26,7 +27,7 @@ export async function scanAndApplyFix(root) {
                 }
                 else if (entry.isFile() && fileCaminho.endsWith('.ts')) {
                     const src = await fs.readFile(fileCaminho, 'utf8');
-                    const { changed: wasChanged, content } = await aplicarFixAliasImports(fileCaminho, src);
+                    const { changed: wasChanged, content } = aplicarFixAliasImports(fileCaminho, src);
                     if (wasChanged) {
                         await fs.writeFile(fileCaminho, content, 'utf8');
                         changed++;
@@ -35,10 +36,10 @@ export async function scanAndApplyFix(root) {
             }
         }
         catch {
+            // Fail silently on directory traversal errors.
         }
     }
     await walk(path.join(root, 'src'));
     await walk(path.join(root, 'tests'));
     return changed;
 }
-//# sourceMappingURL=fix-alias-imports.js.map

package/dist/analysts/corrections/fix-md-fences.js

@@ -2,16 +2,21 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 export function guessLang(block) {
     const head = block.slice(0, 200).trim();
-    if (/^\{[\s\S]*\}$/.test(head))
+    if (/^\{[\s\S]*\}$/.test(head)) {
         return 'json';
-    if (/\$env:|PowerShell/i.test(block))
+    }
+    if (/\$env:|PowerShell/i.test(block)) {
         return 'powershell';
-    if (/^#!\/usr\/bin\/(env\s+)?bash|\bnpm\s|\bnode\s|\bbash\b/i.test(block))
+    }
+    if (/^#!\/usr\/bin\/(env\s+)?bash|\bnpm\s|\bnode\s|\bbash\b/i.test(block)) {
         return 'bash';
-    if (/import\s.+from|export\s+(const|function|default)/.test(block))
+    }
+    if (/import\s.+from|export\s+(const|function|default)/.test(block)) {
         return 'ts';
-    if (/"?type"?\s*:\s*"module"/.test(block))
+    }
+    if (/"?type"?\s*:\s*"module"/.test(block)) {
         return 'json';
+    }
     return 'text';
 }
 export function fixFences(content) {
@@ -54,8 +59,9 @@ export async function scanAndApplyFixMdFences(root) {
             for (const entry of entries) {
                 const fullCaminho = path.join(dir, entry.name);
                 if (entry.isDirectory()) {
-                    if (/^(node_modules|dist|coverage|pre-public|preview-mahoraga|\.git)$/i.test(entry.name))
+                    if (/^(node_modules|dist|coverage|pre-public|preview-mahoraga|\.git)$/i.test(entry.name)) {
                         continue;
+                    }
                     out.push(...(await listMarkdown(fullCaminho)));
                 }
                 else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
@@ -71,11 +77,13 @@ export async function scanAndApplyFixMdFences(root) {
     const files = await listMarkdown(root);
     for (const fileCaminho of files) {
         const rel = path.relative(root, fileCaminho).replace(/\\/g, '/');
-        if (rel.startsWith('pre-public/') || rel.includes('/legado/'))
+        if (rel.startsWith('pre-public/') || rel.includes('/legado/')) {
             continue;
+        }
         const content = await fs.readFile(fileCaminho, 'utf8');
-        if (!/```\s*\n/.test(content))
+        if (!/```\s*\n/.test(content)) {
             continue;
+        }
         const updated = fixFences(content);
         if (updated !== content) {
             await fs.writeFile(fileCaminho, updated, 'utf8');
@@ -84,4 +92,3 @@ export async function scanAndApplyFixMdFences(root) {
     }
     return changed;
 }
-//# sourceMappingURL=fix-md-fences.js.map

package/dist/analysts/corrections/index.js

@@ -1,15 +1,18 @@
 import { analistaPontuacao, analistaQuickFixes } from './analyst-scoring.js';
+// Re-exporta funções de barrel
 export { mapaReversao } from './map-reversion.js';
 export { removerArquivosOrfaos } from './pruning.js';
 export { gerarBarrels, reorganizarBarrelsAposMovimento } from './reorganize-barrels.js';
+// Punto de entrada único para correções automáticas
 export const analistaCorrecaoAutomatica = {
     nome: 'correcoes-automaticas',
     categoria: 'melhorias',
     descricao: 'Agrega técnicas de correções automáticas (quick-fixes e correções de pontuação)',
     test: (relPath) => {
+        // Delegamos aos analistas internos - já tipados como Analista
         const quickFixesApplies = typeof analistaQuickFixes.test === 'function' ? analistaQuickFixes.test(relPath) : false;
         const pontuacaoApplies = typeof analistaPontuacao.test === 'function' ? analistaPontuacao.test(relPath) : false;
-        return Boolean(quickFixesApplies || pontuacaoApplies);
+        return (quickFixesApplies || pontuacaoApplies);
     },
     aplicar: (src, relPath, ast) => {
         const ocorrencias = [];
@@ -22,4 +25,3 @@ export const analistaCorrecaoAutomatica = {
         return ocorrencias;
     }
 };
-//# sourceMappingURL=index.js.map