@williamthorsen/nmr 0.55.0 → 1.0.0

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

@@ -1,24 +1,37 @@
-import { parseArgsOrExit, reportFailure } from '@williamthorsen/nmr-core';
+import process from 'node:process';
+import { reportFailure } from '@williamthorsen/nmr-core';
+import { defineCommand, runCli } from '@williamthorsen/nmr-core/cli';
+import { ENSURE_PREPUBLISH_HOOKS_BIN } from "./bins.js";
 import { DEFAULT_HOOK, ensurePrepublishHooks, reportPrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
 import { resolveBinStyles } from "./resolveBinStyles.js";
 import { findMonorepoRoot } from "./workspace.js";
-const flagSchema = {
-    shouldFix: { long: '--fix', type: 'boolean' },
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-    command: { long: '--command', type: 'string' },
-};
-const { shouldFix, isDryRun, command } = parseArgsOrExit(process.argv.slice(2), flagSchema).flags;
+const command = defineCommand({
+    summary: 'Check that every publishable workspace package has a prepublishOnly script',
+    flags: {
+        fix: { type: 'boolean', description: 'Add the script to each publishable package that lacks it' },
+        dryRun: { type: 'boolean', description: 'With --fix, report the packages that it would change without writing' },
+        command: {
+            type: 'string',
+            description: `The command that the script runs (default: ${DEFAULT_HOOK})`,
+            valueHint: 'command',
+        },
+    },
+    run: ({ flags }) => {
+        const styles = resolveBinStyles();
+        const options = { shouldFix: flags.fix, isDryRun: flags.dryRun, ...(flags.command && { command: flags.command }) };
+        const result = ensurePrepublishHooks(findMonorepoRoot(), options);
+        reportPrepublishHooks(result, flags.command ?? DEFAULT_HOOK, styles.stdout);
+        return result.hasFailures ? 1 : 0;
+    },
+});
 try {
-    const { stdout } = resolveBinStyles();
-    const monorepoRoot = findMonorepoRoot();
-    const options = command ? { shouldFix, isDryRun, command } : { shouldFix, isDryRun };
-    const result = ensurePrepublishHooks(monorepoRoot, options);
-    reportPrepublishHooks(result, command ?? DEFAULT_HOOK, stdout);
-    if (result.hasFailures) {
-        process.exitCode = 1;
-    }
+    process.exitCode = await runCli(process.argv.slice(2), command, {
+        name: ENSURE_PREPUBLISH_HOOKS_BIN,
+        stdout: process.stdout,
+        stderr: process.stderr,
+    });
 }
 catch (error) {
-    reportFailure('ensure-prepublish-hooks', error);
+    reportFailure(ENSURE_PREPUBLISH_HOOKS_BIN, error);
     process.exitCode = 1;
 }

package/dist/esm/cli-fmt.js

@@ -1,10 +1,11 @@
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_FMT_BIN } from "./bins.js";
 import { runFmt } from "./commands/fmt.js";
 try {
     process.exitCode = await runFmt(process.argv.slice(2), process.cwd());
 }
 catch (error) {
-    reportFailure('nmr-fmt', error);
+    reportFailure(NMR_FMT_BIN, error);
     process.exitCode = 1;
 }

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

@@ -1,11 +1,12 @@
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_REPORT_CATALOG_BIN } from "./bins.js";
 import { reportCatalog } from "./commands/report-catalog.js";
 import { resolveBinStyles } from "./resolveBinStyles.js";
 try {
     reportCatalog(process.cwd(), resolveBinStyles().stderr);
 }
 catch (error) {
-    reportFailure('nmr-report-catalog', error);
+    reportFailure(NMR_REPORT_CATALOG_BIN, error);
     process.exitCode = 1;
 }

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

@@ -1,4 +1,5 @@
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_REPORT_OVERRIDES_BIN } from "./bins.js";
 import { reportOverrides } from "./commands/report-overrides.js";
 import { resolveBinStyles } from "./resolveBinStyles.js";
 import { findMonorepoRoot } from "./workspace.js";
