@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/shell/scorers/scorer-shell.js

@@ -1,11 +1,23 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [GRAFICO] Pontuador de qualidade Shell Script
+ *
+ * Avalia a qualidade do Shell baseado em:
+ * - Segurança
+ * - Error handling
+ * - Boas práticas
+ * - Portabilidade
+ * - Performance
+ */
 import { splitLines } from '../../../shared/helpers/index.js';
 export function pontuarShell(src, _relPath) {
     let score = 0;
-    const maxScore = 200;
+    const maxScore = 280;
     const issues = [];
     const strengths = [];
     const linhas = splitLines(src);
     const srcCompleto = src;
+    // Shebang (10 pontos)
     if (linhas.length > 0 && linhas[0].startsWith('#!')) {
         score += 10;
         strengths.push('Shebang presente');
@@ -13,6 +25,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Shebang ausente');
     }
+    // set -e / pipefail (15 pontos)
     if (/set\s+(-e|-o\s+pipefail)/.test(srcCompleto)) {
         score += 15;
         strengths.push('Error handling configurado');
@@ -20,6 +33,31 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Sem set -e / pipefail');
     }
+    // set -u (10 pontos)
+    if (/set\s+-u/.test(srcCompleto)) {
+        score += 10;
+        strengths.push('Strict mode (set -u)');
+    }
+    else {
+        issues.push('Sem set -u');
+    }
+    // IFS (5 pontos)
+    if (/IFS=/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('IFS configurado');
+    }
+    else {
+        issues.push('Sem IFS');
+    }
+    // trap handler (10 pontos)
+    if (/\btrap\s+/.test(srcCompleto)) {
+        score += 10;
+        strengths.push('Cleanup handler presente');
+    }
+    else {
+        issues.push('Sem trap handler');
+    }
+    // No eval (15 pontos)
     if (!/\beval\s+/.test(srcCompleto)) {
         score += 15;
         strengths.push('Sem eval');
@@ -27,6 +65,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('eval detectado');
     }
+    // No curl|sh (10 pontos)
     if (!/(curl|wget).*\|\s*(ba)?sh/.test(srcCompleto)) {
         score += 10;
         strengths.push('Sem curl|sh');
@@ -34,7 +73,8 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('curl|sh detectado');
     }
-    const hardcodedPasswords = (srcCompleto.match(/\b(password|pass|secret|token)\b\s*=\s*['"]/gi) || []).length;
+    // No hardcoded passwords (10 pontos)
+    const hardcodedPasswords = (srcCompleto.match(/\b(password|pass|secret|token)\b\s*=\s*['"]/gi) ?? []).length;
     if (hardcodedPasswords === 0) {
         score += 10;
         strengths.push('Sem senhas hardcoded');
@@ -42,7 +82,8 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push(`${hardcodedPasswords} senha(s) hardcoded`);
     }
-    const unquotedVars = (srcCompleto.match(/\b(echo|ls|cd|rm|cp|mv)\s+.*\$\w+/g) || []).filter(linha => !/["'].*\$\w+.*["']/.test(linha)).length;
+    // Quoted variables (10 pontos)
+    const unquotedVars = (srcCompleto.match(/\b(echo|ls|cd|rm|cp|mv)\s+.*\$\w+/g) ?? []).filter(linha => !/["'].*\$\w+.*["']/.test(linha)).length;
     if (unquotedVars === 0) {
         score += 10;
         strengths.push('Variáveis corretamente aspeadas');
@@ -51,6 +92,7 @@ export function pontuarShell(src, _relPath) {
         score += Math.max(0, 10 - unquotedVars * 3);
         issues.push(`${unquotedVars} variável(is) sem aspas`);
     }
+    // No rm -rf / (10 pontos)
     if (!/\brm\s+-rf\s+\/(\s|$)/.test(srcCompleto)) {
         score += 10;
         strengths.push('Sem rm -rf /');
@@ -58,7 +100,9 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('rm -rf / detectado!');
     }
-    const cds = srcCompleto.match(/^\s*cd\s+\S+/gm) || [];
+    // ── Security (enhanced) ──────────────────────────────────────────────────
+    // cd with check (5 pontos)
+    const cds = srcCompleto.match(/^\s*cd\s+\S+/gm) ?? [];
     const cdsChecked = cds.filter(c => /cd\s+\S+\s*(;|&&|\|\|)/.test(c) || c.includes('|| exit') || c.includes('|| return')).length;
     if (cds.length === 0 || cdsChecked === cds.length) {
         score += 5;
@@ -67,6 +111,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push(`${cds.length - cdsChecked} cd(s) sem verificação`);
     }
+    // mktemp usage (5 pontos)
     if (/\bmktemp\b/.test(srcCompleto) || !/\/tmp\/\w+\.\w+/.test(srcCompleto)) {
         score += 5;
         strengths.push('Sem arquivos tmp inseguros');
@@ -74,6 +119,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Uso inseguro de /tmp');
     }
+    // Permissions (5 pontos)
     if (!/\bchmod\s+777\b/.test(srcCompleto) && !/\bumask\s+000\b/.test(srcCompleto)) {
         score += 5;
         strengths.push('Permissões seguras');
@@ -81,7 +127,8 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Permissões inseguras (chmod 777/umask 000)');
     }
-    const reads = srcCompleto.match(/^\s*read\s+/gm) || [];
+    // read -r (5 pontos)
+    const reads = srcCompleto.match(/^\s*read\s+/gm) ?? [];
     const readsWithR = reads.filter(r => /^\s*read\s+-r/.test(r)).length;
     if (reads.length === 0 || readsWithR === reads.length) {
         score += 5;
@@ -90,8 +137,10 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push(`${reads.length - readsWithR} read(s) sem -r`);
     }
-    const functions = (srcCompleto.match(/(\w+)\s*\(\s*\)/g) || []).length;
-    const locals = (srcCompleto.match(/\blocal\s+/g) || []).length;
+    // ── Best Practices ───────────────────────────────────────────────────────
+    // local variables (10 pontos)
+    const functions = (srcCompleto.match(/(\w+)\s*\(\s*\)/g) ?? []).length;
+    const locals = (srcCompleto.match(/\blocal\s+/g) ?? []).length;
     if (functions === 0 || locals >= functions) {
         score += 10;
         strengths.push('Variáveis locais escopadas');
@@ -100,6 +149,7 @@ export function pontuarShell(src, _relPath) {
         score += Math.max(0, 10 - (functions - locals) * 3);
         issues.push(`${functions - locals} função(ões) sem local variables`);
     }
+    // No backticks (5 pontos)
     if (!/`[^`]+`/.test(srcCompleto)) {
         score += 5;
         strengths.push('Sem crases');
@@ -107,6 +157,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Substituição com crases');
     }
+    // [[ instead of [ (5 pontos)
     if (!/^\s*\[[^\]]+\]/.test(srcCompleto) || /\[\[/.test(srcCompleto)) {
         score += 5;
         strengths.push('Uso de [[ para testes');
@@ -114,6 +165,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('[ usado em vez de [[');
     }
+    // $(( )) for arithmetic (5 pontos)
     if (!/\blet\s+/.test(srcCompleto) && !/^\s*expr\s+/.test(srcCompleto)) {
         score += 5;
         strengths.push('Uso de $(( )) para aritmética');
@@ -121,6 +173,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('let/expr usado em vez de $(( ))');
     }
+    // POSIX function style (5 pontos)
     if (!/^\s*function\s+\w+\s*\{/.test(srcCompleto)) {
         score += 5;
         strengths.push('Sintaxe POSIX de função');
@@ -128,6 +181,8 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Palavra-chave function usada');
     }
+    // ── Portability ──────────────────────────────────────────────────────────
+    // No bashisms in sh scripts (10 pontos)
     const shebang = linhas.length > 0 ? linhas[0] : '';
     if (!/\/bin\/sh(\s|$)/.test(shebang) || !/\b(function|\[\[|<<<|shopt)\b/.test(srcCompleto)) {
         score += 10;
@@ -136,7 +191,8 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Bashisms em script sh');
     }
-    const hardPaths = (srcCompleto.match(/\/(usr\/bin|usr\/local\/bin|bin|sbin)\//g) || []).length;
+    // command -v for paths (5 pontos)
+    const hardPaths = (srcCompleto.match(/\/(usr\/bin|usr\/local\/bin|bin|sbin)\//g) ?? []).length;
     if (hardPaths === 0) {
         score += 5;
         strengths.push('Sem caminhos de plataforma fixos');
@@ -145,6 +201,7 @@ export function pontuarShell(src, _relPath) {
         score += Math.max(0, 5 - hardPaths);
         issues.push(`${hardPaths} caminho(s) de plataforma fixos`);
     }
+    // Quoted array expansion (5 pontos)
     if (!/\$\{\w+\[@\]\}/.test(srcCompleto) || /"\$\{\w+\[@\]\}"/.test(srcCompleto)) {
         score += 5;
         strengths.push('Arrays com aspas');
@@ -152,6 +209,8 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Expansão de array sem aspas');
     }
+    // ── Performance ─────────────────────────────────────────────────────────
+    // No useless cat (5 pontos)
     if (!/\bcat\s+\S+\s*\|\s*/.test(srcCompleto)) {
         score += 5;
         strengths.push('Sem cat inútil');
@@ -159,6 +218,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('cat | command detectado');
     }
+    // No loop over ls (5 pontos)
     if (!/for\s+\w+\s+in\s+\$\(ls\)/.test(srcCompleto) && !/for\s+\w+\s+in\s+`ls`/.test(srcCompleto)) {
         score += 5;
         strengths.push('Glob em vez de ls');
@@ -166,6 +226,7 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('Loop sobre ls');
     }
+    // Pipes instead of temp files (5 pontos)
     if (/>\s*\S+\.tmp\b/.test(srcCompleto) && /<\s*\S+\.tmp\b/.test(srcCompleto)) {
         issues.push('Arquivo tmp usado em vez de pipe');
     }
@@ -173,6 +234,7 @@ export function pontuarShell(src, _relPath) {
         score += 5;
         strengths.push('Pipes em vez de tmp files');
     }
+    // Sudo score (5 pontos)
     if (!/\bsudo\s+/.test(srcCompleto)) {
         score += 5;
         strengths.push('Sem sudo');
@@ -180,6 +242,39 @@ export function pontuarShell(src, _relPath) {
     else {
         issues.push('sudo detectado');
     }
+    // ── Modern Bash (2026) ──────────────────────────────────────────
+    // main function pattern (5 pontos)
+    if (/main\s*\(\s*\)/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Função main presente');
+    }
+    else {
+        issues.push('Sem padrão de função main');
+    }
+    // command -v usage (5 pontos)
+    if (hardPaths === 0 || /command\s+-v/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Uso de command -v');
+    }
+    else {
+        issues.push('Caminhos fixos sem command -v');
+    }
+    // DEBUG mode (5 pontos)
+    if (/\$\{DEBUG[^}]*\}/.test(srcCompleto) || /\$DEBUG\b/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Modo debug presente');
+    }
+    else {
+        issues.push('Sem modo debug');
+    }
+    // Input validation (5 pontos)
+    if (/\[\[ -z "\$[0-9@*]/.test(srcCompleto) || /\[ -z "\$[0-9@*]/.test(srcCompleto)) {
+        score += 5;
+        strengths.push('Validação de input');
+    }
+    else if (/\$[0-9]/.test(srcCompleto)) {
+        issues.push('Sem validação de argumentos');
+    }
     return {
         score,
         maxScore,
@@ -194,4 +289,3 @@ export const pontuadorShell = {
     descricao: 'Pontua qualidade de Shell Script',
     pontuar: pontuarShell
 };
-//# sourceMappingURL=scorer-shell.js.map

package/dist/analysts/sql/analysts/analyst-sql.js

@@ -1,18 +1,24 @@
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
+/**
+ * Analista de SQL
+ * Detecta práticas inseguras, problemas de performance e má organização em arquivos SQL.
+ */
 export const analistaSql = criarAnalista({
     nome: 'analista-sql',
     categoria: 'database',
     descricao: 'Analisa arquivos SQL em busca de injeções, performance ruim e comandos perigosos.',
     test: (relPath) => /\.(sql|pgsql|mysql|sqlite)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
+    aplicar: (src, relPath) => {
         const ocorrencias = [];
         const linhas = src.split('\n');
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;
             const linhaTrim = linha.trim().toLowerCase();
+            // 1. DELETE/UPDATE sem WHERE (Crítico)
             if ((linhaTrim.startsWith('delete ') || linhaTrim.startsWith('update ')) &&
                 !linhaTrim.includes('where') &&
                 !linha.includes('--') && !linha.includes('/*')) {
+                // Verificar se o WHERE está na próxima linha (heurística simples)
                 const proximaLinha = linhas[index + 1]?.trim().toLowerCase() || '';
                 if (!proximaLinha.includes('where')) {
                     ocorrencias.push(criarOcorrencia({
@@ -25,6 +31,7 @@ export const analistaSql = criarAnalista({
                     }));
                 }
             }
+            // 2. SELECT * (Performance/Manutenibilidade)
             if (/\bselect\s+\*\s+from\b/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'problema-performance',
@@ -35,6 +42,7 @@ export const analistaSql = criarAnalista({
                     sugestao: 'Liste explicitamente as colunas necessárias.'
                 }));
             }
+            // 3. Senhas ou segredos em scripts (Segurança)
             if (/\b(password|senha|secret|key|token|credential)\b\s*[:=]\s*['"].*['"]/i.test(linha) ||
                 /identified\s+by\s+['"].*['"]/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
@@ -46,6 +54,7 @@ export const analistaSql = criarAnalista({
                     sugestao: 'Utilize variáveis de ambiente ou sistemas de gerenciamento de segredos.'
                 }));
             }
+            // 4. Injeção de SQL via strings concatenadas (se for template ou arquivo de migração dinâmico)
             if (/\s\+\s*['"`].*['"`]/.test(linha) && /select|insert|update|delete/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'sql-injection',
@@ -56,6 +65,7 @@ export const analistaSql = criarAnalista({
                     sugestao: 'Utilize consultas parametrizadas ou placeholders.'
                 }));
             }
+            // 5. Tabelas temporárias ou globais sem DROP prévio (Boas Práticas)
             if (/create\s+(table|procedure|view)\s+\w+/i.test(linha) && !/if\s+not\s+exists/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'codigo-fragil',
@@ -66,6 +76,7 @@ export const analistaSql = criarAnalista({
                     sugestao: 'Utilize "CREATE TABLE IF NOT EXISTS ..." para maior idempotência.'
                 }));
             }
+            // 6. TRUNCATE TABLE (Risco)
             if (/\btruncate\s+table\b/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'vulnerabilidade-seguranca',
@@ -76,6 +87,7 @@ export const analistaSql = criarAnalista({
                     sugestao: 'Certifique-se de que a limpeza total é intencional e prefira DELETE com WHERE se precisar de reversibilidade.'
                 }));
             }
+            // 7. Uso de tipos obsoletos (ex: VARCHAR sem tamanho, TEXT para colunas pequenas)
             if (/\bvarchar\b\s*(\(|\s|$)/i.test(linha) && !/\bvarchar\(\d+\)/i.test(linha)) {
                 ocorrencias.push(criarOcorrencia({
                     tipo: 'codigo-fragil',
@@ -91,4 +103,3 @@ export const analistaSql = criarAnalista({
     },
     global: false
 });
-//# sourceMappingURL=analyst-sql.js.map

package/dist/analysts/sql/analysts/index.js

@@ -1,2 +1 @@
 export * from './analyst-sql.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/sql/corrections/correction-sql.js

@@ -1,3 +1,12 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [CHAVE-INGLESA] Correções automáticas para SQL
+ *
+ * Fornece correções sugeridas para problemas comuns em SQL:
+ * - SELECT * → colunas explícitas
+ * - DELETE/UPDATE sem WHERE → adicionar WHERE
+ * - VARCHAR sem tamanho → definir tamanho
+ */
 import { messages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
@@ -54,8 +63,9 @@ export const correctionSql = {
     descricao: 'Correções automáticas para problemas SQL',
     test: (relPath) => /\.(sql|pgsql|mysql|sqlite)$/i.test(relPath),
     aplicar: (src, relPath) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const correcoes = detectarCorrecoesSql(src, relPath);
         return correcoes.map(elem => criarOcorrencia({
             tipo: `correction-${elem.tipo}`,
@@ -67,4 +77,3 @@ export const correctionSql = {
         }));
     }
 };
-//# sourceMappingURL=correction-sql.js.map

package/dist/analysts/sql/corrections/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './correction-sql.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/sql/detectors/detector-sql-best-practices.js

@@ -1,2 +1,8 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [BUSCA] Detector de boas práticas SQL (backward compat)
+ *
+ * Re-exporta do novo detector abrangente.
+ * @deprecated Use './detector-sql.js' diretamente.
+ */
 export { detectorSql, detectorSqlBestPractices, obterDetectoresSql, registrarDetectorSql, } from './detector-sql.js';
-//# sourceMappingURL=detector-sql-best-practices.js.map

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

@@ -1,3 +1,14 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [BUSCA] Detector SQL abrangente
+ *
+ * Detecta problemas em SQL organizados em categorias:
+ * - Segurança: SQL injection, credenciais, GRANT ALL, transações
+ * - Padrões de Injeção: LIKE sem ESCAPE, ORDER BY dinâmico, LIMIT/OFFSET dinâmico
+ * - Performance: índices, funções em colunas, N+1, NOT IN, ORs múltiplos
+ * - Boas Práticas: NOT NULL, DEFAULT, AUTO_INCREMENT PK, TEXT vs VARCHAR, UNIQUE, FLOAT moeda, FK
+ * - ORM: eager loading, transações grandes
+ */
 import { messages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
@@ -22,8 +33,9 @@ export const detectorSql = {
     descricao: 'Detector SQL abrangente: segurança, injeção, performance e boas práticas',
     test: (relPath) => /\.(sql|pgsql|mysql|sqlite)$/i.test(relPath),
     aplicar: (src, relPath, _ast, _fc, _ctx) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const ocorrencias = [];
         const linhas = splitLines(src);
         const isOrm = detectarContextoOrm(src);
@@ -34,20 +46,26 @@ export const detectorSql = {
             const num = index + 1;
             const trim = linha.trim();
             const _lowerTrim = trim.toLowerCase();
+            // ── Security ────────────────────────────────────────────────────────
+            // SQL Injection via string concatenation
             if (/\s\+\s*['"`]/.test(linha) && SQL_KEYWORDS.test(linha)) {
                 adicionar('sql-injection-dynamic', 'erro', messages.DetectorSqlMensagens.sqlInjectionDynamic, messages.DetectorSqlMensagens.sqlInjectionDynamicSugestao, num);
             }
+            // Dynamic WHERE clause with + or ${}
             if (/\bwhere\b/i.test(linha) &&
                 /['"`]\s*\+/.test(linha)) {
                 adicionar('sql-dynamic-where', 'erro', messages.DetectorSqlMensagens.dynamicWhere, messages.DetectorSqlMensagens.dynamicWhereSugestao, num);
             }
+            // Password storing without hash
             if (/\b(password|passwd|senha)\b\s+(varchar|text|char|string)/i.test(linha) &&
                 !/\b(hash|bcrypt|argon2|pbkdf|scrypt)\b/i.test(linha)) {
                 adicionar('sql-password-without-hash', 'erro', messages.DetectorSqlMensagens.passwordStoring, messages.DetectorSqlMensagens.passwordStoringSugestao, num);
             }
+            // GRANT ALL PRIVILEGES
             if (/\bgrant\s+all\s+(privileges\s+)?on\b/i.test(linha)) {
                 adicionar('sql-grant-all', 'erro', messages.DetectorSqlMensagens.grantAllPrivileges, messages.DetectorSqlMensagens.grantAllPrivilegesSugestao, num);
             }
+            // Statements without transaction (multiple INSERT/UPDATE/DELETE in sequence)
             if (/^\s*(insert|update|delete)\s+/i.test(trim) &&
                 index > 0 &&
                 /^\s*(insert|update|delete)\s+/i.test(linhas[index - 1]?.trim() ?? '') &&
@@ -55,76 +73,99 @@ export const detectorSql = {
                 !src.toLowerCase().includes('commit')) {
                 adicionar('sql-without-transaction', 'aviso', messages.DetectorSqlMensagens.sqlWithoutTransaction, messages.DetectorSqlMensagens.sqlWithoutTransactionSugestao, num);
             }
+            // ── Injection Patterns ──────────────────────────────────────────────
+            // Variable interpolation in query ${} or {{ }}
             if (/\$\{.*\}\s*/.test(linha) && SQL_KEYWORDS.test(linha)) {
                 adicionar('sql-unsafe-concat', 'erro', messages.DetectorSqlMensagens.unsafeConcatInQuery, messages.DetectorSqlMensagens.unsafeConcatInQuerySugestao, num);
             }
+            // LIKE without ESCAPE
             if (/\blike\b/i.test(linha) &&
                 !/\bescape\b/i.test(linha)) {
                 adicionar('sql-like-without-escape', 'aviso', messages.DetectorSqlMensagens.likeWithoutEscape, messages.DetectorSqlMensagens.likeWithoutEscapeSugestao, num);
             }
+            // ORDER BY with dynamic column (variable/parameter)
             if (/\border\s+by\b/i.test(linha) &&
                 /\$\{|\+ |concat\(|:coluna|:col/i.test(linha)) {
                 adicionar('sql-order-by-injection', 'erro', messages.DetectorSqlMensagens.orderByInjection, messages.DetectorSqlMensagens.orderByInjectionSugestao, num);
             }
+            // LIMIT/OFFSET with dynamic values
             if (/\blimit\b|\boffset\b/i.test(linha) &&
                 /\$\{|\+ |:limite|:offset/i.test(linha)) {
                 adicionar('sql-limit-offset-injection', 'erro', messages.DetectorSqlMensagens.limitOffsetInjection, messages.DetectorSqlMensagens.limitOffsetInjectionSugestao, num);
             }
+            // ── Performance ─────────────────────────────────────────────────────
+            // Function on column in WHERE (e.g., WHERE YEAR(col) = ...)
             if (/\bwhere\b/i.test(linha) && /\b(upper|lower|year|month|day|date|cast|convert|coalesce|nullif|substr|substring|trim|ltrim|rtrim|len|length|abs|round)\s*\(\s*\w+\.?\w*\s*\)/i.test(linha)) {
                 adicionar('sql-function-on-column', 'aviso', messages.DetectorSqlMensagens.functionOnColumn, messages.DetectorSqlMensagens.functionOnColumnSugestao, num);
             }
+            // NOT IN with subquery
             if (/\bnot\s+in\s*\(/.test(linha) && /\bselect\b/i.test(linha)) {
                 adicionar('sql-not-in-subquery', 'aviso', messages.DetectorSqlMensagens.notInSubquery, messages.DetectorSqlMensagens.notInSubquerySugestao, num);
             }
-            const orCount = (linha.match(/\bor\b/gi) || []).length;
+            // Multiple OR conditions (3+)
+            const orCount = (linha.match(/\bor\b/gi) ?? []).length;
             if (orCount >= 3) {
                 adicionar('sql-multiple-or', 'info', messages.DetectorSqlMensagens.orWithMultipleConditions, messages.DetectorSqlMensagens.orWithMultipleConditionsSugestao, num);
             }
+            // JOIN without index heuristic (multiple JOINs in query)
             if (/join\s+\w+/i.test(linha)) {
                 adicionar('sql-join-without-index', 'info', messages.DetectorSqlMensagens.joinWithoutIndex, messages.DetectorSqlMensagens.joinWithoutIndexSugestao, num);
             }
+            // ── Best Practices ──────────────────────────────────────────────────
+            // Column without NOT NULL
             if (/^\s*\w+\s+(int|varchar|text|char|decimal|numeric|float|double|boolean|date|timestamp|blob|json)\b/i.test(trim) &&
                 !/\bnot\s+null\b/i.test(linha) &&
                 !/^\s*--|^\s*\/\//.test(trim)) {
                 adicionar('sql-missing-not-null', 'info', messages.DetectorSqlMensagens.missingNotNull, messages.DetectorSqlMensagens.missingNotNullSugestao, num);
             }
+            // Column with NULL default (could have explicit default)
             if (/\bdefault\s+null\b/i.test(linha) &&
                 /^\s*\w+\s+(int|varchar|text|char|decimal|numeric|float|double|boolean|date|timestamp)\b/i.test(trim)) {
                 adicionar('sql-missing-default', 'info', messages.DetectorSqlMensagens.missingDefault, messages.DetectorSqlMensagens.missingDefaultSugestao, num);
             }
+            // AUTO_INCREMENT not used as PK
             if (/\bauto_increment\b/i.test(linha) && !/\bprimary\s+key\b/i.test(linha)) {
                 adicionar('sql-auto-increment-without-pk', 'aviso', messages.DetectorSqlMensagens.autoIncrementWithoutPK, messages.DetectorSqlMensagens.autoIncrementWithoutPKSugestao, num);
             }
+            // TEXT where VARCHAR would suffice (TEXT for short columns)
             if (/\btext\b/i.test(linha) && !/^\s*(--|\/\/)/.test(trim)) {
                 adicionar('sql-text-instead-of-varchar', 'info', messages.DetectorSqlMensagens.textInsteadOfVarchar, messages.DetectorSqlMensagens.textInsteadOfVarcharSugestao, num);
             }
+            // FLOAT for currency
             if (/\bfloat\b/i.test(linha) &&
                 /(preco|price|valor|value|salario|salary|custo|cost|total|amount|money|revenue|receita)/i.test(linha)) {
                 adicionar('sql-float-for-currency', 'aviso', messages.DetectorSqlMensagens.floatForCurrency, messages.DetectorSqlMensagens.floatForCurrencySugestao, num);
             }
+            // Missing UNIQUE constraint on likely-identifier columns
             if (/\b(cpf|cnpj|email|username|login|slug|document|documento|rg|passport|uuid)\b/i.test(linha) &&
                 /^\s*\w+\s+(varchar|char|text)\b/i.test(trim) &&
                 !/\bunique\b/i.test(linha)) {
                 adicionar('sql-missing-unique', 'aviso', messages.DetectorSqlMensagens.missingUniqueConstraint, messages.DetectorSqlMensagens.missingUniqueConstraintSugestao, num);
             }
+            // Missing FOREIGN KEY (column named *_id or id_*)
             if (/\b\w+_id\b/i.test(linha) &&
                 /^\s*\w+_id\s+(int|bigint|uuid|varchar)\b/i.test(trim) &&
                 !/\bforeign\s+key\b/i.test(linha) &&
                 !/\breferences\b/i.test(linha)) {
                 adicionar('sql-missing-foreign-key', 'info', messages.DetectorSqlMensagens.missingForeignKey, messages.DetectorSqlMensagens.missingForeignKeySugestao, num);
             }
+            // ── ORM-specific ────────────────────────────────────────────────────
             if (isOrm) {
+                // Lazy load in loop (N+1) — query inside for/forEach/while
                 if (/\b(for|forEach|while)\b/i.test(linha) &&
                     /\b(find|query|select|getOne|findOne|findMany|findAll)\b/i.test(linha)) {
                     adicionar('sql-eager-loading-missing', 'erro', messages.DetectorSqlMensagens.eagerLoadingMissing, messages.DetectorSqlMensagens.eagerLoadingMissingSugestao, num);
                 }
+                // Single transaction with many operations
                 if (/\btransaction|$transaction/i.test(linha) &&
                     /(insert|create|save|update|delete|remove)/i.test(linha)) {
                     adicionar('sql-transaction-too-large', 'aviso', messages.DetectorSqlMensagens.transactionTooLarge, messages.DetectorSqlMensagens.transactionTooLargeSugestao, num);
                 }
             }
         });
+        // ── Cross-line checks ─────────────────────────────────────────────────
         const _srcLower = src.toLowerCase();
+        // Hardcoded credentials
         linhas.forEach((linha, index) => {
             const num = index + 1;
             if (/\b(password|senha|secret|key|token)\b\s*[:=]\s*['"].*['"]/i.test(linha) ||
@@ -132,11 +173,13 @@ export const detectorSql = {
                 adicionar('sql-hardcoded-credential', 'erro', messages.DetectorSqlMensagens.hardcodedCredential, messages.DetectorSqlMensagens.hardcodedCredentialSugestao, num);
             }
         });
+        // SELECT *
         linhas.forEach((linha, index) => {
             if (/\bselect\s+\*\s+from\b/i.test(linha)) {
                 adicionar('sql-select-star', 'aviso', messages.DetectorSqlMensagens.selectStar, messages.DetectorSqlMensagens.selectStarSugestao, index + 1);
             }
         });
+        // DELETE/UPDATE without WHERE
         linhas.forEach((linha, index) => {
             const num = index + 1;
             const lc = linha.trim().toLowerCase();
@@ -148,26 +191,31 @@ export const detectorSql = {
                 }
             }
         });
+        // TRUNCATE
         linhas.forEach((linha, index) => {
             if (/\btruncate\s+table\b/i.test(linha)) {
                 adicionar('sql-truncate', 'aviso', messages.DetectorSqlMensagens.truncate, messages.DetectorSqlMensagens.truncateSugestao, index + 1);
             }
         });
+        // Missing IF NOT EXISTS
         linhas.forEach((linha, index) => {
             if (/create\s+(table|procedure|view)\s+\w+/i.test(linha) &&
                 !/if\s+not\s+exists/i.test(linha)) {
                 adicionar('sql-missing-if-not-exists', 'info', messages.DetectorSqlMensagens.missingIfNotExists, messages.DetectorSqlMensagens.missingIfNotExistsSugestao, index + 1);
             }
         });
+        // VARCHAR without size
         linhas.forEach((linha, index) => {
             if (/\bvarchar\b\s*(\(|\s|$)/i.test(linha) && !/\bvarchar\(\d+\)/i.test(linha)) {
                 adicionar('sql-varchar-without-size', 'info', messages.DetectorSqlMensagens.varcharWithoutSize, messages.DetectorSqlMensagens.varcharWithoutSizeSugestao, index + 1);
             }
         });
+        // N+1 heuristic: many SELECTs in sequence
         let selectCount = 0;
         for (const linha of linhas) {
-            if (/\bselect\b/i.test(linha))
+            if (/\bselect\b/i.test(linha)) {
                 selectCount++;
+            }
         }
         if (selectCount > 5) {
             const firstSelect = linhas.findIndex(l => /\bselect\b/i.test(l));
@@ -175,6 +223,7 @@ export const detectorSql = {
                 adicionar('sql-n-plus-one', 'aviso', messages.DetectorSqlMensagens.selectNPlusOne, messages.DetectorSqlMensagens.selectNPlusOneSugestao, firstSelect + 1);
             }
         }
+        // No-index columns heuristic: columns in WHERE that look like non-PK text fields
         const whereCols = new Set();
         for (const linha of linhas) {
             const whereMatch = linha.match(/\bwhere\s+(.+)/i);
@@ -190,6 +239,7 @@ export const detectorSql = {
                 }
             }
         }
+        // Run registered plugin detectors
         for (const detector of detectoresRegistrados) {
             try {
                 const resultado = detector.testar(src, { relPath, linhas });
@@ -198,10 +248,11 @@ export const detectorSql = {
                 }
             }
             catch {
+                // Silently skip detector errors
             }
         }
         return ocorrencias;
     }
 };
+/** Backward-compat alias */
 export const detectorSqlBestPractices = detectorSql;
-//# sourceMappingURL=detector-sql.js.map

package/dist/analysts/sql/detectors/index.js

@@ -1,3 +1,3 @@
+// SPDX-License-Identifier: MIT
 export * from './detector-sql.js';
 export * from './detector-sql-best-practices.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/sql/index.js

@@ -1,5 +1,10 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [BUSCA] Analistas de SQL
+ *
+ * Analisa arquivos SQL em busca de injeções, performance ruim e comandos perigosos.
+ */
 export * from './analysts/analyst-sql.js';
 export * from './corrections/index.js';
 export * from './detectors/index.js';
 export * from './scorers/index.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/sql/scorers/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './scorer-sql.js';
-//# sourceMappingURL=index.js.map