@williamthorsen/nmr 0.48.0 → 0.50.0

package/dist/esm/replay-assembly.d.ts

@@ -1,4 +1,4 @@
-import { type ReplayLine } from './check-cache.js';
+import { type ReplayLine } from './check-cache-entries.js';
 import { type Step } from './steps.js';
 /**
  * Assembles what a composite's skip replays: the excerpts recorded by its constituents, in the order in which
@@ -14,7 +14,7 @@ import { type Step } from './steps.js';
  *
  * An entry is admissible when the run that certified it is this one and the tree that it describes is this one.
  * The witness is what a run stamps on an excerpt that it records and on one that it recalls and replays; the
- * tree hash bounds an identity carried by a process out of the run that issued it.
+ * tree id bounds an identity carried by a process out of the run that issued it.
  */
 export declare function assembleReplay(options: {
     anchorDir: string;

package/dist/esm/replay-assembly.js

@@ -1,4 +1,4 @@
-import { readCheckCacheEntry } from "./check-cache.js";
+import { readCheckCacheEntry } from "./check-cache-entries.js";
 import { readNmrStep } from "./steps.js";
 import { getWorkspacePackageDirs } from "./workspace.js";
 export async function assembleReplay(options) {

package/dist/esm/run-chain.d.ts

@@ -0,0 +1,21 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
+import type { TreeSnapshot } from './check-cache.js';
+import type { Invocation, PhaseResult, RunPlan } from './invocation.js';
+import type { ScriptRegistry } from './resolve-scripts.js';
+import { type ResolvedScript } from './resolver.js';
+/**
+ * Assembles the chain that a resolved script runs at this scope, the hooks wrapped around it included, and the key
+ * under which a pass by that chain is recorded. Settles a no-op override and an argument that no step can take.
+ */
+export declare function assembleChain(options: {
+    invocation: Invocation;
+    registry: ScriptRegistry;
+    resolvedScript: ResolvedScript;
+    snapshot: TreeSnapshot | undefined;
+}): PhaseResult<Pick<RunPlan, 'commandString' | 'key' | 'ownSteps' | 'steps'>>;
+/**
+ * Returns the line announcing that a `package.json` script is standing in for a built-in, or `undefined` under
+ * `quiet` or when none is due. Only a script replacing a name that the registry already defines is worth
+ * announcing; an ordinary tier-3 entry that happens to resolve is not standing in for anything.
+ */
+export declare function formatOverrideNotice(resolvedScript: ResolvedScript, registry: ScriptRegistry, command: string, anchorDir: string, quiet: boolean, style: OutputStyle): string | undefined;

package/dist/esm/run-chain.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import { formatGlyphLine, reportError } from '@williamthorsen/nmr-core';
+import { resolveCacheKey } from "./check-cache-gate.js";
+import { reportNmrCrossing } from "./crossing-diagnostics.js";
+import { NMR_GLYPHS } from "./glyphs.js";
+import { isHookName } from "./helpers/hook-name.js";
+import { quoteForShell } from "./helpers/quoteForShell.js";
+import { wrapWithHooks } from "./hooks.js";
+import { reportVerdict } from "./presentation.js";
+import { applyDevBinToSteps } from "./resolver.js";
+import { dropRecursiveSteps, renderChain } from "./steps.js";
+export function assembleChain(options) {
+    const { invocation, registry, resolvedScript, snapshot } = options;
+    const { anchorDir, command, context, env, parsedArgs, stderr, stdout, styles } = invocation;
+    const { isEmptiedByWorkspace, steps: runnableSteps } = readRunnableSteps(resolvedScript, context.workspacePackageDirs);
+    const resolvedCommand = renderChain(runnableSteps);
+    const noOpReason = findNoOpReason(resolvedCommand, isEmptiedByWorkspace);
+    if (noOpReason !== undefined && !parsedArgs.shouldPrintLog) {
+        reportVerdict({ command, scope: invocation.scope, outcome: 'no-op', reason: noOpReason }, stdout, invocation.format, styles.stdout);
+        return { settled: true, result: { exitCode: 0 } };
+    }
+    const substitutedSteps = applyDevBinToSteps(runnableSteps, context.config.devBin, context.monorepoRoot);
+    const substitutedCommand = renderChain(substitutedSteps);
+    const bindResult = bindPassthrough(substitutedSteps, parsedArgs.passthrough, command);
+    if (!bindResult.ok) {
+        reportError(bindResult.error, stderr);
+        return { settled: true, result: { exitCode: 1 } };
+    }
+    const mainSteps = bindResult.steps;
+    const isHookInvocation = isHookName(command);
+    const fullSteps = isHookInvocation
+        ? mainSteps
+        : wrapWithHooks(command, mainSteps, registry, anchorDir, parsedArgs.isWorkspaceRoot);
+    const fullCommand = renderChain(fullSteps);
+    reportNmrCrossing({
+        config: context.config,
+        isReading: parsedArgs.shouldPrintLog,
+        isWorkspaceRoot: parsedArgs.isWorkspaceRoot,
+        monorepoRoot: context.monorepoRoot,
+        registry,
+        resolvedScript,
+        shouldUseRoot: invocation.shouldUseRoot,
+        stderr,
+        style: styles.stderr,
+    });
+    const key = resolveCacheKey({
+        anchorDir,
+        command,
+        commandString: fullCommand,
+        env,
+        monorepoRoot: context.monorepoRoot,
+        snapshot,
+        stderr,
+        substitution: substitutedCommand === resolvedCommand ? undefined : substitutedCommand,
+    });
+    return { settled: false, value: { commandString: fullCommand, key, ownSteps: mainSteps, steps: fullSteps } };
+}
+export function formatOverrideNotice(resolvedScript, registry, command, anchorDir, quiet, style) {
+    const registryEntry = Object.hasOwn(registry, command) ? registry[command] : undefined;
+    if (quiet || resolvedScript.origin.tier !== 'package' || registryEntry === undefined) {
+        return undefined;
+    }
+    const notice = `${path.basename(anchorDir)}: Using override script: ${renderChain(resolvedScript.steps)}`;
+    return `${formatGlyphLine(NMR_GLYPHS, style, 'package', notice)}\n`;
+}
+function acceptsArguments(step) {
+    return step.kind === 'opaque' || step.shouldDeclineArguments !== true;
+}
+function bindPassthrough(steps, passthrough, command) {
+    if (passthrough.length === 0) {
+        return { ok: true, steps };
+    }
+    if (!steps.some(acceptsArguments)) {
+        return { ok: false, error: formatUnroutableArgumentsError(command) };
+    }
+    const boundSteps = steps.map((step) => {
+        if (!acceptsArguments(step)) {
+            return step;
+        }
+        return step.kind === 'structural'
+            ? { ...step, argv: [...step.argv, ...passthrough] }
+            : { kind: 'opaque', command: `${step.command} ${passthrough.map(quoteForShell).join(' ')}` };
+    });
+    return { ok: true, steps: boundSteps };
+}
+function findNoOpReason(resolvedCommand, isEmptiedByWorkspace) {
+    if (isEmptiedByWorkspace) {
+        return 'empty-workspace';
+    }
+    if (resolvedCommand === '') {
+        return 'empty-override';
+    }
+    if (resolvedCommand === ':') {
+        return 'noop-override';
+    }
+    return undefined;
+}
+function formatUnroutableArgumentsError(command) {
+    return (`\`${command}\` does not take trailing arguments: every step of its chain declines them. ` +
+        'Running it unnarrowed is not what the arguments asked for, so nothing ran.');
+}
+function readRunnableSteps(resolvedScript, workspacePackageDirs) {
+    if (workspacePackageDirs.length > 0) {
+        return { isEmptiedByWorkspace: false, steps: resolvedScript.steps };
+    }
+    const steps = dropRecursiveSteps(resolvedScript.steps);
+    return { isEmptiedByWorkspace: steps.length === 0 && resolvedScript.steps.length > 0, steps };
+}

package/dist/esm/runCli.d.ts

@@ -1,9 +1,5 @@
 import type { Writable } from 'node:stream';
-/**
- * Marks a run made on a delegating caller's behalf, in which a command that the registry does not define, and a
- * `--log` with nothing to show, exit 0 rather than failing.
- */
-export declare const RUN_IF_PRESENT_ENV_VAR = "NMR_RUN_IF_PRESENT";
+import { type RunCliResult } from './invocation.js';
 /** @internal */
 export interface RunCliOptions {
     /** Post-slice CLI arguments (equivalent to `process.argv.slice(2)`). */
@@ -17,10 +13,6 @@ export interface RunCliOptions {
     /** Stream for errors, warnings, and debug notes. */
     stderr: Writable;
 }
-/** @internal */
-export interface RunCliResult {
-    exitCode: number;
-}
 /**
  * Executes the nmr CLI flow in-process and returns the resulting exit code.
  * Does not hold global state, does not read `process.*` globals, and never calls `process.exit`.