@varlock/bumpy 0.0.0 → 0.0.1

package/dist/logger-ZqggsyGZ.mjs

@@ -0,0 +1,176 @@
+//#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));
+const { Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, bold, dim, italic, underline, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let e, t, r, { defineProperty: l, setPrototypeOf: n, create: o, keys: s } = Object, i = "", { round: c, max: a } = Math, p = (e) => {
+		let t = /([a-f\d]{3,6})/i.exec(e)?.[1], r = t?.length, l = parseInt(6 ^ r ? 3 ^ r ? "0" : t[0] + t[0] + t[1] + t[1] + t[2] + t[2] : t, 16);
+		return [
+			l >> 16 & 255,
+			l >> 8 & 255,
+			255 & l
+		];
+	}, u = (e, t, r) => e ^ t || t ^ r ? 16 + 36 * c(e / 51) + 6 * c(t / 51) + c(r / 51) : 8 > e ? 16 : e > 248 ? 231 : c(24 * (e - 8) / 247) + 232, d = (e) => {
+		let t, r, l, n, o;
+		return 8 > e ? 30 + e : 16 > e ? e - 8 + 90 : (232 > e ? (o = (e -= 16) % 36, t = (e / 36 | 0) / 5, r = (o / 6 | 0) / 5, l = o % 6 / 5) : t = r = l = (10 * (e - 232) + 8) / 255, n = 2 * a(t, r, l), n ? 30 + (c(l) << 2 | c(r) << 1 | c(t)) + (2 ^ n ? 0 : 60) : 30);
+	}, f = (() => {
+		let r = (e) => o.some(((t) => e.test(t))), l = globalThis, n = l.process ?? {}, o = n.argv ?? [], i = n.env ?? {}, c = -1;
+		try {
+			e = "," + s(i).join(",");
+		} catch (e) {
+			i = {}, c = 0;
+		}
+		let a = "FORCE_COLOR", p = {
+			false: 0,
+			0: 0,
+			1: 1,
+			2: 2,
+			3: 3
+		}[i[a]] ?? -1, u = a in i && p || r(/^--color=?(true|always)?$/);
+		return u && (c = p), ~c || (c = ((r, l, n) => (t = r.TERM, {
+			"24bit": 3,
+			truecolor: 3,
+			ansi256: 2,
+			ansi: 1
+		}[r.COLORTERM] || (r.CI ? /,GITHUB/.test(e) ? 3 : 1 : l && "dumb" !== t ? n ? 3 : /-256/.test(t) ? 2 : 1 : 0)))(i, !!i.PM2_HOME || i.NEXT_RUNTIME?.includes("edge") || !!n.stdout?.isTTY, "win32" === n.platform)), !p || i.NO_COLOR || r(/^--(no-color|color=(false|never))$/) ? 0 : l.window?.chrome || u && !c ? 3 : c;
+	})(), g = {
+		open: i,
+		close: i
+	}, h = 39, b = 49, O = {}, m = ({ p: e }, { open: t, close: l }) => {
+		let o = (e, ...r) => {
+			if (!e) {
+				if (t && t === l) return t;
+				if ((e ?? i) === i) return i;
+			}
+			let n, s = e.raw ? String.raw({ raw: e }, ...r) : i + e, c = o.p, a = c.o, p = c.c;
+			if (s.includes("\x1B")) for (; c; c = c.p) {
+				let { open: e, close: t } = c, r = t.length, l = i, o = 0;
+				if (r) for (; ~(n = s.indexOf(t, o)); o = n + r) l += s.slice(o, n) + e;
+				s = l + s.slice(o);
+			}
+			return a + (s.includes("\n") ? s.replace(/(\r?\n)/g, p + "$1" + a) : s) + p;
+		}, s = t, c = l;
+		return e && (s = e.o + t, c = l + e.c), n(o, r), o.p = {
+			open: t,
+			close: l,
+			o: s,
+			c,
+			p: e
+		}, o.open = s, o.close = c, o;
+	};
+	const w = new function e(t = f) {
+		let s = {
+			Ansis: e,
+			level: t,
+			isSupported: () => a,
+			strip: (e) => e.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, i),
+			extend(e) {
+				for (let t in e) {
+					let r = e[t], l = (typeof r)[0];
+					"s" === l ? (c(t, T(...p(r))), c(_(t), v(...p(r)))) : c(t, r, "f" === l);
+				}
+				return r = o({}, O), n(s, r), s;
+			}
+		}, c = (e, t, r) => {
+			O[e] = { get() {
+				let n = r ? (...e) => m(this, t(...e)) : m(this, t);
+				return l(this, e, { value: n }), n;
+			} };
+		}, a = t > 0, w = (e, t) => a ? {
+			open: `[${e}m`,
+			close: `[${t}m`
+		} : g, y = (e) => (t) => e(...p(t)), R = (e, t) => (r, l, n) => w(`${e}8;2;${r};${l};${n}`, t), $ = (e, t) => (r, l, n) => w(((e, t, r) => d(u(e, t, r)))(r, l, n) + e, t), x = (e) => (t, r, l) => e(u(t, r, l)), T = R(3, h), v = R(4, b), C = (e) => w("38;5;" + e, h), E = (e) => w("48;5;" + e, b);
+		2 === t ? (T = x(C), v = x(E)) : 1 === t && (T = $(0, h), v = $(10, b), C = (e) => w(d(e), h), E = (e) => w(d(e) + 10, b));
+		let M, I = {
+			fg: C,
+			bg: E,
+			rgb: T,
+			bgRgb: v,
+			hex: y(T),
+			bgHex: y(v),
+			visible: g,
+			reset: w(0, 0),
+			bold: w(1, 22),
+			dim: w(2, 22),
+			italic: w(3, 23),
+			underline: w(4, 24),
+			inverse: w(7, 27),
+			hidden: w(8, 28),
+			strikethrough: w(9, 29)
+		}, _ = (e) => "bg" + e[0].toUpperCase() + e.slice(1), k = "Bright";
+		return "black,red,green,yellow,blue,magenta,cyan,white,gray".split(",").map(((e, t) => {
+			M = _(e), 8 > t ? (I[e + k] = w(90 + t, h), I[M + k] = w(100 + t, b)) : t = 60, I[e] = w(30 + t, h), I[M] = w(40 + t, b);
+		})), s.extend(I);
+	}();
+	module.exports = w, w.default = w;
+})))(), 1)).default;
+//#endregion
+//#region src/utils/logger.ts
+const log = {
+	info(msg) {
+		console.log(`${blue`info`} ${msg}`);
+	},
+	success(msg) {
+		console.log(`${green`done`} ${msg}`);
+	},
+	warn(msg) {
+		console.log(`${yellow`warn`} ${msg}`);
+	},
+	error(msg) {
+		console.error(`${red`error`} ${msg}`);
+	},
+	step(msg) {
+		console.log(`${cyan`=>`} ${msg}`);
+	},
+	dim(msg) {
+		console.log(dim`${msg}`);
+	},
+	bold(msg) {
+		console.log(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 {
+		red,
+		green,
+		yellow,
+		blue,
+		cyan,
+		dim,
+		bold
+	}[color](text);
+}
+//#endregion
+export { __toESM as a, __exportAll as i, log as n, __commonJSMin as r, colorize as t };

package/dist/migrate-DvOrXSw0.mjs

@@ -0,0 +1,114 @@
+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 { resolve } from "node:path";
+import { readdir } from "node:fs/promises";
+//#region src/commands/migrate.ts
+async function migrateCommand(rootDir, opts) {
+	const changesetDir = resolve(rootDir, ".changeset");
+	if (!await exists(changesetDir)) {
+		log.error("No .changeset/ directory found. Nothing to migrate.");
+		process.exit(1);
+	}
+	const bumpyDir = getBumpyDir(rootDir);
+	if (!await exists(resolve(bumpyDir, "_config.json"))) {
+		log.step("Initializing .bumpy/ directory...");
+		await initCommand(rootDir);
+	}
+	const changesetConfigPath = resolve(changesetDir, "config.json");
+	if (await exists(changesetConfigPath)) {
+		log.step("Migrating config from .changeset/config.json...");
+		await migrateConfig(changesetConfigPath, bumpyDir);
+	}
+	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)...`);
+		let migrated = 0;
+		for (const file of mdFiles) {
+			const result = parseChangesetFile(await readText(resolve(changesetDir, file)));
+			if (!result) {
+				log.warn(`  Skipped ${file} (could not parse)`);
+				continue;
+			}
+			const name = file.replace(/\.md$/, "");
+			if (await exists(resolve(bumpyDir, file))) {
+				log.dim(`  Skipped ${file} (already exists in .bumpy/)`);
+				continue;
+			}
+			await writeChangeset(rootDir, name, result.releases, result.summary);
+			migrated++;
+			log.dim(`  Migrated ${file}`);
+		}
+		log.success(`Migrated ${migrated} changeset(s)`);
+	} else log.info("No pending changesets to migrate.");
+	if (!opts.force) {
+		console.log();
+		if (await confirm("Remove .changeset/ directory?", false)) {
+			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.");
+	}
+	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("  - Per-package config goes in package.json[\"bumpy\"]");
+}
+async function migrateConfig(changesetConfigPath, bumpyDir) {
+	const csConfig = await readJson(changesetConfigPath);
+	const bumpyConfigPath = resolve(bumpyDir, "_config.json");
+	let bumpyConfig = {};
+	if (await exists(bumpyConfigPath)) bumpyConfig = await readJson(bumpyConfigPath);
+	for (const field of [
+		"baseBranch",
+		"access",
+		"commit",
+		"fixed",
+		"linked",
+		"ignore",
+		"updateInternalDependencies",
+		"privatePackages"
+	]) if (csConfig[field] !== void 0) bumpyConfig[field] = csConfig[field];
+	const { writeJson } = await import("./fs-DbNNEyzq.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(", "));
+}
+/** Parse a changesets-format markdown file */
+function parseChangesetFile(content) {
+	const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return null;
+	const frontmatter = match[1].trim();
+	const summary = match[2].trim();
+	if (!frontmatter) return null;
+	const releases = [];
+	for (const line of frontmatter.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const lineMatch = trimmed.match(/^"?([^"]+)"?\s*:\s*(.+)$/);
+		if (!lineMatch) continue;
+		const name = lineMatch[1].trim();
+		const type = lineMatch[2].trim();
+		if (type === "none") continue;
+		if ([
+			"major",
+			"minor",
+			"patch"
+		].includes(type)) releases.push({
+			name,
+			type
+		});
+	}
+	if (releases.length === 0 && !summary) return null;
+	return {
+		releases,
+		summary
+	};
+}
+//#endregion
+export { migrateCommand };

package/dist/names-C-u50ofE.mjs

@@ -0,0 +1,143 @@
+//#region src/utils/names.ts
+/** Generate a random adjective-noun name for changeset files */
+function randomName() {
+	return `${ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]}-${NOUNS[Math.floor(Math.random() * NOUNS.length)]}`;
+}
+/** Sanitize a user-provided name into a valid filename slug */
+function slugify(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+const ADJECTIVES = [
+	"brave",
+	"calm",
+	"dark",
+	"eager",
+	"fair",
+	"gentle",
+	"happy",
+	"icy",
+	"jolly",
+	"keen",
+	"lively",
+	"merry",
+	"neat",
+	"odd",
+	"proud",
+	"quiet",
+	"rare",
+	"shy",
+	"tall",
+	"warm",
+	"young",
+	"bold",
+	"cool",
+	"dry",
+	"fast",
+	"glad",
+	"huge",
+	"kind",
+	"lazy",
+	"mild",
+	"new",
+	"old",
+	"pink",
+	"red",
+	"safe",
+	"thin",
+	"vast",
+	"wide",
+	"witty",
+	"zany",
+	"bright",
+	"clean",
+	"deep",
+	"fresh",
+	"grand",
+	"light",
+	"pure",
+	"rich",
+	"sharp",
+	"smooth",
+	"soft",
+	"swift",
+	"tough",
+	"wild",
+	"wise",
+	"tidy",
+	"silver",
+	"golden",
+	"copper",
+	"amber",
+	"coral",
+	"jade",
+	"violet",
+	"rusty"
+];
+const NOUNS = [
+	"ant",
+	"bee",
+	"cat",
+	"dog",
+	"elk",
+	"fox",
+	"gnu",
+	"hen",
+	"ibis",
+	"jay",
+	"koi",
+	"lark",
+	"moth",
+	"newt",
+	"owl",
+	"pug",
+	"quail",
+	"ram",
+	"seal",
+	"toad",
+	"urchin",
+	"vole",
+	"wasp",
+	"yak",
+	"bass",
+	"clam",
+	"dove",
+	"eel",
+	"frog",
+	"goat",
+	"hawk",
+	"igloo",
+	"jade",
+	"kite",
+	"lake",
+	"moon",
+	"nest",
+	"oak",
+	"pine",
+	"reef",
+	"star",
+	"tree",
+	"wave",
+	"fern",
+	"lily",
+	"rose",
+	"sage",
+	"vine",
+	"dawn",
+	"dusk",
+	"mist",
+	"rain",
+	"snow",
+	"wind",
+	"glow",
+	"haze",
+	"crab",
+	"deer",
+	"finch",
+	"heron",
+	"crane",
+	"robin",
+	"swift",
+	"trout"
+];
+//#endregion
+export { slugify as n, randomName as t };

package/dist/prompt-BP8toAOI.mjs

@@ -0,0 +1,46 @@
+import * as readline from "node:readline";
+//#region src/utils/prompt.ts
+function createInterface() {
+	return readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+}
+async function ask(question, defaultValue) {
+	const rl = createInterface();
+	const suffix = defaultValue ? ` (${defaultValue})` : "";
+	return new Promise((resolve) => {
+		rl.question(`${question}${suffix}: `, (answer) => {
+			rl.close();
+			resolve(answer.trim() || defaultValue || "");
+		});
+	});
+}
+async function confirm(question, defaultYes = true) {
+	const answer = await ask(`${question} [${defaultYes ? "Y/n" : "y/N"}]`);
+	if (!answer) return defaultYes;
+	return answer.toLowerCase().startsWith("y");
+}
+async function select(question, options) {
+	console.log(question);
+	for (let i = 0; i < options.length; i++) console.log(`  ${i + 1}) ${options[i].label}`);
+	const answer = await ask("Choose");
+	const idx = parseInt(answer, 10) - 1;
+	if (idx >= 0 && idx < options.length) return options[idx].value;
+	const match = options.find((o) => o.value === answer || o.label.toLowerCase() === answer.toLowerCase());
+	if (match) return match.value;
+	return options[0].value;
+}
+async function multiSelect(question, options) {
+	console.log(question);
+	for (let i = 0; i < options.length; i++) {
+		const mark = options[i].checked ? "[x]" : "[ ]";
+		console.log(`  ${i + 1}) ${mark} ${options[i].label}`);
+	}
+	const answer = await ask("Select (comma-separated numbers, or 'all')");
+	if (answer.toLowerCase() === "all") return options.map((o) => o.value);
+	if (!answer) return options.filter((o) => o.checked).map((o) => o.value);
+	return answer.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((i) => i >= 0 && i < options.length).map((i) => options[i].value);
+}
+//#endregion
+export { select as i, confirm as n, multiSelect as r, ask as t };

package/dist/publish-DZ3m7qkX.mjs

@@ -0,0 +1,197 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { a as loadConfig } from "./config-CJ2orhTL.mjs";
+import { n as discoverWorkspace, r as detectWorkspaces } from "./workspace-mVjawG8g.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { i as tryRun, n as runAsync } from "./shell-DPlltpzb.mjs";
+import { n as hasUncommittedChanges, r as pushWithTags, t as publishPackages } from "./publish-pipeline-1M5GmbdP.mjs";
+//#region src/core/github-release.ts
+/** Create individual GitHub releases for each published package */
+async function createIndividualReleases(releases, changesets, rootDir, opts = {}) {
+	if (!isGhAvailable()) {
+		log.dim("  gh CLI not found — skipping GitHub releases");
+		return;
+	}
+	for (const release of releases) {
+		const tag = `${release.name}@${release.newVersion}`;
+		const body = buildReleaseBody(release, changesets);
+		const title = `${release.name} v${release.newVersion}`;
+		if (opts.dryRun) {
+			log.dim(`  Would create GitHub release: ${title}`);
+			continue;
+		}
+		try {
+			await runAsync(`gh release create "${tag}" --title "${escapeShell(title)}" --notes "${escapeShell(body)}"`, { cwd: rootDir });
+			log.dim(`  Created GitHub release: ${title}`);
+		} catch (err) {
+			log.warn(`  Failed to create GitHub release for ${tag}: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+}
+/** Create a single aggregated GitHub release for all published packages */
+async function createAggregateRelease(releases, changesets, rootDir, opts = {}) {
+	if (!isGhAvailable()) {
+		log.dim("  gh CLI not found — skipping GitHub release");
+		return;
+	}
+	if (releases.length === 0) return;
+	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const title = (opts.title || "Release {{date}}").replace("{{date}}", date);
+	const tag = `release-${date}`;
+	const body = buildAggregateBody(releases, changesets);
+	if (opts.dryRun) {
+		log.dim(`  Would create aggregate GitHub release: ${title}`);
+		log.dim(`  Tag: ${tag}`);
+		return;
+	}
+	try {
+		tryRun(`git tag "${tag}"`, { cwd: rootDir });
+		await runAsync(`gh release create "${tag}" --title "${escapeShell(title)}" --notes "${escapeShell(body)}"`, { cwd: rootDir });
+		log.success(`Created aggregate GitHub release: ${title}`);
+	} catch (err) {
+		log.warn(`Failed to create aggregate GitHub release: ${err instanceof Error ? err.message : err}`);
+	}
+}
+function buildReleaseBody(release, changesets) {
+	const lines = [];
+	const relevant = changesets.filter((cs) => release.changesets.includes(cs.id));
+	if (relevant.length > 0) {
+		for (const cs of relevant) if (cs.summary) lines.push(`- ${cs.summary.split("\n")[0]}`);
+	}
+	if (release.isDependencyBump && relevant.length === 0) lines.push("- Updated dependencies");
+	return lines.join("\n") || "No changelog entries.";
+}
+function buildAggregateBody(releases, changesets) {
+	const lines = [];
+	const groups = [
+		["Major Changes", releases.filter((r) => r.type === "major")],
+		["Minor Changes", releases.filter((r) => r.type === "minor")],
+		["Patch Changes", releases.filter((r) => r.type === "patch")]
+	];
+	for (const [heading, group] of groups) {
+		if (group.length === 0) continue;
+		lines.push(`## ${heading}\n`);
+		for (const release of group) {
+			lines.push(`### ${release.name} v${release.newVersion}\n`);
+			const relevant = changesets.filter((cs) => release.changesets.includes(cs.id));
+			if (relevant.length > 0) {
+				for (const cs of relevant) if (cs.summary) lines.push(`- ${cs.summary.split("\n")[0]}`);
+			} else if (release.isDependencyBump) lines.push("- Updated dependencies");
+			else if (release.isCascadeBump) lines.push("- Version bump via cascade rule");
+			lines.push("");
+		}
+	}
+	return lines.join("\n").trim() || "No changelog entries.";
+}
+function isGhAvailable() {
+	return tryRun("gh --version") !== null;
+}
+function escapeShell(str) {
+	return str.replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+}
+//#endregion
+//#region src/commands/publish.ts
+/**
+* Publish packages that have been versioned but not yet published.
+* Detects unpublished versions by comparing package.json versions against npm registry.
+*/
+async function publishCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const { packages, catalogs } = await discoverWorkspace(rootDir, config);
+	const { packageManager: detectedPm } = await detectWorkspaces(rootDir);
+	const depGraph = new DependencyGraph(packages);
+	if (!opts.dryRun && hasUncommittedChanges({ cwd: rootDir })) {
+		log.warn("You have uncommitted changes. Commit or stash them before publishing.");
+		process.exit(1);
+	}
+	let toPublish = await findUnpublishedPackages(packages, config);
+	if (opts.filter) {
+		const { matchGlob } = await import("./config-CJ2orhTL.mjs").then((n) => n.t);
+		const patterns = opts.filter.split(",").map((p) => p.trim());
+		toPublish = toPublish.filter((r) => patterns.some((p) => matchGlob(r.name, p)));
+	}
+	if (toPublish.length === 0) {
+		log.info("No unpublished packages found.");
+		return;
+	}
+	const releasePlan = {
+		changesets: [],
+		releases: toPublish
+	};
+	if (opts.dryRun) log.bold("Dry run — would publish:");
+	else log.bold("Publishing:");
+	for (const r of toPublish) console.log(`  ${r.name}@${colorize(r.newVersion, "cyan")}`);
+	console.log();
+	const result = await publishPackages(releasePlan, packages, depGraph, config, rootDir, {
+		dryRun: opts.dryRun,
+		tag: opts.tag
+	}, catalogs, detectedPm);
+	if (result.published.length > 0) log.success(`Published ${result.published.length} package(s)`);
+	if (result.skipped.length > 0) log.dim(`Skipped ${result.skipped.length}: ${result.skipped.map((s) => s.name).join(", ")}`);
+	if (result.failed.length > 0) {
+		log.error(`Failed ${result.failed.length}: ${result.failed.map((f) => `${f.name} (${f.error})`).join(", ")}`);
+		process.exit(1);
+	}
+	if (!opts.dryRun && !opts.noPush && result.published.length > 0) try {
+		log.step("Pushing tags...");
+		pushWithTags({ cwd: rootDir });
+		log.success("Pushed tags to remote");
+	} catch (err) {
+		log.warn(`Failed to push tags: ${err instanceof Error ? err.message : err}`);
+	}
+	if (result.published.length > 0) {
+		const publishedReleases = releasePlan.releases.filter((r) => result.published.some((p) => p.name === r.name));
+		const aggConfig = config.aggregateRelease;
+		const isAggregate = aggConfig === true || typeof aggConfig === "object" && aggConfig.enabled;
+		const aggTitle = typeof aggConfig === "object" ? aggConfig.title : void 0;
+		if (isAggregate) await createAggregateRelease(publishedReleases, releasePlan.changesets, rootDir, {
+			dryRun: opts.dryRun,
+			title: aggTitle
+		});
+		else await createIndividualReleases(publishedReleases, releasePlan.changesets, rootDir, { dryRun: opts.dryRun });
+	}
+}
+/**
+* Find packages whose current version is not yet published.
+*
+* Detection strategy (per package):
+* 1. Custom `checkPublished` command → run it, compare output to current version
+* 2. `skipNpmPublish` or custom `publishCommand` → check git tags
+* 3. Default → check npm registry via `npm info`
+*/
+async function findUnpublishedPackages(packages, _config) {
+	const unpublished = [];
+	for (const [name, pkg] of packages) {
+		if (pkg.private && !pkg.bumpy?.publishCommand) continue;
+		if (pkg.version === "0.0.0") continue;
+		if (!await checkIfPublished(name, pkg.version, pkg.bumpy)) unpublished.push({
+			name,
+			type: "patch",
+			oldVersion: pkg.version,
+			newVersion: pkg.version,
+			changesets: [],
+			isDependencyBump: false,
+			isCascadeBump: false
+		});
+	}
+	return unpublished;
+}
+async function checkIfPublished(name, version, pkgConfig) {
+	const { runAsync } = await import("./shell-DPlltpzb.mjs").then((n) => n.r);
+	const { tryRun } = await import("./shell-DPlltpzb.mjs").then((n) => n.r);
+	if (pkgConfig?.checkPublished) try {
+		return (await runAsync(pkgConfig.checkPublished)).trim() === version;
+	} catch {
+		return false;
+	}
+	if (pkgConfig?.skipNpmPublish || pkgConfig?.publishCommand) {
+		const tag = `${name}@${version}`;
+		return tryRun(`git tag -l "${tag}"`) === tag;
+	}
+	try {
+		return await runAsync(`npm info "${name}@${version}" version ${pkgConfig?.registry ? `--registry ${pkgConfig.registry}` : ""}`.trim()) === version;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { publishCommand };