Guarantee formatting and linting with a pre-commit hook

[abernier]

Adds husky + lint-staged, so formatting and linting are guaranteed at commit time rather than left to scripts nobody runs.

What runs on commit

staged	task
every staged file	prettier --write --ignore-unknown
—	pnpm lint
turbo.json, test/**, vitest.config.ts	pnpm test:turbo

And on push, pnpm check — the four tasks CI gates on, before CI runs them. It reads the whole repo (format:check alone is ~10s), so it is worth paying once per push and not once per commit; nothing new since the last push is FULL TURBO (~0.1s).

pnpm test deliberately runs in neither: turbo test is 326 playwright tasks that a repo-wide change invalidates wholesale (266s in CI for the reformat commits, against 93s cached), and the snapshots are not time-deterministic — a hook that runs them refuses commits at random, and the habit it teaches is git commit -n.

pnpm lint is now the one entry point for every linter — turbo lint lint:metadata lint:versions. The two root scripts become //# tasks in turbo.json with explicit inputs, so what needs re-running is a question turbo answers from the task graph rather than one the hook guesses with globs of its own: a commit that moved nothing lint-relevant is ~0.5s (FULL TURBO) instead of ~4.5s, and touching one pmndrs.json re-runs the metadata check while syncpack replays from cache.

Verified on the cache: a pmndrs.json edit misses metadata and hits syncpack; a .syncpackrc.json or pnpm-workspace.yaml edit does the opposite; docs-only touches hit everything. Failures are never cached — a broken pmndrs.json re-executes and fails on every run until fixed.

--concurrent false in the hook, plus one ordered task array: pnpm lint reads the files prettier may have just rewritten.

What CI gates on

CI ran lint:metadata and lint:versions directly. It now runs pnpm check — the same four tasks — which brings eslint and a repo-wide prettier --check under CI for the first time. The hook is the fast path in front of that gate, not the only thing enforcing it. CI also runs pnpm test:turbo.

format:check becomes //#format:check, with $TURBO_DEFAULT$ for its inputs rather than an explicit **: ** also hashes what git ignores, so the .turbo/ logs written by the run itself changed the hash every time — a task that never hit its own cache, and took ~26s hashing node_modules on the way.

One config, one style

The examples carried 160 .prettierrc (plus two prettier keys in a package.json) for 23 distinct variants of the same intent — among them a printWidth of 16078 and a fluid option prettier has never had. All of them are gone: prettier.config.mjs is now the only prettier config in the repo, and every file in it is formatted the same way.

That is 805 files reformatted to the repo style. Keeping the sandbox look (160 cols, no semicolons, single quotes) as an examples/** override would have cost 428 files instead — but it only ever bought a look, and once every example had been reformatted anyway, byte-identity with the sandboxes they were copied from was gone regardless.

One file, examples/svg-maps-with-html-annotations/src/index.jsx, needs two prettier passes to converge; it is committed converged.

What prettier must not touch

.prettierignore is new. The compiled payloads in it are picked by a measurement — max line length — because prettier claims a parser for all of them and --ignore-unknown therefore does not help:

**/draco*/            # minified, 200k-character lines
**/realism-effects/   # vendored bundles, 87k-character lines
**/*.gltf             # 3D scenes; prettier parses them as json

Three further entries are there for reasons of their own:

.claude/              # local agent checkouts, plus a vendored skill that has
                      # to stay byte-identical to what its registry emits
pnpm-lock.yaml        # generated
patches/              # `format:check` runs without `--ignore-unknown`, so a
                      # `.patch` would error rather than be skipped

.glb, .blob, .svg and .splinecode need no entry — prettier has no parser for them. Build outputs and .turbo/ need none either: they are gitignored, and prettier reads .gitignore as well. Font atlases are deliberately not ignored: they are json, and 94% of the catch-up diff is two of them being expanded from a single 800k-character line.

A test for the cache

test/turbo-cache.test.ts (vitest, 10 cases, 12s) pins which file makes which task re-run: build for one example, eslint, the metadata and syncpack checks, format:check. It runs turbo with --dry, so asserting on a build costs a hash rather than a vite build. Sabotaging an inputs list in turbo.json fails exactly the cases that name it — including the hash-stability case, which is there because inputs: ["**"] hashed gitignored files (the run's own .turbo/ logs) and the task could never hit its own cache.

Catch-up

Three commits format the repo so the hook starts from zero drift: 349 files to each example's own .prettierrc, then 428 and 805 more as those 160 configs were unified away. prettier --check over every tracked file now passes.

Also here

• examples/lulaby-city/package.json: drops a vestigial lint-staged block + devDependency inherited from its CodeSandbox template. Nothing ran it, but a lint-staged key makes that directory its own config root — staged files under it would have escaped the root config entirely.

prepare: husky installs the hook on pnpm install. Bypass with git commit -n.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Vtf9zptihDq57ThnNMVfUK