@williamthorsen/nmr 0.19.0 → 0.20.0

package/AGENTS.md

@@ -2,100 +2,9 @@
 source: '@williamthorsen/nmr@0.0.0-source'
 ---
 
-# nmr: agent guidance
+# nmr: agent guidance (generated; do not edit)
 
-This file is managed by `@williamthorsen/nmr`. Do not edit; run `nmr sync-agent-files` to refresh it after an nmr upgrade that changes this guidance.
-
-## Discover scripts by running nmr
-
-Run `nmr` with no command (from the monorepo root or any workspace package) to list every available script, including composite expansions and resolved shell commands. Check this before guessing a script name from another repo: The registry is authoritative.
-
-## Invocation rules
-
-- Use `nmr <command>` for anything nmr provides. Do not use `pnpm run <command>`.
-- You can invoke nmr from the monorepo root or any workspace package.
-
-### How to make `nmr` resolvable
-
-`nmr` ships as a workspace bin. The bare `nmr` command works only when your shell can find `<root>/node_modules/.bin/nmr`. Choose one:
-
-- **direnv** (recommended for contributors). With [direnv](https://direnv.net/) installed, the repo's `.envrc` adds `node_modules/.bin` to your `PATH` automatically. From any subdirectory, bare `nmr` works.
-- **`pnpm exec nmr <command>`**: Works without setup. pnpm resolves the bin from the workspace root.
-
-Avoid `npx nmr`. Inside git worktrees, `npx` can resolve a different nmr binary from outside the working tree.
-
-## Root vs. workspace context
-
-nmr walks up to find `pnpm-workspace.yaml`, then decides which registry to use based on whether your cwd is inside a workspace package. The same command name (e.g. `build`, `test`, `check:strict`) often exists in both registries with different behavior; the root version typically delegates across all workspaces. Use `-w` to force the root registry from inside a package dir, and `-F <pkg>` to run a single package's script from anywhere.
-
-## Composite scripts
-
-A script value shown in `nmr` output as `[a, b, c]` is a composite: it runs `nmr a && nmr b && nmr c`, stopping at the first failure. Composites can reference other composites.
-
-## `root:*` siblings
-
-Some root scripts (e.g. `lint`, `typecheck`, `test`) expand to `nmr root:X && pnpm --recursive exec nmr X`. The `root:X` variant runs only against root-level files; the plain name runs everywhere. Use `root:X` directly when you want to isolate a failure to the root code.
-
-## Managed build
-
-The default `compile` script runs `nmr-compile`, a standalone bin that uses the TypeScript compiler API to emit a package's `src` to `dist/esm` as `.js` and `.d.ts` in one pass, rewriting relative `.ts`→`.js` specifiers and tsconfig `paths` aliases in both outputs, and skipping work when inputs are unchanged. `typescript` is a peer dependency (`>=5.7.0 <7`; TypeScript 7 ships no compiler API). There is no repo-local build script to maintain, and no separate typings step; `nmr build` runs `compile` alone. To find or debug the build, look to `nmr-compile`, not a `config/build.ts` in the consuming repo.
-
-## Dependency upgrades
-
-`nmr upgrade` reports available dependency upgrades, honoring the version ceilings the repo declares in its root `taze.config.ts`. Scope follows context: from the root it covers the root `package.json` and every workspace in one pass; from inside a package, or under `nmr -F <package> upgrade`, it covers that package. `nmr root:upgrade` covers the root `package.json` alone. Run the root-context commands from the monorepo root.
-
-There are no `outdated` or `update` commands; `upgrade` replaced them. Reach for `pnpm outdated` or `pnpm update` directly if you need a report that ignores the ceilings.
-
-Arguments pass through to the underlying tool, including the range mode: `nmr upgrade major` proposes major upgrades, still inside the ceilings. Every form above is report-only until you add `--write`.
-
-**`-w` is not the same on both sides of the command.** `nmr upgrade -w` passes `--write` through and rewrites `package.json`; `nmr -w upgrade` is nmr's own `--workspace-root` and writes nothing. Use the long forms.
-
-To change what a repo holds back, edit its `taze.config.ts`. It imports `defineConfig` from `@williamthorsen/nmr/taze`, which supplies the shared upgrade policy — so that file should carry only the ceilings specific to that repo, and the repo needs no dependency on the upgrade tool itself.
-
-## Override behaviors
-
-In `.config/nmr.config.ts` or a package's `package.json`, override values have special semantics:
-
-- `""` (empty string): Skip the script with a "Skipping" message; exit 0.
-- `":"`: No-op; exit 0. Prefer this over `""` if your repo enforces non-empty script values.
-- Any other string: Runs in place of the default.
-
-## Pre and post hooks
-
-Every `nmr X` invocation auto-wraps as the equivalent of `nmr X:pre && nmr X && nmr X:post`. Hooks are first-class scripts that resolve through the same 3-tier registry (built-in defaults → `.config/nmr.config.ts` → per-package `package.json`). Wrapping is uniform; nested invocations from composite expansion get their own hook treatment. Hook failure short-circuits the chain via shell `&&` semantics, propagating the failing exit code.
-
-Behaviors worth knowing:
-
-- **Silent when absent**: Missing hooks produce no error and no output.
-- **Skip overrides apply to hooks**: A hook value of `""` or `":"` is treated the same as not defining the hook. No console message.
-- **Skipping the main command skips its hooks**: When `X` is overridden to `""` or `":"`, neither `X:pre` nor `X:post` fires.
-- **Recursion guard**: Direct invocation of a hook (e.g., `nmr build:pre`) is treated as a leaf operation. It does NOT itself attempt to resolve `build:pre:pre` or `build:pre:post`.
-- **Passthrough args attach only to the main command**: `nmr X --flag value` runs hooks without `--flag value`.
-
-Worked examples:
-
-```ts
-// .config/nmr.config.ts — extend `nmr build` with a pre-build compile step
-import { defineConfig } from '@williamthorsen/nmr';
-
-export default defineConfig({
-  workspaceScripts: {
-    'build:pre': 'npx rdy compile',
-  },
-});
-```
-
-```jsonc
-// packages/nmr/package.json — re-stamp .agents/nmr/AGENTS.md after every build
-{
-  "scripts": {
-    "build:post": "nmr-sync-agent-files",
-  },
-}
-```
-
-The second example calls the bin directly to sidestep the workspace-vs-root registry distinction.
-
-## Agent-file sync
-
-The presence and version stamp of `.agents/nmr/AGENTS.md` is verified by `check:agent-files`, which is part of the default root `check:strict` composite. If it fails, run `nmr sync-agent-files`.
+- Use `nmr <command>`, not `pnpm run <command>`, for anything nmr provides. Run bare `nmr` to list every command and the shell command it resolves to; a wrong guess reports only `Unknown command`, with no list.
+- Scope follows cwd, and bare `nmr` lists both registries: from the repo root a command covers root files and every workspace; from inside a package, that package alone. `nmr -F <pkg> <command>` targets one package from anywhere; `nmr root:<command>` targets root files alone, which isolates a failure to root code.
+- Never `npx nmr`: inside a git worktree it can resolve a different nmr from outside the tree. Fall back to `pnpm exec nmr`.
+- The rest is in `node_modules/@williamthorsen/nmr/README.md`: pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`), script overrides and their `""`/`":"` skip values, `nmr upgrade` ceilings (report-only until `nmr upgrade --write`), and the `nmr-compile` build (there is no repo-local build script).

package/README.md

@@ -1,27 +1,54 @@
 # @williamthorsen/nmr
 
-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.
+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.19.0 (2026-07-22)
+## Release notes — v0.20.0 (2026-07-28)
 
 ### 🎉 Features
 
-- 🚨 **Breaking:** Replace the dependency commands with nmr upgrade (#491)
+- 🚨 **Breaking:** Migrate to code-quality workflow v7 and retire the version-restatement apparatus (#503)
 
-  Adds `nmr upgrade` as an ergonomic wrapper for displaying and applying available dependency upgrades. Taze is used under the hood to set a soaking period (customizable, defaulting to 7 days) before recently published dependencies will be accepted.
+  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.
 
-  Removes the four dependency commands it replaces: `outdated`, `outdated:latest`, `update`, and `update:latest`.
+  Taking this upgrade requires migrating the repo's code-quality workflow to `@v7` and deleting its version-alignment test in the same change.
+
+- 🚨 **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.
 <!-- /section:release-notes -->
 
 ## Installation
 
-Requires Node.js 24 or later.
+Requires Node.js 24.16 or later.
 
 ```bash
 pnpm add -D @williamthorsen/nmr
 ```
 
+### Making `nmr` resolvable
+
+nmr installs as a workspace bin, so the bare `nmr` command works only when your shell can find `<root>/node_modules/.bin/nmr`. Choose one:
+
+- **[direnv](https://direnv.net/)** (recommended for contributors). Add `PATH_add node_modules/.bin` to the repo's `.envrc`, and bare `nmr` works from any subdirectory.
+- **`pnpm exec nmr <command>`**. Works with no setup: pnpm resolves the bin from the workspace root.
+
+> **Note:** Avoid `npx nmr`. Inside a git worktree, `npx` can resolve a different nmr binary from outside the working tree, so the command succeeds while running the wrong code.
+
 ## Quick start
 
 nmr works out of the box with no configuration. It ships with built-in scripts for common monorepo tasks.
@@ -39,7 +66,7 @@ From the monorepo root:
 ```bash
 nmr test          # Run root tests + recursive workspace tests
 nmr build         # Build all packages
-nmr ci            # Run check:strict && build (full CI pipeline)
+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.
@@ -48,19 +75,26 @@ 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     | `nmr test` runs                               |
-| -------------------------- | ----------------- | --------------------------------------------- |
-| Monorepo root              | Root scripts      | Root tests + `pnpm --recursive exec nmr test` |
-| Inside a workspace package | Workspace scripts | `pnpm exec vitest` (for that package only)    |
-| Anywhere, with `-w` flag   | Root scripts      | Forces root registry regardless of location   |
+| 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` |
 
-Use `-w` to escape package context:
+Relative paths in a script resolve against that working directory, not the invocation directory.
+
+Use `--workspace-root` to escape package context:
 
 ```bash
 # From inside packages/nmr-core, run the root check suite
-nmr -w check
+nmr --workspace-root check
 ```
 
+Two consequences:
+
+- `nmr --workspace-root clean` sweeps every workspace package, as `nmr clean` does from the root.
+- Passthrough paths resolve against the working directory: from `packages/nmr/src/`, `nmr --workspace-root fmt pnpm-workspace.yaml` formats the file at the monorepo root.
+
 ## Three-tier override system
 
 Scripts resolve through three tiers. Higher tiers override lower ones:
@@ -92,6 +126,8 @@ Script values can be `string` or `string[]`. Arrays expand to chained `nmr` sub-
 // expands to: nmr lint && nmr fmt
 ```
 
+Passthrough arguments attach to the final step alone, because the expansion is a single shell chain: `nmr fix --dry-run` runs `nmr lint && nmr fmt --dry-run`.
+
 ## Configuration
 
 Create `.config/nmr.config.ts` in the monorepo root to add or override scripts:
@@ -137,6 +173,44 @@ For example, if a workspace script resolves to `my-cli --verbose`, nmr rewrites
 
 > **Note:** Path resolution uses a heuristic: any non-flag token containing `/` is treated as a relative path. This works well for typical dev-tool commands but may incorrectly resolve URL-like values or glob patterns. Flags using `--flag=value` syntax are not resolved; use the spaced form `--flag value` for paths that need resolution.
 
+## Pre and post hooks
+
+Every `nmr X` invocation auto-wraps as the equivalent of `nmr X:pre && nmr X && nmr X:post`. Hooks are first-class scripts that resolve through the same three tiers as any other script (built-in defaults, then `.config/nmr.config.ts`, then per-package `package.json`). Wrapping is uniform: nested invocations from composite expansion get their own hook treatment. Hook failure short-circuits the chain via shell `&&` semantics, propagating the failing exit code.
+
+Behaviors worth knowing:
+
+- **Silent when absent**: Missing hooks produce no error and no output.
+- **Skip overrides apply to hooks**: A hook value of `""` or `":"` is treated the same as not defining the hook, with no console message.
+- **Skipping the main command skips its hooks**: When `X` is overridden to `""` or `":"`, neither `X:pre` nor `X:post` fires.
+- **Recursion guard**: Direct invocation of a hook (e.g. `nmr build:pre`) is treated as a leaf operation. It does not itself attempt to resolve `build:pre:pre` or `build:pre:post`.
+- **Passthrough args attach only to the main command**: `nmr X --flag value` runs hooks without `--flag value`.
+
+Extend `nmr build` with a pre-build step for every workspace package:
+
+```ts
+// .config/nmr.config.ts
+import { defineConfig } from '@williamthorsen/nmr';
+
+export default defineConfig({
+  workspaceScripts: {
+    'build:pre': 'npx rdy compile',
+  },
+});
+```
+
+Attach a post-build step to one package:
+
+```jsonc
+// packages/nmr/package.json
+{
+  "scripts": {
+    "build:post": "nmr-sync-agent-files",
+  },
+}
+```
+
+The second example calls the bin directly, which sidesteps the workspace-versus-root registry distinction.
+
 ## Dependency upgrades
 
 `nmr upgrade` reports the dependency upgrades available to your repo. What it covers depends on where you run it:
@@ -148,6 +222,8 @@ For example, if a workspace script resolves to `my-cli --verbose`, nmr rewrites
 | `nmr -F <package> upgrade`   | that package, from anywhere                 |
 | `nmr root:upgrade`           | the root `package.json` alone               |
 
+`nmr upgrade` from the root precedes its report with any active `pnpm.overrides` declared in the root `package.json`; `nmr root:upgrade` does not. An override pins a transitive dependency, so an upgrade masked by one never appears in the report.
+
 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
@@ -156,8 +232,6 @@ nmr upgrade major    # major upgrades, still inside the ceilings
 nmr upgrade --write  # apply the proposals to package.json
 ```
 
-> **Note:** `-w` means different things on either side of the command. `nmr upgrade -w` passes `--write` to the upgrade tool; `nmr -w upgrade` is nmr's own `--workspace-root` flag and applies no write. Prefer the long forms to keep them apart. Run the root-context commands from the monorepo root: like nmr's other `root:` scripts, they take the current directory as their starting point.
-
 ### Configuring upgrades
 
 Declare version ceilings in a `taze.config.ts` at the monorepo root:
@@ -225,7 +299,7 @@ A package gets this variant automatically when it contains a `vitest.integration
 | Command | Runs                              |
 | ------- | --------------------------------- |
 | `build` | `pnpm --recursive exec nmr build` |
-| `ci`    | `build`, `check:strict`           |
+| `ci`    | `build`, `check:strict`, `audit`  |
 | `clean` | `nmr-clean`                       |
 
 #### Check and quality
@@ -283,9 +357,9 @@ A package gets this variant automatically when it contains a `vitest.integration
 
 #### Dependencies
 
-| Command   | Runs                                    |
-| --------- | --------------------------------------- |
-| `upgrade` | `nmr-taze --include-locked --recursive` |
+| Command   | Runs                                                            |
+| --------- | --------------------------------------------------------------- |
+| `upgrade` | `nmr-report-overrides && nmr-taze --include-locked --recursive` |
 
 See [dependency upgrades](#dependency-upgrades) for the workflow and its configuration.
 
@@ -305,11 +379,10 @@ These scripts operate on root-level code only (not workspace packages):
 
 #### Utilities
 
-| Command             | Runs                    |
-| ------------------- | ----------------------- |
-| `report-overrides`  | `nmr-report-overrides`  |
-| `sync-agent-files`  | `nmr-sync-agent-files`  |
-| `sync-pnpm-version` | `nmr-sync-pnpm-version` |
+| Command            | Runs                   |
+| ------------------ | ---------------------- |
+| `report-overrides` | `nmr-report-overrides` |
+| `sync-agent-files` | `nmr-sync-agent-files` |
 
 ## CLI reference
 
@@ -319,11 +392,13 @@ These scripts operate on root-level code only (not workspace packages):
 nmr [flags] <command> [args...]
 ```
 
+Position determines ownership: flags before the command name are nmr's own, and everything after the command name is forwarded untouched to the resolved command.
+
 | Flag                     | Description                                         | Default |
 | ------------------------ | --------------------------------------------------- | ------- |
 | `-F, --filter <pattern>` | Run command in matching packages                    | —       |
 | `-R, --recursive`        | Run command in all packages                         | —       |
-| `-w, --workspace-root`   | Force root script registry                          | —       |
+| `-w, --workspace-root`   | Use root scripts, running at the monorepo root      | —       |
 | `-q, --quiet`            | Suppress info messages; show full output on failure | —       |
 | `-?, --help`             | Show available commands                             | —       |
 | `-V, --version`          | Show version number                                 | —       |
@@ -337,14 +412,14 @@ nmr build                   # Compile to .js and .d.ts in one pass
 
 # From the monorepo root
 nmr test                    # Root tests + recursive workspace tests
-nmr ci                      # check:strict + build
+nmr ci                      # build + check:strict + audit
 
 # Target specific packages
-nmr -F core test            # Test only the core package
-nmr -R 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 -w check                # Run root check from a package dir
+nmr --workspace-root check  # Run root check from a package dir
 ```
 
 ## Additional subcommands
@@ -353,7 +428,7 @@ These commands are available as `nmr` subcommands and as standalone `nmr-`-prefi
 
 ### `report-overrides`
 
-Report any active `pnpm.overrides` in the root `package.json`. Useful as a `postinstall` hook to remind developers of active overrides that may need cleanup.
+Report any active `pnpm.overrides` in the root `package.json`, reminding developers of overrides that may need cleanup. The root `upgrade` script runs it automatically, so no per-repo wiring is needed. Invoking it directly is useful for a one-off report.
 
 ```bash
 nmr report-overrides
@@ -378,13 +453,16 @@ To expose the synced guidance to Claude Code sessions, add this include to the c
 @nmr/AGENTS.md
 ```
 
-### `sync-pnpm-version`
+#### What belongs in the synced file
 
-Synchronize the pnpm version from the root `package.json` `packageManager` field into the GitHub `code-quality.yaml` workflow file.
+The synced file is injected at launch in every consuming repo, so every line is paid for on every task whether or not it is relevant. It is a cheatsheet, not a manual.
 
-```bash
-nmr sync-pnpm-version
-```
+A line earns a place in `AGENTS.md` only if both hold:
+
+1. It is absent from nmr's own output. Bare `nmr` already prints the flags, every command, and the shell command each resolves to; failing checks already name their own fix. Repeating any of that costs launch tokens to say something the agent will be told anyway, at the moment it matters.
+2. The obvious action goes wrong without it. Guidance that prevents a silent mistake earns its place; guidance that prevents a mistake the next error message would diagnose does not.
+
+Everything else belongs in this README, reachable on demand at `node_modules/@williamthorsen/nmr/README.md`, with a pointer from `AGENTS.md` naming the topic so an agent knows to look. When adding a feature, document it here and extend that pointer rather than the cheatsheet.
 
 ## Standalone utilities
 
@@ -408,7 +486,7 @@ nmr-compile
 
 ### `nmr-taze`
 
-Run the [taze](https://github.com/antfu-collective/taze) dependency-upgrade tool, forwarding every argument to it untouched. This is what the `upgrade` and `root:upgrade` scripts resolve to — see [dependency upgrades](#dependency-upgrades) for the workflow.
+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.
 
 Under pnpm's isolated `node_modules`, a transitive package's binary is absent from the consuming repo's `node_modules/.bin`, so a repo that depends on nmr cannot run `taze` directly. `nmr-taze` can, because nmr is a direct dependency, and it resolves the tool from the tree nmr controls.
 
@@ -436,25 +514,31 @@ After installing, a consuming repo's root `package.json` scripts shrink to lifec
 
 ```json
 {
-  "prepare": "lefthook install",
-  "postinstall": "nmr report-overrides"
+  "prepare": "lefthook install"
 }
 ```
 
 Per-package `package.json` files no longer need script entries. Run `nmr <command>` directly.
 
-## Consistency tests
+## Workspace introspection
 
-Export structural consistency checks for use in your test suite:
+Repo-wide tests and scripts often need to know where the monorepo root is, or which directories its workspace packages live in. The `@williamthorsen/nmr/workspace` subpath publishes the two pnpm-workspace lookups nmr uses internally:
 
 ```ts
-// __tests__/consistency.test.ts
-import { runConsistencyChecks } from '@williamthorsen/nmr/tests';
+// __tests__/packages.test.ts
+import { findMonorepoRoot, getWorkspacePackageDirs } from '@williamthorsen/nmr/workspace';
+
+const monorepoRoot = findMonorepoRoot();
 
-runConsistencyChecks();
+for (const packageDir of getWorkspacePackageDirs(monorepoRoot)) {
+  // assert something about every workspace package
+}
 ```
 
-This verifies:
+`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.
+
+One divergence from pnpm: a directory counts as a package only if it holds a `package.json`, not a `package.yaml` or `package.json5`.
 
-- pnpm version matches between `package.json` and GitHub workflow
-- Node.js version matches between `.tool-versions` and GitHub workflow
+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.

package/dist/esm/cli-ensure-prepublish-hooks.js

@@ -1,6 +1,6 @@
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { DEFAULT_HOOK, ensurePrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
-import { findMonorepoRoot } from "./context.js";
+import { findMonorepoRoot } from "./workspace.js";
 const flagSchema = {
     fix: { long: '--fix', type: 'boolean' },
     dryRun: { long: '--dry-run', type: 'boolean' },

package/dist/esm/cli-report-overrides.js

@@ -1,6 +1,6 @@
 import { reportError } from '@williamthorsen/nmr-core';
 import { reportOverrides } from "./commands/report-overrides.js";
-import { findMonorepoRoot } from "./context.js";
+import { findMonorepoRoot } from "./workspace.js";
 try {
     const monorepoRoot = findMonorepoRoot();
     reportOverrides(monorepoRoot);

package/dist/esm/cli-sync-agent-files.js

@@ -1,6 +1,6 @@
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { check, sync } from "./commands/sync-agent-files.js";
-import { findMonorepoRoot } from "./context.js";
+import { findMonorepoRoot } from "./workspace.js";
 const flagSchema = {
     check: { long: '--check', type: 'boolean' },
 };

package/dist/esm/commands/clean.js

@@ -1,9 +1,10 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { loadConfig } from "../config.js";
-import { findContainingPackageDir, findMonorepoRoot, getWorkspacePackageDirs } from "../context.js";
+import { findContainingPackageDir } from "../context.js";
 import { applyDevBin, buildWorkspaceRegistry, hasIntegrationTestConfig, resolveScript } from "../resolver.js";
 import { runCommand } from "../runner.js";
+import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
 import { resolveBuildCachePath } from "./build.js";
 const CLEAN_ICON = '🧹';
 const CLEAN_COMMAND = 'clean';

package/dist/esm/commands/ensure-prepublish-hooks.js

@@ -1,8 +1,8 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { getWorkspacePackageDirs } from "../context.js";
 import { readPackageJson } from "../helpers/package-json.js";
 import { isObject } from "../helpers/type-guards.js";
+import { getWorkspacePackageDirs } from "../workspace.js";
 export const DEFAULT_HOOK = 'npm run build';
 export function ensurePrepublishHooks(monorepoRoot, options) {
     const hookCommand = options.command ?? DEFAULT_HOOK;

package/dist/esm/context.d.ts

@@ -5,7 +5,5 @@ export interface ResolvedContext {
     packageDir?: string;
     config: NmrConfig;
 }
-export declare function findMonorepoRoot(startDir?: string): string;
-export declare function getWorkspacePackageDirs(monorepoRoot: string): string[];
 export declare function findContainingPackageDir(dir: string, workspacePackageDirs: string[]): string | undefined;
 export declare function resolveContext(cwd?: string): Promise<ResolvedContext>;

package/dist/esm/context.js

@@ -1,71 +1,18 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { parse } from 'yaml';
 import { loadConfig } from "./config.js";
-import { isObject } from "./helpers/type-guards.js";
-export function findMonorepoRoot(startDir) {
-    let dir = path.resolve(startDir ?? process.cwd());
-    for (;;) {
-        if (existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
-            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');
-        }
-        dir = parent;
-    }
-}
-export function getWorkspacePackageDirs(monorepoRoot) {
-    const workspaceFile = path.join(monorepoRoot, 'pnpm-workspace.yaml');
-    const content = readFileSync(workspaceFile, 'utf8');
-    const parsed = parse(content);
-    const packages = getPackagesFromParsedYaml(parsed);
-    if (!packages) {
-        return [];
-    }
-    const dirs = [];
-    for (const pattern of packages) {
-        if (pattern.endsWith('/*')) {
-            const prefix = pattern.slice(0, -2);
-            const prefixDir = path.resolve(monorepoRoot, prefix);
-            if (existsSync(prefixDir)) {
-                for (const entry of readdirSync(prefixDir)) {
-                    const fullPath = path.join(prefixDir, entry);
-                    if (statSync(fullPath).isDirectory() && existsSync(path.join(fullPath, 'package.json'))) {
-                        dirs.push(fullPath);
-                    }
-                }
-            }
-        }
-        else if (!pattern.includes('*')) {
-            const fullPath = path.resolve(monorepoRoot, pattern);
-            if (existsSync(fullPath) && existsSync(path.join(fullPath, 'package.json'))) {
-                dirs.push(fullPath);
-            }
-        }
-    }
-    return dirs;
-}
+import { findMonorepoRoot, getWorkspacePackageDirs } from "./workspace.js";
 export function findContainingPackageDir(dir, workspacePackageDirs) {
     const resolved = path.resolve(dir);
+    let nearest;
     for (const pkgDir of workspacePackageDirs) {
         const resolvedPkgDir = path.resolve(pkgDir);
-        if (resolved === resolvedPkgDir || resolved.startsWith(resolvedPkgDir + path.sep)) {
-            return resolvedPkgDir;
+        if (resolved !== resolvedPkgDir && !resolved.startsWith(resolvedPkgDir + path.sep))
+            continue;
+        if (nearest === undefined || resolvedPkgDir.length > nearest.length) {
+            nearest = resolvedPkgDir;
         }
     }
-    return undefined;
-}
-function getPackagesFromParsedYaml(parsed) {
-    if (!isObject(parsed))
-        return undefined;
-    const packages = parsed.packages;
-    if (!Array.isArray(packages))
-        return undefined;
-    if (!packages.every((p) => typeof p === 'string'))
-        return undefined;
-    return packages;
+    return nearest;
 }
 export async function resolveContext(cwd) {
     const resolvedCwd = path.resolve(cwd ?? process.cwd());

package/dist/esm/default-scripts.js

@@ -55,10 +55,9 @@ export const rootScripts = {
     'root:typecheck': 'tsgo --noEmit',
     'root:upgrade': 'nmr-taze --include-locked',
     'sync-agent-files': 'nmr-sync-agent-files',
-    'sync-pnpm-version': 'nmr-sync-pnpm-version',
     test: 'nmr root:test && pnpm --recursive exec nmr test',
     'test:coverage': 'nmr root:test && pnpm --recursive exec nmr test:coverage',
     'test:watch': 'vitest --watch',
     typecheck: 'nmr root:typecheck && pnpm --recursive exec nmr typecheck',
-    upgrade: 'nmr-taze --include-locked --recursive',
+    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, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
+import { buildRootRegistry, buildWorkspaceRegistry, describeScript, hasIntegrationTestConfig, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
 export function generateHelp(config, packageDir, useRoot) {
     const lines = [
         'Usage: nmr [flags] <command> [args...]',
@@ -7,15 +7,17 @@ export function generateHelp(config, packageDir, useRoot) {
         'Flags:',
         '  -F, --filter <pattern>   Run command in matching packages',
         '  -R, --recursive          Run command in all packages',
-        '  -w, --workspace-root     Run root command regardless of cwd',
+        '  -w, --workspace-root     Use root scripts, running at the monorepo root',
         '  -q, --quiet              Suppress output on success; show full output on failure',
         '  -?, --help               Show this help',
+        '  -V, --version            Show version number',
         '',
         'Workspace commands:',
     ];
     const overrides = packageDir === undefined ? {} : collectOverrides(packageDir);
     let hadOverride = false;
-    const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config, false));
+    const useIntTests = !useRoot && packageDir !== undefined && hasIntegrationTestConfig(packageDir);
+    const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config, useIntTests));
     const workspaceMarked = !useRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
     if (workspaceMarked.size > 0)
         hadOverride = true;

package/dist/esm/helpers/workspace-patterns.d.ts

@@ -0,0 +1 @@
+export declare function resolvePackageDirs(monorepoRoot: string, patterns: string[]): string[];

package/dist/esm/helpers/workspace-patterns.js

@@ -0,0 +1,29 @@
+import { globSync } from 'node:fs';
+import path from 'node:path';
+const MANIFEST = 'package.json';
+const ALWAYS_EXCLUDED = ['**/node_modules/**'];
+export function resolvePackageDirs(monorepoRoot, patterns) {
+    const included = [];
+    const excluded = [];
+    for (const pattern of patterns) {
+        if (pattern.trim() === '')
+            continue;
+        const isNegated = pattern.startsWith('!');
+        const target = isNegated ? excluded : included;
+        target.push(toManifestPattern(isNegated ? pattern.slice(1) : pattern));
+    }
+    if (included.length === 0) {
+        return [];
+    }
+    const options = {
+        cwd: monorepoRoot,
+        exclude: [...excluded, ...ALWAYS_EXCLUDED],
+        followSymlinks: true,
+    };
+    const matches = globSync(included, options);
+    const dirs = matches.map((match) => path.dirname(path.resolve(monorepoRoot, match)));
+    return [...new Set(dirs)].toSorted();
+}
+function toManifestPattern(pattern) {
+    return `${pattern.replace(/\/?$/, '')}/${MANIFEST}`;
+}

package/dist/esm/index.d.ts

@@ -1,3 +1,2 @@
 export type { NmrConfig } from './config.js';
 export { defineConfig } from './config.js';
-export type { ResolvedContext } from './context.js';

package/dist/esm/runCli.js

@@ -20,9 +20,9 @@ export async function runCli(options) {
     }
     const context = await resolveContext(cwd);
     const useRoot = parsed.workspaceRoot || context.isRoot;
-    const packageDir = useRoot ? context.monorepoRoot : (context.packageDir ?? context.monorepoRoot);
+    const anchorDir = useRoot ? context.monorepoRoot : (context.packageDir ?? context.monorepoRoot);
     if (parsed.help || !parsed.command) {
-        stdout.write(`${generateHelp(context.config, packageDir, useRoot)}\n`);
+        stdout.write(`${generateHelp(context.config, anchorDir, useRoot)}\n`);
         return { exitCode: 0 };
     }
     const { command } = parsed;
@@ -41,8 +41,8 @@ export async function runCli(options) {
     }
     const registry = useRoot
         ? buildRootRegistry(context.config)
-        : buildWorkspaceRegistry(context.config, hasIntegrationTestConfig(packageDir));
-    const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
+        : buildWorkspaceRegistry(context.config, hasIntegrationTestConfig(anchorDir));
+    const resolved = resolveScript(command, registry, anchorDir, parsed.workspaceRoot);
     if (!resolved) {
         if (env.NMR_RUN_IF_PRESENT === '1') {
             return { exitCode: 0 };
@@ -50,20 +50,20 @@ export async function runCli(options) {
         reportError(`Unknown command: ${command}`, stderr);
         return { exitCode: 1 };
     }
-    const skipExitCode = handleSkipMessage(resolved.command, packageDir, parsed.quiet, stdout);
+    const skipExitCode = handleSkipMessage(resolved.command, anchorDir, parsed.quiet, stdout);
     if (skipExitCode !== undefined) {
         return { exitCode: skipExitCode };
     }
     if (resolved.source === 'package' && !parsed.quiet && registry[command] !== undefined) {
-        stdout.write(`📦 ${path.basename(packageDir)}: Using override script: ${resolved.command}\n`);
+        stdout.write(`📦 ${path.basename(anchorDir)}: Using override script: ${resolved.command}\n`);
     }
     const substitutedCommand = applyDevBin(resolved.command, context.config.devBin, context.monorepoRoot);
     const mainCommand = substitutedCommand + passthrough;
     const isHookInvocation = isHookName(command);
     const fullCommand = isHookInvocation
         ? mainCommand
-        : wrapWithHooks(command, mainCommand, registry, packageDir, parsed.workspaceRoot);
-    const exitCode = runCommand(fullCommand, cwd, runOptions);
+        : wrapWithHooks(command, mainCommand, registry, anchorDir, parsed.workspaceRoot);
+    const exitCode = runCommand(fullCommand, anchorDir, runOptions);
     return { exitCode };
 }
 function parseArgs(args) {
@@ -121,35 +121,35 @@ function parseArgs(args) {
     }
     return { ok: true, parsed };
 }
-function handleSkipMessage(resolvedCommand, packageDir, quiet, stdout) {
+function handleSkipMessage(resolvedCommand, anchorDir, quiet, stdout) {
     if (resolvedCommand === '') {
         if (!quiet) {
-            stdout.write(`⛔ ${path.basename(packageDir)}: Override script is defined but empty. Skipping.\n`);
+            stdout.write(`⛔ ${path.basename(anchorDir)}: Override script is defined but empty. Skipping.\n`);
         }
         return 0;
     }
     if (resolvedCommand === ':') {
         if (!quiet) {
-            stdout.write(`⛔ ${path.basename(packageDir)}: Override script is a no-op. Skipping.\n`);
+            stdout.write(`⛔ ${path.basename(anchorDir)}: Override script is a no-op. Skipping.\n`);
         }
         return 0;
     }
     return undefined;
 }
-function wrapWithHooks(command, mainCommand, registry, packageDir, workspaceRoot) {
+function wrapWithHooks(command, mainCommand, registry, anchorDir, workspaceRoot) {
     const segments = [];
     const flag = workspaceRoot ? '-w ' : '';
-    if (hasRunnableHook(`${command}:pre`, registry, packageDir, workspaceRoot)) {
+    if (hasRunnableHook(`${command}:pre`, registry, anchorDir, workspaceRoot)) {
         segments.push(`nmr ${flag}${command}:pre`);
     }
     segments.push(mainCommand);
-    if (hasRunnableHook(`${command}:post`, registry, packageDir, workspaceRoot)) {
+    if (hasRunnableHook(`${command}:post`, registry, anchorDir, workspaceRoot)) {
         segments.push(`nmr ${flag}${command}:post`);
     }
     return segments.join(' && ');
 }
-function hasRunnableHook(hookName, registry, packageDir, workspaceRoot) {
-    const resolved = resolveScript(hookName, registry, packageDir, workspaceRoot);
+function hasRunnableHook(hookName, registry, anchorDir, workspaceRoot) {
+    const resolved = resolveScript(hookName, registry, anchorDir, workspaceRoot);
     if (!resolved)
         return false;
     return resolved.command !== '' && resolved.command !== ':';

package/dist/esm/workspace.d.ts

@@ -0,0 +1,2 @@
+export declare function findMonorepoRoot(startDir?: string): string;
+export declare function getWorkspacePackageDirs(monorepoRoot: string): string[];

package/dist/esm/workspace.js

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { isObject } from "./helpers/type-guards.js";
+import { resolvePackageDirs } from "./helpers/workspace-patterns.js";
+export function findMonorepoRoot(startDir) {
+    let dir = path.resolve(startDir ?? process.cwd());
+    for (;;) {
+        if (existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
+            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');
+        }
+        dir = parent;
+    }
+}
+export function getWorkspacePackageDirs(monorepoRoot) {
+    const workspaceFile = path.join(monorepoRoot, 'pnpm-workspace.yaml');
+    const content = readFileSync(workspaceFile, 'utf8');
+    const parsed = parse(content);
+    const packages = getPackagesFromParsedYaml(parsed);
+    if (!packages) {
+        return [];
+    }
+    return resolvePackageDirs(monorepoRoot, packages);
+}
+function getPackagesFromParsedYaml(parsed) {
+    if (!isObject(parsed))
+        return undefined;
+    const packages = parsed.packages;
+    if (!Array.isArray(packages))
+        return undefined;
+    if (!packages.every((p) => typeof p === 'string'))
+        return undefined;
+    return packages;
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "private": false,
-  "description": "Context-aware script runner for PNPM monorepos",
+  "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
     "monorepo",
     "pnpm",
@@ -34,9 +34,9 @@
       "types": "./dist/esm/taze.d.ts",
       "default": "./dist/esm/taze.js"
     },
-    "./tests": {
-      "types": "./dist/esm/tests/consistency.d.ts",
-      "default": "./dist/esm/tests/consistency.js"
+    "./workspace": {
+      "types": "./dist/esm/workspace.d.ts",
+      "default": "./dist/esm/workspace.js"
     }
   },
   "bin": {
@@ -46,7 +46,6 @@
     "nmr-compile": "bin/nmr-compile.js",
     "nmr-report-overrides": "bin/nmr-report-overrides.js",
     "nmr-sync-agent-files": "bin/nmr-sync-agent-files.js",
-    "nmr-sync-pnpm-version": "bin/nmr-sync-pnpm-version.js",
     "nmr-taze": "bin/nmr-taze.js"
   },
   "files": [
@@ -59,17 +58,13 @@
     "jiti": "2.7.0",
     "taze": "19.15.1",
     "yaml": "2.9.0",
-    "zod": "4.4.3",
-    "@williamthorsen/nmr-core": "0.7.1"
-  },
-  "devDependencies": {
-    "@williamthorsen/toolbelt.strings": "3.1.6"
+    "@williamthorsen/nmr-core": "0.7.2"
   },
   "peerDependencies": {
     "typescript": ">=5.7.0 <7"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=24.16.0"
   },
   "publishConfig": {
     "access": "public"

package/bin/nmr-sync-pnpm-version.js

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

package/dist/esm/cli-sync-pnpm-version.d.ts

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

package/dist/esm/cli-sync-pnpm-version.js

@@ -1,11 +0,0 @@
-import { reportError } from '@williamthorsen/nmr-core';
-import { syncPnpmVersion } from "./commands/sync-pnpm-version.js";
-import { findMonorepoRoot } from "./context.js";
-try {
-    const monorepoRoot = findMonorepoRoot();
-    syncPnpmVersion(monorepoRoot);
-}
-catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-}

package/dist/esm/commands/sync-pnpm-version.d.ts

@@ -1,3 +0,0 @@
-declare function extractPnpmVersion(packageManager: string | undefined): string | null;
-export declare function syncPnpmVersion(monorepoRoot: string): void;
-export { extractPnpmVersion };

package/dist/esm/commands/sync-pnpm-version.js

@@ -1,40 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { parseDocument } from 'yaml';
-import { CodeQualityPnpmWorkflowSchema, getPnpmVersionNodes } from "../helpers/code-quality-pnpm-action.js";
-import { readPackageJson } from "../helpers/package-json.js";
-const WORKFLOW_RELATIVE_PATH = '.github/workflows/code-quality.yaml';
-function extractPnpmVersion(packageManager) {
-    if (!packageManager) {
-        return null;
-    }
-    const match = /^pnpm@(.+)$/.exec(packageManager);
-    return match?.[1] ?? null;
-}
-export function syncPnpmVersion(monorepoRoot) {
-    console.info('Synchronizing pnpm version in GitHub workflow...');
-    const pkg = readPackageJson(monorepoRoot);
-    const pnpmVersion = extractPnpmVersion(pkg.packageManager);
-    if (!pnpmVersion) {
-        throw new Error(`Could not extract pnpm version from package.json packageManager field\npackageManager field: ${pkg.packageManager ?? '(not set)'}`);
-    }
-    console.info(`Package.json pnpm version: ${pnpmVersion}`);
-    const workflowPath = path.join(monorepoRoot, WORKFLOW_RELATIVE_PATH);
-    const doc = parseDocument(readFileSync(workflowPath, 'utf8'));
-    const [parseError] = doc.errors;
-    if (parseError) {
-        throw new Error(`Failed to parse workflow file: ${workflowPath}\n${parseError.message}`);
-    }
-    CodeQualityPnpmWorkflowSchema.parse(doc.toJS());
-    const outdatedNodes = getPnpmVersionNodes(doc).filter((node) => String(node.value) !== pnpmVersion);
-    if (outdatedNodes.length === 0) {
-        console.info('Workflow pnpm version is already up to date');
-        return;
-    }
-    for (const node of outdatedNodes) {
-        node.value = pnpmVersion;
-    }
-    writeFileSync(workflowPath, doc.toString(), 'utf8');
-    console.info(`✓ Updated ${outdatedNodes.length} pnpm-version occurrence(s) → ${pnpmVersion}`);
-}
-export { extractPnpmVersion };

package/dist/esm/helpers/code-quality-pnpm-action.d.ts

@@ -1,13 +0,0 @@
-import { type Document, type Scalar } from 'yaml';
-import { z } from 'zod';
-export declare const CodeQualityPnpmWorkflowSchema: z.ZodObject<{
-    jobs: z.ZodObject<{
-        'code-quality': z.ZodObject<{
-            with: z.ZodObject<{
-                'pnpm-version': z.ZodString;
-            }, z.core.$loose>;
-        }, z.core.$loose>;
-    }, z.core.$loose>;
-}, z.core.$loose>;
-export type CodeQualityPnpmWorkflow = z.infer<typeof CodeQualityPnpmWorkflowSchema>;
-export declare function getPnpmVersionNodes(doc: Document): Scalar[];

package/dist/esm/helpers/code-quality-pnpm-action.js

@@ -1,22 +0,0 @@
-import { isScalar, visit } from 'yaml';
-import { z } from 'zod';
-export const CodeQualityPnpmWorkflowSchema = z.looseObject({
-    jobs: z.looseObject({
-        'code-quality': z.looseObject({
-            with: z.looseObject({
-                'pnpm-version': z.string(),
-            }),
-        }),
-    }),
-});
-export function getPnpmVersionNodes(doc) {
-    const nodes = [];
-    visit(doc, {
-        Pair(_, pair) {
-            if (isScalar(pair.key) && pair.key.value === 'pnpm-version' && isScalar(pair.value)) {
-                nodes.push(pair.value);
-            }
-        },
-    });
-    return nodes;
-}

package/dist/esm/tests/consistency.d.ts

@@ -1,7 +0,0 @@
-export { findMonorepoRoot } from '../context.js';
-export declare function checkPnpmVersionConsistency(monorepoRoot: string): void;
-export declare function checkNodeVersionConsistency(monorepoRoot: string): void;
-export declare function getPnpmVersionFromAction(monorepoRoot: string): Promise<string>;
-export declare function getPnpmVersionFromPackageJson(monorepoRoot: string): string;
-export declare function getNodeVersionFromAction(monorepoRoot: string): Promise<string>;
-export declare function runConsistencyChecks(): void;

package/dist/esm/tests/consistency.js

@@ -1,57 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { findMonorepoRoot } from "../context.js";
-export { findMonorepoRoot } from "../context.js";
-import { getRuntimeVersionFromAsdf } from "./helpers/get-runtime-version-from-asdf.js";
-import { getStringFromYamlFile } from "./helpers/get-string-from-yaml-file.js";
-import { getValueAtPathOrThrow } from "./helpers/get-value-at-path.js";
-const GITHUB_ACTION_FILE_PATH = '.github/workflows/code-quality.yaml';
-export function checkPnpmVersionConsistency(monorepoRoot) {
-    describe('pnpm version consistency', () => {
-        it('pnpm version is the same in GitHub action and package.json', async () => {
-            const actionVersion = await getPnpmVersionFromAction(monorepoRoot);
-            const packageJsonVersion = getPnpmVersionFromPackageJson(monorepoRoot);
-            expect(actionVersion).toBe(packageJsonVersion);
-        });
-    });
-}
-export function checkNodeVersionConsistency(monorepoRoot) {
-    describe('Node.js version consistency', () => {
-        it('version is the same in GitHub action and .tool-versions', async () => {
-            const toolVersion = await getRuntimeVersionFromAsdf('nodejs', monorepoRoot);
-            const actionVersion = await getNodeVersionFromAction(monorepoRoot);
-            expect(toolVersion).toBe(actionVersion);
-        });
-    });
-}
-export async function getPnpmVersionFromAction(monorepoRoot) {
-    const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
-    return getStringFromYamlFile(actionPath, 'jobs.code-quality.with.pnpm-version', 'pnpm version');
-}
-export function getPnpmVersionFromPackageJson(monorepoRoot) {
-    const pkgPath = path.join(monorepoRoot, 'package.json');
-    const raw = fs.readFileSync(pkgPath, 'utf8');
-    const pkg = JSON.parse(raw);
-    const pm = getValueAtPathOrThrow(pkg, 'packageManager');
-    if (typeof pm !== 'string') {
-        throw new TypeError('"packageManager" field missing or not a string in package.json.');
-    }
-    const [name, version] = pm.split('@', 2);
-    if (name !== 'pnpm') {
-        throw new Error('packageManager is not pnpm.');
-    }
-    if (!version) {
-        throw new Error('pnpm version missing in package.json.');
-    }
-    return version;
-}
-export async function getNodeVersionFromAction(monorepoRoot) {
-    const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
-    return getStringFromYamlFile(actionPath, 'jobs.code-quality.with.node-version', 'Node.js version');
-}
-export function runConsistencyChecks() {
-    const monorepoRoot = findMonorepoRoot();
-    checkPnpmVersionConsistency(monorepoRoot);
-    checkNodeVersionConsistency(monorepoRoot);
-}

package/dist/esm/tests/helpers/get-runtime-version-from-asdf.d.ts

@@ -1 +0,0 @@
-export declare function getRuntimeVersionFromAsdf(runtime: string, monorepoRoot: string): Promise<string>;

package/dist/esm/tests/helpers/get-runtime-version-from-asdf.js

@@ -1,12 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import path from 'node:path';
-export async function getRuntimeVersionFromAsdf(runtime, monorepoRoot) {
-    const toolVersionsPath = path.join(monorepoRoot, '.tool-versions');
-    const toolVersions = await fs.promises.readFile(toolVersionsPath, { encoding: 'utf8' });
-    const versionLine = toolVersions.split('\n').find((line) => line.trim().startsWith(runtime));
-    assert.ok(versionLine, `${runtime} not found in .tool-versions`);
-    const [, version] = versionLine.trim().split(/\s+/, 2);
-    assert.ok(version, `${runtime} version missing in .tool-versions`);
-    return version;
-}

package/dist/esm/tests/helpers/get-string-from-yaml-file.d.ts

@@ -1 +0,0 @@
-export declare function getStringFromYamlFile(filePath: string, keyPath: string, label: string): Promise<string>;

package/dist/esm/tests/helpers/get-string-from-yaml-file.js

@@ -1,12 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import { parse } from 'yaml';
-import { getValueAtPathOrThrow } from "./get-value-at-path.js";
-export async function getStringFromYamlFile(filePath, keyPath, label) {
-    const raw = await fs.promises.readFile(filePath, { encoding: 'utf8' });
-    const parsed = parse(raw);
-    assert.ok(parsed, `YAML content not found in ${filePath}`);
-    const value = getValueAtPathOrThrow(parsed, keyPath);
-    assert.ok(typeof value === 'string' && value.length > 0, `${label} not found at ${keyPath}`);
-    return value;
-}

package/dist/esm/tests/helpers/get-value-at-path.d.ts

@@ -1 +0,0 @@
-export declare function getValueAtPathOrThrow(obj: unknown, objPath: string): unknown;

package/dist/esm/tests/helpers/get-value-at-path.js

@@ -1,34 +0,0 @@
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function getValueAtPathOrThrow(obj, objPath) {
-    if (!isObject(obj)) {
-        throw new Error('Expected an object as root value.');
-    }
-    const keys = objPath.split('.');
-    let current = obj;
-    for (const key of keys) {
-        if (Array.isArray(current)) {
-            const index = Number(key);
-            if (Number.isNaN(index)) {
-                throw new TypeError(`Expected array index at segment "${key}" in path "${objPath}"`);
-            }
-            if (index >= 0 && index < current.length) {
-                current = current[index];
-            }
-            else {
-                throw new Error(`Array index out of bounds: "${key}" in path "${objPath}"`);
-            }
-        }
-        else if (isObject(current)) {
-            if (!(key in current)) {
-                throw new Error(`Missing key "${key}" in path "${objPath}"`);
-            }
-            current = current[key];
-        }
-        else {
-            throw new Error(`Unexpected non-object/non-array at segment "${key}" in path "${objPath}"`);
-        }
-    }
-    return current;
-}