@polderlabs/bizar 10.7.1 → 10.7.2

package/.claude/hooks/__tests__/sessionend-recall.test.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * .claude/hooks/__tests__/sessionend-recall.test.mjs
+ *
+ * Unit tests for sessionend-recall.mjs — SessionEnd hook that writes
+ * .bizar/sessions/<date>-<id>.md and .bizar/session-state.json from a
+ * synthesized transcript.
+ *
+ * Strategy: spawn the hook binary with a synthetic transcript on disk;
+ * assert files are written correctly.
+ */
+'use strict';
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, rmSync, existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOK_PATH = join(__dirname, '..', 'sessionend-recall.mjs');
+
+function runHook(inputJson, cwd) {
+  const r = spawnSync('node', [HOOK_PATH], {
+    input: JSON.stringify(inputJson),
+    encoding: 'utf8',
+    cwd: cwd || process.cwd(),
+    timeout: 8000,
+  });
+  return { status: r.status, stdout: r.stdout.trim(), stderr: r.stderr.trim() };
+}
+
+function makeProject({ withActiveFeature = true } = {}) {
+  const dir = join(tmpdir(), `bh-recall-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(join(dir, '.bizar'), { recursive: true });
+  if (withActiveFeature) {
+    writeFileSync(
+      join(dir, 'feature_list.json'),
+      JSON.stringify({
+        features: [
+          { id: 'F-103', state: 'active', behavior: 'rewrite sessionstart-prime' },
+        ],
+      }),
+    );
+  }
+  return dir;
+}
+
+function makeTranscript(events) {
+  const path = join(tmpdir(), `bh-transcript-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.jsonl`);
+  writeFileSync(path, events.map((e) => JSON.stringify(e)).join('\n') + '\n');
+  return path;
+}
+
+function readSessionState(dir) {
+  const p = join(dir, '.bizar', 'session-state.json');
+  if (!existsSync(p)) return null;
+  try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+function readSessionNote(dir) {
+  const p = join(dir, '.bizar', 'sessions');
+  if (!existsSync(p)) return null;
+  const files = readdirSync(p).filter((f) => f.endsWith('.md'));
+  if (files.length === 0) return null;
+  const newest = files.sort().slice(-1)[0];
+  return { name: newest, body: readFileSync(join(p, newest), 'utf8') };
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+test('SessionEnd: writes session note + state from transcript', () => {
+  const dir = makeProject();
+  const transcript = makeTranscript([
+    { type: 'message', timestamp: '2026-07-22T18:00:00Z', message: { role: 'user', content: 'implement F-103 hook overhaul' } },
+    { type: 'message', timestamp: '2026-07-22T18:00:05Z', message: { role: 'assistant', content: [
+      { type: 'tool_use', name: 'Write', input: { file_path: '/home/drb0rk/.claude/hooks/sessionstart-prime.mjs', content: 'x' } },
+    ]}},
+    { type: 'message', timestamp: '2026-07-22T18:00:10Z', message: { role: 'user', content: 'continue' } },
+  ]);
+  try {
+    const { status } = runHook({
+      session_id: 'abc123def456789',
+      reason: 'exit',
+      cwd: dir,
+      transcript_path: transcript,
+    });
+    assert.equal(status, 0);
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.equal(state.lastSessionId, 'abc123def456789');
+    assert.equal(state.reason, 'exit');
+    assert.equal(state.activeFeature, 'F-103');
+    assert.match(state.nextStep, /implement F-103 hook overhaul/);
+    const note = readSessionNote(dir);
+    assert.ok(note);
+    assert.match(note.name, /\d{4}-\d{2}-\d{2}-abc123de\.md/);
+    assert.match(note.body, /activeFeature: F-103/);
+    assert.match(note.body, /implement F-103 hook overhaul/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: extracts bash commands and tools used', () => {
+  const dir = makeProject();
+  const transcript = makeTranscript([
+    { type: 'message', timestamp: '2026-07-22T18:00:00Z', message: { role: 'user', content: 'fix the bug' } },
+    { type: 'message', timestamp: '2026-07-22T18:00:05Z', message: { role: 'assistant', content: [
+      { type: 'tool_use', name: 'Bash', input: { command: 'ls /missing' } },
+      { type: 'tool_use', name: 'Edit', input: { file_path: '/tmp/foo.mjs' } },
+      { type: 'tool_use', name: 'Bash', input: { command: 'make check' } },
+    ]}},
+  ]);
+  try {
+    runHook({ session_id: 'xyz987', reason: 'exit', cwd: dir, transcript_path: transcript });
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.equal(state.toolsUsed.Bash, 2);
+    assert.equal(state.toolsUsed.Edit, 1);
+    assert.ok(state.filesTouched.includes('/tmp/foo.mjs'));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: captures errors as blockers', () => {
+  const dir = makeProject();
+  const transcript = makeTranscript([
+    { type: 'message', timestamp: '2026-07-22T18:00:00Z', message: { role: 'user', content: 'fix the bug' } },
+    { type: 'message', timestamp: '2026-07-22T18:00:05Z', message: { role: 'assistant', content: [
+      { type: 'tool_use', id: 'x1', name: 'Bash', input: { command: 'cat /missing' } },
+    ]}},
+    { type: 'message', timestamp: '2026-07-22T18:00:06Z', message: { role: 'tool', content: [
+      { type: 'tool_result', tool_use_id: 'x1', content: 'Error: ENOENT: no such file or directory' },
+    ]}},
+  ]);
+  try {
+    runHook({ session_id: 'err', reason: 'exit', cwd: dir, transcript_path: transcript });
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.ok(state.blockers.some((b) => b.includes('ENOENT')));
+    assert.match(state.nextStep, /Resolve Error: ENOENT/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: skips filler prompts when picking nextStep', () => {
+  const dir = makeProject();
+  const transcript = makeTranscript([
+    { type: 'message', timestamp: '2026-07-22T18:00:00Z', message: { role: 'user', content: 'rewire the SessionStart briefing' } },
+    { type: 'message', timestamp: '2026-07-22T18:00:05Z', message: { role: 'user', content: 'continue' } },
+    { type: 'message', timestamp: '2026-07-22T18:00:10Z', message: { role: 'user', content: 'yes' } },
+    { type: 'message', timestamp: '2026-07-22T18:00:15Z', message: { role: 'user', content: 'go on' } },
+  ]);
+  try {
+    runHook({ session_id: 'filer', reason: 'exit', cwd: dir, transcript_path: transcript });
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.match(state.nextStep, /rewire the SessionStart briefing/);
+    assert.doesNotMatch(state.nextStep, /Resume: continue/);
+    assert.doesNotMatch(state.nextStep, /Resume: yes/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: zero active features surfaces "pick next"', () => {
+  const dir = makeProject({ withActiveFeature: false });
+  const transcript = makeTranscript([]);  // empty transcript → no prompts
+  try {
+    runHook({ session_id: 'noact', reason: 'exit', cwd: dir, transcript_path: transcript });
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.equal(state.activeFeature, null);
+    assert.match(state.nextStep, /Pick next feature/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: malformed JSONL lines are skipped, hook exits 0', () => {
+  const dir = makeProject();
+  const transcript = join(tmpdir(), `bh-bad-${Date.now()}.jsonl`);
+  writeFileSync(
+    transcript,
+    'not json\n{"type":"message","timestamp":"2026-07-22T18:00:00Z","message":{"role":"user","content":"real prompt"}}\nstill bad\n',
+  );
+  try {
+    const { status } = runHook({ session_id: 'junk', reason: 'exit', cwd: dir, transcript_path: transcript });
+    assert.equal(status, 0);
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.match(state.nextStep, /real prompt/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+19  }
+});
+
+test('SessionEnd: missing transcript_path is graceful, exits 0', () => {
+  const dir = makeProject();
+  try {
+    const { status } = runHook({ session_id: 'none', reason: 'exit', cwd: dir });
+    assert.equal(status, 0);
+    const state = readSessionState(dir);
+    assert.ok(state);
+    // No transcript means no user prompts, no errors.
+    assert.equal(state.filesTouched.length, 0);
+    assert.equal(state.blockers.length, 0);
+    // F-103 is active in the default fixture, so nextStep continues with it.
+    assert.match(state.nextStep, /Continue with F-103/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: invalid JSON on stdin exits 0 with empty state', () => {
+  const dir = makeProject();
+  try {
+    const r = spawnSync('node', [HOOK_PATH], {
+      input: 'not json',
+      encoding: 'utf8',
+      cwd: dir,
+      timeout: 8000,
+    });
+    assert.equal(r.status, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionEnd: handles transcript with 200+ lines (cap respected)', () => {
+  const dir = makeProject();
+  const events = [];
+  for (let i = 0; i < 250; i++) {
+    events.push({
+      type: 'message',
+      timestamp: `2026-07-22T18:${String(Math.floor(i / 60)).padStart(2, '0')}:${String(i % 60).padStart(2, '0')}Z`,
+      message: { role: 'user', content: i === 249 ? 'final substantive prompt' : `prompt ${i}` },
+    });
+  }
+  const transcript = makeTranscript(events);
+  try {
+    const { status } = runHook({ session_id: 'long', reason: 'exit', cwd: dir, transcript_path: transcript });
+    assert.equal(status, 0);
+    const state = readSessionState(dir);
+    assert.ok(state);
+    assert.match(state.nextStep, /final substantive prompt|Resume: final substantive prompt/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/.claude/hooks/__tests__/sessionstart-prime.test.mjs

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * .claude/hooks/__tests__/sessionstart-prime.test.mjs
+ *
+ * Unit tests for sessionstart-prime.mjs — the SessionStart hook that reads
+ * PROGRESS.md + feature_list.json + git log + .bizar/PROJECT.md and emits a
+ * structured briefing.
+ *
+ * Strategy: spawn the hook binary as a subprocess, feed it stdin JSON, and
+ * assert on stdout JSON. This avoids drift between test and source — what
+ * the binary emits IS what the tests check.
+ */
+'use strict';
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOK_PATH = join(__dirname, '..', 'sessionstart-prime.mjs');
+
+function runHook(inputJson, cwd) {
+  const r = spawnSync('node', [HOOK_PATH], {
+    input: JSON.stringify(inputJson),
+    encoding: 'utf8',
+    cwd: cwd || process.cwd(),
+    timeout: 8000,
+  });
+  return {
+    status: r.status,
+    stdout: r.stdout.trim(),
+    stderr: r.stderr.trim(),
+  };
+}
+
+function parseStdout(stdout) {
+  if (!stdout) return null;
+  try { return JSON.parse(stdout); } catch { return null; }
+}
+
+function additionalContext(stdout) {
+  const obj = parseStdout(stdout);
+  if (!obj) return '';
+  return (obj.hookSpecificOutput && obj.hookSpecificOutput.additionalContext) || '';
+}
+
+// ── Fixtures ───────────────────────────────────────────────────────────────
+
+function makeProject({ withProgress = true, withFeatureList = true, withProject = true } = {}) {
+  const dir = join(tmpdir(), `bh-prime-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(join(dir, '.bizar'), { recursive: true });
+  if (withProject) {
+    writeFileSync(
+      join(dir, '.bizar', 'PROJECT.md'),
+      '# TestProject\nA test fixture for the SessionStart hook.\n',
+    );
+  }
+  if (withProgress) {
+    writeFileSync(
+      join(dir, 'PROGRESS.md'),
+      [
+        '# PROGRESS',
+        '',
+        '## Current State',
+        '',
+        'Branch: master | Last: 3b4f6f7 | Status: green',
+        '',
+        '## In Progress — F-099 hook overhaul',
+        '',
+        'Sprint S46: rewriting sessionstart-prime.mjs to read project state.',
+        '',
+        '## Done',
+        '',
+        '- F-098..F-102 shipped.',
+      ].join('\n'),
+    );
+  }
+  if (withFeatureList) {
+    writeFileSync(
+      join(dir, 'feature_list.json'),
+      JSON.stringify({
+        features: [
+          { id: 'F-100', state: 'passing', behavior: 'old feature' },
+          { id: 'F-101', state: 'passing', behavior: 'old feature 2' },
+          { id: 'F-103', state: 'active', behavior: 'rewrite sessionstart-prime' },
+        ],
+      }),
+    );
+  }
+  // Initialize a git repo so `git log` works.
+  spawnSync('git', ['init', '-q'], { cwd: dir });
+  spawnSync('git', ['config', 'user.email', 'test@example.com'], { cwd: dir });
+  spawnSync('git', ['config', 'user.name', 'Test'], { cwd: dir });
+  spawnSync('git', ['commit', '--allow-empty', '-q', '-m', 'init'], { cwd: dir });
+  return dir;
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+test('SessionStart: startup source emits structured briefing', () => {
+  const dir = makeProject();
+  try {
+    const { stdout, status } = runHook({ source: 'startup', cwd: dir });
+    assert.equal(status, 0, `hook exit non-zero (stderr: see above)`);
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(startup\)/);
+    assert.match(ctx, /A test fixture for the SessionStart hook/);
+    assert.match(ctx, /Active feature: F-103/);
+    assert.match(ctx, /rewrite sessionstart-prime/);
+    assert.match(ctx, /WIP=1 honored/);
+    assert.match(ctx, /First move:/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: clear source is lighter (no feature list, no git reread)', () => {
+  const dir = makeProject();
+  try {
+    const { stdout } = runHook({ source: 'clear', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(clear\)/);
+    // clear branch doesn't include feature stats
+    assert.doesNotMatch(ctx, /Active feature:/);
+    // It DOES include PROGRESS.md current-state (last commit line + Progress: line)
+    assert.match(ctx, /Progress:|Last commit:/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: resume source reads session-state.json handoff', () => {
+  const dir = makeProject();
+  try {
+    const handoff = {
+      lastSessionId: 'prior-session-id',
+      lastSessionEnd: '2026-07-22T15:00:00Z',
+      reason: 'exit',
+      activeFeature: 'F-103',
+      nextStep: 'finish the briefing unit tests',
+      filesTouched: ['/foo/bar.mjs'],
+      blockers: ['Error: ENOENT'],
+    };
+    writeFileSync(join(dir, '.bizar', 'session-state.json'), JSON.stringify(handoff));
+    const { stdout } = runHook({ source: 'resume', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(resume\)/);
+    assert.match(ctx, /Last active feature: F-103/);
+    assert.match(ctx, /finish the briefing unit tests/);
+    assert.match(ctx, /Open blockers: Error: ENOENT/);
+    assert.match(ctx, /WARNING: context may have been compacted/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: resume with no session-state.json is graceful', () => {
+  const dir = makeProject();
+  try {
+    const { stdout } = runHook({ source: 'resume', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(resume\)/);
+    assert.match(ctx, /No prior session-state\.json found/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: WIP>1 violation surfaces in briefing', () => {
+  const dir = makeProject();
+  try {
+    writeFileSync(
+      join(dir, 'feature_list.json'),
+      JSON.stringify({
+        features: [
+          { id: 'F-A', state: 'active', behavior: 'one' },
+          { id: 'F-B', state: 'active', behavior: 'two' },
+          { id: 'F-C', state: 'passing', behavior: 'three' },
+        ],
+      }),
+    );
+    const { stdout } = runHook({ source: 'startup', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /WIP VIOLATION/);
+    assert.match(ctx, /F-A/);
+    assert.match(ctx, /F-B/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: zero active features surfaces "pick next"', () => {
+  const dir = makeProject();
+  try {
+    writeFileSync(
+      join(dir, 'feature_list.json'),
+      JSON.stringify({
+        features: [
+          { id: 'F-100', state: 'passing', behavior: 'old' },
+          { id: 'F-101', state: 'passing', behavior: 'old2' },
+        ],
+      }),
+    );
+    const { stdout } = runHook({ source: 'startup', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /2\/2 passing/);
+    assert.match(ctx, /No active feature/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: missing PROGRESS.md is graceful', () => {
+  const dir = makeProject({ withProgress: false });
+  try {
+    const { stdout, status } = runHook({ source: 'startup', cwd: dir });
+    assert.equal(status, 0);
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(startup\)/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: missing feature_list.json is graceful', () => {
+  const dir = makeProject({ withFeatureList: false });
+  try {
+    const { stdout, status } = runHook({ source: 'startup', cwd: dir });
+    assert.equal(status, 0);
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(startup\)/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: missing .bizar/PROJECT.md is graceful', () => {
+  const dir = makeProject({ withProject: false });
+  try {
+    const { stdout, status } = runHook({ source: 'startup', cwd: dir });
+    assert.equal(status, 0);
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(startup\)/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: invalid JSON on stdin exits 0 with empty briefing', () => {
+  const dir = makeProject();
+  try {
+    const r = spawnSync('node', [HOOK_PATH], {
+      input: '{not valid json',
+      encoding: 'utf8',
+      cwd: dir,
+      timeout: 8000,
+    });
+    assert.equal(r.status, 0);
+    const obj = parseStdout(r.stdout);
+    assert.ok(obj);
+    assert.ok(obj.hookSpecificOutput);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: defaults source to startup when missing', () => {
+  const dir = makeProject();
+  try {
+    const { stdout } = runHook({ cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /Bizar SessionStart \(startup\)/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: briefing is hard-capped at 800 characters', () => {
+  const dir = makeProject();
+  try {
+    // Bloat each component individually so the composed briefing exceeds 800 chars.
+    const giantProject = ['# BigProject', '', 'A '.repeat(200).trim(), ' that is the one-line summary.'].join('\n');
+    writeFileSync(join(dir, '.bizar', 'PROJECT.md'), giantProject);
+    const giantProgress = '## Current State\n\nBranch: master | ' + 'filler '.repeat(50) + '\n\n' +
+      '## In Progress — F-099\n\n' + 'body '.repeat(200);
+    writeFileSync(join(dir, 'PROGRESS.md'), giantProgress);
+    const manyActive = Array.from({ length: 50 }, (_, i) => ({
+      id: `F-${100 + i}`,
+      state: 'passing',
+      behavior: 'a passing feature with a long description that fills space',
+    }));
+    manyActive.push({ id: 'F-103', state: 'active', behavior: 'rewrite sessionstart-prime' });
+    writeFileSync(join(dir, 'feature_list.json'), JSON.stringify({ features: manyActive }));
+    // Make many commits to bloat `git log --oneline -10`.
+    for (let i = 0; i < 12; i++) {
+      spawnSync('git', ['commit', '--allow-empty', '-q', '-m', `commit ${'x'.repeat(60)} ${i}`], { cwd: dir });
+    }
+    const { stdout } = runHook({ source: 'startup', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.ok(ctx.length <= 800, `briefing is ${ctx.length} chars, cap is 800`);
+    assert.match(ctx, /…$/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('SessionStart: project_summary reads first non-heading line', () => {
+  const dir = makeProject();
+  try {
+    writeFileSync(
+      join(dir, '.bizar', 'PROJECT.md'),
+      '# MyProject\n\nThis is the one-line summary.\n\nOther stuff.\n',
+    );
+    const { stdout } = runHook({ source: 'startup', cwd: dir });
+    const ctx = additionalContext(stdout);
+    assert.match(ctx, /This is the one-line summary\./);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});