@williamthorsen/nmr 0.37.0 → 0.39.0

package/dist/esm/commands/build.js

@@ -2,19 +2,18 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
-import { readCacheEntry, writeCacheEntry } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, readCacheEntry, STATUS_GLYPHS, writeCacheEntry, } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
 import * as ts from 'typescript';
+import { NMR_GLYPHS } from "../glyphs.js";
 import { resolveConfigPath } from "../helpers/config-path.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';
 const MINIMUM_TYPESCRIPT_MAJOR = 5;
 const MINIMUM_TYPESCRIPT_MINOR = 7;
 const TS_EXTENSION = '.ts';
 const JS_EXTENSION = '.js';
-export async function buildPackage(packageDir, options = {}) {
+export async function buildPackage(packageDir, options) {
     assertSupportedTypeScript();
     const cachePath = resolveBuildCachePath(packageDir);
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
@@ -34,14 +33,14 @@ export async function buildPackage(packageDir, options = {}) {
         compilerVersion: ts.version,
         fingerprint: await resolveToolchainFingerprint(packageDir),
     };
-    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
+    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints), options.style);
     if (!changed) {
         await discardScratchDirs(resolveScratchDirs(emitDir));
         return;
     }
     const emittedFileCount = await emitPackage(packageDir, entryPoints, outdir);
     await writeCacheEntry(cachePath, currentHash);