@@ -7,6 +8,6 @@ try {
     reportOverrides(monorepoRoot, resolveBinStyles().stderr);
 }
 catch (error) {
-    reportFailure('nmr-report-overrides', error);
+    reportFailure(NMR_REPORT_OVERRIDES_BIN, error);
     process.exitCode = 1;
 }

package/dist/esm/cli-shellcheck.js

@@ -1,11 +1,12 @@
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_SHELLCHECK_BIN } from "./bins.js";
 import { runShellcheck } from "./commands/shellcheck.js";
 import { findMonorepoRoot } from "./workspace.js";
 try {
     process.exitCode = await runShellcheck(findMonorepoRoot(), process.argv.slice(2));
 }
 catch (error) {
-    reportFailure('nmr-shellcheck', error);
+    reportFailure(NMR_SHELLCHECK_BIN, error);
     process.exitCode = 1;
 }

package/dist/esm/cli-taze.js

@@ -1,11 +1,12 @@
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_TAZE_BIN } from "./bins.js";
 import { runTaze } from "./commands/taze.js";
 import { resolveBinStyles } from "./resolveBinStyles.js";
 try {
     process.exitCode = await runTaze(process.argv.slice(2), { stderrStyle: resolveBinStyles().stderr });
 }
 catch (error) {
-    reportFailure('nmr-taze', error);
+    reportFailure(NMR_TAZE_BIN, error);
     process.exitCode = 1;
 }

package/dist/esm/cli-vitest.js

@@ -1,10 +1,11 @@
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_VITEST_BIN } from "./bins.js";
 import { runNmrVitest } from "./commands/run-vitest.js";
 try {
     process.exitCode = runNmrVitest(process.argv.slice(2), process.cwd());
 }
 catch (error) {
-    reportFailure('nmr-vitest', error);
+    reportFailure(NMR_VITEST_BIN, error);
     process.exitCode = 1;
 }

package/dist/esm/cli.js

