@mocoto/mahoraga 0.14.0 → 0.14.1

package/dist/core/execution/scanner.js

@@ -1,154 +1,203 @@
 import { promises as fs } from 'node:fs';
+import micromatch from 'micromatch';
+import path from 'path';
 import { config } from '../config/index.js';
 import { messages } from '../messages/index.js';
 import { lerArquivoTexto, lerEstado } from '../../shared/persistence/index.js';
-import micromatch from 'micromatch';
-import path from 'path';
 function getErrMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
 function ensureStringArray(val) {
-    if (!Array.isArray(val))
+    if (!Array.isArray(val)) {
         return [];
+    }
     for (const item of val) {
-        if (typeof item !== 'string')
+        if (typeof item !== 'string') {
             return [];
+        }
     }
     return val;
 }
 export async function scanRepository(baseDir, options = {}) {
+    // Log de início da varredura
     messages.logVarredor.iniciarVarredura(baseDir);
+    // Helpers locais de normalização (não exportados)
     const toPosix = (string) => string.replace(/\\+/g, '/');
     const trimDotSlash = (string) => string.replace(/^\.\/?/, '');
     const { includeContent = true, filter = () => true, onProgress = () => {
         return undefined;
     } } = options;
+    // Em modo scan-only, não devemos ler conteúdos de arquivos
     const efetivoIncluirConteudo = includeContent && !config.SCAN_ONLY;
     const fileMap = {};
     const statCache = new Map();
     const cliIncludeGroups = config.CLI_INCLUDE_GROUPS;
     const includeGroups = Array.isArray(cliIncludeGroups) ? cliIncludeGroups : [];
-    const includeGroupsNorm = includeGroups.map(grupo => (grupo || []).map(caminho => toPosix(trimDotSlash(String(caminho || '')))));
+    const includeGroupsNorm = includeGroups.map(grupo => (grupo || []).map(caminho => toPosix(trimDotSlash((caminho || '')))));
     const includePadroes = ensureStringArray(config.CLI_INCLUDE_PATTERNS);
-    const includePadroesNorm = includePadroes.map(caminho => toPosix(trimDotSlash(String(caminho || ''))));
-    const excludePadroesNorm = ensureStringArray(config.CLI_EXCLUDE_PATTERNS).map(caminho => toPosix(String(caminho || '')));
-    const legacyExcludes = config.INCLUDE_EXCLUDE_RULES?.globalExcludeGlob || [];
-    const ignorePadroesNorm = ensureStringArray(legacyExcludes).map((caminho) => toPosix(String(caminho || '')));
+    const includePadroesNorm = includePadroes.map(caminho => toPosix(trimDotSlash((caminho || ''))));
+    const excludePadroesNorm = ensureStringArray(config.CLI_EXCLUDE_PATTERNS).map(caminho => toPosix((caminho || '')));
+    // [PIN] ÚNICO PONTO DE EXCLUDE: globalExcludeGlob da configuração legacy ou campo simplificado
+    const legacyExcludes = config.INCLUDE_EXCLUDE_RULES.globalExcludeGlob ?? [];
+    const ignorePadroesNorm = ensureStringArray(legacyExcludes).map((caminho) => toPosix((caminho || '')));
     const hasIncluir = includeGroupsNorm.length > 0 || includePadroesNorm.length > 0;
+    // Sinaliza quando os includes pedem ocorrências em qualquer profundidade (ex.: '**/nome/**') ou quando
+    // o usuário forneceu nomes simples (que o expandIncludes converte em '**/nome/**').
     const pedeOcorrenciasGlobais = hasIncluir ? [...includePadroesNorm, ...includeGroupsNorm.flat()].some(caminho => caminho.startsWith('**/')) : false;
-    const includeNodeModulesExplicit = hasIncluir ? [...includePadroesNorm, ...includeGroupsNorm.flat()].some(caminho => /(^|\/)node_modules(\/|$)/.test(String(caminho || ''))) : false;
+    // node_modules explicitamente incluído em algum pattern ou grupo de include
+    const includeNodeModulesExplicit = hasIncluir ? [...includePadroesNorm, ...includeGroupsNorm.flat()].some(caminho => /(^|\/)node_modules(\/|$)/.test((caminho || ''))) : false;
     function adicionarArquivoAoMapa(fullCaminho, relPath, content, mtimeMs) {
         fileMap[`$${relPath}`] = { fullCaminho, relPath, content, ultimaModificacao: mtimeMs };
         if (!config.REPORT_SILENCE_LOGS) {
             onProgress(`[OK] Arquivo lido: ${relPath}`);
         }
     }
+    // Quando includes estão ativos, derivamos diretórios-raiz a partir dos prefixos antes do primeiro metacaractere
     function calcularIncludeRoots(padroes, grupos) {
         const roots = new Set();
         const candidatos = new Set();
-        if (Array.isArray(padroes))
+        if (Array.isArray(padroes)) {
             padroes.forEach(caminho => candidatos.add(toPosix(trimDotSlash(caminho))));
-        if (Array.isArray(grupos))
-            for (const grupo of grupos)
+        }
+        if (Array.isArray(grupos)) {
+            for (const grupo of grupos) {
                 grupo.forEach(caminho => candidatos.add(toPosix(trimDotSlash(caminho))));
-        if (candidatos.size === 0)
+            }
+        }
+        if (candidatos.size === 0) {
             return [];
-        const META = /[\\*\?\{\}\[\]]/;
+        }
+        const META = /[\\*\?\{\}\[\]]/; // caracteres meta de glob
         for (const raw of candidatos) {
-            let caminho = String(raw).trim();
-            if (!caminho)
+            let caminho = raw.trim();
+            if (!caminho) {
                 continue;
+            }
             caminho = toPosix(trimDotSlash(caminho));
             let anchor = '';
-            if (caminho.includes('/**'))
+            if (caminho.includes('/**')) {
                 anchor = caminho.slice(0, caminho.indexOf('/**'));
-            else if (caminho.includes('/*'))
+            }
+            else if (caminho.includes('/*')) {
                 anchor = caminho.slice(0, caminho.indexOf('/*'));
-            else if (caminho.includes('/'))
+            }
+            else if (caminho.includes('/')) {
                 anchor = caminho.split('/')[0];
-            else
+            }
+            else {
                 anchor = '';
+            }
             anchor = anchor.replace(/\/+/g, '/').replace(/\/$/, '');
+            // Ignora anchors inválidos: vazios, apenas '.', '**' ou contendo metacaracteres (ex.: '**/src')
             if (anchor && anchor !== '.' && anchor !== '**' && !META.test(anchor)) {
-                const baseNorm = toPosix(String(baseDir)).replace(/\/$/, '');
+                const baseNorm = toPosix(baseDir).replace(/\/$/, '');
                 const rootPosix = `${baseNorm}/${anchor}`.replace(/\/+/g, '/');
                 roots.add(rootPosix);
             }
         }
         return Array.from(roots);
     }
+    // Matcher de include considerando grupos: AND dentro do grupo, OR entre grupos
     function matchIncluir(relPath) {
+        // Função auxiliar: avalia se um padrão casa com o caminho relativo
         const matchesPadrao = (rp, caminho) => {
-            if (!caminho)
+            if (!caminho) {
                 return false;
-            if (micromatch.isMatch(rp, [caminho]))
+            }
+            // Casamento direto via micromatch
+            if (micromatch.isMatch(rp, [caminho])) {
                 return true;
+            }
+            // Compat extra: reconhece padrões simples com sufixo '/**' por prefixo
             if (caminho.endsWith('/**')) {
-                const base = caminho.slice(0, -3);
-                if (base && rp.startsWith(base))
+                const base = caminho.slice(0, -3); // remove '/**'
+                if (base && rp.startsWith(base)) {
                     return true;
+                }
             }
+            // Quando o padrão não possui metacaracteres, trate como diretório/segmento
             const META = /[\\*\?\{\}\[\]]/;
             if (!META.test(caminho)) {
                 const pat = caminho.replace(/\/+$|\/+$|^\.\/?/g, '').replace(/\/+/g, '/');
-                if (!pat)
+                if (!pat) {
                     return false;
+                }
+                // Se contém barra: trate como caminho base (prefixo)
                 if (pat.includes('/')) {
-                    if (rp === pat)
+                    if (rp === pat) {
                         return true;
-                    if (rp.startsWith(`${pat}/`))
+                    }
+                    if (rp.startsWith(`${pat}/`)) {
                         return true;
-                    if (rp.includes(`/${pat}/`))
+                    }
+                    if (rp.includes(`/${pat}/`)) {
                         return true;
-                    if (rp.endsWith(`/${pat}`))
+                    }
+                    if (rp.endsWith(`/${pat}`)) {
                         return true;
+                    }
                     return false;
                 }
-                if (rp === pat)
+                // Segmento simples: casa em qualquer nível
+                if (rp === pat) {
                     return true;
-                if (rp.startsWith(`${pat}/`))
+                }
+                if (rp.startsWith(`${pat}/`)) {
                     return true;
-                if (rp.includes(`/${pat}/`))
+                }
+                if (rp.includes(`/${pat}/`)) {
                     return true;
-                if (rp.endsWith(`/${pat}`))
+                }
+                if (rp.endsWith(`/${pat}`)) {
                     return true;
+                }
                 return false;
             }
             return false;
         };
+        // Função auxiliar: extrai a "base" do padrão (token original antes das ampliações)
         const baseFromPadrao = (caminho) => {
             let base = caminho.trim();
-            base = base.replace(/^\*\*\//, '');
-            base = base.replace(/\/\*\*$/, '');
-            base = base.replace(/^\.\/?/, '');
+            base = base.replace(/^\*\*\//, ''); // remove '**/' inicial
+            base = base.replace(/\/\*\*$/, ''); // remove '/**' final
+            base = base.replace(/^\.\/?/, ''); // remove './' inicial
             base = base.replace(/\/+/g, '/').replace(/\/$/, '');
             return base;
         };
+        // Quando houver grupos, aplica estritamente: OR entre grupos com AND dentro do grupo
         if (includeGroupsNorm.length > 0) {
             for (const grupo of includeGroupsNorm) {
+                // Agrupa padrões por base (permite OR entre variantes de um mesmo token e AND entre tokens)
                 const porBase = new Map();
                 for (const caminho of grupo) {
                     const base = baseFromPadrao(caminho);
-                    const patternVariants = porBase.get(base) || [];
+                    const patternVariants = porBase.get(base) ?? [];
                     patternVariants.push(caminho);
                     porBase.set(base, patternVariants);
                 }
                 const allBasesMatch = Array.from(porBase.values()).every(lista => lista.some(caminho => matchesPadrao(relPath, caminho)));
-                if (allBasesMatch)
+                if (allBasesMatch) {
                     return true;
+                }
             }
+            // Sem correspondência em nenhum grupo -> não inclui
             return false;
         }
-        if (includePadroesNorm.length && micromatch.isMatch(relPath, includePadroesNorm))
+        // Sem grupos: lista achatada (OR)
+        if (includePadroesNorm.length && micromatch.isMatch(relPath, includePadroesNorm)) {
             return true;
-        for (const caminho of includePadroesNorm || [])
-            if (matchesPadrao(relPath, caminho))
+        }
+        // Compat extra também para padrões simples quando não há grupos
+        for (const caminho of includePadroesNorm || []) {
+            if (matchesPadrao(relPath, caminho)) {
                 return true;
+            }
+        }
         return false;
     }
     async function getStat(caminho) {
         try {
-            const sanitizedPath = String(caminho).replace(/\0/g, '');
+            const sanitizedPath = caminho.replace(/\0/g, '');
             const st = await fs.stat(sanitizedPath);
             statCache.set(sanitizedPath, st);
             return st;
@@ -184,7 +233,7 @@ export async function scanRepository(baseDir, options = {}) {
         }
     }
     async function scan(dir) {
-        const sanitizedDir = String(dir).replace(/\0/g, '');
+        const sanitizedDir = dir.replace(/\0/g, '');
         let entries;
         try {
             entries = await fs.readdir(sanitizedDir, {
@@ -201,6 +250,7 @@ export async function scanRepository(baseDir, options = {}) {
             }));
             return;
         }
+        // Logar apenas diretórios sendo examinados
         onProgress(JSON.stringify({
             tipo: 'diretorio',
             acao: 'examinar',
@@ -209,13 +259,18 @@ export async function scanRepository(baseDir, options = {}) {
         for (const entry of entries) {
             const fullCaminho = path.join(sanitizedDir, entry.name);
             const relPathRaw = path.relative(baseDir, fullCaminho);
+            // Normaliza para separador POSIX para que micromatch funcione de forma consistente no Windows
             const relPath = toPosix(relPathRaw);
+            // Regra fixa do Mahoraga: não analisar testes (deixa para o runner, ex.: Vitest)
+            // Arquivos auto-gerados / terceiros — pular sempre
             const isThirdParty = (caminho) => {
                 const rp = toPosix(caminho);
-                if (/^THIRD-PARTY[-_]/.test(rp))
+                if (/^THIRD-PARTY[-_]/.test(rp)) {
                     return true;
-                if (/^(LICENSE|CHANGELOG|CONTRIBUTING|CODE_OF_CONDUCT)/i.test(rp))
+                }
+                if (/^(LICENSE|CHANGELOG|CONTRIBUTING|CODE_OF_CONDUCT)/i.test(rp)) {
                     return true;
+                }
                 return false;
             };
             if (isThirdParty(relPath)) {
@@ -223,41 +278,52 @@ export async function scanRepository(baseDir, options = {}) {
             }
             const isTestLike = (caminho) => {
                 const rp = toPosix(caminho);
-                if (/(^|\/)__(tests|mocks)__(\/|$)/.test(rp))
+                if (/(^|\/)__(tests|mocks)__(\/|$)/.test(rp)) {
                     return true;
-                if (/(^|\/)(tests?|test)(\/|$)/.test(rp))
+                }
+                if (/(^|\/)(tests?|test)(\/|$)/.test(rp)) {
                     return true;
-                if (/\.(test|spec)\.[jt]sx?$/.test(rp))
+                }
+                if (/\.(test|spec)\.[jt]sx?$/.test(rp)) {
                     return true;
+                }
                 return false;
             };
             if (isTestLike(relPath)) {
                 continue;
             }
             if (entry.isDirectory() && !entry.isSymbolicLink()) {
-                if (!hasIncluir && micromatch.isMatch(relPath, excludePadroesNorm))
+                if (!hasIncluir && micromatch.isMatch(relPath, excludePadroesNorm)) {
                     continue;
-                if (!hasIncluir && micromatch.isMatch(relPath, ignorePadroesNorm))
+                }
+                if (!hasIncluir && micromatch.isMatch(relPath, ignorePadroesNorm)) {
                     continue;
-                if (/(^|\/)node_modules(\/|$)/.test(relPath) && !includeNodeModulesExplicit)
+                }
+                if (/(^|\/)node_modules(\/|$)/.test(relPath) && !includeNodeModulesExplicit) {
                     continue;
+                }
                 await scan(fullCaminho);
                 continue;
             }
-            if (hasIncluir && !matchIncluir(relPath))
+            if (hasIncluir && !matchIncluir(relPath)) {
                 continue;
-            if (!hasIncluir && micromatch.isMatch(relPath, excludePadroesNorm))
+            }
+            if (!hasIncluir && micromatch.isMatch(relPath, excludePadroesNorm)) {
                 continue;
-            if (!hasIncluir && micromatch.isMatch(relPath, ignorePadroesNorm))
+            }
+            if (!hasIncluir && micromatch.isMatch(relPath, ignorePadroesNorm)) {
                 continue;
-            if (!filter(relPath, entry))
+            }
+            if (!filter(relPath, entry)) {
                 continue;
+            }
             try {
                 let stat = statCache.get(fullCaminho);
                 if (!stat) {
                     stat = await getStat(fullCaminho);
-                    if (!stat)
+                    if (!stat) {
                         continue;
+                    }
                 }
                 const mtimeMs = extractMtimeMs(stat);
                 let content = null;
@@ -281,46 +347,51 @@ export async function scanRepository(baseDir, options = {}) {
         for (const diretorio of dirs) {
             let norm = diretorio;
             let end = norm.length;
-            while (end > 0 && (norm[end - 1] === '\\' || norm[end - 1] === '/'))
+            while (end > 0 && (norm[end - 1] === '\\' || norm[end - 1] === '/')) {
                 end--;
+            }
             norm = norm.slice(0, end);
-            if (vistos.has(norm))
+            if (vistos.has(norm)) {
                 continue;
+            }
             vistos.add(norm);
             try {
                 await fs.readdir(norm);
                 await scanFn(norm);
                 continue;
             }
-            catch { }
+            catch { /* not a dir */ }
             try {
                 let st = statC.get(norm);
                 if (!st) {
                     st = await fs.stat(norm);
                     statC.set(norm, st);
                 }
-                let isDir = st?.isDirectory() ?? false;
+                let isDir = st.isDirectory() ?? false;
                 if (!isDir) {
                     try {
                         await fs.readdir(norm);
                         isDir = true;
                     }
-                    catch { }
+                    catch { /* file */ }
                 }
                 if (isDir) {
                     await scanFn(norm);
                     continue;
                 }
                 const relPath = toPosix(path.relative(base, norm));
-                if (hasInc && !matchFn(relPath))
+                if (hasInc && !matchFn(relPath)) {
                     continue;
-                if (!hasInc && (micromatch.isMatch(relPath, exclPad) || micromatch.isMatch(relPath, ignPad)))
+                }
+                if (!hasInc && (micromatch.isMatch(relPath, exclPad) || micromatch.isMatch(relPath, ignPad))) {
                     continue;
+                }
                 const fakeDirent = {
                     name: path.basename(norm), isDirectory: () => false, isSymbolicLink: () => false
                 };
-                if (!filterFn(relPath, fakeDirent))
+                if (!filterFn(relPath, fakeDirent)) {
                     continue;
+                }
                 let content = null;
                 if (efetivoInc) {
                     try {
@@ -339,12 +410,18 @@ export async function scanRepository(baseDir, options = {}) {
         }
     }
     let startDirs = hasIncluir ? calcularIncludeRoots(config.CLI_INCLUDE_PATTERNS, cliIncludeGroups) : [];
+    // Quando o include pede ocorrências em qualquer profundidade, adicionamos também a base do repo para
+    // garantir que diretórios-alvo apareçam em níveis arbitrários (ex.: packages/*/node_modules).
     if (hasIncluir && pedeOcorrenciasGlobais) {
-        const baseNorm = toPosix(String(baseDir)).replace(/\/$/, '');
-        if (!startDirs.includes(baseNorm))
+        const baseNorm = toPosix(baseDir).replace(/\/$/, '');
+        if (!startDirs.includes(baseNorm)) {
             startDirs = [baseNorm, ...startDirs];
+        }
     }
+    // Se nenhum root foi derivado (ex.: includes somente de arquivos como 'a.txt'), varremos a base inteira
+    // para permitir que o filtro de includes atue nos arquivos diretamente.
     if (hasIncluir && startDirs.length === 0) {
+        // Sem roots deriváveis (ex.: include apenas 'a.txt'): varre só a raiz para permitir filtro
         await scan(baseDir);
         return fileMap;
     }
@@ -354,9 +431,9 @@ export async function scanRepository(baseDir, options = {}) {
     else {
         await processarStartDirs(startDirs, baseDir, hasIncluir, efetivoIncluirConteudo, scan, matchIncluir, filter, onProgress, excludePadroesNorm, ignorePadroesNorm, statCache);
     }
+    // Log de conclusão da varredura
     const totalArquivos = Object.keys(fileMap).length;
     const totalDiretorios = new Set(Object.values(fileMap).map(arquivo => path.dirname(arquivo.relPath))).size;
     messages.logVarredor.completo(totalArquivos, totalDiretorios);
     return fileMap;
 }
-//# sourceMappingURL=scanner.js.map

package/dist/core/execution/schema.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Tipos centralizados para sistema de versionamento de schema
+ * Consolidação de: src/core/schema/version.ts e versão anterior
+ */
+export {};

package/dist/core/execution/structure-json.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: MIT
+export {};

package/dist/core/execution/workers.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Tipos para sistema de Worker Pool
+ */
+export {};

package/dist/core/formatters/index.js

@@ -1,3 +1,3 @@
+// SPDX-License-Identifier: MIT
 export { inicializarFormattersBuiltin } from './registro-builtin.js';
 export * from './registry.js';
-//# sourceMappingURL=index.js.map

package/dist/core/formatters/registro-builtin.js

@@ -1,3 +1,7 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Registro dos formatadores built-in (JSON, Markdown, Compliance)
+ */
 import { exportarComplianceJson, exportarComplianceMarkdown, gerarRelatorioJson, gerarRelatorioMarkdown } from '../../cli/diagnostic/exporters/index.js';
 import { gerarRelatorioCompliance } from '../../reports/compliance/index.js';
 import { registrarFormatter } from './registry.js';
@@ -15,8 +19,8 @@ const formatterJson = {
                 arquivo: o.relPath || '',
                 linha: o.linha,
                 coluna: o.coluna,
-                nivel: (o.nivel || 'info'),
-                tipo: o.tipo || '',
+                nivel: (o.nivel ?? 'info'),
+                tipo: o.tipo ?? '',
                 mensagem: o.mensagem || '',
             })),
             linguagens: dados.linguagens,
@@ -55,7 +59,7 @@ const formatterComplianceJson = {
     versao: '1.0.0',
     extensoes: ['.compliance.json'],
     gerar: (dados) => {
-        const relatorio = gerarRelatorioCompliance('iso-27001', dados.ocorrencias, { nomeProjeto: dados.metadata.projectNome || 'projeto', duracao: dados.metadata.timestamp ? 0 : 0, totalArquivos: dados.stats.arquivosAnalisados });
+        const relatorio = gerarRelatorioCompliance('iso-27001', dados.ocorrencias, { nomeProjeto: dados.metadata.projectNome ?? 'projeto', duracao: dados.metadata.timestamp ? 0 : 0, totalArquivos: dados.stats.arquivosAnalisados });
         return relatorio ? exportarComplianceJson(relatorio) : '{}';
     },
 };
@@ -66,7 +70,7 @@ const formatterComplianceMarkdown = {
     versao: '1.0.0',
     extensoes: ['.compliance.md'],
     gerar: (dados) => {
-        const relatorio = gerarRelatorioCompliance('iso-27001', dados.ocorrencias, { nomeProjeto: dados.metadata.projectNome || 'projeto', duracao: 0, totalArquivos: dados.stats.arquivosAnalisados });
+        const relatorio = gerarRelatorioCompliance('iso-27001', dados.ocorrencias, { nomeProjeto: dados.metadata.projectNome ?? 'projeto', duracao: 0, totalArquivos: dados.stats.arquivosAnalisados });
         return relatorio ? exportarComplianceMarkdown(relatorio) : '# Sem dados';
     },
 };
@@ -74,18 +78,17 @@ export function inicializarFormattersBuiltin() {
     try {
         registrarFormatter(formatterJson);
     }
-    catch { }
+    catch { /* já registrado */ }
     try {
         registrarFormatter(formatterMarkdown);
     }
-    catch { }
+    catch { /* já registrado */ }
     try {
         registrarFormatter(formatterComplianceJson);
     }
-    catch { }
+    catch { /* já registrado */ }
     try {
         registrarFormatter(formatterComplianceMarkdown);
     }
-    catch { }
+    catch { /* já registrado */ }
 }
-//# sourceMappingURL=registro-builtin.js.map

package/dist/core/formatters/registry.js

@@ -1,3 +1,7 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Registry pattern para gerenciamento de formatadores
+ */
 import { messages } from '../messages/index.js';
 const registry = new Map();
 export function registrarFormatter(formatter) {
@@ -18,4 +22,3 @@ export function listarFormatters() {
 export function obterFormatterPorFormato(formato) {
     return Array.from(registry.values()).filter(f => f.formato === formato || f.extensoes?.includes(formato));
 }
-//# sourceMappingURL=registry.js.map

package/dist/core/index.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Exportações centralizadas de tipos do core
+ */
+export {};

package/dist/core/messages/en/analysts/analyst-commands-cli-messages.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Diagnostic messages for the CLI commands analyst.
+ * Provides text templates to detect duplicate commands, anonymous handlers,
+ * missing error handling, and other bad practices in CLI command files.
+ */
 function comandoLabel(comandoNome) {
     return comandoNome ? ` "${comandoNome}"` : "";
 }
@@ -11,4 +17,3 @@ export const ComandosCliMensagens = {
     handlerSemFeedback: (comandoNome) => `Handler for command${comandoLabel(comandoNome)} does not log or respond to the user. Consider adding feedback/logging.`,
     multiplosComandos: (count) => `Multiple commands registered in this file (${count}). Consider separating each command into its own module for better maintainability.`
 };
-//# sourceMappingURL=analyst-commands-cli-messages.js.map

package/dist/core/messages/en/analysts/analyst-github-actions-messages.js

@@ -1,3 +1,8 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Diagnostic messages for the GitHub Actions analyst.
+ * Provides summarized text templates for workflow issues.
+ */
 export const AnalistaGithubActionsMensagens = {
     resumoWorkflow: (score, total) => `GitHub Actions Workflow: Score ${score}/100, ${total} issue(s) found`,
     workflowOtimo: 'Workflow follows all GitHub Actions best practices',
@@ -51,4 +56,3 @@ export const AnalistaGithubActionsMensagens = {
     workflowDispatchWithoutInputsSugestao: 'Define required inputs to control manual workflow execution',
     erroAplicarCorrecao: (erro) => `Error applying fix: ${erro}`,
 };
-//# sourceMappingURL=analyst-github-actions-messages.js.map

package/dist/core/messages/en/analysts/analyst-gitlab-ci-messages.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 export const AnalistaGitlabCiMensagens = {
     jobScriptMuitoLongo: (key, n) => `Job '${key}' has a very long script (${n} lines)`,
     semCache: 'Pipeline without cache configuration',
@@ -9,4 +10,3 @@ export const AnalistaGitlabCiMensagens = {
     secretHardcoded: 'Hardcoded secret detected in pipeline',
     scriptInjection: 'Possible script injection via GitLab context variables',
 };
-//# sourceMappingURL=analyst-gitlab-ci-messages.js.map

package/dist/core/messages/en/analysts/analyst-patterns-usage-messages.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 export const PadroesUsoMensagens = {
     varUsage: "Usage of 'var' detected. Prefer 'let' or 'const'.",
     letUsage: "Usage of 'let'. Consider 'const' if there is no reassignment.",
@@ -17,4 +18,3 @@ export const PadroesUsoMensagens = {
     uselessConditional: "Unnecessary comparison: if (x === true). Use just if (x).",
     erroAnalise: (relPath, erro) => `Failed to analyze usage patterns in ${relPath}: ${erro}`
 };
-//# sourceMappingURL=analyst-patterns-usage-messages.js.map

package/dist/core/messages/en/analysts/analyst-shell-messages.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 export const AnalistaShellMensagens = {
     missingShebang: 'Shell script missing shebang detected.',
     missingShebangSugestao: 'Add #!/bin/bash or #!/bin/sh at the top of the file.',
@@ -15,6 +16,7 @@ export const AnalistaShellMensagens = {
     hardcodedPasswordSugestao: 'Use environment variables injected at runtime.',
     sudoUsage: 'sudo usage detected in script.',
     sudoUsageSugestao: 'Try to design scripts that run without root privileges, or ask the user to run the whole script with sudo.',
+    // Security (enhanced)
     unsafePipefail: 'Pipeline without pipefail - pipe errors are ignored.',
     unsafePipefailSugestao: 'Add "set -o pipefail" to catch pipe errors.',
     unsafeCdWithoutCheck: 'cd command without error checking.',
@@ -27,6 +29,7 @@ export const AnalistaShellMensagens = {
     dangerousFlagsSugestao: 'Verify flags are intentional and scope is limited.',
     unsafeReadWithoutR: 'read without -r - backslashes are interpreted.',
     unsafeReadWithoutRSugestao: 'Use "read -r" to preserve backslashes literally.',
+    // Best Practices
     missingLocalVar: 'Variable in function not declared as local.',
     missingLocalVarSugestao: 'Use the "local" keyword to scope variables to the function.',
     uppercaseLocalVar: 'Local variable named with UPPERCASE letters.',
@@ -43,12 +46,14 @@ export const AnalistaShellMensagens = {
     missingDefaultCaseSugestao: 'Add *) as default case to handle unexpected values.',
     emptyCatchBlock: 'Empty then or else block detected.',
     emptyCatchBlockSugestao: 'Add an explanatory comment or remove the empty block.',
+    // Portability
     bashismDetected: 'Bash-specific feature in script with #!/bin/sh shebang.',
     bashismDetectedSugestao: 'Use only POSIX syntax in sh scripts.',
     platformSpecificPath: 'Platform-specific path detected (/usr/bin vs /bin).',
     platformSpecificPathSugestao: 'Use "command -v" to locate executables.',
     missingQuoteArrays: 'Unquoted array expansion.',
     missingQuoteArraysSugestao: 'Use "${arr[@]}" to preserve spaces in elements.',
+    // Performance
     uselessCat: 'Useless cat: "cat file | command".',
     uselessCatSugestao: 'Use redirection: "command < file".',
     loopOverCommandOutput: 'Loop over ls output: "for f in $(ls)".',
@@ -56,4 +61,3 @@ export const AnalistaShellMensagens = {
     pipeOverTempfile: 'Pipeline could replace temporary file.',
     pipeOverTempfileSugestao: 'Use pipes instead of temporary files.',
 };
-//# sourceMappingURL=analyst-shell-messages.js.map

package/dist/core/messages/en/analysts/analyst-todo-comments-messages.js

@@ -1,5 +1,5 @@
+// SPDX-License-Identifier: MIT
 export const TodoComentariosMensagens = {
     todoFound: 'TODO comment found',
     todoOrFixmeFound: (tipo, texto) => `${tipo} found: ${texto}`,
 };
-//# sourceMappingURL=analyst-todo-comments-messages.js.map