@daniellins/power-claude 0.16.3

package/scripts/validate-source-audit.cjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-source-audit.cjs — validador estático de FORMA do bloco `source_audit:`
+ * emitido pelo passo de source-audit do `*extract` (mind-extractor, squad-forge).
+ * Story SF7.10 / ADR-014 (aplicação de ADR-008 à ENTRADA: curadoria de fontes).
+ *
+ * FRONTEIRA (ADR-014 Decisão 4): prova só o MECANIZÁVEL —
+ *   (i)   TODA fonte listada tem `class: ouro|bronze` + `evidence` não-vazia
+ *         (nenhuma omitida/classificada em silêncio);
+ *   (ii)  fonte `bronze` carrega `signal` explícita não-vazia (nunca descartada
+ *         em silêncio — os traços derivados nascem `confidence: low`);
+ *   (iii) `ouro_count`/`bronze_count` RECOMPUTADOS casam com os reportados;
+ *   (iv)  `source_verdict` presente e CONSISTENTE: `blocked` SSE ouro_count = 0
+ *         (o VETO de base do Anexo A — "se a base é bronze, o resto não importa").
+ * NUNCA julga se uma fonte É ouro ou bronze — isso é julgamento do agente + QA
+ * (Anexo A "Onde eu paro": qualidade de fonte não é do validador de processo).
+ * O vetor de fake-green que este script fecha: corpus 100% bronze saindo
+ * "passed", fonte sem classe, bronze sem sinalização, contagem forjada.
+ *
+ * Uso:  node scripts/validate-source-audit.cjs <output.yaml> [<output.yaml> ...]
+ * Exit 0 = bloco bem-formado e veredito coerente; exit 1 = primeira violação nomeada.
+ *
+ * Fonte única do formato: template/pods/squad-forge/knowledge/source-audit-rubric.yaml
+ * (seção output_contract:) — mudar o formato exige tocar rubrica + este validador
+ * (mesma dívida de acoplamento declarada de ADR-008/validate-fidelity-output.cjs).
+ *
+ * Node >= 18, sem dependências externas (reusa o parser YAML-lite do validador de workflow).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseYaml, Fail } = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const CLASSES = new Set(['ouro', 'bronze']);
+const VERDICTS = new Set(['passed', 'blocked']);
+
+function fail(msg) {
+  throw new Fail(msg);
+}
+
+function isPlainMap(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function nonEmptyString(v) {
+  return typeof v === 'string' && v.trim() !== '';
+}
+
+// ---------------------------------------------------------------------------
+// Bloco source_audit — FORMA + coerência veredito↔classes.
+// ---------------------------------------------------------------------------
+
+function validateSourceAuditBlock(sa) {
+  if (!isPlainMap(sa)) fail('source_audit não é um mapa');
+  if (!nonEmptyString(sa.corpus)) fail('source_audit.corpus ausente ou vazio (path do corpus auditado)');
+
+  const sources = sa.sources;
+  if (!Array.isArray(sources) || sources.length === 0) {
+    fail('source_audit.sources ausente ou vazio — toda fonte do corpus deve aparecer, uma entrada por arquivo');
+  }
+
+  const seen = new Set();
+  let ouro = 0;
+  let bronze = 0;
+  for (const s of sources) {
+    if (!isPlainMap(s)) fail('entrada de sources não é um mapa {file, class, evidence[, signal]}');
+    if (!nonEmptyString(s.file)) fail('fonte sem `file` — nenhuma fonte pode ficar anônima no relatório');
+    if (seen.has(s.file)) fail(`fonte duplicada no relatório: "${s.file}"`);
+    seen.add(s.file);
+    if (!CLASSES.has(s.class)) {
+      fail(`fonte "${s.file}": class inválida/ausente ${JSON.stringify(s.class)} (esperado ouro|bronze) — ` +
+        'fonte sem classificação é omissão silenciosa (ADR-014 Decisão 4.i)');
+    }
+    if (!nonEmptyString(s.evidence)) {
+      fail(`fonte "${s.file}" (${s.class}): evidence obrigatória e não-vazia — classificação sem evidência citável é ficção (No Invention)`);
+    }
+    if (s.class === 'bronze') {
+      bronze++;
+      if (!nonEmptyString(s.signal)) {
+        fail(`fonte bronze "${s.file}": signal obrigatória e não-vazia — bronze nunca é descartada/aceita em silêncio ` +
+          '(sinalize o efeito: traços derivados nascem confidence: low)');
+      }
+    } else {
+      ouro++;
+    }
+  }
+
+  if (sa.ouro_count !== ouro) {
+    fail(`ouro_count reportado ${JSON.stringify(sa.ouro_count)} != ${ouro} fontes ouro reais na lista — contagem forjada`);
+  }
+  if (sa.bronze_count !== bronze) {
+    fail(`bronze_count reportado ${JSON.stringify(sa.bronze_count)} != ${bronze} fontes bronze reais na lista — contagem forjada`);
+  }
+
+  if (!VERDICTS.has(sa.source_verdict)) {
+    fail(`source_verdict inválido/ausente ${JSON.stringify(sa.source_verdict)} (esperado passed|blocked)`);
+  }
+  // Coerência do VETO de base (ADR-014 Decisão 5): blocked SSE zero fontes ouro.
+  if (ouro === 0 && sa.source_verdict !== 'blocked') {
+    fail(`source_verdict "${sa.source_verdict}" com ZERO fontes ouro — corpus 100% bronze DEVE sair blocked ` +
+      '("se a base é bronze, o resto não importa. Isso é VETO" — Anexo A; fake-green de base bronze)');
+  }
+  if (ouro > 0 && sa.source_verdict !== 'passed') {
+    fail(`source_verdict "${sa.source_verdict}" com ${ouro} fonte(s) ouro — corpus misto não bloqueia ` +
+      '(bronze individual rebaixa confidence, não veta — ADR-014 Decisão 5); esperado passed');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Documento — exige o bloco source_audit.
+// ---------------------------------------------------------------------------
+
+function validateSourceAudit(doc) {
+  if (!isPlainMap(doc)) fail('raiz do output não é um mapa YAML');
+  if (!('source_audit' in doc)) {
+    fail('bloco source_audit ausente — esperado o output_contract de knowledge/source-audit-rubric.yaml');
+  }
+  validateSourceAuditBlock(doc.source_audit);
+}
+
+function validateFile(filePath) {
+  let doc;
+  try {
+    doc = parseYaml(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    fail(`YAML malformado: ${e.message}`);
+  }
+  validateSourceAudit(doc);
+}
+
+function main() {
+  const targets = process.argv.slice(2);
+  if (targets.length === 0) {
+    console.error('Uso: node scripts/validate-source-audit.cjs <output.yaml> [...]');
+    process.exit(2);
+  }
+  let ok = 0;
+  for (const t of targets) {
+    const rel = path.relative(REPO_ROOT, path.resolve(t));
+    if (!fs.existsSync(t)) {
+      console.error(`[FALHA] ${rel}: arquivo não encontrado`);
+      process.exit(1);
+    }
+    try {
+      validateFile(t);
+      console.log(`[OK   ] ${rel}`);
+      ok++;
+    } catch (e) {
+      if (e instanceof Fail) {
+        console.error(`[FALHA] ${rel}: ${e.message}`);
+        process.exit(1);
+      }
+      throw e;
+    }
+  }
+  console.log(`\n${ok} relatório(s) de source-audit validado(s). Forma + veredito coerentes.`);
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateSourceAudit,
+  validateSourceAuditBlock,
+  Fail,
+};

package/scripts/validate-source-audit.test.cjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-source-audit.test.cjs — suíte do validador de FORMA do source-audit
+ * (Story SF7.10, AC6; ADR-014 Decisão 4). Prova:
+ *  (1) goldens PASSAM — misto (2 ouro + 1 bronze sinalizada → passed) e
+ *      100% bronze bem-formado (→ blocked);
+ *  (2) cada fake-green FALHA pelo seu vetor: fonte sem classe, bronze sem
+ *      sinalização, corpus 100% bronze saindo "passed" (o veto de base),
+ *      contagem forjada, evidência ausente;
+ *  (3) coerência do veredito nos DOIS sentidos (blocked com ouro>0 também falha);
+ *  (4) a rubrica em disco carrega a FORMA exigida (classes ouro/bronze, regras
+ *      de veto, Fonte: Anexo A, output_contract) — fixture estrutural.
+ *
+ * Node >= 18.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { validateSourceAudit, Fail } = require('./validate-source-audit.cjs');
+const { parseYaml } = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(__dirname, '__fixtures__', 'source-audit');
+const RUBRIC = path.join(REPO_ROOT, 'template', 'pods', 'squad-forge', 'knowledge', 'source-audit-rubric.yaml');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+function parseFix(name) {
+  return parseYaml(fs.readFileSync(path.join(FIX, name), 'utf8'));
+}
+function throwsFail(doc) {
+  try { validateSourceAudit(doc); return false; }
+  catch (e) { if (e instanceof Fail) return true; throw e; }
+}
+
+// --- (1) Goldens PASSAM ---
+for (const [name, label] of [
+  ['golden.yaml', 'AC6 (1) golden misto (2 ouro + 1 bronze sinalizada, passed) PASSA'],
+  ['golden-blocked.yaml', 'AC6 (1) golden 100% bronze bem-formado (blocked) PASSA'],
+]) {
+  let g = true;
+  try { validateSourceAudit(parseFix(name)); } catch (e) { g = false; console.error(e.message); }
+  ok(g, label);
+}
+
+// --- (2) Fake-greens FALHAM, cada um pelo seu vetor ---
+ok(throwsFail(parseFix('fake-green-unclassified.yaml')),      'AC6 (2) fonte SEM classe (omissão silenciosa) FALHA');
+ok(throwsFail(parseFix('fake-green-bronze-unsignaled.yaml')), 'AC6 (2) bronze SEM sinalização FALHA');
+ok(throwsFail(parseFix('fake-green-verdict.yaml')),           'AC6 (2) corpus 100% bronze saindo "passed" FALHA (veto de base — Anexo A)');
+ok(throwsFail(parseFix('fake-green-counts.yaml')),            'AC6 (2) contagem forjada (ouro_count inflado) FALHA na recomputação');
+ok(throwsFail(parseFix('fake-green-missing-evidence.yaml')),  'AC6 (2) classificação sem evidência FALHA (No Invention)');
+
+// --- (3) Coerência do veredito nos dois sentidos (inline) ---
+const mixedBlocked = parseFix('golden.yaml');
+mixedBlocked.source_audit.source_verdict = 'blocked';
+ok(throwsFail(mixedBlocked), 'AC4 (3) blocked com ouro>0 FALHA (misto não bloqueia — ADR-014 Decisão 5)');
+const dupSource = parseFix('golden.yaml');
+dupSource.source_audit.sources.push({ ...dupSource.source_audit.sources[0] });
+ok(throwsFail(dupSource), 'AC4 (3) fonte duplicada no relatório FALHA');
+
+// --- (4) Rubrica em disco: fixture estrutural (FORMA, não conteúdo) ---
+const rubricRaw = fs.readFileSync(RUBRIC, 'utf8');
+const rubric = parseYaml(rubricRaw);
+ok(rubric && rubric.classes && rubric.classes.ouro && rubric.classes.bronze,
+  'AC1 (4) rubrica declara as duas classes (ouro/bronze)');
+ok(Array.isArray(rubric.classes?.ouro?.indicators) && rubric.classes.ouro.indicators.length >= 3
+  && Array.isArray(rubric.classes?.bronze?.indicators) && rubric.classes.bronze.indicators.length >= 3,
+  'AC1 (4) rubrica tem indicadores por classe (exemplos-guia, não lista vazia)');
+ok(rubric.rules && typeof rubric.rules.veto_base === 'string' && rubric.rules.veto_base.includes('blocked'),
+  'AC3 (4) rubrica declara o veto de base (zero ouro → blocked)');
+ok(rubric.output_contract && rubric.output_contract.source_audit,
+  'AC4 (4) rubrica declara o output_contract do bloco source_audit');
+ok(/Fonte: .*ANEXO-A-processo-daniel-geracao-squads\.md/.test(rubricRaw)
+  && rubricRaw.includes(':12') && rubricRaw.includes(':20') && rubricRaw.includes(':33') && rubricRaw.includes(':90'),
+  'AC1 (4) rubrica cita a Fonte: Anexo A com as linhas 12/20/33/90 (knowledge-com-fonte)');
+
+// --- Resumo ---
+console.log('');
+if (failures.length) {
+  console.error(`${failures.length} falha(s):`);
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log(`${passed} checks OK — validate-source-audit provado (goldens passam, fake-greens caem).`);
+process.exit(0);