codesentry 0.1.8 → 0.1.10

package/README.md

@@ -1,9 +1,19 @@
+<p align="center">
+  <img src="docs/assets/logo.png" alt="Logo do CodeSentry" width="640">
+</p>
+
 # CodeSentry
 
 CLI de verificação de vulnerabilidades e qualidade de código. O scanner
 combina regras próprias para JavaScript/TypeScript e o ruleset OWASP do
 Semgrep CE para as linguagens suportadas por ele.
 
+- 🔎 **Dois motores num só comando** — regras próprias em TS/JS + Semgrep CE (OWASP Top 10) para dezenas de outras linguagens.
+- 📦 **Uma instalação, zero fricção** — `npm install -g codesentry` e pronto: sem Python, Docker, Semgrep ou conta em lugar nenhum.
+- 🔌 **100% offline depois de instalado** — nunca consulta a Semgrep Registry nem envia métricas.
+- 🪟🐧 **Windows e Linux nativamente** — sem WSL, sem container.
+- 📊 **Console, JSON ou Markdown** — saída pronta tanto para ler no terminal quanto para plugar em CI.
+
 ## O que o CodeSentry faz
 
 Rodando `codesentry scan` num projeto, dois motores de análise trabalham
@@ -25,6 +35,22 @@ motor encontrou o problema (prefixo `semgrep/` para achados do Semgrep).
 Saídas disponíveis: tabela no console, JSON (`--json`) e, quando há mais
 de 20 problemas, um relatório Markdown detalhado é gerado automaticamente.
 
+Exemplo de saída no console:
+
+```text
+❯ codesentry scan .
+✔ Scanning files...
+┌──────────┬──────────────────────┬─────────────────┬──────┬──────────────────────────────────────────┐
+│ Severity │ Rule                 │ File             │ Line │ Message                                    │
+├──────────┼──────────────────────┼─────────────────┼──────┼──────────────────────────────────────────┤
+│ high     │ no-hardcoded-secret  │ src/config.ts    │ 12   │ Possível segredo hardcoded na variável...  │
+│ high     │ semgrep/...shell-true│ scripts/run.py   │ 8    │ subprocess com shell=True é perigoso...    │
+│ medium   │ jwt-no-expiration    │ src/auth.ts      │ 34   │ Token JWT assinado sem "expiresIn"...      │
+└──────────┴──────────────────────┴─────────────────┴──────┴──────────────────────────────────────────┘
+
+3 problema(s) encontrado(s) em 87 arquivo(s) (4213ms). CodeSentry: 87 JS/TS; Semgrep: 64 arquivo(s).
+```
+
 ## Como funciona por baixo dos panos
 
 O ponto central do design é **zero fricção de instalação**: o usuário final
