@stupify/cli 0.0.16 → 0.2.0

package/src/prime-install.test.ts

@@ -0,0 +1,109 @@
+// Guards the hook installer's contract — it writes to the user's Claude Code settings.json, so the invariants
+// that matter are: MERGE (never clobber other hooks/keys), IDEMPOTENT (no duplicate), SURGICAL uninstall
+// (remove only ours), and REFUSE malformed JSON. Driven through the real CLI subprocess against throwaway
+// STUPIFY_HOME + CLAUDE_CONFIG_DIR dirs, so the real ~/.claude is never touched.
+import { expect, test } from 'bun:test'
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const CLI = join(import.meta.dir, 'cli.ts')
+
+function env() {
+  const home = mkdtempSync(join(tmpdir(), 'stupify-home-'))
+  const cfg = mkdtempSync(join(tmpdir(), 'stupify-cc-'))
+  return { home, cfg, settings: join(cfg, 'settings.json') }
+}
+const run = (sub: string[], e: { home: string; cfg: string }) =>
+  spawnSync('bun', [CLI, ...sub], { env: { ...process.env, STUPIFY_HOME: e.home, CLAUDE_CONFIG_DIR: e.cfg }, encoding: 'utf8' })
+const read = (p: string) => JSON.parse(readFileSync(p, 'utf8'))
+const seeded = JSON.stringify({ theme: 'dark', hooks: { PostToolUse: [{ matcher: 'Edit', hooks: [{ type: 'command', command: 'echo keep' }] }] } })
+
+test('--install merges into existing settings without clobbering, and is idempotent', () => {
+  const e = env()
+  writeFileSync(e.settings, seeded)
+  run(['prime', '--install'], e)
+  let s = read(e.settings)
+  expect(s.theme).toBe('dark') // unrelated key survives
+  expect(s.hooks.PostToolUse[0].hooks[0].command).toBe('echo keep') // unrelated hook survives
+  expect(s.hooks.SessionStart[0].matcher).toBe('startup')
+  expect(s.hooks.SessionStart[0].hooks[0].command).toContain('prime.ts') // points at the copied dep-free engine
+  expect(existsSync(join(e.home, 'prime.ts'))).toBe(true) // engine copied
+
+  run(['prime', '--install'], e) // again
+  s = read(e.settings)
+  expect(s.hooks.SessionStart).toHaveLength(1) // no duplicate
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})
+
+test('--uninstall removes only our hook + engine, preserving everything else', () => {
+  const e = env()
+  writeFileSync(e.settings, seeded)
+  run(['prime', '--install'], e)
+  run(['prime', '--uninstall'], e)
+  const s = read(e.settings)
+  expect(s.theme).toBe('dark')
+  expect(s.hooks.PostToolUse[0].hooks[0].command).toBe('echo keep')
+  expect(s.hooks.SessionStart).toBeUndefined() // ours gone; empty array collapsed
+  expect(existsSync(join(e.home, 'prime.ts'))).toBe(false) // engine removed
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})
+
+test('--install refuses to clobber a malformed settings.json', () => {
+  const e = env()
+  writeFileSync(e.settings, 'NOT JSON {')
+  const r = run(['prime', '--install'], e)
+  expect(readFileSync(e.settings, 'utf8')).toContain('NOT JSON') // left untouched
+  expect(r.status).not.toBe(0) // died non-zero rather than overwrite
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})
+
+test('--uninstall on a machine with no settings.json is a clean no-op', () => {
+  const e = env()
+  const r = run(['prime', '--uninstall'], e)
+  expect(r.status).toBe(0)
+  expect(existsSync(e.settings)).toBe(false)
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})
+
+test('taste --pack assembles ~/.stupify/.review and nothing else (no reviewer leaks in)', () => {
+  const e = env()
+  run(['taste', '--pack', 'anton-kropp,zod'], e)
+  expect(readFileSync(join(e.home, '.review', 'CORPUS.md'), 'utf8')).toContain('Anton Kropp') // packs assembled
+  expect(existsSync(join(e.home, 'config.env'))).toBe(false) // no reviewer config
+  expect(existsSync(join(e.home, 'review-sweep.ts'))).toBe(false) // no reviewer engine
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})
+
+test('--install refreshes a stale command on re-install (not just the engine file)', () => {
+  const e = env()
+  run(['prime', '--install', '--pack', 'zod'], e)
+  // simulate bun having moved since first install: rewrite the stored command to a stale path
+  // (keep the engine path so the entry is still recognized as ours)
+  const s = read(e.settings)
+  s.hooks.SessionStart[0].hooks[0].command = `/old/stale/bun ${join(e.home, 'prime.ts')}`
+  writeFileSync(e.settings, JSON.stringify(s))
+  run(['prime', '--install', '--pack', 'zod'], e)
+  const after = read(e.settings)
+  expect(after.hooks.SessionStart).toHaveLength(1) // still no duplicate
+  expect(after.hooks.SessionStart[0].hooks[0].command).not.toContain('/old/stale/bun') // stale path corrected
+  expect(after.hooks.SessionStart[0].hooks[0].command).toContain('prime.ts')
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})
+
+test('prime --install --pack assembles taste AND wires the hook in one step', () => {
+  const e = env()
+  run(['prime', '--install', '--pack', 'zod'], e)
+  expect(readFileSync(join(e.home, '.review', 'CORPUS.md'), 'utf8')).toContain('zod') // taste assembled
+  const s = read(e.settings)
+  expect(s.hooks.SessionStart[0].hooks[0].command).toContain('prime.ts') // and hook wired
+  rmSync(e.home, { recursive: true, force: true })
+  rmSync(e.cfg, { recursive: true, force: true })
+})

