@mocoto/mahoraga 0.14.0 → 0.14.1

package/README.md

@@ -228,7 +228,7 @@ npx mahoraga --help
 ### Do Repositório
 
 ```bash
-git clone https://github.com/um-atoa/mahoraga.git
+git clone https://github.com/o-atoa/mahoraga.git
 cd mahoraga
 npm install
 npm run build
@@ -297,11 +297,11 @@ O Mahoraga lê um arquivo `mahoraga.config.json` na raiz do seu projeto. Se não
 
 | Variável | Descrição | Padrão |
 |----------|-----------|--------|
-| `MAHORAGA_API_PORT` | Porta da API | `3100` |
-| `MAHORAGA_API_CORS_ORIGINS` | Origens CORS | `localhost: 00` |
+| `SUKUNA_API_PORT` | Porta da API | `3100` |
+| `SUKUNA_API_CORS_ORIGINS` | Origens CORS | `localhost: 00` |
 | `LOG_LEVEL` | Nível de log | `info` |
 | `LOG_ESTRUTURADO` | Logs em JSON | `false` |
-| `MAHORAGA_DEBUG` | Modo debug | — |
+| `SUKUNA_DEBUG` | Modo debug | — |
 | `GITHUB_APP_ID` | ID do GitHub App | — |
 | `GITHUB_PRIVATE_KEY` | Chave RSA do GitHub App | — |
 | `GITHUB_WEBHOOK_SECRET` | Webhook secret | — |
@@ -647,7 +647,7 @@ mahoraga github-actions gate --threshold 80 --fail-on erro
 ### Setup
 
 ```bash
-git clone https://github.com/um-atoa/mahoraga.git
+git clone https://github.com/o-atoa/mahoraga.git
 cd mahoraga
 npm install
 npm run build
