@daniellins/power-claude 0.16.3

package/scripts/__tests__/motor-scripts.test.cjs

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * motor-scripts.test.cjs — teste-guarda fail-loud do manifest de distribuição
+ * dos scripts do motor (ADR-007, Decisão 1).
+ *
+ * Converte "esquecer de decidir se um script novo é motor" em falha de CI:
+ * qualquer violação dos 4 invariantes = exit 1 com mensagem que diz o que
+ * decidir. Os invariantes são funções PURAS (recebem listas/conteúdo) testadas
+ * contra fixtures E executadas contra o disco real.
+ *
+ *   1. Completude   — todo script `.cjs`/`.js` em scripts/ que não casa `exclude`
+ *                     está no manifest. Script novo fora dos dois → FAIL.
+ *   2. Existência   — todo `path` do manifest existe no disco (sem entrada morta).
+ *   3. Fechamento   — para cada script do manifest, todo `require('./X')` resolve
+ *                     de require    a um `scripts/X` também no manifest.
+ *   4. Referência   — sem entrada fantasma: cada entrada é justificada por
+ *                     citação em template/ (por basename/stem) OU por ser
+ *                     required-by outra entrada do manifest (fecho de require /
+ *                     campo `requiredBy`). E todo `scripts/<nome>` citado COM
+ *                     prefixo `scripts/` em template/ está no manifest ∪ exclude.
+ *
+ * NOTA sobre o invariante 4 (fiel ao ADR-007): a leitura estrita "todo
+ * `reason: referenced` aparece por basename-com-extensão em template/" torna o
+ * próprio manifest do ADR reprovado no próprio teste — `smoke-pod-workflow.cjs`
+ * só é citado como `smoke` em prosa (pipeline.md), nunca pelo nome completo. O
+ * ADR-007 antecipa isso ("Residual não coberto": citação por nome-cru fica fora
+ * do invariante 4 template→manifest, coberta pelo invariante 1) e usa o campo
+ * `requiredBy` para justificar entradas de fecho. Logo o invariante 4 aqui é um
+ * check ANTI-FANTASMA com escape por fecho de require: `smoke-pod-workflow.cjs`
+ * é legítimo por ser `require`-ado por `migration-manifest.cjs`/`harness-g5-lite.cjs`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const SCRIPTS_DIR = path.join(REPO_ROOT, 'scripts');
+const TEMPLATE_DIR = path.join(REPO_ROOT, 'template');
+
+const { loadManifest } = require('../../installer/motor-scripts');
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) {
+    console.log(`[OK   ] ${msg}`);
+  } else {
+    console.error(`[FALHA] ${msg}`);
+    failures++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers puros
+// ---------------------------------------------------------------------------
+
+/** True se `repoRelPath` (ex.: "scripts/foo.test.cjs") casa algum padrão exclude. */
+function isExcluded(repoRelPath, patterns) {
+  const base = repoRelPath.split('/').pop();
+  const segs = repoRelPath.split('/');
+  return patterns.some((pat) => {
+    if (pat.endsWith('/')) return segs.includes(pat.slice(0, -1)); // dir: __tests__/
+    if (pat.startsWith('*.')) return base.endsWith(pat.slice(1));   // glob: *.test.cjs
+    return base === pat || repoRelPath === pat;                     // exato
+  });
+}
+
+/** Stem = basename sem a última extensão (foo.cjs → foo; validate-branding.js → validate-branding). */
+function stemOf(p) {
+  const base = p.split('/').pop();
+  return base.replace(/\.[^.]+$/, '');
+}
+
+/**
+ * Extrai `require('./X')` de um conteúdo e resolve RELATIVO AO DIRETÓRIO DO PRÓPRIO SCRIPT.
+ *
+ * SF11.11: antes, o alvo era montado como `scripts/X` fixo, o que só está certo para scripts na
+ * RAIZ de `scripts/`. Para um script em subdiretório (`scripts/veto-checks/render-png.cjs`
+ * requerendo `./render-gate.cjs`) o alvo real é `scripts/veto-checks/render-gate.cjs`, e a régua
+ * antiga errava nas DUAS direções: acusava fechamento quebrado num require legítimo (o alvo
+ * `scripts/render-gate.cjs` não existe) e, simetricamente, deixaria passar um require de fato
+ * pendente dentro do subdiretório se por acaso houvesse homônimo na raiz. `fromPath` é opcional
+ * para preservar o contrato das fixtures que passam scripts de raiz.
+ */
+function requiredSiblings(content, fromPath = 'scripts/x.cjs') {
+  const dir = fromPath.split('/').slice(0, -1).join('/');
+  const out = [];
+  const re = /require\(\s*['"]\.\/([^'"]+)['"]\s*\)/g;
+  let m;
+  while ((m = re.exec(content)) !== null) out.push(`${dir}/${m[1]}`);
+  return out;
+}
+
+// --- Invariante 1: completude ---
+// diskScripts: repo-rel paths de todos os .cjs/.js em scripts/ (recursivo).
+// Retorna paths que NÃO estão no manifest E não casam exclude.
+function invariantCompleteness(diskScripts, manifestPaths, excludes) {
+  const inManifest = new Set(manifestPaths);
+  return diskScripts.filter((p) => !inManifest.has(p) && !isExcluded(p, excludes));
+}
+
+// --- Invariante 2: existência ---
+// Retorna paths do manifest ausentes em diskFilesSet.
+function invariantExistence(manifestPaths, diskFilesSet) {
+  return manifestPaths.filter((p) => !diskFilesSet.has(p));
+}
+
+// --- Invariante 3: fechamento de require ---
+// contents: Map<repoRelPath, string>. Retorna violações {from, missing}.
+function invariantRequireClosure(manifestPaths, contents) {
+  const inManifest = new Set(manifestPaths);
+  const violations = [];
+  for (const p of manifestPaths) {
+    const content = contents.get(p);
+    if (content === undefined) continue; // existência cobre o ausente
+    for (const sib of requiredSiblings(content, p)) {
+      if (!inManifest.has(sib)) violations.push({ from: p, missing: sib });
+    }
+  }
+  return violations;
+}
+
+// --- Invariante 4: referência real / anti-fantasma ---
+// entries: [{path, owner, reason, requiredBy?}]; templateText: concat de template/;
+// prefixedCitations: Set de 'scripts/<nome>' citados COM prefixo em template/.
+// Retorna { phantom: string[], danglingCitations: string[] }.
+function invariantRealReference(entries, templateText, prefixedCitations, contents) {
+  const inManifest = new Set(entries.map((e) => e.path));
+  const excludes = loadManifest().exclude;
+
+  // Fecho de require: quem é required-by outra entrada (justifica entrada de fecho).
+  const requiredByClosure = new Set();
+  for (const e of entries) {
+    const content = contents.get(e.path);
+    if (content) for (const sib of requiredSiblings(content, e.path)) requiredByClosure.add(sib);
+    if (e.requiredBy) requiredByClosure.add(e.path); // declarado explicitamente
+  }
+
+  const phantom = [];
+  for (const e of entries) {
+    const stem = stemOf(e.path);
+    const base = e.path.split('/').pop();
+    const citedByName = templateText.includes(base) || templateText.includes(stem);
+    const citedByPrefix = prefixedCitations.has(e.path);
+    const justifiedByClosure = requiredByClosure.has(e.path) || Boolean(e.requiredBy);
+    if (!citedByName && !citedByPrefix && !justifiedByClosure) phantom.push(e.path);
+  }
+
+  // Toda citação COM prefixo scripts/ em template/ tem que estar em manifest ∪ exclude.
+  const dangling = [];
+  for (const cited of prefixedCitations) {
+    if (!inManifest.has(cited) && !isExcluded(cited, excludes)) dangling.push(cited);
+  }
+  return { phantom, danglingCitations: dangling };
+}
+
+// ---------------------------------------------------------------------------
+// Coleta do disco real
+// ---------------------------------------------------------------------------
+
+function listScriptFiles(dir) {
+  // Todos os .cjs/.js sob scripts/ (recursivo), como repo-rel paths.
+  const out = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const d = stack.pop();
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, entry.name);
+      if (entry.isDirectory()) stack.push(p);
+      else if (entry.isFile() && /\.(cjs|js)$/.test(entry.name)) {
+        out.push(path.relative(REPO_ROOT, p).split(path.sep).join('/'));
+      }
+    }
+  }
+  return out;
+}
+
+function readTemplateText(dir) {
+  let text = '';
+  const stack = [dir];
+  while (stack.length > 0) {
+    const d = stack.pop();
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, entry.name);
+      if (entry.isDirectory()) stack.push(p);
+      else if (entry.isFile()) {
+        try { text += fs.readFileSync(p, 'utf8') + '\n'; } catch { /* binário */ }
+      }
+    }
+  }
+  return text;
+}
+
+function prefixedCitationsOf(templateText) {
+  const set = new Set();
+  const re = /scripts\/[a-zA-Z0-9_.-]+\.(?:cjs|js)/g;
+  let m;
+  while ((m = re.exec(templateText)) !== null) set.add(m[0]);
+  return set;
+}
+
+// ---------------------------------------------------------------------------
+// FIXTURES NEGATIVAS (não basta passar contra o disco de hoje)
+// ---------------------------------------------------------------------------
+
+function runNegativeFixtures() {
+  console.log('\n--- Fixtures negativas (cada uma DEVE detectar a violação) ---');
+  const manifestPaths = ['scripts/a.cjs', 'scripts/b.cjs'];
+  const excludes = ['*.test.cjs', '__tests__/', '__fixtures__/'];
+
+  // (a) .cjs novo fora do manifest/exclude → FAIL
+  const disk = ['scripts/a.cjs', 'scripts/b.cjs', 'scripts/novo-motor.cjs', 'scripts/x.test.cjs'];
+  const missing = invariantCompleteness(disk, manifestPaths, excludes);
+  assert(
+    missing.length === 1 && missing[0] === 'scripts/novo-motor.cjs',
+    `fixture (a): script novo fora do manifest/exclude é detectado (detectados: ${missing.join(', ') || 'nenhum'})`
+  );
+
+  // (b) require de módulo fora do manifest → FAIL
+  const contents = new Map([
+    ['scripts/a.cjs', "const b = require('./b.cjs'); const z = require('./nao-listado.cjs');"],
+    ['scripts/b.cjs', '// sem requires'],
+  ]);
+  const closureViol = invariantRequireClosure(manifestPaths, contents);
+  assert(
+    closureViol.length === 1 && closureViol[0].missing === 'scripts/nao-listado.cjs',
+    `fixture (b): require de módulo fora do manifest é detectado (violações: ${closureViol.map((v) => v.missing).join(', ') || 'nenhuma'})`
+  );
+
+  // (b2) SF11.11 — require dentro de SUBDIRETÓRIO resolve pelo dir do próprio script:
+  // o legítimo (irmão no mesmo subdir, presente no manifest) NÃO acusa, e o pendente do
+  // mesmo subdir acusa com o path COMPLETO (não com o homônimo de raiz). Sem esta régua,
+  // `scripts/veto-checks/render-png.cjs` requerendo `./render-gate.cjs` seria falso-positivo.
+  const subPaths = ['scripts/sub/a.cjs', 'scripts/sub/b.cjs', 'scripts/b.cjs'];
+  const subContents = new Map([
+    ['scripts/sub/a.cjs', "const b = require('./b.cjs'); const z = require('./so-na-raiz.cjs');"],
+    ['scripts/sub/b.cjs', '// sem requires'],
+    ['scripts/b.cjs', '// homônimo de raiz, irrelevante para o require do subdir'],
+  ]);
+  const subViol = invariantRequireClosure(subPaths, subContents);
+  assert(
+    subViol.length === 1 && subViol[0].missing === 'scripts/sub/so-na-raiz.cjs',
+    `fixture (b2): require em subdiretório resolve pelo dir do script (violações: ${subViol.map((v) => v.missing).join(', ') || 'nenhuma'})`
+  );
+
+  // (c) entrada do manifest sem arquivo no disco → FAIL
+  const diskSet = new Set(['scripts/a.cjs']); // falta scripts/b.cjs
+  const dead = invariantExistence(manifestPaths, diskSet);
+  assert(
+    dead.length === 1 && dead[0] === 'scripts/b.cjs',
+    `fixture (c): entrada do manifest sem arquivo é detectada (mortas: ${dead.join(', ') || 'nenhuma'})`
+  );
+
+  // Sanidade: fixture "limpa" NÃO acusa nada.
+  const cleanDisk = ['scripts/a.cjs', 'scripts/b.cjs', 'scripts/z.test.cjs'];
+  assert(invariantCompleteness(cleanDisk, manifestPaths, excludes).length === 0, 'sanidade: disco consistente não acusa completude');
+  assert(invariantRequireClosure(manifestPaths, new Map([['scripts/a.cjs', "require('./b.cjs')"]])).length === 0, 'sanidade: fecho consistente não acusa');
+  assert(invariantExistence(manifestPaths, new Set(manifestPaths)).length === 0, 'sanidade: existência consistente não acusa');
+}
+
+// ---------------------------------------------------------------------------
+// EXECUÇÃO CONTRA O DISCO REAL
+// ---------------------------------------------------------------------------
+
+function runAgainstDisk() {
+  console.log('\n--- Invariantes contra o disco real ---');
+  const manifest = loadManifest();
+  const manifestPaths = manifest.scripts.map((e) => e.path);
+  const excludes = manifest.exclude;
+
+  const diskScripts = listScriptFiles(SCRIPTS_DIR);
+  const diskFilesSet = new Set(diskScripts);
+  const contents = new Map();
+  for (const rel of manifestPaths) {
+    const abs = path.join(REPO_ROOT, ...rel.split('/'));
+    if (fs.existsSync(abs)) contents.set(rel, fs.readFileSync(abs, 'utf8'));
+  }
+  const templateText = readTemplateText(TEMPLATE_DIR);
+  const prefixed = prefixedCitationsOf(templateText);
+
+  // 1. Completude
+  const incomplete = invariantCompleteness(diskScripts, manifestPaths, excludes);
+  assert(
+    incomplete.length === 0,
+    incomplete.length === 0
+      ? 'invariante 1 (completude): todo script do disco está no manifest ou no exclude'
+      : `invariante 1 (completude) VIOLADO — decida: motor → manifest; não-motor → exclude: ${incomplete.join(', ')}`
+  );
+
+  // 2. Existência
+  const dead = invariantExistence(manifestPaths, diskFilesSet);
+  assert(
+    dead.length === 0,
+    dead.length === 0
+      ? `invariante 2 (existência): todas as ${manifestPaths.length} entradas existem no disco`
+      : `invariante 2 (existência) VIOLADO — entradas sem arquivo: ${dead.join(', ')}`
+  );
+
+  // 3. Fechamento de require
+  const closure = invariantRequireClosure(manifestPaths, contents);
+  assert(
+    closure.length === 0,
+    closure.length === 0
+      ? 'invariante 3 (fechamento de require): todo require(./irmão) resolve dentro do manifest'
+      : `invariante 3 (fechamento) VIOLADO — ${closure.map((v) => `${v.from} → ${v.missing}`).join('; ')}`
+  );
+
+  // 4. Referência real / anti-fantasma
+  const { phantom, danglingCitations } = invariantRealReference(manifest.scripts, templateText, prefixed, contents);
+  assert(
+    phantom.length === 0,
+    phantom.length === 0
+      ? 'invariante 4a (anti-fantasma): toda entrada é citada em template/ ou justificada por fecho de require'
+      : `invariante 4a (anti-fantasma) VIOLADO — entradas sem justificativa: ${phantom.join(', ')}`
+  );
+  assert(
+    danglingCitations.length === 0,
+    danglingCitations.length === 0
+      ? 'invariante 4b: toda citação com prefixo scripts/ em template/ está no manifest ∪ exclude'
+      : `invariante 4b VIOLADO — citações com prefixo fora do manifest/exclude: ${danglingCitations.join(', ')}`
+  );
+
+  // Sanidade extra: 21 entradas (ADR-007=14; +1 fidelity SF7.1; +1 arena SF7.4; +3 veto-checks SF7.2/ADR-011; +1 harden-learning SF7.6/ADR-012; +1 source-audit SF7.10/ADR-014); +2 SF9.1 pipeline; +1 SF10.1 pod-export-compile; +2 SF10.2 pod-export-executor+tools; +1 SF10.11 pod-export-postprocess (fixer in-process, require-dependency do executor — NÃO blessed: a raiz blessed é só `scripts/veto-checks/`, ver `blessedVetoRels` em pc-run-pod.cjs).
+  assert(manifest.scripts.length === 34, `manifest tem 34 entradas (ADR-007 + SF7.x + SF9.1 pipeline + SF10.1 export + SF10.2 executor/tools + SF10.3 service + SF10.5 ui + SF10.6 release + SF10.8 veto phash-gate + SF10.11 postprocess + SF11.5 pod-memory-note + SF11.11 veto render-png + SF13.1 validate-story-acs) — tem ${manifest.scripts.length}`);
+}
+
+function main() {
+  console.log('POWER CLAUDE — teste-guarda do manifest de scripts do motor (ADR-007)\n');
+  runNegativeFixtures();
+  runAgainstDisk();
+  if (failures > 0) {
+    console.error(`\nTeste-guarda FALHOU: ${failures} violação(ões).`);
+    process.exit(1);
+  }
+  console.log('\nTeste-guarda verde.');
+  process.exit(0);
+}
+
+main();