package/src/prime.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+/**
+ * stupify prime — emit the pre-decided taste (rubric + corpus index) as a Claude Code SessionStart hook
+ * payload, so a coding session opens already holding your standard instead of only catching slop in review.
+ *
+ * Dependency-free (node builtins only) ON PURPOSE: `stupify prime --install` drops a copy of THIS file at
+ * ~/.stupify/prime.ts and points the hook at it, so the hook runs fast with no global install and no
+ * node_modules. Pure file read — no model, no network. It must NEVER break session start: any miss or error
+ * emits nothing and exits 0. stdout is ONLY the JSON payload (a stray byte makes Claude Code drop it).
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const HOME = process.env.STUPIFY_HOME ?? join(homedir(), '.stupify')
+
+/** Resolve taste like the reviewer does (the repo you're coding in wins, else the pack taste setup assembled)
+ *  and build the SessionStart payload. Returns null when no taste is set up — caller emits nothing. */
+export function primePayload(cwd: string = process.cwd(), home: string = HOME): string | null {
+  const dir = [join(cwd, '.review'), join(home, '.review')].find(
+    (d) => existsSync(join(d, 'RUBRIC.md')) && existsSync(join(d, 'CORPUS.md')),
+  )
+  if (dir === undefined) return null
+  const rubric = readFileSync(join(dir, 'RUBRIC.md'), 'utf8').trim()
+  const corpus = readFileSync(join(dir, 'CORPUS.md'), 'utf8').trim()
+  const additionalContext = `# Your taste, loaded by stupify — write to this standard
+
+You're about to write or change code in this repo. Hold every edit to the standard below BEFORE you write it —
+it's the same taste stupify reviews against, so matching it now is a clean review later.
+
+## What counts as slop here — don't ship it (RUBRIC)
+${rubric}
+
+## The code yours should look like (CORPUS)
+The links are commit-pinned exemplars — open one only if a finding needs the detail; never paste them in wholesale.
+${corpus}`
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext } })
+}
+
+/** Write the payload to stdout, or nothing. Swallows every error: a hook must never disrupt session start. */
+export function emitPrime(): void {
+  try {
+    const payload = primePayload()
+    if (payload !== null) process.stdout.write(payload)
+  } catch {
+    /* never break session start */
+  }
+}
+
+if (import.meta.main) emitPrime() // run directly (the installed hook calls `bun ~/.stupify/prime.ts`)

package/src/review-sweep.test.ts

