@varlock/bumpy 0.0.1 → 1.0.0

package/dist/release-plan-Bi5QNSEo.mjs

@@ -0,0 +1,264 @@
+import { h as maxBump, l as DEFAULT_BUMP_RULES, m as hasCascade, p as bumpLevel, s as matchGlob } from "./config-XZWUL3ma.mjs";
+import { n as satisfies, t as bumpVersion } from "./semver-DfQyVLM_.mjs";
+//#region src/core/release-plan.ts
+/**
+* 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
+*/
+function assembleReleasePlan(bumpFiles, packages, depGraph, config) {
+	if (bumpFiles.length === 0) return {
+		bumpFiles: [],
+		releases: [],
+		warnings: []
+	};
+	const planned = /* @__PURE__ */ new Map();
+	const warnings = [];
+	const cascadeOverrides = /* @__PURE__ */ new Map();
+	const suppressedPackages = /* @__PURE__ */ new Set();
+	for (const bf of bumpFiles) for (const release of bf.releases) {
+		if (!packages.has(release.name)) continue;
+		const bump = release.type;
+		if (bump === "none") {
+			suppressedPackages.add(release.name);
+			continue;
+		}
+		const existing = planned.get(release.name);
+		if (existing) {
+			existing.type = maxBump(existing.type, bump);
+			existing.bumpFiles.add(bf.id);
+		} else planned.set(release.name, {
+			type: bump,
+			suppressed: false,
+			isDependencyBump: false,
+			isCascadeBump: false,
+			bumpFiles: new Set([bf.id])
+		});
+		if (hasCascade(release)) {
+			if (!cascadeOverrides.has(release.name)) cascadeOverrides.set(release.name, /* @__PURE__ */ new Map());
+			const overrides = cascadeOverrides.get(release.name);
+			for (const [pattern, bumpType] of Object.entries(release.cascade)) {
+				const existing = overrides.get(pattern);
+				overrides.set(pattern, maxBump(existing, bumpType));
+			}
+		}
+	}
+	for (const name of suppressedPackages) if (!planned.has(name)) planned.set(name, {
+		type: "patch",
+		suppressed: true,
+		isDependencyBump: false,
+		isCascadeBump: false,
+		bumpFiles: /* @__PURE__ */ new Set()
+	});
+	let changed = true;
+	let iterations = 0;
+	const MAX_ITERATIONS = 100;
+	while (changed && iterations < MAX_ITERATIONS) {
+		changed = false;
+		iterations++;
+		for (const [pkgName, bump] of planned) {
+			if (bump.suppressed) continue;
+			const pkg = packages.get(pkgName);
+			const newVersion = bumpVersion(pkg.version, bump.type);
+			const dependents = depGraph.getDependents(pkgName);
+			for (const dep of dependents) {
+				if (dep.depType === "devDependencies") continue;
+				const currentVersion = pkg.version;
+				if (satisfies(newVersion, dep.versionRange, currentVersion)) continue;
+				let depBump;
+				if (dep.depType === "peerDependencies") depBump = bump.type;
+				else depBump = "patch";
+				if (planned.get(dep.name)?.suppressed) throw new Error(`Cannot suppress bump for '${dep.name}' (via 'none' in bump file) — '${pkgName}' is bumping to ${newVersion} which breaks the declared range '${dep.versionRange}'. Either widen the range or remove the 'none' entry.`);
+				if (dep.depType === "peerDependencies" && depBump !== "patch") {
+					let resolvedRange = dep.versionRange.replace(/^workspace:/, "");
+					if (resolvedRange === "^" || resolvedRange === "~") resolvedRange = `${resolvedRange}${pkg.version}`;
+					if (/^\^0(\.|$)/.test(resolvedRange)) warnings.push(`${dep.name} gets a ${depBump} bump because ${pkgName}@${newVersion} is out of range for its peer dep "${dep.versionRange}" (resolves to ${resolvedRange}). npm treats ^ on 0.x as minor-breaking. Consider using >=0.x ranges for pre-1.0 peer deps.`);
+				}
+				if (applyBump(planned, dep.name, depBump, true, false, bump.bumpFiles)) changed = true;
+			}
+		}
+		for (const group of config.fixed) {
+			let groupBump;
+			for (const nameOrGlob of group) for (const [name, bump] of planned) {
+				if (bump.suppressed) continue;
+				if (matchGlob(name, nameOrGlob)) groupBump = maxBump(groupBump, bump.type);
+			}
+			if (!groupBump) continue;
+			for (const nameOrGlob of group) for (const [name] of packages) {
+				if (!matchGlob(name, nameOrGlob)) continue;
+				const existing = planned.get(name);
+				if (existing && existing.suppressed) continue;
+				if (existing) {
+					const newType = maxBump(existing.type, groupBump);
+					if (newType !== existing.type) {
+						existing.type = newType;
+						changed = true;
+					}
+				} else {
+					planned.set(name, {
+						type: groupBump,
+						suppressed: false,
+						isDependencyBump: false,
+						isCascadeBump: false,
+						bumpFiles: /* @__PURE__ */ new Set()
+					});
+					changed = true;
+				}
+			}
+		}
+		for (const group of config.linked) {
+			let groupBump;
+			for (const nameOrGlob of group) for (const [name, bump] of planned) {
+				if (bump.suppressed) continue;
+				if (matchGlob(name, nameOrGlob)) groupBump = maxBump(groupBump, bump.type);
+			}
+			if (!groupBump) continue;
+			for (const nameOrGlob of group) for (const [name] of packages) {
+				if (!matchGlob(name, nameOrGlob)) continue;
+				const existing = planned.get(name);
+				if (!existing || existing.suppressed) continue;
+				const newType = maxBump(existing.type, groupBump);
+				if (newType !== existing.type) {
+					existing.type = newType;
+					changed = true;
+				}
+			}
+		}
+		if (config.updateInternalDependencies !== "out-of-range") for (const [pkgName, bump] of planned) {
+			if (bump.suppressed) continue;
+			if (config.updateInternalDependencies === "minor" && bumpLevel(bump.type) < bumpLevel("minor")) continue;
+			const bfOverrides = cascadeOverrides.get(pkgName);
+			if (bfOverrides) for (const [pattern, cascadeBumpType] of bfOverrides) for (const [targetName] of packages) {
+				if (!matchGlob(targetName, pattern)) continue;
+				if (planned.get(targetName)?.suppressed) continue;
+				if (applyBump(planned, targetName, cascadeBumpType, false, true, bump.bumpFiles)) changed = true;
+			}
+			const cascadeTo = packages.get(pkgName)?.bumpy?.cascadeTo;
+			if (cascadeTo) for (const [pattern, rule] of Object.entries(cascadeTo)) {
+				if (!shouldTrigger(bump.type, rule.trigger)) continue;
+				const cascadeBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				for (const [targetName] of packages) {
+					if (!matchGlob(targetName, pattern)) continue;
+					if (planned.get(targetName)?.suppressed) continue;
+					if (applyBump(planned, targetName, cascadeBump, false, true, bump.bumpFiles)) changed = true;
+				}
+			}
+			const dependents = depGraph.getDependents(pkgName);
+			for (const dep of dependents) {
+				const rule = resolveRule(dep.name, dep.depType, packages, config);
+				if (!rule) continue;
+				if (!shouldTrigger(bump.type, rule.trigger)) continue;
+				if (planned.get(dep.name)?.suppressed) continue;
+				const depBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				if (applyBump(planned, dep.name, depBump, true, false, bump.bumpFiles)) changed = true;
+			}
+		}
+		else for (const [pkgName, bump] of planned) {
+			if (bump.suppressed) continue;
+			const bfOverrides = cascadeOverrides.get(pkgName);
+			if (bfOverrides) for (const [pattern, cascadeBumpType] of bfOverrides) for (const [targetName] of packages) {
+				if (!matchGlob(targetName, pattern)) continue;
+				if (planned.get(targetName)?.suppressed) continue;
+				if (applyBump(planned, targetName, cascadeBumpType, false, true, bump.bumpFiles)) changed = true;
+			}
+			const cascadeTo = packages.get(pkgName)?.bumpy?.cascadeTo;
+			if (cascadeTo) for (const [pattern, rule] of Object.entries(cascadeTo)) {
+				if (!shouldTrigger(bump.type, rule.trigger)) continue;
+				const cascadeBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				for (const [targetName] of packages) {
+					if (!matchGlob(targetName, pattern)) continue;
+					if (planned.get(targetName)?.suppressed) continue;
+					if (applyBump(planned, targetName, cascadeBump, false, true, bump.bumpFiles)) changed = true;
+				}
+			}
+		}
+	}
+	for (const [name, bump] of planned) {
+		if (!bump.suppressed) continue;
+		const pkg = packages.get(name);
+		for (const [depName, depBump] of planned) {
+			if (depBump.suppressed) continue;
+			const depPkg = packages.get(depName);
+			const newDepVersion = bumpVersion(depPkg.version, depBump.type);
+			for (const depType of [
+				"dependencies",
+				"peerDependencies",
+				"optionalDependencies"
+			]) {
+				const range = pkg[depType]?.[depName];
+				if (!range) continue;
+				if (!satisfies(newDepVersion, range, depPkg.version)) throw new Error(`Cannot suppress bump for '${name}' (via 'none' in bump file) — '${depName}' is bumping to ${newDepVersion} which breaks the declared range '${range}'. Either widen the range or remove the 'none' entry.`);
+			}
+		}
+	}
+	const releases = [];
+	for (const [name, bump] of planned) {
+		if (bump.suppressed) continue;
+		const pkg = packages.get(name);
+		if (!pkg) continue;
+		const newVersion = bumpVersion(pkg.version, bump.type);
+		releases.push({
+			name,
+			type: bump.type,
+			oldVersion: pkg.version,
+			newVersion,
+			bumpFiles: [...bump.bumpFiles],
+			isDependencyBump: bump.isDependencyBump,
+			isCascadeBump: bump.isCascadeBump
+		});
+	}
+	releases.sort((a, b) => a.name.localeCompare(b.name));
+	for (const [name, pkg] of packages) for (const [depName, range] of Object.entries(pkg.peerDependencies)) if (range === "workspace:*" && packages.has(depName)) warnings.push(`${name} has peer dep "${depName}": "workspace:*" — this will be published as a fixed range which may not match your intent. Consider using "workspace:^" instead.`);
+	return {
+		bumpFiles,
+		releases,
+		warnings
+	};
+}
+/** Apply a bump to a package, upgrading if already planned. Returns true if anything changed. */
+function applyBump(planned, name, type, isDependencyBump, isCascadeBump, sourceBumpFiles) {
+	const existing = planned.get(name);
+	if (existing) {
+		if (existing.suppressed) return false;
+		const newType = maxBump(existing.type, type);
+		if (newType === existing.type) return false;
+		existing.type = newType;
+		if (isDependencyBump) existing.isDependencyBump = true;
+		if (isCascadeBump) existing.isCascadeBump = true;
+		for (const bf of sourceBumpFiles) existing.bumpFiles.add(bf);
+		return true;
+	}
+	planned.set(name, {
+		type,
+		suppressed: false,
+		isDependencyBump,
+		isCascadeBump,
+		bumpFiles: new Set(sourceBumpFiles)
+	});
+	return true;
+}
+/** Check if a bump level meets the trigger threshold */
+function shouldTrigger(bumpType, trigger) {
+	return bumpLevel(bumpType) >= bumpLevel(trigger);
+}
+/**
+* Resolve the dependency bump rule for a specific dependent + dep type.
+* Priority: per-package depType rules > global depType rules > defaults
+* Returns false if the rule is disabled.
+*/
+function resolveRule(dependentName, depType, packages, config) {
+	const dependent = packages.get(dependentName);
+	if (dependent?.bumpy?.dependencyBumpRules && depType in dependent.bumpy.dependencyBumpRules) return dependent.bumpy.dependencyBumpRules[depType];
+	if (depType in config.dependencyBumpRules) return config.dependencyBumpRules[depType];
+	const defaultRule = DEFAULT_BUMP_RULES[depType];
+	return defaultRule !== void 0 ? defaultRule : {
+		trigger: "patch",
+		bumpAs: "patch"
+	};
+}
+//#endregion
+export { assembleReleasePlan as t };

