@williamthorsen/nmr 0.20.0 → 0.21.0

package/README.md

@@ -3,33 +3,23 @@
 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.21.0 (2026-07-30)
 
 ### 🎉 Features
 
-- 🚨 **Breaking:** Migrate to code-quality workflow v7 and retire the version-restatement apparatus (#503)
+- Add a shared Vitest config export (#526)
 
-  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 a shared Vitest configuration that can be used by repos that use `nmr`. Tests are now sorted into three named categories (unit, integration, and app), so that a run can target or skip a single category. A second variant excludes all tests in workspace packages, allowing the monorepo's own root-level tests to be run separately.
 
-  Taking this upgrade requires migrating the repo's code-quality workflow to `@v7` and deleting its version-alignment test in the same change.
+- 🚨 **Breaking:** Retire the Vitest config-file variants from nmr's defaults (#533)
 
-- 🚨 **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.
+  Packages no longer need extra Vitest config files to keep integration tests out of the default test run. Integration tests are now recognized by an `*.int.test.ts` suffix, and every package gets the same five commands: `test`, `test:all`, `test:coverage`, `test:integration`, and `test:watch`. The same five commands work from the monorepo root. A Vitest run that collects no test files now passes instead of failing. Consumers should migrate the Vitest config when upgrading.
 
 ### 🐛 Bug fixes
 
-- Anchor script execution to the resolved registry's directory (#517)
+- Apply ignore rules from any working directory when formatting (#535)
 
-  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.
+  Fixes an issue where `nmr fmt` and `nmr fmt:check` did not apply a pattern from a package's `.gitignore` or `.prettierignore` when the run started at the monorepo root, so files a package excluded could fail a root-level format gate while passing a package-scoped one. Untracked files that git does not ignore are now formatted alongside tracked ones, and a run started outside a git repository now fails instead of reporting a clean pass over nothing. Trailing arguments to `nmr fmt` are git pathspecs rather than Prettier flags; one that matches no formattable file now fails instead of exiting silently.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -75,11 +65,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.
 
@@ -259,38 +249,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 +318,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 +348,18 @@ 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:all`   | `fmt`, `fmt:sh`         |
+| `fmt:check` | `nmr-fmt --check`       |
+| `fmt:sh`    | `shfmt --write **/*.sh` |
+
+#### 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 +381,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
 
@@ -484,6 +500,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.
@@ -542,3 +575,90 @@ for (const packageDir of getWorkspacePackageDirs(monorepoRoot)) {
 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 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();
+```
+
+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.
+
+The monorepo root is located by walking up from the working directory, and every project is pinned to it, so the exclusions hold wherever the run is invoked from. Pass `startDir` to locate it from somewhere else:
+
+```ts
+export default defineRootVitestConfig({ startDir: import.meta.dirname });
+```
+
+### 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()`.
+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,9 +32,9 @@ export const rootScripts = {
     clean: 'nmr-clean',
     fix: ['lint', 'fmt'],
     'fix:check': ['fmt:check', 'lint:check'],
-    fmt: 'sh -c \'prettier --list-different --write "${@:-.}"\' --',
+    fmt: 'nmr-fmt --write',
     'fmt:all': ['fmt', 'fmt:sh'],
-    'fmt:check': 'sh -c \'prettier --check "${@:-.}"\' --',
+    'fmt:check': 'nmr-fmt --check',
     'fmt:sh': 'shfmt --write **/*.sh',
     lint: 'nmr root:lint && pnpm --recursive exec nmr lint',
     'lint:check': 'nmr root:lint:check && pnpm --recursive exec nmr lint:check',
@@ -51,13 +44,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/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 {
+    startDir?: string;
+}
+export declare function defineVitestConfig(options?: VitestConfigOptions): ViteUserConfig;
+export declare function defineRootVitestConfig(options?: RootVitestConfigOptions): ViteUserConfig;

package/dist/esm/vitest.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { defaultExclude, mergeConfig } from 'vitest/config';
+import { findMonorepoRoot, 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}'];
+export function defineVitestConfig(options = {}) {
+    return buildConfig(options, { coverageInclude: PACKAGE_COVERAGE_INCLUDE });
+}
+export function defineRootVitestConfig(options = {}) {
+    const monorepoRoot = findMonorepoRoot(options.startDir);
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
@@ -34,6 +34,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 +48,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 +61,27 @@
   "dependencies": {
     "glob": "13.0.6",
     "jiti": "2.7.0",
-    "taze": "19.15.1",
+    "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"