@williamthorsen/release-kit 2.1.0 → 2.3.1

package/CHANGELOG.md

@@ -2,6 +2,116 @@
 
 All notable changes to this project will be documented in this file.
 
+## [release-kit-v2.3.0] - 2026-03-28
+
+### Features
+
+- #8 feat: Add shared writeFileWithCheck utility and overwrite reporting (#66)
+
+Extracts three duplicated `writeIfAbsent` implementations and two duplicated terminal helper sets into shared utilities in `@williamthorsen/node-monorepo-core`, then migrates all consumers (`release-kit init`, `preflight init`, `sync-labels`) to use them. All init commands now report which files were created, overwritten, skipped, or failed — including when `--force` replaces existing files.
+
+- #11 release-kit|feat: Separate tag-write errors from release preparation errors (#67)
+
+When tag-file writing fails, the error message now reads "Error writing release tags:" instead of the misleading "Error preparing release:", which only appeared because both operations shared a single try/catch.
+
+Refactors `writeReleaseTags` to use the shared `writeFileWithCheck` utility from `@node-monorepo-tools/core` instead of raw `mkdirSync`/`writeFileSync`. The function now returns a structured `WriteResult` instead of throwing, and contains no `console` calls — all presentation moves to `runAndReport`.
+
+### Tests
+
+- #14 release-kit|tests: Add eligibility check failure and short-circuit tests (#63)
+
+Adds 4 unit tests to `initCommand.unit.test.ts` covering the remaining `checkEligibility` orchestration gaps: individual failure exit codes for `hasPackageJson` and `usesPnpm`, and short-circuit verification ensuring downstream checks are skipped when an earlier check fails.
+
+- #13 release-kit|tests: Add cliff.toml.template alignment test (#64)
+
+Adds a unit test that enforces bidirectional alignment between `DEFAULT_WORK_TYPES` and the bundled `cliff.toml.template` commit parsers. The test parses the TOML template using `smol-toml`, then verifies that every canonical type name and alias is matched by a parser with the correct group heading, and that every parser group maps to a known work type header.
+
+- #12 release-kit|tests: Add releasePrepare coverage for bumpOverride, tagPrefix, and dry-run tags (#65)
+
+Adds three unit tests to `releasePrepare.unit.test.ts` covering previously untested code paths: the `bumpOverride` bypass of commit-based bump detection, custom `tagPrefix` propagation into tags, and tag computation in dry-run mode.
+
+## [release-kit-v2.2.0] - 2026-03-27
+
+### Features
+
+- #27 release-kit|feat: Auto-detect Prettier for CHANGELOG formatting (#36)
+
+When `formatCommand` is not configured, release-kit now auto-detects whether the repo uses Prettier by checking for config files (`.prettierrc*`, `prettier.config.*`) or a `"prettier"` key in root `package.json`. If found, it defaults to `npx prettier --write` on generated files. If not found, formatting is skipped.
+
+- #28 release-kit|feat: Add tag-creation command (#40)
+
+Adds a `release-kit tag` CLI command that reads computed tag names from the `tmp/.release-tags` file produced by `prepare` and creates annotated git tags. The command supports `--dry-run` (preview without creating tags) and `--no-git-checks` (skip dirty working tree validation). The `createTags` function and its options type are exported for programmatic use.
+
+- #29 release-kit|feat: Add publish command (#42)
+
+Adds a `release-kit publish` subcommand that derives packages to publish from git tags on HEAD and delegates to the repo's detected package manager. Also cleans up the `.release-tags` file after tag creation.
+
+- #41 release-kit|feat: Remove tagPrefix customization from component config (#49)
+
+Removes the ability to customize `tagPrefix` per component, enforcing the deterministic `{dir}-v` convention universally. The internal `tagPrefix` property on `ComponentConfig` and `ReleaseConfig` is preserved — only the override/customization entry points are removed. Existing configs that still include `tagPrefix` now receive a clear deprecation error.
+
+- #54 release-kit|feat: Add styled terminal output to prepare command (#55)
+
+Adds ANSI formatting and emoji markers to the `release-kit prepare` command output. Progress chatter is dimmed, key results (version bumps, release tags, completion status) are highlighted with bold text and emoji, and monorepo components are separated by box-drawing section headers.
+
+- #59 feat: Extract nmr CLI from core package (#61)
+
+Extracts all nmr CLI code from `packages/core` into a new `packages/nmr` package (`@williamthorsen/nmr`). Core is reduced to an empty shared-library shell ready for cross-cutting utilities. All internal references are rewired and the full build/test pipeline passes.
+
+Scopes: core, nmr
+
+### Refactoring
+
+- #43 refactor: Replace dist bin targets with thin wrapper scripts (#48)
+
+The `bin` entries in `packages/core` and `packages/release-kit` pointed directly into `dist/esm/`, causing `pnpm install` to emit "Failed to create bin" warnings in fresh worktrees where `dist/` does not yet exist. Each bin entry now points to a committed wrapper script in `bin/` that dynamically imports the real entry point. The `files` field in both packages includes `bin` so the wrappers are published.
+
+- #53 release-kit|refactor: Separate presentation from logic in prepare workflow (#57)
+
+Extracts all `console.info` calls from the prepare workflow's logic functions (`bumpAllVersions`, `generateChangelogs`, `releasePrepare`, `releasePrepareMono`) into a dedicated `reportPrepare` formatter. Logic functions now return structured result types (`BumpResult`, `ComponentPrepareResult`, `PrepareResult`). The legacy `runReleasePrepare` entry point is retired, with its utilities absorbed into `prepareCommand`.
+
+### Tests
+
+- #17 release-kit|tests: Cover multi-changelogPaths and error paths (#44)
+
+Add three tests for previously untested code paths:
+
+- `releasePrepareMono`: component with two `changelogPaths` entries, asserting `git-cliff` is invoked once per path with the correct `--output` target.
+- `getCommitsSinceTarget`: `git describe` failure with a non-128 exit status propagates as a wrapped error instead of being swallowed.
+- `getCommitsSinceTarget`: `git log` failure is wrapped and re-thrown with the commit range in the message.
+
+Also adds a `findAllCliffOutputPaths()` test helper that collects the `--output` arg from every `git-cliff` mock call.
+
+### Tooling
+
+- #37 root|tooling: Adopt nmr to run monorepo and workspace scripts (#38)
+
+Replaces the legacy workspace script runner and ~25 root `package.json` scripts with `nmr`, the monorepo's own context-aware script runner. Root scripts are reduced to 4 (`prepare`, `postinstall`, `ci`, `bootstrap`), packages use direct build commands for bootstrap, and release-kit declares tier-3 test overrides for its integration test configs.
+
+## [release-workflow-v1] - 2026-03-19
+
+### Dependencies
+
+- Root|deps: Add release-kit as root devDependency
+
+Make `npx release-kit` and `pnpm exec release-kit` resolve within
+this repo by adding a `workspace:*` dependency that symlinks the bin.
+
+### Features
+
+- #23 release-kit|feat: Add sync-labels command (#33)
+
+Add a `release-kit sync-labels` command group with three subcommands (`init`, `generate`, `sync`) for declarative GitHub label management in monorepos. Bundle a reusable GitHub Actions workflow and composable label presets with the release-kit package. Introduce a `findPackageRoot` utility to replace fragile hardcoded path resolutions across the codebase.
+
+- #34 release-kit|feat: Report up-to-date status for unchanged init files (#35)
+
+`release-kit init` now compares existing file content against the default before reporting status. When an existing file is identical to the default (after normalizing trailing whitespace), it reports `✅ (up to date)` instead of the misleading `⚠️ (already exists)`.
+
+- Release-workflow|feat: Accept force input
+
+Pass `--force` to the prepare command so callers can force a version
+bump even when there are no release-worthy changes.
+
 ## [release-kit-v2.1.0] - 2026-03-17
 
 ### Features

