@williamthorsen/nmr 0.30.0 → 0.32.0

package/dist/esm/check-cache.d.ts

@@ -1,4 +1,5 @@
 import type { Writable } from 'node:stream';
+import type { OutputChannels } from './runner.js';
 import type { CheckCacheConfig, NmrConfig } from './types.js';
 export interface CheckCacheEntry {
     key: string;
@@ -10,6 +11,22 @@ export interface CheckCacheEntry {
     durationMs: number;
     recordedAt: string;
     buildDigests: Record<string, string>;
+    retention?: Retention;
+}
+export interface EntryRef {
+    anchorDir: string;
+    command: string;
+    monorepoRoot: string;
+}
+export interface ReplayLine {
+    command: string;
+    excerpt: string;
+    scope: string;
+}
+export interface Retention {
+    key: string;
+    replay: ReplayLine[];
+    runId: string;
 }
 export interface BuildOutputState {
     missing: string[];
@@ -28,7 +45,17 @@ export declare const CURRENT_RUNTIME: RuntimeIdentity;
 export declare const DEBUG_ENV_VAR = "NMR_DEBUG";
 export declare const DEFAULT_CACHEABLE_COMMANDS: string[];
 export declare const NO_CACHE_ENV_VAR = "NMR_NO_CACHE";
+export declare const RUN_ID_ENV_VAR = "NMR_RUN_ID";
 export declare const TREE_SNAPSHOT_ENV_VAR = "NMR_TREE_SNAPSHOT";
+export declare function certifyRetention(options: {
+    anchorDir: string;
+    command: string;
+    entry: CheckCacheEntry;
+    env: NodeJS.ProcessEnv;
+    monorepoRoot: string;
+    runId: string;
+    stderr: Writable;
+}): Promise<void>;
 export declare function computeCacheKey(options: {
     anchorDir: string;
     command: string;
@@ -45,18 +72,26 @@ export declare function computeCacheKey(options: {
     ok: false;
     reason: string;
 };
+export declare function computeRetentionKey(options: {
+    channels: OutputChannels;
+    env: NodeJS.ProcessEnv;
+    passKey: string;
+}): string;
 export declare function encodeTreeSnapshot(snapshot: TreeSnapshot): string;
 export declare function findStaleBuildOutput(earlier: Record<string, string>, later: Record<string, string>): string | undefined;
 export declare function formatMisplacedNoCacheWarning(command: string): string;
-export declare function formatSkipLine(command: string, entry: CheckCacheEntry, now: number): string;
+export declare function isCacheableCommand(checkCache: CheckCacheConfig | undefined, command: string): boolean;
 export declare function readBuildOutputState(monorepoRoot: string, config: NmrConfig): Promise<BuildOutputState>;
 export declare function readCheckCacheEntry(options: {
     anchorDir: string;
     command: string;
     monorepoRoot: string;
 }): Promise<CheckCacheEntry | undefined>;
+export declare function readTranscript(ref: EntryRef): Promise<string | undefined>;
+export declare function recordTranscript(ref: EntryRef, transcript: string | undefined): Promise<void>;
 export declare function removeCheckCache(scopeDir: string): Promise<void>;
 export declare function resolveCacheableCommands(checkCache: CheckCacheConfig | undefined): Set<string>;
+export declare function resolveRunId(env: NodeJS.ProcessEnv): string;
 export declare function resolveTreeSnapshot(options: {
     monorepoRoot: string;
     env: NodeJS.ProcessEnv;

package/dist/esm/check-cache.js

@@ -1,11 +1,12 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { readFileSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import { hashWorkingTree, readHeadSha, readJsonCacheEntry, removeCacheDir, resolveCacheEntryPath, writeCacheEntry, } from '@williamthorsen/nmr-core';
+import { hashWorkingTree, readCacheEntry, readHeadSha, readJsonCacheEntry, removeCacheDir, removeCacheEntry, resolveCacheEntryPath, writeCacheEntry, } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { hasBuildOutput, readBuildDigest } from "./commands/build-output.js";
 import { loadWorkspaceConfig } from "./config.js";
-import { formatDuration, formatSaving } from "./helpers/duration.js";
+import { isHookName } from "./helpers/hook-name.js";
 import { isObject, isStringRecord } from "./helpers/type-guards.js";
 import { getDefaultWorkspaceScripts } from "./resolve-scripts.js";
 import { buildWorkspaceRegistry, resolveScript } from "./resolver.js";
@@ -39,6 +40,7 @@ export const DEFAULT_CACHEABLE_COMMANDS = [
     'typecheck',
 ];
 export const NO_CACHE_ENV_VAR = 'NMR_NO_CACHE';
+export const RUN_ID_ENV_VAR = 'NMR_RUN_ID';
 export const TREE_SNAPSHOT_ENV_VAR = 'NMR_TREE_SNAPSHOT';
 const BUILT_IN_COMPILE = 'nmr-compile';
 const CACHE_TOOL = 'nmr-check';
@@ -48,7 +50,26 @@ const INSTALL_FINGERPRINT_FILES = [
 ];
 const KEY_FORMAT = 'nmr-check-cache-v1';
 const KEYED_ENV_VARS = ['LANG', 'LC_ALL', 'NODE_OPTIONS', 'TZ'];
+const RETENTION_KEY_FORMAT = 'nmr-retention-v1';
+const RETENTION_KEYED_ENV_VARS = ['CI', 'COLUMNS', 'FORCE_COLOR', 'NO_COLOR', 'TERM'];
 const UNSAFE_SLUG_CHARACTERS = /[^\w.-]+/g;
+export async function certifyRetention(options) {
+    const { entry, runId } = options;
+    if (entry.retention === undefined || entry.retention.runId === runId) {
+        return;
+    }
+    try {
+        await writeCheckCacheEntry({
+            anchorDir: options.anchorDir,
+            command: options.command,
+            monorepoRoot: options.monorepoRoot,
+            entry: { ...entry, retention: { ...entry.retention, runId } },
+        });
+    }
+    catch (error) {
+        writeDebugNote(`could not certify ${options.command}: ${describeError(error)}`, options.env, options.stderr);
+    }
+}
 export function computeCacheKey(options) {
     const fingerprint = resolveInstallFingerprint(options.monorepoRoot);
     if (!fingerprint.ok) {
@@ -68,16 +89,16 @@ export function computeCacheKey(options) {
         runtime.arch,
         fingerprint.fingerprint,
     ];
-    for (const name of KEYED_ENV_VARS) {
-        const value = options.env[name];
-        parts.push(name, value === undefined ? 'unset' : 'set', value ?? '');
-    }
-    const hash = createHash('sha256');
-    for (const part of parts) {
-        hash.update(part);
-        hash.update('\0');
-    }
-    return { ok: true, key: hash.digest('hex') };
+    return { ok: true, key: digestParts([...parts, ...composeEnvParts(KEYED_ENV_VARS, options.env)]) };
+}
+export function computeRetentionKey(options) {
+    const parts = [
+        RETENTION_KEY_FORMAT,
+        options.passKey,
+        describeChannel(options.channels.stdout),
+        describeChannel(options.channels.stderr),
+    ];
+    return digestParts([...parts, ...composeEnvParts(RETENTION_KEYED_ENV_VARS, options.env)]);
 }
 export function encodeTreeSnapshot(snapshot) {
     return `${snapshot.hash} ${snapshot.headSha}`;
@@ -90,11 +111,8 @@ export function formatMisplacedNoCacheWarning(command) {
     return (`⚠️ --no-cache after the command name is passed to \`${command}\`, not read by nmr. ` +
         `Did you mean \`nmr --no-cache ${command}\`?`);
 }
-export function formatSkipLine(command, entry, now) {
-    const age = formatDuration(Math.max(0, now - Date.parse(entry.recordedAt)));
-    const saving = formatSaving(entry.durationMs);
-    const savingClause = saving === undefined ? '' : ` (${saving})`;
-    return `⏭️ ${command}: passed ${age} ago on this tree${savingClause}.`;
+export function isCacheableCommand(checkCache, command) {
+    return !isHookName(command) && checkCache?.enabled !== false && resolveCacheableCommands(checkCache).has(command);
 }
 export async function readBuildOutputState(monorepoRoot, config) {
     const state = { missing: [], digests: {} };
@@ -126,7 +144,23 @@ export async function readBuildOutputState(monorepoRoot, config) {
     return state;
 }
 export async function readCheckCacheEntry(options) {
-    return readJsonCacheEntry(resolveEntryPath(options), isCheckCacheEntry);
+    const parsed = await readJsonCacheEntry(resolveEntryPath(options), isParsedCheckCacheEntry);
+    if (parsed === undefined) {
+        return undefined;
+    }
+    const { retention, ...pass } = parsed;
+    return isRetention(retention) ? { ...pass, retention } : pass;
+}
+export async function readTranscript(ref) {
+    return readCacheEntry(resolveEntryPath(ref, '.log'));
+}
+export async function recordTranscript(ref, transcript) {
+    const entryPath = resolveEntryPath(ref, '.log');
+    if (transcript === undefined) {
+        await removeCacheEntry(entryPath);
+        return;
+    }
+    await writeCacheEntry(entryPath, transcript);
 }
 export async function removeCheckCache(scopeDir) {
     await removeCacheDir({ tool: CACHE_TOOL, scopeDir });
@@ -139,6 +173,10 @@ export function resolveCacheableCommands(checkCache) {
     }
     return commands;
 }
+export function resolveRunId(env) {
+    const inherited = env[RUN_ID_ENV_VAR];
+    return inherited === undefined || inherited === '' ? randomUUID() : inherited;
+}
 export function resolveTreeSnapshot(options) {
     const inherited = decodeTreeSnapshot(options.env[TREE_SNAPSHOT_ENV_VAR]);
     if (inherited !== undefined && readHeadSha(options.monorepoRoot) === inherited.headSha) {
@@ -168,6 +206,12 @@ export function writeDebugNote(message, env, stderr) {
         stderr.write(`nmr check-cache: ${message}\n`);
     }
 }
+function composeEnvParts(names, env) {
+    return names.flatMap((name) => {
+        const value = env[name];
+        return [name, value === undefined ? 'unset' : 'set', value ?? ''];
+    });
+}
 function decodeTreeSnapshot(encoded) {
     if (encoded === undefined) {
         return undefined;
@@ -178,7 +222,18 @@ function decodeTreeSnapshot(encoded) {
     }
     return { hash, headSha };
 }
-function isCheckCacheEntry(value) {
+function describeChannel(channel) {
+    return channel === 'pipe' ? 'pipe' : 'descriptor';
+}
+function digestParts(parts) {
+    const hash = createHash('sha256');
+    for (const part of parts) {
+        hash.update(part);
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function isParsedCheckCacheEntry(value) {
     if (!isObject(value)) {
         return false;
     }
@@ -193,19 +248,32 @@ function isCheckCacheEntry(value) {
 }
 function isProbeSubject(packageDir, registry) {
     const build = resolveScript('build', registry, packageDir, false);
-    if (build === undefined || build.source === 'package') {
+    if (build === undefined || build.origin.tier === 'package') {
         return false;
     }
     const compile = resolveScript('compile', registry, packageDir, false);
     return compile !== undefined && renderChain(compile.steps) === BUILT_IN_COMPILE;
 }
-function resolveEntryPath(options) {
+function isReplayLine(value) {
+    return (isObject(value) &&
+        typeof value['command'] === 'string' &&
+        typeof value['excerpt'] === 'string' &&
+        typeof value['scope'] === 'string');
+}
+function isRetention(value) {
+    return (isObject(value) &&
+        typeof value['key'] === 'string' &&
+        typeof value['runId'] === 'string' &&
+        Array.isArray(value['replay']) &&
+        value['replay'].every((line) => isReplayLine(line)));
+}
+function resolveEntryPath(options, extension = '.json') {
     const anchorDir = path.resolve(options.anchorDir);
     const ref = {
         tool: CACHE_TOOL,
         scopeDir: options.monorepoRoot,
         slug: `${path.basename(anchorDir)}-${options.command.replaceAll(UNSAFE_SLUG_CHARACTERS, '-')}`,
-        extension: '.json',
+        extension,
         discriminators: [anchorDir, options.command],
     };
     return resolveCacheEntryPath(ref);

package/dist/esm/cli-build.js

@@ -1,4 +1,5 @@
 import { reportError } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { buildPackage } from "./commands/build.js";
 import { loadWorkspaceConfig } from "./config.js";
 try {
@@ -9,6 +10,6 @@ try {
     });
 }
 catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
+    reportError(describeError(error));
     process.exitCode = 1;
 }

package/dist/esm/cli-clean.js

@@ -1,9 +1,10 @@
 import { reportError } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { runClean } from "./commands/clean.js";
 try {
     await runClean(process.cwd());
 }
 catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
+    reportError(describeError(error));
     process.exitCode = 1;
 }

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

@@ -1,5 +1,6 @@
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { DEFAULT_HOOK, ensurePrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
+import { describeError } from '@williamthorsen/toolbelt.errors';
+import { DEFAULT_HOOK, ensurePrepublishHooks, reportPrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
 import { findMonorepoRoot } from "./workspace.js";
 const flagSchema = {
     fix: { long: '--fix', type: 'boolean' },
@@ -9,35 +10,14 @@ const flagSchema = {
 const { fix, dryRun, command } = parseArgsOrExit(process.argv.slice(2), flagSchema).flags;
 try {
     const monorepoRoot = findMonorepoRoot();
-    const hookCommand = command ?? DEFAULT_HOOK;
     const options = command ? { fix, dryRun, command } : { fix, dryRun };
     const result = ensurePrepublishHooks(monorepoRoot, options);
-    for (const pkg of result.packages) {
-        if (pkg.isPrivate) {
-            continue;
-        }
-        switch (pkg.action) {
-            case 'ok':
-                console.info(`✓ ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`);
-                break;
-            case 'missing':
-                console.warn(`✗ ${pkg.packageName}: missing prepublishOnly`);
-                break;
-            case 'fixed':
-                console.info(`✓ ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`);
-                break;
-            case 'would-fix':
-                console.info(`~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`);
-                break;
-        }
-    }
+    reportPrepublishHooks(result, command ?? DEFAULT_HOOK);
     if (result.hasFailures) {
-        const missing = result.packages.filter((p) => p.action === 'missing').length;
-        process.stderr.write(`\n${missing} package(s) missing prepublishOnly. Use --fix to add it.\n`);
         process.exitCode = 1;
     }
 }
 catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
+    reportError(describeError(error));
     process.exitCode = 1;
 }

package/dist/esm/cli-report-catalog.d.ts

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

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

@@ -0,0 +1,11 @@
+import process from 'node:process';
+import { reportError } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
+import { reportCatalog } from "./commands/report-catalog.js";
+try {
+    reportCatalog(process.cwd());
+}
+catch (error) {
+    reportError(describeError(error));
+    process.exitCode = 1;
+}

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

@@ -1,4 +1,5 @@
 import { reportError } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { reportOverrides } from "./commands/report-overrides.js";
 import { findMonorepoRoot } from "./workspace.js";
 try {
@@ -6,6 +7,6 @@ try {
     reportOverrides(monorepoRoot);
 }
 catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
+    reportError(describeError(error));
     process.exitCode = 1;
 }

package/dist/esm/cli-taze.js

@@ -1,10 +1,11 @@
 import process from 'node:process';
 import { reportError } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { runTaze } from "./commands/taze.js";
 try {
     process.exitCode = runTaze(process.argv.slice(2));
 }
 catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
+    reportError(describeError(error));
     process.exitCode = 1;
 }

package/dist/esm/cli.js

@@ -1,4 +1,5 @@
 import process from 'node:process';
+import { reportCliFailure } from "./reportCliFailure.js";
 import { runCli } from "./runCli.js";
 try {
     const { exitCode } = await runCli({
@@ -11,6 +12,6 @@ try {
     process.exitCode = exitCode;
 }
 catch (error) {
-    process.stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+    reportCliFailure(error, process.stderr);
     process.exitCode = 1;
 }

package/dist/esm/commands/build-output.d.ts

@@ -16,3 +16,4 @@ export declare function hasExpectedBuildOutput(packageDir: string, outdir: strin
 export declare function readBuildDigest(packageDir: string): Promise<string | undefined>;
 export declare function resolveBuildCachePath(packageDir: string): string;
 export declare function resolveScratchDirs(emitDir: string): ScratchDirs;
+export declare function resolveToolchainFingerprint(packageDir: string, selfDir?: string): Promise<string>;

package/dist/esm/commands/build-output.js

@@ -1,11 +1,13 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import path from 'node:path';
-import { readCacheEntry, resolveCacheEntryPath } from '@williamthorsen/nmr-core';
+import { findPackageRoot, readCacheEntry, resolveCacheEntryPath } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
+import { readPackageJson } from "../helpers/package-json.js";
 export const DEFAULT_ENTRY_GLOBS = ['src/**/*.ts'];
 export const DEFAULT_IGNORE_PATTERNS = ['**/__fixtures__/**', '**/__mocks__/**', '**/__tests__/**', '**/test-utils/**'];
 export const DEFAULT_OUTDIR = 'dist/esm/';
 const BUILD_CACHE_TOOL = 'nmr-compile';
+const SELF_DIR = findPackageRoot(import.meta.url);
 export async function hasBuildOutput(packageDir, options = {}) {
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
     const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
@@ -42,3 +44,24 @@ export function resolveScratchDirs(emitDir) {
         staging: path.join(parent, `.${name}.staging`),
     };
 }
+export async function resolveToolchainFingerprint(packageDir, selfDir = SELF_DIR) {
+    if (!isSameDir(packageDir, selfDir)) {
+        const digest = await readBuildDigest(selfDir);
+        if (digest !== undefined) {
+            return digest;
+        }
+    }
+    return readPackageJson(selfDir).version ?? '';
+}
+function isSameDir(left, right) {
+    return toRealPath(left) === toRealPath(right);
+}
+function toRealPath(dir) {
+    const absolute = path.resolve(dir);
+    try {
+        return realpathSync(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}

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

@@ -1,4 +1,8 @@
 import type { BuildOptions } from './build-output.js';
+export interface BuildToolchain {
+    compilerVersion: string;
+    fingerprint: string;
+}
 export declare function buildPackage(packageDir: string, options?: BuildOptions): Promise<void>;
-export declare function computeBuildHash(packageDir: string, files: string[], emitConfig: object, compilerVersion: string): Promise<string>;
+export declare function computeBuildHash(packageDir: string, files: string[], emitConfig: object, toolchain: BuildToolchain): Promise<string>;
 export declare function resolveTsconfigChain(packageDir: string, configFileName?: string): string[];

package/dist/esm/commands/build.js

@@ -6,7 +6,7 @@ import { readCacheEntry, writeCacheEntry } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
 import * as ts from 'typescript';
 import { resolveConfigPath } from "../config.js";
-import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, resolveScratchDirs, } from "./build-output.js";
+import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, resolveScratchDirs, resolveToolchainFingerprint, } from "./build-output.js";
 const PACKAGE_ICON = '📦';
 const SKIPPED_ICON = '⏭️';
 const SOURCE_ROOT = 'src';
@@ -30,15 +30,20 @@ export async function buildPackage(packageDir, options = {}) {
         ...(existsSync(configPath) ? [path.relative(packageDir, configPath)] : []),
         ...resolveTsconfigChain(packageDir),
     ];
-    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, ts.version, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
+    const toolchain = {
+        compilerVersion: ts.version,
+        fingerprint: await resolveToolchainFingerprint(packageDir),
+    };
+    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
     if (!changed) {
         await discardScratchDirs(resolveScratchDirs(emitDir));
         return;
     }
-    await emitPackage(packageDir, entryPoints, outdir);
+    const emittedFileCount = await emitPackage(packageDir, entryPoints, outdir);
     await writeCacheEntry(cachePath, currentHash);
+    console.info(`${PACKAGE_ICON} ${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`);
 }
-export async function computeBuildHash(packageDir, files, emitConfig, compilerVersion) {
+export async function computeBuildHash(packageDir, files, emitConfig, toolchain) {
     const hash = createHash('sha256');
     for (const file of files.toSorted()) {
         hash.update(file);
@@ -47,7 +52,9 @@ export async function computeBuildHash(packageDir, files, emitConfig, compilerVe
     }
     hash.update(JSON.stringify(emitConfig));
     hash.update('\0');
-    hash.update(compilerVersion);
+    hash.update(toolchain.compilerVersion);
+    hash.update('\0');
+    hash.update(toolchain.fingerprint);
     return hash.digest('hex');
 }
 export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json') {
@@ -92,10 +99,11 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     }
     if (staged.size === 0) {
         await rm(emitDir, { force: true, recursive: true });
-        return;
+        return 0;
     }
     writeStagedOutput(staged, emitDir, scratchDirs.staging);
     await swapIntoPlace(emitDir, scratchDirs);
+    return staged.size;
 }
 async function discardScratchDirs(scratchDirs) {
     try {
@@ -247,10 +255,10 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-async function detectBuildChanges(packageDir, files, emitConfig, compilerVersion, cachePath, outputPresent) {
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent) {
     const packageName = path.basename(packageDir);
     const previousHash = await readCacheEntry(cachePath);
-    const currentHash = await computeBuildHash(packageDir, files, emitConfig, compilerVersion);
+    const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
     if (previousHash === currentHash) {
         if (outputPresent) {
             console.info(`${SKIPPED_ICON} ${packageName}: No changes detected. Skipping build.`);
@@ -278,6 +286,12 @@ function collectAliasPrefixes(compilerOptions) {
     }
     return Object.keys(compilerOptions.paths).map((pattern) => pattern.replace(/\*$/, ''));
 }
+function describeEmit(fileCount, outdir) {
+    if (fileCount === 0) {
+        return 'Emitted no output.';
+    }
+    return `Compiled ${fileCount} files to ${outdir.replace(/\/+$/u, '')}.`;
+}
 function formatDiagnostics(diagnostics) {
     return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
         getCurrentDirectory: () => process.cwd(),

package/dist/esm/commands/clean.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { removeCheckCache } from "../check-cache.js";
 import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
+import { reportClosing } from "../helpers/reportClosing.js";
 import { applyDevBin, buildWorkspaceRegistry, resolveScript } from "../resolver.js";
 import { resolveChannel, runCommand } from "../runner.js";
 import { renderChain } from "../steps.js";
@@ -40,17 +41,26 @@ async function clearCheckCache(scopeDir) {
     await removeCheckCache(scopeDir);
     console.info(`${CLEAN_ICON} Removed all recorded check results.`);
 }
+function describeSweep(cleaned, skipped) {
+    const packages = cleaned === 1 ? '1 package' : `${cleaned} packages`;
+    const skipClause = skipped === 0 ? '' : `, skipping ${skipped} with an empty clean override`;
+    return `Cleaned ${packages}${skipClause}.`;
+}
 async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
+    let cleaned = 0;
+    let skipped = 0;
     for (const packageDir of workspacePackageDirs) {
         const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
         const resolvedCommand = resolved === undefined ? undefined : renderChain(resolved.steps);
         if (resolvedCommand === undefined || resolvedCommand === '') {
+            skipped++;
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
             await cleanPackage(packageDir);
+            cleaned++;
             continue;
         }
         const command = applyDevBin(resolvedCommand, config.devBin, monorepoRoot);
@@ -60,5 +70,7 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
         if (exitCode !== 0) {
             throw new Error(`nmr-clean: \`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }
+        cleaned++;
     }
+    reportClosing(`${CLEAN_ICON} ${describeSweep(cleaned, skipped)}`);
 }

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

@@ -15,3 +15,4 @@ export declare function ensurePrepublishHooks(monorepoRoot: string, options: {
     dryRun: boolean;
     command?: string;
 }): EnsurePrepublishHooksResult;
+export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string): void;

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

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 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';
@@ -59,6 +60,17 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     const hasFailures = packages.some((p) => p.action === 'missing');
     return { packages, hasFailures };
 }
+export function reportPrepublishHooks(result, hookCommand) {
+    const publishable = result.packages.filter((pkg) => !pkg.isPrivate);
+    if (publishable.length === 0) {
+        console.info('No publishable packages found.');
+        return;
+    }
+    for (const pkg of publishable) {
+        console.info(renderHookStatus(pkg, hookCommand));
+    }
+    reportClosing(describeHookRun(publishable));
+}
 function addPrepublishOnly(packageDir, command) {
     const filePath = path.join(packageDir, 'package.json');
     const raw = readFileSync(filePath, 'utf8');
@@ -71,3 +83,34 @@ function addPrepublishOnly(packageDir, command) {
     parsed['scripts'] = scripts;
     writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
 }
+function countAction(publishable, action) {
+    return publishable.filter((pkg) => pkg.action === action).length;
+}
+function describeHookRun(publishable) {
+    const packages = publishable.length === 1 ? '1 publishable package' : `${publishable.length} publishable packages`;
+    const missing = countAction(publishable, 'missing');
+    if (missing > 0) {
+        return `${missing} of ${packages} ${missing === 1 ? 'is' : 'are'} missing prepublishOnly. Run with --fix to add it.`;
+    }
+    const fixed = countAction(publishable, 'fixed');
+    if (fixed > 0) {
+        return `Added prepublishOnly to ${fixed} of ${packages}.`;
+    }
+    const wouldFix = countAction(publishable, 'would-fix');
+    if (wouldFix > 0) {
+        return `Would add prepublishOnly to ${wouldFix} of ${packages}.`;
+    }
+    return `${packages} ${publishable.length === 1 ? 'has' : 'have'} prepublishOnly.`;
+}
+function renderHookStatus(pkg, hookCommand) {
+    switch (pkg.action) {
+        case 'ok':
+            return `✓ ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
+        case 'missing':
+            return `✗ ${pkg.packageName}: missing prepublishOnly`;
+        case 'fixed':
+            return `✓ ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
+        case 'would-fix':
+            return `~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`;
+    }
+}

package/dist/esm/commands/report-catalog.d.ts

@@ -0,0 +1 @@
+export declare function reportCatalog(cwd: string): void;