@daniellins/power-claude 0.16.3

package/scripts/pod-export-compile.test.cjs

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-compile.test.cjs — teste-guarda do compilador pod→bundle (Story SF10.1).
+ *
+ * Hermético (NÃO toca rede — endpoint mockado; NÃO toca exports/.power-claude reais — escreve
+ * em tmp). Fixture de CI = template/pods/content-carousel (exercita a GENERALIZAÇÃO: nomes de
+ * knowledge diferentes do pod de produção, citação implícita `identidade-visual-mascote.md`).
+ *
+ * Cobre: AC2 (6 linhas da tabela), AC3 (derivação PROGRAMÁTICA + cobertura + regressão hn-fetch),
+ * AC4 (determinismo byte-a-byte), AC5 (endpoint fail-loud mockado), AC6 (schema do lock).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const {
+  compile,
+  writeBundle,
+  serializeLock,
+  validateImageEndpoint,
+  parseCommandKnowledge,
+  extractGoldenRules,
+  splitFrontmatter,
+  COMPILER_VERSION,
+  CompileError,
+} = require('./pod-export-compile.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIXTURE_POD = path.join(REPO_ROOT, 'template', 'pods', 'content-carousel');
+const REAL_PINS = path.join(REPO_ROOT, 'exports', 'content-carousel', 'pins.json');
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) console.log(`[OK   ] ${msg}`);
+  else { console.error(`[FALHA] ${msg}`); failures++; }
+}
+
+// Mocks de rede (AC5) — sem tocar a internet.
+const fetchAlive = async () => ({ ok: true, json: async () => ({ data: { endpoints: [{ name: 'openrouter' }] } }) });
+const fetchNoEndpoints = async () => ({ ok: true, json: async () => ({ data: { endpoints: [] } }) });
+const fetchHttpError = async () => ({ ok: false, status: 404, json: async () => ({}) });
+
+function tmpDir(label) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf10-${label}-`)); }
+function copyPod(dest) { fs.cpSync(FIXTURE_POD, dest, { recursive: true }); return dest; }
+function wfPathOf(podDir) { return path.join(podDir, 'workflows', 'wf-content-carousel.yaml'); }
+function mutateWf(podDir, fn) {
+  const p = wfPathOf(podDir);
+  fs.writeFileSync(p, fn(fs.readFileSync(p, 'utf8')));
+}
+async function expectFail(label, fn, substr) {
+  try {
+    await fn();
+    assert(false, `${label} — esperava FALHA, mas compilou`);
+  } catch (e) {
+    const isCompile = e instanceof CompileError || /Fail/.test(e.constructor.name);
+    assert(isCompile && (!substr || e.message.includes(substr)),
+      `${label} — falhou como esperado${substr ? ` (cita "${substr}")` : ''}: ${e.message.slice(0, 90)}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Unidade: derivação programática (nunca hardcode).
+// ---------------------------------------------------------------------------
+
+function unitTests() {
+  console.log('\n--- Unidade: parsing programático ---');
+  const hn = fs.readFileSync(path.join(FIXTURE_POD, 'agents', 'hn-curator.md'), 'utf8');
+  const { frontmatter, body } = splitFrontmatter(hn);
+  assert(frontmatter.model === 'sonnet', 'splitFrontmatter extrai model=sonnet');
+  // ACOPLAMENTO DECLARADO: o valor esperado é o do frontmatter REAL do pod-template (FIXTURE_POD
+  // aponta para template/pods/content-carousel, não para uma cópia). O que esta asserção prova é o
+  // PARSER, não o número — quando o agente muda de budget, este literal acompanha. Story SF12.2:
+  // 1000 -> 1450 (o `hn-curator` ganhou o modo `roteiro`; ainda sob o teto global de 1500 do
+  // scripts/validate-budgets.js, que é o gate real).
+  assert(frontmatter.budget_tokens === '1450', 'splitFrontmatter extrai budget_tokens');
+  const cited = parseCommandKnowledge(body);
+  assert(cited.has('aquisicao-ancora.md') && cited.size === 1,
+    `parseCommandKnowledge lê só a citação da linha de comando (${[...cited].join(', ')})`);
+  assert(extractGoldenRules(body).startsWith('## Regras de ouro'), 'extractGoldenRules captura a seção');
+
+  // A citação implícita: identidade-visual-mascote.md NÃO é citada por comando em NENHUM agente
+  // → um parser puro a perderia. Prova de que a derivação NÃO pode ser só parsing (D2).
+  let anyCites = false;
+  for (const a of ['hn-curator.md', 'carousel-visual.md', 'carousel-builder.md']) {
+    const b = splitFrontmatter(fs.readFileSync(path.join(FIXTURE_POD, 'agents', a), 'utf8')).body;
+    if (parseCommandKnowledge(b).has('identidade-visual-mascote.md')) anyCites = true;
+  }
+  assert(!anyCites, 'identidade-visual-mascote.md NÃO é citada por comando (só recuperável via campo declarado — D2)');
+}
+
+// ---------------------------------------------------------------------------
+// AC5: endpoint fail-loud (mockado).
+// ---------------------------------------------------------------------------
+
+async function endpointTests() {
+  console.log('\n--- AC5: validação de endpoint do modelo de imagem (mockado) ---');
+  const model = { id: 'google/gemini-2.5-flash-image', endpoints_url: 'https://x/endpoints' };
+  const ok = await validateImageEndpoint(model, { fetchImpl: fetchAlive });
+  assert(ok && ok.endpoints_count === 1, 'endpoint vivo → passa');
+  await expectFail('endpoint sem endpoints ("No endpoints" — Achado 1)',
+    () => validateImageEndpoint(model, { fetchImpl: fetchNoEndpoints }), 'SEM endpoints');
+  await expectFail('endpoint HTTP 404',
+    () => validateImageEndpoint(model, { fetchImpl: fetchHttpError }), 'indisponível');
+}
+
+// ---------------------------------------------------------------------------
+// AC2/AC3/AC6: compile feliz do fixture + cobertura de knowledge.
+// ---------------------------------------------------------------------------
+
+async function happyPathAndCoverage() {
+  console.log('\n--- AC2/AC3/AC6: compile do fixture content-carousel + cobertura ---');
+  const { lock, bundleFiles, podName } = await compile(FIXTURE_POD, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  const byRel = new Map(bundleFiles.map((f) => [f.rel, Buffer.isBuffer(f.content) ? f.content.toString('utf8') : f.content]));
+
+  assert(podName === 'content-carousel', 'nome do pod vem do pod-spec (D6)');
+
+  // AC6 — schema do lock completo.
+  const schemaKeys = ['pod', 'pod_sha', 'per_file_sha', 'modelo_pinado', 'framework_version', 'compiler_version', 'bundle_hashes'];
+  assert(schemaKeys.every((k) => k in lock), `lock tem as 7 chaves do schema: ${schemaKeys.join(', ')}`);
+  assert(lock.compiler_version === COMPILER_VERSION, 'lock.compiler_version = constante do compilador (D4)');
+  assert(/^\d+\.\d+\.\d+$/.test(lock.framework_version), 'lock.framework_version = version do package.json (D4)');
+  assert(lock.modelo_pinado.agents.digest === 'claude-sonnet-5', 'modelo pinado por fase = id concreto (D4)');
+  assert(lock.modelo_pinado.image.id === 'google/gemini-2.5-flash-image', 'modelo de imagem pinado registrado');
+
+  // AC2 — 6 linhas da tabela de compilação presentes no bundle.
+  assert(byRel.has('workflow.yaml'), 'tabela linha 5: grafo = wf VERBATIM empacotado (D3)');
+  assert(byRel.get('workflow.yaml') === fs.readFileSync(wfPathOf(FIXTURE_POD), 'utf8'), 'grafo é byte-idêntico ao wf original (D3)');
+  assert(byRel.has('phases/digest/system.md'), 'tabela linha 1: system prompt por fase');
+  assert(byRel.get('phases/digest/system.md').includes('# REGRAS DE OURO'), 'tabela linha 4: golden rules no bloco só-leitura');
+  assert(byRel.get('phases/digest/system.md').includes('MEMÓRIA CONSOLIDADA') &&
+    byRel.get('phases/digest/system.md').includes('recordLearning DESLIGADO'),
+    'tabela linha 4: memória consolidada SÓ-LEITURA (recordLearning off)');
+  assert(byRel.has('phases/digest/user.md') && byRel.get('phases/digest/user.md').includes('CONTRATO DE SAÍDA'),
+    'tabela linha 3: template como contrato de saída no user prompt');
+  assert(byRel.has('veto-checks/lexical-check.cjs'), 'tabela linha 6: script de veto blessed empacotado (assembly usa lexical-check)');
+
+  // AC3 — cobertura PROGRAMÁTICA de knowledge por fase.
+  const expected = {
+    digest: ['aquisicao-ancora.md', 'selecao-de-ancora.md'],
+    visuals: ['image-generation.md', 'identidade-visual-mascote.md'],
+    assembly: ['slides-html.md', 'cta-brief.md', 'identidade-visual-mascote.md'],
+  };
+  for (const [phase, ks] of Object.entries(expected)) {
+    const meta = JSON.parse(byRel.get(`phases/${phase}/meta.json`));
+    assert(JSON.stringify(meta.knowledge) === JSON.stringify(ks),
+      `fase ${phase}: knowledge na ORDEM declarada = [${ks.join(', ')}]`);
+    for (const k of ks) {
+      assert(byRel.has(`knowledge/${k}`), `fase ${phase}: knowledge/${k} presente no bundle`);
+      assert(byRel.get(`phases/${phase}/system.md`).includes(`# KNOWLEDGE: ${k}`),
+        `fase ${phase}: knowledge/${k} anexado ao system prompt`);
+    }
+  }
+  // Zero omissão: união do knowledge por fase == todo knowledge .md do pod (garantia anti-órfão).
+  const unionKnowledge = new Set(Object.values(expected).flat());
+  const podKnowledgeMd = fs.readdirSync(path.join(FIXTURE_POD, 'knowledge')).filter((f) => f.endsWith('.md'));
+  assert(podKnowledgeMd.every((k) => unionKnowledge.has(k)),
+    `AC3: 100% do knowledge .md do pod está coberto por alguma fase (sem omissão): ${podKnowledgeMd.join(', ')}`);
+  // A citação implícita foi para o bundle (o bug que o parser puro cometeria).
+  assert(byRel.has('knowledge/identidade-visual-mascote.md'),
+    'AC3: citação IMPLÍCITA (identidade-visual-mascote.md) está no bundle via campo declarado (não perdida)');
+}
+
+// ---------------------------------------------------------------------------
+// AC3: regressão + os 3 checks fail-loud.
+// ---------------------------------------------------------------------------
+
+async function regressionAndChecks() {
+  console.log('\n--- AC3: regressão (bug do spike) + 3 checks fail-loud (D2) ---');
+
+  // Regressão: wf declara knowledge INEXISTENTE (hn-fetch.md num pod que não o tem) → FALHA.
+  await expectFail('regressão hn-fetch.md inexistente (bug do PoC)', async () => {
+    const pod = copyPod(tmpDir('regr'));
+    mutateWf(pod, (t) => t.replace('knowledge: [aquisicao-ancora.md, selecao-de-ancora.md]', 'knowledge: [hn-fetch.md]'));
+    await compile(pod, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  }, 'hn-fetch.md');
+
+  // Check 2 (superconjunto): citação de comando fora da lista declarada → FALHA.
+  await expectFail('check superconjunto (citação não declarada)', async () => {
+    const pod = copyPod(tmpDir('super'));
+    mutateWf(pod, (t) => t.replace('knowledge: [aquisicao-ancora.md, selecao-de-ancora.md]', 'knowledge: [selecao-de-ancora.md]'));
+    await compile(pod, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  }, 'aquisicao-ancora.md');
+
+  // Check 3 (órfãos): knowledge presente no pod não reivindicado → FALHA.
+  await expectFail('check órfãos (identidade-visual-mascote esquecido)', async () => {
+    const pod = copyPod(tmpDir('orphan'));
+    mutateWf(pod, (t) => t
+      .replace('knowledge: [image-generation.md, identidade-visual-mascote.md]', 'knowledge: [image-generation.md]')
+      .replace('knowledge: [slides-html.md, cta-brief.md, identidade-visual-mascote.md]', 'knowledge: [slides-html.md, cta-brief.md]'));
+    await compile(pod, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  }, 'identidade-visual-mascote.md');
+
+  // knowledge: ausente numa fase → FALHA (OBRIGATÓRIO para compile).
+  await expectFail('knowledge ausente numa fase', async () => {
+    const pod = copyPod(tmpDir('missing'));
+    mutateWf(pod, (t) => t.replace(/\n\s*knowledge: \[aquisicao-ancora.md, selecao-de-ancora.md\][^\n]*/, ''));
+    await compile(pod, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  }, 'OBRIGATÓRIO');
+
+  // knowledge_exclude: escape hatch permite knowledge não usado → COMPILA.
+  {
+    const pod = copyPod(tmpDir('exclude'));
+    fs.writeFileSync(path.join(pod, 'knowledge', 'extra-unused.md'), '# extra\n');
+    mutateWf(pod, (t) => t.replace('steps:', 'knowledge_exclude: [extra-unused.md]\nsteps:'));
+    try {
+      await compile(pod, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+      assert(true, 'knowledge_exclude libera knowledge não usado (escape hatch D2)');
+    } catch (e) { assert(false, `knowledge_exclude deveria compilar: ${e.message}`); }
+  }
+
+  // Pin ausente → FALHA (D4).
+  await expectFail('alias de modelo sem pin', async () => {
+    const badPins = path.join(tmpDir('pins'), 'pins.json');
+    fs.writeFileSync(badPins, JSON.stringify({ models: {}, image_model: { id: 'x', endpoints_url: 'https://x' } }));
+    await compile(FIXTURE_POD, { fetchImpl: fetchAlive, pinsPath: badPins });
+  }, 'sem pin');
+
+  // Endpoint morto no compile inteiro → FALHA (AC5 ponta-a-ponta).
+  await expectFail('endpoint morto aborta o compile inteiro', async () => {
+    await compile(FIXTURE_POD, { fetchImpl: fetchNoEndpoints, pinsPath: REAL_PINS });
+  }, 'endpoints');
+}
+
+// ---------------------------------------------------------------------------
+// AC4: determinismo byte-a-byte.
+// ---------------------------------------------------------------------------
+
+async function determinism() {
+  console.log('\n--- AC4: determinismo (mesmo pod@sha + compiler_version → bundle byte-idêntico) ---');
+  const a = await compile(FIXTURE_POD, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  const b = await compile(FIXTURE_POD, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  assert(a.lock.pod_sha === b.lock.pod_sha, 'pod_sha estável entre 2 compilações');
+  assert(serializeLock(a.lock) === serializeLock(b.lock), 'lock.json byte-idêntico entre 2 compilações');
+  const hashesA = JSON.stringify(a.lock.bundle_hashes);
+  const hashesB = JSON.stringify(b.lock.bundle_hashes);
+  assert(hashesA === hashesB, 'bundle_hashes byte-idênticos (nenhum timestamp/aleatório no conteúdo)');
+
+  // E o bundle escrito em disco também é byte-idêntico.
+  const d1 = tmpDir('det1'); const d2 = tmpDir('det2');
+  writeBundle(d1, a.bundleFiles); writeBundle(d2, b.bundleFiles);
+  let allEqual = true;
+  for (const f of a.bundleFiles) {
+    const p1 = path.join(d1, f.rel); const p2 = path.join(d2, f.rel);
+    if (!fs.existsSync(p2) || !fs.readFileSync(p1).equals(fs.readFileSync(p2))) allEqual = false;
+  }
+  assert(allEqual, 'todos os arquivos do bundle escrito são byte-idênticos entre as 2 compilações');
+}
+
+// ---------------------------------------------------------------------------
+// SF11.4/ADR-022 (DF-SF11.4-6): ramificação POR TRANSPORTE da memória consolidada.
+// O consolidado cita `memory/learnings.hardened.md` (trilha auditável que vive no
+// repositório do pod). Esse arquivo NÃO viaja no bundle — o prompt compilado não pode
+// mandar o executor consultar um arquivo ausente (referência pendurada).
+// ---------------------------------------------------------------------------
+async function memoryTransportBranch() {
+  console.log('\n--- SF11.4/DF-SF11.4-6: memória no bundle sem referência pendurada ---');
+  const podDir = copyPod(path.join(tmpDir('hardref'), 'pod'));
+  fs.mkdirSync(path.join(podDir, 'memory'), { recursive: true });
+  fs.writeFileSync(path.join(podDir, 'memory', 'learnings.consolidated.md'), [
+    '# Memória consolidada — content-carousel',
+    '',
+    '> Curado por pod-memory.cjs (SF2.1). Único artefato de memória lido pelo agente.',
+    '> Log cru (learnings.jsonl) NÃO é lido pelo agente — auditoria apenas.',
+    '',
+    '## Heurísticas (top-N)',
+    '',
+    '- **[escrever texto de slide]** limite de texto em TODOS os slides _(x2)_',
+    '',
+    '## Endurecidas (🔒 → enforcement)',
+    '',
+    '_2 heurística(s) já viraram forma canônica do pod — enforcement substitui injeção: knowledge/slides-html.md (2). ' +
+      'O knowledge citado é LEITURA OBRIGATÓRIA da etapa e o veto citado bloqueia em disco; por isso o texto delas não é reinjetado aqui._',
+    '_Detalhe auditável (asserção, aprovador, momento): memory/learnings.hardened.md — append-only, nunca podado._',
+    '',
+  ].join('\n'));
+  // a trilha existe no pod (e continua fora do bundle)
+  fs.writeFileSync(path.join(podDir, 'memory', 'learnings.hardened.md'),
+    '# Endurecidas (🔒) — trilha auditável — content-carousel\n\n- 🔒 **[x]** y — endurecida → knowledge/slides-html.md _(por daniel, 2026-08-02T00:00:00.000Z)_\n');
+
+  const { bundleFiles } = await compile(podDir, { fetchImpl: fetchAlive, pinsPath: REAL_PINS });
+  const byRel = new Map(bundleFiles.map((f) => [f.rel, Buffer.isBuffer(f.content) ? f.content.toString('utf8') : f.content]));
+  const sys = byRel.get('phases/digest/system.md');
+  assert(!/learnings\.hardened\.md/.test(sys),
+    'prompt compilado NÃO cita memory/learnings.hardened.md (arquivo ausente do bundle)');
+  assert(/Detalhe auditável das endurecidas .* vive no repositório do pod/.test(sys),
+    'prompt compilado DECLARA onde o detalhe vive, em vez de apagar a linha em silêncio');
+  assert(sys.includes('knowledge/slides-html.md (2)'),
+    'a referência AGREGADA (alvo + contagem) sobrevive ao transporte');
+  assert(!/learnings\.jsonl/.test(sys), 'log cru segue fora do prompt compilado (garantia anterior intacta)');
+  assert(![...byRel.keys()].some((k) => /learnings\.hardened\.md/.test(k)),
+    'a trilha auditável NÃO é empacotada no bundle (DF-SF11.4-6)');
+}
+
+async function main() {
+  console.log('POWER CLAUDE — teste-guarda do compilador pod-export (SF10.1)\n');
+  unitTests();
+  await endpointTests();
+  await happyPathAndCoverage();
+  await regressionAndChecks();
+  await memoryTransportBranch();
+  await determinism();
+  if (failures > 0) {
+    console.error(`\nTeste-guarda FALHOU: ${failures} violação(ões).`);
+    process.exit(1);
+  }
+  console.log('\nTeste-guarda verde.');
+  process.exit(0);
+}
+
+main();