package/scripts/__tests__/pc-run-pod-counter.test.cjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pc-run-pod-counter.test.cjs — suíte DEDICADA do contador de itens (Story SF2.3,
+ * débito #2 do gate sf1.5-piloto-hormozi-g5.yaml).
+ *
+ * Arquivo SEPARADO de pc-run-pod.test.cjs de propósito: a Story SF2.2 roda em
+ * paralelo tocando advance()/buildBrief() na MESMA suíte — este arquivo isola os
+ * fixtures/asserções do contador (território SF2.3) e evita colisão de merge.
+ *
+ * Prova AC7 (as 3 formas contam) e AC8 (sem afrouxamento — bullets contam como
+ * antes; numeradas/tabela só SOMAM; separador de tabela NÃO conta).
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const { countListItemsInSection } = require('../pc-run-pod.cjs');
+
+let passed = 0;
+const failures = [];
+function eq(actual, expected, label) {
+  if (actual === expected) { passed++; console.log(`[OK   ] ${label} (=${actual})`); }
+  else { failures.push(`${label} — esperado ${expected}, obtido ${actual}`); console.log(`[FALHA] ${label} — esperado ${expected}, obtido ${actual}`); }
+}
+
+// --- AC8: bullets contam EXATAMENTE como na SF1.1 (comportamento inalterado) ---
+eq(countListItemsInSection('## Value Stack\n- a\n- b\n* c\n', 'Value Stack'), 3, 'AC8 bullets `-`/`*` contam como antes');
+eq(countListItemsInSection('## Value Stack\ntexto em prosa sem itens\n', 'Value Stack'), 0, 'AC8 prosa corrida NÃO conta');
+eq(countListItemsInSection('## Outra\n- a\n- b\n## Value Stack\n- x\n', 'Value Stack'), 1, 'AC8 só conta sob a seção-alvo (escopo por heading)');
+
+// --- AC7 (b): lista numerada conta ---
+eq(countListItemsInSection('## Value Stack\n1. um\n2. dois\n3. três\n', 'Value Stack'), 3, 'AC7 lista numerada `1.`/`2.` conta');
+eq(countListItemsInSection('## Value Stack\n1. um\ntexto\n2. dois\n', 'Value Stack'), 2, 'AC7 numerada conta só as linhas de item (prosa no meio ignorada)');
+
+// --- AC7 (c): linhas de tabela contam, separador NÃO (Risco 3) ---
+const tabela = '## Value Stack\n| Item | Valor |\n|------|-------|\n| Coaching | $1000 |\n| Plano | $500 |\n';
+eq(countListItemsInSection(tabela, 'Value Stack'), 3, 'AC7 linhas de tabela contam (cabeçalho + 2 dados = 3), separador EXCLUÍDO');
+eq(countListItemsInSection('## Value Stack\n| a | b |\n| :--- | ---: |\n| c | d |\n', 'Value Stack'), 2, 'Risco3 separador `|:---|---:|` alinhado NÃO conta');
+eq(countListItemsInSection('## Value Stack\n|---|---|\n', 'Value Stack'), 0, 'Risco3 tabela só com separador → 0 itens');
+
+// --- AC7 misto: as 3 formas somam sob o mesmo heading ---
+const misto = '## Value Stack\n- bullet\n1. numerado\n| tab | row |\n|-----|-----|\n| dado | dado |\n';
+eq(countListItemsInSection(misto, 'Value Stack'), 4, 'AC7 formas mistas somam (1 bullet + 1 numerada + 2 tabela s/ separador)');
+
+// --- AC8: numeradas/tabela só SOMAM — nunca reduzem um count de bullets ---
+const antes = countListItemsInSection('## VS\n- a\n- b\n- c\n- d\n- e\n', 'VS');
+const depois = countListItemsInSection('## VS\n- a\n- b\n- c\n- d\n- e\n1. extra\n', 'VS');
+eq(antes, 5, 'AC8 baseline de 5 bullets preservado');
+eq(depois, 6, 'AC8 adicionar numerada só INCREMENTA (5→6), nunca reduz');
+
+console.log(`\n${passed}/${passed + failures.length} asserções do contador passaram.`);
+if (failures.length > 0) {
+  console.error('\nSUÍTE contador FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('Suíte contador verde (débito #2 fechado — 3 formas, sem afrouxar bullets).');
+process.exit(0);