-    console.info(`${PACKAGE_ICON} ${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`);
+    console.info(formatGlyphLine(NMR_GLYPHS, options.style, 'package', `${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`));
 }
 export async function computeBuildHash(packageDir, files, emitConfig, toolchain) {
     const hash = createHash('sha256');
@@ -61,18 +60,18 @@ export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json
     const resolvedChain = [];
     const seen = new Set();
     function walk(configPath) {
-        const normalized = path.resolve(configPath);
-        if (seen.has(normalized)) {
+        const normalizedPath = path.resolve(configPath);
+        if (seen.has(normalizedPath)) {
             return;
         }
-        seen.add(normalized);
-        resolvedChain.push(normalized);
-        const configFile = ts.readConfigFile(normalized, (fileName) => ts.sys.readFile(fileName));
+        seen.add(normalizedPath);
+        resolvedChain.push(normalizedPath);
+        const configFile = ts.readConfigFile(normalizedPath, (fileName) => ts.sys.readFile(fileName));
         if (configFile.error) {
-            throw new Error(`nmr-compile: failed to read ${normalized}.\n${formatDiagnostics([configFile.error])}`);
+            throw new Error(`nmr-compile: failed to read ${normalizedPath}.\n${formatDiagnostics([configFile.error])}`);
         }
         for (const entry of normalizeExtendsField(configFile.config)) {
-            walk(resolveExtendsTarget(entry, normalized));
+            walk(resolveExtendsTarget(entry, normalizedPath));
         }
     }
     walk(path.resolve(packageDir, configFileName));
@@ -85,26 +84,26 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     const emitDir = resolveEmitDir(packageDir, outdir);
     const scratchDirs = resolveScratchDirs(emitDir);
     await removeScratchDirs(scratchDirs);
-    const emitted = new Map();
+    const emittedFiles = new Map();
     function collect(fileName, text, writeByteOrderMark) {
-        emitted.set(fileName, { text, writeByteOrderMark });
+        emittedFiles.set(fileName, { text, writeByteOrderMark });
     }
     const host = createCachingCompilerHost(compilerOptions);
     const scriptProgram = ts.createProgram(rootNames, { ...compilerOptions, declaration: false }, host);
     assertEmitSucceeded(scriptProgram.emit(undefined, collect));
     const declarationProgram = ts.createProgram(rootNames, { ...compilerOptions, emitDeclarationOnly: true, removeComments: false }, host, scriptProgram);
     assertEmitSucceeded(declarationProgram.emit(undefined, collect));
-    const staged = new Map();
-    for (const [fileName, file] of emitted) {
-        staged.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
+    const stagedFiles = new Map();
+    for (const [fileName, file] of emittedFiles) {
+        stagedFiles.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
     }
-    if (staged.size === 0) {
+    if (stagedFiles.size === 0) {
         await rm(emitDir, { force: true, recursive: true });
         return 0;
     }
-    writeStagedOutput(staged, emitDir, scratchDirs.staging);
+    writeStagedOutput(stagedFiles, emitDir, scratchDirs.stagingDir);
     await swapIntoPlace(emitDir, scratchDirs);
-    return staged.size;
+    return stagedFiles.size;
 }
 function assertEmitSucceeded(result) {
     if (result.emitSkipped) {
@@ -113,14 +112,14 @@ function assertEmitSucceeded(result) {
 }
 function createCachingCompilerHost(compilerOptions) {
     const host = ts.createCompilerHost(compilerOptions);
-    const parsed = new Map();
+    const parsedFiles = new Map();
     const readSourceFile = host.getSourceFile.bind(host);
     host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
-        if (parsed.has(fileName)) {
-            return parsed.get(fileName);
+        if (parsedFiles.has(fileName)) {
+            return parsedFiles.get(fileName);
         }
         const sourceFile = readSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
-        parsed.set(fileName, sourceFile);
+        parsedFiles.set(fileName, sourceFile);
         return sourceFile;
     };
     return host;
@@ -133,29 +132,31 @@ async function discardScratchDirs(scratchDirs) {
     }
 }
 async function removeScratchDirs(scratchDirs) {
-    await rm(scratchDirs.previous, { force: true, recursive: true });
-    await rm(scratchDirs.staging, { force: true, recursive: true });
+    await rm(scratchDirs.previousDir, { force: true, recursive: true });
+    await rm(scratchDirs.stagingDir, { force: true, recursive: true });
 }
 function resolveEmitDir(packageDir, outdir) {
-    const resolved = path.resolve(packageDir, outdir);
-    const relative = path.relative(packageDir, resolved);
-    if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
+    const resolvedDir = path.resolve(packageDir, outdir);
+    const relativePathFromPackage = path.relative(packageDir, resolvedDir);
+    if (relativePathFromPackage === '' ||
+        relativePathFromPackage.startsWith('..') ||
+        path.isAbsolute(relativePathFromPackage)) {
         throw new Error(`nmr-compile: 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 sit below the package root.');
     }
-    return resolved;
+    return resolvedDir;
 }
 async function swapIntoPlace(emitDir, scratchDirs) {
     const hadPreviousOutput = existsSync(emitDir);
     if (hadPreviousOutput) {
-        await rename(emitDir, scratchDirs.previous);
+        await rename(emitDir, scratchDirs.previousDir);
     }
     try {
-        await rename(scratchDirs.staging, emitDir);
+        await rename(scratchDirs.stagingDir, emitDir);
     }
     catch (error) {
         if (hadPreviousOutput && !existsSync(emitDir)) {
-            await rename(scratchDirs.previous, emitDir);
+            await rename(scratchDirs.previousDir, emitDir);
         }
         throw error;
     }
@@ -167,13 +168,13 @@ function synthesizeCompilerOptions(packageDir, outdir) {
     if (configFile.error) {
         throw new Error(`nmr-compile: failed to read ${configPath}.\n${formatDiagnostics([configFile.error])}`);
     }
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
-    if (parsed.errors.length > 0) {
-        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsed.errors)}`);
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
+    if (parsedConfig.errors.length > 0) {
+        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsedConfig.errors)}`);
     }
     const resolvedOutDir = path.resolve(packageDir, outdir);
     return {
-        ...parsed.options,
+        ...parsedConfig.options,
         noEmit: false,
         emitDeclarationOnly: false,
         declaration: true,
@@ -186,8 +187,8 @@ function synthesizeCompilerOptions(packageDir, outdir) {
         noEmitOnError: false,
     };
 }
-function writeStagedOutput(staged, emitDir, stagingDir) {
-    for (const [fileName, file] of staged) {
+function writeStagedOutput(stagedFiles, emitDir, stagingDir) {
+    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}. ` +
                 "Verify the resolved tsconfig's 'outDir' and 'declarationDir'.");
@@ -199,57 +200,57 @@ function rewriteSpecifiers(outputFile, text, compilerOptions, sourceRoot) {
     if (!isRewritableOutput(outputFile)) {
         return text;
     }
-    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, scriptKindFor(outputFile));
+    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, resolveScriptKind(outputFile));
     const aliasPrefixes = collectAliasPrefixes(compilerOptions);
     const sourceContainingFile = mapOutputToSource(outputFile, compilerOptions, sourceRoot);
     const edits = [];
-    forEachModuleSpecifier(sourceFile, (literal) => {
+    visitModuleSpecifiers(sourceFile, (literal) => {
         const replacement = resolveSpecifierReplacement(literal.text, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes);
         if (replacement === undefined) {
             return;
         }
-        const start = literal.getStart(sourceFile);
-        const quote = text[start] ?? '"';
-        edits.push({ start, end: literal.getEnd(), text: `${quote}${replacement}${quote}` });
+        const startOffset = literal.getStart(sourceFile);
+        const quote = text[startOffset] ?? '"';
+        edits.push({ startOffset, endOffset: literal.getEnd(), text: `${quote}${replacement}${quote}` });
     });
     if (edits.length === 0) {
         return text;
     }
-    const orderedEdits = [...edits].sort((a, b) => b.start - a.start);
+    const orderedEdits = [...edits].sort((a, b) => b.startOffset - a.startOffset);
     let updatedText = text;
     for (const edit of orderedEdits) {
-        updatedText = updatedText.slice(0, edit.start) + edit.text + updatedText.slice(edit.end);
+        updatedText = updatedText.slice(0, edit.startOffset) + edit.text + updatedText.slice(edit.endOffset);
     }
     return updatedText;
 }
 function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes) {
     if (isRelativeSpecifier(specifier)) {
-        const rewritten = swapTypeScriptExtension(specifier);
-        return rewritten === specifier ? undefined : rewritten;
+        const rewrittenSpecifier = swapTypeScriptExtension(specifier);
+        return rewrittenSpecifier === specifier ? undefined : rewrittenSpecifier;
     }
     if (aliasPrefixes.every((prefix) => !(specifier === prefix || specifier.startsWith(prefix)))) {
         return undefined;
     }
-    const resolved = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
-    if (!resolved) {
+    const resolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
+    if (!resolvedModule) {
         throw new Error(`nmr-compile: could not resolve aliased import '${specifier}' from ${sourceContainingFile}. ` +
             `Verify the tsconfig 'paths' mapping and that the target file exists.`);
     }
-    if (!isWithin(sourceRoot, resolved.resolvedFileName)) {
+    if (!isWithin(sourceRoot, resolvedModule.resolvedFileName)) {
         const { paths: _paths, baseUrl: _baseUrl, rootDirs: _rootDirs, ...nodeResolutionOptions } = compilerOptions;
-        const bareResolved = ts.resolveModuleName(specifier, sourceContainingFile, nodeResolutionOptions, ts.sys).resolvedModule;
-        if (bareResolved) {
+        const bareResolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, nodeResolutionOptions, ts.sys).resolvedModule;
+        if (bareResolvedModule) {
             return undefined;
         }
         throw new Error(`nmr-compile: aliased import '${specifier}' from ${sourceContainingFile} resolves to ` +
-            `${resolved.resolvedFileName}, outside the package source root ${sourceRoot}, and does not resolve ` +
+            `${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.`);
     }
-    const relative = toRelativeSpecifier(path.dirname(sourceContainingFile), resolved.resolvedFileName);
-    return swapTypeScriptExtension(relative);
+    const relativeSpecifier = buildRelativeSpecifier(path.dirname(sourceContainingFile), resolvedModule.resolvedFileName);
+    return swapTypeScriptExtension(relativeSpecifier);
 }
-function forEachModuleSpecifier(sourceFile, visit) {
+function visitModuleSpecifiers(sourceFile, visit) {
     function walk(node) {
         const specifier = getModuleSpecifier(node);
         if (specifier !== undefined) {
@@ -275,19 +276,19 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent) {
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, isOutputPresent, style) {
     const packageName = path.basename(packageDir);
     const previousHash = await readCacheEntry(cachePath);
     const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
     if (previousHash === currentHash) {
-        if (outputPresent) {
-            console.info(`${SKIPPED_ICON} ${packageName}: No changes detected. Skipping build.`);
+        if (isOutputPresent) {
+            console.info(`${STATUS_GLYPHS[style].skipped.text} ${packageName}: No changes detected. Skipping build.`);
             return { changed: false, currentHash };
         }
-        console.info(`${PACKAGE_ICON} ${packageName}: Build output is missing. Rebuilding.`);
+        console.info(formatGlyphLine(NMR_GLYPHS, style, 'package', `${packageName}: Build output is missing. Rebuilding.`));
         return { changed: true, currentHash };
     }
-    console.info(`${PACKAGE_ICON} ${packageName}: Changes detected.`);
+    console.info(formatGlyphLine(NMR_GLYPHS, style, 'package', `${packageName}: Changes detected.`));
     return { changed: true, currentHash };
 }
 function assertSupportedTypeScript() {
@@ -347,12 +348,12 @@ function resolveExtendsTarget(extendsEntry, fromConfigPath) {
         }
         throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not exist.`);
     }
-    const resolved = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
+    const resolvedPath = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
         resolvePackageSpecifier(`${extendsEntry}/tsconfig.json`, fromConfigPath);
-    if (resolved === undefined) {
+    if (resolvedPath === undefined) {
         throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not resolve to a file.`);
     }
-    return resolved;
+    return resolvedPath;
 }
 function resolvePackageSpecifier(specifier, fromConfigPath) {
     const { resolvedModule } = ts.resolveModuleName(specifier, fromConfigPath, { moduleResolution: ts.ModuleResolutionKind.NodeNext, resolveJsonModule: true }, ts.sys);
@@ -362,8 +363,8 @@ function isRelativeSpecifier(specifier) {
     return specifier.startsWith('./') || specifier.startsWith('../');
 }
 function isWithin(parent, child) {
-    const relative = path.relative(parent, child);
-    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+    const relativePath = path.relative(parent, child);
+    return relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
 }
 function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
     const outDir = compilerOptions.outDir ?? path.dirname(outputFile);
@@ -371,11 +372,11 @@ function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
     const withoutExtension = relativeFromOut.replace(/\.d\.ts$|\.js$/, '');
     return path.join(sourceRoot, `${withoutExtension}.ts`);
 }
-function toRelativeSpecifier(fromDir, targetFile) {
-    const relative = path.relative(fromDir, targetFile).split(path.sep).join('/');
-    return relative.startsWith('.') ? relative : `./${relative}`;
+function buildRelativeSpecifier(fromDir, targetFile) {
+    const relativePath = path.relative(fromDir, targetFile).split(path.sep).join('/');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
 }
-function scriptKindFor(file) {
+function resolveScriptKind(file) {
     return file.endsWith('.d.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS;
 }
 function swapTypeScriptExtension(specifier) {

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

@@ -1,8 +1,9 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
  * Removes a package's build output and the build-cache entry that describes it, so no state survives to
  * make the next build skip. Removal is idempotent: an already-clean package is a silent no-op.
  */
-export declare function cleanPackage(packageDir: string): Promise<void>;
+export declare function cleanPackage(packageDir: string, style: OutputStyle): Promise<void>;
 /**
  * Cleans the package containing `cwd`, or every workspace package when run from the monorepo root.
  *
@@ -14,4 +15,4 @@ export declare function cleanPackage(packageDir: string): Promise<void>;
  * a `rimraf` in nmr's dependency tree would be unreachable — while nmr's own bins are linked into the
  * consumer's `node_modules/.bin`, nmr being a direct dependency.
  */
-export declare function runClean(cwd?: string): Promise<void>;
+export declare function runClean(cwd: string, style: OutputStyle): Promise<void>;

package/dist/esm/commands/clean.js

@@ -1,66 +1,67 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
 import { removeCheckCache } from "../check-cache.js";
 import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
+import { NMR_GLYPHS } from "../glyphs.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";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
 import { resolveBuildCachePath } from "./build-output.js";
-const CLEAN_ICON = '🧹';
 const CLEAN_COMMAND = 'clean';
 const BUILT_IN_CLEAN = 'nmr-clean';
 const OUTPUT_ROOT = 'dist';
-export async function cleanPackage(packageDir) {
+export async function cleanPackage(packageDir, style) {
     await rm(path.resolve(packageDir, OUTPUT_ROOT), { recursive: true, force: true });
     await rm(resolveBuildCachePath(packageDir), { force: true });
-    console.info(`${CLEAN_ICON} ${path.basename(packageDir)}: Removed build output and cache.`);
+    console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', `${path.basename(packageDir)}: Removed build output and cache.`));
 }
-export async function runClean(cwd = process.cwd()) {
+export async function runClean(cwd, style) {
     let monorepoRoot;
     try {
         monorepoRoot = findMonorepoRoot(cwd);
     }
     catch {
-        await clearCheckCache(cwd);
-        await cleanPackage(cwd);
+        await clearCheckCache(cwd, style);
+        await cleanPackage(cwd, style);
         return;
     }
-    await clearCheckCache(monorepoRoot);
+    await clearCheckCache(monorepoRoot, style);
     const workspacePackageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packageDir = findContainingPackageDir(cwd, workspacePackageDirs);
     if (packageDir !== undefined) {
-        await cleanPackage(packageDir);
+        await cleanPackage(packageDir, style);
         return;
     }
-    await sweepWorkspace(monorepoRoot, workspacePackageDirs);
+    await sweepWorkspace(monorepoRoot, workspacePackageDirs, style);
 }
-async function clearCheckCache(scopeDir) {
+async function clearCheckCache(scopeDir, style) {
     await removeCheckCache(scopeDir);
-    console.info(`${CLEAN_ICON} Removed all recorded check results.`);
+    console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', '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`;
+function describeSweep(cleanedCount, skippedCount) {
+    const packages = cleanedCount === 1 ? '1 package' : `${cleanedCount} packages`;
+    const skipClause = skippedCount === 0 ? '' : `, skipping ${skippedCount} with an empty clean override`;
     return `Cleaned ${packages}${skipClause}.`;
 }
-async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
+async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
-    let cleaned = 0;
-    let skipped = 0;
+    let cleanedCount = 0;
+    let skippedCount = 0;
     for (const packageDir of workspacePackageDirs) {
-        const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
-        const resolvedCommand = resolved === undefined ? undefined : renderChain(resolved.steps);
+        const resolvedScript = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
+        const resolvedCommand = resolvedScript === undefined ? undefined : renderChain(resolvedScript.steps);
         if (resolvedCommand === undefined || resolvedCommand === '') {
-            skipped++;
+            skippedCount++;
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
-            await cleanPackage(packageDir);
-            cleaned++;
+            await cleanPackage(packageDir, style);
+            cleanedCount++;
             continue;
         }
         const command = applyDevBin(resolvedCommand, config.devBin, monorepoRoot);
@@ -70,7 +71,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++;
+        cleanedCount++;
     }
-    reportClosing(`${CLEAN_ICON} ${describeSweep(cleaned, skipped)}`);
+    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleanedCount, skippedCount)));
 }

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

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 export interface PackageHookStatus {
     packageName: string;
     packageDir: string;
@@ -15,15 +16,15 @@ export declare const DEFAULT_HOOK = "npm run build";
  * have a `prepublishOnly` script.
  */
 export declare function ensurePrepublishHooks(monorepoRoot: string, options: {
-    fix: boolean;
-    dryRun: boolean;
+    shouldFix: boolean;
+    isDryRun: boolean;
     command?: string;
 }): EnsurePrepublishHooksResult;
 /**
  * Reports one line per publishable package and closes with what the run came to. Private packages appear in
  * neither: they publish nothing, so a `prepublishOnly` is not theirs to carry.
  *
- * Every line goes to stdout, the `✗` included, and the exit code is what carries a failure. A report split
+ * Every line goes to stdout, a failure's included, and the exit code is what carries a failure. A report split
  * across two streams leaves no reader holding the whole list.
  */
-export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string): void;
+export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string, style: OutputStyle): void;

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

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { STATUS_GLYPHS } from '@williamthorsen/nmr-core';
 import { readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { isObject } from "../helpers/type-guards.js";
@@ -10,33 +11,33 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     const packageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packages = [];
     for (const packageDir of packageDirs) {
-        const pkg = readPackageJson(packageDir);
-        const packageName = pkg.name ?? path.basename(packageDir);
-        const isPrivate = pkg.private === true;
+        const packageJson = readPackageJson(packageDir);
+        const packageName = packageJson.name ?? path.basename(packageDir);
+        const isPrivate = packageJson.private === true;
         if (isPrivate) {
             packages.push({
                 packageName,
                 packageDir,
                 isPrivate: true,
-                prepublishOnly: pkg.scripts?.['prepublishOnly'],
+                prepublishOnly: packageJson.scripts?.['prepublishOnly'],
                 action: 'ok',
             });
             continue;
         }
-        const existing = pkg.scripts?.['prepublishOnly'];
-        if (existing) {
+        const existingHook = packageJson.scripts?.['prepublishOnly'];
+        if (existingHook) {
             packages.push({
                 packageName,
                 packageDir,
                 isPrivate: false,
-                prepublishOnly: existing,
+                prepublishOnly: existingHook,
                 action: 'ok',
             });
             continue;
         }
-        if (options.fix) {
-            const action = options.dryRun ? 'would-fix' : 'fixed';
-            if (!options.dryRun) {
+        if (options.shouldFix) {
+            const action = options.isDryRun ? 'would-fix' : 'fixed';
+            if (!options.isDryRun) {
                 addPrepublishOnly(packageDir, hookCommand);
             }
             packages.push({
@@ -60,57 +61,58 @@ 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) {
+export function reportPrepublishHooks(result, hookCommand, style) {
+    const publishablePackages = result.packages.filter((packageStatus) => !packageStatus.isPrivate);
+    if (publishablePackages.length === 0) {
         console.info('No publishable packages found.');
         return;
     }
-    for (const pkg of publishable) {
-        console.info(renderHookStatus(pkg, hookCommand));
+    for (const packageStatus of publishablePackages) {
+        console.info(renderHookStatus(packageStatus, hookCommand, style));
     }
-    reportClosing(describeHookRun(publishable));
+    reportClosing(describeHookRun(publishablePackages));
 }
 function addPrepublishOnly(packageDir, command) {
     const filePath = path.join(packageDir, 'package.json');
-    const raw = readFileSync(filePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!isObject(parsed)) {
+    const rawText = readFileSync(filePath, 'utf8');
+    const parsedManifest = JSON.parse(rawText);
+    if (!isObject(parsedManifest)) {
         throw new TypeError(`Invalid package.json in ${packageDir}: expected an object`);
     }
-    const scripts = isObject(parsed['scripts']) ? parsed['scripts'] : {};
+    const scripts = isObject(parsedManifest['scripts']) ? parsedManifest['scripts'] : {};
     scripts['prepublishOnly'] = command;
-    parsed['scripts'] = scripts;
-    writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
+    parsedManifest['scripts'] = scripts;
+    writeFileSync(filePath, JSON.stringify(parsedManifest, null, 2) + '\n', 'utf8');
 }
-function countAction(publishable, action) {
-    return publishable.filter((pkg) => pkg.action === action).length;
+function countAction(publishablePackages, action) {
+    return publishablePackages.filter((packageStatus) => packageStatus.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.`;
+function describeHookRun(publishablePackages) {
+    const packages = publishablePackages.length === 1 ? '1 publishable package' : `${publishablePackages.length} publishable packages`;
+    const missingCount = countAction(publishablePackages, 'missing');
+    if (missingCount > 0) {
+        return `${missingCount} of ${packages} ${missingCount === 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 fixedCount = countAction(publishablePackages, 'fixed');
+    if (fixedCount > 0) {
+        return `Added prepublishOnly to ${fixedCount} of ${packages}.`;
     }
-    const wouldFix = countAction(publishable, 'would-fix');
-    if (wouldFix > 0) {
-        return `Would add prepublishOnly to ${wouldFix} of ${packages}.`;
+    const wouldFixCount = countAction(publishablePackages, 'would-fix');
+    if (wouldFixCount > 0) {
+        return `Would add prepublishOnly to ${wouldFixCount} of ${packages}.`;
     }
-    return `${packages} ${publishable.length === 1 ? 'has' : 'have'} prepublishOnly.`;
+    return `${packages} ${publishablePackages.length === 1 ? 'has' : 'have'} prepublishOnly.`;
 }
-function renderHookStatus(pkg, hookCommand) {
-    switch (pkg.action) {
+function renderHookStatus(packageStatus, hookCommand, style) {
+    const statuses = STATUS_GLYPHS[style];
+    switch (packageStatus.action) {
         case 'ok':
-            return `✓ ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
+            return `${statuses.passed.text} ${packageStatus.packageName}: prepublishOnly = "${packageStatus.prepublishOnly}"`;
         case 'missing':
-            return `✗ ${pkg.packageName}: missing prepublishOnly`;
+            return `${statuses.failed.text} ${packageStatus.packageName}: missing prepublishOnly`;
         case 'fixed':
-            return `✓ ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
+            return `${statuses.passed.text} ${packageStatus.packageName}: added prepublishOnly = "${hookCommand}"`;
         case 'would-fix':
-            return `~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`;
+            return `~ ${packageStatus.packageName}: would add prepublishOnly = "${hookCommand}"`;
     }
 }