@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/detectors/detector-monorepo.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import fs from 'node:fs';
 import path from 'node:path';
 export function detectarMonorepo(baseDir) {
@@ -9,12 +10,17 @@ export function detectarMonorepo(baseDir) {
         packageManager: null,
     };
     const rootPkg = lerPackageJson(baseDir);
-    if (!rootPkg)
+    if (!rootPkg) {
         return info;
+    }
+    // Detect package manager
     const pm = rootPkg.packageManager || '';
-    if (pm)
+    if (pm) {
         info.packageManager = pm;
+    }
+    // Detect workspace patterns
     let workspaceGlobs = [];
+    // pnpm-workspace.yaml
     const pnpmWorkspacePath = path.join(baseDir, 'pnpm-workspace.yaml');
     if (fs.existsSync(pnpmWorkspacePath)) {
         info.type = 'pnpm';
@@ -27,6 +33,7 @@ export function detectarMonorepo(baseDir) {
         }
         catch { }
     }
+    // lerna.json
     const lernaPath = path.join(baseDir, 'lerna.json');
     if (fs.existsSync(lernaPath)) {
         info.type = 'lerna';
@@ -38,37 +45,45 @@ export function detectarMonorepo(baseDir) {
         }
         catch { }
     }
+    // nx.json
     const nxPath = path.join(baseDir, 'nx.json');
     if (fs.existsSync(nxPath)) {
         info.type = 'nx';
         try {
             const nx = JSON.parse(fs.readFileSync(nxPath, 'utf-8'));
-            if (nx.workspaceLayout?.appsDir)
-                workspaceGlobs.push(nx.workspaceLayout.appsDir);
-            if (nx.workspaceLayout?.libsDir)
-                workspaceGlobs.push(nx.workspaceLayout.libsDir);
+            const nxLayout = nx.workspaceLayout;
+            if (nxLayout?.appsDir) {
+                workspaceGlobs.push(nxLayout.appsDir);
+            }
+            if (nxLayout?.libsDir) {
+                workspaceGlobs.push(nxLayout.libsDir);
+            }
         }
         catch { }
     }
+    // turbo.json
     const turboPath = path.join(baseDir, 'turbo.json');
     if (fs.existsSync(turboPath)) {
-        if (!info.type)
-            info.type = 'turbo';
+        info.type ??= 'turbo';
     }
+    // package.json workspaces
     if (rootPkg.workspaces) {
         if (!info.type) {
-            const detectedPm = info.packageManager || '';
-            if (detectedPm.startsWith('yarn'))
+            const detectedPm = info.packageManager ?? '';
+            if (detectedPm.startsWith('yarn')) {
                 info.type = 'yarn-workspaces';
-            else if (detectedPm.startsWith('pnpm'))
+            }
+            else if (detectedPm.startsWith('pnpm')) {
                 info.type = 'pnpm';
-            else
+            }
+            else {
                 info.type = 'npm-workspaces';
+            }
         }
         if (Array.isArray(rootPkg.workspaces)) {
             workspaceGlobs = rootPkg.workspaces;
         }
-        else if (typeof rootPkg.workspaces === 'object' && rootPkg.workspaces !== null) {
+        else if (typeof rootPkg.workspaces === 'object') {
             const ws = rootPkg.workspaces;
             if (Array.isArray(ws.packages)) {
                 workspaceGlobs = ws.packages;
@@ -98,6 +113,7 @@ function resolverWorkspaces(rootDir, globs) {
     const workspaces = [];
     const seen = new Set();
     for (const glob of globs) {
+        // Expand simple globs like packages/* or apps/*
         const baseDir = glob.replace(/\/\*$/, '').replace(/\/\*\*$/, '');
         const fullPath = path.join(rootDir, baseDir);
         if (fs.existsSync(fullPath)) {
@@ -107,8 +123,9 @@ function resolverWorkspaces(rootDir, globs) {
                     if (entry.isDirectory() && !entry.name.startsWith('.')) {
                         const wsDir = path.join(fullPath, entry.name);
                         const resolved = path.resolve(wsDir);
-                        if (seen.has(resolved))
+                        if (seen.has(resolved)) {
                             continue;
+                        }
                         seen.add(resolved);
                         const pkg = lerPackageJson(wsDir);
                         if (pkg) {
@@ -116,9 +133,9 @@ function resolverWorkspaces(rootDir, globs) {
                                 name: pkg.name || entry.name,
                                 dir: resolved,
                                 packageJson: pkg,
-                                dependencies: pkg.dependencies || {},
-                                devDependencies: pkg.devDependencies || {},
-                                peerDependencies: pkg.peerDependencies || {},
+                                dependencies: pkg.dependencies,
+                                devDependencies: pkg.devDependencies,
+                                peerDependencies: pkg.peerDependencies,
                             });
                         }
                     }
@@ -136,13 +153,16 @@ export const detectorMonorepo = {
         return true;
     },
     aplicar(_src, _relPath, _ast, _fullPath, contexto) {
-        if (!contexto)
+        if (!contexto) {
             return [];
+        }
         const baseDir = contexto.baseDir;
         const info = detectarMonorepo(baseDir);
-        if (!info.isMonorepo)
+        if (!info.isMonorepo) {
             return [];
+        }
         const ocorrencias = [];
+        // Report monorepo structure
         ocorrencias.push({
             tipo: 'monorepo-detectado',
             nivel: 'info',
@@ -151,9 +171,10 @@ export const detectorMonorepo = {
             relPath: '[monorepo]',
             linha: 0,
         });
+        // Check for missing root scripts
         const rootPkg = lerPackageJson(baseDir);
         if (rootPkg) {
-            const scripts = rootPkg.scripts || {};
+            const scripts = rootPkg.scripts;
             const expectedScripts = ['build', 'test', 'lint'];
             for (const script of expectedScripts) {
                 if (!scripts[script]) {
@@ -168,8 +189,10 @@ export const detectorMonorepo = {
                 }
             }
         }
+        // Per-workspace analysis
         for (const ws of info.workspaces) {
             const relDir = path.relative(baseDir, ws.dir);
+            // Check for missing package.json fields
             if (!ws.packageJson?.name) {
                 ocorrencias.push({
                     tipo: 'monorepo-workspace-sem-nome',
@@ -191,6 +214,7 @@ export const detectorMonorepo = {
                 });
             }
         }
+        // Cross-package dependency analysis
         const allDeps = new Map();
         for (const ws of info.workspaces) {
             const deps = new Set([
@@ -204,6 +228,7 @@ export const detectorMonorepo = {
                 allDeps.set(dep, depSet);
             }
         }
+        // Detect mismatched versions across workspaces
         const versionMap = new Map();
         for (const ws of info.workspaces) {
             for (const [dep, ver] of Object.entries(ws.dependencies)) {
@@ -227,6 +252,7 @@ export const detectorMonorepo = {
                 }
             }
         }
+        // Detect missing internal dependencies (workspace A uses workspace B but B isn't in A's deps)
         const workspaceNames = new Set(info.workspaces.map(w => w.name));
         for (const ws of info.workspaces) {
             const imports = coletarImports(ws.dir);
@@ -276,4 +302,3 @@ function coletarImports(dir) {
     catch { }
     return imports;
 }
-//# sourceMappingURL=detector-monorepo.js.map

package/dist/analysts/detectors/detector-performance.js

@@ -1,6 +1,6 @@
+import { detectarContextoProjeto } from '../../shared/index.js';
 import { traverse } from '../../core/config/index.js';
 import { messages } from '../../core/messages/index.js';
-import { detectarContextoProjeto } from '../../shared/index.js';
 import { agruparPor, criarErroAnalise, filtrarOcorrenciasSuprimidas, splitLines } from '../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../types/index.js';
 export const analistaDesempenho = {
@@ -11,8 +11,9 @@ export const analistaDesempenho = {
         return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
     },
     aplicar: (src, relPath, ast) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const contextoArquivo = detectarContextoProjeto({
             arquivo: relPath,
             conteudo: src,
@@ -20,15 +21,20 @@ export const analistaDesempenho = {
         });
         const problemas = [];
         try {
+            // Detectar problemas por padrões de texto
             detectarPadroesPerformance(src, problemas, relPath);
+            // Detectar problemas via AST quando disponível
             if (ast) {
                 detectarProblemasPerformanceAST(ast, problemas, relPath);
             }
+            // Converter para ocorrências
             const ocorrencias = [];
-            const porImpacto = agruparPor(problemas, caminho => caminho.impacto || 'medio');
+            // Agrupar por impacto
+            const porImpacto = agruparPor(problemas, caminho => caminho.impacto ?? 'medio');
             for (const [impacto, items] of Object.entries(porImpacto)) {
                 if (items.length > 0) {
                     const nivel = mapearImpactoParaNivel(impacto);
+                    // Ser menos rigoroso com testes
                     const nivelAjustado = contextoArquivo.isTest && nivel === 'aviso' ? 'info' : nivel;
                     const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
                     ocorrencias.push(criarOcorrencia({
@@ -40,6 +46,7 @@ export const analistaDesempenho = {
                     }));
                 }
             }
+            // Aplicar supressões inline antes de retornar
             return filtrarOcorrenciasSuprimidas(ocorrencias, 'performance', src);
         }
         catch (erro) {
@@ -54,21 +61,27 @@ function detectarPadroesPerformance(src, problemas, relPath) {
     const loopClose = /^\s*\}/;
     linhas.forEach((linha, index) => {
         const numeroLinha = index + 1;
-        if (loopOpen.test(linha))
+        // Track loop nesting
+        if (loopOpen.test(linha)) {
             dentroLoop++;
-        if (loopClose.test(linha) && dentroLoop > 0)
+        }
+        if (loopClose.test(linha) && dentroLoop > 0) {
             dentroLoop--;
+        }
+        // Operações síncronas bloqueantes
         if (/\b(readFileSync|writeFileSync|execSync)\s*\(/.test(linha)) {
             problemas.push({
                 tipo: 'blocking-operation',
                 descricao: 'Operação síncrona pode bloquear event loop',
                 impacto: 'alto',
                 linha: numeroLinha,
-                coluna: linha.indexOf(/readFileSync|writeFileSync|execSync/.exec(linha)?.[0] || '') + 1,
+                coluna: linha.indexOf(/readFileSync|writeFileSync|execSync/.exec(linha)?.[0] ?? '') + 1,
                 sugestao: 'Use versões assíncronas: readFile, writeFile, exec'
             });
         }
+        // Event listeners sem cleanup
         if (/addEventListener\s*\(/.test(linha)) {
+            // Verificar se há removeEventListener no código (ignorando comentários)
             const srcSemComentarios = src.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
             if (!srcSemComentarios.includes('removeEventListener') && !srcSemComentarios.includes('cleanup') && !srcSemComentarios.includes('destroy')) {
                 problemas.push({
@@ -81,6 +94,7 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 });
             }
         }
+        // React: map sem key (detecção melhorada)
         if (/\.map\s*\([^)]*\)/.test(linha) && (/return\s*<|<\w+/.test(linha) || relPath.includes('.tsx') || relPath.includes('.jsx')) && !linha.includes('key=')) {
             problemas.push({
                 tipo: 'unnecessary-rerender',
@@ -91,6 +105,7 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Adicione key prop única para cada elemento da lista'
             });
         }
+        // N+1 queries pattern
         if (/\.forEach\s*\(.*\.(find|get|query|select)\s*\(/.test(linha)) {
             problemas.push({
                 tipo: 'n-plus-one',
@@ -101,6 +116,7 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Use join/include ou agrupe consultas para evitar N+1'
             });
         }
+        // Await em loops
         if (/\bawait\b/.test(linha) && dentroLoop > 0) {
             problemas.push({
                 tipo: 'sequential-await',
@@ -111,6 +127,7 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Considere usar Promise.all() para executar em paralelo'
             });
         }
+        // Large object spread in loops
         if (/\.\.\./.test(linha) && dentroLoop > 0 && /\{.*\.{3}.*\}/.test(linha)) {
             problemas.push({
                 tipo: 'expensive-spread',
@@ -121,8 +138,10 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 sugestao: 'Considere mutar um objeto local ou usar Map se o objeto for grande'
             });
         }
+        // React: missing memo/useCallback for expensive objects
         if (relPath.endsWith('.tsx') || relPath.endsWith('.jsx')) {
             if (/const\s+\w+\s*=\s*\[.*\]|const\s+\w+\s*=\s*\{.*\}|const\s+\w+\s*=\s*\(.*\)\s*=>/.test(linha) && !/useMemo|useCallback/.test(linha) && !/^\s*\/\//.test(linha)) {
+                // Heurística: se for dentro de um componente React (função que retorna JSX)
                 const totalLinhas = linhas.length;
                 const contextoPosterior = linhas.slice(index, Math.min(index + 20, totalLinhas)).join('\n');
                 if (/<[A-Z]|return\s*\(?\s*</.test(contextoPosterior)) {
@@ -137,6 +156,7 @@ function detectarPadroesPerformance(src, problemas, relPath) {
                 }
             }
         }
+        // Imports de bibliotecas grandes
         if (/import.*from\s+['"]lodash['"]|import.*from\s+['"]moment['"]/.test(linha)) {
             problemas.push({
                 tipo: 'large-bundle',
@@ -154,14 +174,14 @@ function detectarProblemasPerformanceAST(ast, problemas, relPath) {
         const isLoop = (type) => ['ForStatement', 'WhileStatement', 'DoWhileStatement', 'ForInStatement', 'ForOfStatement'].includes(type);
         const checkNesting = (path) => {
             let parent = path.parentPath;
-            while (parent) {
+            while ((parent.node).type !== 'Program') {
                 if (isLoop(parent.type)) {
                     problemas.push({
                         tipo: 'inefficient-loop',
                         descricao: 'Loop aninhado detectado via AST - pode causar performance O(n2)',
                         impacto: 'alto',
-                        linha: path.node.loc?.start.line || 0,
-                        coluna: path.node.loc?.start.column || 0,
+                        linha: path.node.loc?.start.line ?? 0,
+                        coluna: path.node.loc?.start.column ?? 0,
                         sugestao: 'Considere usar Map, Set ou otimizar algoritmo para complexidade linear'
                     });
                     break;
@@ -175,8 +195,10 @@ function detectarProblemasPerformanceAST(ast, problemas, relPath) {
             DoWhileStatement: checkNesting,
             ForInStatement: checkNesting,
             ForOfStatement: checkNesting,
+            // Detectar função setTimeout/setInterval sem cleanup
             CallExpression(path) {
                 if (path.node.callee.type === 'Identifier' && (path.node.callee.name === 'setTimeout' || path.node.callee.name === 'setInterval')) {
+                    // Heurística simples: se não há clear* na mesma função/arquivo
                     const parentFunction = path.getFunctionParent();
                     const context = parentFunction ? parentFunction.toString() : ast.toString();
                     if (!context.includes('clear') && !relPath.includes('test')) {
@@ -184,8 +206,8 @@ function detectarProblemasPerformanceAST(ast, problemas, relPath) {
                             tipo: 'memory-leak',
                             descricao: `${path.node.callee.name} sem cleanup pode causar vazamento`,
                             impacto: 'medio',
-                            linha: path.node.loc?.start.line || 0,
-                            coluna: path.node.loc?.start.column || 0,
+                            linha: path.node.loc?.start.line ?? 0,
+                            coluna: path.node.loc?.start.column ?? 0,
                             sugestao: `Use clear${path.node.callee.name.replace('set', '')} para limpar`
                         });
                     }
@@ -194,6 +216,7 @@ function detectarProblemasPerformanceAST(ast, problemas, relPath) {
         });
     }
     catch {
+        // Ignorar erros de traverse
     }
 }
 function mapearImpactoParaNivel(impacto) {
@@ -203,8 +226,11 @@ function mapearImpactoParaNivel(impacto) {
         case 'medio':
             return 'aviso';
         case 'baixo':
+            return 'info';
+        case undefined: {
+            throw new Error('Not implemented yet: undefined case');
+        }
         default:
             return 'info';
     }
 }
-//# sourceMappingURL=detector-performance.js.map

package/dist/analysts/detectors/detector-phantoms.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { config, isInsideSrc, LIMITES_PADRAO } from '../../core/config/index.js';
@@ -5,20 +6,30 @@ import { scanRepository } from '../../core/execution/index.js';
 import { isTestArquivo, normalizePath } from '../../shared/helpers/index.js';
 import { grafoDependencias } from './detector-dependencies.js';
 const EXTENSOES_ALVO = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+// Janela de inatividade mínima para considerar fantasma (default mais conservador)
 const INATIVIDADE_DIAS = Number(process.env.GHOST_DAYS) || LIMITES_PADRAO.GUARDIAN.DIAS_INATIVIDADE_GHOST;
 const MILIS_POR_DIA = 86_400_000;
+// Padrões de entrypoints comuns que NÃO devem ser considerados órfãos
 const ENTRYPOINT_PADROES = [/^(src\/)?index\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?main\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?server\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?app\.(ts|js|tsx|jsx|mjs|cjs)$/i, /^(src\/)?cli\.(ts|js|tsx|jsx|mjs|cjs)$/i, /(^|\/)bin\/[^/]+\.(ts|js|mjs|cjs)$/i, /\/index\.(ts|js|tsx|jsx|mjs|cjs)$/i, /config\.(ts|js|cjs|mjs)$/i, /\.config\.(ts|js|cjs|mjs)$/i, /\.d\.ts$/i];
+/**
+ * Verifica se é um entrypoint conhecido (bin, cli, main, index, etc.)
+ */
 function isEntrypoint(relPath) {
     const normalized = normalizePath(relPath);
     return ENTRYPOINT_PADROES.some(caminho => caminho.test(normalized));
 }
+/**
+ * Verifica se o arquivo está sendo referenciado por outro arquivo no grafo
+ */
 function estaSendoReferenciado(relPath, grafo) {
     const normalized = normalizePath(relPath);
+    // Variações que podem existir no grafo (com/sem extensão, etc.)
     const variations = new Set([normalized]);
     const ext = path.posix.extname(normalized);
     if (ext) {
         variations.add(normalized.slice(0, -ext.length));
     }
+    // Adiciona variações com extensões comuns
     const base = ext ? normalized.slice(0, -ext.length) : normalized;
     for (const erro of ['.ts', '.js', '.tsx', '.jsx', '.mjs', '.cjs']) {
         variations.add(base + erro);
@@ -26,12 +37,16 @@ function estaSendoReferenciado(relPath, grafo) {
     for (const dependencias of grafo.values()) {
         for (const dep of dependencias) {
             const depNorm = normalizePath(dep);
-            if (variations.has(depNorm))
+            if (variations.has(depNorm)) {
                 return true;
+            }
         }
     }
     return false;
 }
+/**
+ * Verifica se o arquivo importa outros (é um consumidor, não apenas consumido)
+ */
 function importaOutros(relPath, grafo) {
     const normalized = normalizePath(relPath);
     for (const [chave, deps] of grafo.entries()) {
@@ -45,32 +60,43 @@ export async function detectarFantasmas(baseDir = process.cwd()) {
     const fileMap = await scanRepository(baseDir);
     const agora = Date.now();
     const fantasmas = [];
+    // Verifica se a config permite excluir testes da checagem de órfãos
     const testConfiguracao = config.testPadroes;
-    const excludeTestsFromOrphan = testConfiguracao?.excludeFromOrphanCheck !== false;
+    const excludeTestsFromOrphan = testConfiguracao?.excludeFromOrphanCheck !== false; // default true
     for (const entrada of Object.values(fileMap)) {
         const { relPath, fullCaminho } = entrada;
         const ext = path.extname(relPath).toLowerCase();
-        if (!EXTENSOES_ALVO.includes(ext))
+        if (!EXTENSOES_ALVO.includes(ext)) {
             continue;
+        }
+        // 1. Ignora arquivos de teste (usando config centralizada)
         if (excludeTestsFromOrphan && isTestArquivo(relPath)) {
             continue;
         }
+        // 2. Ignora entrypoints conhecidos
         if (isEntrypoint(relPath)) {
             continue;
         }
         try {
             const stat = await fs.stat(fullCaminho);
             const diasInativo = Math.floor((agora - stat.mtimeMs) / MILIS_POR_DIA);
-            if (grafoDependencias.size === 0)
+            // Se o grafo ainda não foi populado (execução isolada da poda), não arrisca classificar
+            if (grafoDependencias.size === 0) {
                 continue;
+            }
             const referenciado = estaSendoReferenciado(relPath, grafoDependencias);
+            // 3. Arquivo que importa outros não é órfão (é um consumidor/entrypoint)
             if (importaOutros(relPath, grafoDependencias)) {
                 continue;
             }
+            // 4. Proteção extra para arquivos dentro de src/
             if (isInsideSrc(relPath)) {
-                if (diasInativo < 7)
+                // Arquivos recentes (menos de 7 dias) não são marcados como órfãos
+                if (diasInativo < 7) {
                     continue;
+                }
             }
+            // 5. Heurística final: somente é fantasma se (não referenciado) E (inativo acima do limiar)
             if (!referenciado && diasInativo > INATIVIDADE_DIAS) {
                 fantasmas.push({
                     arquivo: relPath,
@@ -80,6 +106,7 @@ export async function detectarFantasmas(baseDir = process.cwd()) {
             }
         }
         catch {
+            // Silenciosamente ignora arquivos inacessíveis
         }
     }
     return {
@@ -87,4 +114,3 @@ export async function detectarFantasmas(baseDir = process.cwd()) {
         fantasmas
     };
 }
-//# sourceMappingURL=detector-phantoms.js.map