@mocoto/mahoraga 0.14.8 → 0.14.9

package/dist/analysts/architects/archetypes-custom.js

@@ -1,23 +1,10 @@
-// @mahoraga-disable tipo-literal-inline-complexo ml-deep-nesting
-// SPDX-License-Identifier: MIT
-// Justificativa: tipos locais para arquétipos personalizados
-/**
- * Sistema de Arquétipos Personalizados do Mahoraga
- *
- * Permite que usuários criem arquétipos personalizados para seus projetos,
- * mantendo compatibilidade com arquétipos oficiais e oferecendo sugestões
- * de melhores práticas baseadas na personalização do usuário.
- */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-// NOTA: parseFileAST ainda não foi implementado no módulo de parsing
-// import { parseFileAST } from '@core/parsing/parser.js';
 import { getMessages } from '../../core/messages/index.js';
-import { SUKUNA_ARQUIVOS } from '../../core/registry/index.js';
+import { MAHORAGA_ARQUIVOS } from '../../core/registry/index.js';
 import { ARQUETIPOS } from '../strategists/index.js';
 import { lerEstado, salvarEstado } from '../../shared/persistence/index.js';
 const { log, ArquetiposExtraMensagens } = getMessages();
-// Nome do arquivo legado (para compatibilidade)
 const ARQUETIPO_PERSONALIZADO_FILENAME = 'mahoraga.repo.arquetipo.json';
 function logVerbose(fn) {
     const isTest = (process.env.VITEST ?? '') !== '';
@@ -26,24 +13,15 @@ function logVerbose(fn) {
         fn();
     }
 }
