@williamthorsen/nmr 0.19.0 → 0.21.0

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 { applyDevBin, buildWorkspaceRegistry, hasIntegrationTestConfig, resolveScript } from "../resolver.js";
+import { findContainingPackageDir } from "../context.js";
+import { applyDevBin, buildWorkspaceRegistry, 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';
@@ -33,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/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/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/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.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,14 +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',
-    'sync-pnpm-version': 'nmr-sync-pnpm-version',
     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-taze --include-locked --recursive',
+    upgrade: 'nmr-report-overrides && nmr-taze --include-locked --recursive',
 };

package/dist/esm/help.js

@@ -7,15 +7,16 @@ 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 workspaceRegistry = filterHooks(buildWorkspaceRegistry(config));
     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/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) {
@@ -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;
@@ -39,10 +39,8 @@ 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(packageDir));
-    const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
+    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') {
             return { exitCode: 0 };
@@ -50,20 +48,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 +119,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/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;