@@ -42,20 +68,43 @@ O racional completo está na [ADR 0004](docs/adr/0004-bundled-semgrep-runtime.md
 
 ## Instalação
 
-Em uma release publicada, basta uma instalação:
+Pré-requisito único: [Node.js](https://nodejs.org) 22.12 ou mais recente
+(`node --version` para conferir). Nenhum outro requisito — não precisa
+instalar Python, Docker, Semgrep, criar conta ou autenticar em nada.
+
+### Windows
+
+No PowerShell ou no Prompt de Comando (não precisa de WSL):
+
+```powershell
+npm install -g codesentry
+codesentry scan .
+```
+
+### Linux
 
 ```bash
 npm install -g codesentry
+codesentry scan .
 ```
 
-O pacote compatível de Semgrep CE e Python portátil é instalado como
-dependência opcional automaticamente. Não é necessário instalar Python,
-Docker, Semgrep, criar conta ou autenticar em um site.
+Em ambos os casos, o `npm install` já resolve automaticamente o pacote de
+runtime compatível com a sua plataforma (Semgrep CE + Python portátil) como
+dependência opcional — é isso que faz `codesentry scan` funcionar com
+cobertura OWASP completa sem nenhuma instalação manual. Plataformas com
+runtime publicado hoje: Linux x64 e Windows x64. Os pacotes têm dezenas de
+MB porque incluem esse runtime embutido; essa é a troca para o scan
+funcionar 100% offline depois de instalado.
+
+Se `codesentry` não for encontrado no terminal depois de instalado
+globalmente, feche e reabra o terminal (ou rode `npx codesentry scan .`) —
+alguns terminais não recarregam o PATH do npm automaticamente na mesma
+sessão.
 
-As plataformas inicialmente suportadas são Linux x64 e Windows x64. Os
-pacotes têm tamanho de dezenas de MB porque incluem o runtime; essa é a troca
-para o scan funcionar offline após a instalação. Durante o desenvolvimento,
-use `npm link`:
+### A partir do código-fonte (desenvolvimento)
+
+Para rodar a partir do repositório clonado, em vez do pacote publicado, use
+`npm link`:
 
 ```bash
 git clone git@github.com:Ivan-ReisDev/code-sentry.git
@@ -68,6 +117,16 @@ npm link
 Depois disso, o comando `codesentry` fica disponível em qualquer
 diretório do seu terminal.
 
+> **Atenção:** `npx codesentry` rodado de dentro deste repositório clonado
+> executa o `dist/index.js` local (o `package.json` daqui se chama
+> `codesentry`, e o `npx` prioriza isso sobre a instalação global/publicada).
+> O workspace de desenvolvimento sempre tem o ruleset do Semgrep vazio por
+> design (populado só via `npm run prepare:owasp-rules` ou durante a release —
+> ver [ADR 0004](docs/adr/0004-bundled-semgrep-runtime.md)), então o scan
+> roda sem erro mas sempre reporta zero arquivos analisados pelo Semgrep.
+> Para testar o pacote publicado de verdade, rode `codesentry scan` (sem
+> `npx`) fora deste diretório.
+
 ## Uso
 
 ### `codesentry scan [path]`
@@ -99,31 +158,47 @@ explicitamente em vez de declarar uma análise parcial como completa.
 
 ### `codesentry rules`
 
-Lista as regras de análise disponíveis.
+Lista as regras de análise disponíveis (id e descrição de cada uma).
 
 ```bash
 codesentry rules
 ```
 
-### `codesentry long-functions [path]`
+### `codesentry help`
 
-Analisa um diretório (padrão: diretório atual) em busca apenas de
-funções com mais de 30 linhas (severidade `low`). Essa mesma regra
-também roda automaticamente como parte do `codesentry scan`.
+Lista **todos** os comandos disponíveis, sempre atualizada — inclui tanto
+os comandos gerais quanto os individuais listados a seguir.
 
 ```bash
-codesentry long-functions .
-codesentry long-functions ./src --json
+codesentry help
 ```
 
-### `codesentry help`
+### Comandos individuais por regra
 
-Lista os comandos disponíveis.
+Cada regra nativa também tem um comando próprio, que roda **só ela** sobre
+um diretório — útil para focar em um tipo de problema específico sem esperar
+o scan completo (e sem o Semgrep, que só roda como parte de `scan`). Todos
+seguem o mesmo formato:
 
 ```bash
-codesentry help
+codesentry <comando> [path] [--json]
+```
+
+Alguns exemplos:
+
+```bash
+codesentry long-functions .          # funções com mais de 30 linhas
+codesentry no-eval ./src             # uso de eval()
+codesentry xss ./src --json          # possíveis XSS (innerHTML, document.write, dangerouslySetInnerHTML)
+codesentry unsafe-sql ./src          # SQL injection por concatenação
+codesentry command-injection ./src   # child_process com entrada não sanitizada
+codesentry weak-hash-algorithm ./src # uso de MD5/SHA-1 para hashing sensível
+codesentry dependency-audit .        # `npm audit` das dependências do projeto
 ```
 
+A lista completa (30+ comandos, um por regra) sai de `codesentry help` —
+mantê-la sempre em sincronia aqui manualmente não seria viável.
+
 ### `codesentry init`
 
 Assistente interativo para configurar o CodeSentry no projeto atual.

package/dist/index.js

@@ -36,38 +36,33 @@ var visitSourceNodes = (node, visitor, parent) => {
 var EXEC_METHOD_NAMES = /* @__PURE__ */ new Set(["exec", "execSync"]);
 var CHILD_PROCESS_MODULE_NAMES = /* @__PURE__ */ new Set(["child_process", "node:child_process"]);
 var isChildProcessModuleSpecifier = (node) => node?.type === "StringLiteral" && CHILD_PROCESS_MODULE_NAMES.has(node.value);
+var localName = (specifier) => {
+  const local = specifier.local;
+  return local?.type === "Identifier" ? local.name : void 0;
+};
+var isExecImport = (specifier) => {
+  const imported = specifier.imported;
+  return specifier.type === "ImportSpecifier" && imported?.type === "Identifier" && EXEC_METHOD_NAMES.has(imported.name);
+};
+var isNamespaceImport = (specifier) => specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier";
+var collectImportBinding = (specifier, bindings) => {
+  const name = localName(specifier);
+  if (!name) {
+    return;
+  }
+  const bindingSet = isExecImport(specifier) ? bindings.directCalls : isNamespaceImport(specifier) ? bindings.namespaces : void 0;
+  bindingSet?.add(name);
+};
 var collectFromImportDeclaration = (node, bindings) => {
   if (!isChildProcessModuleSpecifier(node.source)) {
     return;
   }
   for (const specifier of node.specifiers ?? []) {
-    const local = specifier.local;
-    if (local?.type !== "Identifier") {
-      continue;
-    }
-    if (specifier.type === "ImportSpecifier") {
-      const imported = specifier.imported;
-      if (imported?.type === "Identifier" && EXEC_METHOD_NAMES.has(imported.name)) {
-        bindings.directCalls.add(local.name);
-      }
-    } else if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
-      bindings.namespaces.add(local.name);
-    }
+    collectImportBinding(specifier, bindings);
   }
 };
 var isRequireCall = (node) => node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "require" && isChildProcessModuleSpecifier(node.arguments?.[0]);
-var collectFromVariableDeclarator = (node, bindings) => {
-  if (!isRequireCall(node.init)) {
-    return;
-  }
-  const id = node.id;
-  if (id?.type === "Identifier") {
-    bindings.namespaces.add(id.name);
-    return;
-  }
-  if (id?.type !== "ObjectPattern") {
-    return;
-  }
+var collectDirectCallBindings = (id, bindings) => {
   for (const property of id.properties ?? []) {
     const key = property.key;
     const value = property.value;
@@ -76,6 +71,16 @@ var collectFromVariableDeclarator = (node, bindings) => {
     }
   }
 };
+var collectFromVariableDeclarator = (node, bindings) => {
+  if (!isRequireCall(node.init)) {
+    return;
+  }
+  const id = node.id;
+  const namespaceName = id?.type === "Identifier" ? id.name : void 0;
+  const destructuredBindings = id?.type === "ObjectPattern" ? id : void 0;
+  namespaceName && bindings.namespaces.add(namespaceName);
+  destructuredBindings && collectDirectCallBindings(destructuredBindings, bindings);
+};
 var collectChildProcessBindings = (sourceFile) => {
   const bindings = { directCalls: /* @__PURE__ */ new Set(), namespaces: /* @__PURE__ */ new Set() };
   visitSourceNodes(sourceFile, (node) => {
@@ -170,17 +175,12 @@ var SEVERITY_COLOR = {
   high: (text2) => chalk.red(text2),
   critical: (text2) => chalk.bgRed.white(text2)
 };
-var printConsoleReport = (result) => {
-  const coverage = result.engines?.semgrep === void 0 ? "" : ` CodeSentry: ${result.engines.codesentry ?? result.scannedFiles} JS/TS; Semgrep: ${result.engines.semgrep} arquivo(s).`;
-  if (result.findings.length === 0) {
-    console.log(
-      chalk.green(`Nenhum problema encontrado (${result.scannedFiles} arquivos analisados).${coverage}`)
-    );
-    return;
-  }
-  const table = new Table({
-    head: ["Severity", "Rule", "File", "Line", "Message"]
-  });
+var coverageText = (result) => result.engines?.semgrep === void 0 ? "" : ` CodeSentry: ${result.engines.codesentry ?? result.scannedFiles} JS/TS; Semgrep: ${result.engines.semgrep} arquivo(s).`;
+var printCleanReport = (result, coverage) => {
+  console.log(chalk.green(`Nenhum problema encontrado (${result.scannedFiles} arquivos analisados).${coverage}`));
+};
+var findingsTable = (result) => {
+  const table = new Table({ head: ["Severity", "Rule", "File", "Line", "Message"] });
   for (const finding of result.findings) {
     const colorize = SEVERITY_COLOR[finding.severity];
     table.push([
@@ -191,7 +191,10 @@ var printConsoleReport = (result) => {
       finding.message
     ]);
   }
-  console.log(table.toString());
+  return table;
+};
+var printFindingsReport = (result, coverage) => {
+  console.log(findingsTable(result).toString());
   console.log(
     chalk.bold(
       `
@@ -199,6 +202,14 @@ ${result.findings.length} problema(s) encontrado(s) em ${result.scannedFiles} ar
     )
   );
 };
