@williamthorsen/release-kit 16.1.2 → 17.0.0

package/dist/esm/prepareArgs.js

@@ -1,46 +1,5 @@
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { configFlagSchema } from "./configFlagSchema.js";
-const VALID_BUMP_TYPES = ['major', 'minor', 'patch'];
+import { UsageError } from '@williamthorsen/nmr-core/cli';
 export const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
-export const prepareFlagSchema = {
-    ...configFlagSchema,
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-    shouldForce: { long: '--force', type: 'boolean' },
-    shouldSkipGitChecks: {
-        long: '--no-git-checks',
-        type: 'boolean',
-        short: '-n',
-    },
-    bump: { long: '--bump', type: 'string' },
-    setVersion: { long: '--set-version', type: 'string' },
-    only: { long: '--only', type: 'string' },
-    shouldIncludeReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
-};
-export function parseArgs(argv) {
-    const { flags } = parseArgsOrExit(argv, prepareFlagSchema);
-    let bumpOverride;
-    if (flags.bump !== undefined) {
-        if (!isReleaseType(flags.bump)) {
-            reportError(`Invalid bump type "${flags.bump}". Must be one of: ${VALID_BUMP_TYPES.join(', ')}`);
-            process.exit(1);
-        }
-        bumpOverride = flags.bump;
-    }
-    let onlyNames;
-    if (flags.only !== undefined) {
-        onlyNames = flags.only.split(',');
-    }
-    return {
-        configPath: flags.config,
-        isDryRun: flags.isDryRun,
-        shouldForce: flags.shouldForce,
-        shouldSkipGitChecks: flags.shouldSkipGitChecks,
-        bumpOverride,
-        onlyNames,
-        setVersion: flags.setVersion,
-        shouldIncludeReleaseNotes: flags.shouldIncludeReleaseNotes,
-    };
-}
 export function parseSetVersions(value, knownNames) {
     const setVersions = new Map();
     for (const entry of value.split(',')) {
@@ -48,22 +7,16 @@ export function parseSetVersions(value, knownNames) {
         const name = entry.slice(0, Math.max(0, separatorIndex));
         const version = entry.slice(separatorIndex + 1);
         if (separatorIndex <= 0 || !CANONICAL_SEMVER_PATTERN.test(version)) {
-            reportError(`Invalid --set-version entry "${entry}". In monorepo mode, each entry must be <target>@N.N.N ` +
+            throw new UsageError(`Invalid --set-version entry "${entry}". In monorepo mode, each entry must be <target>@N.N.N ` +
                 '(canonical semver, no pre-release suffix), e.g. --set-version=arrays@1.0.0.');
-            process.exit(1);
         }
         if (!knownNames.includes(name)) {
-            reportError(`Unknown release target "${name}" in --set-version. Known targets: ${knownNames.join(', ')}`);
-            process.exit(1);
+            throw new UsageError(`Unknown release target "${name}" in --set-version. Known targets: ${knownNames.join(', ')}`);
         }
         if (setVersions.has(name)) {
-            reportError(`--set-version names target "${name}" more than once`);
-            process.exit(1);
+            throw new UsageError(`--set-version names target "${name}" more than once`);
         }
         setVersions.set(name, version);
     }
     return setVersions;
 }
-function isReleaseType(value) {
-    return VALID_BUMP_TYPES.includes(value);
-}

package/dist/esm/prepareCommand.d.ts

@@ -1,8 +1,20 @@
 import { type StreamStyles } from '@williamthorsen/nmr-core';
+import type { ReleaseType } from './types.js';
+export interface PrepareCommandOptions {
+    bumpOverride: ReleaseType | undefined;
+    configPath: string | undefined;
+    isDryRun: boolean;
+    /** The release targets that `--only` names, or `undefined` to release every target that has changes. */
+    onlyNames: string[] | undefined;
+    /** The raw `--set-version` value, whose accepted form depends on the mode. */
+    setVersion: string | undefined;
+    shouldForce: boolean;
+    shouldIncludeReleaseNotes: boolean;
+    shouldSkipGitChecks: boolean;
+    styles: StreamStyles;
+}
 /**
  * Orchestrates the CLI `prepare` command: checks the working tree, loads and validates the config, discovers the
  * workspaces, and prepares the release over the targets of the repo shape.
- *
- * A relative `--config` resolves against `invocationDir`.
  */
-export declare function prepareCommand(argv: string[], styles: StreamStyles, invocationDir: string): Promise<void>;
+export declare function prepareCommand({ bumpOverride, configPath, isDryRun, onlyNames, setVersion, shouldForce, shouldIncludeReleaseNotes, shouldSkipGitChecks, styles, }: PrepareCommandOptions): Promise<void>;

package/dist/esm/prepareCommand.js

@@ -1,5 +1,6 @@
 import { execSync } from 'node:child_process';
-import { formatGlyphLine, isAnticipatedFailure, reportError, UserError, } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, isAnticipatedFailure, UserError, } from '@williamthorsen/nmr-core';
+import { UsageError } from '@williamthorsen/nmr-core/cli';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertReleasesOnNpm } from "./assertReleasesOnNpm.js";
@@ -7,18 +8,16 @@ import { assertTarballsComplete } from "./assertTarballsComplete.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
-import { loadValidatedConfig, reportConfigProblem, reportConfigWarnings } from "./loadValidatedConfig.js";
-import { CANONICAL_SEMVER_PATTERN, parseArgs, parseSetVersions } from "./prepareArgs.js";
+import { ConfigProblemError, loadValidatedConfig, reportConfigWarnings } from "./loadValidatedConfig.js";
+import { CANONICAL_SEMVER_PATTERN, parseSetVersions } from "./prepareArgs.js";
 import { prepareReleaseTargets } from "./prepareReleaseTargets.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 import { applyReleasePlan } from "./releasePlan.js";
 import { reportPrepare } from "./reportPrepare.js";