@@ -0,0 +1,101 @@
+// Proof of the cache invariant: the review prompt's PREFIX (instructions + spec + rubric + corpus index) is
+// byte-identical for every PR in a repo, and ONLY the tail (diff target, marker, memory) changes. That stable
+// prefix is what the provider caches across diff threads — if a per-PR token ever leaked into it, the cache
+// would thrash and this test would go red. We render against the repo's own real .review/ (no mocks).
+import { expect, test } from 'bun:test'
+import { join } from 'node:path'
+import { type Config, type Pr, reviewPrompt, stablePrefix } from './review-sweep'
+
+const REVIEW_DIR = join(import.meta.dir, '..', '.review') // the real spec/rubric/corpus shipped in this repo
+const THIS_PR = '===== THIS PR' // the boundary between the cached prefix and the per-PR tail
+
+const cfg = (): Config => ({
+  repoDir: '/tmp/x',
+  remote: 'https://github.com/acme/widgets.git',
+  slug: 'acme/widgets',
+  defaultBranch: 'main',
+  reviewDir: REVIEW_DIR,
+  homeReviewDir: REVIEW_DIR,
+  scope: 'label',
+  reviewLabel: 'codex-review',
+  diffLineCap: 800,
+  dryRun: false,
+  maxPrs: 15,
+  stateDir: '/tmp/x/state',
+  codexEffort: 'high',
+  codexProvider: '',
+  codexModel: '',
+})
+
+const pr = (number: number, sha: string): Pr => ({
+  number,
+  headRefOid: sha,
+  isDraft: false,
+  author: { login: 'someone', is_bot: false },
+  labels: [{ name: 'codex-review' }],
+})
+
+const sha256 = (s: string) => new Bun.CryptoHasher('sha256').update(s).digest('hex')
+const prefixOf = (prompt: string) => prompt.slice(0, prompt.indexOf(THIS_PR))
+
+// Three different PRs: different numbers, different head SHAs, and (crucially) one mid-thread with memory —
+// the hardest case, since "continuing a review" must STILL not perturb the prefix.
+const prompts = [
+  reviewPrompt(cfg(), pr(1, 'a'.repeat(40)), ''),
+  reviewPrompt(cfg(), pr(42, 'b'.repeat(40)), ''),
+  reviewPrompt(cfg(), pr(987, 'c'.repeat(40)), 'PRIOR-THREAD: a past review and the author reply'),
+]
+const prefixes = prompts.map(prefixOf)
+
+test('the cached prefix is byte-identical across every PR (incl. mid-thread)', () => {
+  const hashes = new Set(prefixes.map(sha256))
+  expect(hashes.size).toBe(1) // one and only one prefix hash, no matter the PR
+  expect(prefixes[0]).toBe(prefixes[1])
+  expect(prefixes[0]).toBe(prefixes[2])
+})
+
+test('the prefix equals stablePrefix(cfg) and carries the real taste, not generic weights', () => {
+  expect(prefixes[0]?.trimEnd()).toBe(stablePrefix(cfg()).trimEnd())
+  expect(prefixes[0]).toContain('===== RUBRIC')
+  expect(prefixes[0]).toContain('===== CORPUS')
+})
+
+test('NO per-PR token leaks into the cached prefix', () => {
+  for (const prefix of prefixes) {
+    expect(prefix).not.toContain('gh pr diff') // the diff command lives in the tail
+    expect(prefix).not.toContain('a'.repeat(40)) // no head SHA / marker
+    expect(prefix).not.toContain('b'.repeat(40))
+    expect(prefix).not.toContain('PRIOR-THREAD') // memory lives in the tail
+  }
+})
+
+test('only the tail changes — per-PR content is present and correct there', () => {
+  expect(prompts[0]).not.toBe(prompts[1]) // whole prompts differ...
+  expect(prompts[0]).toContain('gh pr diff 1 --repo acme/widgets')
+  expect(prompts[1]).toContain('gh pr diff 42 --repo acme/widgets')
+  expect(prompts[2]).toContain('gh pr diff 987 --repo acme/widgets')
+  expect(prompts[2]).toContain('PRIOR-THREAD') // memory threaded into the tail
+})
+
+test('the prefix is large enough to be cache-eligible (well past the ~1024-token floor)', () => {
+  const bytes = prefixes[0]?.length ?? 0
+  const approxTokens = Math.round(bytes / 4) // ~4 chars/token, the standard rough estimate
+  expect(approxTokens).toBeGreaterThan(1024)
+
+  // Receipt: print the proof so a human sees it, plus the per-100-PR cost model the prefix-cache buys.
+  const reads = 100
+  const naive = reads // full-price prefix on every run
+  const cached = 1 + (reads - 1) * 0.1 // full once, then ~10% cache-read on the rest
+  console.log(
+    [
+      '',
+      '  ── cache invariant proof ─────────────────────────────',
+      `  prefix sha256 (all PRs):  ${sha256(prefixes[0] ?? '')}`,
+      `  prefix size:              ${bytes} bytes  (~${approxTokens} tokens)`,
+      `  prefix identical across:  ${prefixes.length} distinct PRs (incl. one mid-thread)`,
+      `  prefix cost over ${reads} PRs:   naive ${naive.toFixed(1)}× vs cached ${cached.toFixed(1)}× → ${Math.round((1 - cached / naive) * 100)}% off the prefix`,
+      '  ──────────────────────────────────────────────────────',
+      '',
+    ].join('\n'),
+  )
+})