+var printConsoleReport = (result) => {
+  const coverage = coverageText(result);
+  if (result.findings.length === 0) {
+    printCleanReport(result, coverage);
+    return;
+  }
+  printFindingsReport(result, coverage);
+};
 
 // src/reporters/json.reporter.ts
 var toJsonReport = (result) => {
@@ -207,12 +218,13 @@ var toJsonReport = (result) => {
 
 // src/reporters/markdown.reporter.ts
 var SEVERITY_ORDER = ["critical", "high", "medium", "low"];
-var SEVERITY_LABEL = {
-  critical: "Critical",
-  high: "High",
-  medium: "Medium",
-  low: "Low"
-};
+var SEVERITY_LABEL = /* @__PURE__ */ new Map([
+  ["critical", "Critical"],
+  ["high", "High"],
+  ["medium", "Medium"],
+  ["low", "Low"]
+]);
+var severityLabel = (severity) => SEVERITY_LABEL.get(severity) ?? severity;
 var escapeCell = (text2) => text2.replaceAll("|", "\\|");
 var groupBy = (items, keyOf) => {
   const map = /* @__PURE__ */ new Map();
@@ -222,7 +234,7 @@ var groupBy = (items, keyOf) => {
   }
   return map;
 };
-var findingsTable = (findings) => {
+var findingsTable2 = (findings) => {
   const sorted = [...findings].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
   const lines = ["| Arquivo | Linha | Mensagem |", "| --- | --- | --- |"];
   for (const f of sorted) {
@@ -231,11 +243,11 @@ var findingsTable = (findings) => {
   return lines;
 };
 var severitySection = (severity, findings) => {
-  const lines = [`## ${SEVERITY_LABEL[severity]} (${findings.length})`, ""];
+  const lines = [`## ${severityLabel(severity)} (${findings.length})`, ""];
   const byRule = groupBy(findings, (f) => f.ruleId);
   for (const ruleId of [...byRule.keys()].sort()) {
     const ruleFindings = byRule.get(ruleId) ?? [];
-    lines.push(`### ${ruleId} (${ruleFindings.length})`, "", ...findingsTable(ruleFindings), "");
+    lines.push(`### ${ruleId} (${ruleFindings.length})`, "", ...findingsTable2(ruleFindings), "");
   }
   return lines;
 };
@@ -254,7 +266,7 @@ var reportHeader = (result, generatedAt) => [
 var summaryTable = (bySeverity) => {
   const lines = ["## Resumo por severidade", "", "| Severidade | Quantidade |", "| --- | --- |"];
   for (const severity of SEVERITY_ORDER) {
-    lines.push(`| ${SEVERITY_LABEL[severity]} | ${(bySeverity.get(severity) ?? []).length} |`);
+    lines.push(`| ${severityLabel(severity)} | ${(bySeverity.get(severity) ?? []).length} |`);
   }
   lines.push("");
   return lines;
@@ -295,20 +307,21 @@ import { availableParallelism } from "os";
 import { readdir } from "fs/promises";
 import { join } from "path";
 var SCANNABLE_EXTENSIONS = [".js", ".ts", ".jsx", ".tsx"];
-var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next"]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "tests"]);
 var isScannable = (fileName) => SCANNABLE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+var filesFromEntry = async (currentDir, entry) => {
+  if (entry.isDirectory()) {
+    return IGNORED_DIRS.has(entry.name) ? [] : walk(join(currentDir, entry.name));
+  }
+  return entry.isFile() && isScannable(entry.name) ? [join(currentDir, entry.name)] : [];
+};
 var walk = async (currentDir) => {
-  const entries = await readdir(currentDir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (IGNORED_DIRS.has(entry.name)) continue;
-      files.push(...await walk(join(currentDir, entry.name)));
-    } else if (entry.isFile() && isScannable(entry.name)) {
-      files.push(join(currentDir, entry.name));
-    }
+  try {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    return (await Promise.all(entries.map((entry) => filesFromEntry(currentDir, entry)))).flat();
+  } catch (error) {
+    throw new Error(`N\xE3o foi poss\xEDvel listar os arquivos em "${currentDir}".`, { cause: error });
   }
-  return files;
 };
 var findFiles = async (targetDir) => {
   try {
@@ -342,21 +355,30 @@ var readFileContent = async (filePath) => {
     throw new Error(`N\xE3o foi poss\xEDvel ler o arquivo "${filePath}".`, { cause: error });
   }
 };
+var checkRule = (rule, filePath, content) => {
+  try {
+    return { findings: rule.check(filePath, content) };
+  } catch (error) {
+    return { findings: [], error };
+  }
+};
 var scanFile = async (filePath, rules) => {
-  const content = await readFileContent(filePath);
-  const findings = [];
-  let hasParseError = false;
-  for (const rule of rules) {
-    try {
-      findings.push(...rule.check(filePath, content));
-    } catch (error) {
-      if (!hasParseError) {
-        findings.push(parseErrorFinding(filePath, error));
+  try {
+    const content = await readFileContent(filePath);
+    const findings = [];
+    let hasParseError = false;
+    for (const rule of rules) {
+      const result = checkRule(rule, filePath, content);
+      findings.push(...result.findings);
+      if (result.error && !hasParseError) {
+        findings.push(parseErrorFinding(filePath, result.error));
         hasParseError = true;
       }
     }
+    return findings;
+  } catch (error) {
+    throw new Error(`N\xE3o foi poss\xEDvel analisar o arquivo "${filePath}".`, { cause: error });
   }
-  return findings;
 };
 var runScan = async (targetDir, rules, concurrency = DEFAULT_SCAN_CONCURRENCY) => {
   try {
@@ -460,50 +482,65 @@ var mapSemgrepReportToFindings = (report) => report.results.map((finding) => ({
   severity: SEMGREP_SEVERITIES[finding.extra.severity] ?? "medium"
 }));
 var outputFromError = (error) => typeof error.stdout === "string" ? error.stdout : void 0;
-var runBundledSemgrep = async (targetDir, runtime = resolveBundledSemgrepRuntime(), ruleset = resolveBundledSemgrepRuleset(), execute = execFileAsync) => {
-  const startedAt = Date.now();
-  const args = [
-    "scan",
-    "--config",
-    ruleset,
-    "--metrics=off",
-    "--json",
-    "--quiet",
-    "--exclude",
-    "node_modules",
-    "--exclude",
-    ".git",
-    "--exclude",
-    "dist",
-    "--exclude",
-    ".next",
-    // Não repetir targetDir aqui: o processo já roda com cwd = targetDir
-    // (abaixo), então o alvo relativo a esse cwd é o diretório atual.
-    "."
-  ];
-  let stdout;
-  const SYSTEM_PATH_FALLBACK = process.platform === "win32" ? "C:\\Windows\\System32;C:\\Windows" : "/usr/local/bin:/usr/bin:/bin";
-  const env = {
+var semgrepArgs = (ruleset) => [
+  "scan",
+  "--config",
+  ruleset,
+  "--metrics=off",
+  "--json",
+  "--quiet",
+  "--exclude",
+  "node_modules",
+  "--exclude",
+  ".git",
+  "--exclude",
+  "dist",
+  "--exclude",
+  ".next",
+  "--exclude",
+  "tests",
+  // Não repetir targetDir aqui: o processo já roda com cwd = targetDir,
+  // então o alvo relativo a esse cwd é o diretório atual.
+  "."
+];
+var semgrepEnvironment = (runtime) => {
+  const semgrepDir = dirname2(runtime.semgrep);
+  const systemPathFallback = process.platform === "win32" ? "C:\\Windows\\System32;C:\\Windows" : "/usr/local/bin:/usr/bin:/bin";
+  return {
     ...process.env,
-    PATH: `${dirname2(runtime.semgrep)}${delimiter}${process.env.PATH ?? ""}${delimiter}${SYSTEM_PATH_FALLBACK}`
+    PATH: `${semgrepDir}${delimiter}${dirname2(semgrepDir)}${delimiter}${process.env.PATH ?? ""}${delimiter}${systemPathFallback}`
   };
+};
+var executeSemgrep = async (targetDir, runtime, ruleset, execute) => {
   try {
-    ({ stdout } = await execute(runtime.semgrep, args, { cwd: targetDir, maxBuffer: 20 * 1024 * 1024, env }));
+    const { stdout } = await execute(runtime.semgrep, semgrepArgs(ruleset), {
+      cwd: targetDir,
+      maxBuffer: 20 * 1024 * 1024,
+      env: semgrepEnvironment(runtime)
+    });
+    return stdout;
   } catch (error) {
     const output = outputFromError(error);
-    if (!output) {
-      throw new Error("N\xE3o foi poss\xEDvel executar o Semgrep embutido.", { cause: error });
+    if (output) {
+      return output;
     }
-    stdout = output;
+    throw new Error("N\xE3o foi poss\xEDvel executar o Semgrep embutido.", { cause: error });
+  }
+};
+var runBundledSemgrep = async (targetDir, runtime = resolveBundledSemgrepRuntime(), ruleset = resolveBundledSemgrepRuleset(), execute = execFileAsync) => {
+  const startedAt = Date.now();
+  try {
+    const report = parseSemgrepReport(await executeSemgrep(targetDir, runtime, ruleset, execute));
+    const scannedFiles = report.paths?.scanned.length ?? 0;
+    return {
+      scannedFiles,
+      findings: mapSemgrepReportToFindings(report),
+      durationMs: Date.now() - startedAt,
+      engines: { semgrep: scannedFiles }
+    };
+  } catch (error) {
+    throw new Error("N\xE3o foi poss\xEDvel processar o resultado do Semgrep.", { cause: error });
   }
-  const report = parseSemgrepReport(stdout);
-  const scannedFiles = report.paths?.scanned.length ?? 0;
-  return {
-    scannedFiles,
-    findings: mapSemgrepReportToFindings(report),
-    durationMs: Date.now() - startedAt,
-    engines: { semgrep: scannedFiles }
-  };
 };
 
 // src/commands/scan/report-filename.ts
@@ -539,22 +576,28 @@ Relat\xF3rio detalhado gerado em: ${filePath}`));
     console.error(chalk2.red(`N\xE3o foi poss\xEDvel gerar o relat\xF3rio Markdown: ${errorMessage2(error)}`));
   }
 };
+var runScanEngines = async (path, rules, options) => {
+  try {
+    const nativeResult = await runScan(path, rules, options.concurrency);
+    if (!options.semgrep) {
+      return nativeResult;
+    }
+    const semgrepResult = await runBundledSemgrep(path, void 0, options.config);
+    return mergeScanResults(nativeResult, semgrepResult);
+  } catch (error) {
+    throw new Error(`Falha durante a an\xE1lise: ${errorMessage2(error)}`, { cause: error });
+  }
+};
 var createScanTasks = (path, rules, taskTitle, options, onResult) => new Listr([
   {
     title: taskTitle,
-    task: () => runScan(path, rules, options.concurrency).then((nativeResult) => {
-      if (!options.semgrep) {
-        onResult(nativeResult);
-        return void 0;
+    task: async () => {
+      try {
+        onResult(await runScanEngines(path, rules, options));
+      } catch (error) {
+        throw error;
       }
-      return runBundledSemgrep(path, void 0, options.config).then((semgrepResult) => {
-        onResult(mergeScanResults(nativeResult, semgrepResult));
-      });
-    }).catch((error) => {
-      throw new Error(`Falha durante a an\xE1lise: ${errorMessage2(error)}`, {
-        cause: error
-      });
-    })
+    }
   }
 ]);
 var scanAndReport = async (path, rules, taskTitle, options) => {
@@ -883,14 +926,14 @@ var nodeName = (node) => {
   }
   return nameValue(node) ?? literalValue(node) ?? nodeName(node.id);
 };
-var PARENT_NAME_KEYS = {
-  VariableDeclarator: "id",
-  ObjectProperty: "key",
-  AssignmentExpression: "left"
-};
+var PARENT_NAME_READERS = /* @__PURE__ */ new Map([
+  ["VariableDeclarator", (parent) => parent.id],
+  ["ObjectProperty", (parent) => parent.key],
+  ["AssignmentExpression", (parent) => parent.left]
+]);
 var parentFunctionName = (parent) => {
-  const nameKey = parent ? PARENT_NAME_KEYS[parent.type] : void 0;
-  return nameKey ? nodeName(parent?.[nameKey]) : void 0;
+  const readName = parent ? PARENT_NAME_READERS.get(parent.type) : void 0;
+  return readName && parent ? nodeName(readName(parent)) : void 0;
 };
 var isConstructor = (node) => {
   return node.type === "ClassMethod" && node.kind === "constructor";
@@ -1072,20 +1115,11 @@ var calleeName = (callee) => {
   return void 0;
 };
 var isDateNowOrGetTimeCall = (node) => {
-  if (node.type !== "CallExpression") {
-    return false;
-  }
   const callee = node.callee;
-  if (callee?.type !== "MemberExpression") {
-    return false;
-  }
-  const property = callee.property;
+  const property = callee?.property;
   const propertyName = property?.type === "Identifier" ? property.name : void 0;
-  if (propertyName === "getTime") {
-    return true;
-  }
-  const object = callee.object;
-  return object?.type === "Identifier" && object.name === "Date" && propertyName === "now";
+  const object = callee?.object;
+  return node.type === "CallExpression" && callee?.type === "MemberExpression" && (propertyName === "getTime" || object?.type === "Identifier" && object.name === "Date" && propertyName === "now");
 };
 var TIMESTAMP_NAME_PATTERN = /timestamp|^now$/i;
 var containsPredictableTimestamp = (node) => {
@@ -1207,13 +1241,12 @@ var analyzeFile = (sourceFile) => {
     hasSignatureVerification: false
   };
   visitSourceNodes(sourceFile, (node) => {
-    if (isBase64DecodeCall(node) && node.loc) {
-      analysis.base64DecodeLines.push(node.loc.start.line);
-    } else if (isJsonParseCall(node)) {
-      analysis.hasJsonParse = true;
-    } else if (isSignatureVerificationCall(node)) {
-      analysis.hasSignatureVerification = true;
+    const base64DecodeLine = isBase64DecodeCall(node) ? node.loc?.start.line : void 0;
+    if (base64DecodeLine !== void 0) {
+      analysis.base64DecodeLines.push(base64DecodeLine);
     }
+    analysis.hasJsonParse ||= isJsonParseCall(node);
+    analysis.hasSignatureVerification ||= isSignatureVerificationCall(node);
   });
   return analysis;
 };
@@ -1241,14 +1274,14 @@ var jwtDecodeWithoutVerifyRule = {
 
 // src/commands/jwt-decode-without-verify/jwt-decode-without-verify.command.ts
 var registerJwtDecodeWithoutVerifyCommand = (program) => {
-  program.command("jwt-decode-without-verify").description("Detecta decodifica\xE7\xE3o manual de um token (base64 + JSON.parse) sem verificar a assinatura").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(async (path, options) => {
-    await scanAndReport(
+  program.command("jwt-decode-without-verify").description("Detecta decodifica\xE7\xE3o manual de um token (base64 + JSON.parse) sem verificar a assinatura").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(
+    (path, options) => scanAndReport(
       path,
       [jwtDecodeWithoutVerifyRule],
       "Checking JWT decode without verification...",
       options
-    );
-  });
+    )
+  );
 };
 
 // src/rules/jwt-no-expiration.rule.ts
@@ -1609,9 +1642,9 @@ var publicEnvVarSecretRule = {
 
 // src/commands/public-env-var-secret/public-env-var-secret.command.ts
 var registerPublicEnvVarSecretCommand = (program) => {
-  program.command("public-env-var-secret").description("Detecta uma vari\xE1vel de ambiente p\xFAblica (NEXT_PUBLIC_/VITE_/REACT_APP_) com nome de segredo").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(async (path, options) => {
-    await scanAndReport(path, [publicEnvVarSecretRule], "Checking public env var secrets...", options);
-  });
+  program.command("public-env-var-secret").description("Detecta uma vari\xE1vel de ambiente p\xFAblica (NEXT_PUBLIC_/VITE_/REACT_APP_) com nome de segredo").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(
+    (path, options) => scanAndReport(path, [publicEnvVarSecretRule], "Checking public env var secrets...", options)
+  );
 };
 
 // src/commands/rules/rules.command.ts
@@ -1759,15 +1792,15 @@ var chainReachesCatch = (thenCall, ancestors) => {
   let currentCall = thenCall;
   let i = 0;
   while (i < ancestors.length) {
-    const member = ancestors[i];
-    const nextCall = ancestors[i + 1];
-    const isChainMember = member?.type === "MemberExpression" && member.object === currentCall && isCallOf(nextCall, member);
+    const member = ancestors.at(i);
+    const nextCall = ancestors.at(i + 1);
+    const isChainMember = member !== void 0 && member.type === "MemberExpression" && member.object === currentCall && isCallOf(nextCall, member);
     const methodName = isChainMember ? memberPropertyName(member) : void 0;
     const continuesChain = methodName === "then" || methodName === "finally";
     if (methodName === "catch") {
       return true;
     }
-    if (!continuesChain) {
+    if (!nextCall || !continuesChain) {
       return false;
     }
     currentCall = nextCall;
@@ -1863,11 +1896,14 @@ var RULES = {
   "security/detect-new-buffer": "error"
 };
 var PLUGINS = { security: securityPlugin };
+var suppressionMarker = (ruleId) => `codesentry-disable-next-line ${ruleId}`;
+var isSuppressed = (contentLines, finding) => contentLines.at(finding.line - 2)?.includes(suppressionMarker(finding.ruleId)) ?? false;
 var securityLintRule = {
   id: "security-lint",
   description: "Detecta padr\xF5es de seguran\xE7a gen\xE9ricos (object injection, regex n\xE3o literal, fs n\xE3o literal, etc.) via eslint-plugin-security",
   check(filePath, content) {
-    return runEslintRules(filePath, content, RULES, PLUGINS).map((finding) => ({
+    const contentLines = content.split("\n");
+    return runEslintRules(filePath, content, RULES, PLUGINS).filter((finding) => !isSuppressed(contentLines, finding)).map((finding) => ({
       ruleId: finding.ruleId,
       message: `Padr\xE3o inseguro detectado (${finding.ruleId}): ${finding.message}`,
       file: filePath,
@@ -1905,14 +1941,9 @@ var propertyKeyName = (property) => {
 var argumentContainsSensitiveData = (argument) => {
   let found = false;
   visitSourceNodes(argument, (node) => {
-    if (node.type === "Identifier" && SENSITIVE_NAME_PATTERN2.test(node.name)) {
-      found = true;
-    } else if (node.type === "ObjectProperty") {
-      const keyName = propertyKeyName(node);
-      if (keyName && SENSITIVE_NAME_PATTERN2.test(keyName)) {
-        found = true;
-      }
-    }
+    const isSensitiveIdentifier = node.type === "Identifier" && SENSITIVE_NAME_PATTERN2.test(node.name);
+    const keyName = node.type === "ObjectProperty" ? propertyKeyName(node) : void 0;
+    found ||= isSensitiveIdentifier || keyName !== void 0 && SENSITIVE_NAME_PATTERN2.test(keyName);
   });
   return found;
 };
@@ -2197,29 +2228,18 @@ var RULES2 = {
   "no-unsanitized/method": "error"
 };
 var PLUGINS2 = { "no-unsanitized": noUnsanitizedPlugin };
+var isHtmlProperty = (property) => {
+  const key = property.key;
+  return key?.type === "Identifier" && key.name === "__html";
+};
 var isDangerouslySetInnerHtmlWithDynamicValue = (node) => {
-  if (node.type !== "JSXAttribute") {
-    return false;
-  }
   const name = node.name;
-  if (name?.type !== "JSXIdentifier" || name.name !== "dangerouslySetInnerHTML") {
-    return false;
-  }
   const value = node.value;
-  if (value?.type !== "JSXExpressionContainer") {
-    return false;
-  }
-  const expression = value.expression;
-  if (expression?.type !== "ObjectExpression") {
-    return false;
-  }
-  const properties = expression.properties;
-  const htmlProperty = properties?.find((property) => {
-    const key = property.key;
-    return key?.type === "Identifier" && key.name === "__html";
-  });
+  const expression = value?.expression;
+  const properties = expression?.properties;
+  const htmlProperty = properties?.find(isHtmlProperty);
   const htmlValue = htmlProperty?.value;
-  return htmlValue !== void 0 && htmlValue.type !== "StringLiteral";
+  return node.type === "JSXAttribute" && name?.type === "JSXIdentifier" && name.name === "dangerouslySetInnerHTML" && value?.type === "JSXExpressionContainer" && expression?.type === "ObjectExpression" && htmlValue !== void 0 && htmlValue.type !== "StringLiteral";
 };
 var findDangerouslySetInnerHtmlFindings = (filePath, content) => {
   const findings = [];
@@ -2272,19 +2292,10 @@ var hasRiskyOptionEnabled = (options) => {
   }) ?? false;
 };
 var isUnsafeXmlParseCall = (node) => {
-  if (node.type !== "CallExpression") {
-    return false;
-  }
   const callee = node.callee;
-  if (callee?.type !== "MemberExpression") {
-    return false;
-  }
-  const property = callee.property;
-  if (property?.type !== "Identifier" || !XML_PARSE_METHOD_NAMES.has(property.name)) {
-    return false;
-  }
+  const property = callee?.property;
   const args = node.arguments;
-  return hasRiskyOptionEnabled(args?.[1]);
+  return node.type === "CallExpression" && callee?.type === "MemberExpression" && property?.type === "Identifier" && XML_PARSE_METHOD_NAMES.has(property.name) && hasRiskyOptionEnabled(args?.[1]);
 };
 var findUnsafeXmlParsingLines = (filePath, content) => {
   const lines = /* @__PURE__ */ new Set();
@@ -2385,9 +2396,9 @@ var registerSecurityLintCommand = (program) => {
 
 // src/commands/sensitive-data-in-logs/sensitive-data-in-logs.command.ts
 var registerSensitiveDataInLogsCommand = (program) => {
-  program.command("sensitive-data-in-logs").description("Detecta senhas/segredos/tokens sendo passados para chamadas de log").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(async (path, options) => {
-    await scanAndReport(path, [sensitiveDataInLogsRule], "Checking sensitive data in logs...", options);
-  });
+  program.command("sensitive-data-in-logs").description("Detecta senhas/segredos/tokens sendo passados para chamadas de log").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(
+    (path, options) => scanAndReport(path, [sensitiveDataInLogsRule], "Checking sensitive data in logs...", options)
+  );
 };
 
 // src/commands/tls-validation-disabled/tls-validation-disabled.command.ts
@@ -2462,9 +2473,9 @@ var registerWeakHashAlgorithmCommand = (program) => {
 var registerWeakSecretFallbackCommand = (program) => {
   program.command("weak-secret-fallback").description(
     "Detecta uma vari\xE1vel de ambiente de segredo/chave com um valor hardcoded como fallback (|| ou ??)"
-  ).argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(async (path, options) => {
-    await scanAndReport(path, [weakSecretFallbackRule], "Checking weak secret fallbacks...", options);
-  });
+  ).argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(
+    (path, options) => scanAndReport(path, [weakSecretFallbackRule], "Checking weak secret fallbacks...", options)
+  );
 };
 
 // src/commands/xss/xss.command.ts
@@ -2476,9 +2487,9 @@ var registerXssCommand = (program) => {
 
 // src/commands/xxe-unsafe-xml-parsing/xxe-unsafe-xml-parsing.command.ts
 var registerXxeUnsafeXmlParsingCommand = (program) => {
-  program.command("xxe-unsafe-xml-parsing").description("Detecta parsing de XML com noent/dtdload habilitados (risco de XXE)").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(async (path, options) => {
-    await scanAndReport(path, [xxeUnsafeXmlParsingRule], "Checking unsafe XML parsing...", options);
-  });
+  program.command("xxe-unsafe-xml-parsing").description("Detecta parsing de XML com noent/dtdload habilitados (risco de XXE)").argument("[path]", "diret\xF3rio a ser analisado", ".").option("--json", "exibe o resultado em JSON").action(
+    (path, options) => scanAndReport(path, [xxeUnsafeXmlParsingRule], "Checking unsafe XML parsing...", options)
+  );
 };
 
 // src/cli.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesentry",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "workspaces": [
     "packages/semgrep-rules"
   ],
@@ -48,7 +48,7 @@
     "@clack/prompts": "^1.7.0",
     "chalk": "^6.0.0",
     "cli-table3": "^0.6.5",
-    "codesentry-semgrep-rules": "0.1.8",
+    "codesentry-semgrep-rules": "0.1.10",
     "commander": "^15.0.0",
     "eslint": "^10.10.0",
     "eslint-plugin-no-unsanitized": "^4.1.5",
@@ -59,8 +59,8 @@
     "p-limit": "^7.3.2"
   },
   "optionalDependencies": {
-    "codesentry-semgrep-linux-x64": "0.1.8",
-    "codesentry-semgrep-win32-x64": "0.1.8"
+    "codesentry-semgrep-linux-x64": "0.1.10",
+    "codesentry-semgrep-win32-x64": "0.1.10"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",