@daniellins/power-claude 0.16.3

package/scripts/forge-assess-tier.cjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge-assess-tier.cjs — gate de proporcionalidade do forge (Story SF1.4).
+ *
+ * Reproduz o VEREDITO da régua `*assess` 5D do pc-architect por limiares
+ * ESTRUTURAIS determinísticos (ADR-004), sem invocar um subagente arquiteto a
+ * cada geração. Racional (Dev Notes SF1.4): o repo `power-claude` não embute o
+ * papel `pc-architect`; os limiares do ADR-004 são a lógica determinística e
+ * auditável que decide SIMPLE vs STANDARD/COMPLEX. NÃO redefine a régua 5D —
+ * consome os gatilhos estruturais dela.
+ *
+ * SIMPLE  ⇔ ≤2 agentes E ≤1 workflow E ≤1 handoff cross-agente
+ *           E sem DNA/persona externa E entregável não crítico de persistência.
+ * Qualquer gatilho oposto ⇒ STANDARD/COMPLEX.
+ *
+ * Uso:
+ *   node scripts/forge-assess-tier.cjs <pod-spec.json>
+ *   echo '{"agents":["a","b"],"workflows":1,"handoffs":0}' | node scripts/forge-assess-tier.cjs -
+ *
+ * Exit 0 sempre (é uma classificação, não um gate de falha); imprime o tier e os
+ * gatilhos que dispararam. `require()` expõe classifyTier + SCOPE_THRESHOLDS.
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+
+// ---------------------------------------------------------------------------
+// LIMIARES DO ADR-004 — constante nomeada, auditável, num único lugar.
+// Risco 1 (SF1.4): a SF1.5 (hormozi, 4 agentes reais) pode recalibrar estes
+// números; mantê-los aqui (não espalhados) permite ajuste sem reabrir arquitetura.
+// ---------------------------------------------------------------------------
+const SCOPE_THRESHOLDS = {
+  maxAgentsSimple: 2, // ≤2 agentes ainda pode ser SIMPLE
+  maxWorkflowsSimple: 1, // ≤1 workflow ainda pode ser SIMPLE
+  maxHandoffsSimple: 1, // ≤1 handoff cross-agente ainda pode ser SIMPLE
+};
+
+const TIER_SIMPLE = 'SIMPLE';
+const TIER_STANDARD = 'STANDARD/COMPLEX';
+
+/**
+ * Conta IDENTIDADES físicas de agente numa lista de spec (Story SF8.1, AC1).
+ * O padrão real de pod-spec.json modela 1 agente físico como N objetos de etapa
+ * ({name, step, ...}) — `.length` contava ETAPAS, não agentes. Objetos com
+ * `.name` deduplicam por nome distinto; strings/números/objetos sem `.name`
+ * mantêm o comportamento anterior (1 por entrada, contagem por valor).
+ */
+function countAgentIdentities(list) {
+  const names = new Set();
+  let unnamed = 0;
+  for (const entry of list) {
+    if (entry && typeof entry === 'object' && typeof entry.name === 'string' && entry.name !== '') {
+      names.add(entry.name);
+    } else {
+      unnamed += 1;
+    }
+  }
+  return names.size + unnamed;
+}
+
+/**
+ * Normaliza a spec do pod para contagens estruturais.
+ * agents: array de nomes/objetos-de-etapa OU número. workflows/handoffs: número.
+ * dna/critical: bool. Agentes contam por IDENTIDADE física (dedup por `.name`).
+ */
+function normalizeSpec(spec) {
+  const agents = Array.isArray(spec.agents)
+    ? countAgentIdentities(spec.agents)
+    : Number(spec.agents || 0);
+  const workflows = Array.isArray(spec.workflows)
+    ? spec.workflows.length
+    : Number(spec.workflows || 0);
+  const handoffs = Number(spec.handoffs || 0);
+  const dna = Boolean(spec.dna || spec.persona || spec.clone);
+  const critical = Boolean(spec.critical);
+  return { agents, workflows, handoffs, dna, critical };
+}
+
+/**
+ * Classifica o pedido em SIMPLE ou STANDARD/COMPLEX pelos limiares do ADR-004.
+ * Retorna { tier, triggers[] } — triggers lista cada gatilho que forçou o superior.
+ */
+function classifyTier(spec) {
+  const s = normalizeSpec(spec);
+  const triggers = [];
+  if (s.agents > SCOPE_THRESHOLDS.maxAgentsSimple) {
+    triggers.push(`${s.agents} agentes (> ${SCOPE_THRESHOLDS.maxAgentsSimple})`);
+  }
+  if (s.workflows > SCOPE_THRESHOLDS.maxWorkflowsSimple) {
+    triggers.push(`${s.workflows} workflows (> ${SCOPE_THRESHOLDS.maxWorkflowsSimple})`);
+  }
+  if (s.handoffs > SCOPE_THRESHOLDS.maxHandoffsSimple) {
+    triggers.push(`${s.handoffs} handoffs cross-agente (> ${SCOPE_THRESHOLDS.maxHandoffsSimple})`);
+  }
+  if (s.dna) triggers.push('DNA/persona externa (clone)');
+  if (s.critical) triggers.push('entregável crítico de persistência');
+  return {
+    tier: triggers.length === 0 ? TIER_SIMPLE : TIER_STANDARD,
+    triggers,
+    counts: s,
+  };
+}
+
+function readSpec(arg) {
+  const raw = arg === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(arg, 'utf8');
+  return JSON.parse(raw);
+}
+
+// ---------------------------------------------------------------------------
+// Tier AGREGADO do DISCO (Decisão C.1, SF3.1 — fecha G1; agregação corrigida
+// na SF8.1). classifyTier(spec) conta só o que a spec declara; num pod
+// pré-existente isso IGNORA os agentes/workflows/handoffs já em disco e
+// re-classifica SIMPLE uma spec de 2 etapas sobre um pod COMPLEX.
+// `podDiskCounts` lê o DISCO e combina com as contagens da spec por
+// UNIÃO/MÁXIMO (via aggregateSpec) — a fonte da verdade do tier no modo
+// aditivo e no upgrade-in-place. Máximo, não soma: um artefato que a spec
+// declara E que já está materializado em disco é o MESMO artefato (o padrão
+// "spec descreve o pod inteiro" do retrofit); no caso genuinamente
+// incremental (spec declara trabalho novo, disco ainda menor) o valor da
+// spec permanece como piso — nunca subconta o declarado.
+// ---------------------------------------------------------------------------
+const nodePath = require('node:path');
+
+/**
+ * Conta os artefatos JÁ EM DISCO de um pod existente:
+ *   agents     = todos os `agents/*.md` (exceto README.md)
+ *   workflows  = `workflows/wf-*.yaml|yml` (EXCLUINDO os `.smoke.json`/`.smoke.yaml`)
+ *   handoffs   = entradas `- from:`/`to:` declaradas em `squad-io.yaml`
+ * Pod inexistente/vazio → zeros. Determinístico, sem parse de YAML externo.
+ */
+function podDiskCounts(podDir) {
+  const counts = { agents: 0, workflows: 0, handoffs: 0 };
+  if (!podDir || !fs.existsSync(podDir)) return counts;
+  const agentsDir = nodePath.join(podDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    counts.agents = fs.readdirSync(agentsDir)
+      .filter((f) => f.endsWith('.md') && f !== 'README.md').length;
+  }
+  const wfDir = nodePath.join(podDir, 'workflows');
+  if (fs.existsSync(wfDir)) {
+    counts.workflows = fs.readdirSync(wfDir)
+      .filter((f) => /^wf-.*\.ya?ml$/.test(f) && !/\.smoke\./.test(f)).length;
+  }
+  const io = nodePath.join(podDir, 'squad-io.yaml');
+  if (fs.existsSync(io)) {
+    const txt = fs.readFileSync(io, 'utf8');
+    // Cada handoff é um item de lista `- from:` no bloco `handoffs:`.
+    counts.handoffs = (txt.match(/^\s*-\s*from:/gim) || []).length;
+  }
+  return counts;
+}
+
+/**
+ * Retorna uma spec sintética cujas contagens combinam spec declarada e disco
+ * do pod por UNIÃO/MÁXIMO por dimensão (SF8.1, AC2) — nunca soma ingênua:
+ * artefato declarado na spec E materializado em disco é o MESMO artefato,
+ * contado uma vez. Usada por classifyTier para obter o tier AGREGADO.
+ * Preserva os flags qualitativos (dna/critical) da spec original.
+ */
+function aggregateSpec(spec, podDir) {
+  const s = normalizeSpec(spec);
+  const disk = podDiskCounts(podDir);
+  return {
+    agents: Math.max(s.agents, disk.agents),
+    workflows: Math.max(s.workflows, disk.workflows),
+    handoffs: Math.max(s.handoffs, disk.handoffs),
+    dna: s.dna,
+    critical: s.critical,
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  let arg = null;
+  let podDir = null;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--pod-dir') podDir = args[++i];
+    else arg = args[i];
+  }
+  if (!arg) {
+    console.error('Uso: node scripts/forge-assess-tier.cjs <pod-spec.json> | - [--pod-dir <dir>]');
+    process.exit(2);
+  }
+  const spec = readSpec(arg);
+  // Com --pod-dir, o tier é AGREGADO (spec declarada + disco do pod existente).
+  const result = classifyTier(podDir ? aggregateSpec(spec, nodePath.resolve(podDir)) : spec);
+  console.log(`tier: ${result.tier}`);
+  if (podDir) {
+    const disk = podDiskCounts(nodePath.resolve(podDir));
+    console.log(`disco (${podDir}): ${disk.agents} agentes, ${disk.workflows} workflows, ${disk.handoffs} handoffs (agregação por máximo com a spec)`);
+  }
+  if (result.triggers.length > 0) {
+    console.log('gatilhos que forçaram STANDARD/COMPLEX:');
+    for (const t of result.triggers) console.log(`  - ${t}`);
+  } else {
+    console.log('nenhum gatilho oposto — caminho leve (SIMPLE).');
+  }
+  process.exit(0);
+}
+
+if (require.main === module) main();
+
+module.exports = { classifyTier, normalizeSpec, countAgentIdentities, podDiskCounts, aggregateSpec, SCOPE_THRESHOLDS, TIER_SIMPLE, TIER_STANDARD };