@@ -1,5 +1,6 @@
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
+import { NMR_BIN } from "./bins.js";
 import { runCli } from "./runCli.js";
 try {
     const { exitCode } = await runCli({
@@ -12,6 +13,6 @@ try {
     process.exitCode = exitCode;
 }
 catch (error) {
-    reportFailure('nmr', error);
+    reportFailure(NMR_BIN, error);
     process.exitCode = 1;
 }

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

@@ -6,9 +6,9 @@ export interface ActionlintOutcome {
     status: number | null;
 }
 export interface RunActionlintOptions {
-    /** Directory under which the pinned tools are cached; defaults to `node_modules/.cache/nmr-tools` at the root. */
-    cacheRoot?: string;
-    ensure?: (tool: WorkflowTool, cacheRoot: string) => Promise<string>;
+    /** Directories under which the pinned tools are cached, in lookup order; defaults to `resolveToolCacheRoots`. */
+    cacheRoots?: readonly [string, ...string[]];
+    ensure?: (tool: WorkflowTool, cacheRoots: readonly [string, ...string[]]) => Promise<string>;
     spawn?: (file: string, args: string[], cwd: string) => ActionlintOutcome;
 }
 /**

package/dist/esm/commands/actionlint.js

@@ -3,17 +3,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { UserError } from '@williamthorsen/nmr-core';
 import { describeSignalExitCode } from "../child-process.js";
-import { ensureTool } from "./workflow-tools.js";
+import { ensureTool, resolveToolCacheRoots } from "./workflow-tools.js";
 const WORKFLOWS_DIR = path.join('.github', 'workflows');
 export async function runActionlint(monorepoRoot, args, options = {}) {
     if (!fs.existsSync(path.join(monorepoRoot, WORKFLOWS_DIR))) {
         console.info(`No workflows to lint: ${WORKFLOWS_DIR}/ does not exist.`);
         return 0;
     }
-    const cacheRoot = options.cacheRoot ?? path.join(monorepoRoot, 'node_modules', '.cache', 'nmr-tools');
-    const ensure = options.ensure ?? ((tool, root) => ensureTool(tool, { cacheRoot: root }));
-    const actionlintPath = await ensure('actionlint', cacheRoot);
-    const shellcheckPath = await ensure('shellcheck', cacheRoot);
+    const cacheRoots = options.cacheRoots ?? resolveToolCacheRoots(monorepoRoot);
+    const ensure = options.ensure ?? ((tool, roots) => ensureTool(tool, { cacheRoots: roots }));
+    const actionlintPath = await ensure('actionlint', cacheRoots);
+    const shellcheckPath = await ensure('shellcheck', cacheRoots);
     const outcome = (options.spawn ?? spawnInherited)(actionlintPath, buildActionlintArgs(shellcheckPath, args), monorepoRoot);
     if (outcome.error !== undefined) {
         throw new UserError(`Cannot run actionlint: ${outcome.error.message}`, { cause: outcome.error });

package/dist/esm/commands/build.js

@@ -92,7 +92,7 @@ async function emitPackage(packageDir, entryPoints, outdir) {
 }
 function assertEmitSucceeded(result) {
     if (result.emitSkipped) {
-        throw new UserError(`nmr-compile: emit failed.\n${formatDiagnostics(result.diagnostics)}`);
+        throw new UserError(`emit failed.\n${formatDiagnostics(result.diagnostics)}`);
     }
 }
 function createCachingCompilerHost(compilerOptions) {
@@ -127,7 +127,7 @@ function resolveEmitDir(packageDir, outdir) {
     if (relativePathFromPackage === '' ||
         relativePathFromPackage.startsWith('..') ||
         path.isAbsolute(relativePathFromPackage)) {
-        throw new UserError(`nmr-compile: refusing to build into '${outdir}', which does not resolve inside the package. ` +
+        throw new UserError(`refusing to build into '${outdir}', which does not resolve inside the package. ` +
             'The build replaces its output directory on each emit, so the directory must be below the package root.');
     }
     return resolvedDir;
@@ -144,7 +144,7 @@ async function swapIntoPlace(emitDir, scratchDirs) {
         if (hadPreviousOutput && !existsSync(emitDir)) {
             await rename(scratchDirs.previousDir, emitDir);
         }
-        throw new UserError(`nmr-compile: failed to move the built output into ${emitDir}: ${describeError(error)}`, {
+        throw new UserError(`failed to move the built output into ${emitDir}: ${describeError(error)}`, {
             cause: error,
         });
     }
@@ -155,11 +155,11 @@ function synthesizeCompilerOptions(packageDir, outdir) {
     const configPath = path.join(packageDir, 'tsconfig.json');
     const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
     if (configFile.error) {
-        throw new UserError(`nmr-compile: failed to read ${configPath}.\n${formatDiagnostics([configFile.error])}`);
+        throw new UserError(`failed to read ${configPath}.\n${formatDiagnostics([configFile.error])}`);
     }
     const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
     if (parsedConfig.errors.length > 0) {
-        throw new UserError(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsedConfig.errors)}`);
+        throw new UserError(`failed to parse ${configPath}.\n${formatDiagnostics(parsedConfig.errors)}`);
     }
     const resolvedOutDir = path.resolve(packageDir, outdir);
     return {
@@ -180,7 +180,7 @@ function writeStagedOutput(stagedFiles, emitDir, stagingDir) {
     const ts = getCompiler();
     for (const [fileName, file] of stagedFiles) {
         if (!isWithin(emitDir, fileName)) {
-            throw new Error(`nmr-compile: the compiler emitted ${fileName}, which is outside the output directory ${emitDir}. ` +
+            throw new Error(`the compiler emitted ${fileName}, which is outside the output directory ${emitDir}. ` +
                 "Verify the resolved tsconfig's 'outDir' and 'declarationDir'.");
         }
         ts.sys.writeFile(path.join(stagingDir, path.relative(emitDir, fileName)), file.text, file.writeByteOrderMark);

package/dist/esm/commands/clean.js

@@ -1,6 +1,7 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { formatGlyphLine, UserError } from '@williamthorsen/nmr-core';
+import { NMR_CLEAN_BIN } from "../bins.js";
 import { removeCheckCache } from "../check-cache-entries.js";
 import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
@@ -68,10 +69,11 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
         }
         const command = applyDevBin(resolvedCommand, config.devBin, monorepoRoot);
         const { exitCode } = await runCommand(command, packageDir, {
+            bin: NMR_CLEAN_BIN,
             channels: { stderr: resolveChannel(process.stderr, false), stdout: resolveChannel(process.stdout, false) },
         });
         if (exitCode !== 0) {
-            throw new UserError(`nmr-clean: \`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
+            throw new UserError(`\`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }
         cleanedCount++;
     }

package/dist/esm/commands/compiler.js

@@ -14,7 +14,7 @@ export function assertSupportedTypeScript() {
     const minor = minorPart === undefined ? 0 : Number(minorPart);
     const tooOld = major < MINIMUM_TYPESCRIPT_MAJOR || (major === MINIMUM_TYPESCRIPT_MAJOR && minor < MINIMUM_TYPESCRIPT_MINOR);
     if (tooOld || major >= UNSUPPORTED_TYPESCRIPT_MAJOR) {
-        throw new UserError(`nmr-compile requires TypeScript ${SUPPORTED_TYPESCRIPT_RANGE}, but found ` +
+        throw new UserError(`requires TypeScript ${SUPPORTED_TYPESCRIPT_RANGE}, but found ` +
             `${typeof version === 'string' ? version : 'a version without the compiler API'}. ${INSTALL_TYPESCRIPT_GUIDANCE}`);
     }
 }
@@ -28,7 +28,7 @@ export function formatDiagnostics(diagnostics) {
 }
 export function getCompiler() {
     if (ts === undefined) {
-        throw new Error('nmr-compile: the compiler is not loaded; call loadCompiler first.');
+        throw new Error('the compiler is not loaded; call loadCompiler first.');
     }
     return ts;
 }
@@ -38,7 +38,7 @@ export async function loadCompiler(loadTypeScript = importTypeScript) {
     }
     catch (error) {
         if (hasErrnoCode(error, 'ERR_MODULE_NOT_FOUND') && error.message.includes("'typescript'")) {
-            throw new UserError(`nmr-compile requires TypeScript ${SUPPORTED_TYPESCRIPT_RANGE}, but 'typescript' could not be resolved. ` +
+            throw new UserError(`requires TypeScript ${SUPPORTED_TYPESCRIPT_RANGE}, but 'typescript' could not be resolved. ` +
                 INSTALL_TYPESCRIPT_GUIDANCE, { cause: error });
         }
         throw error;

package/dist/esm/commands/ensure-prepublish-hooks.d.ts

@@ -10,7 +10,7 @@ export interface EnsurePrepublishHooksResult {
     packages: PackageHookStatus[];
     hasFailures: boolean;
 }
-export declare const DEFAULT_HOOK = "npm run build";
+export declare const DEFAULT_HOOK = "nmr build";
 /**
  * Checks (and optionally fixes) whether all publishable workspace packages
  * have a `prepublishOnly` script.

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

@@ -1,12 +1,11 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { STATUS_GLYPHS, UserError } from '@williamthorsen/nmr-core';
+import { isRecord, STATUS_GLYPHS, UserError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
-import { isObject } from "../helpers/type-guards.js";
 import { getWorkspacePackageDirs } from "../workspace.js";
-export const DEFAULT_HOOK = 'npm run build';
+export const DEFAULT_HOOK = 'nmr build';
 export function ensurePrepublishHooks(monorepoRoot, options) {
     const hookCommand = options.command ?? DEFAULT_HOOK;
     const packageDirs = getWorkspacePackageDirs(monorepoRoot);
@@ -83,10 +82,10 @@ function addPrepublishOnly(packageDir, command) {
     catch (error) {
         throw new UserError(`Invalid package.json in ${packageDir}: ${describeError(error)}`, { cause: error });
     }
-    if (!isObject(parsedManifest)) {
+    if (!isRecord(parsedManifest)) {
         throw new UserError(`Invalid package.json in ${packageDir}: expected an object`);
     }
-    const scripts = isObject(parsedManifest['scripts']) ? parsedManifest['scripts'] : {};
+    const scripts = isRecord(parsedManifest['scripts']) ? parsedManifest['scripts'] : {};
     scripts['prepublishOnly'] = command;
     parsedManifest['scripts'] = scripts;
     writeFileSync(filePath, JSON.stringify(parsedManifest, null, 2) + '\n', 'utf8');

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

@@ -1,8 +1,8 @@
 export type FormatMode = 'check' | 'write';
 /**
- * Formats or checks the files that git reports for `cwd`, and returns the exit code to report. A repository
- * without a Prettier config of its own is formatted with the house config. The run uses Prettier's content-keyed
- * cache unless `--no-cache` or `NMR_NO_CACHE=1` bypasses it.
+ * Runs `nmr-fmt` against `argv` and returns the exit code to report: It formats or checks the files that git
+ * reports for `cwd`. A repository without a Prettier config of its own is formatted with the house config. The run
+ * uses Prettier's content-keyed cache unless `--no-cache` or `NMR_NO_CACHE=1` bypasses it.
  *
  * Trailing arguments are git pathspecs, not Prettier flags; an unrecognized option is rejected rather
  * than passed along, since git would read it as a pathspec matching nothing and the run would report

package/dist/esm/commands/fmt.js

@@ -5,29 +5,41 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
-import { reportError } from '@williamthorsen/nmr-core';
+import { isRecord, reportError } from '@williamthorsen/nmr-core';
+import { defineCommand, runCli, UsageError } from '@williamthorsen/nmr-core/cli';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { isObject } from "../helpers/type-guards.js";
+import { NMR_FMT_BIN } from "../bins.js";
 import { prepareFmtCache } from "./fmt-cache.js";
 import { resolveFormatTargets } from "./format-targets.js";
 const PRETTIER_PACKAGE = 'prettier';
 const DEFAULT_CONFIG_PATH = fileURLToPath(new URL(`../prettier-default.config${path.extname(fileURLToPath(import.meta.url))}`, import.meta.url));
 const ARGUMENT_BUDGET_BYTES = 100_000;
-const USAGE = 'Usage: nmr-fmt (--check | --write) [--no-cache] [--] [pathspec...]';
 const MODE_ARGS = {
     check: ['--check'],
     write: ['--list-different', '--write'],
 };
 export async function runFmt(argv, cwd = process.cwd()) {
-    const parsedArgs = parseFmtArgs(argv);
-    if (!parsedArgs.ok) {
-        reportError(`nmr-fmt: ${parsedArgs.error}`);
-        process.stderr.write(`${USAGE}\n`);
-        return 1;
-    }
-    const resolvedTargets = resolveFormatTargets(cwd, parsedArgs.pathspecs);
+    const command = defineCommand({
+        summary: 'Format or check the files that git lists',
+        flags: {
+            check: { type: 'boolean', description: 'Report the files that are not formatted, without changing them' },
+            write: { type: 'boolean', description: 'Format the files in place, naming each one that changes' },
+            noCache: { type: 'boolean', description: "Ignore Prettier's cache of files that already passed" },
+        },
+        operands: [{ name: 'pathspec', description: 'Git pathspecs that limit the files', optional: true, variadic: true }],
+        run: ({ flags, operands }) => {
+            if (flags.check === flags.write) {
+                throw new UsageError(flags.check ? 'Pass --check or --write, not both.' : 'Pass --check or --write.');
+            }
+            return formatFiles({ mode: flags.check ? 'check' : 'write', pathspecs: operands.pathspec, shouldBypassCache: flags.noCache }, cwd);
+        },
+    });
+    return runCli(argv, command, { name: NMR_FMT_BIN, stdout: process.stdout, stderr: process.stderr, baseDir: cwd });
+}
+async function formatFiles(request, cwd) {
+    const resolvedTargets = resolveFormatTargets(cwd, request.pathspecs);
     if (!resolvedTargets.ok) {
-        reportError(`nmr-fmt: ${resolvedTargets.error}`);
+        reportError(NMR_FMT_BIN, resolvedTargets.error);
         return 1;
     }
     const { excludedFiles, files, ignorePaths, repositoryRoot, unreadableFiles } = resolvedTargets.targets;
@@ -35,10 +47,10 @@ export async function runFmt(argv, cwd = process.cwd()) {
         process.stderr.write(`nmr-fmt: skipped ${file}, which cannot be read (${code})\n`);
     }
     if (files.length === 0) {
-        if (parsedArgs.pathspecs.length === 0)
+        if (request.pathspecs.length === 0)
             return 0;
         if (excludedFiles.length === 0 && unreadableFiles.length === 0) {
-            reportError(`nmr-fmt: the pathspecs did not match any file that git lists: ${parsedArgs.pathspecs.join(', ')}`);
+            reportError(NMR_FMT_BIN, `the pathspecs did not match any file that git lists: ${request.pathspecs.join(', ')}`);
             return 1;
         }
         if (excludedFiles.length > 0) {
@@ -48,19 +60,19 @@ export async function runFmt(argv, cwd = process.cwd()) {
     }
     const cli = resolvePrettierCli(cwd);
     if (!cli.ok) {
-        reportError(`nmr-fmt: ${cli.error}`);
+        reportError(NMR_FMT_BIN, cli.error);
         return 1;
     }
     const repositoryConfig = await findRepositoryConfig(cli.manifestPath, cwd);
     if (!repositoryConfig.ok) {
-        reportError(`nmr-fmt: ${repositoryConfig.error}`);
+        reportError(NMR_FMT_BIN, repositoryConfig.error);
         return 1;
     }
     const cache = prepareFmtCache({
         cwd,
         env: process.env,
         repositoryRoot,
-        shouldBypassCache: parsedArgs.shouldBypassCache,
+        shouldBypassCache: request.shouldBypassCache,
     });
     if (cache.kind === 'failed') {
         process.stderr.write(`nmr-fmt: running without the Prettier cache: ${cache.reason}\n`);
@@ -69,43 +81,12 @@ export async function runFmt(argv, cwd = process.cwd()) {
         cacheLocation: cache.kind === 'cached' ? cache.location : undefined,
         cliPath: cli.cliPath,
         configPath: repositoryConfig.found ? undefined : DEFAULT_CONFIG_PATH,
-        mode: parsedArgs.mode,
+        mode: request.mode,
         files,
         ignorePaths,
         cwd,
     });
 }
-function parseFmtArgs(argv) {
-    let mode;
-    let shouldBypassCache = false;
-    const pathspecs = [];
-    for (const [index, arg] of argv.entries()) {
-        if (arg === '--') {
-            pathspecs.push(...argv.slice(index + 1));
-            break;
-        }
-        if (arg === '--no-cache') {
-            shouldBypassCache = true;
-            continue;
-        }
-        if (arg === '--check' || arg === '--write') {
-            const requestedMode = arg === '--check' ? 'check' : 'write';
-            if (mode !== undefined && mode !== requestedMode) {
-                return { ok: false, error: 'Pass --check or --write, not both.' };
-            }
-            mode = requestedMode;
-            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, shouldBypassCache };
-}
 function resolvePrettierCli(cwd) {
     const missingResult = {
         ok: false,
@@ -116,9 +97,9 @@ function resolvePrettierCli(cwd) {
     if (manifestPath === undefined)
         return missingResult;
     const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    if (!isObject(manifest))
+    if (!isRecord(manifest))
         return missingResult;
-    const bin = isObject(manifest['bin']) ? manifest['bin'][PRETTIER_PACKAGE] : manifest['bin'];
+    const bin = isRecord(manifest['bin']) ? manifest['bin'][PRETTIER_PACKAGE] : manifest['bin'];
     if (typeof bin !== 'string')
         return missingResult;
     return { ok: true, cliPath: path.resolve(path.dirname(manifestPath), bin), manifestPath };
@@ -126,7 +107,7 @@ function resolvePrettierCli(cwd) {
 async function findRepositoryConfig(manifestPath, cwd) {
     try {
         const prettier = createRequire(manifestPath)(PRETTIER_PACKAGE);
-        const resolveConfigFile = isObject(prettier) ? prettier['resolveConfigFile'] : undefined;
+        const resolveConfigFile = isRecord(prettier) ? prettier['resolveConfigFile'] : undefined;
         if (typeof resolveConfigFile !== 'function') {
             return {
                 ok: false,
@@ -157,7 +138,7 @@ export function runPrettier(options) {
     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}).`);
+            reportError(NMR_FMT_BIN, `could not run \`${PRETTIER_PACKAGE}\` (${result.error.message}).`);
             return 1;
         }
         const status = result.status ?? 1;

package/dist/esm/commands/format-targets.js

@@ -1,7 +1,6 @@
-import { spawnSync } from 'node:child_process';
 import { lstatSync } from 'node:fs';
 import path from 'node:path';
-import { hasErrnoCode } from '@williamthorsen/nmr-core';
+import { hasErrnoCode, runGit } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 const IGNORE_FILENAME = '.prettierignore';
 const LIST_FILES_ARGS = ['ls-files', '-z', '--cached', '--others', '--exclude-standard'];
@@ -64,17 +63,6 @@ function classifyListedFile(cwd, file) {
         return { kind: 'failed', error: `could not stat ${file}: ${describeError(error)}` };
     }
 }
-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 !== '');
 }

package/dist/esm/commands/node-pin.js

@@ -1,10 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import { formatGlyphLine } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, isRecord } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { NMR_GLYPHS } from "../glyphs.js";
-import { isObject } from "../helpers/type-guards.js";
 export const NODE_RELEASE_INDEX_URL = 'https://nodejs.org/dist/index.json';
 const TOOL_VERSIONS_FILE = '.tool-versions';
 const SOAK_MS = 2 * 24 * 60 * 60 * 1000;
@@ -77,7 +76,7 @@ export function selectNodeUpgrade(pin, releases, now) {
     let best;
     let bestVersion;
     for (const release of releases) {
-        if (!isObject(release))
+        if (!isRecord(release))
             continue;
         const { date, version } = release;
         if (typeof version !== 'string' || typeof date !== 'string' || !RELEASE_DATE_PATTERN.test(date))
@@ -120,7 +119,7 @@ function findNodePin(content) {
     return { start: match.index + match[0].length - version.length, version };
 }
 function isMissingFileError(error) {
-    return isObject(error) && error['code'] === 'ENOENT';
+    return isRecord(error) && error['code'] === 'ENOENT';
 }
 function parseVersion(version) {
     return version.split('.').map(Number);

package/dist/esm/commands/rewrite-specifiers.js

@@ -89,7 +89,7 @@ function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOp
     const ts = getCompiler();
     const resolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
     if (!resolvedModule) {
-        throw new UserError(`nmr-compile: could not resolve aliased import '${specifier}' from ${sourceContainingFile}. ` +
+        throw new UserError(`could not resolve aliased import '${specifier}' from ${sourceContainingFile}. ` +
             `Verify the tsconfig 'paths' mapping and that the target file exists.`);
     }
     if (!isWithin(sourceRoot, resolvedModule.resolvedFileName)) {
@@ -98,7 +98,7 @@ function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOp
         if (bareResolvedModule) {
             return undefined;
         }
-        throw new UserError(`nmr-compile: aliased import '${specifier}' from ${sourceContainingFile} resolves to ` +
+        throw new UserError(`aliased import '${specifier}' from ${sourceContainingFile} resolves to ` +
             `${resolvedModule.resolvedFileName}, outside the package source root ${sourceRoot}, and does not resolve ` +
             `the way Node will at runtime, which ignores tsconfig 'paths', 'baseUrl', and 'rootDirs'. The ` +
             `emitted specifier would fail at runtime; re-anchor the alias inside the package.`);

package/dist/esm/commands/run-vitest.js

@@ -3,10 +3,10 @@ import { existsSync, readFileSync } 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 { isRecord, reportError } from '@williamthorsen/nmr-core';
 import { findMonorepoRoot as findMonorepoRootOrNothing } from '@williamthorsen/nmr-core/workspace';
+import { NMR_VITEST_BIN } from "../bins.js";
 import { describeSignalExitCode } from "../child-process.js";
-import { isObject } from "../helpers/type-guards.js";
 import { omitOutcomeFile } from "../stated-outcome.js";
 const VITEST_PACKAGE = 'vitest';
 const SUPPORTED_VITEST_RANGE = '>=4.0.0 <6';
@@ -14,7 +14,7 @@ const CONFIG_EXTENSIONS = ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs'];
 export function runNmrVitest(argv, cwd = process.cwd()) {
     const cli = resolveVitestCli(cwd);
     if (!cli.ok) {
-        reportError(`nmr-vitest: ${cli.error}`);
+        reportError(NMR_VITEST_BIN, cli.error);
         return 1;
     }
     const result = spawnSync(process.execPath, [cli.cliPath, ...chooseVitestConfigArgs(argv, cwd)], {
@@ -23,7 +23,7 @@ export function runNmrVitest(argv, cwd = process.cwd()) {
         stdio: 'inherit',
     });
     if (result.error) {
-        reportError(`nmr-vitest: could not run \`${VITEST_PACKAGE}\` (${result.error.message}).`);
+        reportError(NMR_VITEST_BIN, `could not run \`${VITEST_PACKAGE}\` (${result.error.message}).`);
         return 1;
     }
     if (result.signal !== null)
@@ -73,7 +73,7 @@ function resolveVitestCli(cwd) {
         return missingResult;
     }
     const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    const bin = isObject(manifest) && isObject(manifest['bin']) ? manifest['bin'][VITEST_PACKAGE] : undefined;
+    const bin = isRecord(manifest) && isRecord(manifest['bin']) ? manifest['bin'][VITEST_PACKAGE] : undefined;
     if (typeof bin !== 'string') {
         return { ok: false, error: `\`${VITEST_PACKAGE}\` at ${path.dirname(manifestPath)} does not declare a CLI.` };
     }

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

@@ -6,9 +6,9 @@ export interface ShellcheckOutcome {
     status: number | null;
 }
 export interface RunShellcheckOptions {
-    /** Directory under which the pinned tools are cached; defaults to `node_modules/.cache/nmr-tools` at the root. */
-    cacheRoot?: string;
-    ensure?: (tool: WorkflowTool, cacheRoot: string) => Promise<string>;
+    /** Directories under which the pinned tools are cached, in lookup order; defaults to `resolveToolCacheRoots`. */
+    cacheRoots?: readonly [string, ...string[]];
+    ensure?: (tool: WorkflowTool, cacheRoots: readonly [string, ...string[]]) => Promise<string>;
     /** Lists the tracked `*.sh` files under the root, relative to it. */
     listFiles?: (monorepoRoot: string) => string[];
     spawn?: (file: string, args: string[], cwd: string) => ShellcheckOutcome;