@mocoto/mahoraga 0.14.1 → 0.14.3

package/dist/analysts/detectors/detector-code-fragile.js

@@ -45,7 +45,7 @@ const visitorFragil = {
         const fragilidades = visitorState.resultados.get('codigo-fragil') ?? [];
         let depth = 0;
         let current = path;
-        while (current) {
+        while (current.node.type !== 'Program') {
             if (current.isIfStatement()) {
                 depth++;
             }
@@ -65,9 +65,9 @@ const visitorFragil = {
     FunctionDeclaration(path, state) {
         const visitorState = state;
         const fragilidades = visitorState.resultados.get('codigo-fragil') ?? [];
-        const maxLinhas = config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_LINHAS_FUNCAO ?? LIMITES.LINHAS_FUNCAO;
+        const maxLinhas = config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_LINHAS_FUNCAO;
         const node = path.node;
-        if (node.body.type === 'BlockStatement') {
+        {
             const inicio = node.loc?.start.line ?? 0;
             const fim = node.loc?.end.line ?? 0;
             const numLinhas = fim - inicio;
@@ -90,7 +90,7 @@ const visitorFragil = {
         if (isInVariableDeclarator(path) || isInArrayIndex(path)) {
             return;
         }
-        frameworksDetectados ??= detectarFrameworks(process.cwd()).map(arquivo => arquivo.name);
+        frameworksDetectados = detectarFrameworks(process.cwd()).map(arquivo => arquivo.name);
         if (isWhitelistedConstant(value, frameworksDetectados)) {
             return;
         }
@@ -104,14 +104,43 @@ const visitorFragil = {
         visitorState.resultados.set('codigo-fragil', fragilidades);
     }
 };
+function converterFragilidadesParaOcorrencias(fragilidades, relPath) {
+    const ocorrencias = [];
+    const porSeveridade = agruparPor(fragilidades, arquivo => arquivo.severidade ?? 'media');
+    for (const [severidade, items] of Object.entries(porSeveridade)) {
+        if (items.length === 0) {
+            continue;
+        }
+        const nivel = severidade === 'critica' || severidade === 'alta' ? 'erro' : severidade === 'media' ? 'aviso' : 'info';
+        const tipos = {};
+        for (const it of items) {
+            tipos[it.tipo] = (tipos[it.tipo] || 0) + 1;
+        }
+        const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
+        const amostra = items.slice(0, 5).map(it => `${it.tipo} (L${it.linha})`);
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'codigo-fragil',
+            nivel,
+            mensagem: messages.DetectorCodigoFragilMensagens.fragilidadesResumo(severidade, resumo, {
+                severidade,
+                total: items.length,
+                tipos,
+                amostra
+            }),
+            relPath,
+            linha: items[0].linha
+        }));
+    }
+    return ocorrencias;
+}
 export const analistaCodigoFragil = {
     nome: 'codigo-fragil',
     categoria: 'qualidade',
     descricao: 'Detecta padrões de código que podem levar a problemas futuros',
     limites: {
-        maxLinhasFuncao: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_LINHAS_FUNCAO ?? LIMITES.LINHAS_FUNCAO,
-        maxParametros: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_PARAMETROS ?? LIMITES.PARAMETROS_FUNCAO,
-        maxNestedCallbacks: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_NESTED_CALLBACKS ?? LIMITES.CALLBACKS_ANINHADOS
+        maxLinhasFuncao: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_LINHAS_FUNCAO,
+        maxParametros: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_PARAMETROS,
+        maxNestedCallbacks: config.ANALISE_LIMITES.CODIGO_FRAGIL.MAX_NESTED_CALLBACKS
     },
     visitor: visitorFragil,
     test: (relPath) => {
@@ -156,11 +185,12 @@ export const analistaCodigoFragil = {
             });
         }
         // Processamento AST: Otimizado (preColetado) ou Fallback
-        if (ast.preColetado) {
-            fragilidades.push(...ast.preColetado);
+        const astMeta = ast;
+        if (astMeta?.preColetado) {
+            fragilidades.push(...astMeta.preColetado);
         }
         else {
-            const nodeToTraverse = ast.node ?? ast;
+            const nodeToTraverse = astMeta?.node ?? ast;
             const stateMock = {
                 resultados: new Map([['codigo-fragil', []]])
             };
@@ -169,32 +199,7 @@ export const analistaCodigoFragil = {
         }
         // Detecções de texto complementares (Heurísticas)
         detectarProblemasAvancados(src, fragilidades);
-        // Converter para ocorrências Mahoraga
-        const ocorrencias = [];
-        const porSeveridade = agruparPor(fragilidades, arquivo => arquivo.severidade ?? 'media');
-        for (const [severidade, items] of Object.entries(porSeveridade)) {
-            if (items.length > 0) {
-                const nivel = severidade === 'critica' || severidade === 'alta' ? 'erro' : severidade === 'media' ? 'aviso' : 'info';
-                const resumo = items.slice(0, 3).map(caminho => caminho.tipo).join(', ');
-                const tipos = {};
-                for (const it of items) {
-                    tipos[it.tipo] = (tipos[it.tipo] || 0) + 1;
-                }
-                const amostra = items.slice(0, 5).map(it => `${it.tipo} (L${it.linha})`);
-                ocorrencias.push(criarOcorrencia({
-                    tipo: 'codigo-fragil',
-                    nivel,
-                    mensagem: messages.DetectorCodigoFragilMensagens.fragilidadesResumo(severidade, resumo, {
-                        severidade,
-                        total: items.length,
-                        tipos,
-                        amostra
-                    }),
-                    relPath,
-                    linha: items[0].linha
-                }));
-            }
-        }
+        const ocorrencias = converterFragilidadesParaOcorrencias(fragilidades, relPath);
         return filtrarOcorrenciasSuprimidas(ocorrencias, 'codigo-fragil', src);
     }
 };

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

@@ -14,7 +14,7 @@ function ehImportSomenteTipo(node) {
     if (node.importKind === 'type') {
         return true;
     }
-    const specifiers = node.specifiers || [];
+    const specifiers = node.specifiers;
     if (specifiers.length === 0) {
         return false;
     }
@@ -185,12 +185,12 @@ function processarImportDeclaration(caminho, state) {
     }
     const val = caminho.node.source.value;
     if (somenteTipo) {
-        const specifiers = caminho.node.specifiers || [];
+        const specifiers = caminho.node.specifiers;
         for (const s of specifiers) {
             if (s.type === 'ImportDefaultSpecifier' || s.type === 'ImportSpecifier') {
                 state.importsDeclarados.add(s.local.name);
             }
-            else if (s.type === 'ImportNamespaceSpecifier') {
+            else {
                 state.importsDeclarados.add(s.local.name);
             }
         }
@@ -240,12 +240,12 @@ function processarImportDeclaration(caminho, state) {
             });
         }
     }
-    const specifiers = caminho.node.specifiers || [];
+    const specifiers = caminho.node.specifiers;
     for (const s of specifiers) {
         if (s.type === 'ImportDefaultSpecifier' || s.type === 'ImportSpecifier') {
             state.importsDeclarados.add(s.local.name);
         }
-        else if (s.type === 'ImportNamespaceSpecifier') {
+        else {
             state.importsDeclarados.add(s.local.name);
         }
     }

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

@@ -13,7 +13,7 @@ export const analistaDuplicacoes = {
     test: (relPath) => {
         return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
     },
-    aplicar: async (src, relPath, ast, fullCaminho, contexto) => {
+    aplicar: (src, relPath, ast, fullCaminho, contexto) => {
         if (!ast || !src || !contexto) {
             return [];
         }
@@ -40,24 +40,7 @@ export const analistaDuplicacoes = {
             if (duplicacoes.length === 0) {
                 return [];
             }
-            // Agrupar por tipo de similaridade
-            const porTipo = agruparPorTipoSimilaridade(duplicacoes);
-            const ocorrencias = [];
-            for (const [tipo, dups] of Object.entries(porTipo)) {
-                if (dups.length > 0) {
-                    const nivel = tipo === 'identica' ? 'aviso' : 'info';
-                    const primeiraFunc = dups[0]?.funcaoA;
-                    const resumo = dups.map(diretorio => `${diretorio.funcaoA?.nome ?? 'unknown'} ≈ ${diretorio.funcaoB?.nome ?? 'unknown'} (${diretorio.similaridade.toFixed(0)}%)`).slice(0, 3).join(', ');
-                    ocorrencias.push(criarOcorrencia({
-                        tipo: 'codigo_duplicado',
-                        nivel,
-                        mensagem: messages.DetectorAgregadosMensagens.duplicacoesResumo(tipo, resumo, dups.length),
-                        relPath,
-                        linha: primeiraFunc?.inicio ?? 1
-                    }));
-                }
-            }
-            return ocorrencias;
+            return agruparEConverterDuplicacoes(duplicacoes, relPath);
         }
         catch (erro) {
             return [criarOcorrencia({
@@ -70,6 +53,26 @@ export const analistaDuplicacoes = {
         }
     }
 };
+function agruparEConverterDuplicacoes(duplicacoes, relPath) {
+    const porTipo = agruparPorTipoSimilaridade(duplicacoes);
+    const ocorrencias = [];
+    for (const [tipo, dups] of Object.entries(porTipo)) {
+        if (dups.length === 0) {
+            continue;
+        }
+        const nivel = tipo === 'identica' ? 'aviso' : 'info';
+        const primeiraFunc = dups[0]?.funcaoA;
+        const resumo = dups.map(diretorio => `${diretorio.funcaoA?.nome ?? 'unknown'} ≈ ${diretorio.funcaoB?.nome ?? 'unknown'} (${diretorio.similaridade.toFixed(0)}%)`).slice(0, 3).join(', ');
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'codigo_duplicado',
+            nivel,
+            mensagem: messages.DetectorAgregadosMensagens.duplicacoesResumo(tipo, resumo, dups.length),
+            relPath,
+            linha: primeiraFunc?.inicio ?? 1
+        }));
+    }
+    return ocorrencias;
+}
 function extrairFuncoes(ast, caminho, src) {
     const funcoes = [];
     const linhas = src.split('\n');
@@ -125,12 +128,12 @@ function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
     if ('id' in node && node.id && 'name' in node.id) {
         nome = node.id.name;
     }
-    else if ('key' in node && node.key && 'name' in node.key) {
+    else if ('key' in node && 'name' in node.key) {
         nome = node.key.name;
     }
     else if (path.parentPath.isVariableDeclarator()) {
         const parent = path.parentPath.node;
-        nome = 'id' in parent && parent.id && 'name' in parent.id ? parent.id.name : 'assigned';
+        nome = 'id' in parent && 'name' in parent.id ? parent.id.name : 'assigned';
     }
     // Extrair parâmetros
     const parametros = ('params' in node && Array.isArray(node.params) ? node.params : []).map((param) => {
@@ -138,7 +141,7 @@ function extrairInfoFuncao(path, caminho, tipoFuncao, linhas) {
         if (param.type === 'Identifier' && 'name' in param) {
             return param.name;
         } // Identifier node
-        if (param.type === 'RestElement' && 'argument' in param && param.argument && 'name' in param.argument) {
+        if (param.type === 'RestElement' && 'argument' in param && 'name' in param.argument) {
             return `...${param.argument.name}`; // RestElement node
         }
         return param.type;
@@ -257,10 +260,7 @@ function agruparPorTipoSimilaridade(duplicacoes) {
     return duplicacoes.reduce((acc, dup) => {
         const tipo = dup.tipoSimilaridade;
         if (tipo) {
-            if (!acc[tipo]) {
-                acc[tipo] = [];
-            }
-            acc[tipo].push(dup);
+            (acc[tipo] ??= []).push(dup);
         }
         return acc;
     }, {});

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

@@ -14,7 +14,7 @@ export function detectarMonorepo(baseDir) {
         return info;
     }
     // Detect package manager
-    const pm = rootPkg.packageManager || '';
+    const pm = rootPkg.packageManager ?? '';
     if (pm) {
         info.packageManager = pm;
     }
@@ -51,11 +51,12 @@ export function detectarMonorepo(baseDir) {
         info.type = 'nx';
         try {
             const nx = JSON.parse(fs.readFileSync(nxPath, 'utf-8'));
-            if (nx.workspaceLayout?.appsDir) {
-                workspaceGlobs.push(nx.workspaceLayout.appsDir);
+            const nxLayout = nx.workspaceLayout;
+            if (nxLayout?.appsDir) {
+                workspaceGlobs.push(nxLayout.appsDir);
             }
-            if (nx.workspaceLayout?.libsDir) {
-                workspaceGlobs.push(nx.workspaceLayout.libsDir);
+            if (nxLayout?.libsDir) {
+                workspaceGlobs.push(nxLayout.libsDir);
             }
         }
         catch { }
@@ -82,7 +83,7 @@ export function detectarMonorepo(baseDir) {
         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;
@@ -132,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,
                             });
                         }
                     }
@@ -173,7 +174,7 @@ export const detectorMonorepo = {
         // 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]) {
@@ -236,47 +237,52 @@ export const detectorMonorepo = {
                 versionMap.set(dep, verMap);
             }
         }
-        for (const [dep, versions] of versionMap) {
-            if (versions.size > 1) {
-                const uniqueVersions = new Set(versions.values());
-                if (uniqueVersions.size > 1) {
-                    ocorrencias.push({
-                        tipo: 'monorepo-versao-mismatch',
-                        nivel: 'aviso',
-                        mensagem: `Dependência ${dep} com versões diferentes entre workspaces: ${Array.from(versions.entries()).map(([w, v]) => `${w}@${v}`).join(', ')}`,
-                        origem: 'detector-monorepo',
-                        relPath: '[monorepo]',
-                        linha: 0,
-                    });
-                }
+        detectarVersionMismatch(versionMap, ocorrencias);
+        detectarDependenciasInternasFaltando(info, ocorrencias);
+        return ocorrencias;
+    },
+};
+function detectarVersionMismatch(versionMap, ocorrencias) {
+    for (const [dep, versions] of versionMap) {
+        if (versions.size > 1) {
+            const uniqueVersions = new Set(versions.values());
+            if (uniqueVersions.size > 1) {
+                ocorrencias.push({
+                    tipo: 'monorepo-versao-mismatch',
+                    nivel: 'aviso',
+                    mensagem: `Dependência ${dep} com versões diferentes entre workspaces: ${Array.from(versions.entries()).map(([w, v]) => `${w}@${v}`).join(', ')}`,
+                    origem: 'detector-monorepo',
+                    relPath: '[monorepo]',
+                    linha: 0,
+                });
             }
         }
-        // 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);
-            for (const imp of imports) {
-                for (const wsName of workspaceNames) {
-                    if (imp.includes(wsName) && wsName !== ws.name) {
-                        const isDep = ws.dependencies[wsName] || ws.devDependencies[wsName] || ws.peerDependencies[wsName];
-                        if (!isDep) {
-                            ocorrencias.push({
-                                tipo: 'monorepo-dependencia-interna-faltando',
-                                nivel: 'aviso',
-                                mensagem: `${ws.name} importa ${wsName} mas não o declara como dependência`,
-                                origem: 'detector-monorepo',
-                                relPath: `[${ws.name}]`,
-                                linha: 0,
-                            });
-                        }
-                        break;
+    }
+}
+function detectarDependenciasInternasFaltando(info, ocorrencias) {
+    const workspaceNames = new Set(info.workspaces.map(w => w.name));
+    for (const ws of info.workspaces) {
+        const imports = coletarImports(ws.dir);
+        for (const imp of imports) {
+            for (const wsName of workspaceNames) {
+                if (imp.includes(wsName) && wsName !== ws.name) {
+                    const isDep = ws.dependencies[wsName] || ws.devDependencies[wsName] || ws.peerDependencies[wsName];
+                    if (!isDep) {
+                        ocorrencias.push({
+                            tipo: 'monorepo-dependencia-interna-faltando',
+                            nivel: 'aviso',
+                            mensagem: `${ws.name} importa ${wsName} mas não o declara como dependência`,
+                            origem: 'detector-monorepo',
+                            relPath: `[${ws.name}]`,
+                            linha: 0,
+                        });
                     }
+                    break;
                 }
             }
         }
-        return ocorrencias;
-    },
-};
+    }
+}
 function coletarImports(dir) {
     const imports = [];
     try {

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

@@ -169,12 +169,33 @@ function detectarPadroesPerformance(src, problemas, relPath) {
         }
     });
 }
+function detectarTimerSemCleanup(path, ast, problemas, relPath) {
+    if (path.node.callee.type !== 'Identifier') {
+        return;
+    }
+    if (path.node.callee.name !== 'setTimeout' && path.node.callee.name !== 'setInterval') {
+        return;
+    }
+    const parentFunction = path.getFunctionParent();
+    const context = parentFunction ? parentFunction.toString() : ast.toString();
+    if (context.includes('clear') || relPath.includes('test')) {
+        return;
+    }
+    problemas.push({
+        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,
+        sugestao: `Use clear${path.node.callee.name.replace('set', '')} para limpar`
+    });
+}
 function detectarProblemasPerformanceAST(ast, problemas, relPath) {
     try {
         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',
@@ -195,23 +216,8 @@ 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')) {
-                        problemas.push({
-                            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,
-                            sugestao: `Use clear${path.node.callee.name.replace('set', '')} para limpar`
-                        });
-                    }
-                }
+                detectarTimerSemCleanup(path, ast, problemas, relPath);
             }
         });
     }
@@ -226,6 +232,7 @@ function mapearImpactoParaNivel(impacto) {
         case 'medio':
             return 'aviso';
         case 'baixo':
+            return 'info';
         case undefined: {
             throw new Error('Not implemented yet: undefined case');
         }

package/dist/analysts/detectors/detector-recommendation-architecture.js

@@ -3,6 +3,43 @@ import { criarOcorrencia } from '../../types/index.js';
  * Analista global que analisa o projeto completo e recomenda
  * a melhor arquitetura (Clean Architecture, Microsserviços, MVC, etc.)
  */
+const CONFIANCA_SIMPLES = 60;
+function adicionarOcorrenciasRecomendacao(ocorrencias, _relPath, sinaisCleanArch, sinaisDistributed, recomendacoes, arquiteturaRecomendada, confianca) {
+    ocorrencias.push(criarOcorrencia({
+        tipo: 'recomendacao-arquitetura',
+        nivel: 'info',
+        relPath: _relPath,
+        linha: 1,
+        mensagem: `[TARGET] Arquitetura recomendada: ${arquiteturaRecomendada} (${confianca}% confiança)`
+    }));
+    if (sinaisCleanArch.length > 0) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'sinais-clean-arch',
+            nivel: 'info',
+            relPath: _relPath,
+            linha: 1,
+            mensagem: `Sinais de Clean Architecture: ${sinaisCleanArch.join(', ')}`
+        }));
+    }
+    if (sinaisDistributed.length > 0) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'sinais-distributed-arch',
+            nivel: 'info',
+            relPath: _relPath,
+            linha: 1,
+            mensagem: `Sinais de Arquitetura Distribuída: ${sinaisDistributed.join(', ')}`
+        }));
+    }
+    for (const rec of recomendacoes.slice(0, 5)) {
+        ocorrencias.push(criarOcorrencia({
+            tipo: 'recomendacao-arquitetura-item',
+            nivel: 'info',
+            relPath: _relPath,
+            linha: 1,
+            mensagem: `[IDEA] ${rec}`
+        }));
+    }
+}
 export const analistaRecomendacaoArquitetura = {
     nome: 'recomendacao-arquitetura',
     categoria: 'arquitetura',
@@ -210,7 +247,7 @@ export const analistaRecomendacaoArquitetura = {
         }
         // MVC para projetos web tradicionais
         if (temFrontend && temControllers && !temEntities) {
-            const scoreMvc = (temControllers ? 15 : 0) + (temFrontend ? 15 : 0);
+            const scoreMvc = 30;
             if (scoreMvc > melhorScore && !complexidadeBaixa) {
                 arquiteturaRecomendada = 'MVC (Model-View-Controller)';
                 melhorScore = scoreMvc;
@@ -221,7 +258,7 @@ export const analistaRecomendacaoArquitetura = {
         if (melhorScore === 0) {
             if (complexidadeBaixa) {
                 arquiteturaRecomendada = 'Arquitetura Simples / Monolítica';
-                confianca = 60;
+                confianca = CONFIANCA_SIMPLES;
                 recomendacoes.push('Projeto de baixa complexidade - comece com uma estrutura simples');
                 recomendacoes.push('Considere evoluir para Clean Architecture conforme o projeto crescer');
             }
@@ -243,40 +280,7 @@ export const analistaRecomendacaoArquitetura = {
         if (totalArquivos > 100 && servicosSet.size === 0) {
             recomendacoes.push('Projeto grande e monolítico - considere dividir em serviços menores');
         }
-        ocorrencias.push(criarOcorrencia({
-            tipo: 'recomendacao-arquitetura',
-            nivel: 'info',
-            relPath: _relPath,
-            linha: 1,
-            mensagem: `[TARGET] Arquitetura recomendada: ${arquiteturaRecomendada} (${confianca}% confiança)`
-        }));
-        if (sinaisCleanArch.length > 0) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'sinais-clean-arch',
-                nivel: 'info',
-                relPath: _relPath,
-                linha: 1,
-                mensagem: `Sinais de Clean Architecture: ${sinaisCleanArch.join(', ')}`
-            }));
-        }
-        if (sinaisDistributed.length > 0) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'sinais-distributed-arch',
-                nivel: 'info',
-                relPath: _relPath,
-                linha: 1,
-                mensagem: `Sinais de Arquitetura Distribuída: ${sinaisDistributed.join(', ')}`
-            }));
-        }
-        for (const rec of recomendacoes.slice(0, 5)) {
-            ocorrencias.push(criarOcorrencia({
-                tipo: 'recomendacao-arquitetura-item',
-                nivel: 'info',
-                relPath: _relPath,
-                linha: 1,
-                mensagem: `[IDEA] ${rec}`
-            }));
-        }
+        adicionarOcorrenciasRecomendacao(ocorrencias, _relPath, sinaisCleanArch, sinaisDistributed, recomendacoes, arquiteturaRecomendada, confianca);
         return ocorrencias;
     }
 };