@williamthorsen/nmr 0.20.0 → 0.22.0

package/README.md

@@ -3,33 +3,17 @@
 Context-aware script runner for pnpm monorepos. Ships an `nmr` (node-monorepo run) binary that provides centralized, consistent script execution across workspace packages and the monorepo root.
 
 <!-- section:release-notes -->
-## Release notes — v0.20.0 (2026-07-28)
+## Release notes — v0.22.0 (2026-07-31)
 
 ### 🎉 Features
 
-- 🚨 **Breaking:** Migrate to code-quality workflow v7 and retire the version-restatement apparatus (#503)
+- 🚨 **Breaking:** Ship shell and Dockerfile formatting from a shared nmr Prettier config (#540)
 
-  Migrates the code-quality workflow from `@v6` to `@v7`, which no longer requires the Node version to be specified in two places, and removes the test that previously checked for drift. Also removed are the `nmr sync-pnpm-version` command and drift-related exported functions.
+  Adds the ability to format shell scripts and Dockerfiles to `nmr fmt`. `@williamthorsen/nmr` now provides a common config for consistency across projects. Shell fences inside Markdown are now formatted as well. These features are absorbed into `nmr fmt` and `nmr fmt:check`; the `fmt:sh` and `fmt:all` commands are removed.
 
-  Taking this upgrade requires migrating the repo's code-quality workflow to `@v7` and deleting its version-alignment test in the same change.
+- 🚨 **Breaking:** Require the monorepo root in the shared root Vitest config (#541)
 
-- 🚨 **Breaking:** Resolve workspace packages with pnpm's pattern semantics (#509)
-
-  nmr now excludes packages matched by a `!`-prefixed pattern in `pnpm-workspace.yaml` from the packages it operates on. Deep globs such as `packages/**` now match nested packages, and running a command from inside a nested package targets that package rather than an enclosing ancestor. Exclusion patterns must be quoted to take effect. nmr now requires Node.js 24.16 or later.
-
-- Report pnpm overrides when reviewing dependencies (#514)
-
-  From the monorepo root, `nmr upgrade` now reports the repo's active pnpm dependency overrides alongside the upgrade report, making clear when a pin is the reason an expected upgrade is absent. Repos that wired up this override report themselves with an install-time hook can now remove that hook.
-
-- Trim the bundled agent guidance to a cheatsheet (#516)
-
-  Trims the agent guidance nmr installs into consuming repos from 100 lines to 10. Only the bare essentials are now injected into context. Agents are instructed to consult the package's README for details.
-
-### 🐛 Bug fixes
-
-- Anchor script execution to the resolved registry's directory (#517)
-
-  Fixes an issue where `nmr --workspace-root`, run from inside a workspace package, either failed outright or silently acted on the wrong directory. Commands now behave the same regardless of the directory they are invoked from: root commands act on the monorepo root, and package commands on their own package. Two changes for existing users: `nmr --workspace-root clean` now sweeps every workspace package instead of cleaning only the current one, and relative paths passed to a script now resolve against the directory the script runs in.
+  Modifies the testing configuration so that root-level test runs always cover the repository containing the configuration. The shared root Vitest config now requires a `monorepoRoot` option specifying an absolute path to the repository's own root, in place of the optional search origin. A repository nested inside a parent monorepo fails instead of resolving silently to its parent.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -56,17 +40,17 @@ nmr works out of the box with no configuration. It ships with built-in scripts f
 From a package directory:
 
 ```bash
-nmr test          # Run tests for the current package
-nmr build         # Compile to .js and .d.ts in one pass
-nmr check         # Typecheck, format check, lint check, and tests
+nmr test  # Run tests for the current package
+nmr build # Compile to .js and .d.ts in one pass
+nmr check # Typecheck, format check, lint check, and tests
 ```
 
 From the monorepo root:
 
 ```bash
-nmr test          # Run root tests + recursive workspace tests
-nmr build         # Build all packages
-nmr ci            # Run build && check:strict && audit (full CI pipeline)
+nmr test  # Run root tests + recursive workspace tests
+nmr build # Build all packages
+nmr ci    # Run build && check:strict && audit (full CI pipeline)
 ```
 
 nmr detects where you are and selects the right scripts automatically — see [context-aware resolution](#context-aware-resolution) below.
@@ -75,11 +59,11 @@ nmr detects where you are and selects the right scripts automatically — see [c
 
 nmr's key feature is that the same command runs different scripts depending on where you invoke it. It walks up from your current directory to find `pnpm-workspace.yaml`, then checks whether your CWD is inside a workspace package directory.
 
-| Where you run `nmr`               | Registry used     | Working directory | `nmr test` runs                               |
-| --------------------------------- | ----------------- | ----------------- | --------------------------------------------- |
-| Monorepo root                     | Root scripts      | Monorepo root     | Root tests + `pnpm --recursive exec nmr test` |
-| Inside a workspace package        | Workspace scripts | The package root  | `pnpm exec vitest` (for that package only)    |
-| Anywhere, with `--workspace-root` | Root scripts      | Monorepo root     | Root tests + `pnpm --recursive exec nmr test` |
+| Where you run `nmr`               | Registry used     | Working directory | `nmr test` runs                                                 |
+| --------------------------------- | ----------------- | ----------------- | --------------------------------------------------------------- |
+| Monorepo root                     | Root scripts      | Monorepo root     | Root tests + `pnpm --recursive exec nmr test`                   |
+| Inside a workspace package        | Workspace scripts | The package root  | `pnpm exec vitest --project '!integration'` (that package only) |
+| Anywhere, with `--workspace-root` | Root scripts      | Monorepo root     | Root tests + `pnpm --recursive exec nmr test`                   |
 
 Relative paths in a script resolve against that working directory, not the invocation directory.
 
@@ -227,9 +211,9 @@ The second example calls the bin directly, which sidesteps the workspace-versus-
 The upgrade tool ([taze](https://github.com/antfu-collective/taze)) arrives with nmr, so your repo declares no dependency on it. Everything after the command name is passed through, including the range mode:
 
 ```bash
-nmr upgrade          # upgrades available within each package's version ceilings
-nmr upgrade major    # major upgrades, still inside the ceilings
-nmr upgrade --write  # apply the proposals to package.json
+nmr upgrade         # upgrades available within each package's version ceilings
+nmr upgrade major   # major upgrades, still inside the ceilings
+nmr upgrade --write # apply the proposals to package.json
 ```
 
 ### Configuring upgrades
@@ -259,38 +243,48 @@ These scripts are available out of the box. Repo-wide config (tier 2) and per-pa
 
 ### Workspace scripts
 
-| Command         | Runs                                                     |
-| --------------- | -------------------------------------------------------- |
-| `build`         | `compile`                                                |
-| `check`         | `typecheck`, `fmt:check`, `lint:check`, `test`           |
-| `check:strict`  | `typecheck`, `fmt:check`, `lint:strict`, `test:coverage` |
-| `clean`         | `nmr-clean`                                              |
-| `compile`       | `nmr-compile`                                            |
-| `fix`           | `lint`, `fmt`                                            |
-| `fix:check`     | `fmt:check`, `lint:check`                                |
-| `fmt`           | `prettier --list-different --write .`                    |
-| `fmt:check`     | `prettier --check .`                                     |
-| `lint`          | `eslint --fix .`                                         |
-| `lint:check`    | `eslint .`                                               |
-| `lint:strict`   | `strict-lint`                                            |
-| `test`          | `pnpm exec vitest`                                       |
-| `test:coverage` | `pnpm exec vitest --coverage`                            |
-| `test:watch`    | `pnpm exec vitest --watch`                               |
-| `typecheck`     | `tsgo --noEmit`                                          |
-| `upgrade`       | `nmr-taze --include-locked`                              |
-| `view-coverage` | `open coverage/index.html`                               |
-
-#### Integration test variant
-
-A package gets this variant automatically when it contains a `vitest.integration.config.ts` file: `test` and `test:coverage` run the standalone (non-integration) suite, and integration tests run only when invoked explicitly. Activation is detected per package, so it applies under the recursive `nmr ci` fan-out. Opting in requires **both** `vitest.integration.config.ts` and `vitest.standalone.config.ts`, since the standalone scripts reference the latter.
-
-| Command            | Runs                                                               |
-| ------------------ | ------------------------------------------------------------------ |
-| `test`             | `pnpm exec vitest --config=vitest.standalone.config.ts`            |
-| `test:all`         | `pnpm exec vitest`                                                 |
-| `test:coverage`    | `pnpm exec vitest --config=vitest.standalone.config.ts --coverage` |
-| `test:integration` | `pnpm exec vitest --config=vitest.integration.config.ts`           |
-| `test:watch`       | `pnpm exec vitest --config=vitest.standalone.config.ts --watch`    |
+| Command            | Runs                                                     |
+| ------------------ | -------------------------------------------------------- |
+| `build`            | `compile`                                                |
+| `check`            | `typecheck`, `fmt:check`, `lint:check`, `test`           |
+| `check:strict`     | `typecheck`, `fmt:check`, `lint:strict`, `test:coverage` |
+| `clean`            | `nmr-clean`                                              |
+| `compile`          | `nmr-compile`                                            |
+| `fix`              | `lint`, `fmt`                                            |
+| `fix:check`        | `fmt:check`, `lint:check`                                |
+| `fmt`              | `nmr-fmt --write`                                        |
+| `fmt:check`        | `nmr-fmt --check`                                        |
+| `lint`             | `eslint --fix .`                                         |
+| `lint:check`       | `eslint .`                                               |
+| `lint:strict`      | `strict-lint`                                            |
+| `test`             | `pnpm exec vitest --project '!integration'`              |
+| `test:all`         | `pnpm exec vitest`                                       |
+| `test:coverage`    | `pnpm exec vitest --project '!integration' --coverage`   |
+| `test:integration` | `pnpm exec vitest --project integration`                 |
+| `test:watch`       | `pnpm exec vitest --project '!integration' --watch`      |
+| `typecheck`        | `tsgo --noEmit`                                          |
+| `upgrade`          | `nmr-taze --include-locked`                              |
+| `view-coverage`    | `open coverage/index.html`                               |
+
+`fmt` and `fmt:check` select their files through git rather than by walking the directory, which is what makes a package-level run and a root-level run apply the same ignore rules — see [file selection](#file-selection).
+
+#### Test selections
+
+Every package resolves the same five test commands. Nothing is detected on disk: the commands select [Vitest projects](#shared-vitest-config), so a package separates its integration tests by naming them `*.int.test.ts`, not by carrying extra config files.
+
+| To run                              | Command            |
+| ----------------------------------- | ------------------ |
+| Everything except integration tests | `test`             |
+| Integration tests alone             | `test:integration` |
+| Every project                       | `test:all`         |
+
+`test` negates `integration` rather than naming the code-only projects, so a category added later joins the default run instead of being dropped from it.
+
+`test:coverage` and `test:watch` are the same selection as `test` in a different mode. There are no `test:integration --coverage` equivalents because none are needed: everything after a command name is forwarded untouched, so `nmr test:integration --coverage` already works.
+
+To narrow to a single project, go through `test:all`: `nmr test:all --project app`. Narrowing through `test` does not work, because a second `--project` widens the filter rather than restricting it.
+
+A run that collects no test files passes. That is what lets `nmr test:integration` fan out across a monorepo in which most packages have no integration tests, and it means a package with no tests at all needs no `"test": ""` override.
 
 ### Root scripts
 
@@ -318,11 +312,19 @@ A package gets this variant automatically when it contains a `vitest.integration
 
 #### Test
 
-| Command         | Runs                                                       |
-| --------------- | ---------------------------------------------------------- |
-| `test`          | `nmr root:test && pnpm --recursive exec nmr test`          |
-| `test:coverage` | `nmr root:test && pnpm --recursive exec nmr test:coverage` |
-| `test:watch`    | `vitest --watch`                                           |
+The same five names the workspace registry carries, so a command means the same thing from the monorepo root as from inside a package. Each fans out to root-level files and every workspace package.
+
+| Command            | Runs                                                                      |
+| ------------------ | ------------------------------------------------------------------------- |
+| `test`             | `nmr root:test && pnpm --recursive exec nmr test`                         |
+| `test:all`         | `nmr root:test:all && pnpm --recursive exec nmr test:all`                 |
+| `test:coverage`    | `nmr root:test && pnpm --recursive exec nmr test:coverage`                |
+| `test:integration` | `nmr root:test:integration && pnpm --recursive exec nmr test:integration` |
+| `test:watch`       | `vitest --project '!integration' --watch`                                 |
+
+`test:coverage` chains `root:test` rather than a `root:test:coverage`, because the root config reports no coverage of its own; packages cover their own sources.
+
+`test:watch` is the exception to the fan-out shape, and deliberately omits `--config`: bare `vitest` at the monorepo root resolves the root `vitest.config.ts`, whose projects then cover the whole tree in one process. A chain like the others would never advance past its first watcher. To watch root-level files alone, run `nmr root:test --watch`.
 
 #### Typecheck
 
@@ -340,12 +342,16 @@ A package gets this variant automatically when it contains a `vitest.integration
 
 #### Format
 
-| Command     | Runs                                  |
-| ----------- | ------------------------------------- |
-| `fmt`       | `prettier --list-different --write .` |
-| `fmt:all`   | `fmt`, `fmt:sh`                       |
-| `fmt:check` | `prettier --check .`                  |
-| `fmt:sh`    | `shfmt --write **/*.sh`               |
+| Command     | Runs              |
+| ----------- | ----------------- |
+| `fmt`       | `nmr-fmt --write` |
+| `fmt:check` | `nmr-fmt --check` |
+
+#### File selection
+
+`fmt` and `fmt:check` format the files git reports: tracked files, plus untracked files git does not ignore. Prettier reads `.gitignore` and `.prettierignore` from the working directory alone, so a pattern in `packages/<pkg>/.gitignore` never reaches a run started at the monorepo root. git knows the whole hierarchy, including `.git/info/exclude` and `core.excludesFile`, and every `.prettierignore` in the tree is discovered from the repository root, so package-level exclusions apply from any directory as well.
+
+A file git ignores is never formatted, even when named directly. Trailing arguments are git pathspecs rather than Prettier flags, so `nmr fmt:check packages/nmr` narrows the run, while an unrecognized option and a pathspec matching no formattable file both fail it. Running outside a git repository fails rather than reporting a clean run.
 
 #### Audit
 
@@ -367,15 +373,17 @@ See [dependency upgrades](#dependency-upgrades) for the workflow and its configu
 
 These scripts operate on root-level code only (not workspace packages):
 
-| Command            | Runs                                                          |
-| ------------------ | ------------------------------------------------------------- |
-| `root:check`       | `root:typecheck`, `fmt:check`, `root:lint:check`, `root:test` |
-| `root:lint`        | `eslint --fix --ignore-pattern 'packages/**' .`               |
-| `root:lint:check`  | `eslint --ignore-pattern 'packages/**' .`                     |
-| `root:lint:strict` | `strict-lint --ignore-pattern 'packages/**' .`                |
-| `root:test`        | `vitest --config ./vitest.root.config.ts`                     |
-| `root:typecheck`   | `tsgo --noEmit`                                               |
-| `root:upgrade`     | `nmr-taze --include-locked`                                   |
+| Command                 | Runs                                                               |
+| ----------------------- | ------------------------------------------------------------------ |
+| `root:check`            | `root:typecheck`, `fmt:check`, `root:lint:check`, `root:test`      |
+| `root:lint`             | `eslint --fix --ignore-pattern 'packages/**' .`                    |
+| `root:lint:check`       | `eslint --ignore-pattern 'packages/**' .`                          |
+| `root:lint:strict`      | `strict-lint --ignore-pattern 'packages/**' .`                     |
+| `root:test`             | `vitest --config ./vitest.root.config.ts --project '!integration'` |
+| `root:test:all`         | `vitest --config ./vitest.root.config.ts`                          |
+| `root:test:integration` | `vitest --config ./vitest.root.config.ts --project integration`    |
+| `root:typecheck`        | `tsgo --noEmit`                                                    |
+| `root:upgrade`          | `nmr-taze --include-locked`                                        |
 
 #### Utilities
 
@@ -407,19 +415,19 @@ Position determines ownership: flags before the command name are nmr's own, and
 
 ```bash
 # From a package directory
-nmr test                    # Run workspace test script
-nmr build                   # Compile to .js and .d.ts in one pass
+nmr test  # Run workspace test script
+nmr build # Compile to .js and .d.ts in one pass
 
 # From the monorepo root
-nmr test                    # Root tests + recursive workspace tests
-nmr ci                      # build + check:strict + audit
+nmr test # Root tests + recursive workspace tests
+nmr ci   # build + check:strict + audit
 
 # Target specific packages
-nmr --filter core test      # Test only the core package
-nmr --recursive lint        # Lint all workspace packages
+nmr --filter core test # Test only the core package
+nmr --recursive lint   # Lint all workspace packages
 
 # Force root context from anywhere
-nmr --workspace-root check  # Run root check from a package dir
+nmr --workspace-root check # Run root check from a package dir
 ```
 
 ## Additional subcommands
@@ -439,8 +447,8 @@ nmr report-overrides
 Sync the agent-facing guidance shipped with nmr into the consuming repo.
 
 ```bash
-nmr sync-agent-files          # write .agents/nmr/AGENTS.md, stamped with the installed nmr version
-nmr sync-agent-files --check  # verify the stamp matches; exit 1 with a fix message if not
+nmr sync-agent-files         # write .agents/nmr/AGENTS.md, stamped with the installed nmr version
+nmr sync-agent-files --check # verify the stamp matches; exit 1 with a fix message if not
 ```
 
 Run `nmr sync-agent-files` once after upgrading nmr. The generated file is committed to the consuming repo; do not edit it by hand.
@@ -484,6 +492,23 @@ Compile a single package's `src` tree to `dist/esm` with the TypeScript compiler
 nmr-compile
 ```
 
+### `nmr-fmt`
+
+Format, or check the formatting of, the files git reports for the working directory. Exactly one of `--check` and `--write` is required; a bare invocation prints usage and exits non-zero rather than defaulting to a mutation. `--write` also lists the files it rewrote. This is what `fmt` and `fmt:check` resolve to, in both registries.
+
+The selection is tracked files plus untracked files git does not ignore, scoped to the working directory, with every `.prettierignore` in the tree discovered from the repository root and passed to Prettier explicitly — see [file selection](#file-selection) for what that buys. Paths the index names but the filesystem does not have (a file deleted but not yet staged) and submodule gitlinks are both dropped, so neither reaches Prettier.
+
+Trailing arguments are git pathspecs, not Prettier flags: they narrow the selection, an unrecognized option is rejected rather than forwarded, and pathspecs that match no formattable file fail rather than passing quietly.
+
+`prettier` is an optional peer dependency (`>=3.9.5 <4`); the consuming repo provides it, and it is resolved through the module graph rather than from `PATH`, so the copy that runs is the one the repo declares and not whichever `prettier` happens to come first. A repository's formatter has to be the one its editor and pre-commit hook also run, which is why nmr takes it from the consumer instead of bundling a copy. It is optional because a repo can use nmr purely as a script runner; one that formats without a resolvable Prettier gets a message naming the package and the range.
+
+The floor is a currency policy, not a capability boundary. What the design requires is `--ignore-path` honouring every flag rather than only the last, so a repository-root ignore file passed alongside a package-level one is not silently dropped — Prettier has done that since 3.0.0, while 2.x honoured only the final flag. The floor sits at the current release because every consuming repo tracks it; lowering it to `>=3.0.0` would cost correctness nothing.
+
+```bash
+nmr-fmt --check
+nmr-fmt --write packages/nmr
+```
+
 ### `nmr-taze`
 
 Run the [taze](https://github.com/antfu-collective/taze) dependency-upgrade tool, forwarding every argument to it untouched. This is what `root:upgrade` resolves to, and what the root `upgrade` script ends with — see [dependency upgrades](#dependency-upgrades) for the workflow.
@@ -537,8 +562,144 @@ for (const packageDir of getWorkspacePackageDirs(monorepoRoot)) {
 
 `findMonorepoRoot(startDir?)` walks up from `startDir`, defaulting to `process.cwd()`, until it reaches a directory containing `pnpm-workspace.yaml`. It throws if it runs out of parent directories without finding one.
 
-`getWorkspacePackageDirs(monorepoRoot)` reads the workspace patterns from that repo's `pnpm-workspace.yaml` and resolves them to absolute package directories, sorted and free of duplicates. Patterns carry pnpm's own semantics: `packages/*`, deeper globs such as `packages/**`, exact paths such as `tools/cli`, and `!`-prefixed exclusions such as `!packages/legacy` or `!**/test/**`, which filter every directory the positive patterns matched regardless of where they appear in the list. Nothing under `node_modules` is ever returned.
+`getWorkspacePackageDirs(monorepoRoot)` reads the workspace patterns from that repo's `pnpm-workspace.yaml` and resolves them to absolute package directories, sorted and free of duplicates. It throws if `monorepoRoot` holds no `pnpm-workspace.yaml`. Patterns carry pnpm's own semantics: `packages/*`, deeper globs such as `packages/**`, exact paths such as `tools/cli`, and `!`-prefixed exclusions such as `!packages/legacy` or `!**/test/**`, which filter every directory the positive patterns matched regardless of where they appear in the list. Nothing under `node_modules` is ever returned.
 
 One divergence from pnpm: a directory counts as a package only if it holds a `package.json`, not a `package.yaml` or `package.json5`.
 
 Quote exclusion patterns in the manifest — `- '!packages/legacy'`. An unquoted `!` opens a YAML tag rather than a string, so the entry never reaches nmr (or pnpm) as a pattern.
+
+## Shared Prettier config
+
+Every repo consuming nmr otherwise maintains its own copy of the house Prettier options, and wires up shell formatting itself. The `@williamthorsen/nmr/prettier` subpath publishes both as a factory, so a repo declares only what it customizes:
+
+```js
+// .prettierrc.js
+import { definePrettierConfig } from '@williamthorsen/nmr/prettier';
+
+export default definePrettierConfig();
+```
+
+`prettier` is a peer dependency (`>=3.9.5 <4`), declared optional — the consuming repo provides it. The shell and Dockerfile plugin is a dependency of nmr rather than a peer, so its version is pinned centrally and two repos cannot format the same script differently.
+
+### What it formats
+
+Beyond everything Prettier already handles, this config formats `.sh`, `.bash`, `.zsh`, and the other extensions and dotfile names of the Shell language, plus `Dockerfile` and `Containerfile`. `nmr fmt` therefore covers shell scripts with no extra script, glob, or workflow entry.
+
+Shell output matches `shfmt` run with no flags: `binaryNextLine`, `spaceRedirects`, and `switchCaseIndent` are pinned to shfmt's CLI defaults, which the underlying plugin inverts. A repo whose scripts shfmt already formatted sees no diff on adoption.
+
+### Language scoping
+
+`prettier-plugin-sh` routes 20 further file types to the same shell parser, among them `.gitignore`, `.env`, `.csh`, `.nu`, `.properties`, `.ics`, `.vcf`, `CODEOWNERS`, and `hosts`. Since `nmr fmt` hands git's whole file list to Prettier, registering the plugin as shipped would make every one of them formattable — and the shell parser either fails on them or silently rewrites them. A `.gitignore` pattern such as `a(b)c` fails to parse, and an unquoted `&` in a `.env` or `.properties` value is split across two lines.
+
+This config registers a narrowed plugin, so Prettier infers a parser for the Shell and Dockerfile languages alone. `.flaskenv`, `gradlew`, and `mvnw` are dropped from Shell as well: the first holds dotenv content the plugin misfiles as shell, and the other two are vendored wrappers their generators would overwrite.
+
+The parsers themselves stay registered, so a repo that wants a dropped language back assigns it explicitly:
+
+```js
+export default definePrettierConfig({
+  additionalOverrides: [{ files: ['APKBUILD', '*.ebuild'], options: { parser: 'sh' } }],
+});
+```
+
+### Customizing
+
+Any Prettier option passed to the factory spreads over the defaults:
+
+```js
+export default definePrettierConfig({
+  printWidth: 100,
+  additionalPlugins: [await import('prettier-plugin-tailwindcss')],
+  additionalOverrides: [{ files: ['*.md'], options: { proseWrap: 'always' } }],
+});
+```
+
+`additionalPlugins` and `additionalOverrides` append to what the config declares, so a later override wins over nmr's own and no seam can drop shell support. Passing `plugins` or `overrides` throws, and both are typed `never` — replacement is inexpressible rather than merely discouraged, because a silently ignored key would produce no diff to notice.
+
+### Adoption caveats
+
+- **Indentation follows `.editorconfig`**, as it did under shfmt: Prettier maps `indent_style` and `indent_size` to `useTabs` and `tabWidth`, and the plugin honours both. With no `.editorconfig`, the two disagree — shfmt indents shell with tabs, Prettier with two spaces. Add `indent_style = tab` under `[*.sh]` to keep tabs.
+- **Shell fences in Markdown are formatted**, which collapses hand-aligned comment columns in documentation. Prettier keeps the original text when an embedded snippet fails to parse, so illustrative or truncated fences are safe. Use `<!-- prettier-ignore -->` before a fence whose alignment matters.
+- **Adopting the house options reformats the repo.** `singleQuote`, `trailingComma`, and the rest apply on the first run; review that diff separately from the shell one.
+
+## Shared Vitest config
+
+Every repo consuming nmr otherwise writes and maintains its own Vitest config. The `@williamthorsen/nmr/vitest` subpath publishes that config as a factory, so a repo declares only what it customizes:
+
+```ts
+// vitest.config.ts
+import { defineVitestConfig } from '@williamthorsen/nmr/vitest';
+
+export default defineVitestConfig();
+```
+
+`vitest` is a peer dependency (`>=4.0.0 <5`), declared optional — the consuming repo provides it, and repos that never import this subpath are unaffected.
+
+### Test categories
+
+The config declares three projects, named for what the tests cover:
+
+| Project       | Matches                                | Covers                                   |
+| ------------- | -------------------------------------- | ---------------------------------------- |
+| `unit`        | every test file the others don't claim | source code                              |
+| `integration` | `*.int.test.{ts,tsx}`                  | behavior beyond source code              |
+| `app`         | `*.app.test.{ts,tsx}`                  | the app's own tooling, e.g. drift checks |
+
+All three match only under a `__tests__` directory. Select them at run time with `--project`, which accepts negation:
+
+```bash
+vitest --project '!integration' # everything except integration tests
+vitest --project integration    # integration tests alone
+vitest                          # every project
+```
+
+`unit` is defined by subtracting the other categories rather than by an allow-list of suffixes, so a file such as `parser.smoke.test.ts` runs under `unit` instead of being silently dropped.
+
+### Customizing by scope
+
+Vitest applies some options at the root of a `projects` config and others per project, and placing one at the wrong level is silent rather than loud. The factory therefore takes two separate override surfaces instead of one merged config:
+
+```ts
+export default defineVitestConfig({
+  // Vite-level options, plus the test options Vitest honours only at the root.
+  root: { resolve: { conditions: ['development'] } },
+  // Applied to every project.
+  project: { setupFiles: ['./vitest.setup.ts'] },
+});
+```
+
+`root` is typed to accept only the options that work at the root, so writing a per-project option there is a compile error rather than a setting that never runs. Both surfaces merge into the generated config rather than replacing it, so overriding one coverage field leaves the rest intact.
+
+Arrays concatenate rather than replace. `exclude` and `setupFiles` therefore add to what the config already declares, and neither seam can narrow `include` or drop a default exclusion. Adding an `include` pattern through `project` widens all three projects at once, so a file matching it is collected by each and runs three times.
+
+### Root-scoped tests
+
+A monorepo's own root-level tests need a second config, because the package config is found by walking up from a package directory:
+
+```ts
+// vitest.root.config.ts
+import { defineRootVitestConfig } from '@williamthorsen/nmr/vitest';
+
+export default defineRootVitestConfig({ monorepoRoot: import.meta.dirname });
+```
+
+This variant reads `pnpm-workspace.yaml` and excludes every workspace package from all three projects, so a root run covers only root-level files. It reports no coverage of its own — packages cover their own sources.
+
+`monorepoRoot` is required, and because the config sits at the monorepo root, it is always `import.meta.dirname`. Stating the root rather than searching for it is what makes the exclusions describe this repo: a search from the working directory would resolve whichever monorepo the run started in, and every project is then pinned to that one. A directory holding no `pnpm-workspace.yaml` throws, naming the directory.
+
+### Migrating from the config-file variants
+
+nmr once selected a package's test scripts by looking for a `vitest.integration.config.ts` on disk, which meant three config files per package that separated its integration tests. Those files are no longer consulted. **Migrate the config and the scripts together**: one without the other leaves the repo in one of the two states below.
+
+1. Replace the repo's root `vitest.config.ts` with `defineVitestConfig()`, and its root-scoped config with `defineRootVitestConfig({ monorepoRoot: import.meta.dirname })`.
+2. Delete every `vitest.integration.config.ts` and `vitest.standalone.config.ts`, plus any per-package `vitest.config.ts` that only re-exports an ancestor. Vitest resolves config by walking up from the run root, so those are redundant.
+3. Rename integration tests to `*.int.test.ts` and tooling or drift tests to `*.app.test.ts`.
+4. Drop any hand-copied `test*` entries from `package.json`, which now shadow the defaults.
+
+Until step 1 is done, an upgraded nmr behaves as follows against a config that declares no projects:
+
+| Command                      | Result                                                                                                                                             |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `nmr test` / `test:coverage` | **Succeeds, and runs integration tests too.** The separation is lost with no error, because `--project '!integration'` matches nothing to exclude. |
+| `nmr test:integration`       | **Fails** with `No projects matched the filter "integration"`.                                                                                     |
+
+The second is the reliable signal that migration is incomplete. The first is silent, so do not treat a green `nmr test` as evidence that the move succeeded.

package/bin/nmr-fmt.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+try {
+  await import('../dist/esm/cli-fmt.js');
+} catch (error) {
+  if (error.code === 'ERR_MODULE_NOT_FOUND') {
+    process.stderr.write('nmr-fmt: build output not found — run `pnpm run build` first\n');
+  } else {
+    process.stderr.write(`nmr-fmt: failed to load: ${error.message}\n`);
+  }
+  process.exit(1);
+}

package/dist/esm/cli-fmt.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/cli-fmt.js

@@ -0,0 +1,3 @@
+import process from 'node:process';
+import { runFmt } from "./commands/fmt.js";
+process.exitCode = runFmt(process.argv.slice(2), process.cwd());

package/dist/esm/commands/clean.js

@@ -2,7 +2,7 @@ import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { loadConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
-import { applyDevBin, buildWorkspaceRegistry, hasIntegrationTestConfig, resolveScript } from "../resolver.js";
+import { applyDevBin, buildWorkspaceRegistry, resolveScript } from "../resolver.js";
 import { runCommand } from "../runner.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
 import { resolveBuildCachePath } from "./build.js";
@@ -34,8 +34,8 @@ export async function runClean(cwd = process.cwd()) {
 }
 async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
     const config = await loadConfig(monorepoRoot);
+    const registry = buildWorkspaceRegistry(config);
     for (const packageDir of workspacePackageDirs) {
-        const registry = buildWorkspaceRegistry(config, hasIntegrationTestConfig(packageDir));
         const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
         if (resolved === undefined || resolved.command === '') {
             continue;

package/dist/esm/commands/fmt.d.ts

@@ -0,0 +1,23 @@
+export type FormatMode = 'check' | 'write';
+export interface FormatTargets {
+    files: string[];
+    ignorePaths: string[];
+}
+export type ResolveTargetsResult = {
+    ok: true;
+    targets: FormatTargets;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function runFmt(argv: string[], cwd?: string): number;
+export declare function resolveFormatTargets(cwd: string, pathspecs?: string[]): ResolveTargetsResult;
+export interface RunPrettierOptions {
+    cliPath: string;
+    mode: FormatMode;
+    files: string[];
+    ignorePaths: string[];
+    cwd: string;
+    budgetBytes?: number;
+}
+export declare function runPrettier(options: RunPrettierOptions): number;

package/dist/esm/commands/fmt.js

@@ -0,0 +1,172 @@
+import { Buffer } from 'node:buffer';
+import { spawnSync } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import process from 'node:process';
+import { reportError } from '@williamthorsen/nmr-core';
+import { isObject } from "../helpers/type-guards.js";
+const IGNORE_FILENAME = '.prettierignore';
+const LIST_FILES_ARGS = ['ls-files', '-z', '--cached', '--others', '--exclude-standard'];
+const IGNORE_FILE_PATHSPEC = `*${IGNORE_FILENAME}`;
+const PRETTIER_PACKAGE = 'prettier';
+const PRETTIER_RANGE = '>=3.9.5 <4';
+const ARGUMENT_BUDGET_BYTES = 100_000;
+const USAGE = 'Usage: nmr-fmt (--check | --write) [pathspec...]';
+const MODE_ARGS = {
+    check: ['--check'],
+    write: ['--list-different', '--write'],
+};
+export function runFmt(argv, cwd = process.cwd()) {
+    const parsed = parseFmtArgs(argv);
+    if (!parsed.ok) {
+        reportError(`nmr-fmt: ${parsed.error}`);
+        process.stderr.write(`${USAGE}\n`);
+        return 1;
+    }
+    const resolved = resolveFormatTargets(cwd, parsed.pathspecs);
+    if (!resolved.ok) {
+        reportError(`nmr-fmt: ${resolved.error}`);
+        return 1;
+    }
+    const { files, ignorePaths } = resolved.targets;
+    if (files.length === 0) {
+        if (parsed.pathspecs.length > 0) {
+            reportError(`nmr-fmt: no formattable files matched: ${parsed.pathspecs.join(', ')}`);
+            return 1;
+        }
+        return 0;
+    }
+    const cli = resolvePrettierCli();
+    if (!cli.ok) {
+        reportError(`nmr-fmt: ${cli.error}`);
+        return 1;
+    }
+    return runPrettier({ cliPath: cli.cliPath, mode: parsed.mode, files, ignorePaths, cwd });
+}
+export function resolveFormatTargets(cwd, pathspecs = []) {
+    const toplevel = runGit(['rev-parse', '--show-toplevel'], cwd);
+    if (!toplevel.ok)
+        return toplevel;
+    const repositoryRoot = toplevel.stdout.trim();
+    const listed = runGit([...LIST_FILES_ARGS, '--', ...pathspecs], cwd);
+    if (!listed.ok)
+        return listed;
+    const ignoreFiles = runGit([...LIST_FILES_ARGS, '--', IGNORE_FILE_PATHSPEC], repositoryRoot);
+    if (!ignoreFiles.ok)
+        return ignoreFiles;
+    const discovered = splitNulSeparated(ignoreFiles.stdout)
+        .filter((file) => path.basename(file) === IGNORE_FILENAME)
+        .map((file) => path.resolve(repositoryRoot, file));
+    return {
+        ok: true,
+        targets: {
+            files: dedupe(splitNulSeparated(listed.stdout))
+                .filter((file) => isFormattableFile(cwd, file))
+                .toSorted(),
+            ignorePaths: dedupe([path.join(repositoryRoot, IGNORE_FILENAME), ...discovered]),
+        },
+    };
+}
+function isFormattableFile(cwd, file) {
+    return statSync(path.resolve(cwd, file), { throwIfNoEntry: false })?.isFile() === true;
+}
+function parseFmtArgs(argv) {
+    let mode;
+    const pathspecs = [];
+    for (const arg of argv) {
+        if (arg === '--check' || arg === '--write') {
+            const requested = arg === '--check' ? 'check' : 'write';
+            if (mode !== undefined && mode !== requested) {
+                return { ok: false, error: 'Pass --check or --write, not both.' };
+            }
+            mode = requested;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            return { ok: false, error: `Unknown option: ${arg}` };
+        }
+        pathspecs.push(arg);
+    }
+    if (mode === undefined) {
+        return { ok: false, error: 'Pass --check or --write.' };
+    }
+    return { ok: true, mode, pathspecs };
+}
+function resolvePrettierCli() {
+    const missing = {
+        ok: false,
+        error: `\`${PRETTIER_PACKAGE}\` (${PRETTIER_RANGE}) could not be resolved. Install it in this repository.`,
+    };
+    let manifestPath;
+    try {
+        manifestPath = createRequire(import.meta.url).resolve(`${PRETTIER_PACKAGE}/package.json`);
+    }
+    catch {
+        return missing;
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    if (!isObject(manifest))
+        return missing;
+    const bin = isObject(manifest.bin) ? manifest.bin[PRETTIER_PACKAGE] : manifest.bin;
+    if (typeof bin !== 'string')
+        return missing;
+    return { ok: true, cliPath: path.resolve(path.dirname(manifestPath), bin) };
+}
+export function runPrettier(options) {
+    const { cliPath, mode, files, ignorePaths, cwd, budgetBytes = ARGUMENT_BUDGET_BYTES } = options;
+    const prettierArgs = [
+        cliPath,
+        '--ignore-unknown',
+        ...ignorePaths.flatMap((ignorePath) => ['--ignore-path', ignorePath]),
+        ...MODE_ARGS[mode],
+    ];
+    let firstFailure = 0;
+    for (const batch of batchWithinBudget(files, budgetBytes)) {
+        const result = spawnSync(process.execPath, [...prettierArgs, ...batch], { cwd, stdio: 'inherit' });
+        if (result.error) {
+            reportError(`nmr-fmt: could not run \`${PRETTIER_PACKAGE}\` (${result.error.message}).`);
+            return 1;
+        }
+        const status = result.status ?? 1;
+        if (status !== 0 && firstFailure === 0) {
+            firstFailure = status;
+        }
+    }
+    return firstFailure;
+}
+function batchWithinBudget(files, budget) {
+    const batches = [];
+    let batch = [];
+    let size = 0;
+    for (const file of files) {
+        const cost = Buffer.byteLength(file) + 1;
+        if (batch.length > 0 && size + cost > budget) {
+            batches.push(batch);
+            batch = [];
+            size = 0;
+        }
+        batch.push(file);
+        size += cost;
+    }
+    if (batch.length > 0)
+        batches.push(batch);
+    return batches;
+}
+function runGit(args, cwd) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    if (result.error) {
+        return { ok: false, error: result.error.message };
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr.trim();
+        return { ok: false, error: stderr || `\`git ${args.join(' ')}\` failed with exit code ${result.status}.` };
+    }
+    return { ok: true, stdout: result.stdout };
+}
+function splitNulSeparated(output) {
+    return output.split('\0').filter((entry) => entry !== '');
+}
+function dedupe(items) {
+    return [...new Set(items)];
+}

package/dist/esm/default-scripts.d.ts

@@ -1,6 +1,4 @@
 export type ScriptValue = string | string[];
 export type ScriptRegistry = Record<string, ScriptValue>;
-export declare const commonWorkspaceScripts: ScriptRegistry;
-export declare const integrationTestScripts: ScriptRegistry;
-export declare const standardTestScripts: ScriptRegistry;
+export declare const workspaceScripts: ScriptRegistry;
 export declare const rootScripts: ScriptRegistry;

package/dist/esm/default-scripts.js

@@ -1,4 +1,4 @@
-export const commonWorkspaceScripts = {
+export const workspaceScripts = {
     build: ['compile'],
     check: ['typecheck', 'fmt:check', 'lint:check', 'test'],
     'check:strict': ['typecheck', 'fmt:check', 'lint:strict', 'test:coverage'],
@@ -6,27 +6,20 @@ export const commonWorkspaceScripts = {
     compile: 'nmr-compile',
     fix: ['lint', 'fmt'],
     'fix:check': ['fmt:check', 'lint:check'],
-    fmt: 'prettier --list-different --write .',
-    'fmt:check': 'prettier --check .',
+    fmt: 'nmr-fmt --write',
+    'fmt:check': 'nmr-fmt --check',
     lint: 'eslint --fix .',
     'lint:check': 'eslint .',
     'lint:strict': 'strict-lint',
+    test: "pnpm exec vitest --project '!integration'",
+    'test:all': 'pnpm exec vitest',
+    'test:coverage': "pnpm exec vitest --project '!integration' --coverage",
+    'test:integration': 'pnpm exec vitest --project integration',
+    'test:watch': "pnpm exec vitest --project '!integration' --watch",
     typecheck: 'tsgo --noEmit',
     upgrade: 'nmr-taze --include-locked',
     'view-coverage': 'open coverage/index.html',
 };
-export const integrationTestScripts = {
-    test: 'pnpm exec vitest --config=vitest.standalone.config.ts',
-    'test:all': 'pnpm exec vitest',
-    'test:coverage': 'pnpm exec vitest --config=vitest.standalone.config.ts --coverage',
-    'test:integration': 'pnpm exec vitest --config=vitest.integration.config.ts',
-    'test:watch': 'pnpm exec vitest --config=vitest.standalone.config.ts --watch',
-};
-export const standardTestScripts = {
-    test: 'pnpm exec vitest',
-    'test:coverage': 'pnpm exec vitest --coverage',
-    'test:watch': 'pnpm exec vitest --watch',
-};
 export const rootScripts = {
     audit: ['audit:prod', 'audit:dev'],
     'audit:dev': 'pnpm exec v11y --dev',
@@ -39,10 +32,8 @@ export const rootScripts = {
     clean: 'nmr-clean',
     fix: ['lint', 'fmt'],
     'fix:check': ['fmt:check', 'lint:check'],
-    fmt: 'sh -c \'prettier --list-different --write "${@:-.}"\' --',
-    'fmt:all': ['fmt', 'fmt:sh'],
-    'fmt:check': 'sh -c \'prettier --check "${@:-.}"\' --',
-    'fmt:sh': 'shfmt --write **/*.sh',
+    fmt: 'nmr-fmt --write',
+    'fmt:check': 'nmr-fmt --check',
     lint: 'nmr root:lint && pnpm --recursive exec nmr lint',
     'lint:check': 'nmr root:lint:check && pnpm --recursive exec nmr lint:check',
     'lint:strict': 'nmr root:lint:strict && pnpm --recursive exec nmr lint:strict',
@@ -51,13 +42,17 @@ export const rootScripts = {
     'root:lint': "eslint --fix --ignore-pattern 'packages/**' .",
     'root:lint:check': "eslint --ignore-pattern 'packages/**' .",
     'root:lint:strict': "strict-lint --ignore-pattern 'packages/**' .",
-    'root:test': 'vitest --config ./vitest.root.config.ts',
+    'root:test': "vitest --config ./vitest.root.config.ts --project '!integration'",
+    'root:test:all': 'vitest --config ./vitest.root.config.ts',
+    'root:test:integration': 'vitest --config ./vitest.root.config.ts --project integration',
     'root:typecheck': 'tsgo --noEmit',
     'root:upgrade': 'nmr-taze --include-locked',
     'sync-agent-files': 'nmr-sync-agent-files',
     test: 'nmr root:test && pnpm --recursive exec nmr test',
+    'test:all': 'nmr root:test:all && pnpm --recursive exec nmr test:all',
     'test:coverage': 'nmr root:test && pnpm --recursive exec nmr test:coverage',
-    'test:watch': 'vitest --watch',
+    'test:integration': 'nmr root:test:integration && pnpm --recursive exec nmr test:integration',
+    'test:watch': "vitest --project '!integration' --watch",
     typecheck: 'nmr root:typecheck && pnpm --recursive exec nmr typecheck',
     upgrade: 'nmr-report-overrides && nmr-taze --include-locked --recursive',
 };

package/dist/esm/help.js

@@ -1,5 +1,5 @@
 import { isHookName } from "./helpers/hook-name.js";
-import { buildRootRegistry, buildWorkspaceRegistry, describeScript, hasIntegrationTestConfig, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
+import { buildRootRegistry, buildWorkspaceRegistry, describeScript, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
 export function generateHelp(config, packageDir, useRoot) {
     const lines = [
         'Usage: nmr [flags] <command> [args...]',
@@ -16,8 +16,7 @@ export function generateHelp(config, packageDir, useRoot) {
     ];
     const overrides = packageDir === undefined ? {} : collectOverrides(packageDir);
     let hadOverride = false;
-    const useIntTests = !useRoot && packageDir !== undefined && hasIntegrationTestConfig(packageDir);
-    const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config, useIntTests));
+    const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config));
     const workspaceMarked = !useRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
     if (workspaceMarked.size > 0)
         hadOverride = true;

package/dist/esm/prettier.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from 'prettier';
+export interface PrettierConfigOptions extends Omit<Config, 'overrides' | 'plugins'> {
+    additionalPlugins?: NonNullable<Config['plugins']>;
+    additionalOverrides?: NonNullable<Config['overrides']>;
+    overrides?: never;
+    plugins?: never;
+}
+export declare function definePrettierConfig(options?: PrettierConfigOptions): Config;

package/dist/esm/prettier.js

@@ -0,0 +1,60 @@
+import * as shPlugin from 'prettier-plugin-sh';
+const INFERRED_LANGUAGES = new Set(['Dockerfile', 'Shell']);
+const EXCLUDED_FILENAMES = new Set([
+    '.bash_history',
+    '.cshrc',
+    '.flaskenv',
+    '.login',
+    'cshrc',
+    'gradlew',
+    'login',
+    'mvnw',
+]);
+const DEFAULT_OPTIONS = {
+    binaryNextLine: false,
+    checkIgnorePragma: true,
+    jsxSingleQuote: false,
+    singleQuote: true,
+    spaceRedirects: false,
+    switchCaseIndent: false,
+    trailingComma: 'all',
+};
+const DEFAULT_OVERRIDES = [
+    {
+        files: ['*.json5', '*.jsonc', 'tsconfig.json', 'tsconfig.*.json'],
+        options: { parser: 'jsonc', singleQuote: false, trailingComma: 'all' },
+    },
+];
+export function definePrettierConfig(options = {}) {
+    assertNoReplacement(options);
+    const { additionalOverrides = [], additionalPlugins = [], ...overrideOptions } = options;
+    return {
+        ...DEFAULT_OPTIONS,
+        ...overrideOptions,
+        overrides: [...DEFAULT_OVERRIDES, ...additionalOverrides],
+        plugins: [buildShellPlugin(), ...additionalPlugins],
+    };
+}
+function buildShellPlugin() {
+    return {
+        ...shPlugin,
+        languages: shPlugin.languages.filter(isInferredLanguage).map(withoutExcludedFilenames),
+    };
+}
+function isInferredLanguage(language) {
+    return INFERRED_LANGUAGES.has(language.name);
+}
+function withoutExcludedFilenames(language) {
+    if (language.filenames === undefined)
+        return language;
+    return { ...language, filenames: language.filenames.filter((name) => !EXCLUDED_FILENAMES.has(name)) };
+}
+function assertNoReplacement(options) {
+    if ('overrides' in options)
+        throw ownedKeyError('overrides', 'additionalOverrides');
+    if ('plugins' in options)
+        throw ownedKeyError('plugins', 'additionalPlugins');
+}
+function ownedKeyError(key, seam) {
+    return new TypeError(`definePrettierConfig: \`${key}\` is owned by this config. Use \`${seam}\` to append to it.`);
+}

package/dist/esm/resolve-scripts.d.ts

@@ -1,4 +1,4 @@
 import type { ScriptRegistry } from './default-scripts.js';
 export type { ScriptRegistry, ScriptValue } from './default-scripts.js';
-export declare function getDefaultWorkspaceScripts(useIntTests: boolean): ScriptRegistry;
+export declare function getDefaultWorkspaceScripts(): ScriptRegistry;
 export declare function getDefaultRootScripts(): ScriptRegistry;

package/dist/esm/resolve-scripts.js

@@ -1,9 +1,6 @@
-import { commonWorkspaceScripts, integrationTestScripts, rootScripts, standardTestScripts } from "./default-scripts.js";
-export function getDefaultWorkspaceScripts(useIntTests) {
-    return {
-        ...commonWorkspaceScripts,
-        ...(useIntTests ? integrationTestScripts : standardTestScripts),
-    };
+import { rootScripts, workspaceScripts } from "./default-scripts.js";
+export function getDefaultWorkspaceScripts() {
+    return { ...workspaceScripts };
 }
 export function getDefaultRootScripts() {
     return { ...rootScripts };

package/dist/esm/resolver.d.ts

@@ -8,8 +8,7 @@ export interface ResolvedScript {
 export declare function expandScript(script: ScriptValue, workspaceRoot: boolean): string;
 export declare function describeScript(script: ScriptValue): string;
 export declare function readPackageJsonScripts(packageDir: string): Record<string, string> | undefined;
-export declare function hasIntegrationTestConfig(packageDir: string): boolean;
-export declare function buildWorkspaceRegistry(config: NmrConfig, useIntTests: boolean): ScriptRegistry;
+export declare function buildWorkspaceRegistry(config: NmrConfig): ScriptRegistry;
 export declare function buildRootRegistry(config: NmrConfig): ScriptRegistry;
 export declare function isSelfReferential(script: string, commandName: string): boolean;
 export declare function resolveScript(commandName: string, registry: ScriptRegistry, packageDir: string | undefined, workspaceRoot: boolean): ResolvedScript | undefined;

package/dist/esm/resolver.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { isObject } from "./helpers/type-guards.js";
 import { getDefaultRootScripts, getDefaultWorkspaceScripts } from "./resolve-scripts.js";
@@ -63,12 +63,9 @@ export function readPackageJsonScripts(packageDir) {
         throw error;
     }
 }
-export function hasIntegrationTestConfig(packageDir) {
-    return existsSync(path.join(packageDir, 'vitest.integration.config.ts'));
-}
-export function buildWorkspaceRegistry(config, useIntTests) {
+export function buildWorkspaceRegistry(config) {
     return {
-        ...getDefaultWorkspaceScripts(useIntTests),
+        ...getDefaultWorkspaceScripts(),
         ...config.workspaceScripts,
     };
 }

package/dist/esm/runCli.js

@@ -3,7 +3,7 @@ import { readPackageVersion, reportError } from '@williamthorsen/nmr-core';
 import { resolveContext } from "./context.js";
 import { generateHelp } from "./help.js";
 import { isHookName } from "./helpers/hook-name.js";
-import { applyDevBin, buildRootRegistry, buildWorkspaceRegistry, hasIntegrationTestConfig, resolveScript, } from "./resolver.js";
+import { applyDevBin, buildRootRegistry, buildWorkspaceRegistry, resolveScript } from "./resolver.js";
 import { runCommand } from "./runner.js";
 const VERSION = readPackageVersion(import.meta.url);
 export async function runCli(options) {
@@ -39,9 +39,7 @@ export async function runCli(options) {
         const exitCode = runCommand(delegateCmd, context.monorepoRoot, { ...runOptions, env: childEnv });
         return { exitCode };
     }
-    const registry = useRoot
-        ? buildRootRegistry(context.config)
-        : buildWorkspaceRegistry(context.config, hasIntegrationTestConfig(anchorDir));
+    const registry = useRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config);
     const resolved = resolveScript(command, registry, anchorDir, parsed.workspaceRoot);
     if (!resolved) {
         if (env.NMR_RUN_IF_PRESENT === '1') {

package/dist/esm/vitest.d.ts

@@ -0,0 +1,15 @@
+import type { ViteUserConfig } from 'vitest/config';
+import type { InlineConfig, ProjectConfig } from 'vitest/node';
+export type RootTestOptions = Omit<InlineConfig, keyof ProjectConfig>;
+export type RootOverrides = Omit<ViteUserConfig, 'test'> & {
+    test?: RootTestOptions;
+};
+export interface VitestConfigOptions {
+    root?: RootOverrides;
+    project?: ProjectConfig;
+}
+export interface RootVitestConfigOptions extends VitestConfigOptions {
+    monorepoRoot: string;
+}
+export declare function defineVitestConfig(options?: VitestConfigOptions): ViteUserConfig;
+export declare function defineRootVitestConfig(options: RootVitestConfigOptions | undefined): ViteUserConfig;

package/dist/esm/vitest.js

@@ -0,0 +1,69 @@
+import path from 'node:path';
+import { defaultExclude, mergeConfig } from 'vitest/config';
+import { getWorkspacePackageDirs } from "./workspace.js";
+const APP_PATTERNS = ['**/__tests__/**/*.app.test.{ts,tsx}'];
+const INTEGRATION_PATTERNS = ['**/__tests__/**/*.int.test.{ts,tsx}'];
+const ALL_TEST_PATTERNS = ['**/__tests__/**/*.test.{ts,tsx}'];
+const COVERAGE_EXCLUDE = [
+    '**/__{mocks,tests}__/*',
+    '**/index.ts',
+    '**/mock*.{ts,tsx}',
+    '**/*.d.ts',
+    '**/*.types.ts',
+];
+const PACKAGE_COVERAGE_INCLUDE = ['**/src/**/*.{ts,tsx}'];
+const MISSING_MONOREPO_ROOT = 'defineRootVitestConfig requires `monorepoRoot`, an absolute path to the directory holding pnpm-workspace.yaml. Pass `import.meta.dirname` from the root config.';
+export function defineVitestConfig(options = {}) {
+    return buildConfig(options, { coverageInclude: PACKAGE_COVERAGE_INCLUDE });
+}
+export function defineRootVitestConfig(options) {
+    if (options === undefined) {
+        throw new TypeError(MISSING_MONOREPO_ROOT);
+    }
+    const monorepoRoot = options.monorepoRoot;
+    if (typeof monorepoRoot !== 'string' || !path.isAbsolute(monorepoRoot)) {
+        throw new TypeError(MISSING_MONOREPO_ROOT);
+    }
+    return buildConfig(options, {
+        coverageInclude: [],
+        projectExclude: getWorkspaceExcludePatterns(monorepoRoot),
+        projectRoot: monorepoRoot,
+    });
+}
+function buildConfig(options, { coverageInclude, projectExclude = [], projectRoot }) {
+    const config = {
+        test: {
+            coverage: {
+                enabled: false,
+                exclude: COVERAGE_EXCLUDE,
+                include: coverageInclude,
+                provider: 'v8',
+            },
+            passWithNoTests: true,
+            projects: buildProjects(options.project, projectExclude, projectRoot),
+            silent: 'passed-only',
+            watch: false,
+        },
+    };
+    return options.root ? mergeConfig(config, options.root) : config;
+}
+function buildProjects(overrides, extraExclude, projectRoot) {
+    const categories = [
+        { exclude: [], include: APP_PATTERNS, name: 'app' },
+        { exclude: [], include: INTEGRATION_PATTERNS, name: 'integration' },
+        { exclude: [...APP_PATTERNS, ...INTEGRATION_PATTERNS], include: ALL_TEST_PATTERNS, name: 'unit' },
+    ];
+    return categories.map(({ exclude, include, name }) => {
+        const project = {
+            extends: true,
+            ...(projectRoot !== undefined && { root: projectRoot }),
+            test: { exclude: [...defaultExclude, ...exclude, ...extraExclude], include, name },
+        };
+        return overrides ? mergeConfig(project, { test: overrides }) : project;
+    });
+}
+function getWorkspaceExcludePatterns(monorepoRoot) {
+    return getWorkspacePackageDirs(monorepoRoot)
+        .map((dir) => `${path.relative(monorepoRoot, dir).split(path.sep).join('/')}/**`)
+        .toSorted();
+}

package/dist/esm/workspace.js

@@ -3,21 +3,25 @@ import path from 'node:path';
 import { parse } from 'yaml';
 import { isObject } from "./helpers/type-guards.js";
 import { resolvePackageDirs } from "./helpers/workspace-patterns.js";
+const WORKSPACE_MANIFEST = 'pnpm-workspace.yaml';
 export function findMonorepoRoot(startDir) {
     let dir = path.resolve(startDir ?? process.cwd());
     for (;;) {
-        if (existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
+        if (existsSync(path.join(dir, WORKSPACE_MANIFEST))) {
             return dir;
         }
         const parent = path.dirname(dir);
         if (parent === dir) {
-            throw new Error('Could not find monorepo root: no pnpm-workspace.yaml found in any parent directory');
+            throw new Error(`Could not find monorepo root: no ${WORKSPACE_MANIFEST} found in any parent directory`);
         }
         dir = parent;
     }
 }
 export function getWorkspacePackageDirs(monorepoRoot) {
-    const workspaceFile = path.join(monorepoRoot, 'pnpm-workspace.yaml');
+    const workspaceFile = path.join(monorepoRoot, WORKSPACE_MANIFEST);
+    if (!existsSync(workspaceFile)) {
+        throw new Error(`Not a monorepo root: no ${WORKSPACE_MANIFEST} in ${monorepoRoot}`);
+    }
     const content = readFileSync(workspaceFile, 'utf8');
     const parsed = parse(content);
     const packages = getPackagesFromParsedYaml(parsed);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
@@ -26,6 +26,10 @@
       "types": "./dist/esm/index.d.ts",
       "default": "./dist/esm/index.js"
     },
+    "./prettier": {
+      "types": "./dist/esm/prettier.d.ts",
+      "default": "./dist/esm/prettier.js"
+    },
     "./scripts": {
       "types": "./dist/esm/scripts.d.ts",
       "default": "./dist/esm/scripts.js"
@@ -34,6 +38,10 @@
       "types": "./dist/esm/taze.d.ts",
       "default": "./dist/esm/taze.js"
     },
+    "./vitest": {
+      "types": "./dist/esm/vitest.d.ts",
+      "default": "./dist/esm/vitest.js"
+    },
     "./workspace": {
       "types": "./dist/esm/workspace.d.ts",
       "default": "./dist/esm/workspace.js"
@@ -44,6 +52,7 @@
     "nmr": "bin/nmr.js",
     "nmr-clean": "bin/nmr-clean.js",
     "nmr-compile": "bin/nmr-compile.js",
+    "nmr-fmt": "bin/nmr-fmt.js",
     "nmr-report-overrides": "bin/nmr-report-overrides.js",
     "nmr-sync-agent-files": "bin/nmr-sync-agent-files.js",
     "nmr-taze": "bin/nmr-taze.js"
@@ -56,12 +65,28 @@
   "dependencies": {
     "glob": "13.0.6",
     "jiti": "2.7.0",
-    "taze": "19.15.1",
+    "prettier-plugin-sh": "0.19.0",
+    "taze": "19.16.0",
     "yaml": "2.9.0",
-    "@williamthorsen/nmr-core": "0.7.2"
+    "@williamthorsen/nmr-core": "0.7.3"
+  },
+  "devDependencies": {
+    "prettier": "3.9.6",
+    "tinyglobby": "0.2.17",
+    "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "typescript": ">=5.7.0 <7"
+    "prettier": ">=3.9.5 <4",
+    "typescript": ">=5.7.0 <7",
+    "vitest": ">=4.0.0 <5"
+  },
+  "peerDependenciesMeta": {
+    "prettier": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=24.16.0"