package/scripts/forge-assess-tier.test.cjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * forge-assess-tier.test.cjs — Story SF8.1 (fix do caminho --pod-dir).
+ *
+ * Cobre:
+ *   AC1 dedup de agentes por IDENTIDADE física (objetos com `.name` repetido
+ *       contam 1 por nome; strings/números mantêm contagem por entrada).
+ *   AC2 agregação spec+disco por UNIÃO/MÁXIMO por dimensão (agentes,
+ *       workflows, handoffs) — nunca soma; caso incremental real preserva o
+ *       valor da spec como piso (Risco 3).
+ *   AC3 fixture reproduzindo o caso EXATO do gate SF6.4 (CONCERNS-1):
+ *       agente físico único modelado como 2 etapas + disco com o .md físico e
+ *       o wf já gerado → --pod-dir relata SIMPLE (bate com o standalone).
+ *   AC4 regressão do standalone: specs SEM nome repetido → saída CLI
+ *       byte-idêntica ao comportamento anterior; COM nome repetido → corrigida.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const at = require('./forge-assess-tier.cjs');
+const SCRIPT = path.join(__dirname, 'forge-assess-tier.cjs');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label, extra) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}${extra ? ` — ${extra}` : ''}`); }
+}
+function tmp(name) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf81-${name}-`)); }
+function runCli(args) { return spawnSync(process.execPath, [SCRIPT, ...args], { encoding: 'utf8' }); }
+
+// ---------------------------------------------------------------------------
+// AC1 — dedup por identidade física.
+// ---------------------------------------------------------------------------
+ok(at.countAgentIdentities([{ name: 'chief', step: 'a' }, { name: 'chief', step: 'b' }]) === 1,
+  'AC1 2 etapas do MESMO agente físico contam 1 identidade');
+ok(at.countAgentIdentities([{ name: 'chief', step: 'a' }, { name: 'chief', step: 'b' }, { name: 'critic', step: 'c' }]) === 2,
+  'AC1 3 etapas de 2 agentes físicos contam 2 identidades');
+ok(at.countAgentIdentities(['x', 'y']) === 2, 'AC1 array de strings mantém contagem por entrada (comportamento anterior)');
+ok(at.normalizeSpec({ agents: [{ name: 'chief', step: 'a' }, { name: 'chief', step: 'b' }] }).agents === 1,
+  'AC1 normalizeSpec aplica o dedup (vale para standalone E --pod-dir)');
+ok(at.normalizeSpec({ agents: 3 }).agents === 3, 'AC1 agents numérico intacto');
+
+// ---------------------------------------------------------------------------
+// AC2 — união/máximo por dimensão, nunca soma.
+// ---------------------------------------------------------------------------
+const podMax = tmp('podmax');
+fs.mkdirSync(path.join(podMax, 'agents'), { recursive: true });
+fs.writeFileSync(path.join(podMax, 'agents', 'content-chief.md'), '# agente\n');
+fs.mkdirSync(path.join(podMax, 'workflows'), { recursive: true });
+fs.writeFileSync(path.join(podMax, 'workflows', 'wf-x.yaml'), 'steps:\n');
+const specTwoSteps = { pod: 'p', agents: [{ name: 'content-chief', step: 'a' }, { name: 'content-chief', step: 'b' }], workflows: 1, handoffs: 0 };
+const agg = at.aggregateSpec(specTwoSteps, podMax);
+ok(agg.agents === 1, 'AC2 agentes: max(spec dedup 1, disco 1) = 1 — não 3 (soma antiga)', `agents=${agg.agents}`);
+ok(agg.workflows === 1, 'AC2 workflows: max(1 declarado, 1 já gerado) = 1 — não 2', `workflows=${agg.workflows}`);
+ok(agg.handoffs === 0, 'AC2 handoffs: max(0, 0) = 0');
+// Caso incremental real (Risco 3): spec declara MAIS do que há em disco → spec é piso.
+const aggInc = at.aggregateSpec({ pod: 'p', agents: 5, workflows: 3, handoffs: 2 }, podMax);
+ok(aggInc.agents === 5 && aggInc.workflows === 3 && aggInc.handoffs === 2,
+  'AC2 incremental (disco < spec): valor da spec preservado como piso, nunca subconta');
+// Disco maior que a spec continua dominando (semântica do forge-additive preservada).
+const podBig = tmp('podbig');
+fs.mkdirSync(path.join(podBig, 'agents'), { recursive: true });
+for (const n of ['a', 'b', 'c', 'd']) fs.writeFileSync(path.join(podBig, 'agents', `${n}.md`), '# x\n');
+ok(at.classifyTier(at.aggregateSpec({ pod: 'p', agents: ['x', 'y'] }, podBig)).tier === at.TIER_STANDARD,
+  'AC2 spec 2 + disco 4: max=4 > 2 → STANDARD/COMPLEX (caso do forge-additive preservado)');
+
+// ---------------------------------------------------------------------------
+// AC3 — fixture do caso exato do gate SF6.4 (authority-content/academy).
+// Spec no formato real (1 agente físico como 2 etapas) + disco com o .md
+// físico e o wf-*.yaml JÁ gerado a partir desta MESMA spec.
+// ---------------------------------------------------------------------------
+const FIXTURE = path.join(__dirname, '__fixtures__', 'assess-tier', 'retrofit-leve');
+const fxSpec = path.join(FIXTURE, 'pod-spec.json');
+const fxPod = path.join(FIXTURE, 'pod');
+ok(fs.existsSync(fxSpec) && fs.existsSync(fxPod), 'AC3 fixture materializada em __fixtures__/assess-tier/retrofit-leve');
+const cliFix = runCli([fxSpec, '--pod-dir', fxPod]);
+ok(/^tier: SIMPLE/m.test(cliFix.stdout),
+  'AC3 caso SF6.4: --pod-dir agora relata SIMPLE (antes: 3 agentes/2 workflows → STANDARD falso)', cliFix.stdout);
+ok(!/STANDARD/.test(cliFix.stdout), 'AC3 nenhum gatilho falso disparado na fixture');
+const cliFixAlone = runCli([fxSpec]);
+ok(/^tier: SIMPLE/m.test(cliFixAlone.stdout), 'AC3 --pod-dir bate com o caminho standalone (SIMPLE nos dois)');
+
+// ---------------------------------------------------------------------------
+// AC4 — regressão do standalone (byte-idêntico sem nome repetido).
+// ---------------------------------------------------------------------------
+const specPlain = tmp('plain');
+const plainSimple = path.join(specPlain, 'simple.json');
+fs.writeFileSync(plainSimple, JSON.stringify({ agents: ['a', 'b'], workflows: 1, handoffs: 0 }));
+const outSimple = runCli([plainSimple]);
+ok(outSimple.stdout === 'tier: SIMPLE\nnenhum gatilho oposto — caminho leve (SIMPLE).\n',
+  'AC4 standalone SIMPLE sem nome repetido: saída byte-idêntica', JSON.stringify(outSimple.stdout));
+const plainStd = path.join(specPlain, 'std.json');
+fs.writeFileSync(plainStd, JSON.stringify({ agents: ['a', 'b', 'c'], workflows: 2, handoffs: 0 }));
+const outStd = runCli([plainStd]);
+ok(outStd.stdout === 'tier: STANDARD/COMPLEX\ngatilhos que forçaram STANDARD/COMPLEX:\n  - 3 agentes (> 2)\n  - 2 workflows (> 1)\n',
+  'AC4 standalone STANDARD sem nome repetido: saída byte-idêntica', JSON.stringify(outStd.stdout));
+// Com nome repetido: corrigida (dedup) — o gatilho de agentes deixa de disparar.
+const plainDup = path.join(specPlain, 'dup.json');
+fs.writeFileSync(plainDup, JSON.stringify({ agents: [{ name: 'c', step: 'a' }, { name: 'c', step: 'b' }, { name: 'c', step: 'c' }], workflows: 1, handoffs: 0 }));
+const outDup = runCli([plainDup]);
+ok(/^tier: SIMPLE/m.test(outDup.stdout),
+  'AC4 standalone COM nome repetido: corrigida (3 etapas de 1 agente físico → SIMPLE)', outDup.stdout);
+
+// ---------------------------------------------------------------------------
+console.log(`\n${passed} verificações OK, ${failures.length} falha(s).`);
+if (failures.length > 0) {
+  for (const f of failures) console.log(`  - ${f}`);
+  process.exit(1);
+}