claude-code-session-manager 0.25.1 → 0.27.0

package/src/main/__tests__/dod-report.test.cjs

@@ -0,0 +1,304 @@
+/**
+ * dod-report.test.cjs — unit tests for flagRiskySurfaces + writeReport.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/dod-report.test.cjs
+ *
+ * Fixtures: os.tmpdir() only — never writes into real runs/.
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { flagRiskySurfaces, writeReport } = require('../lib/definitionOfDone.cjs');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'dod-report-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writePrd(prdsDir, slug, implNotes, cwd) {
+  const body = [
+    '---',
+    `title: ${slug}`,
+    `cwd: ${cwd}`,
+    'estimateMinutes: 5',
+    '---',
+    '',
+    '# Goal',
+    '',
+    'Test fixture.',
+    '',
+    '# Acceptance criteria',
+    '',
+    '- [ ] `timeout 10 node -e "process.exit(0)"` passes.',
+    '',
+    '# Implementation notes',
+    '',
+    implNotes,
+    '',
+    '# Out of scope',
+    '',
+    '- N/A',
+  ].join('\n');
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
+  return { slug, cwd };
+}
+
+// ─── flagRiskySurfaces: money-path ────────────────────────────────────────────
+
+test('flagRiskySurfaces: flags money-path when impl notes reference payment', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '201-billing', '- Edit `src/payment-processor.js`\n- Update order schema', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.strictEqual(flags[0].slug, '201-billing');
+    assert.ok(flags[0].surfaces.includes('money-path'), `expected money-path in ${JSON.stringify(flags[0].surfaces)}`);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: flags auth when impl notes reference auth/token', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '202-auth', '- Modify `src/auth-middleware.py`\n- Update token refresh logic', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.ok(flags[0].surfaces.includes('auth'));
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: flags migration when impl notes reference .sql file', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '203-schema', '- Run `db/migrations/0042_users.sql`', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.ok(flags[0].surfaces.includes('migration'));
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: clean job is not returned', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '204-clean', '- Update `src/ui/button.tsx`\n- Add tooltip component', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 0);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: job with no PRD file is skipped (not thrown)', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  try {
+    const flags = flagRiskySurfaces([{ slug: '205-missing', cwd }], { prdsDir });
+    assert.strictEqual(flags.length, 0);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: mixed batch returns only risky jobs', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const jobRisky = writePrd(prdsDir, '206-risky', '- Modify `src/trade-engine.js`', cwd);
+  const jobClean = writePrd(prdsDir, '207-clean', '- Update `src/tooltip.tsx`', cwd);
+  try {
+    const flags = flagRiskySurfaces([jobRisky, jobClean], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.strictEqual(flags[0].slug, '206-risky');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+// ─── writeReport: structure ────────────────────────────────────────────────────
+
+test('writeReport: all three jobs appear in AC table', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [
+    { slug: '101-pass',  status: 'pass',         code: 0,    ms: 500 },
+    { slug: '102-fail',  status: 'fail',         code: 1,    ms: 300 },
+    { slug: '103-risky', status: 'pass',         code: 0,    ms: 400 },
+  ];
+  const riskFlags = [{ slug: '103-risky', surfaces: ['money-path'] }];
+  try {
+    const reportPath = writeReport('abcd1234', { acResults, riskFlags, runsDir });
+    assert.ok(fs.existsSync(reportPath), `report missing at ${reportPath}`);
+    const content = fs.readFileSync(reportPath, 'utf8');
+    assert.ok(content.includes('101-pass'), 'missing 101-pass in table');
+    assert.ok(content.includes('102-fail'), 'missing 102-fail in table');
+    assert.ok(content.includes('103-risky'), 'missing 103-risky in table');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: fail and risky slug both appear in needs-attention list', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [
+    { slug: '101-pass',  status: 'pass', code: 0, ms: 500 },
+    { slug: '102-fail',  status: 'fail', code: 1, ms: 300 },
+    { slug: '103-risky', status: 'pass', code: 0, ms: 400 },
+  ];
+  const riskFlags = [{ slug: '103-risky', surfaces: ['money-path'] }];
+  try {
+    const reportPath = writeReport('abcd1234', { acResults, riskFlags, runsDir });
+    const content = fs.readFileSync(reportPath, 'utf8');
+    // Both should appear in the Needs Human Attention section
+    const attentionIdx = content.indexOf('## Needs Human Attention');
+    assert.ok(attentionIdx !== -1, 'missing Needs Human Attention section');
+    const attentionSection = content.slice(attentionIdx);
+    assert.ok(attentionSection.includes('102-fail'), '102-fail missing from attention list');
+    assert.ok(attentionSection.includes('103-risky'), '103-risky missing from attention list');
+    // Clean pass should NOT be in attention list
+    const passInAttention = attentionSection.includes('101-pass');
+    assert.ok(!passInAttention, '101-pass should not appear in attention list');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: report states review is recommended, not auto-run', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  try {
+    const reportPath = writeReport('abcd1234', { acResults: [], riskFlags: [], runsDir });
+    const content = fs.readFileSync(reportPath, 'utf8');
+    assert.ok(
+      content.toLowerCase().includes('recommended') && content.toLowerCase().includes('not auto-run'),
+      'report must state review is recommended, not auto-run'
+    );
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: no .tmp files left after write', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [{ slug: '101-pass', status: 'pass', code: 0, ms: 100 }];
+  try {
+    writeReport('deadbeef', { acResults, riskFlags: [], runsDir });
+    // Walk all files in runsDir recursively, check none end in .tmp-*
+    function findTmps(dir) {
+      const hits = [];
+      try {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, e.name);
+          if (e.isDirectory()) hits.push(...findTmps(full));
+          else if (e.name.includes('.tmp-')) hits.push(full);
+        }
+      } catch { /* */ }
+      return hits;
+    }
+    const tmps = findTmps(runsDir);
+    assert.deepStrictEqual(tmps, [], `found leftover tmp files: ${tmps.join(', ')}`);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: second call with same batchKey produces clean report, no tmp files', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [
+    { slug: '101-pass', status: 'pass', code: 0, ms: 100 },
+    { slug: '102-fail', status: 'fail', code: 1, ms: 200 },
+  ];
+  const riskFlags = [{ slug: '101-pass', surfaces: ['auth'] }];
+  try {
+    writeReport('cafebabe', { acResults, riskFlags, runsDir });
+    // Small delay to guarantee different timestamp dir
+    const t = Date.now() + 2;
+    while (Date.now() < t) { /* busy wait 2ms */ }
+    const report2 = writeReport('cafebabe', { acResults, riskFlags, runsDir });
+
+    // Second report must exist and be valid
+    assert.ok(fs.existsSync(report2));
+    const content = fs.readFileSync(report2, 'utf8');
+
+    // No duplicate rows in the AC table — slice only the AC table section.
+    const acStart = content.indexOf('## AC Results');
+    const riskStart = content.indexOf('## Risk Flags');
+    const acSection = content.slice(acStart, riskStart === -1 ? undefined : riskStart);
+    const passCount = (acSection.match(/101-pass/g) || []).length;
+    const failCount = (acSection.match(/102-fail/g) || []).length;
+    assert.strictEqual(passCount, 1, `101-pass appears ${passCount} times in AC table`);
+    assert.strictEqual(failCount, 1, `102-fail appears ${failCount} times in AC table`);
+
+    // No tmp files anywhere
+    function findTmps(dir) {
+      const hits = [];
+      try {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, e.name);
+          if (e.isDirectory()) hits.push(...findTmps(full));
+          else if (e.name.includes('.tmp-')) hits.push(full);
+        }
+      } catch { /* */ }
+      return hits;
+    }
+    assert.deepStrictEqual(findTmps(runsDir), []);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: report filename contains the batchKey', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  try {
+    const reportPath = writeReport('feed1234', { acResults: [], riskFlags: [], runsDir });
+    assert.ok(path.basename(reportPath).includes('feed1234'));
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: invalid batchKey throws', () => {
+  assert.throws(
+    () => writeReport('not-hex!!', { acResults: [], riskFlags: [] }),
+    /invalid batchKey/
+  );
+});