package/README.md

@@ -48,12 +48,6 @@ Options:
 
 Component names for `--only` match the package directory name (e.g., `arrays`, `release-kit`).
 
-**Self-hosting note**: in a repo where `release-kit` is a workspace package (e.g., this monorepo), `npx` and `pnpm exec` may not resolve the binary. Run the built entry point directly:
-
-```bash
-node packages/release-kit/dist/esm/bin/release-kit.js prepare --dry-run
-```
-
 ### `release-kit init`
 
 Initialize release-kit in the current repository. By default, scaffolds only the GitHub Actions workflow file. Use `--with-config` to also scaffold configuration files.
@@ -120,7 +114,6 @@ All fields are optional.
 ```typescript
 interface ComponentOverride {
   dir: string; // Package directory name (e.g., 'arrays')
-  tagPrefix?: string; // Custom git tag prefix (defaults to '${dir}-v')
   shouldExclude?: boolean; // If true, exclude from release processing
 }
 ```
@@ -184,12 +177,9 @@ component('packages/arrays');
 //   changelogPaths: ['packages/arrays'],
 //   paths: ['packages/arrays/**'],
 // }
-
-// Custom tag prefix
-component('libs/core', 'core-v');
 ```
 
-The `dir` field is derived from `path.basename()`, so `packages/arrays` and `libs/arrays` both produce `dir: 'arrays'`.
+The `dir` field is derived from `path.basename()`, so `packages/arrays` and `libs/arrays` both produce `dir: 'arrays'`. The `tagPrefix` is always `${dir}-v` — it cannot be customized.
 
 ## GitHub Actions workflow
 

package/bin/release-kit.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/esm/bin/release-kit.js');

package/dist/esm/.cache

@@ -1 +1 @@
-c3020d624e72bb577d60cb16ff223c951d26227fa82aec1c15894f2b2429603f
+af9641831236630f28f7bf1301d1dc1319b90769e7e70ff6664f80af452c1a72

package/dist/esm/bin/release-kit.js

@@ -1,19 +1,75 @@
 #!/usr/bin/env node
 import { initCommand } from "../init/initCommand.js";
 import { prepareCommand } from "../prepareCommand.js";
+import { publishCommand } from "../publishCommand.js";
+import { generateCommand } from "../sync-labels/generateCommand.js";
+import { syncLabelsInitCommand } from "../sync-labels/initCommand.js";
+import { syncLabelsCommand } from "../sync-labels/syncCommand.js";
+import { tagCommand } from "../tagCommand.js";
 function showUsage() {
   console.info(`
 Usage: release-kit <command> [options]
 
 Commands:
   prepare       Run release preparation (auto-discovers workspaces)
