@varlock/bumpy 0.0.0 → 0.0.1

package/dist/ci-8KWWhjXl.mjs

@@ -0,0 +1,224 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { a as loadConfig } from "./config-CJ2orhTL.mjs";
+import { n as discoverWorkspace } from "./workspace-mVjawG8g.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { r as readChangesets } from "./changeset-ClCYsChu.mjs";
+import { t as assembleReleasePlan } from "./release-plan-CFnutSHD.mjs";
+import { i as tryRun, n as runAsync, t as run } from "./shell-DPlltpzb.mjs";
+//#region src/commands/ci.ts
+/** Configure git identity for CI commits if not already set */
+function ensureGitIdentity(rootDir, config) {
+	if (!tryRun("git config user.name", { cwd: rootDir })) {
+		const { name: gitName, email: gitEmail } = config.gitUser;
+		run(`git config user.name "${gitName}"`, { cwd: rootDir });
+		run(`git config user.email "${gitEmail}"`, { cwd: rootDir });
+		log.dim(`  Using git identity: ${gitName} <${gitEmail}>`);
+	}
+}
+/**
+* CI check: report on pending changesets.
+* Designed for PR workflows — shows what would be released and optionally comments on the PR.
+*/
+async function ciCheckCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const { packages } = await discoverWorkspace(rootDir, config);
+	const depGraph = new DependencyGraph(packages);
+	const changesets = await readChangesets(rootDir);
+	const inCI = !!process.env.CI;
+	const shouldComment = opts.comment ?? inCI;
+	const prNumber = detectPrNumber();
+	if (changesets.length === 0) {
+		log.info("No changesets found in this PR.");
+		if (shouldComment && prNumber) await postOrUpdatePrComment(prNumber, formatNoChangesetsComment(), rootDir);
+		if (opts.failOnMissing) process.exit(1);
+		return;
+	}
+	const plan = assembleReleasePlan(changesets, packages, depGraph, config);
+	log.bold(`${changesets.length} changeset(s) → ${plan.releases.length} package(s) to release\n`);
+	for (const r of plan.releases) {
+		const tag = r.isDependencyBump ? " (dep)" : r.isCascadeBump ? " (cascade)" : "";
+		console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(r.newVersion, "cyan")}${tag}`);
+	}
+	if (shouldComment && prNumber) await postOrUpdatePrComment(prNumber, formatReleasePlanComment(plan, changesets.length), rootDir);
+}
+/**
+* CI release: either auto-publish or create a version PR.
+* Designed for merge-to-main workflows.
+*/
+async function ciReleaseCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	ensureGitIdentity(rootDir, config);
+	const { packages } = await discoverWorkspace(rootDir, config);
+	const depGraph = new DependencyGraph(packages);
+	const changesets = await readChangesets(rootDir);
+	if (changesets.length === 0) {
+		log.info("No pending changesets — checking for unpublished packages...");
+		const { publishCommand } = await import("./publish-DZ3m7qkX.mjs");
+		await publishCommand(rootDir, { tag: opts.tag });
+		return;
+	}
+	const plan = assembleReleasePlan(changesets, packages, depGraph, config);
+	if (plan.releases.length === 0) {
+		log.info("Changesets found but no packages would be released.");
+		return;
+	}
+	if (opts.mode === "auto-publish") await autoPublish(rootDir, config, opts.tag);
+	else await createVersionPr(rootDir, plan, config, opts.branch);
+}
+async function autoPublish(rootDir, config, tag) {
+	log.step("Running bumpy version...");
+	const { versionCommand } = await import("./version-CJwf8XIA.mjs");
+	await versionCommand(rootDir);
+	log.step("Committing version changes...");
+	run("git add -A", { cwd: rootDir });
+	if (tryRun("git status --porcelain", { cwd: rootDir })) {
+		run("git commit -m \"Version packages\"", { cwd: rootDir });
+		run("git push", { cwd: rootDir });
+	}
+	log.step("Running bumpy publish...");
+	const { publishCommand } = await import("./publish-DZ3m7qkX.mjs");
+	await publishCommand(rootDir, { tag });
+}
+async function createVersionPr(rootDir, plan, config, branchName) {
+	const branch = branchName || config.versionPr.branch;
+	const baseBranch = tryRun("git rev-parse --abbrev-ref HEAD", { cwd: rootDir }) || "main";
+	const existingPr = tryRun(`gh pr list --head "${branch}" --json number --jq ".[0].number"`, { cwd: rootDir });
+	log.step(`Creating branch ${branch}...`);
+	if (tryRun(`git rev-parse --verify ${branch}`, { cwd: rootDir }) !== null) {
+		run(`git checkout ${branch}`, { cwd: rootDir });
+		run(`git reset --hard ${baseBranch}`, { cwd: rootDir });
+	} else run(`git checkout -b ${branch}`, { cwd: rootDir });
+	log.step("Running bumpy version...");
+	const { versionCommand } = await import("./version-CJwf8XIA.mjs");
+	await versionCommand(rootDir);
+	run("git add -A", { cwd: rootDir });
+	if (!tryRun("git status --porcelain", { cwd: rootDir })) {
+		log.info("No version changes to commit.");
+		run(`git checkout ${baseBranch}`, { cwd: rootDir });
+		return;
+	}
+	run("git commit -F -", {
+		cwd: rootDir,
+		input: [
+			"Version packages",
+			"",
+			...plan.releases.map((r) => `${r.name}@${r.newVersion}`)
+		].join("\n")
+	});
+	run(`git push -u origin ${branch} --force`, { cwd: rootDir });
+	const prBody = formatVersionPrBody(plan, config.versionPr.preamble);
+	if (existingPr) {
+		log.step(`Updating existing PR #${existingPr}...`);
+		await runAsync(`gh pr edit ${existingPr} --title "${config.versionPr.title}" --body-file -`, {
+			cwd: rootDir,
+			input: prBody
+		});
+		log.success(`Updated PR #${existingPr}`);
+	} else {
+		log.step("Creating version PR...");
+		const prTitle = config.versionPr.title;
+		const result = await runAsync(`gh pr create --title "${prTitle}" --body-file - --base "${baseBranch}" --head "${branch}"`, {
+			cwd: rootDir,
+			input: prBody
+		});
+		log.success(`Created PR: ${result}`);
+	}
+	run(`git checkout ${baseBranch}`, { cwd: rootDir });
+}
+function formatReleasePlanComment(plan, changesetCount) {
+	const lines = [];
+	lines.push("## 🐸 Bumpy Release Plan\n");
+	lines.push(`**${changesetCount}** changeset(s) → **${plan.releases.length}** package(s) to release\n`);
+	const groups = [
+		["🔴 Major", plan.releases.filter((r) => r.type === "major")],
+		["🟡 Minor", plan.releases.filter((r) => r.type === "minor")],
+		["🟢 Patch", plan.releases.filter((r) => r.type === "patch")]
+	];
+	for (const [label, group] of groups) {
+		if (group.length === 0) continue;
+		lines.push(`### ${label}\n`);
+		lines.push("| Package | Change |");
+		lines.push("|---------|--------|");
+		for (const r of group) {
+			const suffix = r.isDependencyBump ? " _(dep)_" : r.isCascadeBump ? " _(cascade)_" : "";
+			lines.push(`| \`${r.name}\` | ${r.oldVersion} → **${r.newVersion}**${suffix} |`);
+		}
+		lines.push("");
+	}
+	lines.push("---");
+	lines.push(`_This comment is maintained by [bumpy](https://github.com/dmno-dev/bumpy)._`);
+	return lines.join("\n");
+}
+function formatNoChangesetsComment() {
+	return [
+		"## 🐸 Bumpy Release Plan\n",
+		"No changesets found in this PR. If this PR should trigger a release, run:\n",
+		"```bash",
+		"bumpy add",
+		"```\n",
+		"---",
+		`_This comment is maintained by [bumpy](https://github.com/dmno-dev/bumpy)._`
+	].join("\n");
+}
+const FROG_IMG_BASE = "https://raw.githubusercontent.com/dmno-dev/bumpy/main/images";
+function bumpSectionHeader(type) {
+	return `### ${`<img src="${FROG_IMG_BASE}/frog-${type}.png" alt="${type}" width="52" style="image-rendering: pixelated;" align="right" />`} ${type.charAt(0).toUpperCase() + type.slice(1)} releases`;
+}
+function formatVersionPrBody(plan, preamble) {
+	const lines = [];
+	lines.push(preamble);
+	lines.push("");
+	const groups = {
+		major: [],
+		minor: [],
+		patch: []
+	};
+	for (const r of plan.releases) groups[r.type]?.push(r);
+	for (const type of [
+		"major",
+		"minor",
+		"patch"
+	]) {
+		const releases = groups[type];
+		if (!releases || releases.length === 0) continue;
+		lines.push(bumpSectionHeader(type));
+		lines.push("");
+		for (const r of releases) {
+			const suffix = r.isDependencyBump ? " (dep)" : r.isCascadeBump ? " (cascade)" : "";
+			lines.push(`- \`${r.name}\` ${r.oldVersion} → **${r.newVersion}**${suffix}`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+const COMMENT_MARKER = "<!-- bumpy-release-plan -->";
+async function postOrUpdatePrComment(prNumber, body, rootDir) {
+	const markedBody = `${COMMENT_MARKER}\n${body}`;
+	try {
+		const existingComment = tryRun(`gh pr view ${prNumber} --json comments --jq '.comments[] | select(.body | startswith("${COMMENT_MARKER}")) | .id' | head -1`, { cwd: rootDir });
+		if (existingComment) {
+			await runAsync(`gh api repos/{owner}/{repo}/issues/comments/${existingComment} -X PATCH -f body=@-`, {
+				cwd: rootDir,
+				input: markedBody
+			});
+			log.dim("  Updated PR comment");
+		} else {
+			await runAsync(`gh pr comment ${prNumber} --body-file -`, {
+				cwd: rootDir,
+				input: markedBody
+			});
+			log.dim("  Posted PR comment");
+		}
+	} catch (err) {
+		log.warn(`  Failed to comment on PR: ${err instanceof Error ? err.message : err}`);
+	}
+}
+function detectPrNumber() {
+	if (process.env.GITHUB_EVENT_NAME === "pull_request") {
+		const match = process.env.GITHUB_REF?.match(/refs\/pull\/(\d+)\//);
+		if (match) return match[1];
+	}
+	return process.env.BUMPY_PR_NUMBER || process.env.PR_NUMBER || null;
+}
+//#endregion
+export { ciCheckCommand, ciReleaseCommand };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { n as findRoot } from "./config-CJ2orhTL.mjs";
+//#region src/cli.ts
+const args = process.argv.slice(2);
+const command = args[0];
+function parseFlags(args) {
+	const flags = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const key = arg.slice(2);
+			const next = args[i + 1];
+			if (next && !next.startsWith("--")) {
+				flags[key] = next;
+				i++;
+			} else flags[key] = true;
+		}
+	}
+	return flags;
+}
+async function main() {
+	const flags = parseFlags(args.slice(1));
+	try {
+		switch (command) {
+			case "init": {
+				const rootDir = await findRoot();
+				const { initCommand } = await import("./init-Blw2GfC_.mjs");
+				await initCommand(rootDir);
+				break;
+			}
+			case "add": {
+				const rootDir = await findRoot();
+				const { addCommand } = await import("./add-u5V9V3L7.mjs");
+				await addCommand(rootDir, {
+					packages: flags.packages,
+					message: flags.message,
+					name: flags.name,
+					empty: flags.empty === true
+				});
+				break;
+			}
+			case "status": {
+				const rootDir = await findRoot();
+				const { statusCommand } = await import("./status-DRpq_Mha.mjs");
+				await statusCommand(rootDir, {
+					json: flags.json === true,
+					packagesOnly: flags.packages === true,
+					bumpType: flags.bump,
+					filter: flags.filter,
+					verbose: flags.verbose === true
+				});
+				break;
+			}
+			case "version": {
+				const rootDir = await findRoot();
+				const { versionCommand } = await import("./version-CJwf8XIA.mjs");
+				await versionCommand(rootDir);
+				break;
+			}
+			case "generate": {
+				const rootDir = await findRoot();
+				const { generateCommand } = await import("./generate-oOFD9ABC.mjs");
+				await generateCommand(rootDir, {
+					from: flags.from,
+					dryRun: flags["dry-run"] === true,
+					name: flags.name
+				});
+				break;
+			}
+			case "migrate": {
+				const rootDir = await findRoot();
+				const { migrateCommand } = await import("./migrate-DvOrXSw0.mjs");
+				await migrateCommand(rootDir, { force: flags.force === true });
+				break;
+			}
+			case "check": {
+				const rootDir = await findRoot();
+				const { checkCommand } = await import("./check-CkRubvuk.mjs");
+				await checkCommand(rootDir);
+				break;
+			}
+			case "ci": {
+				const rootDir = await findRoot();
+				const subcommand = args[1];
+				const ciFlags = parseFlags(args.slice(2));
+				if (subcommand === "check") {
+					const { ciCheckCommand } = await import("./ci-8KWWhjXl.mjs");
+					await ciCheckCommand(rootDir, {
+						comment: ciFlags.comment !== void 0 ? ciFlags.comment === true : void 0,
+						failOnMissing: ciFlags["fail-on-missing"] === true
+					});
+				} else if (subcommand === "release") {
+					const { ciReleaseCommand } = await import("./ci-8KWWhjXl.mjs");
+					await ciReleaseCommand(rootDir, {
+						mode: ciFlags["auto-publish"] === true ? "auto-publish" : "version-pr",
+						tag: ciFlags.tag,
+						branch: ciFlags.branch
+					});
+				} else {
+					log.error(`Unknown ci subcommand: ${subcommand}. Use "ci check" or "ci release".`);
+					process.exit(1);
+				}
+				break;
+			}
+			case "publish": {
+				const rootDir = await findRoot();
+				const { publishCommand } = await import("./publish-DZ3m7qkX.mjs");
+				await publishCommand(rootDir, {
+					dryRun: flags["dry-run"] === true,
+					tag: flags.tag,
+					noPush: flags["no-push"] === true,
+					filter: flags.filter
+				});
+				break;
+			}
+			case "ai": {
+				const rootDir = await findRoot();
+				const subcommand = args[1];
+				const aiFlags = parseFlags(args.slice(2));
+				if (subcommand === "setup") {
+					const { aiSetupCommand } = await import("./ai-B8ZL2x8z.mjs");
+					await aiSetupCommand(rootDir, { target: aiFlags.target });
+				} else {
+					log.error(`Unknown ai subcommand: ${subcommand}. Use "ai setup".`);
+					process.exit(1);
+				}
+				break;
+			}
+			case "--version":
+			case "-v":
+				console.log(`bumpy 0.0.1`);
+				break;
+			case "help":
+			case "--help":
+			case "-h":
+			case void 0:
+				printHelp();
+				break;
+			default:
+				log.error(`Unknown command: ${command}`);
+				printHelp();
+				process.exit(1);
+		}
+	} catch (err) {
+		log.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+}
+function printHelp() {
+	console.log(`
+  ${colorize(`🐸 bumpy v0.0.1`, "bold")} - Modern monorepo versioning
+
+  Usage: bumpy <command> [options]
+
+  Commands:
+    init                    Initialize .bumpy/ directory
+    add                     Create a new changeset
+    generate                Generate changeset from conventional commits
+    status                  Show pending releases
+    check                   Verify changed packages have changesets (for pre-push hooks)
+    version                 Apply changesets and bump versions
+    publish                 Publish versioned packages
+    ci check                PR check — report pending releases, comment on PR
+    ci release              Release — create version PR or auto-publish
+    migrate                 Migrate from .changeset/ to .bumpy/
+    ai setup                Install AI skill for creating changesets
+
+  Add options:
+    --packages <list>       Package bumps (e.g., "pkg-a:minor,pkg-b:patch")
+    --message <text>        Changeset summary
+    --name <name>           Changeset filename
+    --empty                 Create an empty changeset
+
+  Generate options:
+    --from <ref>            Git ref to scan from (default: last version tag)
+    --dry-run               Preview without creating a changeset
+    --name <name>           Changeset filename
+
+  Status options:
+    --json                  Output as JSON (includes dirs, changesets, packageNames)
+    --packages              Output only package names, one per line
+    --bump <types>          Filter by bump type (e.g., "major", "minor,patch")
+    --filter <names>        Filter by package name/glob (e.g., "@myorg/*")
+    --verbose               Show changeset details
+
+  Publish options:
+    --dry-run               Preview without publishing
+    --tag <tag>             npm dist-tag (e.g., "next", "beta")
+    --no-push               Skip pushing git tags to remote
+    --filter <names>        Publish only matching packages (e.g., "@myorg/*")
+
+  CI check options:
+    --comment               Force PR comment on/off (auto-detected in CI)
+    --fail-on-missing       Exit 1 if no changesets found
+
+  CI release options:
+    --auto-publish          Version + publish directly (default: create version PR)
+    --tag <tag>             npm dist-tag for auto-publish
+    --branch <name>         Branch name for version PR (default: bumpy/version-packages)
+
+  AI setup options:
+    --target <tool>         Target AI tool: opencode, cursor, codex
+
+  ${colorize("https://github.com/dmno-dev/bumpy", "dim")}
+`);
+}
+main();
+//#endregion
+export {};

package/dist/config-CJ2orhTL.mjs

@@ -0,0 +1,215 @@
+import { i as __exportAll } from "./logger-ZqggsyGZ.mjs";
+import { a as readJson, n as exists } from "./fs-DbNNEyzq.mjs";
+import { resolve } from "node:path";
+//#region src/types.ts
+const BUMP_LEVELS = {
+	patch: 0,
+	minor: 1,
+	major: 2
+};
+function bumpLevel(type) {
+	return BUMP_LEVELS[type];
+}
+function parseIsolatedBump(type) {
+	if (type.endsWith("-isolated")) return {
+		bump: type.replace("-isolated", ""),
+		isolated: true
+	};
+	return {
+		bump: type,
+		isolated: false
+	};
+}
+function maxBump(a, b) {
+	if (!a) return b;
+	return bumpLevel(a) >= bumpLevel(b) ? a : b;
+}
+const DEFAULT_BUMP_RULES = {
+	dependencies: {
+		trigger: "patch",
+		bumpAs: "patch"
+	},
+	peerDependencies: {
+		trigger: "major",
+		bumpAs: "major"
+	},
+	devDependencies: {
+		trigger: "none",
+		bumpAs: "patch"
+	},
+	optionalDependencies: {
+		trigger: "minor",
+		bumpAs: "patch"
+	}
+};
+const DEP_TYPES = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const DEFAULT_PUBLISH_CONFIG = {
+	packManager: "auto",
+	publishManager: "npm",
+	publishArgs: [],
+	protocolResolution: "pack"
+};
+const DEFAULT_CONFIG = {
+	baseBranch: "main",
+	access: "public",
+	commit: false,
+	changelog: "default",
+	fixed: [],
+	linked: [],
+	ignore: [],
+	include: [],
+	updateInternalDependencies: "out-of-range",
+	dependencyBumpRules: {},
+	privatePackages: {
+		version: false,
+		tag: false
+	},
+	packages: {},
+	publish: { ...DEFAULT_PUBLISH_CONFIG },
+	aggregateRelease: false,
+	gitUser: {
+		name: "bumpy-bot",
+		email: "276066384+bumpy-bot@users.noreply.github.com"
+	},
+	versionPr: {
+		title: "🐸 Versioned release",
+		branch: "bumpy/version-packages",
+		preamble: [
+			`<a href="https://github.com/dmno-dev/bumpy"><img src="https://raw.githubusercontent.com/dmno-dev/bumpy/main/images/frog-talking.png" alt="bumpy-frog" width="60" align="left" style="image-rendering: pixelated;" title="Hi! I'm bumpy!" /></a>`,
+			"",
+			`This PR was created and will be kept in sync by [bumpy](https://github.com/dmno-dev/bumpy) based on your .bumpy changeset files. Merge it when you are ready to release the packages listed below:`,
+			"<br clear=\"left\" />"
+		].join("\n")
+	}
+};
+function hasCascade(r) {
+	return "cascade" in r && Object.keys(r.cascade).length > 0;
+}
+//#endregion
+//#region src/core/config.ts
+var config_exports = /* @__PURE__ */ __exportAll({
+	findRoot: () => findRoot,
+	getBumpyDir: () => getBumpyDir,
+	isPackageManaged: () => isPackageManaged,
+	loadConfig: () => loadConfig,
+	loadPackageConfig: () => loadPackageConfig,
+	matchGlob: () => matchGlob
+});
+const BUMPY_DIR = ".bumpy";
+const CONFIG_FILE = "_config.json";
+/** Find the monorepo root by walking up from cwd looking for .bumpy/ */
+async function findRoot(startDir = process.cwd()) {
+	let dir = resolve(startDir);
+	while (true) {
+		if (await exists(resolve(dir, BUMPY_DIR))) return dir;
+		if (await exists(resolve(dir, "package.json"))) try {
+			if ((await readJson(resolve(dir, "package.json"))).workspaces) return dir;
+		} catch {}
+		const parent = resolve(dir, "..");
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return resolve(startDir);
+}
+/** Load the root bumpy config, merging with defaults */
+async function loadConfig(rootDir) {
+	const configPath = resolve(rootDir, BUMPY_DIR, CONFIG_FILE);
+	let userConfig = {};
+	if (await exists(configPath)) userConfig = await readJson(configPath);
+	return mergeConfig(DEFAULT_CONFIG, userConfig);
+}
+/** Load per-package bumpy config from package.json["bumpy"] or .bumpy.config.json */
+async function loadPackageConfig(pkgDir, rootConfig, pkgName) {
+	const rootPkgConfig = findPackageConfig(rootConfig, pkgName);
+	let pkgJsonConfig = {};
+	try {
+		const pkg = await readJson(resolve(pkgDir, "package.json"));
+		if (pkg.bumpy && typeof pkg.bumpy === "object") pkgJsonConfig = pkg.bumpy;
+	} catch {}
+	return mergePackageConfig(rootPkgConfig, pkgJsonConfig);
+}
+/** Find a package config from the root config, supporting glob patterns */
+function findPackageConfig(config, pkgName) {
+	if (config.packages[pkgName]) return config.packages[pkgName];
+	for (const [pattern, pkgConfig] of Object.entries(config.packages)) if (matchGlob(pkgName, pattern)) return pkgConfig;
+	return {};
+}
+/** Simple glob matching for package names (supports * and **) */
+function matchGlob(name, pattern) {
+	if (name === pattern) return true;
+	const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLE}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLE}}/g, ".*");
+	return new RegExp(`^${regexStr}$`).test(name);
+}
+function mergeConfig(defaults, user) {
+	return {
+		...defaults,
+		...user,
+		dependencyBumpRules: {
+			...defaults.dependencyBumpRules,
+			...user.dependencyBumpRules
+		},
+		privatePackages: {
+			...defaults.privatePackages,
+			...user.privatePackages
+		},
+		publish: {
+			...defaults.publish,
+			...user.publish
+		},
+		packages: {
+			...defaults.packages,
+			...user.packages
+		}
+	};
+}
+function mergePackageConfig(...configs) {
+	const result = {};
+	for (const cfg of configs) {
+		Object.assign(result, cfg);
+		if (cfg.dependencyBumpRules) result.dependencyBumpRules = {
+			...result.dependencyBumpRules,
+			...cfg.dependencyBumpRules
+		};
+		if (cfg.specificDependencyRules) result.specificDependencyRules = {
+			...result.specificDependencyRules,
+			...cfg.specificDependencyRules
+		};
+		if (cfg.cascadeTo) result.cascadeTo = {
+			...result.cascadeTo,
+			...cfg.cascadeTo
+		};
+	}
+	return result;
+}
+function getBumpyDir(rootDir) {
+	return resolve(rootDir, BUMPY_DIR);
+}
+/**
+* Determine if a package should be managed by bumpy.
+* Resolution order:
+* 1. Per-package `managed: false` → skip (explicit opt-out)
+* 2. `config.ignore` glob match → skip
+* 3. Per-package `managed: true` → include (explicit opt-in, overrides private)
+* 4. `config.include` glob match → include (overrides private)
+* 5. Private package + `config.privatePackages.version` false → skip
+* 6. Otherwise → include
+*/
+function isPackageManaged(pkgName, isPrivate, config, pkgBumpy) {
+	if (pkgBumpy?.managed === false) return false;
+	if (config.ignore.some((pattern) => matchGlob(pkgName, pattern))) {
+		if (pkgBumpy?.managed === true) return true;
+		if (config.include.some((pattern) => matchGlob(pkgName, pattern))) return true;
+		return false;
+	}
+	if (pkgBumpy?.managed === true) return true;
+	if (config.include.some((pattern) => matchGlob(pkgName, pattern))) return true;
+	if (isPrivate && !config.privatePackages.version) return false;
+	return true;
+}
+//#endregion
+export { loadConfig as a, BUMP_LEVELS as c, DEFAULT_PUBLISH_CONFIG as d, DEP_TYPES as f, parseIsolatedBump as g, maxBump as h, isPackageManaged as i, DEFAULT_BUMP_RULES as l, hasCascade as m, findRoot as n, loadPackageConfig as o, bumpLevel as p, getBumpyDir as r, matchGlob as s, config_exports as t, DEFAULT_CONFIG as u };