@stupify/cli 0.0.16 → 0.2.0

package/.review/CORPUS.md

@@ -0,0 +1,44 @@
+# Good-code reference — taste packs
+
+Judge 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.
+
+---
+
+## Code like Sindre Sorhus (@sindresorhus) · one file, one job
+
+Radical minimalism: each module does exactly one thing and is small enough to read in five minutes. A function
+where a class would do; no surprise dependencies; inputs validated eagerly at the top so failures are loud and
+early. Tiny public surface, deep comments on the *why*. If it can't be read top-to-bottom in one sitting, it's
+too big.
+
+- [`p-limit/index.js`](https://github.com/sindresorhus/p-limit/blob/42599ebbbb1228a5bdab381fcf8f4ac20eb8d551/index.js) — a whole concurrency limiter in one short, obvious file.
+- [`execa/options.js`](https://github.com/sindresorhus/execa/blob/f3a2e8481a1e9138de3895827895c834078b9456/lib/arguments/options.js) — careful, explicit input normalization before anything runs.
+- [`chalk/index.js`](https://github.com/sindresorhus/chalk/blob/aa06bb5ac3f14df9fda8cfb54274dfc165ddfdef/source/index.js) — a clean, composable API with a minimal surface.
+
+
+---
+
+## Code like Anton Kropp (@devshorts) · DI + branded types
+
+The Startup Architecture house style: every domain concept gets its own tiny wrapper type (a `QueueName`,
+never a raw `String`), so a primitive never leaks across a boundary. Dependencies are wired through small,
+single-purpose DI modules listed explicitly at one auditable composition root. Interfaces are single-method
+contracts. `Clock` is injected so tests can move time. Fail fast and loud; no silent fallbacks.
+
+- [`QueueName.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/model/src/main/java/io/paradoxical/cassieq/model/QueueName.java) — a branded value type: a raw string can't masquerade as a `QueueName`.
+- [`DefaultApplicationModules.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/DefaultApplicationModules.java) — the composition root: one explicit list of named DI modules, no magic scanning.
+- [`ClockModule.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/ClockModule.java) — one module, one concern (binds `Clock`), trivially swapped in tests.
+
+
+---
+
+## Code like Colin McDonnell (@colinhacks) · parse, don't validate
+
+Data never enters the system as an unvalidated primitive — it's parsed at the boundary and the parsed type
+guarantees its shape. Schemas are immutable values (methods return new instances). Errors are discriminated
+unions with a `code`, so every branch is exhaustive and typed. `parse` throws (fail fast); `safeParse` returns
+a typed result for callers that want to branch. Composable validators replace hand-rolled type guards.
+
+- [`parse.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/parse.ts) — symmetric `parse`/`safeParse` with the sync/async boundary enforced; the error class is injected, not hardcoded.
+- [`errors.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/errors.ts) — a discriminated-union error type, every field `readonly`, a `path[]` for nested location.
+- [`schemas.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/schemas.ts) — distinct compile-time types per schema kind: illegal states are unrepresentable.

package/.review/CORPUS.template.md

@@ -0,0 +1,73 @@
+# Good-code reference — YOUR curated exemplars (template)
+
+> This is a template. **Replace it with 3–6 files from your own codebase that you'd point a new hire at** —
+> the code you wish all your code looked like. The reviewer treats these as the standard and measures every
+> diff against them. Taste can't be auto-extracted: hand-pick these, and say *why* each is good. A vague
+> corpus produces vague reviews; a sharp one produces sharp ones.
+
+How to write an entry:
+- **Name the file** (a real path in this repo) and **one sentence on what makes it good** — the principle it
+  embodies (e.g. "complexity tamed by decomposition", "type makes illegal states unrepresentable",
+  "fail-fast at the boundary"). The reviewer opens the live file; the excerpt just shows the shape.
+- Keep a short code excerpt that captures the pattern. The point is the *principle*, not the lines.
+- Group loosely (e.g. "complex but readable", "clean service boundary") so the reviewer can cite the right one.
+
+Pick principles you actually care about. Common ones worth encoding:
+**dependency injection** (collaborators injected, never `new`d inline; config read only at a composition root),
+**type-system-first invariants** (`satisfies`, discriminated unions, schemas at boundaries — illegal states
+hard to represent), **fail fast and loud** (no silent fallback), **small single-responsibility units**,
+**declarative over imperative**, **readable signatures** (≤3 positional params → options object).
+
+---
+
+## A. Complex, kept readable
+
+### 1. `src/path/to/your-exemplar.ts` — one line on why it's good
+`src/path/to/your-exemplar.ts`
+
+Say what makes it the standard — e.g. the complexity (optimistic UI, retries, sync) is tamed by decomposition:
+the orchestrator only *coordinates*; every concern is a small focused unit, and every operation is the same
+shape, so N of them read like one.
+
+```ts
+// a short excerpt that shows the pattern — the shape, not the whole file
+export function handle(input: Input): Result {
+  const state = read()
+  const ops = compute(state, input)   // pure
+  return apply(ops)                   // effectful shell
+}
+```
+
+### 2. `src/path/to/another.ts` — composition + named pieces
+`src/path/to/another.ts`
+
+e.g. pure composition — each piece a named small component, conditions become named type-guards, not inline
+boolean soup.
+
+```ts
+function hasMeasuredWidth(width: number | undefined): width is number {
+  return width !== undefined && width > 0
+}
+```
+
+---
+
+## B. Clean boundary / DI
+
+### `src/path/to/service.ts` — injected collaborator + composition-root factory
+`src/path/to/service.ts`
+
+e.g. constructor injection — the collaborator is never `new`d inline; a small factory is the composition root;
+the method parses input at the boundary, logs with structured context, and **fails loud** (catch → log → rethrow).
+
+```ts
+export function createService() {
+  const scope = container.createChildContainer()
+  scope.register(CLIENT, { useValue: makeClient() })
+  return scope.resolve(Service)
+}
+```
+
+---
+
+> Add a "Fine — do NOT flag" set of your own here too, if there are patterns reviewers keep wrongly dinging.

package/.review/REVIEW-PROMPT.md

@@ -0,0 +1,52 @@
+# Review spec — corpus-grounded, anti-slop, with a personality
+
+You are reviewing a code diff for this repo. You're running in the repo with `gh` / `git` / file access and
+your own model — no API key needed. Run these steps:
+
+1. Read `RUBRIC.md` (the anti-slop rubric + finding taxonomy) and `CORPUS.md` (this team's curated "good code"
+   — the primitives it actually uses). Treat the corpus as the standard. Open the live files it points at.
+2. Get the diff for the target PR.
+3. Review every changed code file (skip lockfiles, generated/snapshot files, pure deletions). Catch BOTH
+   kinds from the rubric — the "just wrong" (bug / type-lie / dead-code / footgun) and the "taste / reuse"
+   (reinvents-primitive / slop). "Slop" is code RELATIVE to the simpler or already-existing way: does it
+   reinvent a corpus primitive, or is it bigger / more abstract / more speculative than the corpus pattern for
+   the same job? When you cite a fix, name the actual corpus file/primitive it should use.
+4. Format the review per the **Comment format** below. Report everything incl. low-confidence; don't self-filter.
+5. Post it with the `gh pr comment` command you were given (write the comment to the file, then post).
+
+## Prior reviews on this PR (your memory)
+
+If the runner hands you a **"Prior reviews on this PR"** block, it's the existing review conversation — your
+past reviews and the author's replies. You are CONTINUING that thread, not starting fresh. Treat it as memory:
+
+- **Don't re-raise what's settled.** If you already flagged something and it's now fixed, or the author
+  **declined it with a reason**, do not raise it again — unless the diff brings new evidence that actually
+  rebuts their reason. Re-litigating a reasoned decline is noise (and the fastest way to be ignored).
+- **Report only what's new.** Surface issues introduced since your last review, or ones you genuinely missed.
+  Do not manufacture marginal findings just to have something to say — a nit you wouldn't have raised on
+  round one doesn't become worth raising on round six.
+- **Converge — knowing when to stop is part of the job.** If there are no new issues and the prior ones are
+  addressed or reasonably declined, do NOT write a review. Post exactly this line and nothing else:
+  `no new blocking issues — prior items addressed ✅`
+
+(No prior-reviews block = this is the first review of this PR; ignore this section.)
+
+## Comment format (GitHub markdown — warm + scannable)
+
+- **Opening line — write it yourself: direct, genuinely silly, honest.** ONE short, lowercase-casual line —
+  goofy human noises, drawn-out exclamations, mild swears, the way someone reacts while scrolling code:
+  "uhhhh ummm", "shieeeeet", "oof", "ohhh boy", "ok so… yeah". NOT corporate, NOT clever-witty, NOT a linter
+  header, no praise-padding. Be a little dumb on purpose, then get to what you found. Vary it every run:
+  - nothing wrong → `yep. clean. no notes 🎉` and **stop** (no blocks).
+  - a few small things → `uhhhh ummm a couple things 👇`  ·  `shieeeeet, found some stuff:`  ·  `ok so. some stuff:`
+  - something real → `oh no. ok there's a real one in here:`  ·  `oof, yeah this'll break:`
+  Then a blank line. (Tune this register to your taste — or delete it for a dry tone.)
+- **Each finding** worst-first, as a 3-line block with a blank line between blocks:
+  - line 1: `<emoji> **`path:line`** · <kind> · conf <0–1>`
+  - line 2: what's wrong and why (1–2 sentences, plain — describe the code, don't scold)
+  - line 3: `**→ Fix:** <corpus primitive to reuse, or the correct approach> (`<reference file>`)`
+- Severity emoji: 🔴 high · 🟠 med · 🟡 low.
+- Close with a quiet attribution on its own line so it's clearly the auto-reviewer, not a person:
+  `_— stupify, against the good-code corpus_`
+- No tables, no nested bullets, no preamble before the opener. End the comment with the exact hidden marker
+  line you were given.

package/.review/RUBRIC.md

@@ -0,0 +1,46 @@
+# Anti-slop rubric — the single source of truth for taste
+
+This is what the reviewer judges against, alongside `CORPUS.md`. Edit it to match your team. A reviewer
+catches two kinds of problem. Tag every finding with its `kind`.
+
+## Just wrong — flag regardless of the corpus
+- `kind: bug` — correctness bugs; off-by-one; broken null/empty handling; wrong condition.
+- `kind: type-lie` — a type/annotation that does not match what the code actually returns
+  (e.g. annotated `T | null` but every path returns a non-null value cast to `T`).
+- `kind: dead-code` — unreachable or dead branches; a declared-and-unused const/import/function.
+- `kind: footgun` — swallowed errors / catch-and-continue with no owned degraded state; silent fallbacks;
+  test-only special-casing (`NODE_ENV === 'test'`, env-name string checks) leaking into production code.
+
+## Taste / reuse — relative to the corpus and the simpler way
+- `kind: reinvents-primitive` — a NEW abstraction/layer/wrapper/facade/shim/fallback-reader when a corpus
+  primitive already does it (name the primitive). Or hand-rolling what a corpus file does.
+- `kind: slop` — bigger / more abstract / more speculative than the corpus pattern for the same job:
+  - speculative `unknown` in hand-authored types; `TResult = unknown` generic defaults;
+    `z.unknown()` / `z.array(z.unknown())`
+  - generic-parameter explosion on a call site that is not actually reused generically
+  - `let best*/latest*` imperative argmax/latest accumulator loops
+  - throwaway one-call helpers, or wrapper functions that add no value — a pure pass-through to another fn
+    with the same signature; inline it / call the inner directly
+  - a defensive `?.` / `??` fallback on a value the type or schema already guarantees — e.g. `x?.foo ?? x.y.foo`
+    when `x` is required (or should be). Drop the optional chain and the fallback (it's `x.foo`); if `x` is
+    wrongly optional, fix the schema/type, don't paper over it at the call site
+  - denormalized parallel constants or hardcoded membership lists (derive a Set/Record from ONE `as const` array)
+  - speculative config seams / unused `mode` switches / injectable-override defaults nothing needs yet
+  - additive churn on a cleanup; code that "looks productive" over the minimal change
+
+## Fine — do NOT flag
+- `unknown` at a real parse boundary fed into a normalizer; `Record<string, unknown>` context bags
+- Set/Map-building or dedupe loops (not argmax accumulators)
+- a single choke-point helper its owner reuses
+
+## Weigh the fix against the owner
+Right-size the remedy to the code that owns it. Don't prescribe a heavier primitive than the context warrants:
+a one-off script shouldn't grow a schema library, glue code shouldn't sprout an interface, a guaranteed-shape
+boundary doesn't need the validation an untrusted one does, and an unattended job usually wants a loud default
+over a hard exit. Demanding more rigor than the owner needs is its own slop. If the minimal fix is a one-liner,
+the fix is the one-liner — propose that, not an architecture.
+
+## Output per finding
+`path:line` — [kind] — what's wrong and why — **fix:** the corpus primitive to reuse OR (for a bug) the
+correct approach — severity(high|med|low) · confidence(0–1). Sort worst-first. Report everything incl.
+low-confidence — do not self-filter; a downstream ranker (and your own memory) handles that.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Stupify contributors
+Copyright (c) 2026 Noah Lindner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,58 +1,116 @@
-# @stupify/cli
+> Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as
+> cleverly as possible, you are, by definition, not smart enough to debug it.
+>
+> — **Kernighan's Law**
 
-Local-only diagnostic CLI for checking whether AI is making you dumber.
+# stupify
 
-Released under the MIT License.
+Tired of [wasting your time](https://github.com/thesysdev/openui/issues/517) reviewing [AI](https://github.com/RsyncProject/rsync/issues/929) [slop](https://github.com/anthropics/claudes-c-compiler/issues/1)?
 
-Stupify has one analysis path:
+[![npm](https://img.shields.io/npm/v/@stupify/cli?color=cb3837&label=%40stupify%2Fcli)](https://www.npmjs.com/package/@stupify/cli)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-```text
-sem diff -> counter scout -> Repomix context -> local search model
-```
+**A code reviewer that talks like an idiot and catches real bugs.**
 
-It emits search `matches`, not audit findings.
+Kernighan was right: the clever code is the code you can't debug. stupify drags your code back toward boring —
+at **both ends** of the loop:
 
-```sh
-npx @stupify/cli --staged
-npx @stupify/cli --since "2 weeks ago"
-npx @stupify/cli --commit HEAD
-npx @stupify/cli --commits 20
-git diff HEAD~1..HEAD | npx @stupify/cli --stdin
-```
+- **before you code** — [`stupify prime`](#prime-your-agent-instant-local-no-servers) seeds every Claude Code session with your taste, so the agent writes to your standard from line one.
+- **after you PR** — the reviewer reads every PR on [Codex](https://github.com/openai/codex) against that *same* taste and flags what drifted.
+
+You encode your taste once — a `CORPUS.md` of files you already think are good (or a [taste pack](#taste-packs)) — and stupify enforces it going in and coming out. Not some model's idea of "best practice." So it catches the stuff that actually bugs *you*: premature abstractions, cute one-liners with a bug hiding in them, helpers someone reinvented. Then it points at the boring thing they should've used.
+
+Most AI reviewers carpet-bomb your PR with `consider renaming this`. stupify stays quiet until it finds
+something real, says it in one sentence, and shuts up.
+
+> uhhhh ummm this cleanup got a little cleanup-y:
+>
+> 🟠 **`server/checkout.ts:40`** · slop · conf 0.82
+> you inlined `validateCart` and `applyDiscounts` into the handler, so it's branch soup with two mutable `let`s now, instead of validate → price → charge. those weren't throwaway wrappers, they were the steps.
+> **→ Fix:** put the named steps back. the handler should orchestrate, not do all of it.
+>
+> 🟡 **`server/checkout.ts:12`** · slop · conf 0.7
+> `order?.total ?? order.cart.total` — `order` is required here, so the `?.` never fires and the fallback is dead code cosplaying as safety. it's `order.total`.
+> **→ Fix:** drop the `?.` and the `??`. if order's actually optional, fix the type, don't paper over it.
+>
+> _— stupify, against the good-code corpus_
 
-Install the warn-only pre-commit hook:
+### What you get
 
-```sh
-stupify hook install
+- **Your taste, not the model's.** Everything is judged against a `CORPUS.md` — a [taste pack](#taste-packs) ("code like dtolnay / DHH / antirez …") or your own best files. Nothing to write to start.
+- **Slop, named.** `RUBRIC.md` is your list of what counts as slop: reinvented primitives, speculative abstraction, fallbacks the types already guarantee. It keeps the fix small.
+- **Both ends of the loop.** The *same* `.review/` primes the agent before it writes (prevention) and reviews the PR after (detection). The best review is the one you didn't need.
+- **It remembers.** Reads the PR thread, won't re-raise what you fixed or waved off, posts `no new blocking issues ✅` when there's nothing left.
+- **It's funny.** `oof, yeah this'll break:`. Turn it off if you hate joy.
+
+## Prime your agent (instant, local, no servers)
+
+The best slop is the slop never written. `prime` wires a Claude Code [SessionStart hook](https://docs.claude.com/en/docs/claude-code/hooks) that injects your taste into every session — so the agent holds your standard *before* it touches a line. Pure file read, ~30ms, no model call.
+
+```bash
+bunx @stupify/cli taste --pack sindre-sorhus,zod   # pick the code yours should look like
+bunx @stupify/cli prime --install                  # every Claude Code session now opens knowing it
 ```
 
-The hook runs `stupify --staged` and exits 0.
+That's it. Open Claude Code in any repo and it's already primed. A repo's own `.review/` wins; otherwise it
+falls back to the taste you assembled. `bunx @stupify/cli prime --uninstall` removes the hook cleanly.
+
+## Add the reviewer (rides exe.dev — no keys, no servers *you* run)
 
-Check local setup:
+From your laptop, **one command** provisions a VM that reviews your repo's PRs. No API keys, no tokens — you
+never even SSH anywhere.
 
-```sh
-stupify doctor
+```bash
+bunx @stupify/cli
 ```
 
-Default search enables the checks that currently pass the local hook-safety
-bench: `duplicated_schema`, `unnecessary_complexity`, `over_commenting`,
-`lint_bypass`, and `reinvented_utils`. Other registry patterns can be opted in
-with `--checks`.
+```
+┌  stupify  — provision a reviewer on exe.dev
+◇  using integration acme-widgets
+◇  VM stupify-acme-widgets created
+└  stupify is provisioned for acme/widgets 👀
+```
+
+New to [exe.dev](https://exe.dev)? `ssh exe.dev` to onboard and link GitHub at
+[exe.dev/integrations](https://exe.dev/integrations) — both one-time, both painless. Then just **open a PR** —
+stupify reviews every non-draft, non-bot PR in ~60s, no labels or workflows to wire up. (Want manual control?
+`SCOPE=label` flips it to opt-in: only PRs you tag get reviewed.)
 
-```sh
-stupify --staged --checks over_commenting
+```bash
+bunx @stupify/cli <owner/repo>          # provision for a specific repo
+bunx @stupify/cli setup                 # run the reviewer on this machine instead of a VM
+ssh exe.dev rm stupify-<owner>-<repo>   # tear it down
 ```
 
-Large search inputs are skipped rather than truncated:
+## Taste packs
+
+Don't have a corpus yet? Borrow one. Pick a programmer whose code you'd point a new hire at and review (and
+write) like them — or compose several:
+
+[dtolnay](packs/dtolnay.md) · [DHH](packs/dhh.md) · [antirez](packs/antirez.md) ·
+[Sindre Sorhus](packs/sindre-sorhus.md) · [Rich Harris](packs/rich-harris.md) ·
+[zod](packs/zod.md) · [Mitchell Hashimoto](packs/mitchell-hashimoto.md) ·
+[Tanner Linsley](packs/tanner-linsley.md) · [Simon Willison](packs/simon-willison.md) ·
+[Anton Kropp](packs/anton-kropp.md) · [the perf pack](packs/jarred-sumner.md) · [browse all →](packs)
+
+Each pack is concrete principles plus commit-pinned exemplar files. Or bring your own: drop a
+[`.review/`](.review) in your repo and point `CORPUS.md` at the files you *wish* all your code looked like (it
+always wins over a pack). stupify dogfoods this — its own [`.review/CORPUS.md`](.review/CORPUS.md) is real.
+
+## How it works
 
-```sh
-stupify --staged --max-search-input-tokens 24000
 ```
+prime   Claude Code SessionStart hook → bun ~/.stupify/prime.ts → inject .review/ (rubric + corpus)
+review  cron (~60s) → review-sweep.ts → codex exec → gh pr comment
+          refresh checkout · list open PRs (skip drafts/bots) · skip already-reviewed heads
+          feed the PR's thread back as memory · review against .review/* · post
+```
+
+Both halves read the same `.review/` (a repo's own wins; else the pack taste you assembled). The CLI
+(`src/cli.ts`) sets things up; the engines (`src/prime.ts` and `src/review-sweep.ts`) are dependency-free Bun.
+The whole design — including why it *remembers* instead of debouncing — is in
+[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md).
 
-The package is prepared for the public `@stupify` npm scope. Publishing should
-use the repository release workflow so npm receives Trusted Publishing
-provenance. See the repository release docs.
+## License
 
-This iteration intentionally does not run findings audit, validators, judges,
-baselines, hosted LLM APIs, GitHub integration, dashboards, or repo-wide
-crawling.
+[MIT](LICENSE) © Noah Lindner. Built by the team at [Bevyl](https://bevyl.ai). `stupif.ai` — read it "stupify". PRs welcome — it'll review them 😈

package/package.json

@@ -1,53 +1,54 @@
 {
   "name": "@stupify/cli",
-  "version": "0.0.16",
-  "description": "Local-only diagnostic CLI for checking whether AI is making you dumber.",
-  "private": false,
+  "version": "0.2.0",
+  "description": "A code reviewer that talks like an idiot and catches real bugs — corpus-grounded, anti-slop, runs on Codex.",
   "type": "module",
   "bin": {
-    "stupify": "dist/stupify.js"
+    "stupify": "src/cli.ts"
   },
+  "files": [
+    "src",
+    ".review",
+    "packs",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "homepage": "https://stupif.ai",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Octember/stupif.ai.git",
-    "directory": "packages/cli"
+    "url": "git+https://github.com/Octember/stupify.git"
   },
-  "homepage": "https://stupif.ai",
   "bugs": {
-    "url": "https://github.com/Octember/stupif.ai/issues"
+    "url": "https://github.com/Octember/stupify/issues"
   },
   "keywords": [
+    "code-review",
+    "codex",
     "ai",
-    "cli",
+    "pull-request",
     "developer-tools",
-    "local-first",
-    "code-review"
+    "anti-slop"
   ],
-  "license": "MIT",
   "engines": {
-    "node": ">=20"
+    "bun": ">=1.3"
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
-  "files": [
-    "dist",
-    "src",
-    "LICENSE",
-    "README.md",
-    "package.json"
-  ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepack": "bun run build",
     "typecheck": "tsc -p tsconfig.json",
-    "smoke": "bun run build && node ./dist/stupify.js --help"
+    "test": "bun test",
+    "cli": "bun src/cli.ts"
   },
   "dependencies": {
-    "@ataraxy-labs/sem": "^0.3.24",
     "@clack/prompts": "^1.2.0",
-    "picocolors": "^1.1.1",
-    "repomix": "^1.14.0"
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
   }
 }

package/packs/antirez.md

@@ -0,0 +1,10 @@
+## Code like Salvatore Sanfilippo / antirez (@antirez) · comments that earn their keep
+
+Readable C, of all things — because the comments do real work. ASCII-art diagrams of the data structure sit
+above the code that implements it. Banner section dividers read like chapters. Every function comment states
+the contract, the error return, and the ownership of any pointer it touches. Nothing non-obvious goes
+unexplained; nothing obvious gets a comment.
+
+- [`rax.h`](https://github.com/antirez/rax/blob/1927550cb218ec3c3dda8b39d82d1d019bf0476d/rax.h) — the radix tree drawn in ASCII before a line of it is implemented.
+- [`rax.c`](https://github.com/antirez/rax/blob/1927550cb218ec3c3dda8b39d82d1d019bf0476d/rax.c) — banner-divided sections; each function comment states its contract and pointer ownership.
+- [`sds.h`](https://github.com/antirez/sds/blob/5347739b1581fcba74fd5cab1fc21d2aef317d71/sds.h) — a string library whose header comments are the spec.

package/packs/anton-kropp.md

@@ -0,0 +1,10 @@
+## Code like Anton Kropp (@devshorts) · DI + branded types
+
+The Startup Architecture house style: every domain concept gets its own tiny wrapper type (a `QueueName`,
+never a raw `String`), so a primitive never leaks across a boundary. Dependencies are wired through small,
+single-purpose DI modules listed explicitly at one auditable composition root. Interfaces are single-method
+contracts. `Clock` is injected so tests can move time. Fail fast and loud; no silent fallbacks.
+
+- [`QueueName.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/model/src/main/java/io/paradoxical/cassieq/model/QueueName.java) — a branded value type: a raw string can't masquerade as a `QueueName`.
+- [`DefaultApplicationModules.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/DefaultApplicationModules.java) — the composition root: one explicit list of named DI modules, no magic scanning.
+- [`ClockModule.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/ClockModule.java) — one module, one concern (binds `Clock`), trivially swapped in tests.

package/packs/dhh.md

@@ -0,0 +1,10 @@
+## Code like DHH (@dhh) · controllers that tell the story
+
+Conventions used so consistently that a new file is predictable. Controllers fit on one screen: actions are a
+few lines, all setup pushed into `before_action` filters with self-documenting names (`set_room`,
+`ensure_can_administer`). Cross-cutting behavior is extracted into named concerns (`Authentication`,
+`Authorization`), not sprinkled inline. The code reads like the product, top to bottom.
+
+- [`messages_controller.rb`](https://github.com/basecamp/once-campfire/blob/8d3c2bbd2be070008a275330efbee1001fd202dc/app/controllers/messages_controller.rb) — a controller you can read in one screen; the actions tell the story.
+- [`authentication.rb`](https://github.com/basecamp/once-campfire/blob/8d3c2bbd2be070008a275330efbee1001fd202dc/app/controllers/concerns/authentication.rb) — a named policy extracted as a concern, reused everywhere.
+- [`message.rb`](https://github.com/basecamp/once-campfire/blob/8d3c2bbd2be070008a275330efbee1001fd202dc/app/models/message.rb) — a fat-but-organized model with the domain rules where they belong.

package/packs/dtolnay.md

@@ -0,0 +1,10 @@
+## Code like David Tolnay (@dtolnay) · the API that disappears
+
+The gold standard of idiomatic Rust. Every public type earns its existence; the API surface collapses to the
+minimum, and correct usage is the *only* usage. Errors carry context without leaking internals. Derive macros
+vanish into your types and leave no fingerprint. Trait impls over free functions. Expose the smallest thing
+that works.
+
+- [`thiserror/lib.rs`](https://github.com/dtolnay/thiserror/blob/7214e0e8331d76afbea7173d8a14997512ac8713/src/lib.rs) — a tiny public surface that generates exactly the error impls you'd hand-write.
+- [`thiserror/expand.rs`](https://github.com/dtolnay/thiserror/blob/7214e0e8331d76afbea7173d8a14997512ac8713/impl/src/expand.rs) — the macro internals: precise, readable codegen with no fingerprint left behind.
+- [`anyhow/context.rs`](https://github.com/dtolnay/anyhow/blob/841522b2aa09732fecee40804440d2c35c68c480/src/context.rs) — errors with context attached, internals never leaked.

package/packs/jarred-sumner.md

@@ -0,0 +1,9 @@
+## Code like Jarred Sumner (@Jarred-Sumner) · perf as a correctness concern
+
+The perf pack. Performance decided *structurally*, not by micro-tweaking later: stack-fallback allocators
+before the heap, atomic counters instead of mutexes, `comptime` conditionals that delete dead paths at zero
+runtime cost. Names encode invariants. The root module is a curated namespace, not a junk drawer. Fast because
+the *shape* is fast — and still readable.
+
+- [`bun.zig`](https://github.com/oven-sh/bun/blob/454e3b2884c2bfabfa424ebecc3e9a1a9ee32773/src/bun.zig) — the root namespace, deliberately curated so the fast path is the obvious one.
+- [`AsyncHTTP.zig`](https://github.com/oven-sh/bun/blob/454e3b2884c2bfabfa424ebecc3e9a1a9ee32773/src/http/AsyncHTTP.zig) — concurrency built from atomics and explicit state, not locks bolted on.

package/packs/mitchell-hashimoto.md

@@ -0,0 +1,10 @@
+## Code like Mitchell Hashimoto (@mitchellh) · documented tradeoffs
+
+State machines as exhaustive tagged unions, so every case is handled or it won't compile. Data structures that
+document their own tradeoffs inline. Comments explain the *why* and the tradeoff taken, never the *what*.
+Explicit `MAX_*` constants with the empirical reason next to them. When something is non-obvious, it says so
+candidly instead of pretending it's clean.
+
+- [`Parser.zig`](https://github.com/mitchellh/ghostty/blob/49a9181560707936c587ae121656d2d762d27849/src/terminal/Parser.zig) — a real state machine as an exhaustive enum; no `default:` swallowing the unknown.
+- [`circ_buf.zig`](https://github.com/mitchellh/ghostty/blob/49a9181560707936c587ae121656d2d762d27849/src/datastruct/circ_buf.zig) — a data structure whose comments justify the layout and its costs.
+- [`Config.zig`](https://github.com/mitchellh/ghostty/blob/49a9181560707936c587ae121656d2d762d27849/src/config/Config.zig) — config as typed data with the constraints stated, not scattered through the code.

package/packs/rich-harris.md

@@ -0,0 +1,10 @@
+## Code like Rich Harris (@Rich-Harris) · compiler-grade precision
+
+Library code written with a compiler author's discipline: small named classes with one responsibility,
+immutable sentinel constants (`BLANK`, `EMPTY_SET`) instead of re-allocating, errors that carry a `code` and a
+docs URL. No defensive fallbacks — methods throw immediately with a precise message rather than papering over a
+bad state.
+
+- [`magic-string/Chunk.js`](https://github.com/Rich-Harris/magic-string/blob/410fd4d080d8bf0b5be900c16c8ba11276fd8749/src/Chunk.js) — a focused, mutation-careful data structure.
+- [`rollup/blank.ts`](https://github.com/rollup/rollup/blob/5e0066d92defee0097f10fb814e63f60b2a7b612/src/utils/blank.ts) — shared sentinel objects, named and reused instead of re-allocated.
+- [`rollup/getOrCreate.ts`](https://github.com/rollup/rollup/blob/5e0066d92defee0097f10fb814e63f60b2a7b612/src/utils/getOrCreate.ts) — a one-job helper extracted and reused, not inlined everywhere.

package/packs/simon-willison.md

@@ -0,0 +1,10 @@
+## Code like Simon Willison (@simonw) · one concept per file
+
+(Yes — the person who coined "slop".) Plugin-first design: every extension point is a named hookspec, declared
+before it's implemented. One concept per file (`recipes.py`, `events.py`, `hookspecs.py`). Dataclasses for
+typed events and data. Sentinel values over magic booleans. Docstrings explain the contract, not the
+implementation. Small, obvious, testable seams.
+
+- [`recipes.py`](https://github.com/simonw/sqlite-utils/blob/8f0c06e1889513ed0f01cb57783ddf07c442d4be/sqlite_utils/recipes.py) — one concept per module: small, composable transforms.
+- [`hookspecs.py`](https://github.com/simonw/sqlite-utils/blob/8f0c06e1889513ed0f01cb57783ddf07c442d4be/sqlite_utils/hookspecs.py) — plugin seams declared up front, before any implementation.
+- [`events.py`](https://github.com/simonw/datasette/blob/dfd5b95ec8adc425b683df22148cb1c14bb01128/datasette/events.py) — typed dataclass events instead of loose dicts.

package/packs/sindre-sorhus.md

@@ -0,0 +1,10 @@
+## Code like Sindre Sorhus (@sindresorhus) · one file, one job
+
+Radical minimalism: each module does exactly one thing and is small enough to read in five minutes. A function
+where a class would do; no surprise dependencies; inputs validated eagerly at the top so failures are loud and
+early. Tiny public surface, deep comments on the *why*. If it can't be read top-to-bottom in one sitting, it's
+too big.
+
+- [`p-limit/index.js`](https://github.com/sindresorhus/p-limit/blob/42599ebbbb1228a5bdab381fcf8f4ac20eb8d551/index.js) — a whole concurrency limiter in one short, obvious file.
+- [`execa/options.js`](https://github.com/sindresorhus/execa/blob/f3a2e8481a1e9138de3895827895c834078b9456/lib/arguments/options.js) — careful, explicit input normalization before anything runs.
+- [`chalk/index.js`](https://github.com/sindresorhus/chalk/blob/aa06bb5ac3f14df9fda8cfb54274dfc165ddfdef/source/index.js) — a clean, composable API with a minimal surface.

package/packs/tanner-linsley.md

@@ -0,0 +1,10 @@
+## Code like Tanner Linsley (@tannerlinsley) · types that forbid bad states
+
+Private class fields (`#field`) for real encapsulation. Types do the enforcing: `Updater<T> = T | ((old: T) =>
+T)`, recursion-guarded `DeepKeys<T>`, tuple utilities — illegal states are structurally unrepresentable, caught
+at compile time, not asserted at runtime. Big interfaces are assembled from small feature slices rather than
+written as one god-type.
+
+- [`query/subscribable.ts`](https://github.com/TanStack/query/blob/0bed37a91efa1b6e84b192ca3629d6e0c6cfcb73/packages/query-core/src/subscribable.ts) — a tiny single-purpose unit with truly private state.
+- [`query/focusManager.ts`](https://github.com/TanStack/query/blob/0bed37a91efa1b6e84b192ca3629d6e0c6cfcb73/packages/query-core/src/focusManager.ts) — one concern, encapsulated, testable.
+- [`table/type-utils.ts`](https://github.com/TanStack/table/blob/ed814260e0a863861f8387087e72feef1b75cd37/packages/table-core/src/types/type-utils.ts) — type-algebra that makes the wrong shape a compile error.

package/packs/zod.md

@@ -0,0 +1,10 @@
+## Code like Colin McDonnell (@colinhacks) · parse, don't validate
+
+Data never enters the system as an unvalidated primitive — it's parsed at the boundary and the parsed type
+guarantees its shape. Schemas are immutable values (methods return new instances). Errors are discriminated
+unions with a `code`, so every branch is exhaustive and typed. `parse` throws (fail fast); `safeParse` returns
+a typed result for callers that want to branch. Composable validators replace hand-rolled type guards.
+
+- [`parse.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/parse.ts) — symmetric `parse`/`safeParse` with the sync/async boundary enforced; the error class is injected, not hardcoded.
+- [`errors.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/errors.ts) — a discriminated-union error type, every field `readonly`, a `path[]` for nested location.
+- [`schemas.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/schemas.ts) — distinct compile-time types per schema kind: illegal states are unrepresentable.