package/dist/{semver-DWO6NFKN.mjs → semver-DfQyVLM_.mjs}

@@ -1,4 +1,4 @@
-import { a as __toESM, r as __commonJSMin } from "./logger-ZqggsyGZ.mjs";
+import { i as __commonJSMin, o as __toESM } from "./logger-C2dEe5Su.mjs";
 //#region ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const SEMVER_SPEC_VERSION = "2.0.0";
@@ -1341,11 +1341,21 @@ function bumpVersion(version, type) {
 	if (!result) throw new Error(`Failed to bump ${version} by ${type}`);
 	return result;
 }
-/** Check if a version satisfies a range */
-function satisfies(version, range) {
+/**
+* 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:~
+*/
+function satisfies(version, range, currentVersion) {
 	if (range.startsWith("workspace:")) {
 		const cleanRange = range.slice(10);
-		if (!cleanRange || cleanRange === "*" || cleanRange === "^" || cleanRange === "~") return true;
+		if (!cleanRange || cleanRange === "*") return true;
+		if (cleanRange === "^" || cleanRange === "~") {
+			if (!currentVersion) return true;
+			const resolved = `${cleanRange}${currentVersion}`;
+			return import_semver.default.satisfies(version, resolved);
+		}
 		return import_semver.default.satisfies(version, cleanRange);
 	}
 	if (range.startsWith("catalog:")) return true;

package/dist/shell-Dj7JRD_q.mjs

@@ -0,0 +1,92 @@
+import { a as __exportAll } from "./logger-C2dEe5Su.mjs";
+import { exec, execFile, execFileSync } from "node:child_process";
+//#region src/utils/shell.ts
+var shell_exports = /* @__PURE__ */ __exportAll({
+	runArgs: () => runArgs,
+	runArgsAsync: () => runArgsAsync,
+	runAsync: () => runAsync,
+	sq: () => sq,
+	tryRunArgs: () => tryRunArgs
+});
+/**
+* Escape a value for safe interpolation inside a single-quoted shell string.
+* Works by ending the current single-quote, inserting an escaped single-quote,
+* and re-opening the single-quote: "it's" → 'it'\''s'
+*/
+function sq(value) {
+	return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+function checkIntercept(args, opts) {
+	return null;
+}
+function runAsync(cmd, opts) {
+	const result = checkIntercept(cmd.split(/\s+/), opts);
+	if (result?.intercepted) {
+		if ("error" in result) return Promise.reject(new Error(result.error));
+		return Promise.resolve(result.result);
+	}
+	return new Promise((resolve, reject) => {
+		const child = exec(cmd, {
+			cwd: opts?.cwd,
+			encoding: "utf-8"
+		}, (err, stdout, stderr) => {
+			if (err) reject(/* @__PURE__ */ new Error(`Command failed: ${cmd}\n${stderr}`));
+			else resolve(stdout.trim());
+		});
+		if (opts?.input) {
+			child.stdin?.write(opts.input);
+			child.stdin?.end();
+		}
+	});
+}
+/** Run a command with an argument array — bypasses the shell entirely */
+function runArgs(args, opts) {
+	const result = checkIntercept(args, opts);
+	if (result?.intercepted) {
+		if ("error" in result) throw new Error(result.error);
+		return result.result;
+	}
+	const [cmd, ...rest] = args;
+	return execFileSync(cmd, rest, {
+		cwd: opts?.cwd,
+		input: opts?.input,
+		encoding: "utf-8",
+		stdio: [
+			opts?.input ? "pipe" : "pipe",
+			"pipe",
+			"pipe"
+		]
+	}).trim();
+}
+/** Async version of runArgs */
+function runArgsAsync(args, opts) {
+	const result = checkIntercept(args, opts);
+	if (result?.intercepted) {
+		if ("error" in result) return Promise.reject(new Error(result.error));
+		return Promise.resolve(result.result);
+	}
+	const [cmd, ...rest] = args;
+	return new Promise((resolve, reject) => {
+		const child = execFile(cmd, rest, {
+			cwd: opts?.cwd,
+			encoding: "utf-8"
+		}, (err, stdout, stderr) => {
+			if (err) reject(/* @__PURE__ */ new Error(`Command failed: ${args.join(" ")}\n${stderr}`));
+			else resolve(stdout.trim());
+		});
+		if (opts?.input) {
+			child.stdin?.write(opts.input);
+			child.stdin?.end();
+		}
+	});
+}
+/** tryRun equivalent for argument arrays */
+function tryRunArgs(args, opts) {
+	try {
+		return runArgs(args, opts);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { sq as a, shell_exports as i, runArgsAsync as n, tryRunArgs as o, runAsync as r, runArgs as t };

package/dist/{status-DRpq_Mha.mjs → status-CfE63ti5.mjs}

@@ -1,41 +1,41 @@
-import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
-import { a as loadConfig } from "./config-CJ2orhTL.mjs";
-import { t as discoverPackages } 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 { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
+import { a as loadConfig } from "./config-XZWUL3ma.mjs";
+import { t as discoverPackages } from "./workspace-C5ULTyUN.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { r as readBumpFiles } from "./bump-file-CCLXMLA8.mjs";
+import { t as assembleReleasePlan } from "./release-plan-Bi5QNSEo.mjs";
 //#region src/commands/status.ts
 async function statusCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
 	const packages = await discoverPackages(rootDir, config);
 	const depGraph = new DependencyGraph(packages);
-	const changesets = await readChangesets(rootDir);
-	if (changesets.length === 0) {
+	const bumpFiles = await readBumpFiles(rootDir);
+	if (bumpFiles.length === 0) {
 		if (opts.json) console.log(JSON.stringify({
-			changesets: [],
+			bumpFiles: [],
 			releases: [],
 			packageNames: []
 		}, null, 2));
-		else if (!opts.packagesOnly) log.info("No pending changesets.");
+		else if (!opts.packagesOnly) log.info("No pending bump files.");
 		process.exit(1);
 	}
-	const plan = assembleReleasePlan(changesets, packages, depGraph, config);
+	const plan = assembleReleasePlan(bumpFiles, packages, depGraph, config);
 	let releases = plan.releases;
 	if (opts.bumpType) {
 		const types = opts.bumpType.split(",").map((t) => t.trim());
 		releases = releases.filter((r) => types.includes(r.type));
 	}
 	if (opts.filter) {
-		const { matchGlob } = await import("./config-CJ2orhTL.mjs").then((n) => n.t);
+		const { matchGlob } = await import("./config-XZWUL3ma.mjs").then((n) => n.t);
 		const patterns = opts.filter.split(",").map((p) => p.trim());
 		releases = releases.filter((r) => patterns.some((p) => matchGlob(r.name, p)));
 	}
 	if (opts.json) {
 		const jsonOutput = {
-			changesets: plan.changesets.map((cs) => ({
-				id: cs.id,
-				summary: cs.summary,
-				releases: cs.releases.map((r) => ({
+			bumpFiles: plan.bumpFiles.map((bf) => ({
+				id: bf.id,
+				summary: bf.summary,
+				releases: bf.releases.map((r) => ({
 					name: r.name,
 					type: r.type
 				}))
@@ -46,7 +46,7 @@ async function statusCommand(rootDir, opts) {
 				oldVersion: r.oldVersion,
 				newVersion: r.newVersion,
 				dir: packages.get(r.name)?.relativeDir,
-				changesets: r.changesets,
+				bumpFiles: r.bumpFiles,
 				isDependencyBump: r.isDependencyBump,
 				isCascadeBump: r.isCascadeBump
 			})),
@@ -59,7 +59,7 @@ async function statusCommand(rootDir, opts) {
 		for (const r of releases) console.log(r.name);
 		return;
 	}
-	log.bold(`${changesets.length} changeset(s) pending\n`);
+	log.bold(`${bumpFiles.length} bump file(s) pending\n`);
 	if (releases.length === 0) {
 		log.warn("No packages match the current filters.");
 		return;
@@ -87,12 +87,16 @@ async function statusCommand(rootDir, opts) {
 		for (const r of group) printRelease(r, packages);
 		console.log();
 	}
+	if (plan.warnings.length > 0) {
+		for (const w of plan.warnings) log.warn(w);
+		console.log();
+	}
 	if (opts.verbose) {
-		log.bold("Changesets:");
-		for (const cs of plan.changesets) {
-			console.log(`  ${colorize(cs.id, "cyan")}`);
-			for (const r of cs.releases) console.log(`    ${r.name}: ${r.type}`);
-			if (cs.summary) console.log(`    ${colorize(cs.summary.split("\n")[0], "dim")}`);
+		log.bold("Bump files:");
+		for (const bf of plan.bumpFiles) {
+			console.log(`  ${colorize(bf.id, "cyan")}`);
+			for (const r of bf.releases) console.log(`    ${r.name}: ${r.type}`);
+			if (bf.summary) console.log(`    ${colorize(bf.summary.split("\n")[0], "dim")}`);
 		}
 	}
 }

package/dist/version-19vVt9dv.mjs

@@ -0,0 +1,124 @@
+import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
+import { a as loadConfig } from "./config-XZWUL3ma.mjs";
+import { n as detectWorkspaces } from "./package-manager-VCe10bjc.mjs";
+import { t as discoverPackages } from "./workspace-C5ULTyUN.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { o as tryRunArgs, t as runArgs } from "./shell-Dj7JRD_q.mjs";
+import { r as readBumpFiles } from "./bump-file-CCLXMLA8.mjs";
+import { t as assembleReleasePlan } from "./release-plan-Bi5QNSEo.mjs";
+import { t as applyReleasePlan } from "./apply-release-plan-CczGWJTk.mjs";
+//#region src/commands/version.ts
+async function versionCommand(rootDir) {
+	const config = await loadConfig(rootDir);
+	const packages = await discoverPackages(rootDir, config);
+	const depGraph = new DependencyGraph(packages);
+	const bumpFiles = await readBumpFiles(rootDir);
+	if (bumpFiles.length === 0) {
+		log.info("No pending bump files.");
+		return;
+	}
+	const plan = assembleReleasePlan(bumpFiles, packages, depGraph, config);
+	if (plan.releases.length === 0) {
+		log.warn("Bump files found but no packages would be released.");
+		return;
+	}
+	if (plan.warnings.length > 0) {
+		for (const w of plan.warnings) log.warn(w);
+		console.log();
+	}
+	log.step("Applying version bumps:");
+	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}`);
+	}
+	await applyReleasePlan(plan, packages, rootDir, config);
+	log.success(`Updated ${plan.releases.length} package(s)`);
+	log.dim(`  Deleted ${bumpFiles.length} bump file(s)`);
+	await updateLockfile(rootDir);
+	if (config.commit) try {
+		runArgs([
+			"git",
+			"add",
+			"-A",
+			".bumpy/"
+		], { cwd: rootDir });
+		for (const r of plan.releases) {
+			const pkg = packages.get(r.name);
+			runArgs([
+				"git",
+				"add",
+				"--",
+				`${pkg.relativeDir}/package.json`
+			], { cwd: rootDir });
+			runArgs([
+				"git",
+				"add",
+				"--",
+				`${pkg.relativeDir}/CHANGELOG.md`
+			], { cwd: rootDir });
+		}
+		for (const lockfile of [
+			"bun.lock",
+			"bun.lockb",
+			"pnpm-lock.yaml",
+			"yarn.lock",
+			"package-lock.json"
+		]) tryRunArgs([
+			"git",
+			"add",
+			"--",
+			lockfile
+		], { cwd: rootDir });
+		runArgs([
+			"git",
+			"commit",
+			"-F",
+			"-"
+		], {
+			cwd: rootDir,
+			input: [
+				"Version packages",
+				"",
+				...plan.releases.map((r) => `${r.name}@${r.newVersion}`)
+			].join("\n")
+		});
+		log.success("Created git commit");
+	} catch (e) {
+		log.warn(`Git commit failed: ${e}`);
+	}
+}
+/** Run the package manager's install to update the lockfile */
+async function updateLockfile(rootDir) {
+	const { packageManager } = await detectWorkspaces(rootDir);
+	const installArgs = getInstallArgs(packageManager);
+	log.step(`Updating lockfile (${installArgs.join(" ")})...`);
+	try {
+		runArgs(installArgs, { cwd: rootDir });
+		log.dim("  Lockfile updated");
+	} catch (err) {
+		log.warn(`  Lockfile update failed: ${err instanceof Error ? err.message : err}`);
+	}
+}
+function getInstallArgs(pm) {
+	switch (pm) {
+		case "pnpm": return [
+			"pnpm",
+			"install",
+			"--lockfile-only"
+		];
+		case "bun": return ["bun", "install"];
+		case "yarn": return [
+			"yarn",
+			"install",
+			"--mode",
+			"update-lockfile"
+		];
+		default: return [
+			"npm",
+			"install",
+			"--package-lock-only"
+		];
+	}
+}
+//#endregion
+export { versionCommand };