+  tag           Create annotated git tags from the tags file
+  publish       Publish packages with release tags on HEAD
   init          Initialize release-kit in the current repository
+  sync-labels   Manage GitHub label synchronization
 
 Options:
   --dry-run     Preview changes without writing files
   --help, -h    Show this help message
 `);
 }
+function showSyncLabelsHelp() {
+  console.info(`
+Usage: release-kit sync-labels <subcommand> [options]
+
+Manage GitHub label synchronization via preset and custom label definitions.
+
+Subcommands:
+  init          Scaffold caller workflow and config, then generate labels
+  generate      Regenerate .github/labels.yaml from config
+  sync          Trigger the sync-labels workflow via gh CLI
+
+Options:
+  --help, -h    Show this help message
+`);
+}
+function showSyncLabelsInitHelp() {
+  console.info(`
+Usage: release-kit sync-labels init [options]
+
+Scaffold the sync-labels caller workflow and config file, auto-discover workspaces
+for scope labels, then generate .github/labels.yaml.
+
+Options:
+  --dry-run     Preview changes without writing files
+  --force       Overwrite existing files instead of skipping them
+  --help, -h    Show this help message
+`);
+}
+function showSyncLabelsGenerateHelp() {
+  console.info(`
+Usage: release-kit sync-labels generate
+
+Regenerate .github/labels.yaml from .config/sync-labels.config.ts.
+
+Options:
+  --help, -h    Show this help message
+`);
+}
+function showSyncLabelsSyncHelp() {
+  console.info(`
+Usage: release-kit sync-labels sync
+
+Trigger the sync-labels GitHub Actions workflow via the gh CLI.
+
+Options:
+  --help, -h    Show this help message
+`);
+}
 function showInitHelp() {
   console.info(`
 Usage: release-kit init [options]
@@ -41,6 +97,31 @@ Options:
   --help, -h            Show this help message
 `);
 }
+function showTagHelp() {
+  console.info(`
+Usage: release-kit tag [options]
+
+Create annotated git tags from the tags file produced by \`prepare\`.
+
+Options:
+  --dry-run          Preview without creating tags
+  --no-git-checks    Skip dirty working tree check
+  --help, -h         Show this help message
+`);
+}
+function showPublishHelp() {
+  console.info(`
+Usage: release-kit publish [options]
+
+Publish packages that have release tags on HEAD.
+
+Options:
+  --dry-run              Preview without publishing
+  --no-git-checks        Skip git checks (pnpm only)
+  --only=name1,name2     Only publish the named packages (comma-separated, monorepo only)
+  --help, -h             Show this help message
+`);
+}
 const args = process.argv.slice(2);
 const command = args[0];
 const flags = args.slice(1);
