@varlock/bumpy 0.0.1 → 1.0.0

package/dist/index.d.mts

@@ -1,20 +1,16 @@
 //#region src/types.d.ts
 type BumpType = 'major' | 'minor' | 'patch';
-type BumpTypeWithIsolated = BumpType | 'minor-isolated' | 'patch-isolated';
+type BumpTypeWithNone = BumpType | 'none';
 declare const BUMP_LEVELS: Record<BumpType, number>;
 declare function bumpLevel(type: BumpType): number;
-declare function parseIsolatedBump(type: BumpTypeWithIsolated): {
-  bump: BumpType;
-  isolated: boolean;
-};
 declare function maxBump(a: BumpType | undefined, b: BumpType): BumpType;
 interface DependencyBumpRule {
   /** What bump level in the dependency triggers propagation */
-  trigger: BumpType | 'none';
+  trigger: BumpType;
   /** What bump to apply to the dependent */
   bumpAs: BumpType | 'match';
 }
-declare const DEFAULT_BUMP_RULES: Record<string, DependencyBumpRule>;
+declare const DEFAULT_BUMP_RULES: Record<string, DependencyBumpRule | false>;
 type DepType = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
 declare const DEP_TYPES: DepType[];
 interface PublishConfig {
@@ -44,12 +40,22 @@ interface BumpyConfig {
   ignore: string[];
   /** Package names/globs to explicitly include (overrides private + ignore) */
   include: string[];
-  updateInternalDependencies: 'patch' | 'minor' | 'out-of-range' | 'none';
-  dependencyBumpRules: Partial<Record<DepType, DependencyBumpRule>>;
+  updateInternalDependencies: 'patch' | 'minor' | 'out-of-range';
+  dependencyBumpRules: Partial<Record<DepType, DependencyBumpRule | false>>;
   privatePackages: {
     version: boolean;
     tag: boolean;
   };
+  /**
+   * Allow per-package custom commands (buildCommand, publishCommand, checkPublished)
+   * defined in package.json "bumpy" fields.
+   * Commands defined in the root config's `packages` map are always trusted.
+   *
+   * true = allow all packages to define custom commands
+   * string[] = allow only matching package names/globs
+   * false = only root-config commands are allowed (default)
+   */
+  allowCustomCommands: boolean | string[];
   packages: Record<string, PackageConfig>;
   publish: PublishConfig;
   /**
@@ -84,26 +90,25 @@ interface PackageConfig {
   skipNpmPublish?: boolean;
   /** Command to check if a version is already published. Should output the published version string. */
   checkPublished?: string;
-  dependencyBumpRules?: Partial<Record<DepType, DependencyBumpRule>>;
-  specificDependencyRules?: Record<string, DependencyBumpRule>;
+  dependencyBumpRules?: Partial<Record<DepType, DependencyBumpRule | false>>;
   cascadeTo?: Record<string, DependencyBumpRule>;
 }
 declare const DEFAULT_PUBLISH_CONFIG: PublishConfig;
 declare const DEFAULT_CONFIG: BumpyConfig;
-interface ChangesetReleaseSimple {
+interface BumpFileReleaseSimple {
   name: string;
-  type: BumpTypeWithIsolated;
+  type: BumpTypeWithNone;
 }
-interface ChangesetReleaseCascade {
+interface BumpFileReleaseCascade {
   name: string;
-  type: BumpTypeWithIsolated;
+  type: BumpTypeWithNone;
   cascade: Record<string, BumpType>;
 }
-type ChangesetRelease = ChangesetReleaseSimple | ChangesetReleaseCascade;
-declare function hasCascade(r: ChangesetRelease): r is ChangesetReleaseCascade;
-interface Changeset {
+type BumpFileRelease = BumpFileReleaseSimple | BumpFileReleaseCascade;
+declare function hasCascade(r: BumpFileRelease): r is BumpFileReleaseCascade;
+interface BumpFile {
   id: string;
-  releases: ChangesetRelease[];
+  releases: BumpFileRelease[];
   summary: string;
 }
 interface WorkspacePackage {
@@ -131,13 +136,14 @@ interface PlannedRelease {
   type: BumpType;
   oldVersion: string;
   newVersion: string;
-  changesets: string[];
+  bumpFiles: string[];
   isDependencyBump: boolean;
   isCascadeBump: boolean;
 }
 interface ReleasePlan {
-  changesets: Changeset[];
+  bumpFiles: BumpFile[];
   releases: PlannedRelease[];
+  warnings: string[];
 }
 //#endregion
 //#region src/core/config.d.ts
@@ -175,30 +181,35 @@ declare class DependencyGraph {
   topologicalSort(packages: Map<string, WorkspacePackage>): string[];
 }
 //#endregion
-//#region src/core/changeset.d.ts
-/** Read all changeset files from .bumpy/ directory */
-declare function readChangesets(rootDir: string): Promise<Changeset[]>;
-/** Parse changeset content (for testing) */
-declare function parseChangeset(content: string, id: string): Changeset | null;
-/** Write a changeset file */
-declare function writeChangeset(rootDir: string, filename: string, releases: ChangesetRelease[], summary: string): Promise<string>;
+//#region src/core/bump-file.d.ts
+/** Read all bump files from .bumpy/ directory, sorted by git creation order */
+declare function readBumpFiles(rootDir: string): Promise<BumpFile[]>;
+/** Parse bump file content (for testing) */
+declare function parseBumpFile(content: string, id: string): BumpFile | null;
+/** Write a bump file */
+declare function writeBumpFile(rootDir: string, filename: string, releases: BumpFileRelease[], summary: string): Promise<string>;
 //#endregion
 //#region src/core/release-plan.d.ts
 /**
- * Build a release plan from pending changesets, the dependency graph, and config.
+ * Build a release plan from pending bump files, the dependency graph, and config.
  * This is the core algorithm of bumpy.
+ *
+ * The propagation loop runs three phases until stable:
+ *   Phase A — fix out-of-range dependencies (always runs)
+ *   Phase B — enforce fixed/linked group constraints
+ *   Phase C — apply cascades and proactive propagation rules
  */
-declare function assembleReleasePlan(changesets: Changeset[], packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig): ReleasePlan;
+declare function assembleReleasePlan(bumpFiles: BumpFile[], packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig): ReleasePlan;
 //#endregion
 //#region src/core/apply-release-plan.d.ts
-/** Apply the release plan: bump versions, update changelogs, delete changesets */
+/** Apply the release plan: bump versions, update changelogs, delete bump files */
 declare function applyReleasePlan(releasePlan: ReleasePlan, packages: Map<string, WorkspacePackage>, rootDir: string, config: BumpyConfig): Promise<void>;
 //#endregion
 //#region src/core/changelog.d.ts
 interface ChangelogContext {
   release: PlannedRelease;
-  /** Changesets that contributed to this release */
-  changesets: Changeset[];
+  /** Bump files that contributed to this release */
+  bumpFiles: BumpFile[];
   /** ISO date string (YYYY-MM-DD) */
   date: string;
 }
@@ -215,14 +226,29 @@ declare const defaultFormatter: ChangelogFormatter;
  */
 declare function loadFormatter(changelog: BumpyConfig['changelog'], rootDir: string): Promise<ChangelogFormatter>;
 /** Generate a changelog entry using the configured formatter */
-declare function generateChangelogEntry(release: PlannedRelease, changesets: Changeset[], formatter?: ChangelogFormatter, date?: string): Promise<string>;
+declare function generateChangelogEntry(release: PlannedRelease, bumpFiles: BumpFile[], formatter?: ChangelogFormatter, date?: string): Promise<string>;
 /** Prepend a new entry to an existing CHANGELOG.md content */
 declare function prependToChangelog(existingContent: string, newEntry: string): string;
 //#endregion
+//#region src/core/changelog-github.d.ts
+interface GithubChangelogOptions {
+  /** "owner/repo" — auto-detected from gh CLI if not provided */
+  repo?: string;
+  /** Whether to include "Thanks @user" messages for contributors (default: true) */
+  thankContributors?: boolean;
+  /** GitHub usernames (without @) to skip "Thanks" messages for (e.g. internal team members) */
+  internalAuthors?: string[];
+}
+//#endregion
 //#region src/core/semver.d.ts
 declare function bumpVersion(version: string, type: BumpType): string;
-/** Check if a version satisfies a range */
-declare function satisfies(version: string, range: string): boolean;
+/**
+ * Check if a version satisfies a range.
+ * @param version - The version to check
+ * @param range - The version range (may include workspace: or catalog: protocol)
+ * @param currentVersion - The dependency's current version, used to resolve workspace:^ and workspace:~
+ */
+declare function satisfies(version: string, range: string, currentVersion?: string): boolean;
 /** Strip workspace: protocol from version ranges */
 declare function stripProtocol(range: string): string;
 //#endregion
@@ -251,4 +277,4 @@ interface PublishResult {
  */
 declare function publishPackages(releasePlan: ReleasePlan, packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig, rootDir: string, opts?: PublishOptions, catalogs?: CatalogMap, detectedPm?: PackageManager): Promise<PublishResult>;
 //#endregion
-export { BUMP_LEVELS, BumpType, BumpTypeWithIsolated, BumpyConfig, type ChangelogContext, type ChangelogFormatter, Changeset, ChangesetRelease, ChangesetReleaseCascade, ChangesetReleaseSimple, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DepType, DependencyBumpRule, DependencyGraph, DependentInfo, PackageConfig, PackageManager, PlannedRelease, PublishConfig, ReleasePlan, WorkspacePackage, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, parseChangeset, parseIsolatedBump, prependToChangelog, publishPackages, readChangesets, satisfies, stripProtocol, writeChangeset };
+export { BUMP_LEVELS, BumpFile, BumpFileRelease, BumpFileReleaseCascade, BumpFileReleaseSimple, BumpType, BumpTypeWithNone, BumpyConfig, type ChangelogContext, type ChangelogFormatter, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DepType, DependencyBumpRule, DependencyGraph, DependentInfo, type GithubChangelogOptions, PackageConfig, PackageManager, PlannedRelease, PublishConfig, ReleasePlan, WorkspacePackage, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, parseBumpFile, prependToChangelog, publishPackages, readBumpFiles, satisfies, stripProtocol, writeBumpFile };

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { a as loadConfig, c as BUMP_LEVELS, d as DEFAULT_PUBLISH_CONFIG, f as DEP_TYPES, g as parseIsolatedBump, h as maxBump, l as DEFAULT_BUMP_RULES, m as hasCascade, n as findRoot, p as bumpLevel, r as getBumpyDir, s as matchGlob, u as DEFAULT_CONFIG } from "./config-CJ2orhTL.mjs";
-import { t as discoverPackages } from "./workspace-mVjawG8g.mjs";
-import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
-import { i as writeChangeset, n as parseChangeset, r as readChangesets } from "./changeset-ClCYsChu.mjs";
-import { n as satisfies, r as stripProtocol, t as bumpVersion } from "./semver-DWO6NFKN.mjs";
-import { t as assembleReleasePlan } from "./release-plan-CFnutSHD.mjs";
-import { a as prependToChangelog, i as loadFormatter, n as defaultFormatter, r as generateChangelogEntry, t as applyReleasePlan } from "./apply-release-plan-DtU3rVyL.mjs";
-import { t as publishPackages } from "./publish-pipeline-1M5GmbdP.mjs";
-export { BUMP_LEVELS, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DependencyGraph, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, parseChangeset, parseIsolatedBump, prependToChangelog, publishPackages, readChangesets, satisfies, stripProtocol, writeChangeset };
+import { a as loadConfig, c as BUMP_LEVELS, d as DEFAULT_PUBLISH_CONFIG, f as DEP_TYPES, h as maxBump, l as DEFAULT_BUMP_RULES, m as hasCascade, n as findRoot, p as bumpLevel, r as getBumpyDir, s as matchGlob, u as DEFAULT_CONFIG } from "./config-XZWUL3ma.mjs";
+import { t as discoverPackages } from "./workspace-C5ULTyUN.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { i as writeBumpFile, n as parseBumpFile, r as readBumpFiles } from "./bump-file-CCLXMLA8.mjs";
+import { n as satisfies, r as stripProtocol, t as bumpVersion } from "./semver-DfQyVLM_.mjs";
+import { t as assembleReleasePlan } from "./release-plan-Bi5QNSEo.mjs";
+import { a as prependToChangelog, i as loadFormatter, n as defaultFormatter, r as generateChangelogEntry, t as applyReleasePlan } from "./apply-release-plan-CczGWJTk.mjs";
+import { t as publishPackages } from "./publish-pipeline-BwBuKCIk.mjs";
+export { BUMP_LEVELS, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DependencyGraph, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, parseBumpFile, prependToChangelog, publishPackages, readBumpFiles, satisfies, stripProtocol, writeBumpFile };

package/dist/{init-Blw2GfC_.mjs → init-lA9E5pEc.mjs}

@@ -1,5 +1,5 @@
-import { n as log } from "./logger-ZqggsyGZ.mjs";
-import { c as writeJson, l as writeText, n as exists, t as ensureDir } from "./fs-DbNNEyzq.mjs";
+import { n as log } from "./logger-C2dEe5Su.mjs";
+import { d as writeText, n as exists, t as ensureDir, u as writeJson } from "./fs-DYR2XuFE.mjs";
 import { resolve } from "node:path";
 //#region src/commands/init.ts
 async function initCommand(rootDir) {
@@ -13,7 +13,7 @@ async function initCommand(rootDir) {
 		baseBranch: "main",
 		changelog: "default"
 	});
-	await writeText(resolve(bumpyDir, "README.md"), `# 🐸 Bumpy\n\nThis directory is used by [bumpy](https://github.com/dmno-dev/bumpy) to manage versioning.\n\nChangeset files (\`.md\`) in this directory describe pending version bumps.\nRun \`bumpy add\` to create a new changeset.\n`);
+	await writeText(resolve(bumpyDir, "README.md"), `# 🐸 Bumpy\n\nThis directory is used by [bumpy](https://github.com/dmno-dev/bumpy) to manage versioning.\n\nBump files (\`.md\`) in this directory describe pending version bumps.\nRun \`bumpy add\` to create a new bump file.\n`);
 	log.success("Initialized .bumpy/ directory");
 	log.dim("  Created .bumpy/_config.json");
 	log.dim("  Created .bumpy/README.md");

package/dist/logger-C2dEe5Su.mjs

@@ -0,0 +1,135 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+//#endregion
+//#region src/utils/logger.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const log = {
+	info(msg) {
+		console.log(`${import_picocolors.default.blue("info")} ${msg}`);
+	},
+	success(msg) {
+		console.log(`${import_picocolors.default.green("done")} ${msg}`);
+	},
+	warn(msg) {
+		console.log(`${import_picocolors.default.yellow("warn")} ${msg}`);
+	},
+	error(msg) {
+		console.error(`${import_picocolors.default.red("error")} ${msg}`);
+	},
+	step(msg) {
+		console.log(`${import_picocolors.default.cyan("=>")} ${msg}`);
+	},
+	dim(msg) {
+		console.log(import_picocolors.default.dim(msg));
+	},
+	bold(msg) {
+		console.log(import_picocolors.default.bold(msg));
+	},
+	table(rows) {
+		if (rows.length === 0) return;
+		const colWidths = rows[0].map((_, i) => Math.max(...rows.map((r) => (r[i] ?? "").length)));
+		for (const row of rows) console.log(row.map((cell, i) => cell.padEnd(colWidths[i])).join("  "));
+	}
+};
+function colorize(text, color) {
+	return import_picocolors.default[color](text);
+}
+//#endregion
+export { __exportAll as a, __commonJSMin as i, log as n, __toESM as o, require_picocolors as r, colorize as t };

package/dist/{migrate-DvOrXSw0.mjs → migrate-DmOYgmfD.mjs}

@@ -1,12 +1,13 @@
-import { n as log } from "./logger-ZqggsyGZ.mjs";
-import { a as readJson, n as exists, o as readText } from "./fs-DbNNEyzq.mjs";
-import { r as getBumpyDir } from "./config-CJ2orhTL.mjs";
-import { i as writeChangeset } from "./changeset-ClCYsChu.mjs";
-import { n as confirm } from "./prompt-BP8toAOI.mjs";
-import { initCommand } from "./init-Blw2GfC_.mjs";
+import { n as log, o as __toESM, r as require_picocolors } from "./logger-C2dEe5Su.mjs";
+import { a as readJson, n as exists, o as readText } from "./fs-DYR2XuFE.mjs";
+import { r as getBumpyDir } from "./config-XZWUL3ma.mjs";
+import { i as writeBumpFile } from "./bump-file-CCLXMLA8.mjs";
+import { a as fe, c as ot, n as O, o as gt, s as mt, t as unwrap } from "./clack-CDRCHrC-.mjs";
+import { initCommand } from "./init-lA9E5pEc.mjs";
 import { resolve } from "node:path";
 import { readdir } from "node:fs/promises";
 //#region src/commands/migrate.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 async function migrateCommand(rootDir, opts) {
 	const changesetDir = resolve(rootDir, ".changeset");
 	if (!await exists(changesetDir)) {
@@ -25,7 +26,7 @@ async function migrateCommand(rootDir, opts) {
 	}
 	const mdFiles = (await readdir(changesetDir)).filter((f) => f.endsWith(".md") && f !== "README.md");
 	if (mdFiles.length > 0) {
-		log.step(`Migrating ${mdFiles.length} pending changeset(s)...`);
+		log.step(`Migrating ${mdFiles.length} pending changeset(s) to bump files...`);
 		let migrated = 0;
 		for (const file of mdFiles) {
 			const result = parseChangesetFile(await readText(resolve(changesetDir, file)));
@@ -38,26 +39,32 @@ async function migrateCommand(rootDir, opts) {
 				log.dim(`  Skipped ${file} (already exists in .bumpy/)`);
 				continue;
 			}
-			await writeChangeset(rootDir, name, result.releases, result.summary);
+			await writeBumpFile(rootDir, name, result.releases, result.summary);
 			migrated++;
 			log.dim(`  Migrated ${file}`);
 		}
-		log.success(`Migrated ${migrated} changeset(s)`);
+		log.success(`Migrated ${migrated} bump file(s)`);
 	} else log.info("No pending changesets to migrate.");
 	if (!opts.force) {
-		console.log();
-		if (await confirm("Remove .changeset/ directory?", false)) {
+		mt(import_picocolors.default.bgCyan(import_picocolors.default.black(" bumpy migrate ")));
+		if (unwrap(await ot({
+			message: "Remove .changeset/ directory?",
+			initialValue: false
+		}))) {
+			const spin = fe();
+			spin.start("Removing .changeset/");
 			const { rm } = await import("node:fs/promises");
 			await rm(changesetDir, { recursive: true });
-			log.success("Removed .changeset/ directory");
-		} else log.dim("Keeping .changeset/ — you can remove it manually when ready.");
+			spin.stop("Removed .changeset/ directory");
+		} else O.info("Keeping .changeset/ — you can remove it manually when ready.");
+		gt(import_picocolors.default.green("Cleanup complete"));
 	}
 	console.log();
 	log.success("Migration complete!");
 	log.dim("Review .bumpy/_config.json and adjust settings as needed.");
 	log.dim("Key differences from changesets:");
-	log.dim("  - peerDependency bumps only propagate on major (not minor)");
-	log.dim("  - Use 'patch-isolated'/'minor-isolated' to skip propagation");
+	log.dim("  - Out-of-range peer dep bumps match the triggering bump level (not always major)");
+	log.dim("  - Use 'none' in a bump file to suppress a propagated bump");
 	log.dim("  - Per-package config goes in package.json[\"bumpy\"]");
 }
 async function migrateConfig(changesetConfigPath, bumpyDir) {
@@ -75,7 +82,7 @@ async function migrateConfig(changesetConfigPath, bumpyDir) {
 		"updateInternalDependencies",
 		"privatePackages"
 	]) if (csConfig[field] !== void 0) bumpyConfig[field] = csConfig[field];
-	const { writeJson } = await import("./fs-DbNNEyzq.mjs").then((n) => n.r);
+	const { writeJson } = await import("./fs-DYR2XuFE.mjs").then((n) => n.r);
 	await writeJson(bumpyConfigPath, bumpyConfig);
 	log.dim("  Migrated config fields: " + Object.keys(bumpyConfig).filter((k) => k !== "baseBranch" || bumpyConfig[k] !== "main").join(", "));
 }

package/dist/{names-C-u50ofE.mjs → names-9VubBmL0.mjs}

@@ -1,7 +1,8 @@
 //#region src/utils/names.ts
-/** Generate a random adjective-noun name for changeset files */
+/** Generate a random adjective-noun name for bump files */
 function randomName() {
-	return `${ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]}-${NOUNS[Math.floor(Math.random() * NOUNS.length)]}`;
+	const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+	return `${pick(ADJECTIVES)}-${pick(ADJECTIVES)}-${pick(NOUNS)}`;
 }
 /** Sanitize a user-provided name into a valid filename slug */
 function slugify(name) {

package/dist/package-manager-VCe10bjc.mjs

@@ -0,0 +1,80 @@
+import { a as readJson, n as exists, o as readText } from "./fs-DYR2XuFE.mjs";
+import { t as jsYaml } from "./js-yaml-DpZfOoD4.mjs";
+import { resolve } from "node:path";
+//#region src/utils/package-manager.ts
+/** Detect the package manager, extract workspace globs, and load catalogs */
+async function detectWorkspaces(rootDir) {
+	const pm = await detectPackageManager(rootDir);
+	return {
+		packageManager: pm,
+		globs: await getWorkspaceGlobs(rootDir, pm),
+		catalogs: await loadCatalogs(rootDir, pm)
+	};
+}
+async function detectPackageManager(rootDir) {
+	if (await exists(resolve(rootDir, "bun.lock")) || await exists(resolve(rootDir, "bun.lockb"))) return "bun";
+	if (await exists(resolve(rootDir, "pnpm-lock.yaml"))) return "pnpm";
+	if (await exists(resolve(rootDir, "yarn.lock"))) return "yarn";
+	try {
+		const pkg = await readJson(resolve(rootDir, "package.json"));
+		if (typeof pkg.packageManager === "string") {
+			const name = pkg.packageManager.split("@")[0];
+			if (name === "pnpm" || name === "yarn" || name === "bun") return name;
+		}
+	} catch {}
+	return "npm";
+}
+async function getWorkspaceGlobs(rootDir, pm) {
+	if (pm === "pnpm") {
+		const wsFile = resolve(rootDir, "pnpm-workspace.yaml");
+		if (await exists(wsFile)) {
+			const content = await readText(wsFile);
+			const parsed = jsYaml.load(content);
+			if (parsed?.packages) return parsed.packages;
+		}
+	}
+	try {
+		const workspaces = (await readJson(resolve(rootDir, "package.json"))).workspaces;
+		if (Array.isArray(workspaces)) return workspaces;
+		if (workspaces && typeof workspaces === "object" && "packages" in workspaces) {
+			const pkgs = workspaces.packages;
+			if (Array.isArray(pkgs)) return pkgs;
+		}
+	} catch {}
+	return [];
+}
+/** Load catalog definitions from pnpm-workspace.yaml or root package.json */
+async function loadCatalogs(rootDir, pm) {
+	const catalogs = /* @__PURE__ */ new Map();
+	if (pm === "pnpm") {
+		const wsFile = resolve(rootDir, "pnpm-workspace.yaml");
+		if (await exists(wsFile)) {
+			const content = await readText(wsFile);
+			const parsed = jsYaml.load(content);
+			if (parsed?.catalog) catalogs.set("", parsed.catalog);
+			if (parsed?.catalogs) for (const [name, deps] of Object.entries(parsed.catalogs)) catalogs.set(name, deps);
+		}
+	}
+	try {
+		const pkg = await readJson(resolve(rootDir, "package.json"));
+		if (pkg.catalog && typeof pkg.catalog === "object") catalogs.set("", pkg.catalog);
+		if (pkg.catalogs && typeof pkg.catalogs === "object") for (const [name, deps] of Object.entries(pkg.catalogs)) catalogs.set(name, deps);
+		const workspaces = pkg.workspaces;
+		if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+			const ws = workspaces;
+			if (ws.catalog && typeof ws.catalog === "object") catalogs.set("", ws.catalog);
+			if (ws.catalogs && typeof ws.catalogs === "object") for (const [name, deps] of Object.entries(ws.catalogs)) catalogs.set(name, deps);
+		}
+	} catch {}
+	return catalogs;
+}
+/** Resolve a specific dependency's catalog: reference */
+function resolveCatalogDep(depName, range, catalogs) {
+	if (!range.startsWith("catalog:")) return null;
+	const catalogName = range.slice(8).trim() || "";
+	const catalog = catalogs.get(catalogName);
+	if (!catalog) return null;
+	return catalog[depName] ?? null;
+}
+//#endregion
+export { detectWorkspaces as n, resolveCatalogDep as r, detectPackageManager as t };