@varlock/bumpy 0.0.2 → 1.1.0

package/.claude-plugin/plugin.json

@@ -1,13 +1,13 @@
 {
   "name": "bumpy",
   "version": "0.0.1",
-  "description": "AI-assisted changeset creation for bumpy monorepo versioning",
+  "description": "AI-assisted bump file creation for bumpy monorepo versioning",
   "author": {
     "name": "DMNO",
     "url": "https://github.com/dmno-dev"
   },
   "repository": "https://github.com/dmno-dev/bumpy",
   "license": "MIT",
-  "keywords": ["monorepo", "versioning", "changelog", "changesets"],
+  "keywords": ["monorepo", "versioning", "changelog", "bump-files"],
   "skills": "./skills/"
 }

package/config-schema.json

@@ -0,0 +1,327 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/dmno-dev/bumpy/main/packages/bumpy/config-schema.json",
+  "title": "Bumpy Configuration",
+  "description": "Configuration for @varlock/bumpy — monorepo versioning and changelog tool",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Path or URL to the JSON schema"
+    },
+    "baseBranch": {
+      "type": "string",
+      "description": "Branch used for release comparisons",
+      "default": "main"
+    },
+    "access": {
+      "type": "string",
+      "enum": ["public", "restricted"],
+      "description": "Default npm publish access level",
+      "default": "public"
+    },
+    "versionCommitMessage": {
+      "type": "string",
+      "description": "Customize the commit message used when versioning. A plain string is used as-is. A path starting with \"./\" or \"../\" is loaded as a module that exports a function receiving the release plan and returning a message string."
+    },
+    "changelog": {
+      "description": "Changelog formatter — \"default\", \"github\", or path to a custom formatter. Can also be a tuple of [formatter, options]. Set to false to disable changelog generation.",
+      "default": "default",
+      "oneOf": [
+        { "type": "boolean", "const": false },
+        { "type": "string" },
+        {
+          "type": "array",
+          "items": [{ "type": "string" }, { "type": "object" }],
+          "minItems": 2,
+          "maxItems": 2
+        }
+      ]
+    },
+    "changedFilePatterns": {
+      "type": "array",
+      "description": "Glob patterns to filter which changed files count toward marking a package as changed. Can be overridden per-package.",
+      "items": { "type": "string" },
+      "default": ["**"]
+    },
+    "fixed": {
+      "type": "array",
+      "description": "Package groups that always bump together to the same version. Each element is an array of package name globs.",
+      "items": {
+        "type": "array",
+        "items": { "type": "string" }
+      },
+      "default": []
+    },
+    "linked": {
+      "type": "array",
+      "description": "Package groups that share the highest bump level. Each element is an array of package name globs.",
+      "items": {
+        "type": "array",
+        "items": { "type": "string" }
+      },
+      "default": []
+    },
+    "ignore": {
+      "type": "array",
+      "description": "Package name globs to exclude from versioning",
+      "items": { "type": "string" },
+      "default": []
+    },
+    "include": {
+      "type": "array",
+      "description": "Package name globs to explicitly include (overrides ignore and privatePackages)",
+      "items": { "type": "string" },
+      "default": []
+    },
+    "updateInternalDependencies": {
+      "type": "string",
+      "enum": ["patch", "minor", "out-of-range"],
+      "description": "When to update internal dependency version ranges",
+      "default": "out-of-range"
+    },
+    "dependencyBumpRules": {
+      "type": "object",
+      "description": "Controls how bumps propagate through dependency types",
+      "properties": {
+        "dependencies": { "$ref": "#/$defs/dependencyBumpRule" },
+        "devDependencies": { "$ref": "#/$defs/dependencyBumpRule" },
+        "peerDependencies": { "$ref": "#/$defs/dependencyBumpRule" },
+        "optionalDependencies": { "$ref": "#/$defs/dependencyBumpRule" }
+      },
+      "additionalProperties": false
+    },
+    "privatePackages": {
+      "type": "object",
+      "description": "Whether to version and/or create git tags for private packages",
+      "properties": {
+        "version": {
+          "type": "boolean",
+          "description": "Whether to version private packages",
+          "default": false
+        },
+        "tag": {
+          "type": "boolean",
+          "description": "Whether to create git tags for private packages",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "allowCustomCommands": {
+      "description": "Allow per-package custom commands (buildCommand, publishCommand, checkPublished) defined in package.json \"bumpy\" fields. true = allow all, string[] = allow matching package name globs, false = only root-config commands allowed.",
+      "default": false,
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      ]
+    },
+    "packages": {
+      "type": "object",
+      "description": "Per-package config overrides, keyed by package name or glob pattern",
+      "additionalProperties": { "$ref": "#/$defs/packageConfig" }
+    },
+    "publish": {
+      "type": "object",
+      "description": "Publishing pipeline configuration",
+      "properties": {
+        "packManager": {
+          "type": "string",
+          "enum": ["auto", "npm", "pnpm", "bun", "yarn"],
+          "description": "Package manager to use for packing. \"auto\" detects from lockfile.",
+          "default": "auto"
+        },
+        "publishManager": {
+          "type": "string",
+          "enum": ["npm", "pnpm", "bun", "yarn"],
+          "description": "Command to use for publishing. npm supports OIDC/provenance.",
+          "default": "npm"
+        },
+        "publishArgs": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Extra args appended to the publish command (e.g., \"--provenance\")",
+          "default": []
+        },
+        "protocolResolution": {
+          "type": "string",
+          "enum": ["pack", "in-place", "none"],
+          "description": "How to handle workspace:/catalog: protocol resolution. \"pack\" = use PM's pack to build a clean tarball, \"in-place\" = rewrite package.json before publish, \"none\" = don't resolve.",
+          "default": "pack"
+        }
+      },
+      "additionalProperties": false
+    },
+    "aggregateRelease": {
+      "description": "GitHub release creation (requires gh CLI). false = individual release per package, true = single aggregated release, or an object with enabled and optional title (supports {{date}}).",
+      "default": false,
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Whether to create an aggregated release"
+            },
+            "title": {
+              "type": "string",
+              "description": "Custom title for the aggregated release (supports {{date}})"
+            }
+          },
+          "required": ["enabled"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "gitUser": {
+      "type": "object",
+      "description": "Git identity used for CI commits",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "Git user name",
+          "default": "bumpy-bot"
+        },
+        "email": {
+          "type": "string",
+          "description": "Git user email",
+          "default": "276066384+bumpy-bot@users.noreply.github.com"
+        }
+      },
+      "additionalProperties": false
+    },
+    "versionPr": {
+      "type": "object",
+      "description": "Customize the version PR created by bumpy ci release",
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "PR title",
+          "default": "🐸 Versioned release"
+        },
+        "branch": {
+          "type": "string",
+          "description": "Branch name for the version PR",
+          "default": "bumpy/version-packages"
+        },
+        "preamble": {
+          "type": "string",
+          "description": "HTML/markdown content prepended to the PR body"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "bumpType": {
+      "type": "string",
+      "enum": ["major", "minor", "patch"]
+    },
+    "dependencyBumpRule": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "trigger": {
+              "$ref": "#/$defs/bumpType",
+              "description": "Minimum bump level that triggers propagation"
+            },
+            "bumpAs": {
+              "description": "What level to bump the dependent (\"match\" mirrors the triggering level)",
+              "oneOf": [{ "$ref": "#/$defs/bumpType" }, { "type": "string", "const": "match" }]
+            }
+          },
+          "required": ["trigger", "bumpAs"],
+          "additionalProperties": false
+        },
+        {
+          "type": "boolean",
+          "const": false,
+          "description": "Set to false to disable propagation for this dependency type"
+        }
+      ]
+    },
+    "packageConfig": {
+      "type": "object",
+      "description": "Per-package configuration",
+      "properties": {
+        "managed": {
+          "type": "boolean",
+          "description": "Explicitly opt this package in or out of version management"
+        },
+        "access": {
+          "type": "string",
+          "enum": ["public", "restricted"],
+          "description": "Override the global access level"
+        },
+        "publishCommand": {
+          "description": "Custom command(s) to publish this package (replaces npm publish)",
+          "oneOf": [
+            { "type": "string" },
+            {
+              "type": "array",
+              "items": { "type": "string" }
+            }
+          ]
+        },
+        "buildCommand": {
+          "type": "string",
+          "description": "Command to run before publishing"
+        },
+        "registry": {
+          "type": "string",
+          "description": "Custom npm registry URL"
+        },
+        "skipNpmPublish": {
+          "type": "boolean",
+          "description": "Don't publish to npm (still creates git tags)"
+        },
+        "checkPublished": {
+          "type": "string",
+          "description": "Custom command that outputs the currently published version"
+        },
+        "changedFilePatterns": {
+          "type": "array",
+          "description": "Glob patterns to filter which changed files count toward marking this package as changed (overrides root setting)",
+          "items": { "type": "string" }
+        },
+        "dependencyBumpRules": {
+          "type": "object",
+          "description": "Per-package override for dependency propagation rules",
+          "properties": {
+            "dependencies": { "$ref": "#/$defs/dependencyBumpRule" },
+            "devDependencies": { "$ref": "#/$defs/dependencyBumpRule" },
+            "peerDependencies": { "$ref": "#/$defs/dependencyBumpRule" },
+            "optionalDependencies": { "$ref": "#/$defs/dependencyBumpRule" }
+          },
+          "additionalProperties": false
+        },
+        "cascadeTo": {
+          "type": "object",
+          "description": "Explicit cascade targets — glob pattern mapped to { trigger, bumpAs }",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "trigger": {
+                "$ref": "#/$defs/bumpType",
+                "description": "Minimum bump level that triggers the cascade"
+              },
+              "bumpAs": {
+                "description": "What level to bump the target",
+                "oneOf": [{ "$ref": "#/$defs/bumpType" }, { "type": "string", "const": "match" }]
+              }
+            },
+            "required": ["trigger", "bumpAs"],
+            "additionalProperties": false
+          }
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/dist/add-BmNL5VwL.mjs

@@ -0,0 +1,323 @@
+import { n as log, o as __toESM, r as require_picocolors } from "./logger-C2dEe5Su.mjs";
+import { n as exists, t as ensureDir } from "./fs-DYR2XuFE.mjs";
+import { a as loadConfig, o as loadPackageConfig, r as getBumpyDir, s as matchGlob } from "./config-B-Qg3DZH.mjs";
+import { t as discoverPackages } from "./workspace-DWXlwcH4.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { i as writeBumpFile } from "./bump-file-DVqR3k67.mjs";
+import { r as getChangedFiles } from "./git-YDedMddc.mjs";
+import { c as ot, d as yt, i as _t, l as pt, o as gt, r as Ot, s as mt, t as unwrap, u as wt } from "./clack-C6bVkGxf.mjs";
+import { n as slugify, t as randomName } from "./names-C-TuOPbd.mjs";
+import { t as require_picomatch } from "./picomatch-DMmqYjgq.mjs";
+import { relative, resolve } from "node:path";
+import * as readline from "node:readline";
+//#region src/prompts/bump-select.ts
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const LEVELS = [
+	"none",
+	"patch",
+	"minor",
+	"major"
+];
+/**
+* Custom interactive prompt for selecting bump levels for multiple packages.
+* - Up/Down arrows to navigate between packages
+* - Left/Right arrows to change the bump level
+* - Changed packages default to "patch", unchanged to "none"
+* - Enter to confirm
+* - Ctrl+C / Escape to cancel
+*/
+async function bumpSelectPrompt(items) {
+	const changedEntries = items.map((item, idx) => ({
+		item,
+		idx
+	})).filter(({ item }) => item.changed);
+	const unchangedEntries = items.map((item, idx) => ({
+		item,
+		idx
+	})).filter(({ item }) => !item.changed);
+	const displayOrder = [...changedEntries, ...unchangedEntries];
+	let cursor = 0;
+	const levels = items.map((item) => item.changed ? "patch" : "none");
+	return new Promise((resolve) => {
+		const { stdin, stdout } = process;
+		const rl = readline.createInterface({
+			input: stdin,
+			terminal: true
+		});
+		stdout.write("\x1B[?25l");
+		let renderedLines = 0;
+		function render(final = false) {
+			if (renderedLines > 0) {
+				stdout.write(`\x1B[${renderedLines}A`);
+				stdout.write("\x1B[0J");
+			}
+			const lines = [];
+			if (final) {
+				lines.push(`${import_picocolors.default.green("◇")}  Bump levels selected`);
+				const selected = displayOrder.filter(({ idx }) => levels[idx] !== "none");
+				if (selected.length === 0) lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.dim("(none)")}`);
+				else for (const { item, idx } of selected) lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.cyan(item.name)} ${import_picocolors.default.dim("→")} ${import_picocolors.default.bold(levels[idx])}`);
+				lines.push(import_picocolors.default.dim("│"));
+			} else {
+				lines.push(`${import_picocolors.default.cyan("◆")}  Select bump levels`);
+				lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.dim("↑/↓ navigate · ←/→ change level · enter to confirm")}`);
+				lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.dim("0 clear current · x clear all · r reset all to defaults")}`);
+				lines.push(import_picocolors.default.dim("│"));
+				let displayIdx = 0;
+				if (changedEntries.length > 0) {
+					lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.underline("Changed")}`);
+					for (const { item, idx } of changedEntries) {
+						lines.push(formatRow(item, levels[idx], cursor === displayIdx));
+						displayIdx++;
+					}
+					if (unchangedEntries.length > 0) lines.push(import_picocolors.default.dim("│"));
+				}
+				if (unchangedEntries.length > 0) {
+					lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.underline("Unchanged")}`);
+					for (const { item, idx } of unchangedEntries) {
+						lines.push(formatRow(item, levels[idx], cursor === displayIdx));
+						displayIdx++;
+					}
+				}
+				lines.push(import_picocolors.default.dim("│"));
+				const selectedCount = levels.filter((l) => l !== "none").length;
+				lines.push(`${import_picocolors.default.dim("│")}  ${import_picocolors.default.dim(`${selectedCount} package${selectedCount !== 1 ? "s" : ""} selected`)}`);
+				lines.push(`${import_picocolors.default.dim("└")}`);
+			}
+			const output = lines.join("\n") + "\n";
+			stdout.write(output);
+			renderedLines = lines.length;
+		}
+		function cleanup() {
+			rl.close();
+			stdout.write("\x1B[?25h");
+			if (stdin.isTTY) stdin.setRawMode(false);
+		}
+		function finish(result) {
+			render(true);
+			cleanup();
+			resolve(result);
+		}
+		if (stdin.isTTY) stdin.setRawMode(true);
+		stdin.resume();
+		render();
+		stdin.on("keypress", (_str, key) => {
+			if (!key) return;
+			if (key.name === "escape" || key.ctrl && key.name === "c") {
+				cleanup();
+				if (renderedLines > 0) {
+					stdout.write(`\x1B[${renderedLines}A`);
+					stdout.write("\x1B[0J");
+				}
+				stdout.write(`${import_picocolors.default.red("■")}  Cancelled\n`);
+				resolve(Symbol("cancel"));
+				return;
+			}
+			if (key.name === "return") {
+				const results = [];
+				for (let i = 0; i < items.length; i++) if (levels[i] !== "none") results.push({
+					name: items[i].name,
+					type: levels[i]
+				});
+				finish(results);
+				return;
+			}
+			if (key.name === "up" || key.name === "k") cursor = (cursor - 1 + displayOrder.length) % displayOrder.length;
+			else if (key.name === "down" || key.name === "j") cursor = (cursor + 1) % displayOrder.length;
+			else if (key.name === "right" || key.name === "l") {
+				const entry = displayOrder[cursor];
+				const currentLevel = LEVELS.indexOf(levels[entry.idx]);
+				if (currentLevel < LEVELS.length - 1) levels[entry.idx] = LEVELS[currentLevel + 1];
+			} else if (key.name === "left" || key.name === "h") {
+				const entry = displayOrder[cursor];
+				const currentLevel = LEVELS.indexOf(levels[entry.idx]);
+				if (currentLevel > 0) levels[entry.idx] = LEVELS[currentLevel - 1];
+			} else if (_str === "0" || key.name === "backspace") {
+				const entry = displayOrder[cursor];
+				levels[entry.idx] = "none";
+			} else if (_str === "r") for (let i = 0; i < items.length; i++) levels[i] = items[i].changed ? "patch" : "none";
+			else if (_str === "x") for (let i = 0; i < items.length; i++) levels[i] = "none";
+			render();
+		});
+		readline.emitKeypressEvents(stdin, rl);
+	});
+}
+function formatRow(item, level, focused) {
+	return `${import_picocolors.default.dim("│")}  ${focused ? import_picocolors.default.cyan("›") : " "} ${focused ? import_picocolors.default.cyan(item.name) : item.name} ${import_picocolors.default.dim(`(${item.version})`)}  ${formatLevel(level, focused)}`;
+}
+function formatLevel(level, focused) {
+	if (!focused) {
+		if (level === "none") return import_picocolors.default.dim("·");
+		if (level === "major") return import_picocolors.default.red(level);
+		if (level === "minor") return import_picocolors.default.yellow(level);
+		return import_picocolors.default.green(level);
+	}
+	return `◄ ${LEVELS.map((l) => {
+		if (l === level) {
+			if (l === "none") return import_picocolors.default.bold(import_picocolors.default.dim("[none]"));
+			if (l === "major") return import_picocolors.default.bold(import_picocolors.default.red(`[${l}]`));
+			if (l === "minor") return import_picocolors.default.bold(import_picocolors.default.yellow(`[${l}]`));
+			return import_picocolors.default.bold(import_picocolors.default.green(`[${l}]`));
+		}
+		return import_picocolors.default.dim(l);
+	}).join(import_picocolors.default.dim(" · "))} ►`;
+}
+//#endregion
+//#region src/commands/add.ts
+const CASCADE_CHOICES = [
+	{
+		label: "patch",
+		value: "patch"
+	},
+	{
+		label: "minor",
+		value: "minor"
+	},
+	{
+		label: "major",
+		value: "major"
+	}
+];
+async function addCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const bumpyDir = getBumpyDir(rootDir);
+	await ensureDir(bumpyDir);
+	if (opts.empty) {
+		const filename = opts.name ? slugify(opts.name) : randomName();
+		const filePath = resolve(bumpyDir, `${filename}.md`);
+		const { writeText } = await import("./fs-DYR2XuFE.mjs").then((n) => n.r);
+		await writeText(filePath, "---\n---\n");
+		log.success(`🐸 Created empty bump file: .bumpy/${filename}.md`);
+		return;
+	}
+	let releases;
+	let summary;
+	let filename;
+	if (opts.packages) {
+		releases = parsePackagesFlag(opts.packages);
+		summary = opts.message || "";
+		filename = opts.name ? slugify(opts.name) : randomName();
+	} else {
+		mt(import_picocolors.default.bgCyan(import_picocolors.default.black(" bumpy add ")));
+		const pkgs = await discoverPackages(rootDir, config);
+		const depGraph = new DependencyGraph(pkgs);
+		if (pkgs.size === 0) {
+			pt("No managed packages found in this workspace.");
+			process.exit(1);
+		}
+		const baseBranch = config.baseBranch;
+		const changedFiles = getChangedFiles(rootDir, baseBranch);
+		const matchers = /* @__PURE__ */ new Map();
+		for (const [name, pkg] of pkgs) {
+			const patterns = (await loadPackageConfig(pkg.dir, config, name)).changedFilePatterns ?? config.changedFilePatterns;
+			matchers.set(name, (0, import_picomatch.default)(patterns));
+		}
+		const changedPackageNames = /* @__PURE__ */ new Set();
+		for (const file of changedFiles) for (const [name, pkg] of pkgs) {
+			const pkgRelDir = relative(rootDir, pkg.dir);
+			if (file.startsWith(pkgRelDir + "/")) {
+				const relToPackage = file.slice(pkgRelDir.length + 1);
+				if (matchers.get(name)(relToPackage)) changedPackageNames.add(name);
+			}
+		}
+		const bumpSelectResult = await bumpSelectPrompt([...pkgs.values()].map((pkg) => ({
+			name: pkg.name,
+			version: pkg.version,
+			changed: changedPackageNames.has(pkg.name)
+		})));
+		if (typeof bumpSelectResult === "symbol") {
+			pt("Aborted");
+			process.exit(0);
+		}
+		const bumpSelections = bumpSelectResult;
+		if (bumpSelections.length === 0) {
+			pt("No packages selected.");
+			process.exit(0);
+		}
+		releases = [];
+		for (const { name, type: bumpType } of bumpSelections) {
+			const release = {
+				name,
+				type: bumpType
+			};
+			{
+				const dependents = depGraph.getDependents(name);
+				const cascadeTargets = pkgs.get(name).bumpy?.cascadeTo;
+				if (dependents.length > 0 || cascadeTargets) {
+					if (unwrap(await ot({
+						message: `${import_picocolors.default.cyan(name)} has ${import_picocolors.default.bold(String(dependents.length))} dependents. Specify explicit cascades?`,
+						initialValue: false
+					}))) {
+						const allTargets = /* @__PURE__ */ new Set();
+						for (const d of dependents) allTargets.add(d.name);
+						if (cascadeTargets) {
+							for (const pattern of Object.keys(cascadeTargets)) for (const [pName] of pkgs) if (matchGlob(pName, pattern)) allTargets.add(pName);
+						}
+						const cascadeSelected = unwrap(await yt({
+							message: "Which packages should cascade?",
+							options: [...allTargets].map((n) => ({
+								label: n,
+								value: n
+							})),
+							required: false
+						}));
+						if (cascadeSelected.length > 0) {
+							const cascadeBump = unwrap(await _t({
+								message: "Cascade bump type",
+								options: CASCADE_CHOICES
+							}));
+							const cascade = {};
+							for (const target of cascadeSelected) cascade[target] = cascadeBump;
+							release.cascade = cascade;
+						}
+					}
+				}
+			}
+			releases.push(release);
+		}
+		summary = unwrap(await Ot({
+			message: "Summary (what changed and why)",
+			placeholder: "A short description of the change",
+			validate: (value) => {
+				if (!value || !value.trim()) return "Summary is required";
+			}
+		}));
+		const defaultName = randomName();
+		filename = slugify(unwrap(await Ot({
+			message: "Bump file name",
+			placeholder: defaultName,
+			defaultValue: defaultName,
+			validate: (value) => {
+				if (!value) return void 0;
+				if (!slugify(value)) return "Name must contain at least one alphanumeric character";
+			}
+		}))) || defaultName;
+	}
+	if (await exists(resolve(bumpyDir, `${filename}.md`))) filename = `${filename}-${Date.now()}`;
+	await writeBumpFile(rootDir, filename, releases, summary);
+	if (opts.packages) {
+		log.success(`🐸 Created bump file: .bumpy/${filename}.md`);
+		for (const r of releases) log.dim(`  ${r.name}: ${r.type}${formatCascade(r)}`);
+	} else {
+		wt(releases.map((r) => `${import_picocolors.default.cyan(r.name)} ${import_picocolors.default.dim("→")} ${import_picocolors.default.bold(r.type)}${formatCascade(r)}`).join("\n"), "Bump file");
+		gt(import_picocolors.default.green(`🐸 Created .bumpy/${filename}.md`));
+	}
+}
+function formatCascade(r) {
+	if (!("cascade" in r) || Object.keys(r.cascade).length === 0) return "";
+	const parts = Object.entries(r.cascade).map(([k, v]) => `${k}:${v}`);
+	return import_picocolors.default.dim(` (cascade: ${parts.join(", ")})`);
+}
+function parsePackagesFlag(input) {
+	return input.split(",").map((entry) => {
+		const [name, type] = entry.trim().split(":");
+		if (!name || !type) throw new Error(`Invalid package format: "${entry}". Expected "name:bumpType"`);
+		return {
+			name: name.trim(),
+			type: type.trim()
+		};
+	});
+}
+//#endregion
+export { addCommand };