@@ -56,6 +137,22 @@ if (command === "prepare") {
   await prepareCommand(flags);
   process.exit(0);
 }
+if (command === "tag") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showTagHelp();
+    process.exit(0);
+  }
+  tagCommand(flags);
+  process.exit(0);
+}
+if (command === "publish") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showPublishHelp();
+    process.exit(0);
+  }
+  await publishCommand(flags);
+  process.exit(0);
+}
 if (command === "init") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
     showInitHelp();
@@ -73,6 +170,57 @@ if (command === "init") {
   const exitCode = initCommand({ dryRun, force, withConfig });
   process.exit(exitCode);
 }
+if (command === "sync-labels") {
+  const subcommand = flags[0];
+  const subflags = flags.slice(1);
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === void 0) {
+    showSyncLabelsHelp();
+    process.exit(0);
+  }
+  if (subcommand === "init") {
+    if (subflags.some((f) => f === "--help" || f === "-h")) {
+      showSyncLabelsInitHelp();
+      process.exit(0);
+    }
+    const knownFlags = /* @__PURE__ */ new Set(["--dry-run", "--force", "--help", "-h"]);
+    const unknownFlags = subflags.filter((f) => !knownFlags.has(f));
+    if (unknownFlags.length > 0) {
+      console.error(`Error: Unknown option: ${unknownFlags[0]}`);
+      process.exit(1);
+    }
+    const dryRun = subflags.includes("--dry-run");
+    const force = subflags.includes("--force");
+    const exitCode = await syncLabelsInitCommand({ dryRun, force });
+    process.exit(exitCode);
+  }
+  if (subcommand === "generate") {
+    if (subflags.some((f) => f === "--help" || f === "-h")) {
+      showSyncLabelsGenerateHelp();
+      process.exit(0);
+    }
+    if (subflags.length > 0) {
+      console.error(`Error: Unknown option: ${subflags[0]}`);
+      process.exit(1);
+    }
+    const exitCode = await generateCommand();
+    process.exit(exitCode);
+  }
+  if (subcommand === "sync") {
+    if (subflags.some((f) => f === "--help" || f === "-h")) {
+      showSyncLabelsSyncHelp();
+      process.exit(0);
+    }
+    if (subflags.length > 0) {
+      console.error(`Error: Unknown option: ${subflags[0]}`);
+      process.exit(1);
+    }
+    const exitCode = syncLabelsCommand();
+    process.exit(exitCode);
+  }
+  console.error(`Error: Unknown subcommand: ${subcommand}`);
+  showSyncLabelsHelp();
+  process.exit(1);
+}
 console.error(`Error: Unknown command: ${command}`);
 showUsage();
 process.exit(1);

package/dist/esm/bumpAllVersions.d.ts

@@ -1,2 +1,2 @@
-import type { ReleaseType } from './types.ts';
-export declare function bumpAllVersions(packageFiles: readonly string[], releaseType: ReleaseType, dryRun: boolean): string;
+import type { BumpResult, ReleaseType } from './types.ts';
+export declare function bumpAllVersions(packageFiles: readonly string[], releaseType: ReleaseType, dryRun: boolean): BumpResult;

package/dist/esm/bumpAllVersions.js

