@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/core/execution/inquisitor.js

@@ -1,11 +1,12 @@
+// SPDX-License-Identifier: MIT
+import pLimit from 'p-limit';
+import * as path from 'path';
 import { config, isMetaPath } from '../config/index.js';
 import { messages } from '../messages/index.js';
 import { lerEstado } from '../../shared/persistence/index.js';
-import pLimit from 'p-limit';
-import * as path from 'path';
-import { ocorrenciaParseErro } from '../../types/index.js';
 import { executarInquisicao as executarExecucao, registrarUltimasMetricas } from './executor.js';
 import { scanRepository } from './scanner.js';
+import { ocorrenciaParseErro } from '../../types/index.js';
 function getGlobal() {
     return globalThis;
 }
@@ -30,8 +31,9 @@ function detalheErro(erro) {
 function getSimbolosLog() {
     const logAny = messages.log;
     const s = logAny.simbolos;
-    if (s && typeof s === 'object')
+    if (s && typeof s === 'object') {
         return s;
+    }
     return {
         info: '[INFO]',
         sucesso: '[OK]',
@@ -59,11 +61,11 @@ function infoDestaque(mensagem) {
 }
 async function handleParseError(entry) {
     const g = getGlobal();
-    const lista = g.__MAHORAGA_PARSE_ERROS__ || [];
+    const lista = g.__SUKUNA_PARSE_ERROS__ ?? [];
     try {
         const babel = await import('@babel/parser');
         try {
-            babel.parse(entry.content || '', {
+            babel.parse(entry.content ?? '', {
                 sourceType: 'unambiguous',
                 plugins: ['typescript', 'jsx', 'decorators-legacy', 'classProperties']
             });
@@ -92,37 +94,37 @@ async function handleParseError(entry) {
             origem: 'parser'
         }));
     }
-    g.__MAHORAGA_PARSE_ERROS__ = lista;
+    g.__SUKUNA_PARSE_ERROS__ = lista;
 }
 async function aplicarPriorizacao(entries, metaSet) {
-    if (!config.ANALISE_PRIORIZACAO_ENABLED || !config.ANALISE_INCREMENTAL_STATE_PATH)
+    if (!config.ANALISE_PRIORIZACAO_ENABLED || !config.ANALISE_INCREMENTAL_STATE_PATH) {
         return entries;
+    }
     try {
         const inc = await lerEstado(config.ANALISE_INCREMENTAL_STATE_PATH).catch(() => null);
-        if (!inc?.arquivos)
+        if (!inc?.arquivos) {
             return entries;
+        }
         const pesos = {
-            duracaoMs: config.ANALISE_PRIORIZACAO_PESOS?.duracaoMs ?? 1,
-            ocorrencias: config.ANALISE_PRIORIZACAO_PESOS?.ocorrencias ?? 2,
-            penalidadeReuso: config.ANALISE_PRIORIZACAO_PESOS?.penalidadeReuso ?? 0.5
+            duracaoMs: config.ANALISE_PRIORIZACAO_PESOS.duracaoMs,
+            ocorrencias: config.ANALISE_PRIORIZACAO_PESOS.ocorrencias,
+            penalidadeReuso: config.ANALISE_PRIORIZACAO_PESOS.penalidadeReuso
         };
         const scored = entries.map(entry => {
             const hist = inc.arquivos[entry.relPath];
             let score = 0;
-            if (hist) {
-                let dur = 0;
-                let occ = 0;
-                if (hist.analistas) {
-                    for (const a of Object.values(hist.analistas)) {
-                        dur += a.duracaoMs;
-                        occ += a.ocorrencias;
-                    }
-                }
-                else {
-                    occ = hist.ocorrencias?.length || 0;
+            let dur = 0;
+            let occ = 0;
+            if (hist.analistas) {
+                for (const a of Object.values(hist.analistas)) {
+                    dur += a.duracaoMs;
+                    occ += a.ocorrencias;
                 }
-                score = dur * pesos.duracaoMs + occ * pesos.ocorrencias - (hist.reaproveitadoCount || 0) * pesos.penalidadeReuso;
             }
+            else {
+                occ = hist.ocorrencias?.length ?? 0;
+            }
+            score = dur * pesos.duracaoMs + occ * pesos.ocorrencias - (hist.reaproveitadoCount ?? 0) * pesos.penalidadeReuso;
             return { entry, score };
         });
         scored.sort((a, b) => b.score - a.score);
@@ -147,23 +149,23 @@ async function aplicarPriorizacao(entries, metaSet) {
         return result;
     }
     catch (erro) {
-        if (config.DEV_MODE)
+        if (config.DEV_MODE) {
             messages.log.erro(`Falha priorização: ${erro instanceof Error ? erro.message : String(erro)}`);
+        }
         return entries;
     }
 }
 const EXTENSOES_COM_AST = new Set(Array.isArray(config.SCANNER_EXTENSOES_COM_AST) ? config.SCANNER_EXTENSOES_COM_AST : ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
 export async function prepararComAst(entries, baseDir) {
     const g = getGlobal();
-    const cache = g.__MAHORAGA_AST_CACHE__ || new Map();
-    if (!g.__MAHORAGA_AST_CACHE__)
-        g.__MAHORAGA_AST_CACHE__ = cache;
-    const metricas = g.__MAHORAGA_METRICAS__ || { parsingTimeMs: 0, cacheHits: 0, cacheMiss: 0 };
+    const cache = g.__SUKUNA_AST_CACHE__ ?? new Map();
+    g.__SUKUNA_AST_CACHE__ ??= cache;
+    const metricas = g.__SUKUNA_METRICAS__ ?? { parsingTimeMs: 0, cacheHits: 0, cacheMiss: 0 };
     metricas.parsingTimeMs = 0;
     metricas.cacheHits = 0;
     metricas.cacheMiss = 0;
-    g.__MAHORAGA_METRICAS__ = metricas;
-    const CONCURRENCY = Number(config.AUTOANALISE_CONCURRENCY ?? 50);
+    g.__SUKUNA_METRICAS__ = metricas;
+    const CONCURRENCY = config.AUTOANALISE_CONCURRENCY;
     const limit = pLimit(CONCURRENCY);
     return Promise.all(entries.map(entry => limit(async () => {
         let ast;
@@ -175,7 +177,7 @@ export async function prepararComAst(entries, baseDir) {
         if (entry.content && EXTENSOES_COM_AST.has(extEfetiva)) {
             if (config.ANALISE_AST_CACHE_ENABLED && cacheValido) {
                 const anterior = cache.get(entry.relPath);
-                if (anterior && anterior.mtimeMs === mtimeMs) {
+                if (anterior?.mtimeMs === mtimeMs) {
                     ast = anterior.ast;
                     metricas.cacheHits++;
                 }
@@ -183,11 +185,11 @@ export async function prepararComAst(entries, baseDir) {
             try {
                 if (!ast) {
                     const inicioParse = performance.now();
-                    const parsed = await import('../parsing/index.js').then(mod => mod.decifrarSintaxe(entry.content || '', extEfetiva, { relPath: entry.relPath }));
+                    const parsed = await import('../parsing/index.js').then(mod => mod.decifrarSintaxe(entry.content ?? '', extEfetiva, { relPath: entry.relPath }));
                     if (parsed && typeof parsed === 'object' && getObjectKeysLen(parsed) > 0) {
                         ast = undefined;
                     }
-                    else if (parsed == null) {
+                    else if (parsed === null) {
                         if (/(^|\/)node_modules(\/|\\)/.test(entry.relPath)) {
                             ast = undefined;
                         }
@@ -205,13 +207,13 @@ export async function prepararComAst(entries, baseDir) {
             catch (erro) {
                 const err = erro instanceof Error ? erro : new Error(String(erro));
                 messages.log.erro(messages.InquisidorMensagens.falhaGerarAst(entry.relPath, err.message));
-                const lista = g.__MAHORAGA_PARSE_ERROS__ || [];
+                const lista = g.__SUKUNA_PARSE_ERROS__ ?? [];
                 lista.push(ocorrenciaParseErro({
                     mensagem: messages.InquisidorMensagens.parseErro(err.message),
                     relPath: entry.relPath,
                     origem: 'parser'
                 }));
-                g.__MAHORAGA_PARSE_ERROS__ = lista;
+                g.__SUKUNA_PARSE_ERROS__ = lista;
             }
         }
         return {
@@ -230,20 +232,25 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
             const progressData = JSON.parse(msg);
             if (progressData.tipo === 'diretorio') {
                 const g = getGlobal();
-                g.__MAHORAGA_DIR_COUNT__ = (g.__MAHORAGA_DIR_COUNT__ || 0) + 1;
-                if (!g.__MAHORAGA_DIR_SAMPLES__)
-                    g.__MAHORAGA_DIR_SAMPLES__ = [];
-                if (g.__MAHORAGA_DIR_SAMPLES__.length < 5) {
-                    g.__MAHORAGA_DIR_SAMPLES__.push(progressData.caminho);
+                g.__SUKUNA_DIR_COUNT__ = (g.__SUKUNA_DIR_COUNT__ ?? 0) + 1;
+                const samples = g.__SUKUNA_DIR_SAMPLES__ ?? [];
+                if (samples.length < 5) {
+                    const caminho = progressData.caminho ?? '';
+                    samples.push(caminho);
+                    g.__SUKUNA_DIR_SAMPLES__ = samples;
                 }
             }
             else if (progressData.tipo === 'erro') {
-                messages.log.erro(`Erro ao ${progressData.acao} ${progressData.caminho}: ${progressData.mensagem}`);
+                const acao = progressData.acao ?? '';
+                const caminho = progressData.caminho ?? '';
+                const mensagem = progressData.mensagem ?? '';
+                messages.log.erro(`Erro ao ${acao} ${caminho}: ${mensagem}`);
             }
         }
         catch {
-            if (msg && msg.includes('[AVISO]'))
+            if (msg.includes('[AVISO]')) {
                 messages.log.aviso(msg);
+            }
         }
     }
     const fileMap = await scanRepository(baseDir, {
@@ -251,6 +258,7 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
         onProgress: onScanProgress
     });
     let entriesBase = Object.values(fileMap);
+    // Filtra arquivos meta com helper central: tudo fora de src/ é meta por padrão
     const metaSet = new Set(entriesBase.filter(erro => isMetaPath(erro.relPath)).map(erro => erro.relPath));
     entriesBase = await aplicarPriorizacao(entriesBase, metaSet);
     const fileEntries = entriesBase.map(entry => ({
@@ -260,8 +268,8 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
     }));
     try {
         const g = getGlobal();
-        const totalDirs = g.__MAHORAGA_DIR_COUNT__ || 0;
-        const amostra = Array.isArray(g.__MAHORAGA_DIR_SAMPLES__) ? g.__MAHORAGA_DIR_SAMPLES__ : [];
+        const totalDirs = g.__SUKUNA_DIR_COUNT__ ?? 0;
+        const amostra = Array.isArray(g.__SUKUNA_DIR_SAMPLES__) ? g.__SUKUNA_DIR_SAMPLES__ : [];
         if (config.LOG_ESTRUTURADO) {
             messages.log.info(JSON.stringify({
                 tipo: 'varredura_preliminar',
@@ -271,10 +279,14 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
         }
     }
     catch {
+        /* ignore */
     }
+    // Agora fileEntries é FileEntryWithAst[]
     let totalArquivos = fileEntries.length;
     let ocorrencias = [];
     if (!skipExec) {
+        // Inversão de Controle: tecnicas devem ser fornecidas pelo chamador sempre que skipExec=false.
+        // Para compatibilidade retroativa, se não vierem definidas carregamos dinamicamente o registro.
         let tecnicasEfetivas = tecnicas;
         if (!tecnicasEfetivas) {
             const mod = await import('../../analysts/registry/registry.js');
@@ -284,14 +296,14 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
         totalArquivos = execRes.totalArquivos;
         ocorrencias = execRes.ocorrencias;
     }
-    const parseErros = getGlobal().__MAHORAGA_PARSE_ERROS__ || [];
+    const parseErros = getGlobal().__SUKUNA_PARSE_ERROS__ ?? [];
     if (parseErros.length) {
-        getGlobal().__MAHORAGA_PARSE_ERROS_ORIGINAIS__ = parseErros.length;
+        getGlobal().__SUKUNA_PARSE_ERROS_ORIGINAIS__ = parseErros.length;
         if (config.PARSE_ERRO_AGRUPAR) {
             const porArquivo = {};
             for (const pe of parseErros) {
                 const chave = pe.relPath || '__desconhecido__';
-                (porArquivo[chave] = porArquivo[chave] || []).push(pe);
+                porArquivo[chave].push(pe);
             }
             for (const [arq, lista] of Object.entries(porArquivo)) {
                 if (lista.length <= (config.PARSE_ERRO_MAX_POR_ARQUIVO || 1)) {
@@ -327,4 +339,3 @@ export async function iniciarInquisicao(baseDir = process.cwd(), options = {}, t
     };
 }
 export { executarExecucao as executarInquisicao, registrarUltimasMetricas };
-//# sourceMappingURL=inquisitor.js.map

package/dist/core/execution/linguagens.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: MIT
+export {};

package/dist/core/execution/parse-errors.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: MIT
+export {};

package/dist/core/execution/registry.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Tipos para o file registry
+ */
+export {};

package/dist/core/execution/results.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: MIT
+export {};