@@ -724,9 +724,9 @@ Dependências de terceiros listadas em [THIRD-PARTY-NOTICES.txt](./THIRD-PARTY-N
 <div align="center">
 
 [![npm](https://img.shields.io/badge/npm-mahoraga-CB3837)](https://www.npmjs.com/package/mahoraga)
-[![GitHub](https://img.shields.io/badge/github-blue--diaz/mahoraga-181717)](https://github.com/um-atoa/mahoraga)
-[![Issues](https://img.shields.io/badge/issues-report-FF4500)](https://github.com/um-atoa/mahoraga/issues)
-[![Releases](https://img.shields.io/badge/releases-latest-2ea44f)](https://github.com/um-atoa/mahoraga/releases)
+[![GitHub](https://img.shields.io/badge/github-blue--diaz/mahoraga-181717)](https://github.com/o-atoa/mahoraga)
+[![Issues](https://img.shields.io/badge/issues-report-FF4500)](https://github.com/o-atoa/mahoraga/issues)
+[![Releases](https://img.shields.io/badge/releases-latest-2ea44f)](https://github.com/o-atoa/mahoraga/releases)
 
 **Feito para os iniciantes** — [Voltar ao topo](#mahoraga)
 

package/dist/analysts/architects/analyst-structure.js

@@ -1,7 +1,9 @@
+// SPDX-License-Identifier: MIT
 import path from 'node:path';
-import { config } from '../../core/config/index.js';
 import pLimit from 'p-limit';
-export const CONCORRENCIA = Number(config.STRUCTURE_CONCURRENCY ?? 5);
+import { config } from '../../core/config/index.js';
+// Constantes para análise estrutural
+export const CONCORRENCIA = (config.STRUCTURE_CONCURRENCY ?? 5);
 export const CAMADAS = {
     ts: 'src',
     js: 'src',
@@ -13,11 +15,13 @@ export const CAMADAS = {
     md: 'docs',
     yml: 'config',
     yaml: 'config',
+    // Adicione mais mapeamentos conforme necessário
 };
 export async function analisarEstrutura(fileEntries, _baseDir = process.cwd()) {
     const limit = pLimit(CONCORRENCIA);
     const resultados = await Promise.all(fileEntries.map((entry) => limit(() => {
         const rel = entry.relPath;
+        // Normaliza para separador POSIX para evitar dependência de platform e necessidade de mock em testes
         const normalizado = rel.replace(/\\/g, '/');
         const atual = normalizado.split('/')[0] || '';
         let ideal = null;
@@ -37,4 +41,3 @@ export async function analisarEstrutura(fileEntries, _baseDir = process.cwd()) {
     return resultados;
 }
 export { analisarEstrutura as alinhamentoEstrutural };
-//# sourceMappingURL=analyst-structure.js.map

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

@@ -1,23 +1,46 @@
+// SPDX-License-Identifier: MIT
+// @mahoraga-disable tipo-literal-inline-complexo
+// 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';
-import { ARQUETIPOS } from '../strategists/index.js';
+// 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 { MAHORAGA_ARQUIVOS } from '../../core/registry/index.js';
+import { SUKUNA_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';
+/**
+ * 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()) {
-    const novoCaminho = MAHORAGA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
+    // Tentar novo caminho primeiro
+    const novoCaminho = SUKUNA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
     const caminhoLegado = path.join(baseDir, ARQUETIPO_PERSONALIZADO_FILENAME);
     try {
+        // Tenta novo caminho
         const arquetipo = await lerEstado(novoCaminho, null);
-        if (arquetipo && arquetipo.nome && arquetipo.arquetipoOficial) {
+        if (arquetipo?.nome && arquetipo.arquetipoOficial) {
             return arquetipo;
         }
+        // Se não encontrou no novo caminho, tenta o legado
         const arquetipoLegado = await lerEstado(caminhoLegado, null);
-        if (!arquetipoLegado || !arquetipoLegado.nome || !arquetipoLegado.arquetipoOficial) {
+        // Validação básica
+        if (!arquetipoLegado?.nome || !arquetipoLegado.arquetipoOficial) {
+            // Reduz ruído em testes e quando não estiver em modo verbose
             const isTest = (process.env.VITEST ?? '') !== '';
-            const isVerbose = log.verbose || false;
+            const isVerbose = log.verbose ?? false;
             if (!isTest && isVerbose) {
                 log.aviso(ArquetiposExtraMensagens.naoEncontrado.replace('{novo}', novoCaminho).replace('{legado}', caminhoLegado));
             }
@@ -26,9 +49,14 @@ 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,
@@ -38,7 +66,9 @@ export async function salvarArquetipoPersonalizado(arquetipo, _baseDir = process
             notasUsuario: undefined
         }
     };
-    const novoCaminho = MAHORAGA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
+    // Usar novo caminho centralizado
+    const novoCaminho = SUKUNA_ARQUIVOS.ESTRUTURA_ARQUETIPO;
+    // Garantir que o diretório .mahoraga existe
     const mahoragaDir = path.dirname(novoCaminho);
     try {
         await fs.mkdir(mahoragaDir, {
@@ -46,13 +76,18 @@ 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(MAHORAGA_ARQUIVOS.ESTRUTURA_ARQUETIPO);
+        await fs.stat(SUKUNA_ARQUIVOS.ESTRUTURA_ARQUETIPO);
         return true;
     }
     catch {
@@ -66,11 +101,17 @@ 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);
+    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)}
@@ -91,29 +132,42 @@ ${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,
@@ -123,6 +177,7 @@ export function criarTemplateArquetipoPersonalizado(nomeProjeto, estruturaDetect
             diretorios: diretoriosPrincipais,
             arquivosChave,
             padroesNomenclatura: {
+                // Padrões comuns baseados na estrutura detectada
                 ...(estruturaDetectada.some(diretorio => diretorio.includes('components')) && {
                     components: '*-component.*'
                 }),
@@ -141,6 +196,9 @@ export function criarTemplateArquetipoPersonalizado(nomeProjeto, estruturaDetect
         }
     };
 }
+/**
+ * Valida um arquétipo personalizado
+ */
 export function validarArquetipoPersonalizado(arquetipo) {
     const erros = [];
     if (!arquetipo.nome || typeof arquetipo.nome !== 'string') {
@@ -150,9 +208,10 @@ export function validarArquetipoPersonalizado(arquetipo) {
         erros.push(ArquetiposExtraMensagens.validacao.arquetipoObrigatorio);
     }
     else {
-        const arquetipoOficial = ARQUETIPOS?.find((arq) => arq.nome === arquetipo.arquetipoOficial);
+        // 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(', ')));
+            erros.push(ArquetiposExtraMensagens.validacao.arquetipoNaoEncontrado.replace('{arquetipo}', arquetipo.arquetipoOficial).replace('{disponiveis}', (ARQUETIPOS ?? []).map(arquivo => (arquivo).nome).join(', ')));
         }
     }
     if (!arquetipo.estruturaPersonalizada) {
@@ -171,21 +230,27 @@ 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,
         nome: personalizado.nome,
-        descricao: personalizado.descricao || oficial.descricao,
+        descricao: personalizado.descricao ?? oficial.descricao,
         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,
         pesoBase: oficial.pesoBase
     };
 }
-//# sourceMappingURL=archetypes-custom.js.map

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

@@ -1,15 +1,19 @@
+// SPDX-License-Identifier: MIT
+// Nota: manter ARQUETIPOS importado visível como lembrete para integração futura
 import path from 'node:path';
-import { scoreArquetipoAvancado } from '../scorers/index.js';
-import { ARQUETIPOS, OperarioEstrutura } from '../strategists/index.js';
 import { config } from '../../core/config/index.js';
 import { getMessages } from '../../core/messages/index.js';
+import { scoreArquetipoAvancado } from '../scorers/index.js';
+import { ARQUETIPOS, OperarioEstrutura } from '../strategists/index.js';
 import { lerEstado, salvarEstado } from '../../shared/persistence/index.js';
 import { carregarArquetipoPersonalizado, integrarArquetipos, obterArquetipoOficial } from './archetypes-custom.js';
 import { extrairSinaisAvancados } from './signals-project-advanced.js';
 const { DetectorArquetiposExtraMensagens } = getMessages();
 function scoreArquetipo(def, arquivos, _sinaisAvancados) {
-    const matchedRequired = (def.requiredDirs || []).filter(diretorio => arquivos.some(arquivo => arquivo.startsWith(`${diretorio}/`) || arquivo === diretorio));
-    const missingRequired = (def.requiredDirs || []).filter(diretorio => !matchedRequired.includes(diretorio));
+    // 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 {
         nome: def.nome,
         score: def.pesoBase ? def.pesoBase * 10 : 10,
@@ -27,10 +31,12 @@ 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.__MAHORAGA_TESTS__ ?? {};
-    grupo.__MAHORAGA_TESTS__ = {
+    const prev = grupo.__SUKUNA_TESTS__ ?? {};
+    grupo.__SUKUNA_TESTS__ = {
         ...prev,
         scoreArquetipo
     };
@@ -40,42 +46,54 @@ 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;
+        const estruturaDetectada = arquivos; // Lista de caminhos
+        // Carregar package.json com tratamento de erro adequado
         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 && 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'],
@@ -89,19 +107,22 @@ export async function detectarArquetipos(contexto, baseDir, options) {
             };
             const tecnologiaDetectada = melhorDeteccao.tecnologia ?? 'desconhecido';
             const arquetiposCandidatos = mapeamentoTecnologia[tecnologiaDetectada] || [];
+            // Aplicar boost de confiança para arquétipos relacionados
             let boostAplicado = false;
             candidatos = candidatos.map((candidato) => {
                 if (arquetiposCandidatos.some((arq) => candidato.nome.includes(arq) || arq.includes(candidato.nome))) {
-                    const boostConfianca = Math.min(melhorDeteccao.confiancaTotal * 100 * 0.8, 60);
+                    const boostConfianca = Math.min(melhorDeteccao.confiancaTotal * 100 * 0.8, 60); // Boost agressivo até 60%
                     boostAplicado = true;
                     return {
                         ...candidato,
                         confidence: Math.max(candidato.confidence + boostConfianca, 70),
-                        explicacaoSimilaridade: `[Boost contextual: ${melhorDeteccao.tecnologia} detectado com ${(melhorDeteccao.confiancaTotal * 100).toFixed(0)}% confiança] ${candidato.explicacaoSimilaridade || ''}`
+                        // Mínimo 70% se detectado
+                        explicacaoSimilaridade: `[Boost contextual: ${melhorDeteccao.tecnologia} detectado com ${(melhorDeteccao.confiancaTotal * 100).toFixed(0)}% confiança] ${candidato.explicacaoSimilaridade ?? ''}`
                     };
                 }
                 return candidato;
             });
+            // Se não encontrou arquétipo compatível, criar um virtual baseado na detecção
             if (!boostAplicado) {
                 const arquetipoVirtual = {
                     nome: tecnologiaDetectada,
@@ -110,31 +131,37 @@ export async function detectarArquetipos(contexto, baseDir, options) {
                     matchedRequired: [],
                     missingRequired: [],
                     matchedOptional: [],
-                    dependencyMatches: (melhorDeteccao.evidencias || []).filter(erro => erro.tipo === 'dependencia').map(erro => erro.valor),
-                    filePadraoMatches: (melhorDeteccao.evidencias || []).filter(erro => erro.tipo === 'estrutura').map(erro => erro.valor),
+                    dependencyMatches: (melhorDeteccao.evidencias ?? []).filter(erro => erro.tipo === 'dependencia').map(erro => erro.valor),
+                    filePadraoMatches: (melhorDeteccao.evidencias ?? []).filter(erro => erro.tipo === 'estrutura').map(erro => erro.valor),
                     forbiddenPresent: [],
                     anomalias: [],
-                    sugestaoPadronizacao: (melhorDeteccao.sugestoesMelhoria || []).join('; '),
+                    sugestaoPadronizacao: (melhorDeteccao.sugestoesMelhoria ?? []).join('; '),
                     explicacaoSimilaridade: `Detectado via sistema inteligente contextual com ${(melhorDeteccao.confiancaTotal * 100).toFixed(0)}% confiança`,
                     descricao: `Projeto ${melhorDeteccao.tecnologia} identificado por análise contextual`
                 };
-                candidatos.unshift(arquetipoVirtual);
+                candidatos.unshift(arquetipoVirtual); // Adiciona no início
             }
         }
     }
     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: [],
@@ -148,12 +175,18 @@ 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);
-        const ehHibridoReal = proximos.some(elem => 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 // 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)));
         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);
+            const confidenceHibrido = Math.max(top.confidence - 10, 40); // reduzir confiança mas manter mínimo
             candidatos = [{
                     nome: 'misto',
                     score: Math.round(scoreHibrido),
@@ -171,6 +204,7 @@ export async function detectarArquetipos(contexto, baseDir, options) {
                 }];
         }
         else {
+            // Dominante claro
             candidatos = [top];
         }
     }
@@ -190,6 +224,7 @@ 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 || []);
@@ -199,6 +234,7 @@ export async function detectarArquetipos(contexto, baseDir, options) {
             const melhorLinhaBase = {
                 nome: baseline.arquetipo,
                 score: 999,
+                // força topo da lista
                 confidence: baseline.confidence,
                 matchedRequired: [],
                 missingRequired: [],
@@ -222,12 +258,16 @@ export async function detectarArquetipos(contexto, baseDir, options) {
         const setAtual = new Set(arquivosRaizAtuais);
         const novos = [];
         const removidos = [];
-        for (const arquivo of setAtual)
-            if (!setBase.has(arquivo))
+        for (const arquivo of setAtual) {
+            if (!setBase.has(arquivo)) {
                 novos.push(arquivo);
-        for (const arquivo of setBase)
-            if (!setAtual.has(arquivo))
+            }
+        }
+        for (const arquivo of setBase) {
+            if (!setAtual.has(arquivo)) {
                 removidos.push(arquivo);
+            }
+        }
         drift = {
             alterouArquetipo: baseline.arquetipo !== atual.nome,
             anterior: baseline.arquetipo,
@@ -237,8 +277,10 @@ 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;
@@ -246,10 +288,12 @@ export async function detectarArquetipos(contexto, baseDir, options) {
                 preferEstrategista,
                 preset
             });
-            if (plano)
+            if (plano) {
                 candidatos[0].planoSugestao = plano;
+            }
         }
         catch {
+            // mantém default vazio se falhar
         }
     }
     return {
@@ -259,4 +303,3 @@ export async function detectarArquetipos(contexto, baseDir, options) {
         arquetipoPersonalizado
     };
 }
-//# sourceMappingURL=detector-archetypes.js.map

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

@@ -1,3 +1,4 @@
+// Níveis de confiança para detecção de tipos de projeto
 const CONFIANCA = {
     PADRAO: 0.3,
     FULLSTACK: 0.95,
@@ -35,6 +36,7 @@ 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,
@@ -42,7 +44,8 @@ export function diagnosticarProjeto(sinais) {
     };
 }
 function ehLanding(string) {
-    return !!(string.temPages === true);
+    // Considera landing se temPages for true, mesmo sem components/controllers
+    return (string.temPages === true);
 }
 function ehApi(string) {
     return !!(string.temApi ?? string.temControllers ?? string.temExpress);
@@ -53,4 +56,3 @@ function ehLib(string) {
 function ehCli(string) {
     return !!string.temCli;
 }
-//# sourceMappingURL=diagnostic-project.js.map

package/dist/analysts/architects/index.js

@@ -1,3 +1,7 @@
+// 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';
@@ -6,4 +10,3 @@ export * from './orchestrator-archetypes.js';
 export * from './signals-project.js';
 export * from './signals-project-advanced.js';
 export * from './strategist-structure.js';
-//# sourceMappingURL=index.js.map