@williamthorsen/release-kit 16.1.1 → 17.0.0

package/dist/esm/packFromCleanCheckout.js

@@ -2,8 +2,9 @@ import { spawnSync } from 'node:child_process';
 import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { isRecord, UserError } from '@williamthorsen/nmr-core';
 import { resolveExecutable } from "./detectPackageManager.js";
-import { isRecord } from "./typeGuards.js";
+import { chainUserError } from "./user-error-chaining.js";
 export function packFromCleanCheckout(workspacePaths, packageManager) {
     const repoRoot = runStep('find the repository root', 'git', ['rev-parse', '--show-toplevel'], process.cwd()).trim();
     const headSha = runStep('resolve HEAD', 'git', ['rev-parse', 'HEAD'], repoRoot).trim();
@@ -51,7 +52,14 @@ const PACKAGE_MANAGER_COMMANDS = {
     },
 };
 function declaresPrepublishOnly(packageDir) {
-    const manifest = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'));
+    const manifestPath = join(packageDir, 'package.json');
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        throw chainUserError(`Failed to parse ${manifestPath}`, error);
+    }
     const scripts = isRecord(manifest) ? manifest['scripts'] : undefined;
     return isRecord(scripts) && typeof scripts['prepublishOnly'] === 'string';
 }
@@ -59,7 +67,7 @@ function findTarball(packDir, workspacePath) {
     const tarballs = readdirSync(packDir).filter((name) => name.endsWith('.tgz'));
     const [tarball] = tarballs;
     if (tarballs.length !== 1 || tarball === undefined) {
-        throw new Error(`Could not pack ${workspacePath}: expected one tarball, found ${tarballs.length}.`);
+        throw new UserError(`Could not pack ${workspacePath}: expected one tarball, found ${tarballs.length}.`);
     }
     return join(packDir, tarball);
 }
@@ -77,5 +85,5 @@ function runStep(step, command, args, cwd) {
     }
     const outcome = result.error === undefined ? `exited with status ${result.status}` : result.error.message;
     const output = [result.stdout, result.stderr].filter((text) => text !== '').join('\n');
-    throw new Error(`Could not ${step}: \`${[command, ...args].join(' ')}\` ${outcome}.${output === '' ? '' : `\n${output}`}`);
+    throw new UserError(`Could not ${step}: \`${[command, ...args].join(' ')}\` ${outcome}.${output === '' ? '' : `\n${output}`}`);
 }

package/dist/esm/parseChangeRecordBlock.js

@@ -1,5 +1,5 @@
+import { isRecord } from '@williamthorsen/nmr-core';
 import { parseDocument } from 'yaml';
