@fontdata/ai-harness 2.3.0 → 2.3.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdata",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Harness de engenharia com IA da Fontdata para Claude Code",
   "author": { "name": "Fontdata" },
   "commands": ["./templates/commands"],

package/README.md

@@ -141,7 +141,7 @@ Os formatos estão em [`docs/contratos/ARTEFATOS.md`](docs/contratos/ARTEFATOS.m
 | Hook | Quando | Modo inicial |
 |---|---|---|
 | `lembrete` | O pedido parece bug, funcionalidade nova, risco de segurança ou problema de performance: sugere o fluxo certo | aviso |
-| `segredo-no-commit` | `git commit` com chave de acesso, token, chave privada ou senha no diff | **bloqueio** |
+| `segredo-no-commit` | `git commit` com chave de acesso, token, chave privada ou senha no diff (em arquivo de teste, só token e chave de verdade) | **bloqueio** |
 | `proteger-contratos` | SPEC, PLAN ou CLAUDE.md reescritos durante a execução de um trabalho | aviso |
 | `task-so-fecha-verde` | Task marcada como concluída sem suíte verde no rastro | aviso |
 | `sem-jargao` | Termo técnico no relatório para o cliente | aviso |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontdata/ai-harness",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Harness de engenharia com IA da Fontdata para Claude Code: roda os slash commands direto na pasta do projeto via npx, sem instalar nada — ou instala-os em .claude/commands.",
   "type": "module",
   "bin": {

package/templates/hooks/comentarios/check.mjs

@@ -9,7 +9,8 @@ const DENSIDADE_ALVO = 0.1;
 const EXTENSOES = new Set([
   '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
   '.py', '.go', '.rs', '.java', '.cs', '.php',
-  '.pas', '.dpr', '.sql', '.sh',
+  '.pas', '.dpr', '.dpk', '.lpr', '.sql', '.sh', '.bash', '.zsh',
+  '.ps1', '.psm1', '.bat', '.cmd',
 ]);
 
 const IGNORAR = [
@@ -21,7 +22,7 @@ const IGNORAR = [
 ];
 
 const CABECALHO_PERMITIDO =
-  /eslint|ts-nocheck|ts-check|ts-ignore|prettier|@license|copyright|spdx|jshint|globals|^#!|use (strict|client|server)/i;
+  /eslint|ts-nocheck|ts-check|ts-ignore|prettier|@license|copyright|spdx|jshint|globals|use (strict|client|server)|code generated|do not edit|auto-generated/i;
 
 const BANNER = /^[-=─-╿_*#~+]{3,}|[-=─-╿_*#~+]{3,}$/;
 
@@ -42,33 +43,136 @@ const DATA = /(^|[^"'\w])20\d{2}-\d{2}-\d{2}([^"'\w]|$)/;
 const CODIGO_TOKEN = /(^|\s)(const|let|var|function|return|if|for|while|await|import|export|def|class)\b/;
 const CODIGO_FIM = /[;{}]\s*$/;
 
-function comentario(linha, ext) {
-  const t = linha.trim();
-  if (!t) return null;
-  if (ext === '.py' || ext === '.sh') return t.startsWith('#') ? t.replace(/^#+/, '').trim() : null;
-  if (ext === '.sql') {
-    if (t.startsWith('--')) return t.replace(/^-+/, '').trim();
-    if (t.startsWith('/*') || t.startsWith('*')) return t.replace(/^[/*]+/, '').trim();
-    return null;
+const so = (...exts) => new Set(exts);
+const JS = so('.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs');
+const C_LIKE = so(...JS, '.go', '.rs', '.java', '.cs', '.php');
+const PASCAL = so('.pas', '.dpr', '.dpk', '.lpr');
+const SHELL = so('.sh', '.bash', '.zsh');
+const POWERSHELL = so('.ps1', '.psm1');
+const BATCH = so('.bat', '.cmd');
+
+const SINTAXE = [
+  [so('.php'), { linha: ['//', '#'], blocos: [['/*', '*/']], naoComentario: /^#\[/ }],
+  [C_LIKE, { linha: ['//'], blocos: [['/*', '*/']] }],
+  [PASCAL, { linha: ['//'], blocos: [['{', '}'], ['(*', '*)']] }],
+  [so('.sql'), { linha: ['--'], blocos: [['/*', '*/']] }],
+  [POWERSHELL, { linha: ['#'], blocos: [['<#', '#>']] }],
+  [so('.py', ...SHELL), { linha: ['#'], blocos: [] }],
+  [BATCH, { linha: ['::'], blocos: [] }],
+];
+
+// Têm forma de comentário, mas são lidas pelo compilador, pelo interpretador ou por uma ferramenta.
+const DIRETIVA = Symbol('diretiva');
+const DIRETIVAS = [
+  [PASCAL, /^(\{|\(\*)[$%]/],
+  [C_LIKE, /^\/[/*]\s*(#?region\b|#?endregion\b|<\/?editor-fold|@formatter:)/i],
+  [JS, /^\/\/\/\s*<(reference|amd-module|amd-dependency)\b/],
+  [JS, /^\/[/*]\*?\s*(@ts-(check|nocheck|ignore|expect-error)\b|eslint|jshint|jscs:|tslint:|prettier-ignore|(istanbul|c8|v8) ignore|biome-ignore|deno-|oxlint-|@flow\b|@jsx|@vite-ignore|@vitest-environment|@jest-environment|webpack[A-Z]\w*:|@refresh\b)/i],
+  [JS, /^\/\*+\s*globals?\s/],
+  [JS, /^\/\/[#@]\s*source(Mapping)?URL=/],
+  [so('.go'), /^\/\/(go:|line |export |extern )|^\/\/\s*(\+build\b|nolint\b|lint:ignore\b)/],
+  [so('.rs'), /^#!\[/],
+  [so('.java'), /^\/[/*]\s*(noinspection\b|NOSONAR\b|CHECKSTYLE[:.]|\$NON-NLS)/],
+  [so('.cs'), /^#\s*(region|endregion|if|elif|else|endif|define|undef|pragma|nullable|warning|error|line)\b/],
+  [so('.cs'), /^\/\/\s*(ReSharper\s|<\/?auto-generated)/i],
+  [so('.php'), /^\/[/*]\*?\s*(phpcs:|@phpstan-|@psalm-|@codeCoverageIgnore|@noinspection\b|@var\s)/],
+  [so('.sql'), /^\/\*[!+]/],
+  [so('.sql'), /^--\s*(liquibase\s|changeset\s|rollback\b|precondition|comment:|validCheckSum\b|ignoreLines:|\+(goose|migrate)\b|name:\s*\S+\s*:|noqa\b|sqlfluff:|#?(region|endregion)\b)/i],
+  [so('.py'), /^#\s*(-\*-.*-\*-|(en)?coding[:=]|vim?:|noqa\b|nosec\b|type:|pylint:|mypy:|pyright:|pyre-|pytype:|ruff:|isort:|fmt:|pragma\b)/i],
+  [SHELL, /^#\s*(shellcheck\s|-\*-.*-\*-|vim?:|ex:)|^#(compdef|autoload)\b/i],
+  [POWERSHELL, /^#(requires|region|endregion)\b/i],
+];
+const BLOCOS_DIRETIVA = [
+  [SHELL, /^###\s*BEGIN INIT INFO/, /^###\s*END INIT INFO/],
+  [POWERSHELL, /^#\s*SIG\s*#\s*Begin signature block/i, /^#\s*SIG\s*#\s*End signature block/i],
+];
+const HEREDOC = /(?<!<)<<(?!<)-?\s*(['"]?)([A-Za-z_]\w*)\1/g;
+
+const limpar = (texto) => texto.replace(/^\*+/, '').trim();
+
+function comentarioDeLinha(t, sintaxe, ext) {
+  if (BATCH.has(ext)) {
+    if (t.startsWith('::')) return t.replace(/^:+/, '').trim();
+    const rem = t.match(/^@?rem(?:[\s.:/\\](.*))?$/i);
+    return rem ? (rem[1] ?? '').trim() : null;
   }
-  if (ext === '.pas' || ext === '.dpr') {
-    if (t.startsWith('//')) return t.replace(/^\/+/, '').trim();
-    if (t.startsWith('(*')) return t.replace(/^\(\*/, '').trim();
-    if (t.startsWith('{') && !t.startsWith('{$')) return t.replace(/^\{/, '').trim();
-    return null;
+  const marcador = sintaxe.linha.find((m) => t.startsWith(m));
+  if (!marcador || sintaxe.naoComentario?.test(t)) return null;
+  let k = 0;
+  while (t[k] === marcador[0]) k++;
+  return t.slice(k).trim();
+}
+
+// Devolve, por linha: o texto do comentário, DIRETIVA, ou null para código e linha em branco.
+function classificar(linhas, ext) {
+  const sintaxe = SINTAXE.find(([exts]) => exts.has(ext))?.[1] ?? { linha: ['//'], blocos: [['/*', '*/']] };
+  const saida = [];
+  const heredocs = [];
+  let fimTexto = null;
+  let fimDiretiva = null;
+  let bloco = null;
+  for (let i = 0; i < linhas.length; i++) {
+    const t = linhas[i].trim();
+    if (heredocs.length) {
+      if (t === heredocs[0]) heredocs.shift();
+      saida.push(null);
+      continue;
+    }
+    if (fimTexto) {
+      if (fimTexto.test(t)) fimTexto = null;
+      saida.push(null);
+      continue;
+    }
+    if (bloco) {
+      const pos = t.indexOf(bloco.fim);
+      saida.push(bloco.diretiva ? DIRETIVA : limpar(pos === -1 ? t : t.slice(0, pos)));
+      if (pos !== -1) bloco = null;
+      continue;
+    }
+    if (!t) { saida.push(null); continue; }
+    if (fimDiretiva) {
+      if (fimDiretiva.test(t)) fimDiretiva = null;
+      saida.push(DIRETIVA);
+      continue;
+    }
+    const linhaDiretiva = BLOCOS_DIRETIVA.find(([exts, abre]) => exts.has(ext) && abre.test(t));
+    if (linhaDiretiva) { fimDiretiva = linhaDiretiva[2]; saida.push(DIRETIVA); continue; }
+
+    const diretiva = (i === 0 && t.startsWith('#!')) || DIRETIVAS.some(([exts, re]) => exts.has(ext) && re.test(t));
+    const abre = sintaxe.blocos.find(([inicio]) => t.startsWith(inicio));
+    if (abre) {
+      const resto = t.slice(abre[0].length);
+      const pos = resto.indexOf(abre[1]);
+      if (pos === -1) bloco = { fim: abre[1], diretiva };
+      saida.push(diretiva ? DIRETIVA : limpar(pos === -1 ? resto : resto.slice(0, pos)));
+      continue;
+    }
+    if (diretiva) { saida.push(DIRETIVA); continue; }
+
+    const c = comentarioDeLinha(t, sintaxe, ext);
+    saida.push(c);
+    if (c !== null) continue;
+    if (SHELL.has(ext)) for (const m of t.matchAll(HEREDOC)) heredocs.push(m[2]);
+    if (POWERSHELL.has(ext) && /@["']$/.test(t)) fimTexto = t.endsWith('"') ? /^"@/ : /^'@/;
   }
-  if (t.startsWith('//')) return t.replace(/^\/+/, '').trim();
-  if (t.startsWith('/*')) return t.replace(/^\/\*+/, '').trim();
-  if (t.startsWith('*')) return t.replace(/^\*+\/?/, '').trim();
-  return null;
+  // O comentário colado em `import "C"` é o preâmbulo do cgo: código C, não comentário.
+  if (ext === '.go') {
+    for (let i = 0; i < linhas.length; i++) {
+      if (linhas[i].trim() !== 'import "C"') continue;
+      for (let j = i - 1; j >= 0 && typeof saida[j] === 'string'; j--) saida[j] = DIRETIVA;
+    }
+  }
+  return saida;
 }
 
+const ehTexto = (c) => typeof c === 'string';
+
 function analisar(caminho, fonte) {
   const ext = extname(caminho);
   const linhas = fonte.split('\n');
   const achados = [];
   const marca = (linha, msg) => achados.push({ linha, msg });
-  const ehComentario = linhas.map((l) => comentario(l, ext));
+  const ehComentario = classificar(linhas, ext);
 
   let primeiroCodigo = -1;
   for (let i = 0; i < linhas.length; i++) {
@@ -77,10 +181,10 @@ function analisar(caminho, fonte) {
 
   let i = 0;
   while (i < linhas.length) {
-    if (ehComentario[i] === null) { i++; continue; }
+    if (!ehTexto(ehComentario[i])) { i++; continue; }
     const inicio = i;
     const conteudo = [];
-    while (i < linhas.length && ehComentario[i] !== null) { conteudo.push(ehComentario[i]); i++; }
+    while (i < linhas.length && ehTexto(ehComentario[i])) { conteudo.push(ehComentario[i]); i++; }
     const fim = i - 1;
     const corpo = conteudo.filter(Boolean);
     const texto = corpo.join(' ');
@@ -103,9 +207,9 @@ function analisar(caminho, fonte) {
     }
 
     let proxima = fim + 1;
-    while (proxima < linhas.length && !linhas[proxima].trim()) proxima++;
+    while (proxima < linhas.length && (!linhas[proxima].trim() || ehComentario[proxima] === DIRETIVA)) proxima++;
     const ehDocstring =
-      /^(\/\*\*|"""|'''|\/\/\/)/.test(linhas[inicio].trim()) &&
+      /^(\/\*\*|"""|'''|\/\/\/|<#)/.test(linhas[inicio].trim()) &&
       proxima < linhas.length &&
       ehComentario[proxima] === null;
     const teto = ehDocstring ? MAX_DOCSTRING : MAX_BLOCO;
@@ -120,7 +224,7 @@ function analisar(caminho, fonte) {
     }
   }
 
-  const comentadas = ehComentario.filter((c) => c !== null).length;
+  const comentadas = ehComentario.filter(ehTexto).length;
   const uteis = linhas.filter((l) => l.trim()).length;
   return { achados, comentadas, uteis, densidade: uteis ? comentadas / uteis : 0 };
 }

package/templates/hooks/lib/segredos.mjs

@@ -33,6 +33,15 @@ function isEnvFile(path) {
   return /^\.env(\..+)?$/.test(name) && !/\.(example|sample|template|dist)$/.test(name);
 }
 
+/**
+ * Arquivo de teste: `tests/`, `test/`, `__tests__/`, `spec/` ou `*.test.ts` / `*.spec.js`...
+ * Fixture de senha é o caso normal em teste, então a heurística de atribuição não vale ali.
+ * @param {string} path
+ */
+function isTestFile(path) {
+  return /(^|\/)(tests?|__tests__|spec)\//.test(path) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(basename(path));
+}
+
 /**
  * @param {string} path
  * @param {string} content Linha adicionada, sem o `+`.
@@ -47,6 +56,8 @@ function secretIn(path, content) {
     return value && !isPlaceholder(value) ? 'valor em arquivo .env' : null;
   }
 
+  if (isTestFile(path)) return null;
+
   const assigned = ASSIGNED_SECRET.exec(content);
   return assigned && !isPlaceholder(assigned[2] ?? '') ? 'senha ou token atribuído no código' : null;
 }