@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/cli/diagnostic/exporters/svg-optimization-exporter.js

@@ -1,34 +1,46 @@
+// SPDX-License-Identifier: MIT
 import path from 'node:path';
 import { otimizarSvgLikeSvgo, shouldSugerirOtimizacaoSvg } from '../../../shared/formatters/index.js';
 function formatBytes(bytes) {
-    if (!Number.isFinite(bytes) || bytes < 0)
+    if (!Number.isFinite(bytes) || bytes < 0) {
         return String(bytes);
-    if (bytes < 1024)
+    }
+    if (bytes < 1024) {
         return `${bytes}B`;
+    }
     const kb = bytes / 1024;
-    if (kb < 1024)
+    if (kb < 1024) {
         return `${kb.toFixed(1)}KB`;
+    }
     const mb = kb / 1024;
     return `${mb.toFixed(1)}MB`;
 }
+/**
+* Gera e escreve o relatório de otimização de SVG no diretório de relatórios
+*/
 export async function exportarRelatorioSvgOtimizacao(params) {
     const { entries, relatoriosDir, ts } = params;
     const candidatos = [];
     for (const erro of entries) {
-        if (!erro || typeof erro.relPath !== 'string')
+        if (typeof erro.relPath !== 'string') {
             continue;
-        if (!/\.svg$/i.test(erro.relPath))
+        }
+        if (!/\.svg$/i.test(erro.relPath)) {
             continue;
-        if (typeof erro.content !== 'string')
+        }
+        if (typeof erro.content !== 'string') {
             continue;
-        if (!/<svg\b/i.test(erro.content))
+        }
+        if (!/<svg\b/i.test(erro.content)) {
             continue;
+        }
         const opt = otimizarSvgLikeSvgo({
             svg: erro.content
         });
         const shouldSuggest = opt.changed && opt.originalBytes > opt.optimizedBytes && shouldSugerirOtimizacaoSvg(opt.originalBytes, opt.optimizedBytes);
-        if (!shouldSuggest)
+        if (!shouldSuggest) {
             continue;
+        }
         const savedBytes = opt.originalBytes - opt.optimizedBytes;
         candidatos.push({
             relPath: erro.relPath,
@@ -55,8 +67,9 @@ export async function exportarRelatorioSvgOtimizacao(params) {
         else {
             existing.count += 1;
             existing.totalSaved += elem.savedBytes;
-            if (existing.exemplos.length < 10)
+            if (existing.exemplos.length < 10) {
                 existing.exemplos.push(elem);
+            }
         }
     }
     const outputCaminho = path.join(relatoriosDir, `mahoraga-svg-otimizacao-${ts}.md`);
@@ -92,4 +105,3 @@ export async function exportarRelatorioSvgOtimizacao(params) {
         totalEconomiaBytes
     };
 }
-//# sourceMappingURL=svg-optimization-exporter.js.map

package/dist/cli/diagnostic/filters.js

@@ -1,23 +1,65 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [ALVO] Sistema de Filtros para Diagnóstico
+ *
+ * Gerencia inclusão/exclusão de arquivos para análise
+ * - Processa padrões glob
+ * - Expande diretórios automaticamente
+ * - Gerencia node_modules e outros padrões especiais
+ * - Aplica precedência correta (CLI > config > defaults)
+ */
 import fs from 'node:fs';
 import { config, mesclarConfigExcludes } from '../../core/config/index.js';
+// ─── PROCESSAMENTO DE PADRÕES ─────────────────────────────────
+/**
+ * Processa lista de padrões achatada (vírgulas, espaços)
+ *
+ * @example
+ * processPatternListAchatado(['src/**', 'tests, lib'])
+ * // => ['src/**', 'tests', 'lib']
+ */
 export function processPatternListAchatado(raw) {
-    if (!raw || raw.length === 0)
+    if (!raw || raw.length === 0) {
         return [];
+    }
     return Array.from(new Set(raw.flatMap(raiz => raiz.split(/[\s,]+/)).map(string => string.trim()).filter(Boolean)));
 }
+/**
+ * Processa padrões em grupos (cada elemento da lista é um grupo)
+ *
+ * @example
+ * processPatternGroups(['src/** tests/**', 'lib/**'])
+ * // => [['src/**', 'tests/**'], ['lib/**']]
+ */
 export function processPatternGroups(raw) {
-    if (!raw || raw.length === 0)
+    if (!raw || raw.length === 0) {
         return [];
+    }
     return raw.map(grupo => grupo.split(/[\s,]+/).map(string => string.trim()).filter(Boolean)).filter(grupo => grupo.length > 0);
 }
+/**
+ * Expande padrões de inclusão (adiciona variantes recursivas)
+ *
+ * Para padrões sem metacaracteres glob, adiciona:
+ * - `pattern/**` (recursivo)
+ * - `** /pattern/**` (se não tiver barra)
+ *
+ * @example
+ * expandIncludes(['src', 'lib/*.ts'])
+ * // => ['src', 'src/**', '** /src/**', 'lib/*.ts']
+ */
 export function expandIncludes(list) {
-    const META = /[\\*\?\{\}\[\]]/;
+    const META = /[\\*\?\{\}\[\]]/; // metacaracteres glob
     const out = new Set();
     for (const caminho of list) {
         out.add(caminho);
+        // Se não tem metacaracteres, é um diretório literal
         if (!META.test(caminho)) {
+            // Remove barras terminais
             const normalized = caminho.replace(/[\\\/]+$/, '');
+            // Adiciona variante recursiva
             out.add(`${normalized}/**`);
+            // Se é nome simples (sem barra), adiciona busca em qualquer nível
             if (!caminho.includes('/') && !caminho.includes('\\')) {
                 out.add(`**/${normalized}/**`);
             }
@@ -25,6 +67,10 @@ export function expandIncludes(list) {
     }
     return Array.from(out);
 }
+// ─── DETECÇÃO DE TIPO DE PROJETO ──────────────────────────────
+/**
+ * Detecta tipo de projeto baseado em arquivos presentes
+ */
 export function detectarTipoProjeto(baseDir = process.cwd()) {
     try {
         const files = fs.readdirSync(baseDir);
@@ -47,36 +93,59 @@ export function detectarTipoProjeto(baseDir = process.cwd()) {
         return 'generico';
     }
 }
+// ─── PADRÕES DE EXCLUSÃO ──────────────────────────────────────
+/**
+ * Obtém padrões de exclusão padrão baseados em configuração e tipo de projeto
+ */
 export function getDefaultExcludes(tipoProjeto) {
+    // Tenta obter do mahoraga.config.json
     const configIncluirExcluir = config.INCLUDE_EXCLUDE_RULES;
-    if (configIncluirExcluir?.globalExcludeGlob) {
+    if (configIncluirExcluir.globalExcludeGlob) {
         if (Array.isArray(configIncluirExcluir.globalExcludeGlob) && configIncluirExcluir.globalExcludeGlob.length > 0) {
             return Array.from(new Set(configIncluirExcluir.globalExcludeGlob));
         }
     }
-    const tipo = tipoProjeto || detectarTipoProjeto();
+    // Fallback: usa padrões do sistema baseado no tipo de projeto
+    const tipo = tipoProjeto ?? detectarTipoProjeto();
     return mesclarConfigExcludes(null, tipo);
 }
+// ─── CONFIGURAÇÃO DE FILTROS ──────────────────────────────────
+/**
+ * Processa e aplica filtros CLI
+ *
+ * Precedência:
+ * 1. CLI --exclude (máxima)
+ * 2. mahoraga.config.json
+ * 3. Padrões do sistema (fallback)
+ */
 export function processarFiltros(opcoes) {
     const tipoProjeto = detectarTipoProjeto();
+    // Processar includes
     const includeGroups = processPatternGroups(opcoes.include);
     const includeFlat = includeGroups.flat();
     const includeExpanded = expandIncludes(includeFlat);
+    // Processar excludes
     const excludeFlat = processPatternListAchatado(opcoes.exclude);
+    // Determinar padrões de exclusão finais
     let excludePadroes;
     if (excludeFlat.length > 0) {
+        // CLI tem precedência
         excludePadroes = excludeFlat;
     }
     else {
+        // Usar defaults do config ou sistema
         excludePadroes = getDefaultExcludes(tipoProjeto);
     }
-    let incluiNodeModules = opcoes.forceIncludeNodeModules || false;
+    // Verificar se node_modules deve ser incluído
+    let incluiNodeModules = opcoes.forceIncludeNodeModules ?? false;
     if (includeFlat.some(caminho => /node_modules/.test(caminho))) {
         incluiNodeModules = true;
     }
+    // Remover node_modules dos excludes se explicitamente incluído
     if (incluiNodeModules) {
         excludePadroes = excludePadroes.filter(caminho => !/node_modules/.test(caminho));
     }
+    // Processar flag de testes
     if (opcoes.forceIncludeTests && !includeFlat.some(caminho => /tests?/.test(caminho))) {
         includeExpanded.push('tests/**', 'test/**', '**/*.test.*', '**/*.spec.*');
     }
@@ -88,7 +157,11 @@ export function processarFiltros(opcoes) {
         tipoProjeto
     };
 }
+/**
+ * Aplica filtros processados ao config global
+ */
 export function aplicarFiltrosAoConfig(filtros) {
+    // Configurar includes
     if (filtros.includeFlat.length > 0) {
         config.CLI_INCLUDE_GROUPS = filtros.includeGroups;
         config.CLI_INCLUDE_PATTERNS = filtros.includeFlat;
@@ -97,11 +170,14 @@ export function aplicarFiltrosAoConfig(filtros) {
         config.CLI_INCLUDE_GROUPS = [];
         config.CLI_INCLUDE_PATTERNS = [];
     }
+    // Configurar excludes
     config.CLI_EXCLUDE_PATTERNS = filtros.excludePadroes;
 }
+/**
+ * API simplificada: processa e aplica filtros em uma única chamada
+ */
 export function configurarFiltros(opcoes) {
     const filtros = processarFiltros(opcoes);
     aplicarFiltrosAoConfig(filtros);
     return filtros;
 }
-//# sourceMappingURL=filters.js.map

package/dist/cli/diagnostic/handlers/archetype-handler.js

@@ -1,24 +1,45 @@
-import { detectarArquetipos } from '../../../analysts/architects/index.js';
+// SPDX-License-Identifier: MIT
+/**
+ * [BUILD] Arquetipo Handler
+ *
+ * Gerencia detecção e análise de estrutura do projeto
+ * - Detecta arquetipos com timeout
+ * - Identifica padrões de projeto
+ * - Salva arquetipos personalizados
+ * - Formata resultados
+ */
 import { config } from '../../../core/config/index.js';
 import { messages } from '../../../core/messages/index.js';
+import { detectarArquetipos } from '../../../analysts/architects/index.js';
 const log = messages.log;
+/**
+ * Timeout padrão para detecção (em ms)
+ */
 const PADRAO_TEMPO_LIMITE_MS = process.env.VITEST ? 1000 : 30000;
+/**
+ * Executa detecção de arquetipos com timeout
+ */
 export async function executarDeteccaoArquetipos(entries, baseDir, options) {
+    // Se desabilitado, retorna resultado vazio
     if (!options.enabled) {
         return {
             executado: false
         };
     }
     try {
+        // Log de início (se não silencioso)
         if (!options.silent) {
             log.info(messages.MENSAGENS_ARQUETIPOS.detectando);
         }
+        // Preparar contexto
         const ctx = {
             arquivos: entries,
             baseDir
         };
-        const timeoutMs = options.timeout || PADRAO_TEMPO_LIMITE_MS;
+        // Executar detecção com timeout
+        const timeoutMs = options.timeout ?? PADRAO_TEMPO_LIMITE_MS;
         const resultado = await executarComTimeout(detectarArquetipos(ctx, baseDir), timeoutMs);
+        // Se timeout ou erro, retorna resultado parcial
         if (!resultado) {
             if (!options.silent) {
                 log.aviso(messages.CliArquetipoHandlerMensagens.timeoutDeteccao);
@@ -28,24 +49,23 @@ export async function executarDeteccaoArquetipos(entries, baseDir, options) {
                 erro: 'timeout'
             };
         }
-        const arquetipos = resultado.candidatos || [];
-        const principal = arquetipos.length > 0 ? arquetipos[0] : undefined;
+        // Processar resultado
+        const arquetipos = resultado.candidatos;
+        const principal = arquetipos.length > 0 ? arquetipos[0] : undefined; // Log de resultado (se não silencioso)
         if (!options.silent && principal) {
             log.info(messages.MENSAGENS_ARQUETIPOS.identificado(principal.nome, principal.confidence));
             if (arquetipos.length > 1) {
                 log.info(messages.MENSAGENS_ARQUETIPOS.multiplos(arquetipos.length));
             }
         }
-        let salvo = false;
-        if (options.salvar && resultado) {
-            salvo = await salvarArquetipo(resultado, baseDir, options.silent);
-        }
+        // Salvar se solicitado
+        const salvo = await salvarArquetipo(resultado, baseDir, options.silent);
         return {
             executado: true,
             arquetipos: arquetipos.map(arquivo => ({
                 tipo: arquivo.nome,
                 confianca: arquivo.confidence,
-                caracteristicas: arquivo.matchedRequired || []
+                caracteristicas: arquivo.matchedRequired
             })),
             principal: principal ? {
                 tipo: principal.nome,
@@ -59,6 +79,7 @@ export async function executarDeteccaoArquetipos(entries, baseDir, options) {
         if (!options.silent) {
             log.aviso(messages.CliArquetipoHandlerMensagens.erroDeteccao(mensagem));
         }
+        // Em DEV_MODE, log mais detalhado
         if (config.DEV_MODE) {
             console.error(messages.CliArquetipoHandlerMensagens.devErroPrefixo, erro);
         }
@@ -68,22 +89,30 @@ export async function executarDeteccaoArquetipos(entries, baseDir, options) {
         };
     }
 }
+/**
+ * Executa função com timeout
+ */
 async function executarComTimeout(promise, timeoutMs) {
     try {
-        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(undefined), timeoutMs));
+        const timeoutPromise = new Promise(resolve => setTimeout(() => { resolve(undefined); }, timeoutMs));
         return await Promise.race([promise, timeoutPromise]);
     }
     catch {
         return undefined;
     }
 }
+/**
+ * Salva arquetipo personalizado
+ */
 async function salvarArquetipo(resultado, baseDir, silent) {
     try {
         if (!silent) {
             log.info(messages.MENSAGENS_ARQUETIPOS.salvando);
         }
+        // Importação dinâmica para evitar dependências circulares
         const fs = await import('node:fs/promises');
         const path = await import('node:path');
+        // Preparar dados do arquetipo
         const arquetipo = {
             timestamp: new Date().toISOString(),
             projeto: path.basename(baseDir),
@@ -91,6 +120,7 @@ async function salvarArquetipo(resultado, baseDir, silent) {
             baseline: resultado.baseline,
             drift: resultado.drift
         };
+        // Salvar em arquivo
         const outputCaminho = path.join(baseDir, 'mahoraga.repo.arquetipo.json');
         await fs.writeFile(outputCaminho, JSON.stringify(arquetipo, null, 2), 'utf-8');
         if (!silent) {
@@ -106,6 +136,9 @@ async function salvarArquetipo(resultado, baseDir, silent) {
         return false;
     }
 }
+/**
+ * Formata resultado de arquetipos para JSON
+ */
 export function formatarArquetiposParaJson(result) {
     if (!result.executado) {
         return {
@@ -120,17 +153,21 @@ export function formatarArquetiposParaJson(result) {
     }
     return {
         executado: true,
-        arquetipos: result.arquetipos || [],
-        principal: result.principal || null,
-        salvo: result.salvo || false
+        arquetipos: result.arquetipos ?? [],
+        principal: result.principal ?? null,
+        salvo: result.salvo ?? false
     };
 }
+/**
+ * Gera sugestões baseadas no arquetipo detectado
+ */
 export function gerarSugestoesArquetipo(result) {
     const sugestoes = [];
     if (!result.executado || !result.principal) {
         return sugestoes;
     }
     const { tipo, confianca } = result.principal;
+    // Sugestões baseadas no tipo de projeto
     switch (tipo.toLowerCase()) {
         case 'monorepo':
             sugestoes.push('[IDEIA] Monorepo detectado: considere usar filtros por workspace');
@@ -156,10 +193,10 @@ export function gerarSugestoesArquetipo(result) {
             sugestoes.push('[IDEIA] Frontend detectado: priorize componentes e state management');
             break;
     }
+    // Sugestão baseada em confiança
     if (confianca < 70) {
         sugestoes.push('[AVISO]  Confiança baixa na detecção: estrutura pode ser híbrida');
         sugestoes.push('[IDEIA] Use --criar-arquetipo --salvar-arquetipo para personalizar');
     }
     return sugestoes;
 }
-//# sourceMappingURL=archetype-handler.js.map

package/dist/cli/diagnostic/handlers/auto-fix-handler.js

@@ -1,7 +1,23 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Mahoraga Contributors
+/**
+ * @module cli/diagnostico/handlers/auto-fix-handler
+ * @description Handler modular para execução de auto-fix com validação de options
+ * @see docs/REFACTOR-CLI-DIAGNOSTICAR.md - Sprint 2
+ */
 import { messages } from '../../../core/messages/index.js';
 const { log, MENSAGENS_AUTOFIX, CliAutoFixHandlerMensagens } = messages;
+// ─── Handler Principal ────────────────────────────────────────
+/**
+ * Executa o sistema de auto-fix com timeout e validação
+ *
+ * @param entries - Lista de arquivos para processar
+ * @param options - Opções de execução
+ * @returns Resultado da execução
+ */
 export async function executarAutoFix(entries, options) {
     try {
+        // Log de início (se não silencioso)
         if (!options.silent) {
             const modoLabel = {
                 conservative: CliAutoFixHandlerMensagens.modoConservador,
@@ -9,15 +25,17 @@ export async function executarAutoFix(entries, options) {
                 aggressive: CliAutoFixHandlerMensagens.modoAgressivo
             }[options.mode];
             if (options.dryRun) {
-                console.log(`${MENSAGENS_AUTOFIX.iniciando(modoLabel)}`);
+                console.log(MENSAGENS_AUTOFIX.iniciando(modoLabel));
                 console.log(MENSAGENS_AUTOFIX.dryRun);
             }
             else {
                 console.log(MENSAGENS_AUTOFIX.iniciando(modoLabel));
             }
         }
+        // Executar com timeout
         const timeout = options.timeout ?? (process.env.VITEST === 'true' ? 1000 : 60000);
         const resultado = await executarComTimeout(entries, options, timeout);
+        // Log de conclusão (se não silencioso)
         if (!options.silent) {
             const { correcoesAplicadas } = resultado.stats;
             if (options.dryRun && resultado.stats.correcoesSugeridas > 0) {
@@ -37,6 +55,7 @@ export async function executarAutoFix(entries, options) {
         if (!options.silent) {
             log.aviso(`${MENSAGENS_AUTOFIX.resultados.erroArquivo('', mensagem).split(':')[0]}: ${mensagem}`);
         }
+        // Retornar resultado vazio em caso de erro
         return {
             executado: false,
             mode: options.mode,
@@ -51,6 +70,9 @@ export async function executarAutoFix(entries, options) {
         };
     }
 }
+/**
+ * Executa auto-fix com proteção de timeout
+ */
 async function executarComTimeout(entries, options, timeoutMs) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -59,13 +81,18 @@ async function executarComTimeout(entries, options, timeoutMs) {
         executarAutoFixInterno(entries, options).then(resultado => {
             clearTimeout(timer);
             resolve(resultado);
-        }).catch(erro => {
+        }).catch((erro) => {
             clearTimeout(timer);
-            reject(erro);
+            reject(erro instanceof Error ? erro : new Error(String(erro)));
         });
     });
 }
-async function executarAutoFixInterno(entries, options) {
+/**
+ * Lógica interna de auto-fix
+ */
+function executarAutoFixInterno(entries, options) {
+    // NOTA: Integração real com sistema de auto-fix pendente de implementação
+    // Por enquanto, retornar resultado mock
     const stats = {
         arquivosAnalisados: entries.length,
         arquivosModificados: 0,
@@ -73,13 +100,17 @@ async function executarAutoFixInterno(entries, options) {
         correcoesSugeridas: 0,
         correcoesPuladas: 0
     };
-    return {
+    return Promise.resolve({
         executado: true,
         mode: options.mode,
         dryRun: options.dryRun,
         stats
-    };
+    });
 }
+// ─── Formatação para JSON ─────────────────────────────────────
+/**
+ * Formata resultado do auto-fix para saída JSON
+ */
 export function formatarAutoFixParaJson(resultado) {
     return {
         executado: resultado.executado,
@@ -94,6 +125,10 @@ export function formatarAutoFixParaJson(resultado) {
         })
     };
 }
+// ─── Helpers de Confiança ─────────────────────────────────────
+/**
+ * Calcula limiar de confiança baseado no modo
+ */
 export function calcularLimiarConfianca(mode) {
     const limiares = {
         conservative: 90,
@@ -102,22 +137,32 @@ export function calcularLimiarConfianca(mode) {
     };
     return limiares[mode];
 }
+/**
+ * Valida se uma correção deve ser aplicada
+ */
 export function deveAplicarCorrecao(confianca, limiar, mode) {
+    // Conservative: apenas alta confiança
     if (mode === 'conservative') {
         return confianca >= limiar;
     }
+    // Balanced: permite ajuste fino
     if (mode === 'balanced') {
         return confianca >= limiar * 0.9;
     }
+    // Aggressive: aceita confiança mais baixa
     return confianca >= limiar * 0.75;
 }
+// ─── Exit Code Helper ─────────────────────────────────────────
+/**
+ * Determina exit code baseado no resultado do auto-fix
+ */
 export function getExitCodeAutoFix(resultado) {
     if (!resultado.executado) {
-        return 1;
+        return 1; // Erro na execução
     }
     if (resultado.dryRun) {
-        return resultado.stats.correcoesSugeridas > 0 ? 0 : 0;
+        return resultado.stats.correcoesSugeridas > 0 ? 0 : 0; // Sempre 0 em dry-run
     }
+    // Sucesso se aplicou correções ou não havia correções
     return resultado.stats.correcoesAplicadas >= 0 ? 0 : 1;
 }
-//# sourceMappingURL=auto-fix-handler.js.map

package/dist/cli/diagnostic/handlers/guardian-handler.js

@@ -1,7 +1,21 @@
-import { messages } from '../../../core/messages/index.js';
+// SPDX-License-Identifier: MIT
+/**
+ * [SHIELD] Guardian Handler
+ *
+ * Gerencia verificação de integridade do Guardian
+ * - Executa scan de integridade
+ * - Gerencia baseline
+ * - Detecta drift
+ * - Formata resultados
+ */
 import { scanSystemIntegrity } from '../../../guardian/index.js';
+import { messages } from '../../../core/messages/index.js';
 import { IntegridadeStatus } from '../../../types/index.js';
+/**
+ * Executa verificação Guardian
+ */
 export async function executarGuardian(entries, options) {
+    // Se desabilitado, retorna resultado vazio
     if (!options.enabled) {
         return {
             executado: false,
@@ -9,6 +23,7 @@ export async function executarGuardian(entries, options) {
         };
     }
     try {
+        // Log de início (se não silencioso)
         if (!options.silent) {
             messages.logGuardian.info(messages.MENSAGENS_GUARDIAN.iniciando);
             if (options.fullScan) {
@@ -21,12 +36,14 @@ export async function executarGuardian(entries, options) {
                 messages.logGuardian.info(`  ${messages.MENSAGENS_GUARDIAN.saveBaseline}`);
             }
         }
+        // Executar scan
         const resultado = await scanSystemIntegrity(entries, {
             suppressLogs: options.silent,
-        });
-        const status = resultado.status || IntegridadeStatus.Ok;
-        const drift = resultado.detalhes?.length || 0;
+        }); // Processar resultado
+        const status = resultado.status;
+        const drift = resultado.detalhes?.length ?? 0;
         const temProblemas = status === IntegridadeStatus.AlteracoesDetectadas;
+        // Log de resultado (se não silencioso)
         if (!options.silent) {
             switch (status) {
                 case IntegridadeStatus.Ok:
@@ -63,6 +80,9 @@ export async function executarGuardian(entries, options) {
         };
     }
 }
+/**
+ * Formata resultado Guardian para JSON
+ */
 export function formatarGuardianParaJson(result) {
     if (!result.executado) {
         return {
@@ -72,8 +92,8 @@ export function formatarGuardianParaJson(result) {
     }
     return {
         executado: true,
-        status: result.status || 'desconhecido',
-        drift: result.drift || 0,
+        status: result.status ?? 'desconhecido',
+        drift: result.drift ?? 0,
         temProblemas: result.temProblemas,
         detalhes: result.resultado
             ? {
@@ -84,9 +104,12 @@ export function formatarGuardianParaJson(result) {
             : undefined,
     };
 }
+/**
+ * Determina exit code baseado no status Guardian
+ */
 export function getExitCodeGuardian(result) {
     if (!result.executado || !result.status) {
-        return 0;
+        return 0; // Não executado ou sem status = OK
     }
     switch (result.status) {
         case IntegridadeStatus.Ok:
@@ -99,4 +122,3 @@ export function getExitCodeGuardian(result) {
             return 0;
     }
 }
-//# sourceMappingURL=guardian-handler.js.map

package/dist/cli/diagnostic/handlers/index.js

@@ -1,4 +1,7 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Diagnosis handlers
+ */
 export * from './archetype-handler.js';
 export * from './auto-fix-handler.js';
 export * from './guardian-handler.js';
-//# sourceMappingURL=index.js.map

package/dist/cli/diagnostic/index.js

@@ -1,5 +1,10 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Diagnosis processing and normalization
+ */
+export * from './auto-fix.js';
 export * from './filters.js';
 export * from './normalize-occurrences-json.js';
 export * from './options-diagnose.js';
 export { processarDiagnostico } from './processing-diagnostic.js';
-//# sourceMappingURL=index.js.map
+export * from './processing-helpers.js';

package/dist/cli/diagnostic/normalize-occurrences-json.js

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: MIT
+// Em JSON, queremos incluir localização sempre que possível.
+// Muitos analistas armazenam `loc` (ex.: Babel) mas nem sempre preenchem `linha/coluna`.
 export function normalizarOcorrenciaParaJson(oc) {
     try {
         const out = { ...oc };
@@ -29,4 +32,3 @@ export function normalizarOcorrenciaParaJson(oc) {
         return oc;
     }
 }
-//# sourceMappingURL=normalize-occurrences-json.js.map