-import { isRecord } from "./typeGuards.js";
 export function parseChangeRecordBlock(message) {
     const lines = message.split(/\r?\n/);
     const fence = findFences(lines).at(-1);

package/dist/esm/planVersionBump.js

@@ -1,7 +1,8 @@
 import { readFileSync } from 'node:fs';
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { UserError } from '@williamthorsen/nmr-core';
 import { bumpVersion } from "./bumpVersion.js";
 import { isForwardVersion } from "./compareVersions.js";
+import { chainUserError } from "./user-error-chaining.js";
 function isPackageJson(value) {
     return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
@@ -19,7 +20,7 @@ export function planVersionSet(packageFiles, newVersion) {
     const { firstFile, firstPackageJson } = readPrimaryPackage(packageFiles);
     const currentVersion = firstPackageJson.version;
     if (!isForwardVersion(currentVersion, newVersion)) {
-        throw new Error(`--set-version ${newVersion} is not greater than current version ${currentVersion}`);
+        throw new UserError(`--set-version ${newVersion} is not greater than current version ${currentVersion}`);
     }
     return {
         currentVersion,
@@ -50,17 +51,17 @@ function readPackageJson(filePath) {
         content = readFileSync(filePath, 'utf8');
     }
     catch (error) {
-        throw chainError(`Failed to read ${filePath}`, error);
+        throw chainUserError(`Failed to read ${filePath}`, error);
     }
     let parsedJson;
     try {
         parsedJson = JSON.parse(content);
     }
     catch (error) {
-        throw chainError(`Failed to parse JSON in ${filePath}`, error);
+        throw chainUserError(`Failed to parse JSON in ${filePath}`, error);
     }
     if (!isPackageJson(parsedJson)) {
-        throw new Error(`No valid 'version' field found in ${filePath}`);
+        throw new UserError(`No valid 'version' field found in ${filePath}`);
     }
     return parsedJson;
 }

package/dist/esm/prepareArgs.d.ts

@@ -1,55 +1,7 @@
-import type { ReleaseType } from './types.js';
 /** Canonical `N.N.N` semver pattern for validating `--set-version` input. */
 export declare const CANONICAL_SEMVER_PATTERN: RegExp;
-export declare const prepareFlagSchema: {
-    isDryRun: {
-        long: string;
-        type: "boolean";
-    };
-    shouldForce: {
-        long: string;
-        type: "boolean";
-    };
-    shouldSkipGitChecks: {
-        long: string;
-        type: "boolean";
-        short: string;
-    };
-    bump: {
-        long: string;
-        type: "string";
-    };
-    setVersion: {
-        long: string;
-        type: "string";
-    };
-    only: {
-        long: string;
-        type: "string";
-    };
-    shouldIncludeReleaseNotes: {
-        long: string;
-        type: "boolean";
-    };
-    config: {
-        long: string;
-        type: "string";
-    };
-};
-/** Parses CLI arguments into structured options. Prints a usage error and exits on invalid input. */
-export declare function parseArgs(argv: string[]): {
-    configPath: string | undefined;
-    isDryRun: boolean;
-    shouldForce: boolean;
-    shouldSkipGitChecks: boolean;
-    bumpOverride: ReleaseType | undefined;
-    onlyNames: string[] | undefined;
-    /** The raw `--set-version` value, whose accepted form depends on the mode. */
-    setVersion: string | undefined;
-    shouldIncludeReleaseNotes: boolean;
-};
 /**
  * Parses a monorepo `--set-version` value, a comma-separated list of `<target>@N.N.N` entries, into versions keyed by
- * target name. Prints a usage error and exits on a malformed entry, an unknown target, or a repeated one.
+ * target name. Throws a `UsageError` for a malformed entry, an unknown target, or a repeated one.
  */
 export declare function parseSetVersions(value: string, knownNames: readonly string[]): Map<string, string>;

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, reportError } 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,16 +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";
-export async function prepareCommand(argv, styles, invocationDir) {
-    const { configPath: configFlag, isDryRun, shouldForce, shouldSkipGitChecks, bumpOverride, onlyNames, setVersion, shouldIncludeReleaseNotes, } = parseArgs(argv);
+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({ bumpOverride, configPath, isDryRun, onlyNames, setVersion, shouldForce, shouldIncludeReleaseNotes, shouldSkipGitChecks, styles, }) {
     const options = {
         shouldForce,
         ...(bumpOverride !== undefined && { bumpOverride }),
@@ -26,18 +27,11 @@ export async function prepareCommand(argv, styles, invocationDir) {
         console.info(`\n${formatGlyphLine(RELEASE_GLYPHS, styles.stdout, 'dryRun', 'DRY RUN: release-kit will not modify any files')}\n`);
     }
     if (!isDryRun && !shouldSkipGitChecks) {
-        try {
-            assertCleanWorkingTree();
-        }
-        catch (error) {
-            reportError(describeError(error));
-            process.exit(1);
-        }
+        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') {
@@ -49,14 +43,12 @@ export async function prepareCommand(argv, styles, invocationDir) {
         workspaceDiscovery = discoverWorkspaces();
     }
     catch (error) {
-        reportError(`Failed to discover workspaces: ${describeError(error)}`);
-        process.exit(1);
+        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 }),
@@ -74,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);
     }
@@ -91,14 +81,12 @@ function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
         config = resolveReleaseTargets(userConfig, discovery);
     }
     catch (error) {
-        reportError(`Failed to resolve workspaces: ${describeError(error)}`);
-        process.exit(1);
+        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 ?? [];
@@ -106,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;
 }
@@ -129,31 +116,26 @@ function runAndReport(computePlan, isDryRun, style) {
         plan = computePlan();
     }
     catch (error) {
-        reportError(describeError(error));
-        process.stderr.write('The command did not write any files; the working tree is unchanged.\n');
-        process.exit(1);
+        if (isAnticipatedFailure(error)) {
+            throw new UserError(`${error.message}\n${UNCHANGED_TREE_NOTE}`, { cause: error });
+        }
+        process.stderr.write(`${UNCHANGED_TREE_NOTE}\n`);
+        throw error;
     }
     if (isDryRun) {
         process.stdout.write(reportPrepare(plan, { applied: false, style }) + '\n');
         reportPlanFiles(plan, true);
         return;
     }
-    try {
-        applyReleasePlan(plan);
-    }
-    catch (error) {
-        reportError(describeError(error));
-        process.exit(1);
-    }
+    applyReleasePlan(plan);
     const formatError = runFormatCommand(plan.formatCommand);
     process.stdout.write(reportPrepare(plan, { applied: true, style, ...(formatError !== undefined && { formatError }) }) + '\n');
     reportPlanFiles(plan, false);
     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/prepareComposite.js

@@ -1,3 +1,4 @@
+import { UserError } from '@williamthorsen/nmr-core';
 import { assertTaggedBaseline } from "./assertTaggedBaseline.js";
 import { collect } from "./prepareRunContext.js";
 import { buildSkippedTargetResult, decideTargetRelease, planTargetRelease, readTargetHistory, } from "./prepareTarget.js";
@@ -24,7 +25,7 @@ export function prepareComposite(compositeTarget, context, options, collectedRel
         return buildSkippedTargetResult(compositeTarget, history, decision.skipReason);
     }
     if (decision.setVersion !== undefined) {
-        throw new Error('A composite target cannot take --set-version');
+        throw new UserError('A composite target cannot take --set-version');
     }
     const plannedRelease = planTargetRelease({
         ...context,

package/dist/esm/prepareRunContext.js

@@ -1,5 +1,5 @@
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { isRepoRoot } from "./prepareTarget.js";
+import { prefixUserError } from "./user-error-chaining.js";
 export function collect(collectedReleases, plannedRelease) {
     collectedReleases.tags.push(plannedRelease.tag);
     collectedReleases.writes.push(...plannedRelease.writes);
@@ -34,6 +34,6 @@ export function runStage(stage, fn) {
         return fn();
     }
     catch (error) {
-        throw chainError(stage, error);
+        throw prefixUserError(stage, error);
     }
 }

package/dist/esm/previewTagPrefixes.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { basename } from 'node:path';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES, UserError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { DEFAULT_PROJECT_TAG_PREFIX } from "./defaults.js";
 import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
@@ -12,7 +12,7 @@ import { normalizeWorkspacePath } from "./resolveReleaseDeclaration.js";
 export function previewTagPrefixes(config) {
     const workspace = discoverWorkspaces();
     if (workspace.kind === 'empty') {
-        throw new Error(`No workspace package to preview. ${describeEmptyWorkspace(workspace)}`);
+        throw new UserError(`No workspace package to preview. ${describeEmptyWorkspace(workspace)}`);
     }
     const workspacePaths = workspace.kind === 'packages' ? workspace.packageDirs : [];
     const overridesByPath = buildOverrideMap(config, workspacePaths);

package/dist/esm/publish.js

@@ -1,11 +1,17 @@
 import { execFileSync } from 'node:child_process';
 import { resolveExecutable } from "./detectPackageManager.js";
+import { asUserError } from "./user-error-chaining.js";
 export function publishPackage(resolvedTag, packageManager, options) {
     const { isDryRun, shouldGenerateProvenance } = options;
     const executable = resolveExecutable(packageManager);
     const args = buildPublishArgs(packageManager, { isDryRun, shouldGenerateProvenance });
     console.info(`\n${isDryRun ? '[dry-run] ' : ''}Running: ${executable} ${args.join(' ')} (cwd: ${resolvedTag.workspacePath})`);
-    execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: 'inherit' });
+    try {
+        execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: 'inherit' });
+    }
+    catch (error) {
+        throw asUserError(error);
+    }
 }
 function buildPublishArgs(packageManager, options) {
     const args = packageManager === 'yarn-berry' ? ['npm', 'publish'] : ['publish'];

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,10 +1,7 @@
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
 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";
@@ -12,32 +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) {
-        try {
-            assertCleanWorkingTree();
-        }
-        catch (error) {
-            reportError(describeError(error));
-            process.exit(1);
-        }
+        assertCleanWorkingTree();
     }
-    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     if (resolvedTags.length === 0) {
         return;
@@ -47,13 +25,7 @@ export async function publishCommand(argv, styles, invocationDir) {
         console.info('Nothing to publish.');
         return;
     }
-    try {
-        assertTarballsComplete(publishableTags.map(({ workspacePath }) => workspacePath), userConfig?.devExportConditions ?? []);
-    }
-    catch (error) {
-        reportError(describeError(error));
-        process.exit(1);
-    }
+    assertTarballsComplete(publishableTags.map(({ workspacePath }) => workspacePath), userConfig?.devExportConditions ?? []);
     const packageManager = detectPackageManager();
     const { releaseNotes, changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     const shouldInject = releaseNotes.shouldInjectIntoReadme;
@@ -90,8 +62,7 @@ export async function publishCommand(argv, styles, invocationDir) {
                 console.warn(`  ${tag}`);
             }
         }
-        reportError(describeError(error));
-        process.exit(1);
+        throw error;
     }
 }
 function filterPublishableTags(resolvedTags, isExplicit) {

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,24 +1,9 @@
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
-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;
     }
@@ -32,16 +17,10 @@ export async function pushCommand(argv, styles, invocationDir) {
     for (const { tag } of resolvedTags) {
         console.info(`  ${tag}`);
     }
-    try {
-        const steps = pushRelease(resolvedTags, { isDryRun, tagsOnly });
-        if (isDryRun) {
-            for (const step of steps) {
-                console.info(`[dry-run] ${step.command.join(' ')}`);
-            }
+    const steps = pushRelease(resolvedTags, { isDryRun, tagsOnly });
+    if (isDryRun) {
+        for (const step of steps) {
+            console.info(`[dry-run] ${step.command.join(' ')}`);
         }
     }
-    catch (error) {
-        reportError(describeError(error));
-        process.exit(1);
-    }
 }