@williamthorsen/nmr 0.14.0 → 0.14.2

package/README.md

@@ -45,7 +45,7 @@ nmr's key feature is that the same command runs different scripts depending on w
 Use `-w` to escape package context:
 
 ```bash
-# From inside packages/core, run the root check suite
+# From inside packages/nmr-core, run the root check suite
 nmr -w check
 ```
 
@@ -321,7 +321,7 @@ The default root `check:strict` composite includes `check:agent-files`, which ru
 To expose the synced guidance to Claude Code sessions, add this include to the consuming repo's `.agents/PROJECT.md`:
 
 ```markdown
-@.agents/nmr/AGENTS.md
+@nmr/AGENTS.md
 ```
 
 ### `sync-pnpm-version`

package/dist/esm/.cache

@@ -1 +1 @@
-2d3864d638817ab1f6e49b7d20cb118260518782ce8c8c372346c837f72edadc
+762ecbce6ca8e70fc4e9734eb2fab7d61a05d38cda5a77fe8d1ce2c2ad45aa85

package/dist/esm/cli.js

@@ -1,162 +1,16 @@
-import path from "node:path";
 import process from "node:process";
-import { readPackageVersion } 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, resolveScript } from "./resolver.js";
-import { runCommand } from "./runner.js";
-const VERSION = readPackageVersion(import.meta.url);
-function shellQuote(arg) {
-  return "'" + arg.replace(/'/g, String.raw`'\''`) + "'";
-}
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  const result = {
-    quiet: false,
-    recursive: false,
-    workspaceRoot: false,
-    help: false,
-    version: false,
-    intTest: false,
-    passthrough: []
-  };
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (arg === void 0) break;
-    if (arg === "-F" || arg === "--filter") {
-      i++;
-      const filterValue = args[i];
-      if (filterValue === void 0) {
-        console.error("Error: -F/--filter requires a pattern argument");
-        process.exit(1);
-      }
-      result.filter = filterValue;
-      i++;
-      continue;
-    }
-    if (arg === "-R" || arg === "--recursive") {
-      result.recursive = true;
-      i++;
-      continue;
-    }
-    if (arg === "-w" || arg === "--workspace-root") {
-      result.workspaceRoot = true;
-      i++;
-      continue;
-    }
-    if (arg === "-?" || arg === "--help") {
-      result.help = true;
-      i++;
-      continue;
-    }
-    if (arg === "-V" || arg === "--version") {
-      result.version = true;
-      i++;
-      continue;
-    }
-    if (arg === "-q" || arg === "--quiet") {
-      result.quiet = true;
-      i++;
-      continue;
-    }
-    if (arg === "--int-test") {
-      result.intTest = true;
-      i++;
-      continue;
-    }
-    result.command = arg;
-    result.passthrough = args.slice(i + 1);
-    break;
-  }
-  return result;
-}
-async function main() {
-  const parsed = parseArgs(process.argv);
-  if (parsed.version) {
-    console.info(VERSION);
-    process.exit(0);
-  }
-  const context = await resolveContext();
-  const useRoot = parsed.workspaceRoot || context.isRoot;
-  const packageDir = useRoot ? context.monorepoRoot : context.packageDir ?? context.monorepoRoot;
-  if (parsed.help || !parsed.command) {
-    console.info(generateHelp(context.config, packageDir, useRoot));
-    process.exit(0);
-  }
-  const { command } = parsed;
-  const passthrough = parsed.passthrough.length > 0 ? " " + parsed.passthrough.map(shellQuote).join(" ") : "";
-  const runOptions = { quiet: parsed.quiet };
-  if (parsed.filter) {
-    const delegateCmd = `pnpm --filter ${shellQuote(parsed.filter)} exec nmr ${command}${passthrough}`;
-    const code2 = runCommand(delegateCmd, context.monorepoRoot, runOptions);
-    process.exit(code2);
-  }
-  if (parsed.recursive) {
-    process.env.NMR_RUN_IF_PRESENT = "1";
-    const delegateCmd = `pnpm --recursive exec nmr ${command}${passthrough}`;
-    const code2 = runCommand(delegateCmd, context.monorepoRoot, runOptions);
-    process.exit(code2);
-  }
-  const registry = useRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config, parsed.intTest);
-  const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
-  if (!resolved) {
-    if (process.env.NMR_RUN_IF_PRESENT === "1") {
-      process.exit(0);
-    }
-    console.error(`Unknown command: ${command}`);
-    process.exit(1);
-  }
-  const skipExitCode = handleSkipMessage(resolved.command, packageDir, parsed.quiet);
-  if (skipExitCode !== void 0) {
-    process.exit(skipExitCode);
-  }
-  if (resolved.source === "package" && !parsed.quiet && registry[command] !== void 0) {
-    console.info(`\u{1F4E6} ${path.basename(packageDir)}: Using override script: ${resolved.command}`);
-  }
-  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 code = runCommand(fullCommand, void 0, runOptions);
-  process.exit(code);
-}
-function handleSkipMessage(resolvedCommand, packageDir, quiet) {
-  if (resolvedCommand === "") {
-    if (!quiet) {
-      console.info(`\u26D4 ${path.basename(packageDir)}: Override script is defined but empty. Skipping.`);
-    }
-    return 0;
-  }
-  if (resolvedCommand === ":") {
-    if (!quiet) {
-      console.info(`\u26D4 ${path.basename(packageDir)}: Override script is a no-op. Skipping.`);
-    }
-    return 0;
-  }
-  return void 0;
-}
-function wrapWithHooks(command, mainCommand, registry, packageDir, workspaceRoot) {
-  const segments = [];
-  const flag = workspaceRoot ? "-w " : "";
-  if (hasRunnableHook(`${command}:pre`, registry, packageDir, workspaceRoot)) {
-    segments.push(`nmr ${flag}${command}:pre`);
-  }
-  segments.push(mainCommand);
-  if (hasRunnableHook(`${command}:post`, registry, packageDir, workspaceRoot)) {
-    segments.push(`nmr ${flag}${command}:post`);
-  }
-  return segments.join(" && ");
-}
-function hasRunnableHook(hookName, registry, packageDir, workspaceRoot) {
-  const resolved = resolveScript(hookName, registry, packageDir, workspaceRoot);
-  if (!resolved) return false;
-  return resolved.command !== "" && resolved.command !== ":";
-}
+import { runCli } from "./runCli.js";
 try {
-  await main();
+  const { exitCode } = await runCli({
+    args: process.argv.slice(2),
+    cwd: process.cwd(),
+    env: process.env,
+    stdout: process.stdout,
+    stderr: process.stderr
+  });
+  process.exit(exitCode);
 } catch (error) {
-  console.error(error);
+  process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
   process.exit(1);
 }

package/dist/esm/context.d.ts

@@ -1,4 +1,4 @@
-import type { NmrConfig } from './config.js';
+import type { NmrConfig } from './config.ts';
 export interface ResolvedContext {
     monorepoRoot: string;
     isRoot: boolean;

package/dist/esm/context.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
-import yaml from "js-yaml";
+import { parse } from "yaml";
 import { loadConfig } from "./config.js";
 import { isObject } from "./helpers/type-guards.js";
 function findMonorepoRoot(startDir) {
@@ -19,7 +19,7 @@ function findMonorepoRoot(startDir) {
 function getWorkspacePackageDirs(monorepoRoot) {
   const workspaceFile = path.join(monorepoRoot, "pnpm-workspace.yaml");
   const content = readFileSync(workspaceFile, "utf8");
-  const parsed = yaml.load(content);
+  const parsed = parse(content);
   const packages = getPackagesFromParsedYaml(parsed);
   if (!packages) {
     return [];

package/dist/esm/help.d.ts

@@ -1,2 +1,2 @@
-import type { NmrConfig } from './config.js';
+import type { NmrConfig } from './config.ts';
 export declare function generateHelp(config: NmrConfig, packageDir: string | undefined, useRoot: boolean): string;

package/dist/esm/helpers/yaml-utils.js

@@ -1,9 +1,9 @@
 import { readFileSync } from "node:fs";
-import yaml from "js-yaml";
+import { parse } from "yaml";
 function readYamlFile(filepath) {
   try {
     const content = readFileSync(filepath, "utf8");
-    return yaml.load(content);
+    return parse(content);
   } catch (error) {
     throw new Error(`Failed to read YAML file: ${filepath}
 ${error instanceof Error ? error.message : String(error)}`);

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';
+import type { ScriptRegistry } from './default-scripts.ts';
+export type { ScriptRegistry, ScriptValue } from './default-scripts.ts';
 export declare function getDefaultWorkspaceScripts(useIntTests: boolean): ScriptRegistry;
 export declare function getDefaultRootScripts(): ScriptRegistry;

package/dist/esm/resolver.d.ts

@@ -1,5 +1,5 @@
-import type { NmrConfig } from './config.js';
-import type { ScriptRegistry, ScriptValue } from './resolve-scripts.js';
+import type { NmrConfig } from './config.ts';
+import type { ScriptRegistry, ScriptValue } from './resolve-scripts.ts';
 export declare function applyDevBin(command: string, devBin: Record<string, string> | undefined, monorepoRoot: string): string;
 export interface ResolvedScript {
     command: string;

package/dist/esm/runCli.d.ts

@@ -0,0 +1,12 @@
+import type { Writable } from 'node:stream';
+export interface RunCliOptions {
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdout: Writable;
+    stderr: Writable;
+}
+export interface RunCliResult {
+    exitCode: number;
+}
+export declare function runCli(options: RunCliOptions): Promise<RunCliResult>;

package/dist/esm/runCli.js

@@ -0,0 +1,169 @@
+import path from "node:path";
+import { readPackageVersion } 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, resolveScript } from "./resolver.js";
+import { runCommand } from "./runner.js";
+const VERSION = readPackageVersion(import.meta.url);
+async function runCli(options) {
+  const { args, cwd, env, stdout, stderr } = options;
+  const parseResult = parseArgs(args);
+  if (!parseResult.ok) {
+    stderr.write(`${parseResult.error}
+`);
+    return { exitCode: 1 };
+  }
+  const { parsed } = parseResult;
+  if (parsed.version) {
+    stdout.write(`${VERSION}
+`);
+    return { exitCode: 0 };
+  }
+  const context = await resolveContext(cwd);
+  const useRoot = parsed.workspaceRoot || context.isRoot;
+  const packageDir = useRoot ? context.monorepoRoot : context.packageDir ?? context.monorepoRoot;
+  if (parsed.help || !parsed.command) {
+    stdout.write(`${generateHelp(context.config, packageDir, useRoot)}
+`);
+    return { exitCode: 0 };
+  }
+  const { command } = parsed;
+  const passthrough = parsed.passthrough.length > 0 ? " " + parsed.passthrough.map(shellQuote).join(" ") : "";
+  const runOptions = { quiet: parsed.quiet, stdout, stderr, env };
+  if (parsed.filter) {
+    const delegateCmd = `pnpm --filter ${shellQuote(parsed.filter)} exec nmr ${command}${passthrough}`;
+    const exitCode2 = runCommand(delegateCmd, context.monorepoRoot, runOptions);
+    return { exitCode: exitCode2 };
+  }
+  if (parsed.recursive) {
+    const childEnv = { ...env, NMR_RUN_IF_PRESENT: "1" };
+    const delegateCmd = `pnpm --recursive exec nmr ${command}${passthrough}`;
+    const exitCode2 = runCommand(delegateCmd, context.monorepoRoot, { ...runOptions, env: childEnv });
+    return { exitCode: exitCode2 };
+  }
+  const registry = useRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config, parsed.intTest);
+  const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
+  if (!resolved) {
+    if (env.NMR_RUN_IF_PRESENT === "1") {
+      return { exitCode: 0 };
+    }
+    stderr.write(`Unknown command: ${command}
+`);
+    return { exitCode: 1 };
+  }
+  const skipExitCode = handleSkipMessage(resolved.command, packageDir, parsed.quiet, stdout);
+  if (skipExitCode !== void 0) {
+    return { exitCode: skipExitCode };
+  }
+  if (resolved.source === "package" && !parsed.quiet && registry[command] !== void 0) {
+    stdout.write(`\u{1F4E6} ${path.basename(packageDir)}: Using override script: ${resolved.command}
+`);
+  }
+  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);
+  return { exitCode };
+}
+function parseArgs(args) {
+  const parsed = {
+    quiet: false,
+    recursive: false,
+    workspaceRoot: false,
+    help: false,
+    version: false,
+    intTest: false,
+    passthrough: []
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === void 0) break;
+    if (arg === "-F" || arg === "--filter") {
+      i++;
+      const filterValue = args[i];
+      if (filterValue === void 0) {
+        return { ok: false, error: "Error: -F/--filter requires a pattern argument" };
+      }
+      parsed.filter = filterValue;
+      i++;
+      continue;
+    }
+    if (arg === "-R" || arg === "--recursive") {
+      parsed.recursive = true;
+      i++;
+      continue;
+    }
+    if (arg === "-w" || arg === "--workspace-root") {
+      parsed.workspaceRoot = true;
+      i++;
+      continue;
+    }
+    if (arg === "-?" || arg === "--help") {
+      parsed.help = true;
+      i++;
+      continue;
+    }
+    if (arg === "-V" || arg === "--version") {
+      parsed.version = true;
+      i++;
+      continue;
+    }
+    if (arg === "-q" || arg === "--quiet") {
+      parsed.quiet = true;
+      i++;
+      continue;
+    }
+    if (arg === "--int-test") {
+      parsed.intTest = true;
+      i++;
+      continue;
+    }
+    parsed.command = arg;
+    parsed.passthrough = args.slice(i + 1);
+    break;
+  }
+  return { ok: true, parsed };
+}
+function handleSkipMessage(resolvedCommand, packageDir, quiet, stdout) {
+  if (resolvedCommand === "") {
+    if (!quiet) {
+      stdout.write(`\u26D4 ${path.basename(packageDir)}: Override script is defined but empty. Skipping.
+`);
+    }
+    return 0;
+  }
+  if (resolvedCommand === ":") {
+    if (!quiet) {
+      stdout.write(`\u26D4 ${path.basename(packageDir)}: Override script is a no-op. Skipping.
+`);
+    }
+    return 0;
+  }
+  return void 0;
+}
+function wrapWithHooks(command, mainCommand, registry, packageDir, workspaceRoot) {
+  const segments = [];
+  const flag = workspaceRoot ? "-w " : "";
+  if (hasRunnableHook(`${command}:pre`, registry, packageDir, workspaceRoot)) {
+    segments.push(`nmr ${flag}${command}:pre`);
+  }
+  segments.push(mainCommand);
+  if (hasRunnableHook(`${command}:post`, registry, packageDir, workspaceRoot)) {
+    segments.push(`nmr ${flag}${command}:post`);
+  }
+  return segments.join(" && ");
+}
+function hasRunnableHook(hookName, registry, packageDir, workspaceRoot) {
+  const resolved = resolveScript(hookName, registry, packageDir, workspaceRoot);
+  if (!resolved) return false;
+  return resolved.command !== "" && resolved.command !== ":";
+}
+function shellQuote(arg) {
+  return "'" + arg.replace(/'/g, String.raw`'\''`) + "'";
+}
+export {
+  runCli
+};

package/dist/esm/runner.d.ts

@@ -1,4 +1,8 @@
+import type { Writable } from 'node:stream';
 export interface RunCommandOptions {
     quiet?: boolean;
+    stdout?: Writable;
+    stderr?: Writable;
+    env?: NodeJS.ProcessEnv;
 }
 export declare function runCommand(command: string, cwd?: string, options?: RunCommandOptions): number;

package/dist/esm/runner.js

@@ -1,37 +1,39 @@
-import { execSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import process from "node:process";
 function runCommand(command, cwd, options) {
   const quiet = options?.quiet === true;
-  const stdio = quiet ? "pipe" : "inherit";
-  try {
-    execSync(command, { stdio, cwd });
-    return 0;
-  } catch (error) {
-    if (error !== null && typeof error === "object") {
-      if (quiet) {
-        writeErrorOutput(error);
-      }
-      if ("status" in error) {
-        const { status } = error;
-        return typeof status === "number" ? status : 1;
-      }
-    }
+  const stdout = options?.stdout ?? process.stdout;
+  const stderr = options?.stderr ?? process.stderr;
+  const env = options?.env ?? process.env;
+  const stdoutChannel = quiet ? "pipe" : streamFdOrPipe(stdout);
+  const stderrChannel = quiet ? "pipe" : streamFdOrPipe(stderr);
+  const result = spawnSync(command, [], {
+    shell: true,
+    stdio: ["inherit", stdoutChannel, stderrChannel],
+    cwd,
+    env
+  });
+  if (result.error) {
+    stderr.write(`${result.error.message}
+`);
     return 1;
   }
-}
-function writeErrorOutput(error) {
-  if ("stdout" in error) {
-    const { stdout } = error;
-    if (Buffer.isBuffer(stdout) && stdout.length > 0) {
-      process.stderr.write(stdout);
-    }
-  }
-  if ("stderr" in error) {
-    const { stderr } = error;
-    if (Buffer.isBuffer(stderr) && stderr.length > 0) {
-      process.stderr.write(stderr);
+  if (quiet) {
+    if (result.status !== 0) {
+      writeBuffer(result.stdout, stderr);
+      writeBuffer(result.stderr, stderr);
     }
+  } else {
+    if (stdoutChannel === "pipe") writeBuffer(result.stdout, stdout);
+    if (stderrChannel === "pipe") writeBuffer(result.stderr, stderr);
   }
+  return result.status ?? 1;
+}
+function streamFdOrPipe(stream) {
+  return "fd" in stream && typeof stream.fd === "number" ? stream.fd : "pipe";
+}
+function writeBuffer(buffer, dest) {
+  if (buffer.length > 0) dest.write(buffer);
 }
 export {
   runCommand

package/dist/esm/scripts.d.ts

@@ -1,2 +1,2 @@
-export type { ScriptRegistry, ScriptValue } from './default-scripts.js';
-export { getDefaultRootScripts, getDefaultWorkspaceScripts } from './resolve-scripts.js';
+export type { ScriptRegistry, ScriptValue } from './default-scripts.ts';
+export { getDefaultRootScripts, getDefaultWorkspaceScripts } from './resolve-scripts.ts';

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

@@ -1,10 +1,10 @@
 import assert from "node:assert";
 import fs from "node:fs";
-import yaml from "js-yaml";
+import { parse } from "yaml";
 import { getValueAtPathOrThrow } from "./get-value-at-path.js";
 async function getStringFromYamlFile(filePath, keyPath, label) {
   const raw = await fs.promises.readFile(filePath, { encoding: "utf8" });
-  const parsed = yaml.load(raw);
+  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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "private": false,
   "description": "Context-aware script runner for PNPM monorepos",
   "keywords": [
@@ -40,9 +40,9 @@
   ],
   "dependencies": {
     "jiti": "2.7.0",
-    "js-yaml": "4.1.1",
+    "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@williamthorsen/nmr-core": "0.3.1"
+    "@williamthorsen/nmr-core": "0.3.2"
   },
   "publishConfig": {
     "access": "public"