@williamthorsen/release-kit 18.2.0 → 18.3.0

package/dist/esm/loadConfig.js

@@ -6,31 +6,18 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { isRecord, UserError } from '@williamthorsen/nmr-core';
-import { chainUserError } from "./user-error-chaining.js";
+import { readJsonFile } from "./readJsonFile.js";
 export const ROOT_PACKAGE_JSON_PATH = 'package.json';
 export function readRootPackageVersion() {
     const absolutePath = path.resolve(process.cwd(), ROOT_PACKAGE_JSON_PATH);
     if (!existsSync(absolutePath)) {
         return { doesExist: false, version: undefined };
     }
-    let contents;
-    try {
-        contents = readFileSync(absolutePath, 'utf8');
-    }
-    catch (error) {
-        throw chainUserError(`Failed to read root ${ROOT_PACKAGE_JSON_PATH}`, error);
-    }
-    let parsedJson;
-    try {
-        parsedJson = JSON.parse(contents);
-    }
-    catch (error) {
-        throw chainUserError(`Failed to parse root ${ROOT_PACKAGE_JSON_PATH}`, error);
-    }
+    const parsedJson = readJsonFile(ROOT_PACKAGE_JSON_PATH);
     if (!isRecord(parsedJson)) {
         return { doesExist: true, version: undefined };
     }

package/dist/esm/mergeConfig.d.ts

@@ -9,7 +9,8 @@ import type { MonorepoReleaseConfig, ReleaseSettings, WorkTypeConfig } from './t
  *   directories that `releases` declares resolve through `deriveDirectoryConfig` into `directories`, which must not
  *   share a version file with any other target.
  * - `workTypes`: Shallow merge; consumer entries override or add to defaults by key.
- * - `versionPatterns`: Consumer value replaces defaults entirely.
+ * - `versionPatterns`: Consumer value replaces defaults entirely, except that an omitted `none` takes its default in
+ *   `determineBumpType`.
  * - Pass-through fields (see `applyOptionalPassthroughFields`): Consumer value wins.
  * - `project`: Present iff the config declares a composite. Resolves `tagPrefix` to `DEFAULT_PROJECT_TAG_PREFIX` and
  *   `paths` to the union of its members' `paths` when omitted. Requires `rootPackage` to be passed and to contain a

package/dist/esm/packFromCleanCheckout.js

@@ -1,10 +1,10 @@
 import { spawnSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readdirSync, 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 { chainUserError } from "./user-error-chaining.js";
+import { readJsonFile } from "./readJsonFile.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();
@@ -53,13 +53,7 @@ const PACKAGE_MANAGER_COMMANDS = {
 };
 function declaresPrepublishOnly(packageDir) {
     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 manifest = readJsonFile(manifestPath);
     const scripts = isRecord(manifest) ? manifest['scripts'] : undefined;
     return isRecord(scripts) && typeof scripts['prepublishOnly'] === 'string';
 }

package/dist/esm/planVersionBump.js

@@ -1,8 +1,7 @@
-import { readFileSync } from 'node:fs';
 import { UserError } from '@williamthorsen/nmr-core';
 import { bumpVersion } from "./bumpVersion.js";
 import { isForwardVersion } from "./compareVersions.js";
-import { chainUserError } from "./user-error-chaining.js";
+import { readJsonFile } from "./readJsonFile.js";
 function isPackageJson(value) {
     return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
@@ -46,20 +45,7 @@ function renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersi
     });
 }
 function readPackageJson(filePath) {
-    let content;
-    try {
-        content = readFileSync(filePath, 'utf8');
-    }
-    catch (error) {
-        throw chainUserError(`Failed to read ${filePath}`, error);
-    }
-    let parsedJson;
-    try {
-        parsedJson = JSON.parse(content);
-    }
-    catch (error) {
-        throw chainUserError(`Failed to parse JSON in ${filePath}`, error);
-    }
+    const parsedJson = readJsonFile(filePath);
     if (!isPackageJson(parsedJson)) {
         throw new UserError(`No valid 'version' field found in ${filePath}`);
     }

package/dist/esm/prepareCommand.js

@@ -7,6 +7,7 @@ import { assertReleasesOnNpm } from "./assertReleasesOnNpm.js";
 import { assertTarballsComplete } from "./assertTarballsComplete.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
+import { realGit } from "./git.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { ConfigProblemError, loadValidatedConfig, reportConfigWarnings } from "./loadValidatedConfig.js";
 import { CANONICAL_SEMVER_PATTERN, parseSetVersions } from "./prepareArgs.js";
@@ -55,7 +56,7 @@ export async function prepareCommand({ bumpOverride, configPath, isDryRun, onlyN
         ...(setVersion !== undefined && { versionOverridesById: resolveSetVersions(setVersion, config.targets) }),
     };
     runAndReport(() => {
-        const plan = prepareReleaseTargets(config, targetOptions);
+        const plan = prepareReleaseTargets(config, targetOptions, realGit);
         const releasedPackagePaths = findReleasedPackagePaths(plan, config.targets);
         assertReleasesOnNpm(releasedPackagePaths);
         assertTarballsComplete(releasedPackagePaths, userConfig?.devExportConditions ?? []);

package/dist/esm/prepareComposite.js

@@ -14,7 +14,7 @@ export function describeCompositeSkip(compositeTarget, onlyNames) {
     return `Release '${compositeTarget.id}' skipped: --only does not name it. Add ${compositeTarget.id} to --only to include it.`;
 }
 export function prepareComposite(compositeTarget, context, options, collectedReleases, warnings) {
-    const { history, untaggedBaseline } = readTargetHistory(compositeTarget, context.settings);
+    const { history, untaggedBaseline } = readTargetHistory(compositeTarget, context.settings, context.git);
     assertTaggedBaseline([untaggedBaseline]);
     const decision = decideTargetRelease(compositeTarget, history, {
         shouldForce: options.shouldForce === true,

package/dist/esm/prepareReleaseTargets.d.ts

@@ -1,3 +1,4 @@
+import type { Git } from './git.js';
 import { type TargetPrepareSettings } from './prepareTarget.js';
 import type { ReleasePlan } from './releasePlan.js';
 import type { ReleaseTarget, ReleaseType } from './types.js';
@@ -44,4 +45,4 @@ export interface TargetPrepareOptions {
  * 5. Prepares each composite after every package target, unless `onlyTargetIds` narrowed the run without naming it.
  * 6. Renders the format command over the modified files.
  */
-export declare function prepareReleaseTargets(config: TargetPrepareConfig, options: TargetPrepareOptions): ReleasePlan;
+export declare function prepareReleaseTargets(config: TargetPrepareConfig, options: TargetPrepareOptions, git: Git): ReleasePlan;

package/dist/esm/prepareReleaseTargets.js

@@ -15,7 +15,7 @@ import { propagateBumps } from "./propagateBumps.js";
 import { isSinglePackageTargets } from "./resolveReleaseTargets.js";
 import { sortTopologically } from "./topologicalSort.js";
 const PREVIEWS_REQUIRE_JSON_WARNING = '--with-release-notes requires changelogJson.enabled; skipping preview generation';
-export function prepareReleaseTargets(config, options) {
+export function prepareReleaseTargets(config, options, git) {
     const { settings } = config;
     const { onlyTargetIds, shouldIncludeReleaseNotes } = options;
     const isSinglePackage = isSinglePackageTargets(config.targets);
@@ -33,13 +33,14 @@ export function prepareReleaseTargets(config, options) {
     const workTypes = resolveWorkTypes(settings.workTypes);
     const context = {
         settings,
+        git,
         overrideContext: createOverrideContext(plannedTargets.flatMap(listOverrideDirectory)),
         sectionOrder: deriveSectionOrder(workTypes),
         dependenciesHeader: deriveDependenciesHeader(workTypes),
         shouldPlanPreviews: shouldIncludeReleaseNotes === true && settings.changelogJson.enabled,
         today: new Date().toISOString().slice(0, 10),
     };
-    const directReleases = decideDirectReleases(plannedTargets, settings, options, startIds);
+    const directReleases = decideDirectReleases(plannedTargets, settings, options, startIds, git);
     if (!isSinglePackage) {
         reportUnroutedEntryScopes(plannedTargets, directReleases, settings, memberTargets);
     }

package/dist/esm/prepareRunContext.d.ts

@@ -1,5 +1,6 @@
 import type { ReleaseHistory } from './buildChangelogEntries.js';
 import type { OverrideContext } from './changelogOverrides.js';
+import type { Git } from './git.js';
 import { type TargetPrepareSettings } from './prepareTarget.js';
 import type { PlannedWrite } from './releasePlan.js';
 import type { DirectoryTarget, PackageTarget, ReleaseTarget } from './types.js';
@@ -28,6 +29,7 @@ export declare function readHistory(readings: ReadonlyMap<string, ReleaseHistory
 /** What every target's planning reads from the run. */
 export interface RunContext {
     settings: TargetPrepareSettings;
+    git: Git;
     overrideContext: OverrideContext;
     sectionOrder: string[];
     dependenciesHeader: string;

package/dist/esm/prepareTarget.d.ts

@@ -3,6 +3,7 @@ import { type ReleaseHistory } from './buildChangelogEntries.js';
 import { type TargetRelease } from './buildReleasedResult.js';
 import { type OverrideContext } from './changelogOverrides.js';
 import { type GenerateChangelogOptions } from './generateChangelogs.js';
+import type { Git } from './git.js';
 import type { PlannedWrite } from './releasePlan.js';
 import type { DirectoryTarget, ReleasedTargetResult, ReleaseSettings, ReleaseTarget, ReleaseType, TargetPrepareResult } from './types.js';
 /** The shared settings that the prepare step reads, which do not include the release-notes settings. */
@@ -68,7 +69,7 @@ export interface PlannedTargetRelease {
     warnings: string[];
 }
 /** Reads a target's release windows under its tag prefixes and commit window, and finds its untagged baseline. */
-export declare function readTargetHistory(target: ReleaseTarget, settings: TargetPrepareSettings): TargetReading;
+export declare function readTargetHistory(target: ReleaseTarget, settings: TargetPrepareSettings, git: Git): TargetReading;
 /**
  * Returns the bounds of a target's history read: its current and legacy tag prefixes, its commit window, and, for a
  * workspace or a directory other than the repo root, the scope to which change-record entries route, which is its name.
@@ -87,9 +88,10 @@ export declare function decideTargetRelease(target: ReleaseTarget, history: Rele
  * Plans a target's release: the version bump, the changelogs, and the release-notes previews, and builds its result.
  *
  * The changelog entries come from the target's release windows, with the synthetic "Forced version bump." entry for a
- * window that doesn't yield any item, or, for a release that propagation alone set, from one synthetic entry listing
- * the dependencies. Overrides apply before `changelog.json` and `CHANGELOG.md` render from the merged set, and
- * `CHANGELOG.md` keeps the existing sections whose versions the merged set lacks.
+ * window that doesn't yield any item, or, for a release that propagation alone set, from the window's entries with the
+ * dependencies added to the new version's entry, or one synthetic entry listing them when the window doesn't yield any
+ * item. Overrides apply before `changelog.json` and `CHANGELOG.md` render from the merged set, and `CHANGELOG.md`
+ * keeps the existing sections whose versions the merged set lacks.
  */
 export declare function planTargetRelease(args: PlanTargetReleaseArgs): PlannedTargetRelease;
 /** Builds the result of a target that skips, from the window that its read produced. */

package/dist/esm/prepareTarget.js

@@ -9,9 +9,9 @@ import { planChangelogFiles } from "./planChangelogFiles.js";
 import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
 import { planVersionBump, planVersionSet } from "./planVersionBump.js";
 import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
-export function readTargetHistory(target, settings) {
+export function readTargetHistory(target, settings, git) {
     const options = describeHistoryWindow(target);
-    const history = readReleaseHistory(settings, options);
+    const history = readReleaseHistory(settings, options, git);
     const untaggedBaseline = findUntaggedBaseline({
         label: describeBaselineLabel(target),
         packageFiles: target.versionFiles,
@@ -60,7 +60,13 @@ export function planTargetRelease(args) {
     const tag = `${target.tagPrefix}${bumpPlan.newVersion}`;
     const writes = [...bumpPlan.writes];
     const entries = decision === undefined
-        ? buildPropagationEntries(target, release, bumpPlan.newVersion, today, args.dependenciesHeader)
+        ? buildPropagationEntries(target, release, {
+            history,
+            tag,
+            newVersion: bumpPlan.newVersion,
+            today,
+            dependenciesHeader: args.dependenciesHeader,
+        })
         : convertToReleaseEntries(history, tag, today);
     const overrideScope = describeOverrideScope(target);
     const appliedOverrides = applyWorkspaceOverrides(entries, overrideScope, overrideContext);

package/dist/esm/previewTagPrefixes.d.ts

@@ -1,5 +1,6 @@
 import type { ReleaseKitConfig } from './configSchema.js';
 import { type UndeclaredTagPrefix } from './detectUndeclaredTagPrefixes.js';
+import { type Git } from './git.js';
 /** One workspace's or directory target's preview row in the tag-prefix preview. */
 export interface TagPrefixPreviewRow {
     /** Directory path relative to the repo root (e.g., `packages/core`). */
@@ -56,4 +57,4 @@ export interface TagPrefixPreview {
  * tags, and collisions across the successfully derived prefixes. A declared composite's tag prefix counts as known, so
  * that its tags are not reported as undeclared.
  */
-export declare function previewTagPrefixes(config?: ReleaseKitConfig): TagPrefixPreview;
+export declare function previewTagPrefixes(config?: ReleaseKitConfig, git?: Git): TagPrefixPreview;

package/dist/esm/previewTagPrefixes.js

@@ -1,15 +1,15 @@
-import { execFileSync } from 'node:child_process';
 import { basename } from 'node:path';
-import { GIT_OUTPUT_LIMIT_BYTES, UserError } from '@williamthorsen/nmr-core';
+import { UserError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { DEFAULT_PROJECT_TAG_PREFIX } from "./defaults.js";
 import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
+import { realGit } from "./git.js";
 import { matchesTagPrefix } from "./matchesTagPrefix.js";
 import { normalizeWorkspacePath } from "./resolveReleaseDeclaration.js";
-export function previewTagPrefixes(config) {
+export function previewTagPrefixes(config, git = realGit) {
     const workspace = discoverWorkspaces();
     if (workspace.kind === 'empty') {
         throw new UserError(`No workspace package to preview. ${describeEmptyWorkspace(workspace)}`);
@@ -17,13 +17,13 @@ export function previewTagPrefixes(config) {
     const workspacePaths = workspace.kind === 'packages' ? workspace.packageDirs : [];
     const overridesByPath = buildOverrideMap(config, workspacePaths);
     const workspaces = [
-        ...Array.from(workspacePaths, (workspacePath) => buildPreviewRow(workspacePath, null, () => deriveWorkspaceConfig(workspacePath), overridesByPath)),
-        ...buildDirectoryRows(config, workspacePaths, overridesByPath),
+        ...Array.from(workspacePaths, (workspacePath) => buildPreviewRow(workspacePath, null, () => deriveWorkspaceConfig(workspacePath), overridesByPath, git)),
+        ...buildDirectoryRows(config, workspacePaths, overridesByPath, git),
     ];
-    const retiredPackages = buildRetiredPreviewEntries(config?.retiredPackages ?? []);
+    const retiredPackages = buildRetiredPreviewEntries(config?.retiredPackages ?? [], git);
     const collisions = detectCollisions(workspaces);
     const knownPrefixes = collectKnownPrefixes(workspaces, retiredPackages, findCompositeTagPrefix(config));
-    const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes);
+    const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes, git);
     return { workspaces, collisions, undeclaredCandidates, retiredPackages };
 }
 function buildOverrideMap(config, workspacePaths) {
@@ -46,7 +46,7 @@ function buildOverrideMap(config, workspacePaths) {
     }
     return map;
 }
-function buildDirectoryRows(config, workspacePaths, overridesByPath) {
+function buildDirectoryRows(config, workspacePaths, overridesByPath, git) {
     const discoveredPaths = new Set(workspacePaths);
     return Object.entries(config?.releases ?? {}).flatMap(([name, entry]) => {
         if (entry === false || !('path' in entry))
@@ -59,10 +59,10 @@ function buildDirectoryRows(config, workspacePaths, overridesByPath) {
             path: directoryPath,
             ...(entry.tagPrefix !== undefined && { tagPrefix: entry.tagPrefix }),
         };
-        return [buildPreviewRow(directoryPath, name, () => deriveDirectoryConfig(declaredDirectory), overridesByPath)];
+        return [buildPreviewRow(directoryPath, name, () => deriveDirectoryConfig(declaredDirectory), overridesByPath, git)];
     });
 }
-function buildPreviewRow(workspacePath, knownName, deriveTarget, overridesByPath) {
+function buildPreviewRow(workspacePath, knownName, deriveTarget, overridesByPath, git) {
     const dir = basename(workspacePath);
     let name = knownName;
     let derivedPrefix = null;
@@ -75,12 +75,12 @@ function buildPreviewRow(workspacePath, knownName, deriveTarget, overridesByPath
     catch (error) {
         derivationError = describeError(error);
     }
-    const derivedTagCount = derivedPrefix === null ? 0 : countTagsMatching(derivedPrefix);
+    const derivedTagCount = derivedPrefix === null ? 0 : countTagsMatching(derivedPrefix, git);
     const declaredIdentities = overridesByPath.get(workspacePath) ?? [];
     const legacyEntries = declaredIdentities.map((identity) => ({
         name: identity.name,
         prefix: identity.tagPrefix,
-        tagCount: countTagsMatching(identity.tagPrefix),
+        tagCount: countTagsMatching(identity.tagPrefix, git),
     }));
     return {
         workspacePath,
@@ -92,14 +92,9 @@ function buildPreviewRow(workspacePath, knownName, deriveTarget, overridesByPath
         legacyEntries,
     };
 }
-function countTagsMatching(prefix) {
+function countTagsMatching(prefix, git) {
     try {
-        const output = execFileSync('git', ['tag', '--list', `${prefix}*`], {
-            encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return output.split('\n').filter((line) => matchesTagPrefix(line.trim(), [prefix])).length;
+        return git.listTags(`${prefix}*`).filter((tag) => matchesTagPrefix(tag, [prefix])).length;
     }
     catch {
         return 0;
@@ -142,11 +137,11 @@ function collectKnownPrefixes(rows, retiredPackages, compositeTagPrefix) {
         knownPrefixes.add(compositeTagPrefix);
     return [...knownPrefixes];
 }
-function buildRetiredPreviewEntries(retiredPackages) {
+function buildRetiredPreviewEntries(retiredPackages, git) {
     return retiredPackages.map((retiredPackage) => ({
         name: retiredPackage.name,
         tagPrefix: retiredPackage.tagPrefix,
-        tagCount: countTagsMatching(retiredPackage.tagPrefix),
+        tagCount: countTagsMatching(retiredPackage.tagPrefix, git),
         ...(retiredPackage.successor !== undefined && { successor: retiredPackage.successor }),
     }));
 }

package/dist/esm/publishCommand.d.ts

@@ -1,4 +1,4 @@
-import type { StreamStyles } from '@williamthorsen/nmr-core';
+import { type StreamStyles } from '@williamthorsen/nmr-core';
 export interface PublishCommandOptions {
     configPath: string | undefined;
     isDryRun: boolean;

package/dist/esm/publishCommand.js

@@ -1,13 +1,15 @@
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { formatStatusLine } from '@williamthorsen/nmr-core';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertTarballsComplete } from "./assertTarballsComplete.js";
+import { describeChangelogFileProblem } from "./changelogJsonUtils.js";
 import { deriveReleaseNotesConfig } from "./deriveReleaseNotesConfig.js";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { formatDirectoryPublishSkip } from "./formatDirectoryPublishSkip.js";
 import { formatPrivateSkip } from "./formatPrivateSkip.js";
 import { formatProjectPublishSkip } from "./formatProjectPublishSkip.js";
-import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
+import { injectReleaseNotesIntoReadme, resolveReadmePath, } from "./injectReleaseNotesIntoReadme.js";
 import { loadUsableConfig } from "./loadValidatedConfig.js";
 import { publishPackage } from "./publish.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
@@ -41,7 +43,15 @@ export async function publishCommand({ configPath, isDryRun, shouldGenerateProve
             if (shouldInject) {
                 readmePath = resolveReadmePath(resolvedTag.workspacePath);
                 if (readmePath !== undefined) {
-                    originalReadme = injectReleaseNotesIntoReadme(readmePath, join(resolvedTag.workspacePath, changelogJsonOutputPath), resolvedTag.tag, sectionOrder);
+                    const changelogJsonPath = join(resolvedTag.workspacePath, changelogJsonOutputPath);
+                    const injection = injectReleaseNotesIntoReadme(readmePath, changelogJsonPath, resolvedTag.tag, sectionOrder);
+                    if (injection.status === 'injected') {
+                        originalReadme = injection.originalReadme;
+                    }
+                    else {
+                        const message = formatInjectionSkip(resolvedTag, changelogJsonPath, injection.skip);
+                        console.warn(`  ${formatStatusLine(styles.stderr, 'warning', message)}`);
+                    }
                 }
             }
             try {
@@ -65,6 +75,18 @@ export async function publishCommand({ configPath, isDryRun, shouldGenerateProve
         throw error;
     }
 }
+function describeInjectionSkip(changelogJsonPath, skip) {
+    switch (skip.reason) {
+        case 'missing-file':
+            return describeChangelogFileProblem('missing', changelogJsonPath);
+        case 'unreadable-file':
+            return describeChangelogFileProblem('unreadable', changelogJsonPath);
+        case 'no-entry':
+            return `no changelog entry for version ${skip.version}`;
+        case 'empty-body':
+            return `no user-facing release notes for version ${skip.version}`;
+    }
+}
 function filterPublishableTags(resolvedTags, isExplicit) {
     const publishableTags = [];
     const unpublishableTags = [];
@@ -78,6 +100,9 @@ function filterPublishableTags(resolvedTags, isExplicit) {
     }
     return publishableTags;
 }
+function formatInjectionSkip(resolvedTag, changelogJsonPath, skip) {
+    return `Skipping README injection for ${resolvedTag.tag} (${resolvedTag.workspacePath}): ${describeInjectionSkip(changelogJsonPath, skip)}`;
+}
 function formatPublishSkip(resolvedTag) {
     switch (resolvedTag.kind) {
         case 'directory':

package/dist/esm/pushRelease.d.ts

@@ -1,3 +1,4 @@
+import { type Git } from './git.js';
 import type { ResolvedTag } from './resolveReleaseTags.js';
 export interface PushReleaseOptions {
     isDryRun?: boolean;
@@ -14,4 +15,4 @@ export interface PushStep {
  *
  * Returns the push steps, which it runs only outside dry-run mode.
  */
-export declare function pushRelease(resolvedTags: ResolvedTag[], options?: PushReleaseOptions): PushStep[];
+export declare function pushRelease(resolvedTags: ResolvedTag[], options?: PushReleaseOptions, git?: Git): PushStep[];

package/dist/esm/pushRelease.js

@@ -1,32 +1,32 @@
-import { execFileSync } from 'node:child_process';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
+import { buildBranchPushArgs, buildTagPushArgs, realGit } from "./git.js";
 import { asUserError } from "./user-error-chaining.js";
-export function pushRelease(resolvedTags, options = {}) {
+export function pushRelease(resolvedTags, options = {}, git = realGit) {
     const { isDryRun = false, tagsOnly = false } = options;
     const steps = [];
     if (!tagsOnly) {
         let branch;
         try {
-            branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-                encoding: 'utf8',
-                maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
+            branch = git.readCurrentBranch();
         }
         catch (error) {
             throw asUserError(error);
         }
-        const command = ['git', 'push', 'origin', branch];
+        const command = ['git', ...buildBranchPushArgs(branch)];
         steps.push({ type: 'branch', ref: branch, command });
     }
     for (const { tag } of resolvedTags) {
-        const command = ['git', 'push', '--no-follow-tags', 'origin', tag];
+        const command = ['git', ...buildTagPushArgs(tag)];
         steps.push({ type: 'tag', ref: tag, command });
     }
     if (!isDryRun) {
         for (const step of steps) {
             try {
-                execFileSync(step.command[0], step.command.slice(1), { stdio: 'inherit' });
+                if (step.type === 'branch') {
+                    git.pushBranch(step.ref);
+                }
+                else {
+                    git.pushTag(step.ref);
+                }
             }
             catch (error) {
                 throw asUserError(error);

package/dist/esm/readJsonFile.d.ts

@@ -0,0 +1,2 @@
+/** Reads a UTF-8 file and parses it as JSON, throwing a `UserError` that names the file when either step fails. */
+export declare function readJsonFile(filePath: string): unknown;

package/dist/esm/readJsonFile.js

@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+import { chainUserError } from "./user-error-chaining.js";
+export function readJsonFile(filePath) {
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        throw chainUserError(`Failed to read ${filePath}`, error);
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw chainUserError(`Failed to parse JSON in ${filePath}`, error);
+    }
+}