-/**
- * Carrega o arquétipo personalizado do projeto atual
- * Tenta primeiro o novo caminho (.mahoraga/estrutura.arquetipo.json),
- * depois o legado (raiz/mahoraga.repo.arquetipo.json)
- */
 export async function carregarArquetipoPersonalizado(baseDir = process.cwd()) {
-    // Tentar novo caminho primeiro
-    const novoCaminho = SUKUNA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
+    const novoCaminho = MAHORAGA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
     const caminhoLegado = path.join(baseDir, ARQUETIPO_PERSONALIZADO_FILENAME);
     try {
-        // Tenta novo caminho
         const arquetipo = await lerEstado(novoCaminho, null);
         if (arquetipo?.nome && arquetipo.arquetipoOficial) {
             return arquetipo;
         }
-        // Se não encontrou no novo caminho, tenta o legado
         const arquetipoLegado = await lerEstado(caminhoLegado, null);
-        // Validação básica
         if (!arquetipoLegado?.nome || !arquetipoLegado.arquetipoOficial) {
             logVerbose(() => { log.aviso(ArquetiposExtraMensagens.naoEncontrado.replace('{novo}', novoCaminho).replace('{legado}', caminhoLegado)); });
             return null;
@@ -51,14 +29,9 @@ export async function carregarArquetipoPersonalizado(baseDir = process.cwd()) {
         return arquetipoLegado;
     }
     catch {
-        // Arquivo não existe ou é inválido - isso é normal
         return null;
     }
 }
-/**
- * Salva o arquétipo personalizado do projeto atual
- * Usa o novo caminho (.mahoraga/estrutura.arquetipo.json)
- */
 export async function salvarArquetipoPersonalizado(arquetipo, _baseDir = process.cwd()) {
     const arquetipoCompleto = {
         ...arquetipo,
@@ -68,9 +41,7 @@ export async function salvarArquetipoPersonalizado(arquetipo, _baseDir = process
             notasUsuario: undefined
         }
     };
-    // Usar novo caminho centralizado
-    const novoCaminho = SUKUNA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
-    // Garantir que o diretório .mahoraga existe
+    const novoCaminho = MAHORAGA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
     const mahoragaDir = path.dirname(novoCaminho);
     try {
         await fs.mkdir(mahoragaDir, {
@@ -78,18 +49,13 @@ export async function salvarArquetipoPersonalizado(arquetipo, _baseDir = process
         });
     }
     catch {
-        // Diretório já existe
     }
     await salvarEstado(novoCaminho, arquetipoCompleto);
     log.sucesso(ArquetiposExtraMensagens.salvo.replace('{caminho}', novoCaminho));
 }
-/**
- * Verifica se existe um arquétipo personalizado
- * Verifica tanto o novo caminho quanto o legado
- */
 export async function existeArquetipoPersonalizado(baseDir = process.cwd()) {
     try {
-        await fs.stat(SUKUNA_ARQUIVOS.ESTRUTURA_ARQUETIPO);
+        await fs.stat(MAHORAGA_ARQUIVOS.ESTRUTURA_ARQUETIPO);
         return true;
     }
     catch {
@@ -103,17 +69,11 @@ export async function existeArquetipoPersonalizado(baseDir = process.cwd()) {
         }
     }
 }
-/**
- * Obtém o arquétipo oficial base para um arquétipo personalizado
- */
 export function obterArquetipoOficial(arquetipoPersonalizado) {
     const nomeOficial = arquetipoPersonalizado.arquetipoOficial;
     const encontrado = ARQUETIPOS?.find((arq) => arq.nome === nomeOficial);
     return encontrado ?? null;
 }
-/**
- * Gera sugestões de criação de arquétipo personalizado quando projeto é desconhecido
- */
 export function gerarSugestaoArquetipoPersonalizado(projetoDesconhecido) {
     const sugestao = `
 ${ArquetiposExtraMensagens.projetoPersonalizado.replace('{nome}', projetoDesconhecido.nome)}
@@ -134,42 +94,29 @@ ${ArquetiposExtraMensagens.explicacaoCriar}
 `;
     return sugestao;
 }
-/**
- * Cria um template de arquétipo personalizado baseado na estrutura atual do projeto
- */
 export function criarTemplateArquetipoPersonalizado(nomeProjeto, estruturaDetectada, arquivosRaiz, arquetipoSugerido = 'generico') {
-    // Usa o arquétipo sugerido pelo sistema de detecção inteligente
-    // Se não foi fornecido, tenta inferir de forma mais rigorosa
     let arquetipoOficial = arquetipoSugerido;
     if (arquetipoOficial === 'generico' || !arquetipoOficial) {
-        // Heurística mais rigorosa para evitar falsos positivos
-        // CLI: precisa ter bin/ E (cli/ OU commands/) E package.json com bin
         const temBin = estruturaDetectada.some(dir => dir === 'bin' || dir.startsWith('bin/'));
         const temCli = estruturaDetectada.some(dir => dir.includes('/cli') || dir === 'cli');
         const temCommands = estruturaDetectada.some(dir => dir.includes('/commands') || dir === 'commands');
         if (temBin && (temCli || temCommands)) {
             arquetipoOficial = 'cli-modular';
         }
-        // Bot: precisa ter src/bot/ E (events/ OU scenes/) - muito específico
         else if (estruturaDetectada.some(dir => dir === 'src/bot' || dir.startsWith('src/bot/')) && estruturaDetectada.some(dir => dir.includes('events') || dir.includes('scenes'))) {
             arquetipoOficial = 'bot';
         }
-        // API: precisa ter controllers/ E routes/
         else if (estruturaDetectada.some(dir => dir.includes('controllers')) && estruturaDetectada.some(dir => dir.includes('routes'))) {
             arquetipoOficial = 'api-rest-express';
         }
-        // Fullstack: precisa ter pages/ E api/ (ambos)
         else if (estruturaDetectada.some(dir => dir.includes('pages')) && estruturaDetectada.some(dir => dir.includes('api'))) {
             arquetipoOficial = 'fullstack';
         }
-        // Fallback: lib-tsc se tem src/ organizado mas nenhum dos padrões acima
         else if (estruturaDetectada.some(dir => dir === 'src' || dir.startsWith('src/'))) {
             arquetipoOficial = 'lib-tsc';
         }
     }
-    // Identifica diretórios principais (não muito profundos)
     const diretoriosPrincipais = estruturaDetectada.filter(dir => !dir.includes('/') || dir.split('/').length <= 2).filter(dir => !dir.startsWith('node_modules') && !dir.startsWith('.git'));
-    // Identifica arquivos-chave na raiz
     const arquivosChave = arquivosRaiz.filter(file => ['package.json', 'tsconfig.json', 'README.md', '.env.example'].includes(file) || file.endsWith('.ts') || file.endsWith('.js')).slice(0, 5);
     return {
         nome: nomeProjeto,
@@ -179,7 +126,6 @@ export function criarTemplateArquetipoPersonalizado(nomeProjeto, estruturaDetect
             diretorios: diretoriosPrincipais,
             arquivosChave,
             padroesNomenclatura: {
-                // Padrões comuns baseados na estrutura detectada
                 ...(estruturaDetectada.some(diretorio => diretorio.includes('components')) && {
                     components: '*-component.*'
                 }),
@@ -198,9 +144,6 @@ export function criarTemplateArquetipoPersonalizado(nomeProjeto, estruturaDetect
         }
     };
 }
-/**
- * Valida um arquétipo personalizado
- */
 export function validarArquetipoPersonalizado(arquetipo) {
     const erros = [];
     if (!arquetipo.nome || typeof arquetipo.nome !== 'string') {
@@ -210,7 +153,6 @@ export function validarArquetipoPersonalizado(arquetipo) {
         erros.push(ArquetiposExtraMensagens.validacao.arquetipoObrigatorio);
     }
     else {
-        // Verifica se o arquétipo oficial existe
         const arquetipoOficial = ARQUETIPOS?.find((arq) => arq.nome === arquetipo.arquetipoOficial);
         if (!arquetipoOficial) {
             erros.push(ArquetiposExtraMensagens.validacao.arquetipoNaoEncontrado.replace('{arquetipo}', arquetipo.arquetipoOficial).replace('{disponiveis}', ARQUETIPOS.map(arquivo => (arquivo).nome).join(', ')));
@@ -227,15 +169,9 @@ export function validarArquetipoPersonalizado(arquetipo) {
         erros
     };
 }
-/**
- * Lista todos os arquétipos oficiais disponíveis
- */
 export function listarArquetiposOficiais() {
     return ARQUETIPOS;
 }
-/**
- * Integra arquétipo personalizado com oficial para sugestões
- */
 export function integrarArquetipos(personalizado, oficial) {
     return {
         ...oficial,
@@ -244,7 +180,6 @@ export function integrarArquetipos(personalizado, oficial) {
         requiredDirs: personalizado.estruturaPersonalizada.diretorios,
         optionalDirs: oficial.optionalDirs,
         rootFilesAllowed: personalizado.estruturaPersonalizada.arquivosChave,
-        // Mantém outras propriedades do oficial como base
         forbiddenDirs: oficial.forbiddenDirs,
         dependencyHints: oficial.dependencyHints,
         filePresencePatterns: oficial.filePresencePatterns,

package/dist/analysts/architects/detector-archetypes.js

@@ -1,6 +1,3 @@
-// SPDX-License-Identifier: MIT
-// Nota: manter ARQUETIPOS importado visível como lembrete para integração futura
-// @mahoraga-disable ml-deep-nesting
 import path from 'node:path';
 import { config } from '../../core/config/index.js';
 import { getMessages } from '../../core/messages/index.js';
@@ -11,8 +8,6 @@ import { carregarArquetipoPersonalizado, integrarArquetipos, obterArquetipoOfici
 import { extrairSinaisAvancados } from './signals-project-advanced.js';
 const { DetectorArquetiposExtraMensagens } = getMessages();
 function scoreArquetipo(def, arquivos, _sinaisAvancados) {
-    // Implementação simplificada temporária.
-    // Mantemos a assinatura e a forma do retorno para compatibilidade.
     const matchedRequired = (def.requiredDirs ?? []).filter(diretorio => arquivos.some(arquivo => arquivo.startsWith(`${diretorio}/`) || arquivo === diretorio));
     const missingRequired = (def.requiredDirs ?? []).filter(diretorio => !matchedRequired.includes(diretorio));
     return {
@@ -32,12 +27,10 @@ function scoreArquetipo(def, arquivos, _sinaisAvancados) {
         candidatoExtra: undefined
     };
 }
-// Exposição somente para testes (não altera API pública)
-// Evita exportar diretamente para não vazar em produção
 if (process.env.VITEST) {
     const grupo = globalThis;
-    const prev = grupo.__SUKUNA_TESTS__ ?? {};
-    grupo.__SUKUNA_TESTS__ = {
+    const prev = grupo.__MAHORAGA_TESTS__ ?? {};
+    grupo.__MAHORAGA_TESTS__ = {
         ...prev,
         scoreArquetipo
     };
@@ -75,54 +68,42 @@ export async function detectarArquetipos(contexto, baseDir, options) {
         console.log(DetectorArquetiposExtraMensagens.debugChamado, contexto.arquivos.length, 'arquivos');
     }
     const arquivos = contexto.arquivos.map(arquivo => arquivo.relPath);
-    // Carregar arquétipo personalizado se existir
     const arquetipoPersonalizado = await carregarArquetipoPersonalizado(baseDir);
     let arquetiposParaAvaliar = ARQUETIPOS;
-    // Se há arquétipo personalizado, integrá-lo com o oficial
     if (arquetipoPersonalizado) {
         const arquetipoOficial = obterArquetipoOficial(arquetipoPersonalizado);
         if (arquetipoOficial) {
             const arquetipoIntegrado = integrarArquetipos(arquetipoPersonalizado, arquetipoOficial);
-            // Substituir o oficial pelo personalizado na lista de avaliação
             arquetiposParaAvaliar = ARQUETIPOS.map((arq) => arq.nome === arquetipoPersonalizado.arquetipoOficial ? arquetipoIntegrado : arq);
         }
     }
-    // Extrai sinais avançados do projeto
     let packageJsonParaSinais = {};
     try {
         packageJsonParaSinais = (await lerEstado(path.join(baseDir, 'package.json')));
     }
     catch {
-        // Package.json não encontrado - usar objeto vazio
         packageJsonParaSinais = {};
     }
     const sinaisAvancados = extrairSinaisAvancados(contexto.arquivos, packageJsonParaSinais, undefined, baseDir, arquivos);
-    // Pontua todos os arquétipos disponíveis usando sinais avançados
     let candidatos = arquetiposParaAvaliar.map((def) => scoreArquetipoAvancado(def, arquivos, sinaisAvancados));
-    // [LANCAMENTO] INTEGRAÇÃO SISTEMA INTELIGENTE: Aplicar boost contextual
     if (!options?.quiet && config.VERBOSE) {
         console.log(DetectorArquetiposExtraMensagens.debugContextual);
     }
     try {
         const { detectarContextoInteligente } = await import('../js-ts/detectors/index.js');
-        const estruturaDetectada = arquivos; // Lista de caminhos
-        // Carregar package.json com tratamento de erro adequado
+        const estruturaDetectada = arquivos;
         let packageJsonContent = {};
         try {
             packageJsonContent = (await lerEstado(path.join(baseDir, 'package.json')));
         }
         catch {
-            // Package.json não encontrado ou inválido - usar objeto vazio
             packageJsonContent = {};
         }
         const resultadosContextuais = detectarContextoInteligente(estruturaDetectada, contexto.arquivos, packageJsonContent, options);
-        // Pegar o resultado com maior confiança
         const melhorDeteccao = resultadosContextuais.reduce((melhor, atual) => atual.confiancaTotal > melhor.confiancaTotal ? atual : melhor, {
             confiancaTotal: 0
         });
         if (melhorDeteccao.confiancaTotal > 0.6) {
-            // Escala 0-1, não 0-100
-            // Mapear tecnologias detectadas para arquétipos conhecidos
             const mapeamentoTecnologia = {
                 'discord-bot': ['bot-discord', 'bot', 'discord-bot'],
                 'telegram-bot': ['bot-telegram', 'bot', 'telegram-bot'],
@@ -142,7 +123,6 @@ export async function detectarArquetipos(contexto, baseDir, options) {
                 }
             }
             else {
-                // Aplicar boost de confiança para arquétipos relacionados
                 const boostAplicado = candidatos.some((candidato) => arquetiposCandidatos.some((arq) => candidato.nome.includes(arq) || arq.includes(candidato.nome)));
                 candidatos = candidatos.map((candidato) => aplicarBoostConfianca(candidato, arquetiposCandidatos, melhorDeteccao));
                 if (!boostAplicado) {
@@ -152,24 +132,18 @@ export async function detectarArquetipos(contexto, baseDir, options) {
         }
     }
     catch (error) {
-        // Falha silenciosa - sistema inteligente é opcional
         if (process.env.NODE_ENV !== 'production') {
             console.debug('Sistema inteligente não disponível:', error);
         }
     }
-    // Ordena por confiança/score decrescente
     candidatos.sort((arquivo, base) => base.confidence - arquivo.confidence || base.score - arquivo.score);
-    // Decisão final: dominante, misto ou desconhecido
-    // Agora considera fatores contextuais e thresholds adaptativos
     const scoresValidos = candidatos.filter(elem => elem.confidence >= 30);
     if (!scoresValidos.length) {
-        // Nenhum padrão relevante - verificar se é um projeto muito pequeno ou não estruturado
         const temAlgumaEstrutura = arquivos.some(arquivo => arquivo.includes('src/') || arquivo.includes('lib/') || arquivo.includes('app/') || arquivo.includes('packages/'));
         candidatos = [{
                 nome: 'desconhecido',
                 score: 0,
                 confidence: temAlgumaEstrutura ? 10 : 0,
-                // pequena confiança se há alguma estrutura
                 matchedRequired: [],
                 missingRequired: [],
                 matchedOptional: [],
@@ -183,18 +157,12 @@ export async function detectarArquetipos(contexto, baseDir, options) {
             }];
     }
     else {
-        // Análise mais sofisticada para decidir entre dominante e misto
         const top = scoresValidos[0];
-        const proximos = scoresValidos.filter(elem => elem !== top && Math.abs(elem.confidence - top.confidence) <= 15 // threshold aumentado
-        );
-        // Verificar se é realmente um caso híbrido ou apenas competição próxima
-        const ehHibridoReal = proximos.some(elem => 
-        // Verificar se há sobreposição significativa de características
-        elem.matchedRequired.some(req => top.matchedRequired.includes(req)) || elem.dependencyMatches.some(dep => top.dependencyMatches.includes(dep)));
+        const proximos = scoresValidos.filter(elem => elem !== top && Math.abs(elem.confidence - top.confidence) <= 15);
+        const ehHibridoReal = proximos.some(elem => elem.matchedRequired.some(req => top.matchedRequired.includes(req)) || elem.dependencyMatches.some(dep => top.dependencyMatches.includes(dep)));
         if (proximos.length > 0 && ehHibridoReal) {
-            // Sistema de pontuação para casos híbridos
             const scoreHibrido = top.score * 0.7 + proximos.reduce((acc, elem) => acc + elem.score * 0.3 / proximos.length, 0);
-            const confidenceHibrido = Math.max(top.confidence - 10, 40); // reduzir confiança mas manter mínimo
+            const confidenceHibrido = Math.max(top.confidence - 10, 40);
             candidatos = [{
                     nome: 'misto',
                     score: Math.round(scoreHibrido),
@@ -212,7 +180,6 @@ export async function detectarArquetipos(contexto, baseDir, options) {
                 }];
         }
         else {
-            // Dominante claro
             candidatos = [top];
         }
     }
@@ -232,7 +199,6 @@ export async function detectarArquetipos(contexto, baseDir, options) {
         };
         await salvarEstado(baselineCaminho, baseline);
     }
-    // Prioriza baseline apenas se o candidato principal for 'desconhecido' ou confiança baixa
     if (baseline && baseline.arquetipo !== 'desconhecido') {
         const arquivosRaizAtuais = arquivos.filter(caminho => !caminho.includes('/'));
         const setBase = new Set(baseline.arquivosRaiz);
@@ -242,7 +208,6 @@ export async function detectarArquetipos(contexto, baseDir, options) {
             const melhorLinhaBase = {
                 nome: baseline.arquetipo,
                 score: 999,
-                // força topo da lista
                 confidence: baseline.confidence,
                 matchedRequired: [],
                 missingRequired: [],
@@ -285,10 +250,8 @@ export async function detectarArquetipos(contexto, baseDir, options) {
             arquivosRaizRemovidos: removidos
         };
     }
-    // Sugestão de plano para o candidato top
     if (candidatos[0]) {
         try {
-            // Usa plano de arquétipos se preset for diferente de 'mahoraga' ou em ambiente de teste
             const preset = contexto.preset ?? 'mahoraga';
             const emTeste = !!process.env.VITEST;
             const preferEstrategista = preset === 'mahoraga' && !emTeste;
@@ -301,7 +264,6 @@ export async function detectarArquetipos(contexto, baseDir, options) {
             }
         }
         catch {
-            // mantém default vazio se falhar
         }
     }
     return {

package/dist/analysts/architects/diagnostic-project.js

@@ -1,4 +1,3 @@
-// Níveis de confiança para detecção de tipos de projeto
 const CONFIANCA = {
     PADRAO: 0.3,
     FULLSTACK: 0.95,
@@ -36,7 +35,6 @@ export function diagnosticarProjeto(sinais) {
         tipo = 'lib';
         confianca = CONFIANCA.LIB;
     }
-    // Mantém valor de confiança original (0..1) sem arredondar para evitar perda de precisão
     return {
         tipo,
         sinais: positivos,
@@ -44,7 +42,6 @@ export function diagnosticarProjeto(sinais) {
     };
 }
 function ehLanding(string) {
-    // Considera landing se temPages for true, mesmo sem components/controllers
     return (string.temPages === true);
 }
 function ehApi(string) {

package/dist/analysts/architects/index.js

@@ -1,7 +1,3 @@
-// SPDX-License-Identifier: MIT
-/**
- * @fileoverview Arquitetos e orquestração de projeto
- */
 export * from './analyst-structure.js';
 export * from './archetypes-custom.js';
 export * from './detector-archetypes.js';

package/dist/analysts/architects/orchestrator-archetypes.js

@@ -1,14 +1,9 @@
-// SPDX-License-Identifier: MIT
 import { detectarContextoProjeto } from '../../shared/index.js';
 import { detectarArquetipoNode } from '../plugins/index.js';
 import { pontuarTodos } from '../scorers/index.js';
 import { ARQUETIPOS } from '../strategists/index.js';
 import { detectarArquetipoXML } from '../xml/detectors/index.js';
-// Evita warning de unused import - função usada em runtime
 void detectarContextoProjeto;
-/**
- * Cria um resultado padrão para arquétipo desconhecido
- */
 function criarResultadoDesconhecido(motivo) {
     const anomalias = motivo ? [{
             path: 'projeto',
@@ -31,37 +26,24 @@ function criarResultadoDesconhecido(motivo) {
         descricao: 'Arquétipo não identificado'
     };
 }
-/**
- * Orquestrador central de detecção de arquétipos
- * Agrega votos dos detectores especializados e decide o arquétipo final
- *
- * @param arquivos Lista de arquivos do projeto para análise
- * @returns Melhor arquétipo detectado ou 'desconhecido' se não identificado
- */
 export function detectarArquetipo(arquivos) {
-    // Early return para projetos muito pequenos (< 5 arquivos)
     if (arquivos.length < 5) {
         return criarResultadoDesconhecido('Projeto muito pequeno para análise de arquétipo');
     }
-    // Performance: executar detectores de forma inteligente baseado nos tipos de arquivos
     const candidatos = [];
     const hasJS = arquivos.some(arquivo => arquivo.endsWith('.js') || arquivo.endsWith('.ts') || arquivo.endsWith('.jsx') || arquivo.endsWith('.tsx'));
     const hasXML = arquivos.some(arquivo => arquivo.endsWith('.xml'));
     const hasPackageJson = arquivos.some(arquivo => arquivo.endsWith('package.json'));
-    // Executar detectores baseado nos tipos de arquivos presentes (otimização de performance)
     if (hasJS || hasPackageJson) {
         candidatos.push(...detectarArquetipoNode(arquivos));
     }
-    // Futuro: adicionar detectores para outras linguagens // }
     if (hasXML) {
         candidatos.push(...detectarArquetipoXML(arquivos));
     }
     let lista = candidatos;
     if (!lista.length) {
-        // Fallback: usar o pontuador completo quando detectores especializados não retornarem candidatos
         lista = pontuarTodos(arquivos);
     }
-    // Se ainda vazio, é desconhecido
     if (!lista.length) {
         return {
             nome: 'desconhecido',
@@ -79,20 +61,13 @@ export function detectarArquetipo(arquivos) {
             descricao: 'Arquétipo não identificado'
         };
     }
-    // Regra especial (compatibilidade com testes de penalidades):
-    // Se existir candidato cujo único "sinal" são diretórios proibidos presentes
-    // (sem matches de required/optional/dependency/pattern), priorizamos aquele
-    // com maior quantidade de diretórios proibidos detectados.
     const apenasPenalidades = lista.filter(elem => {
         const pos = (elem.matchedRequired.length || 0) + (elem.matchedOptional.length || 0) + (elem.dependencyMatches.length || 0) + (elem.filePadraoMatches.length || 0);
         const forb = elem.forbiddenPresent.length || 0;
         return forb > 0 && pos === 0;
     });
     if (apenasPenalidades.length > 0) {
-        // Heurística de segurança: ignore o candidato 'monorepo-packages' quando o único forbidden presente for 'src'
-        // (cenário comum em projetos Node simples com pasta src/, que não devem ser classificados como monorepo).
         const filtrados = apenasPenalidades.filter(elem => {
-            // Regra específica: se o candidato for 'monorepo-packages' e o único forbidden detectado for 'src', descartamos
             if (elem.nome === 'monorepo-packages') {
                 const forb = elem.forbiddenPresent;
                 if (forb.length === 1 && forb[0] === 'src') {
@@ -102,14 +77,11 @@ export function detectarArquetipo(arquivos) {
             return true;
         });
         if (filtrados.length === 0) {
-            // caso todos tenham sido filtrados, prossegue com fluxo normal
         }
         else {
-            // desempate refinado: maior cobertura relativa de forbidden (detectados/definidos)
             filtrados.sort((arquivo, base) => {
                 const forbA = arquivo.forbiddenPresent.length || 0;
                 const forbB = base.forbiddenPresent.length || 0;
-                // Usa somente o total de diretórios proibidos definidos no alvo para o ratio
                 const defA = ARQUETIPOS?.find((diretorio) => diretorio.nome === arquivo.nome);
                 const defB = ARQUETIPOS?.find((diretorio) => diretorio.nome === base.nome);
                 const totA = defA?.forbiddenDirs?.length ?? 0;
@@ -122,7 +94,6 @@ export function detectarArquetipo(arquivos) {
                 if (forbB !== forbA) {
                     return forbB - forbA;
                 }
-                // depois, mais missingRequired primeiro (penalidade maior do alvo)
                 const miss = (base.missingRequired.length || 0) - (arquivo.missingRequired.length || 0);
                 if (miss !== 0) {
                     return miss;
@@ -132,7 +103,6 @@ export function detectarArquetipo(arquivos) {
             return filtrados[0];
         }
     }
-    // Ordenação: menor missingRequired, maior score, maior matchedRequired, maior confidence, nome asc
     lista.sort((arquivo, base) => {
         const mm = (arquivo.missingRequired.length || 0) - (base.missingRequired.length || 0);
         if (mm !== 0) {

package/dist/analysts/architects/signals-project-advanced.js

@@ -1,8 +1,4 @@
-export function scoreArquetipo(def, _arquivos, 
-// prefixo _ para ignorar warning de unused
-_sinaisAvancados // prefixo _ para ignorar warning de unused
-) {
-    // Implementação fictícia para evitar erro de compilação
+export function scoreArquetipo(def, _arquivos, _sinaisAvancados) {
     return {
         nome: def.nome,
         descricao: def.descricao,
@@ -40,7 +36,6 @@ function processarImportsFramework(imports, tecnologias, sinais) {
     }
 }
 export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir, _arquivos) {
-    // Auxiliar para checar se o nó possui id.name string
     const hasIdNome = (node) => {
         return typeof node === 'object' && node !== null && 'id' in node && typeof node.id?.name === 'string';
     };
@@ -56,13 +51,11 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
         pastasPadrao: [],
         arquivosPadrao: [],
         arquivosConfiguracao: [],
-        // Novos sinais inteligentes
         padroesArquiteturais: [],
         tecnologiasDominantes: [],
         complexidadeEstrutura: 'baixa',
         tipoDominante: 'desconhecido'
     };
-    // Análise de padrões arquiteturais baseada no código
     const padroesDetectados = new Set();
     const tecnologias = new Map();
     for (const fe of fileEntries) {
@@ -70,14 +63,11 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
         if (fe.ast && 'node' in fe.ast && Array.isArray(fe.ast.node.body)) {
             body = (fe.ast.node).body;
         }
-        // Análise inteligente de padrões
         const conteudo = fe.content ?? '';
         const relPath = fe.relPath.toLowerCase();
-        // Detectar padrões MVC
         if (relPath.includes('controller') || relPath.includes('model') || relPath.includes('view')) {
             padroesDetectados.add('mvc');
         }
-        // Detectar Clean Architecture patterns
         if (relPath.includes('/domain/') || relPath.includes('/entities/') || relPath.includes('value-object')) {
             padroesDetectados.add('clean-arch-domain');
         }
@@ -96,9 +86,7 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
         if (relPath.includes('entity') || relPath.includes('aggregate')) {
             padroesDetectados.add('domain-entity');
         }
-        // Detectar Distributed Architecture patterns
         if (relPath.includes('/services/') && !relPath.includes('/services/')) {
-            // múltiplos serviços
         }
         if (relPath.match(/services\/[^/]+\//)) {
             padroesDetectados.add('microservice-boundary');
@@ -124,40 +112,28 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
         if (relPath.includes('/monitoring') || relPath.includes('/health') || relPath.includes('/metrics')) {
             padroesDetectados.add('monitoring');
         }
-        // Detectar padrões Repository/Service
         if (relPath.includes('repository') || relPath.includes('service')) {
             padroesDetectados.add('repository-service');
         }
-        // Detectar hooks React
         if (conteudo.includes('useState') || conteudo.includes('useEffect')) {
             tecnologias.set('react-hooks', (tecnologias.get('react-hooks') ?? 0) + 1);
         }
-        // Detectar async/await patterns
         if (conteudo.includes('async') && conteudo.includes('await')) {
             padroesDetectados.add('async-await');
         }
-        // Detectar TypeScript advanced features
         if (conteudo.includes('interface') || conteudo.includes('type ')) {
             tecnologias.set('typescript-advanced', (tecnologias.get('typescript-advanced') ?? 0) + 1);
         }
-        // Detectar padrões de CLI
         if (conteudo.includes('commander') || conteudo.includes('yargs') || relPath.includes('bin/')) {
             padroesDetectados.add('cli-patterns');
         }
-        // Funções
         sinais.funcoes += body.filter((node) => node.type === 'FunctionDeclaration').length;
-        // Imports
         const imports = body.filter((node) => node.type === 'ImportDeclaration');
         sinais.imports.push(...imports.map(indice => indice.source.value));
-        // Variáveis
         sinais.variaveis += body.filter((node) => node.type === 'VariableDeclaration').length;
-        // Tipos (TypeScript)
         sinais.tipos.push(...body.filter((node) => ['TSTypeAliasDeclaration', 'TSInterfaceDeclaration', 'TSEnumDeclaration'].includes(node.type)).map(node => hasIdNome(node) ? node.id.name : undefined).filter((valor) => typeof valor === 'string'));
-        // Classes
         sinais.classes += body.filter((node) => node.type === 'ClassDeclaration').length;
-        // Frameworks por import (expandido)
         processarImportsFramework(imports, tecnologias, sinais);
-        // Padrões de pastas/arquivos (expandido)
         const rel = fe.relPath.replace(/\\/g, '/');
         if (/src\/controllers|pages|api|prisma|packages|apps|src\/routes|src\/services|src\/repositories/.test(rel)) {
             sinais.pastasPadrao.push(rel);
@@ -169,9 +145,7 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
             sinais.arquivosConfiguracao.push(rel);
         }
     }
-    // Processar sinais inteligentes
     sinais.padroesArquiteturais = Array.from(padroesDetectados);
-    // Detectar camadas da Clean Architecture
     const temDomain = padroesDetectados.has('clean-arch-domain') || padroesDetectados.has('domain-entity');
     const temApplication = padroesDetectados.has('clean-arch-application') || padroesDetectados.has('use-case');
     const temInfrastructure = padroesDetectados.has('clean-arch-infrastructure');
@@ -184,7 +158,6 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
     };
     sinais.padroesCleanArch = Array.from(padroesDetectados)
         .filter(p => p.startsWith('clean-arch') || p === 'use-case' || p === 'domain-entity');
-    // Detectar boundaries de serviço e padrões distribuídos
     const serviceBoundaries = new Set(fileEntries
         .map(fe => {
         const match = fe.relPath.match(/services\/([^/]+)/);
@@ -203,7 +176,6 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
             c.includes('eventemitter') || c.includes('pubsub');
     })
         .map(fe => fe.relPath);
-    // Determinar tecnologia dominante
     let maxContagem = 0;
     let dominante = 'desconhecido';
     for (const [tech, count] of tecnologias) {
@@ -214,7 +186,6 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
     }
     sinais.tecnologiasDominantes = Array.from(tecnologias.keys());
     sinais.tipoDominante = dominante;
-    // Determinar complexidade da estrutura
     const totalArquivos = fileEntries.length;
     const totalPastas = new Set(fileEntries.map(fe => fe.relPath.split('/').slice(0, -1).join('/'))).size;
     if (totalArquivos > 100 || totalPastas > 20) {
@@ -226,12 +197,10 @@ export function extrairSinaisAvancados(fileEntries, packageJson, _p0, _baseDir,
     else {
         sinais.complexidadeEstrutura = 'baixa';
     }
-    // Dependências e scripts do package.json
     if (packageJson) {
         sinais.dependencias.push(...Object.keys(packageJson.dependencies ?? {}));
         sinais.scripts.push(...Object.keys(packageJson.scripts ?? {}));
     }
-    // Normaliza arrays
     sinais.imports = Array.from(new Set(sinais.imports));
     sinais.frameworksDetectados = Array.from(new Set(sinais.frameworksDetectados));
     sinais.pastasPadrao = Array.from(new Set(sinais.pastasPadrao));