package/src/main/hives.cjs

@@ -1,29 +1,28 @@
 /**
- * hives.cjs — pre-baked subagent swarm templates ("Hives").
+ * hives.cjs — subagent recipe templates ("Hives").
  *
- * A Hive is a named collection of subagent roles + an optional default plan,
- * launchable as one unit. Concept ported from ClaudeCodeUnleashed; our shape
- * is `{ slug, name, description, roles: [{ label, prompt }], defaultPlan? }`
- * (renderer launches by configuring Orchestrator with those roles).
+ * A Recipe is a named sequence of steps, each referencing an agent by name
+ * from `~/.claude/agents/<agentName>.md`. Shape:
+ *   { slug, name, description, brief?, steps: [{ agentName, note? }] }
+ *
+ * Legacy hives (old shape: `roles: [{ label, prompt }]`) are migrated on
+ * first read: each role is materialized as an agent .md and replaced by a
+ * step referencing it. Migration is idempotent and permanent (re-saved).
  *
  * Storage: `~/.claude/session-manager/hives/<slug>.json`
  *   - slug must match SLUG_RE: /^[a-z0-9-_]{1,64}$/
- *   - up to 32 roles per hive
+ *   - up to 32 steps per recipe
  *   - per-field byte caps mirrored in the inline zod schemas below
  *
- * IPC namespace:
- *   - hives:list   -> { hives: Hive[], error: string | null }
- *   - hives:get    -> { hive: Hive | null, error: string | null }
+ * IPC namespace (channel names kept for backwards compat):
+ *   - hives:list   -> { hives: Recipe[], error: string | null }
+ *   - hives:get    -> { hive: Recipe | null, error: string | null }
  *   - hives:save   -> { ok: boolean, error: string | null }
  *   - hives:delete -> { ok: boolean, error: string | null }
  *
- * All mutations go through config.cjs::writeJson (atomic tmp+rename) and
- * config.cjs::validatePath (allowedRoots = home dir). Never raw fs.writeFile.
- *
- * Default hives (Code review / Build feature / Bug hunt) ship in the renderer
- * (src/renderer/lib/defaultHives.ts) and are NOT writable to disk — they exist
- * only as in-memory starter examples so a fresh install has content. The IPC
- * layer only sees user-saved hives.
+ * All mutations go through config.cjs::writeJson / writeTextAtomic (atomic
+ * tmp+rename) and config.cjs::validatePath (allowedRoots = home dir).
+ * Never raw fs.writeFile.
  */
 
 'use strict';