-import { resolveConfigFlag } from "./resolveConfigFlag.js";
 import { isSinglePackageTargets, PROJECT_TARGET_ID, resolveReleaseTargets, SINGLE_PACKAGE_TARGET_ID, } from "./resolveReleaseTargets.js";
 import { prefixUserError } from "./user-error-chaining.js";
 const UNCHANGED_TREE_NOTE = 'The command did not write any files; the working tree is unchanged.';
-export async function prepareCommand(argv, styles, invocationDir) {
-    const { configPath: configFlag, isDryRun, shouldForce, shouldSkipGitChecks, bumpOverride, onlyNames, setVersion, shouldIncludeReleaseNotes, } = parseArgs(argv);
+export async function prepareCommand({ bumpOverride, configPath, isDryRun, onlyNames, setVersion, shouldForce, shouldIncludeReleaseNotes, shouldSkipGitChecks, styles, }) {
     const options = {
         shouldForce,
         ...(bumpOverride !== undefined && { bumpOverride }),
@@ -30,10 +29,9 @@ export async function prepareCommand(argv, styles, invocationDir) {
     if (!isDryRun && !shouldSkipGitChecks) {
         assertCleanWorkingTree();
     }
-    const configResult = await loadValidatedConfig(resolveConfigFlag(configFlag, invocationDir));
+    const configResult = await loadValidatedConfig(configPath);
     if (configResult.status === 'invalid') {
-        reportConfigProblem(configResult.problem, styles.stderr);
-        process.exit(1);
+        throw new ConfigProblemError(configResult.problem);
     }
     let userConfig;
     if (configResult.status === 'ok') {
@@ -48,10 +46,9 @@ export async function prepareCommand(argv, styles, invocationDir) {
         throw prefixUserError('Failed to discover workspaces', error);
     }
     if (workspaceDiscovery.kind === 'empty') {
-        reportError(`No workspace package to release. ${describeEmptyWorkspace(workspaceDiscovery)}`);
-        process.exit(1);
+        throw new UserError(`No workspace package to release. ${describeEmptyWorkspace(workspaceDiscovery)}`);
     }
-    const config = resolveTargetsOrExit(userConfig, workspaceDiscovery, onlyNames, setVersion);
+    const config = resolveSelectedTargets(userConfig, workspaceDiscovery, onlyNames, setVersion);
     const targetOptions = {
         ...options,
         ...(onlyNames !== undefined && { onlyTargetIds: onlyNames }),
@@ -69,15 +66,13 @@ function findReleasedPackagePaths(plan, targets) {
     const releasedIds = new Set(plan.targets.flatMap((result) => result.status === 'released' && result.kind === 'package' ? result.targetId : []));
     return targets.flatMap((target) => target.kind === 'package' && releasedIds.has(target.id) ? target.packagePath : []);
 }
-function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
+function resolveSelectedTargets(userConfig, discovery, onlyNames, setVersion) {
     if (discovery.kind === 'single-package') {
         if (onlyNames !== undefined) {
-            reportError('--only is only supported for monorepo configurations');
-            process.exit(1);
+            throw new UsageError('--only is only supported for monorepo configurations');
         }
         if (setVersion !== undefined && !CANONICAL_SEMVER_PATTERN.test(setVersion)) {
-            reportError(`Invalid --set-version value "${setVersion}". Must be canonical semver (N.N.N, no pre-release suffix).`);
-            process.exit(1);
+            throw new UsageError(`Invalid --set-version value "${setVersion}". Must be canonical semver (N.N.N, no pre-release suffix).`);
         }
         return resolveReleaseTargets(userConfig, discovery);
     }
@@ -89,10 +84,9 @@ function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
         throw prefixUserError('Failed to resolve workspaces', error);
     }
     if (setVersion !== undefined && config.targets.some((target) => target.kind === 'composite')) {
-        reportError('--set-version cannot be combined with a project release. ' +
+        throw new UsageError('--set-version cannot be combined with a project release. ' +
             "--set-version sets individual workspaces' versions; a project release rolls up every " +
             'contributing workspace. To use --set-version, run on a config without a `project` block or a `releases` composite.');
-        process.exit(1);
     }
     const knownNames = listSelectableIds(config.targets);
     const requestedNames = onlyNames ?? [];
@@ -100,8 +94,7 @@ function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
         if (knownNames.includes(name)) {
             continue;
         }
-        reportError(`Unknown release target "${name}". Known targets: ${knownNames.join(', ')}`);
-        process.exit(1);
+        throw new UsageError(`Unknown release target "${name}". Known targets: ${knownNames.join(', ')}`);
     }
     return config;
 }
@@ -141,9 +134,8 @@ function runAndReport(computePlan, isDryRun, style) {
     if (formatError === undefined) {
         return;
     }
-    reportError(`The format command failed, but the release is prepared and ${RELEASE_TAGS_FILE} is written. ` +
+    throw new UserError(`The format command failed, but the release is prepared and ${RELEASE_TAGS_FILE} is written. ` +
         `Format the release files and run 'release-kit commit'.`);
-    process.exit(1);
 }
 function runFormatCommand(formatCommand) {
     if (formatCommand === undefined) {

package/dist/esm/publishCommand.d.ts

@@ -1,7 +1,16 @@
-import { type StreamStyles } from '@williamthorsen/nmr-core';
+import type { StreamStyles } from '@williamthorsen/nmr-core';
+export interface PublishCommandOptions {
+    configPath: string | undefined;
+    isDryRun: boolean;
+    shouldGenerateProvenance: boolean;
+    shouldSkipGitChecks: boolean;
+    /** The tag names that `--tags` selects, or `undefined` to publish every publishable release tag on HEAD. */
+    tags: string[] | undefined;
+    styles: StreamStyles;
+}
 /**
  * Orchestrates the CLI `publish` command: checks for a clean working tree, resolves the tags on HEAD, checks the
  * tarballs of the publishable ones from a clean checkout, and publishes each one, injecting release notes into its
- * README for the duration of the publish. A relative `--config` resolves against `invocationDir`.
+ * README for the duration of the publish.
  */
-export declare function publishCommand(argv: string[], styles: StreamStyles, invocationDir: string): Promise<void>;
+export declare function publishCommand({ configPath, isDryRun, shouldGenerateProvenance, shouldSkipGitChecks, tags: requestedTags, styles, }: PublishCommandOptions): Promise<void>;

package/dist/esm/publishCommand.js

@@ -1,9 +1,7 @@
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { parseArgsOrExit } from '@williamthorsen/nmr-core';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertTarballsComplete } from "./assertTarballsComplete.js";
-import { configFlagSchema } from "./configFlagSchema.js";
 import { deriveReleaseNotesConfig } from "./deriveReleaseNotesConfig.js";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { formatDirectoryPublishSkip } from "./formatDirectoryPublishSkip.js";
@@ -11,26 +9,13 @@ import { formatPrivateSkip } from "./formatPrivateSkip.js";
 import { formatProjectPublishSkip } from "./formatProjectPublishSkip.js";
 import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
 import { loadUsableConfig } from "./loadValidatedConfig.js";
-import { parseRequestedTags } from "./parseRequestedTags.js";
 import { publishPackage } from "./publish.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
-import { resolveConfigFlag } from "./resolveConfigFlag.js";
-const publishFlagSchema = {
-    ...configFlagSchema,
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-    shouldSkipGitChecks: { long: '--no-git-checks', type: 'boolean' },
-    shouldGenerateProvenance: { long: '--provenance', type: 'boolean' },
-    tags: { long: '--tags', type: 'string' },
-};
-export async function publishCommand(argv, styles, invocationDir) {
-    const parsedArgs = parseArgsOrExit(argv, publishFlagSchema);
-    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
-    const { isDryRun, shouldSkipGitChecks, shouldGenerateProvenance } = parsedArgs.flags;
+export async function publishCommand({ configPath, isDryRun, shouldGenerateProvenance, shouldSkipGitChecks, tags: requestedTags, styles, }) {
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
     if (!isDryRun && !shouldSkipGitChecks) {
         assertCleanWorkingTree();
     }
-    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     if (resolvedTags.length === 0) {
         return;

package/dist/esm/pushCommand.d.ts

@@ -1,6 +1,14 @@
-import { type StreamStyles } from '@williamthorsen/nmr-core';
+import type { StreamStyles } from '@williamthorsen/nmr-core';
+export interface PushCommandOptions {
+    configPath: string | undefined;
+    isDryRun: boolean;
+    /** The tag names that `--tags` selects, or `undefined` to push every release tag on HEAD. */
+    tags: string[] | undefined;
+    tagsOnly: boolean;
+    styles: StreamStyles;
+}
 /**
- * Orchestrates the CLI `push` command: parses flags, loads the config, resolves tags from HEAD, and pushes
- * the release commit and each tag individually. A relative `--config` resolves against `invocationDir`.
+ * Orchestrates the CLI `push` command: loads the config, resolves tags from HEAD, and pushes the release commit and
+ * each tag individually.
  */
-export declare function pushCommand(argv: string[], styles: StreamStyles, invocationDir: string): Promise<void>;
+export declare function pushCommand({ configPath, isDryRun, tags, tagsOnly, styles }: PushCommandOptions): Promise<void>;

package/dist/esm/pushCommand.js

@@ -1,23 +1,9 @@
-import { parseArgsOrExit } from '@williamthorsen/nmr-core';
-import { configFlagSchema } from "./configFlagSchema.js";
 import { loadUsableConfig } from "./loadValidatedConfig.js";
-import { parseRequestedTags } from "./parseRequestedTags.js";
 import { pushRelease } from "./pushRelease.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
-import { resolveConfigFlag } from "./resolveConfigFlag.js";
-const pushFlagSchema = {
-    ...configFlagSchema,
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-    tags: { long: '--tags', type: 'string' },
-    tagsOnly: { long: '--tags-only', type: 'boolean' },
-};
-export async function pushCommand(argv, styles, invocationDir) {
-    const parsedArgs = parseArgsOrExit(argv, pushFlagSchema);
-    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
-    const { isDryRun, tagsOnly } = parsedArgs.flags;
+export async function pushCommand({ configPath, isDryRun, tags, tagsOnly, styles }) {
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
-    const resolvedTags = resolveCommandTags(requestedTags, userConfig);
+    const resolvedTags = resolveCommandTags(tags, userConfig);
     if (resolvedTags.length === 0) {
         return;
     }

package/dist/esm/resolveCommandTags.d.ts

@@ -3,9 +3,9 @@ import { type ResolvedTag } from './resolveReleaseTags.js';
 /**
  * Discovers workspaces, resolves release tags from HEAD, validates `--tags` names against the full resolved tag
  * names (e.g., `nmr-core-v1.3.0`), and returns the filtered tag list. Throws a `UserError` when workspace discovery
- * fails, when a workspace's `package.json` does not have a `name` field, and when `mergeMonorepoConfig` rejects the
- * config. Exits with an error message on any other validation failure, including a workspace that does not resolve to
- * any package, which is not single-package mode.
+ * fails, when a workspace's `package.json` does not have a `name` field, when `mergeMonorepoConfig` rejects the
+ * config, when the workspace does not resolve to any package (which is not single-package mode), and when HEAD does
+ * not have any release tags; throws a `UsageError` for a `--tags` name that HEAD lacks.
  *
  * In monorepo mode the workspace list is `userConfig` merged over the discovered workspaces, as `prepare` builds it,
  * and each directory target and a declared composite (a `project` block or a `releases` composite) contribute their

package/dist/esm/resolveCommandTags.js

@@ -1,4 +1,5 @@
-import { reportError } from '@williamthorsen/nmr-core';
+import { UserError } from '@williamthorsen/nmr-core';
+import { UsageError } from '@williamthorsen/nmr-core/cli';
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { formatExcludedSkip } from "./formatExcludedSkip.js";
@@ -15,8 +16,7 @@ export function resolveCommandTags(tags, userConfig) {
         throw prefixUserError('Failed to discover workspaces', error);
     }
     if (workspace.kind === 'empty') {
-        reportError(`No workspace package to tag. ${describeEmptyWorkspace(workspace)}`);
-        process.exit(1);
+        throw new UserError(`No workspace package to tag. ${describeEmptyWorkspace(workspace)}`);
     }
     let workspaces;
     let directories = [];
@@ -50,8 +50,7 @@ export function resolveCommandTags(tags, userConfig) {
         throw new Error('resolveCommandTags: invariant violated; neither workspaces nor singleWorkspace was derived');
     }
     if (resolvedTags.length === 0) {
-        reportError('HEAD does not have any release tags. Create tags with `release-kit tag` first.');
-        process.exit(1);
+        throw new UserError('HEAD does not have any release tags. Create tags with `release-kit tag` first.');
     }
     if (tags !== undefined) {
         const availableTagNames = resolvedTags.map((t) => t.tag);
@@ -59,8 +58,7 @@ export function resolveCommandTags(tags, userConfig) {
             if (availableTagNames.includes(name)) {
                 continue;
             }
-            reportError(`Unknown tag "${name}" in --tags. Available: ${availableTagNames.join(', ')}`);
-            process.exit(1);
+            throw new UsageError(`Unknown tag "${name}" in --tags. Available: ${availableTagNames.join(', ')}`);
         }
         resolvedTags = resolvedTags.filter((t) => tags.includes(t.tag));
     }

package/dist/esm/{resolveStylesOrExit.d.ts → resolveStyles.d.ts}

@@ -6,5 +6,5 @@ export interface ResolveStylesOptions {
     readonly stderrIsTty: boolean;
     readonly stdoutIsTty: boolean;
 }
-/** Resolves the style of each output stream, exiting with a usage error when the variable does not name a setting. */
-export declare function resolveStylesOrExit(options: ResolveStylesOptions): StreamStyles;
+/** Resolves the style of each output stream, throwing a `UsageError` when the variable doesn't name a setting. */
+export declare function resolveStyles(options: ResolveStylesOptions): StreamStyles;

package/dist/esm/resolveStyles.js

@@ -0,0 +1,10 @@
+import { describeInvalidOutputStyle, resolveStreamStyles } from '@williamthorsen/nmr-core';
+import { UsageError } from '@williamthorsen/nmr-core/cli';
+export const OUTPUT_STYLE_ENV_VAR = 'RELEASE_KIT_OUTPUT_STYLE';
+export function resolveStyles(options) {
+    const { invalid, styles } = resolveStreamStyles({ ...options, envVar: OUTPUT_STYLE_ENV_VAR });
+    if (invalid !== undefined) {
+        throw new UsageError(describeInvalidOutputStyle(invalid));
+    }
+    return styles;
+}

package/dist/esm/route.d.ts

@@ -0,0 +1,2 @@
+/** Runs the `release-kit` command tree against the arguments and resolves to the exit code. */
+export declare function routeCommand(args: string[]): Promise<number>;

package/dist/esm/route.js

@@ -0,0 +1,39 @@
+import process from 'node:process';
+import { resolveSelfVersion } from '@williamthorsen/nmr-core';
+import { createCli, runCli } from '@williamthorsen/nmr-core/cli';
+import { BIN } from "./bin.js";
+import { init, overrides, showTagPrefixes, syncLabels, updateTemplates } from "./cli/maintenanceCommands.js";
+import { commit, createGithubRelease, prepare, publish, push, tag } from "./cli/releaseCommands.js";
+import { OUTPUT_STYLE_ENV_VAR, resolveStyles } from "./resolveStyles.js";
+const VERSION = resolveSelfVersion(import.meta.url);
+export async function routeCommand(args) {
+    return runCli(args, ROOT, {
+        name: BIN,
+        context: { env: process.env, stderrIsTty: process.stderr.isTTY, stdoutIsTty: process.stdout.isTTY },
+        stdout: process.stdout,
+        stderr: process.stderr,
+        version: () => VERSION,
+    });
+}
+const { defineGroup } = createCli();
+const ROOT = defineGroup({
+    summary: 'Version-bumping and changelog-generation toolkit for release workflows',
+    deriveContext: (_flags, context) => ({ styles: resolveStyles(context) }),
+    commands: {
+        prepare,
+        commit,
+        tag,
+        push,
+        publish,
+        'create-github-release': createGithubRelease,
+        'show-tag-prefixes': showTagPrefixes,
+        init,
+        'update-templates': updateTemplates,
+        overrides,
+        'sync-labels': syncLabels,
+    },
+    epilog: `Environment:
+  ${OUTPUT_STYLE_ENV_VAR}
+      Output style: auto (default), plain, or rich. auto prints plain, without emoji,
+      when CI is set or the stream is not a terminal.`,
+});

package/dist/esm/showTagPrefixesCommand.js

@@ -1,4 +1,5 @@
 import { formatStatusLine, isAnticipatedFailure, reportError, } from '@williamthorsen/nmr-core';
+import { BIN } from "./bin.js";
 import { detectRepoType } from "./init/detectRepoType.js";
 import { loadValidatedConfig, reportConfigProblem } from "./loadValidatedConfig.js";
 import { previewTagPrefixes } from "./previewTagPrefixes.js";
@@ -20,7 +21,7 @@ export async function showTagPrefixesCommand(styles, configPath) {
         if (!isAnticipatedFailure(error)) {
             throw error;
         }
-        reportError(error.message);
+        reportError(BIN, error.message);
         return 1;
     }
     process.stdout.write(renderMonorepo(preview, styles.stdout));

package/dist/esm/sync-labels/generateCommand.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { isAnticipatedFailure, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { stringify } from 'yaml';
+import { BIN } from "../bin.js";
 import { CONFIG_FILE_PATH } from "../loadConfig.js";
 import { loadValidatedConfig, reportConfigProblem } from "../loadValidatedConfig.js";
 import { hashPreset } from "./presets.js";
@@ -28,7 +29,7 @@ export function formatLabelsYaml(labels, presetHashes, configFilePath = CONFIG_F
 export async function loadRepoLabelsConfig(stderrStyle, configPath) {
     const result = await loadValidatedConfig(configPath);
     if (result.status === 'missing') {
-        reportError(`Config file not found at ${result.configFilePath}. Run \`release-kit sync-labels init\` first.`);
+        reportError(BIN, `Config file not found at ${result.configFilePath}. Run \`release-kit sync-labels init\` first.`);
         return undefined;
     }
     if (result.status === 'invalid') {
@@ -36,7 +37,7 @@ export async function loadRepoLabelsConfig(stderrStyle, configPath) {
         return undefined;
     }
     if (result.config.repoLabels === undefined) {
-        reportError(`The \`repoLabels\` block is missing from ${result.configFilePath}. Run \`release-kit sync-labels init\` to seed one.`);
+        reportError(BIN, `The \`repoLabels\` block is missing from ${result.configFilePath}. Run \`release-kit sync-labels init\` to seed one.`);
         return undefined;
     }
     return result.config.repoLabels;
@@ -58,7 +59,7 @@ export async function generateCommand({ shouldCheck = false, configPath, styles
             throw error;
         }
         const message = describeError(error);
-        reportError(`Failed to resolve labels: ${message}`);
+        reportError(BIN, `Failed to resolve labels: ${message}`);
         return 1;
     }
     const presetHashes = new Map();
@@ -76,7 +77,7 @@ export async function generateCommand({ shouldCheck = false, configPath, styles
     }
     catch (error) {
         const message = describeError(error);
-        reportError(`Failed to write ${LABELS_OUTPUT_PATH}: ${message}`);
+        reportError(BIN, `Failed to write ${LABELS_OUTPUT_PATH}: ${message}`);
         return 1;
     }
     console.info(`Generated ${LABELS_OUTPUT_PATH} with ${String(labels.length)} labels.`);
@@ -88,11 +89,11 @@ function compareAgainstCommittedFile(expectedContent) {
         existingContent = readFileSync(LABELS_OUTPUT_PATH, 'utf8');
     }
     catch {
-        reportError(`${LABELS_OUTPUT_PATH} is missing. Run \`release-kit sync-labels generate\` and commit the result.`);
+        reportError(BIN, `${LABELS_OUTPUT_PATH} is missing. Run \`release-kit sync-labels generate\` and commit the result.`);
         return 1;
     }
     if (existingContent !== expectedContent) {
-        reportError(`${LABELS_OUTPUT_PATH} is stale. Run \`release-kit sync-labels generate\` and commit the result.`);
+        reportError(BIN, `${LABELS_OUTPUT_PATH} is stale. Run \`release-kit sync-labels generate\` and commit the result.`);
         return 1;
     }
     console.info(`${LABELS_OUTPUT_PATH} is up to date.`);

package/dist/esm/sync-labels/presets.js

@@ -2,9 +2,8 @@ import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { CANONICAL_TAXONOMY } from '@williamthorsen/change-grammar';
-import { findPackageRoot, UserError } from '@williamthorsen/nmr-core';
+import { findPackageRoot, isRecord, UserError } from '@williamthorsen/nmr-core';
 import { parse } from 'yaml';
-import { isRecord } from "../typeGuards.js";
 import { chainUserError } from "../user-error-chaining.js";
 import { deriveTypeLabels } from "./typeLabels.js";
 const TYPE_LABELS_PRESET = 'common';

package/dist/esm/sync-labels/retiredConfig.js

@@ -1,11 +1,12 @@
 import { existsSync } from 'node:fs';
 import { reportError } from '@williamthorsen/nmr-core';
+import { BIN } from "../bin.js";
 import { CONFIG_FILE_PATH } from "../loadConfig.js";
 export const RETIRED_SYNC_LABELS_CONFIG_PATH = '.config/sync-labels.config.ts';
 export function checkRetiredSyncLabelsConfig(configPath = CONFIG_FILE_PATH) {
     if (!existsSync(RETIRED_SYNC_LABELS_CONFIG_PATH)) {
         return false;
     }
-    reportError(`${RETIRED_SYNC_LABELS_CONFIG_PATH} is no longer read. Move its labels into the \`repoLabels\` block of ${configPath} (presets move to \`repoLabels.extends\`; each label becomes a \`'name': { color, description }\` entry under \`repoLabels.labels\`), then delete the file.`);
+    reportError(BIN, `${RETIRED_SYNC_LABELS_CONFIG_PATH} is no longer read. Move its labels into the \`repoLabels\` block of ${configPath} (presets move to \`repoLabels.extends\`; each label becomes a \`'name': { color, description }\` entry under \`repoLabels.labels\`), then delete the file.`);
     return true;
 }

package/dist/esm/sync-labels/syncCommand.js

@@ -2,6 +2,7 @@ import { execSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { GIT_OUTPUT_LIMIT_BYTES, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
+import { BIN } from "../bin.js";
 import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
 const WORKFLOW_FILE = '.github/workflows/sync-labels.yaml';
 function checkGhAvailable() {
@@ -18,11 +19,11 @@ export function syncLabelsCommand() {
         return 1;
     }
     if (!checkGhAvailable()) {
-        reportError('The `gh` CLI is not installed or not in PATH. Install it from https://cli.github.com/');
+        reportError(BIN, 'The `gh` CLI is not installed or not in PATH. Install it from https://cli.github.com/');
         return 1;
     }
     if (!existsSync(WORKFLOW_FILE)) {
-        reportError(`${WORKFLOW_FILE} not found. Run \`release-kit sync-labels init\` first.`);
+        reportError(BIN, `${WORKFLOW_FILE} not found. Run \`release-kit sync-labels init\` first.`);
         return 1;
     }
     try {
@@ -30,7 +31,7 @@ export function syncLabelsCommand() {
     }
     catch (error) {
         const message = describeError(error);
-        reportError(`Failed to trigger workflow: ${message}`);
+        reportError(BIN, `Failed to trigger workflow: ${message}`);
         return 1;
     }
     console.info('Workflow triggered successfully. View runs at: gh run list --workflow=sync-labels.yaml');

package/dist/esm/tagCommand.d.ts

@@ -1,3 +1,8 @@
-import { type StreamStyles } from '@williamthorsen/nmr-core';
-/** Runs the CLI `tag` command: parses flags and delegates to `createTags`. */
-export declare function tagCommand(argv: string[], styles: StreamStyles): void;
+import type { StreamStyles } from '@williamthorsen/nmr-core';
+export interface TagCommandOptions {
+    isDryRun: boolean;
+    shouldSkipGitChecks: boolean;
+    styles: StreamStyles;
+}
+/** Runs the CLI `tag` command by delegating to `createTags`. */
+export declare function tagCommand({ isDryRun, shouldSkipGitChecks, styles }: TagCommandOptions): void;

package/dist/esm/tagCommand.js

@@ -1,10 +1,4 @@
-import { parseArgsOrExit } from '@williamthorsen/nmr-core';
 import { createTags } from "./createTags.js";
-const tagFlagSchema = {
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-    shouldSkipGitChecks: { long: '--no-git-checks', type: 'boolean' },
-};
-export function tagCommand(argv, styles) {
-    const { isDryRun, shouldSkipGitChecks } = parseArgsOrExit(argv, tagFlagSchema).flags;
+export function tagCommand({ isDryRun, shouldSkipGitChecks, styles }) {
     createTags({ isDryRun, shouldSkipGitChecks, style: styles.stdout });
 }

package/dist/esm/typeGuards.d.ts

@@ -1,4 +1,2 @@
-/** Checks whether a value is a plain object (non-null, non-array). */
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
 /** Narrows an `unknown` value to `unknown[]` via `Array.isArray`, avoiding `any[]`. */
 export declare function isUnknownArray(value: unknown): value is unknown[];

package/dist/esm/typeGuards.js

@@ -1,6 +1,3 @@
-export function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 export function isUnknownArray(value) {
     return Array.isArray(value);
 }

package/dist/esm/validateConfig.js

@@ -1,5 +1,5 @@
+import { isRecord } from '@williamthorsen/nmr-core';
 import { releaseKitConfigSchema } from "./configSchema.js";
-import { isRecord } from "./typeGuards.js";
 export function validateConfig(rawConfig) {
     if (!isRecord(rawConfig)) {
         return { config: {}, errors: ['Config must be an object'], warnings: [] };