@@ -11,10 +11,8 @@ function bumpAllVersions(packageFiles, releaseType, dryRun) {
   const firstPkg = readPackageJson(firstFile);
   const currentVersion = firstPkg.version;
   const newVersion = bumpVersion(currentVersion, releaseType);
-  console.info(`Bumping version: ${currentVersion} -> ${newVersion} (${releaseType})`);
   for (const filePath of packageFiles) {
     if (dryRun) {
-      console.info(`  [dry-run] Would bump ${filePath}`);
       continue;
     }
     const pkg = filePath === firstFile ? firstPkg : readPackageJson(filePath);
@@ -24,9 +22,8 @@ function bumpAllVersions(packageFiles, releaseType, dryRun) {
     } catch (error) {
       throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    console.info(`  Bumped ${filePath}`);
   }
-  return newVersion;
+  return { currentVersion, newVersion, files: [...packageFiles] };
 }
 function readPackageJson(filePath) {
   let content;

package/dist/esm/component.d.ts

@@ -1,2 +1,2 @@
 import type { ComponentConfig } from './types.ts';
-export declare function component(workspacePath: string, tagPrefix?: string): ComponentConfig;
+export declare function component(workspacePath: string): ComponentConfig;

package/dist/esm/component.js

@@ -1,10 +1,9 @@
 import { basename } from "node:path";
-function component(workspacePath, tagPrefix) {
+function component(workspacePath) {
   const dir = basename(workspacePath);
-  const prefix = tagPrefix ?? `${dir}-v`;
   return {
     dir,
-    tagPrefix: prefix,
+    tagPrefix: `${dir}-v`,
     packageFiles: [`${workspacePath}/package.json`],
     changelogPaths: [workspacePath],
     paths: [`${workspacePath}/**`]

package/dist/esm/createTags.d.ts

@@ -0,0 +1,5 @@
+export interface CreateTagsOptions {
+    dryRun: boolean;
+    noGitChecks: boolean;
+}
+export declare function createTags(options: CreateTagsOptions): string[];

package/dist/esm/createTags.js

@@ -0,0 +1,73 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync, unlinkSync } from "node:fs";
+import { RELEASE_TAGS_FILE } from "./prepareCommand.js";
+function createTags(options) {
+  const { dryRun, noGitChecks } = options;
+  let content;
+  try {
+    content = readFileSync(RELEASE_TAGS_FILE, "utf8");
+  } catch {
+    throw new Error("No tags file found. Run `release-kit prepare` first.");
+  }
+  const tags = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  if (tags.length === 0) {
+    return [];
+  }
+  if (!dryRun && !noGitChecks) {
+    assertCleanWorkingTree();
+  }
+  if (dryRun) {
+    console.info("[dry-run] Would create tags:");
+    for (const tag of tags) {
+      console.info(`\u{1F3F7}\uFE0F ${tag}`);
+    }
+    return tags;
+  }
+  const created = [];
+  for (const tag of tags) {
+    try {
+      execFileSync("git", ["tag", "-a", tag, "-m", tag]);
+      created.push(tag);
+    } catch (error) {
+      if (created.length > 0) {
+        console.warn("Tags created before failure:");
+        for (const t of created) {
+          console.warn(`  ${t}`);
+        }
+      }
+      throw error;
+    }
+  }
+  console.info("Created tags:");
+  for (const tag of tags) {
+    console.info(`\u{1F3F7}\uFE0F ${tag}`);
+  }
+  deleteTagsFile();
+  return tags;
+}
+function deleteTagsFile() {
+  try {
+    unlinkSync(RELEASE_TAGS_FILE);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+function assertCleanWorkingTree() {
+  try {
+    execFileSync("git", ["diff", "--quiet"]);
+    execFileSync("git", ["diff", "--quiet", "--cached"]);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw error;
+    }
+    throw new Error(
+      "Working tree is dirty. Commit or stash changes before tagging, or use `--no-git-checks` to skip this check."
+    );
+  }
+}
+export {
+  createTags
+};

package/dist/esm/detectPackageManager.d.ts

@@ -0,0 +1,2 @@
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'yarn-berry';
+export declare function detectPackageManager(): PackageManager;

package/dist/esm/detectPackageManager.js

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { isRecord } from "./typeGuards.js";
+function detectPackageManager() {
+  const packageJsonPath = join(process.cwd(), "package.json");
+  try {
+    const content = readFileSync(packageJsonPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (isRecord(parsed) && typeof parsed.packageManager === "string") {
+      const [name, version] = parsed.packageManager.split("@");
+      if (name === "pnpm" || name === "npm") {
+        return name;
+      }
+      if (name === "yarn") {
+        return isYarnBerry(version) ? "yarn-berry" : "yarn";
+      }
+    }
+  } catch {
+  }
+  return detectFromLockfile();
+}
+function isYarnBerry(version) {
+  if (version === void 0) {
+    return false;
+  }
+  const major = Number.parseInt(version, 10);
+  return !Number.isNaN(major) && major >= 2;
+}
+function detectFromLockfile() {
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  if (existsSync(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+export {
+  detectPackageManager
+};

package/dist/esm/findPackageRoot.d.ts

@@ -0,0 +1 @@
+export declare function findPackageRoot(fromUrl: string): string;

package/dist/esm/findPackageRoot.js

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function findPackageRoot(fromUrl) {
+  let dir = dirname(fileURLToPath(fromUrl));
+  while (!existsSync(resolve(dir, "package.json"))) {
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error("Could not find package root from " + fromUrl);
+    }
+    dir = parent;
+  }
+  return dir;
+}
+export {
+  findPackageRoot
+};

package/dist/esm/format.d.ts

@@ -0,0 +1,3 @@
+export declare function bold(text: string): string;
+export declare function dim(text: string): string;
+export declare function sectionHeader(name: string): string;

package/dist/esm/format.js

@@ -0,0 +1,14 @@
+function bold(text) {
+  return `\x1B[1m${text}\x1B[0m`;
+}
+function dim(text) {
+  return `\x1B[2m${text}\x1B[0m`;
+}
+function sectionHeader(name) {
+  return `\u2501\u2501\u2501 ${name} \u2501\u2501\u2501`;
+}
+export {
+  bold,
+  dim,
+  sectionHeader
+};

package/dist/esm/generateChangelogs.d.ts

@@ -2,5 +2,5 @@ import type { ReleaseConfig } from './types.ts';
 export interface GenerateChangelogOptions {
     includePaths?: string[];
 }
-export declare function generateChangelog(config: Pick<ReleaseConfig, 'cliffConfigPath'>, changelogPath: string, tag: string, dryRun: boolean, options?: GenerateChangelogOptions): void;
-export declare function generateChangelogs(config: ReleaseConfig, tag: string, dryRun: boolean): void;
+export declare function generateChangelog(config: Pick<ReleaseConfig, 'cliffConfigPath'>, changelogPath: string, tag: string, dryRun: boolean, options?: GenerateChangelogOptions): string[];
+export declare function generateChangelogs(config: ReleaseConfig, tag: string, dryRun: boolean): string[];

package/dist/esm/generateChangelogs.js

@@ -7,23 +7,23 @@ function generateChangelog(config, changelogPath, tag, dryRun, options) {
   for (const includePath of options?.includePaths ?? []) {
     args.push("--include-path", includePath);
   }
-  if (dryRun) {
-    console.info(`  [dry-run] Would run: npx --yes git-cliff ${args.join(" ")}`);
-    return;
-  }
-  console.info(`  Generating changelog: ${outputFile}`);
-  try {
-    execFileSync("npx", ["--yes", "git-cliff", ...args], { stdio: "inherit" });
-  } catch (error) {
-    throw new Error(
-      `Failed to generate changelog for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
-    );
+  if (!dryRun) {
+    try {
+      execFileSync("npx", ["--yes", "git-cliff", ...args], { stdio: "inherit" });
+    } catch (error) {
+      throw new Error(
+        `Failed to generate changelog for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
   }
+  return [outputFile];
 }
 function generateChangelogs(config, tag, dryRun) {
+  const results = [];
   for (const changelogPath of config.changelogPaths) {
-    generateChangelog(config, changelogPath, tag, dryRun);
+    results.push(...generateChangelog(config, changelogPath, tag, dryRun));
   }
+  return results;
 }
 export {
   generateChangelog,

package/dist/esm/hasPrettierConfig.d.ts

@@ -0,0 +1 @@
+export declare function hasPrettierConfig(): boolean;

package/dist/esm/hasPrettierConfig.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { isRecord } from "./typeGuards.js";
+function hasPrettierConfig() {
+  const cwd = process.cwd();
+  for (const file of PRETTIER_CONFIG_FILES) {
+    if (existsSync(path.join(cwd, file))) {
+      return true;
+    }
+  }
+  return hasPrettierKeyInPackageJson(path.join(cwd, "package.json"));
+}
+function hasPrettierKeyInPackageJson(packageJsonPath) {
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return isRecord(parsed) && "prettier" in parsed;
+  } catch {
+    return false;
+  }
+}
+const PRETTIER_CONFIG_FILES = [
+  ".prettierrc",
+  ".prettierrc.cjs",
+  ".prettierrc.js",
+  ".prettierrc.json",
+  ".prettierrc.json5",
+  ".prettierrc.mjs",
+  ".prettierrc.toml",
+  ".prettierrc.ts",
+  ".prettierrc.yaml",
+  ".prettierrc.yml",
+  "prettier.config.cjs",
+  "prettier.config.js",
+  "prettier.config.mjs",
+  "prettier.config.ts"
+];
+export {
+  hasPrettierConfig
+};