@@ -37,34 +36,35 @@ const config = require('./config.cjs');
 
 // ──────────────────────────────────────────── caps
 const SLUG_RE = /^[a-z0-9-_]{1,64}$/;
+const AGENT_NAME_RE = /^[a-z0-9-_]{1,64}$/;
 const MAX_NAME_LEN = 128;
 const MAX_DESC_LEN = 2048;
-const MAX_LABEL_LEN = 128;
-const MAX_PROMPT_LEN = 16 * 1024;
-const MAX_PLAN_LEN = 8 * 1024;
-const MAX_ROLES = 32;
+const MAX_BRIEF_LEN = 8 * 1024;
+const MAX_NOTE_LEN = 2048;
+const MAX_STEPS = 32;
 
 // ──────────────────────────────────────────── inline zod schemas
-const hiveRoleSchema = z.object({
-  label: z.string().min(1).max(MAX_LABEL_LEN),
-  prompt: z.string().min(1).max(MAX_PROMPT_LEN),
+const recipeStepSchema = z.object({
+  agentName: z.string().regex(AGENT_NAME_RE),
+  note: z.string().max(MAX_NOTE_LEN).optional(),
 }).strict();
 
-const hiveSchema = z.object({
+const recipeSchema = z.object({
   slug: z.string().regex(SLUG_RE),
   name: z.string().min(1).max(MAX_NAME_LEN),
   description: z.string().max(MAX_DESC_LEN).default(''),
-  roles: z.array(hiveRoleSchema).min(1).max(MAX_ROLES),
-  defaultPlan: z.string().max(MAX_PLAN_LEN).optional(),
+  brief: z.string().max(MAX_BRIEF_LEN).optional(),
+  steps: z.array(recipeStepSchema).min(1).max(MAX_STEPS),
 }).strict();
 
 const slugPayload = z.object({
   slug: z.string().regex(SLUG_RE),
 }).strict();
 
+// Field name "hive" kept for IPC channel backwards compatibility.
 const savePayload = z.object({
   slug: z.string().regex(SLUG_RE),
-  hive: hiveSchema,
+  hive: recipeSchema,
 }).strict();
 
 // ──────────────────────────────────────────── paths
@@ -72,6 +72,10 @@ function rootDir() {
   return path.join(os.homedir(), '.claude', 'session-manager', 'hives');
 }
 
+function agentsDir() {
+  return path.join(os.homedir(), '.claude', 'agents');
+}
+
 function hivePath(slug) {
   if (!SLUG_RE.test(slug)) {
     throw new Error(`invalid hive slug (must match ${SLUG_RE.source})`);
@@ -83,6 +87,58 @@ async function ensureRoot() {
   await fsp.mkdir(rootDir(), { recursive: true });
 }
 
+// ──────────────────────────────────────────── helpers
+function kebabCase(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64) || 'agent';
+}
+
+// ──────────────────────────────────────────── legacy migration
+async function migrateLegacyHive(slug, raw) {
+  const adir = agentsDir();
+  await fsp.mkdir(adir, { recursive: true });
+
+  const usedNames = new Set();
+  const steps = [];
+
+  for (const role of (raw.roles ?? [])) {
+    let base = kebabCase(role.label ?? 'agent');
+    let agentName = base;
+    let suffix = 2;
+    while (usedNames.has(agentName)) {
+      agentName = `${base.slice(0, 62)}-${suffix++}`;
+    }
+    usedNames.add(agentName);
+
+    const agentFilePath = path.join(adir, `${agentName}.md`);
+    // validatePath ensures we stay within allowedRoots (home dir).
+    const validPath = config.validatePath(agentFilePath);
+
+    let exists = false;
+    try { await fsp.stat(validPath); exists = true; } catch { /* ENOENT = not yet created */ }
+
+    if (!exists) {
+      const descLine = (role.prompt ?? '').replace(/[\r\n]+/g, ' ').slice(0, 200);
+      const content = `---\nname: ${role.label}\ndescription: ${descLine}\n---\n\n${role.prompt ?? ''}\n`;
+      await config.writeTextAtomic(validPath, content);
+    }
+
+    steps.push({ agentName });
+  }
+
+  const recipe = {
+    slug,
+    name: raw.name,
+    description: raw.description ?? '',
+    steps,
+    ...(raw.defaultPlan ? { brief: raw.defaultPlan } : {}),
+  };
+
+  // Persist migrated shape permanently so subsequent reads skip migration.
+  await saveHive(slug, recipe);
+
+  return { hive: recipe, error: null };
+}
+
 // ──────────────────────────────────────────── core ops
 async function listHives() {
   try {
@@ -118,13 +174,20 @@ async function readHive(slug) {
   const r = await config.readJson(abs);
   if (!r || !r.exists) return { hive: null, error: null };
   if (r.parseError) return { hive: null, error: `parse error: ${r.parseError}` };
+
+  const raw = r.data;
+
+  // Legacy migration: old shape has `roles` array instead of `steps`.
+  if (raw && Array.isArray(raw.roles) && !Array.isArray(raw.steps)) {
+    return migrateLegacyHive(slug, raw);
+  }
+
   // Re-validate stored shape so a hand-edited file can't smuggle in bad data.
-  const parsed = hiveSchema.safeParse(r.data);
+  const parsed = recipeSchema.safeParse(raw);
   if (!parsed.success) {
-    return { hive: null, error: `invalid hive on disk: ${parsed.error.issues[0]?.message ?? 'unknown'}` };
+    return { hive: null, error: `invalid recipe on disk: ${parsed.error.issues[0]?.message ?? 'unknown'}` };
   }
-  // Trust the file's own slug only if it matches the filename; otherwise force
-  // them to agree (filename wins — that's the storage key).
+  // Trust the file's own slug only if it matches the filename; filename wins.
   const hive = { ...parsed.data, slug };
   return { hive, error: null };
 }
@@ -139,8 +202,7 @@ async function getHive(slug) {
 
 async function saveHive(slug, hive) {
   try {
-    // Body slug must match path slug. Reject mismatches loudly so the renderer
-    // can't accidentally overwrite the wrong file by tampering with `slug`.
+    // Body slug must match path slug.
     if (hive.slug !== slug) {
       return { ok: false, error: `slug mismatch: payload slug "${hive.slug}" != path "${slug}"` };
     }
@@ -148,10 +210,9 @@ async function saveHive(slug, hive) {
     const abs = hivePath(slug);
     const out = {
       ...hive,
-      // Strip undefined for clean JSON on disk.
       description: hive.description ?? '',
     };
-    if (out.defaultPlan === undefined || out.defaultPlan === '') delete out.defaultPlan;
+    if (out.brief === undefined || out.brief === '') delete out.brief;
     const result = await config.writeJson(abs, out);
     if (!result || !result.ok) {
       return { ok: false, error: result?.error ?? 'write failed' };
@@ -178,7 +239,6 @@ async function deleteHive(slug) {
       await fsp.unlink(real);
     } catch (e) {
       if (e.code === 'ENOENT') {
-        // Treat missing as success — idempotent delete, same as fs unlink ENOENT.
         return { ok: true, error: null };
       }
       return { ok: false, error: e.message };