@ucdjs/release-scripts 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/index.mjs

@@ -1,23 +1,76 @@
+import { t as Eta } from "./eta-j5TFRbI4.mjs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
 import process from "node:process";
-import { getCommits } from "commit-parser";
-import createDebug from "debug";
+import readline from "node:readline";
 import farver from "farver";
+import mri from "mri";
 import { exec } from "tinyexec";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { dedent } from "@luxass/utils";
+import { getCommits, groupByType } from "commit-parser";
 import prompts from "prompts";
+import { compare, gt } from "semver";
 
-//#region src/logger.ts
-function createDebugger(namespace) {
-	const debug$2 = createDebug(namespace);
-	if (debug$2.enabled) return debug$2;
-}
+//#region src/publish.ts
+function publish(_options) {}
 
 //#endregion
-//#region src/utils.ts
-const globalOptions = { dryRun: false };
-async function run(bin, args, opts = {}) {
-	return exec(bin, args, {
+//#region src/shared/utils.ts
+const args = mri(process.argv.slice(2));
+const isDryRun = !!args.dry;
+const isVerbose = !!args.verbose;
+const isForce = !!args.force;
+const ucdjsReleaseOverridesPath = ".github/ucdjs-release.overrides.json";
+const isCI = typeof process.env.CI === "string" && process.env.CI !== "" && process.env.CI.toLowerCase() !== "false";
+const logger = {
+	info: (...args$1) => {
+		console.info(...args$1);
+	},
+	warn: (...args$1) => {
+		console.warn(`  ${farver.yellow("⚠")}`, ...args$1);
+	},
+	error: (...args$1) => {
+		console.error(`  ${farver.red("✖")}`, ...args$1);
+	},
+	verbose: (...args$1) => {
+		if (!isVerbose) return;
+		if (args$1.length === 0) {
+			console.log();
+			return;
+		}
+		if (args$1.length > 1 && typeof args$1[0] === "string") {
+			console.log(farver.dim(args$1[0]), ...args$1.slice(1));
+			return;
+		}
+		console.log(...args$1);
+	},
+	section: (title) => {
+		console.log();
+		console.log(`  ${farver.bold(title)}`);
+		console.log(`  ${farver.gray("─".repeat(title.length + 2))}`);
+	},
+	emptyLine: () => {
+		console.log();
+	},
+	item: (message, ...args$1) => {
+		console.log(`  ${message}`, ...args$1);
+	},
+	step: (message) => {
+		console.log(`  ${farver.blue("→")} ${message}`);
+	},
+	success: (message) => {
+		console.log(`  ${farver.green("✓")} ${message}`);
+	},
+	clearScreen: () => {
+		const repeatCount = process.stdout.rows - 2;
+		const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+		console.log(blank);
+		readline.cursorTo(process.stdout, 0, 0);
+		readline.clearScreenDown(process.stdout);
+	}
+};
+async function run(bin, args$1, opts = {}) {
+	return exec(bin, args$1, {
 		throwOnError: true,
 		...opts,
 		nodeOptions: {
@@ -26,211 +79,27 @@ async function run(bin, args, opts = {}) {
 		}
 	});
 }
-async function dryRun(bin, args, opts) {
-	return console.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
+async function dryRun(bin, args$1, opts) {
+	return logger.verbose(farver.blue(`[dryrun] ${bin} ${args$1.join(" ")}`), opts || "");
 }
-const runIfNotDry = globalOptions.dryRun ? dryRun : run;
-
-//#endregion
-//#region src/commits.ts
-const debug$1 = createDebugger("ucdjs:release-scripts:commits");
-async function getLastPackageTag(packageName, workspaceRoot) {
-	const { stdout } = await run("git", ["tag", "--list"], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} });
-	return stdout.split("\n").map((tag) => tag.trim()).filter(Boolean).reverse().find((tag) => tag.startsWith(`${packageName}@`));
-}
-function determineHighestBump(commits) {
-	if (commits.length === 0) return "none";
-	let highestBump = "none";
-	for (const commit of commits) {
-		const bump = determineBumpType(commit);
-		if (bump === "major") return "major";
-		if (bump === "minor") highestBump = "minor";
-		else if (bump === "patch" && highestBump === "none") highestBump = "patch";
-	}
-	return highestBump;
+const runIfNotDry = isDryRun ? dryRun : run;
+function exitWithError(message, hint) {
+	logger.error(farver.bold(message));
+	if (hint) console.error(farver.gray(`  ${hint}`));
+	process.exit(1);
 }
-async function getPackageCommits(pkg, workspaceRoot) {
-	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
-	const allCommits = getCommits({
-		from: lastTag,
-		to: "HEAD"
+if (isDryRun || isVerbose || isForce) {
+	logger.verbose(farver.inverse(farver.yellow(" Running with special flags ")));
+	logger.verbose({
+		isDryRun,
+		isVerbose,
+		isForce
 	});
-	debug$1?.(`Found ${allCommits.length} commits for ${pkg.name} since ${lastTag || "beginning"}`);
-	const touchedCommitHashes = await getCommitsTouchingPackage(lastTag || "HEAD", "HEAD", pkg.path, workspaceRoot);
-	const touchedSet = new Set(touchedCommitHashes);
-	const packageCommits = allCommits.filter((commit) => touchedSet.has(commit.shortHash));
-	debug$1?.(`${packageCommits.length} commits affect ${pkg.name}`);
-	return packageCommits;
-}
-async function analyzePackageCommits(pkg, workspaceRoot) {
-	return determineHighestBump(await getPackageCommits(pkg, workspaceRoot));
-}
-function determineBumpType(commit) {
-	if (commit.isBreaking) return "major";
-	if (!commit.isConventional || !commit.type) return "none";
-	switch (commit.type) {
-		case "feat": return "minor";
-		case "fix":
-		case "perf": return "patch";
-		case "docs":
-		case "style":
-		case "refactor":
-		case "test":
-		case "build":
-		case "ci":
-		case "chore":
-		case "revert": return "none";
-		default: return "none";
-	}
-}
-async function getCommitsTouchingPackage(from, to, packagePath, workspaceRoot) {
-	try {
-		const { stdout } = await run("git", [
-			"log",
-			"--pretty=format:%h",
-			from === "HEAD" ? "HEAD" : `${from}...${to}`,
-			"--",
-			packagePath
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-	} catch (error) {
-		debug$1?.(`Error getting commits touching package: ${error}`);
-		return [];
-	}
-}
-
-//#endregion
-//#region src/validation.ts
-/**
-* Validation utilities for release scripts
-*/
-function isValidSemver(version) {
-	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
-}
-function validateSemver(version) {
-	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
-}
-
-//#endregion
-//#region src/version.ts
-/**
-* Calculate the new version based on current version and bump type
-* Pure function - no side effects, easily testable
-*/
-function calculateNewVersion(currentVersion, bump) {
-	if (bump === "none") return currentVersion;
-	validateSemver(currentVersion);
-	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
-	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
-	const [, major, minor, patch, suffix] = match;
-	let newMajor = Number.parseInt(major, 10);
-	let newMinor = Number.parseInt(minor, 10);
-	let newPatch = Number.parseInt(patch, 10);
-	switch (bump) {
-		case "major":
-			newMajor += 1;
-			newMinor = 0;
-			newPatch = 0;
-			break;
-		case "minor":
-			newMinor += 1;
-			newPatch = 0;
-			break;
-		case "patch":
-			newPatch += 1;
-			break;
-	}
-	return `${newMajor}.${newMinor}.${newPatch}`;
-}
-/**
-* Create a version update object
-*/
-function createVersionUpdate(pkg, bump, hasDirectChanges) {
-	const newVersion = calculateNewVersion(pkg.version, bump);
-	return {
-		package: pkg,
-		currentVersion: pkg.version,
-		newVersion,
-		bumpType: bump,
-		hasDirectChanges
-	};
-}
-/**
-* Update a package.json file with new version and dependency versions
-*/
-async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
-	const packageJsonPath = join(pkg.path, "package.json");
-	const content = await readFile(packageJsonPath, "utf-8");
-	const packageJson = JSON.parse(content);
-	packageJson.version = newVersion;
-	for (const [depName, depVersion] of dependencyUpdates) {
-		if (packageJson.dependencies?.[depName]) {
-			if (packageJson.dependencies[depName] === "workspace:*") continue;
-			packageJson.dependencies[depName] = `^${depVersion}`;
-		}
-		if (packageJson.devDependencies?.[depName]) {
-			if (packageJson.devDependencies[depName] === "workspace:*") continue;
-			packageJson.devDependencies[depName] = `^${depVersion}`;
-		}
-		if (packageJson.peerDependencies?.[depName]) {
-			if (packageJson.peerDependencies[depName] === "workspace:*") continue;
-			packageJson.peerDependencies[depName] = `^${depVersion}`;
-		}
-	}
-	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
-}
-/**
-* Get all dependency updates needed for a package
-*/
-function getDependencyUpdates(pkg, allUpdates) {
-	const updates = /* @__PURE__ */ new Map();
-	const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
-	for (const dep of allDeps) {
-		const update = allUpdates.find((u) => u.package.name === dep);
-		if (update) updates.set(dep, update.newVersion);
-	}
-	return updates;
-}
-
-//#endregion
-//#region src/dependencies.ts
-/**
-* Pure function: Determine which packages need updates due to dependency changes
-*
-* When a package is updated, all packages that depend on it should also be updated.
-* This function calculates which additional packages need patch bumps.
-*
-* @param updateOrder - Packages in topological order with their dependency levels
-* @param directUpdates - Packages with direct code changes
-* @returns All updates including dependent packages
-*/
-function createDependentUpdates(updateOrder, directUpdates) {
-	const allUpdates = [...directUpdates];
-	const updatedPackages = new Set(directUpdates.map((u) => u.package.name));
-	for (const { package: pkg } of updateOrder) {
-		if (updatedPackages.has(pkg.name)) continue;
-		if (hasUpdatedDependencies(pkg, updatedPackages)) {
-			allUpdates.push(createVersionUpdate(pkg, "patch", false));
-			updatedPackages.add(pkg.name);
-		}
-	}
-	return allUpdates;
-}
-/**
-* Pure function: Check if a package has any updated dependencies
-*/
-function hasUpdatedDependencies(pkg, updatedPackages) {
-	return [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies].some((dep) => updatedPackages.has(dep));
+	logger.verbose();
 }
 
 //#endregion
-//#region src/git.ts
+//#region src/core/git.ts
 /**
 * Check if the working directory is clean (no uncommitted changes)
 * @param {string} workspaceRoot - The root directory of the workspace
@@ -244,7 +113,7 @@ async function isWorkingDirectoryClean(workspaceRoot) {
 		} })).stdout.trim() !== "") return false;
 		return true;
 	} catch (err) {
-		console.error("Error checking git status:", err);
+		logger.error("Error checking git status:", err);
 		return false;
 	}
 }
@@ -270,83 +139,123 @@ async function doesBranchExist(branch, workspaceRoot) {
 	}
 }
 /**
-* Pull latest changes from remote branch
-* @param branch - The branch name to pull from
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if pull succeeded, false otherwise
+* Retrieves the default branch name from the remote repository.
+* Falls back to "main" if the default branch cannot be determined.
+* @returns {Promise<string>} A Promise resolving to the default branch name as a string.
 */
-async function pullLatestChanges(branch, workspaceRoot) {
+async function getDefaultBranch(workspaceRoot) {
 	try {
-		await run("git", [
-			"pull",
-			"origin",
-			branch
-		], { nodeOptions: {
+		const match = (await run("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { nodeOptions: {
 			cwd: workspaceRoot,
 			stdio: "pipe"
-		} });
-		return true;
+		} })).stdout.trim().match(/^refs\/remotes\/origin\/(.+)$/);
+		if (match && match[1]) return match[1];
+		return "main";
 	} catch {
-		return false;
+		return "main";
 	}
 }
 /**
-* Create a new git branch
-* @param branch - The new branch name
-* @param base - The base branch to create from
-* @param workspaceRoot - The root directory of the workspace
+* Retrieves the name of the current branch in the repository.
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<string>} A Promise resolving to the current branch name as a string
 */
-async function createBranch(branch, base, workspaceRoot) {
-	await runIfNotDry("git", [
-		"checkout",
-		"-b",
-		branch,
-		base
-	], { nodeOptions: { cwd: workspaceRoot } });
+async function getCurrentBranch(workspaceRoot) {
+	try {
+		return (await run("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.trim();
+	} catch (err) {
+		logger.error("Error getting current branch:", err);
+		throw err;
+	}
 }
 /**
-* Checkout a git branch
-* @param branch - The branch name to checkout
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if checkout succeeded, false otherwise
+* Retrieves the list of available branches in the repository.
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<string[]>} A Promise resolving to an array of branch names
+*/
+async function getAvailableBranches(workspaceRoot) {
+	try {
+		return (await run("git", ["branch", "--list"], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.split("\n").map((line) => line.replace("*", "").trim()).filter((line) => line.length > 0);
+	} catch (err) {
+		logger.error("Error getting available branches:", err);
+		throw err;
+	}
+}
+/**
+* Creates a new branch from the specified base branch.
+* @param {string} branch - The name of the new branch to create
+* @param {string} base - The base branch to create the new branch from
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<void>} A Promise that resolves when the branch is created
 */
+async function createBranch(branch, base, workspaceRoot) {
+	try {
+		logger.info(`Creating branch: ${farver.green(branch)} from ${farver.cyan(base)}`);
+		await runIfNotDry("git", [
+			"branch",
+			branch,
+			base
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+	} catch {
+		exitWithError(`Failed to create branch: ${branch}`, `Make sure the branch doesn't already exist and you have a clean working directory`);
+	}
+}
 async function checkoutBranch(branch, workspaceRoot) {
 	try {
-		await run("git", ["checkout", branch], { nodeOptions: { cwd: workspaceRoot } });
-		return true;
+		logger.info(`Switching to branch: ${farver.green(branch)}`);
+		const match = (await run("git", ["checkout", branch], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stderr.trim().match(/Switched to branch '(.+)'/);
+		if (match && match[1] === branch) {
+			logger.info(`Successfully switched to branch: ${farver.green(branch)}`);
+			return true;
+		}
+		return false;
 	} catch {
 		return false;
 	}
 }
-/**
-* Get the current branch name
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to the current branch name
-*/
-async function getCurrentBranch(workspaceRoot) {
-	return (await run("git", [
-		"rev-parse",
-		"--abbrev-ref",
-		"HEAD"
-	], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} })).stdout.trim();
+async function pullLatestChanges(branch, workspaceRoot) {
+	try {
+		await run("git", [
+			"pull",
+			"origin",
+			branch
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		return false;
+	}
 }
-/**
-* Rebase current branch onto another branch
-* @param ontoBranch - The target branch to rebase onto
-* @param workspaceRoot - The root directory of the workspace
-*/
 async function rebaseBranch(ontoBranch, workspaceRoot) {
-	await run("git", ["rebase", ontoBranch], { nodeOptions: { cwd: workspaceRoot } });
+	try {
+		logger.info(`Rebasing onto: ${farver.cyan(ontoBranch)}`);
+		await runIfNotDry("git", ["rebase", ontoBranch], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		exitWithError(`Failed to rebase onto: ${ontoBranch}`, `You may have merge conflicts. Run 'git rebase --abort' to undo the rebase`);
+	}
 }
-/**
-* Check if local branch is ahead of remote (has commits to push)
-* @param branch - The branch name to check
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if local is ahead, false otherwise
-*/
 async function isBranchAheadOfRemote(branch, workspaceRoot) {
 	try {
 		const result = await run("git", [
@@ -362,134 +271,398 @@ async function isBranchAheadOfRemote(branch, workspaceRoot) {
 		return true;
 	}
 }
-/**
-* Check if there are any changes to commit (staged or unstaged)
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if there are changes, false otherwise
-*/
-async function hasChangesToCommit(workspaceRoot) {
-	return (await run("git", ["status", "--porcelain"], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} })).stdout.trim() !== "";
-}
-/**
-* Commit changes with a message
-* @param message - The commit message
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if commit was made, false if there were no changes
-*/
 async function commitChanges(message, workspaceRoot) {
-	await run("git", ["add", "."], { nodeOptions: { cwd: workspaceRoot } });
-	if (!await hasChangesToCommit(workspaceRoot)) return false;
-	await run("git", [
-		"commit",
-		"-m",
-		message
-	], { nodeOptions: { cwd: workspaceRoot } });
-	return true;
+	try {
+		await run("git", ["add", "."], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		if (await isWorkingDirectoryClean(workspaceRoot)) return false;
+		logger.info(`Committing changes: ${farver.dim(message)}`);
+		await runIfNotDry("git", [
+			"commit",
+			"-m",
+			message
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		exitWithError(`Failed to commit changes`, `Make sure you have git configured properly with user.name and user.email`);
+	}
 }
-/**
-* Push branch to remote
-* @param branch - The branch name to push
-* @param workspaceRoot - The root directory of the workspace
-* @param options - Push options
-* @param options.force - Force push (overwrite remote)
-* @param options.forceWithLease - Force push with safety check (won't overwrite unexpected changes)
-*/
 async function pushBranch(branch, workspaceRoot, options) {
-	const args = [
-		"push",
-		"origin",
-		branch
-	];
-	if (options?.forceWithLease) args.push("--force-with-lease");
-	else if (options?.force) args.push("--force");
-	await run("git", args, { nodeOptions: { cwd: workspaceRoot } });
-}
-/**
-* Generate PR body from version updates
-* @param updates - Array of version updates to include in the PR body
-* @returns Formatted PR body as a string
-*/
-function generatePRBody(updates) {
-	const lines = [];
-	lines.push("## Packages");
-	lines.push("");
-	const directChanges = updates.filter((u) => u.hasDirectChanges);
-	const dependencyUpdates = updates.filter((u) => !u.hasDirectChanges);
-	if (directChanges.length > 0) {
-		lines.push("### Direct Changes");
-		lines.push("");
-		for (const update of directChanges) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (${update.bumpType})`);
-		lines.push("");
-	}
-	if (dependencyUpdates.length > 0) {
-		lines.push("### Dependency Updates");
-		lines.push("");
-		for (const update of dependencyUpdates) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (dependencies changed)`);
-		lines.push("");
-	}
-	lines.push("---");
-	lines.push("");
-	lines.push("This release PR was automatically generated.");
-	return lines.join("\n");
-}
-
-//#endregion
-//#region src/github.ts
-async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
 	try {
-		const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch}`, { headers: {
-			Accept: "application/vnd.github.v3+json",
-			Authorization: `token ${githubToken}`
+		const args$1 = [
+			"push",
+			"origin",
+			branch
+		];
+		if (options?.forceWithLease) {
+			args$1.push("--force-with-lease");
+			logger.info(`Pushing branch: ${farver.green(branch)} ${farver.dim("(with lease)")}`);
+		} else if (options?.force) {
+			args$1.push("--force");
+			logger.info(`Force pushing branch: ${farver.green(branch)}`);
+		} else logger.info(`Pushing branch: ${farver.green(branch)}`);
+		await runIfNotDry("git", args$1, { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
 		} });
-		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
-		const pulls = await res.json();
-		if (pulls == null || !Array.isArray(pulls) || pulls.length === 0) return null;
-		const firstPullRequest = pulls[0];
-		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
-		const pullRequest = {
-			number: firstPullRequest.number,
-			title: firstPullRequest.title,
-			body: firstPullRequest.body,
-			draft: firstPullRequest.draft,
-			html_url: firstPullRequest.html_url
-		};
-		console.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
-		return pullRequest;
-	} catch (err) {
-		console.error("Error fetching pull request:", err);
-		return null;
+		return true;
+	} catch {
+		exitWithError(`Failed to push branch: ${branch}`, `Make sure you have permission to push to the remote repository`);
 	}
 }
-async function upsertPullRequest({ owner, repo, title, body, head, base, pullNumber, githubToken }) {
+async function readFileFromGit(workspaceRoot, ref, filePath) {
 	try {
-		const isUpdate = pullNumber != null;
-		const url = isUpdate ? `https://api.github.com/repos/${owner}/${repo}/pulls/${pullNumber}` : `https://api.github.com/repos/${owner}/${repo}/pulls`;
-		const method = isUpdate ? "PATCH" : "POST";
-		const requestBody = isUpdate ? {
+		return (await run("git", ["show", `${ref}:${filePath}`], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout;
+	} catch {
+		return null;
+	}
+}
+async function getMostRecentPackageTag(workspaceRoot, packageName) {
+	try {
+		const { stdout } = await run("git", [
+			"tag",
+			"--list",
+			`${packageName}@*`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const tags = stdout.split("\n").map((tag) => tag.trim()).filter(Boolean);
+		if (tags.length === 0) return;
+		return tags.reverse()[0];
+	} catch (err) {
+		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
+		return;
+	}
+}
+/**
+* Builds a mapping of commit SHAs to the list of files changed in each commit
+* within a given inclusive range.
+*
+* Internally runs:
+*   git log --name-only --format=%H <from>^..<to>
+*
+* Notes
+* - This includes the commit identified by `from` (via `from^..to`).
+* - Order of commits in the resulting Map follows `git log` output
+*   (reverse chronological, newest first).
+* - On failure (e.g., invalid refs), the function returns null.
+*
+* @param {string} workspaceRoot Absolute path to the git repository root used as cwd.
+* @param {string} from          Starting commit/ref (inclusive).
+* @param {string} to            Ending commit/ref (inclusive).
+* @returns {Promise<Map<string, string[]> | null>} Promise resolving to a Map where keys are commit SHAs and values are
+*          arrays of file paths changed by that commit, or null on error.
+*/
+async function getGroupedFilesByCommitSha(workspaceRoot, from, to) {
+	const commitsMap = /* @__PURE__ */ new Map();
+	try {
+		const { stdout } = await run("git", [
+			"log",
+			"--name-only",
+			"--format=%H",
+			`${from}^..${to}`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const lines = stdout.trim().split("\n").filter((line) => line.trim() !== "");
+		let currentSha = null;
+		const HASH_REGEX = /^[0-9a-f]{40}$/i;
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (HASH_REGEX.test(trimmedLine)) {
+				currentSha = trimmedLine;
+				commitsMap.set(currentSha, []);
+				continue;
+			}
+			if (currentSha === null) continue;
+			commitsMap.get(currentSha).push(trimmedLine);
+		}
+		return commitsMap;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/core/changelog.ts
+const globalAuthorCache = /* @__PURE__ */ new Map();
+const DEFAULT_CHANGELOG_TEMPLATE = dedent`
+  <% if (it.previousVersion) { -%>
+  ## [<%= it.version %>](<%= it.compareUrl %>) (<%= it.date %>)
+  <% } else { -%>
+  ## <%= it.version %> (<%= it.date %>)
+  <% } %>
+
+  <% it.groups.forEach((group) => { %>
+  <% if (group.commits.length > 0) { %>
+
+  ### <%= group.title %>
+  <% group.commits.forEach((commit) => { %>
+
+  * <%= commit.line %>
+  <% }); %>
+
+  <% } %>
+  <% }); %>
+`;
+async function generateChangelogEntry(options) {
+	const { packageName, version, previousVersion, date, commits, owner, repo, groups, template, githubClient } = options;
+	const compareUrl = previousVersion ? `https://github.com/${owner}/${repo}/compare/${packageName}@${previousVersion}...${packageName}@${version}` : void 0;
+	const grouped = groupByType(commits, {
+		includeNonConventional: false,
+		mergeKeys: Object.fromEntries(groups.map((g) => [g.name, g.types]))
+	});
+	const commitAuthors = await resolveCommitAuthors(commits, githubClient);
+	const templateData = {
+		packageName,
+		version,
+		previousVersion,
+		date,
+		compareUrl,
+		owner,
+		repo,
+		groups: groups.map((group) => {
+			const commitsInGroup = grouped.get(group.name) ?? [];
+			if (commitsInGroup.length > 0) logger.verbose(`Found ${commitsInGroup.length} commits for group "${group.name}".`);
+			const formattedCommits = commitsInGroup.map((commit) => ({ line: formatCommitLine({
+				commit,
+				owner,
+				repo,
+				authors: commitAuthors.get(commit.hash) ?? []
+			}) }));
+			return {
+				name: group.name,
+				title: group.title,
+				commits: formattedCommits
+			};
+		})
+	};
+	const eta = new Eta();
+	const templateToUse = template || DEFAULT_CHANGELOG_TEMPLATE;
+	return eta.renderString(templateToUse, templateData).trim();
+}
+async function updateChangelog(options) {
+	const { version, previousVersion, commits, date, normalizedOptions, workspacePackage, githubClient } = options;
+	const changelogPath = join(workspacePackage.path, "CHANGELOG.md");
+	const changelogRelativePath = relative(normalizedOptions.workspaceRoot, join(workspacePackage.path, "CHANGELOG.md"));
+	const existingContent = await readFileFromGit(normalizedOptions.workspaceRoot, normalizedOptions.branch.default, changelogRelativePath);
+	logger.verbose("Existing content found: ", Boolean(existingContent));
+	const newEntry = await generateChangelogEntry({
+		packageName: workspacePackage.name,
+		version,
+		previousVersion,
+		date,
+		commits,
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		groups: normalizedOptions.groups,
+		template: normalizedOptions.changelog?.template,
+		githubClient
+	});
+	let updatedContent;
+	if (!existingContent) {
+		updatedContent = `# ${workspacePackage.name}\n\n${newEntry}\n`;
+		await writeFile(changelogPath, updatedContent, "utf-8");
+		return;
+	}
+	const parsed = parseChangelog(existingContent);
+	const lines = existingContent.split("\n");
+	const existingVersionIndex = parsed.versions.findIndex((v) => v.version === version);
+	if (existingVersionIndex !== -1) {
+		const existingVersion = parsed.versions[existingVersionIndex];
+		const before = lines.slice(0, existingVersion.lineStart);
+		const after = lines.slice(existingVersion.lineEnd + 1);
+		updatedContent = [
+			...before,
+			newEntry,
+			...after
+		].join("\n");
+	} else {
+		const insertAt = parsed.headerLineEnd + 1;
+		const before = lines.slice(0, insertAt);
+		const after = lines.slice(insertAt);
+		if (before.length > 0 && before[before.length - 1] !== "") before.push("");
+		updatedContent = [
+			...before,
+			newEntry,
+			"",
+			...after
+		].join("\n");
+	}
+	await writeFile(changelogPath, updatedContent, "utf-8");
+}
+async function resolveCommitAuthors(commits, githubClient) {
+	const authorsToResolve = /* @__PURE__ */ new Set();
+	const commitAuthors = /* @__PURE__ */ new Map();
+	for (const commit of commits) {
+		const authorsForCommit = [];
+		commit.authors.forEach((author, idx) => {
+			if (!author.email || !author.name) return;
+			let info = globalAuthorCache.get(author.email);
+			if (!info) {
+				info = {
+					commits: [],
+					name: author.name,
+					email: author.email
+				};
+				globalAuthorCache.set(author.email, info);
+			}
+			if (idx === 0) info.commits.push(commit.shortHash);
+			authorsForCommit.push(info);
+			if (!info.login) authorsToResolve.add(info);
+		});
+		commitAuthors.set(commit.hash, authorsForCommit);
+	}
+	await Promise.all(Array.from(authorsToResolve).map((info) => githubClient.resolveAuthorInfo(info)));
+	return commitAuthors;
+}
+function formatCommitLine({ commit, owner, repo, authors }) {
+	const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
+	let line = `${commit.description}`;
+	const references = commit.references ?? [];
+	if (references.length > 0) logger.verbose("Located references in commit", references.length);
+	for (const ref of references) {
+		if (!ref.value) continue;
+		const number = Number.parseInt(ref.value.replace(/^#/, ""), 10);
+		if (Number.isNaN(number)) continue;
+		if (ref.type === "issue") {
+			line += ` ([Issue ${ref.value}](https://github.com/${owner}/${repo}/issues/${number}))`;
+			continue;
+		}
+		line += ` ([PR ${ref.value}](https://github.com/${owner}/${repo}/pull/${number}))`;
+	}
+	line += ` ([${commit.shortHash}](${commitUrl}))`;
+	if (authors.length > 0) {
+		const authorList = authors.map((author) => {
+			if (author.login) return `[@${author.login}](https://github.com/${author.login})`;
+			return author.name;
+		}).join(", ");
+		line += ` (by ${authorList})`;
+	}
+	return line;
+}
+function parseChangelog(content) {
+	const lines = content.split("\n");
+	let packageName = null;
+	let headerLineEnd = -1;
+	const versions = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("# ")) {
+			packageName = line.slice(2).trim();
+			headerLineEnd = i;
+			break;
+		}
+	}
+	for (let i = headerLineEnd + 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("## ")) {
+			const versionMatch = line.match(/##\s+(?:<small>)?\[?([^\](\s<]+)/);
+			if (versionMatch) {
+				const version = versionMatch[1];
+				const lineStart = i;
+				let lineEnd = lines.length - 1;
+				for (let j = i + 1; j < lines.length; j++) if (lines[j].trim().startsWith("## ")) {
+					lineEnd = j - 1;
+					break;
+				}
+				const versionContent = lines.slice(lineStart, lineEnd + 1).join("\n");
+				versions.push({
+					version,
+					lineStart,
+					lineEnd,
+					content: versionContent
+				});
+			}
+		}
+	}
+	return {
+		packageName,
+		versions,
+		headerLineEnd
+	};
+}
+
+//#endregion
+//#region src/core/github.ts
+var GitHubClient = class {
+	owner;
+	repo;
+	githubToken;
+	apiBase = "https://api.github.com";
+	constructor({ owner, repo, githubToken }) {
+		this.owner = owner;
+		this.repo = repo;
+		this.githubToken = githubToken;
+	}
+	async request(path, init = {}) {
+		const url = path.startsWith("http") ? path : `${this.apiBase}${path}`;
+		const res = await fetch(url, {
+			...init,
+			headers: {
+				...init.headers,
+				"Accept": "application/vnd.github.v3+json",
+				"Authorization": `token ${this.githubToken}`,
+				"User-Agent": "ucdjs-release-scripts (+https://github.com/ucdjs/ucdjs-release-scripts)"
+			}
+		});
+		if (!res.ok) {
+			const errorText = await res.text();
+			throw new Error(`GitHub API request failed with status ${res.status}: ${errorText || "No response body"}`);
+		}
+		if (res.status === 204) return;
+		return res.json();
+	}
+	async getExistingPullRequest(branch) {
+		const head = branch.includes(":") ? branch : `${this.owner}:${branch}`;
+		const endpoint = `/repos/${this.owner}/${this.repo}/pulls?state=open&head=${encodeURIComponent(head)}`;
+		logger.verbose(`Requesting pull request for branch: ${branch} (url: ${this.apiBase}${endpoint})`);
+		const pulls = await this.request(endpoint);
+		if (!Array.isArray(pulls) || pulls.length === 0) return null;
+		const firstPullRequest = pulls[0];
+		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
+		const pullRequest = {
+			number: firstPullRequest.number,
+			title: firstPullRequest.title,
+			body: firstPullRequest.body,
+			draft: firstPullRequest.draft,
+			html_url: firstPullRequest.html_url,
+			head: "head" in firstPullRequest && typeof firstPullRequest.head === "object" && firstPullRequest.head !== null && "sha" in firstPullRequest.head && typeof firstPullRequest.head.sha === "string" ? { sha: firstPullRequest.head.sha } : void 0
+		};
+		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
+		return pullRequest;
+	}
+	async upsertPullRequest({ title, body, head, base, pullNumber }) {
+		const isUpdate = typeof pullNumber === "number";
+		const endpoint = isUpdate ? `/repos/${this.owner}/${this.repo}/pulls/${pullNumber}` : `/repos/${this.owner}/${this.repo}/pulls`;
+		const requestBody = isUpdate ? {
 			title,
 			body
 		} : {
 			title,
 			body,
 			head,
-			base
+			base,
+			draft: true
 		};
-		const res = await fetch(url, {
-			method,
-			headers: {
-				Accept: "application/vnd.github.v3+json",
-				Authorization: `token ${githubToken}`
-			},
+		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${this.apiBase}${endpoint})`);
+		const pr = await this.request(endpoint, {
+			method: isUpdate ? "PATCH" : "POST",
 			body: JSON.stringify(requestBody)
 		});
-		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
-		const pr = await res.json();
 		if (typeof pr !== "object" || pr === null || !("number" in pr) || typeof pr.number !== "number" || !("title" in pr) || typeof pr.title !== "string" || !("body" in pr) || typeof pr.body !== "string" || !("draft" in pr) || typeof pr.draft !== "boolean" || !("html_url" in pr) || typeof pr.html_url !== "string") throw new TypeError("Pull request data validation failed");
 		const action = isUpdate ? "Updated" : "Created";
-		console.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
+		logger.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
 		return {
 			number: pr.number,
 			title: pr.title,
@@ -497,129 +670,266 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			draft: pr.draft,
 			html_url: pr.html_url
 		};
-	} catch (err) {
-		console.error(`Error upserting pull request:`, err);
-		throw err;
 	}
+	async setCommitStatus({ sha, state, targetUrl, description, context }) {
+		const endpoint = `/repos/${this.owner}/${this.repo}/statuses/${sha}`;
+		logger.verbose(`Setting commit status on ${sha} to ${state} (url: ${this.apiBase}${endpoint})`);
+		await this.request(endpoint, {
+			method: "POST",
+			body: JSON.stringify({
+				state,
+				target_url: targetUrl,
+				description: description || "",
+				context
+			})
+		});
+		logger.info(`Commit status set to ${farver.cyan(state)} for ${farver.gray(sha.substring(0, 7))}`);
+	}
+	async resolveAuthorInfo(info) {
+		if (info.login) return info;
+		try {
+			const q = encodeURIComponent(`${info.email} type:user in:email`);
+			const data = await this.request(`/search/users?q=${q}`);
+			if (!data.items || data.items.length === 0) return info;
+			info.login = data.items[0].login;
+		} catch (err) {
+			logger.warn(`Failed to resolve author info for email ${info.email}: ${err.message}`);
+		}
+		if (info.login) return info;
+		if (info.commits.length > 0) try {
+			const data = await this.request(`/repos/${this.owner}/${this.repo}/commits/${info.commits[0]}`);
+			if (data.author && data.author.login) info.login = data.author.login;
+		} catch (err) {
+			logger.warn(`Failed to resolve author info from commits for email ${info.email}: ${err.message}`);
+		}
+		return info;
+	}
+};
+function createGitHubClient(options) {
+	return new GitHubClient(options);
+}
+const DEFAULT_PR_BODY_TEMPLATE = dedent`
+  This PR was automatically generated by the release script.
+
+  The following packages have been prepared for release:
+
+  <% it.packages.forEach((pkg) => { %>
+  - **<%= pkg.name %>**: <%= pkg.currentVersion %> → <%= pkg.newVersion %> (<%= pkg.bumpType %>)
+  <% }) %>
+
+  Please review the changes and merge when ready.
+
+  For a more in-depth look at the changes, please refer to the individual package changelogs.
+
+  > [!NOTE]
+  > When this PR is merged, the release process will be triggered automatically, publishing the new package versions to the registry.
+`;
+function dedentString(str) {
+	const lines = str.split("\n");
+	const minIndent = lines.filter((line) => line.trim().length > 0).reduce((min, line) => Math.min(min, line.search(/\S/)), Infinity);
+	return lines.map((line) => minIndent === Infinity ? line : line.slice(minIndent)).join("\n").trim();
+}
+function generatePullRequestBody(updates, body) {
+	const eta = new Eta();
+	const bodyTemplate = body ? dedentString(body) : DEFAULT_PR_BODY_TEMPLATE;
+	return eta.renderString(bodyTemplate, { packages: updates.map((u) => ({
+		name: u.package.name,
+		currentVersion: u.currentVersion,
+		newVersion: u.newVersion,
+		bumpType: u.bumpType,
+		hasDirectChanges: u.hasDirectChanges
+	})) });
 }
 
 //#endregion
-//#region src/prompts.ts
-async function promptPackageSelection(packages) {
-	const response = await prompts({
-		type: "multiselect",
-		name: "selectedPackages",
-		message: "Select packages to release",
-		choices: packages.map((pkg) => ({
-			title: `${pkg.name} (${pkg.version})`,
-			value: pkg.name,
-			selected: true
-		})),
-		min: 1,
-		hint: "Space to select/deselect. Return to submit."
-	});
-	if (!response.selectedPackages || response.selectedPackages.length === 0) throw new Error("No packages selected");
-	return response.selectedPackages;
+//#region src/versioning/commits.ts
+function determineHighestBump(commits) {
+	if (commits.length === 0) return "none";
+	let highestBump = "none";
+	for (const commit of commits) {
+		const bump = determineBumpType(commit);
+		if (bump === "major") return "major";
+		if (bump === "minor") highestBump = "minor";
+		else if (bump === "patch" && highestBump === "none") highestBump = "patch";
+	}
+	return highestBump;
 }
-async function promptVersionOverride(packageName, currentVersion, suggestedVersion, suggestedBumpType) {
-	const choices = [{
-		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
-		value: "suggested"
-	}];
-	for (const bumpType of [
-		"patch",
-		"minor",
-		"major"
-	]) if (bumpType !== suggestedBumpType) {
-		const version = calculateNewVersion(currentVersion, bumpType);
-		choices.push({
-			title: `${bumpType}: ${version}`,
-			value: bumpType
+/**
+* Get commits grouped by workspace package.
+* For each package, retrieves all commits since its last release tag that affect that package.
+*
+* @param {string} workspaceRoot - The root directory of the workspace
+* @param {WorkspacePackage[]} packages - Array of workspace packages to analyze
+* @returns {Promise<Map<string, GitCommit[]>>} A map of package names to their commits since their last release
+*/
+async function getWorkspacePackageGroupedCommits(workspaceRoot, packages) {
+	const changedPackages = /* @__PURE__ */ new Map();
+	const promises = packages.map(async (pkg) => {
+		const lastTag = await getMostRecentPackageTag(workspaceRoot, pkg.name);
+		const allCommits = await getCommits({
+			from: lastTag,
+			to: "HEAD",
+			cwd: workspaceRoot,
+			folder: pkg.path
 		});
-	}
-	choices.push({
-		title: "Custom version",
-		value: "custom"
+		logger.verbose(`Found ${farver.cyan(allCommits.length)} commits for package ${farver.bold(pkg.name)} since tag ${farver.cyan(lastTag ?? "N/A")}`);
+		return {
+			pkgName: pkg.name,
+			commits: allCommits
+		};
 	});
-	const response = await prompts([{
-		type: "select",
-		name: "choice",
-		message: `${packageName} (${currentVersion}):`,
-		choices,
-		initial: 0
-	}, {
-		type: (prev) => prev === "custom" ? "text" : null,
-		name: "customVersion",
-		message: "Enter custom version:",
-		initial: suggestedVersion,
-		validate: (value) => {
-			return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(value) || "Invalid semver version (e.g., 1.0.0)";
-		}
-	}]);
-	if (response.choice === "suggested") return suggestedVersion;
-	else if (response.choice === "custom") return response.customVersion;
-	else return calculateNewVersion(currentVersion, response.choice);
+	const results = await Promise.all(promises);
+	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
+	return changedPackages;
 }
-async function promptVersionOverrides(packages) {
-	const overrides = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const newVersion = await promptVersionOverride(pkg.name, pkg.currentVersion, pkg.suggestedVersion, pkg.bumpType);
-		overrides.set(pkg.name, newVersion);
+/**
+* Check if a file path touches any package folder.
+* @param file - The file path to check
+* @param packagePaths - Set of normalized package paths
+* @param workspaceRoot - The workspace root for path normalization
+* @returns true if the file is inside a package folder
+*/
+function fileMatchesPackageFolder(file, packagePaths, workspaceRoot) {
+	const normalizedFile = file.startsWith("./") ? file.slice(2) : file;
+	for (const pkgPath of packagePaths) {
+		const normalizedPkgPath = pkgPath.startsWith(workspaceRoot) ? pkgPath.slice(workspaceRoot.length + 1) : pkgPath;
+		if (normalizedFile.startsWith(`${normalizedPkgPath}/`) || normalizedFile === normalizedPkgPath) return true;
 	}
-	return overrides;
+	return false;
 }
-
-//#endregion
-//#region src/workspace.ts
-const debug = createDebugger("ucdjs:release-scripts:workspace");
-function shouldIncludePackage(pkg, options) {
-	if (!options) return true;
-	if (options.excludePrivate && pkg.private) return false;
-	if (options.included && options.included.length > 0) {
-		if (!options.included.includes(pkg.name)) return false;
+/**
+* Check if a commit is a "global" commit (doesn't touch any package folder).
+* @param workspaceRoot - The workspace root
+* @param files - Array of files changed in the commit
+* @param packagePaths - Set of normalized package paths
+* @returns true if this is a global commit
+*/
+function isGlobalCommit(workspaceRoot, files, packagePaths) {
+	if (!files || files.length === 0) return false;
+	return !files.some((file) => fileMatchesPackageFolder(file, packagePaths, workspaceRoot));
+}
+const DEPENDENCY_FILES = [
+	"package.json",
+	"pnpm-lock.yaml",
+	"pnpm-workspace.yaml",
+	"yarn.lock",
+	"package-lock.json"
+];
+/**
+* Find the oldest and newest commits across all packages.
+* @param packageCommits - Map of package commits
+* @returns Object with oldest and newest commit SHAs, or null if no commits
+*/
+function findCommitRange(packageCommits) {
+	let oldestCommit = null;
+	let newestCommit = null;
+	for (const commits of packageCommits.values()) {
+		if (commits.length === 0) continue;
+		const firstCommit = commits[0].shortHash;
+		const lastCommit = commits[commits.length - 1].shortHash;
+		if (!newestCommit) newestCommit = firstCommit;
+		oldestCommit = lastCommit;
 	}
-	if (options.excluded?.includes(pkg.name)) return false;
-	return true;
+	if (!oldestCommit || !newestCommit) return null;
+	return {
+		oldest: oldestCommit,
+		newest: newestCommit
+	};
 }
-async function findWorkspacePackages(workspaceRoot, options) {
-	const result = await run("pnpm", [
-		"-r",
-		"ls",
-		"--json"
-	], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} });
-	const rawProjects = JSON.parse(result.stdout);
-	const packages = [];
-	const allPackageNames = new Set(rawProjects.map((p) => p.name));
-	for (const rawProject of rawProjects) {
-		const content = await readFile(join(rawProject.path, "package.json"), "utf-8");
-		const packageJson = JSON.parse(content);
-		if (!shouldIncludePackage(packageJson, options)) {
-			debug?.(`Excluding package ${rawProject.name}`);
+/**
+* Get global commits for each package based on their individual commit timelines.
+* This solves the problem where packages with different release histories need different global commits.
+*
+* A "global commit" is a commit that doesn't touch any package folder but may affect all packages
+* (e.g., root package.json, CI config, README).
+*
+* Performance: Makes ONE batched git call to get files for all commits across all packages.
+*
+* @param workspaceRoot - The root directory of the workspace
+* @param packageCommits - Map of package name to their commits (from getWorkspacePackageCommits)
+* @param allPackages - All workspace packages (used to identify package folders)
+* @param mode - Filter mode: false (disabled), "all" (all global commits), or "dependencies" (only dependency-related)
+* @returns Map of package name to their global commits
+*/
+async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPackages, mode) {
+	const result = /* @__PURE__ */ new Map();
+	if (!mode) {
+		logger.verbose("Global commits mode disabled");
+		return result;
+	}
+	logger.verbose(`Computing global commits per-package (mode: ${farver.cyan(mode)})`);
+	const commitRange = findCommitRange(packageCommits);
+	if (!commitRange) {
+		logger.verbose("No commits found across packages");
+		return result;
+	}
+	logger.verbose("Fetching files for commits range", `${farver.cyan(commitRange.oldest)}..${farver.cyan(commitRange.newest)}`);
+	const commitFilesMap = await getGroupedFilesByCommitSha(workspaceRoot, commitRange.oldest, commitRange.newest);
+	if (!commitFilesMap) {
+		logger.warn("Failed to get commit file list, returning empty global commits");
+		return result;
+	}
+	logger.verbose("Got file lists for commits", `${farver.cyan(commitFilesMap.size)} commits in ONE git call`);
+	const packagePaths = new Set(allPackages.map((p) => p.path));
+	for (const [pkgName, commits] of packageCommits) {
+		const globalCommitsAffectingPackage = [];
+		logger.verbose("Filtering global commits for package", `${farver.bold(pkgName)} from ${farver.cyan(commits.length)} commits`);
+		for (const commit of commits) {
+			const files = commitFilesMap.get(commit.shortHash);
+			if (!files) continue;
+			if (isGlobalCommit(workspaceRoot, files, packagePaths)) globalCommitsAffectingPackage.push(commit);
+		}
+		logger.verbose("Package global commits found", `${farver.bold(pkgName)}: ${farver.cyan(globalCommitsAffectingPackage.length)} global commits`);
+		if (mode === "all") {
+			result.set(pkgName, globalCommitsAffectingPackage);
 			continue;
 		}
-		const workspaceDeps = extractWorkspaceDependencies(rawProject.dependencies, allPackageNames);
-		const workspaceDevDeps = extractWorkspaceDependencies(rawProject.devDependencies, allPackageNames);
-		packages.push({
-			name: rawProject.name,
-			version: rawProject.version,
-			path: rawProject.path,
-			packageJson,
-			workspaceDependencies: workspaceDeps,
-			workspaceDevDependencies: workspaceDevDeps
-		});
+		const dependencyCommits = [];
+		for (const commit of globalCommitsAffectingPackage) {
+			const files = commitFilesMap.get(commit.shortHash);
+			if (!files) continue;
+			if (files.some((file) => DEPENDENCY_FILES.includes(file.startsWith("./") ? file.slice(2) : file))) {
+				logger.verbose("Global commit affects dependencies", `${farver.bold(pkgName)}: commit ${farver.cyan(commit.shortHash)} affects dependencies`);
+				dependencyCommits.push(commit);
+			}
+		}
+		logger.verbose("Global commits affect dependencies", `${farver.bold(pkgName)}: ${farver.cyan(dependencyCommits.length)} global commits affect dependencies`);
+		result.set(pkgName, dependencyCommits);
 	}
-	return packages;
+	return result;
 }
-function extractWorkspaceDependencies(dependencies, workspacePackages) {
-	if (!dependencies) return [];
-	return Object.keys(dependencies).filter((dep) => {
-		return workspacePackages.has(dep);
-	});
+function determineBumpType(commit) {
+	if (commit.isBreaking) return "major";
+	if (!commit.isConventional || !commit.type) return "none";
+	switch (commit.type) {
+		case "feat": return "minor";
+		case "fix":
+		case "perf": return "patch";
+		case "docs":
+		case "style":
+		case "refactor":
+		case "test":
+		case "build":
+		case "ci":
+		case "chore":
+		case "revert": return "none";
+		default: return "none";
+	}
 }
-function buildDependencyGraph(packages) {
+
+//#endregion
+//#region src/versioning/package.ts
+/**
+* Build a dependency graph from workspace packages
+*
+* Creates a bidirectional graph that maps:
+* - packages: Map of package name → WorkspacePackage
+* - dependents: Map of package name → Set of packages that depend on it
+*
+* @param packages - All workspace packages
+* @returns Dependency graph with packages and dependents maps
+*/
+function buildPackageDependencyGraph(packages) {
 	const packagesMap = /* @__PURE__ */ new Map();
 	const dependents = /* @__PURE__ */ new Map();
 	for (const pkg of packages) {
@@ -638,203 +948,809 @@ function buildDependencyGraph(packages) {
 		dependents
 	};
 }
-function getPackageUpdateOrder(graph, changedPackages) {
-	const result = [];
-	const visited = /* @__PURE__ */ new Set();
-	const toUpdate = new Set(changedPackages);
-	const packagesToProcess = new Set(changedPackages);
-	for (const pkg of changedPackages) {
-		const deps = graph.dependents.get(pkg);
-		if (deps) for (const dep of deps) {
-			packagesToProcess.add(dep);
-			toUpdate.add(dep);
+/**
+* Get all packages affected by changes (including transitive dependents)
+*
+* Uses graph traversal to find all packages that need updates:
+* - Packages with direct changes
+* - All packages that depend on changed packages (transitively)
+*
+* @param graph - Dependency graph
+* @param changedPackages - Set of package names with direct changes
+* @returns Set of all package names that need updates
+*/
+function getAllAffectedPackages(graph, changedPackages) {
+	const affected = /* @__PURE__ */ new Set();
+	function visitDependents(pkgName) {
+		if (affected.has(pkgName)) return;
+		affected.add(pkgName);
+		const dependents = graph.dependents.get(pkgName);
+		if (dependents) for (const dependent of dependents) visitDependents(dependent);
+	}
+	for (const pkg of changedPackages) visitDependents(pkg);
+	return affected;
+}
+/**
+* Create version updates for all packages affected by dependency changes
+*
+* When a package is updated, all packages that depend on it should also be updated.
+* This function calculates which additional packages need patch bumps due to dependency changes.
+*
+* @param graph - Dependency graph
+* @param workspacePackages - All workspace packages
+* @param directUpdates - Packages with direct code changes
+* @returns All updates including dependent packages that need patch bumps
+*/
+function createDependentUpdates(graph, workspacePackages, directUpdates) {
+	const allUpdates = [...directUpdates];
+	const directUpdateMap = new Map(directUpdates.map((u) => [u.package.name, u]));
+	const affectedPackages = getAllAffectedPackages(graph, new Set(directUpdates.map((u) => u.package.name)));
+	for (const pkgName of affectedPackages) {
+		logger.verbose(`Processing affected package: ${pkgName}`);
+		if (directUpdateMap.has(pkgName)) {
+			logger.verbose(`Skipping ${pkgName}, already has a direct update`);
+			continue;
 		}
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) continue;
+		allUpdates.push(createVersionUpdate(pkg, "patch", false));
 	}
-	function visit(pkgName, level) {
-		if (visited.has(pkgName)) return;
-		visited.add(pkgName);
-		const pkg = graph.packages.get(pkgName);
-		if (!pkg) return;
-		const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
-		let maxDepLevel = level;
-		for (const dep of allDeps) if (toUpdate.has(dep)) {
-			visit(dep, level);
-			const depResult = result.find((r) => r.package.name === dep);
-			if (depResult && depResult.level >= maxDepLevel) maxDepLevel = depResult.level + 1;
+	return allUpdates;
+}
+
+//#endregion
+//#region src/versioning/version.ts
+function isValidSemver(version) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+}
+function getNextVersion(currentVersion, bump) {
+	if (bump === "none") {
+		logger.verbose(`No version bump needed, keeping version ${currentVersion}`);
+		return currentVersion;
+	}
+	if (!isValidSemver(currentVersion)) throw new Error(`Cannot bump version for invalid semver: ${currentVersion}`);
+	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
+	const [, major, minor, patch] = match;
+	let newMajor = Number.parseInt(major, 10);
+	let newMinor = Number.parseInt(minor, 10);
+	let newPatch = Number.parseInt(patch, 10);
+	switch (bump) {
+		case "major":
+			newMajor += 1;
+			newMinor = 0;
+			newPatch = 0;
+			break;
+		case "minor":
+			newMinor += 1;
+			newPatch = 0;
+			break;
+		case "patch":
+			newPatch += 1;
+			break;
+	}
+	return `${newMajor}.${newMinor}.${newPatch}`;
+}
+function createVersionUpdate(pkg, bump, hasDirectChanges) {
+	const newVersion = getNextVersion(pkg.version, bump);
+	return {
+		package: pkg,
+		currentVersion: pkg.version,
+		newVersion,
+		bumpType: bump,
+		hasDirectChanges
+	};
+}
+function _calculateBumpType(oldVersion, newVersion) {
+	if (!isValidSemver(oldVersion) || !isValidSemver(newVersion)) throw new Error(`Cannot calculate bump type for invalid semver: ${oldVersion} or ${newVersion}`);
+	const oldParts = oldVersion.split(".").map(Number);
+	const newParts = newVersion.split(".").map(Number);
+	if (newParts[0] > oldParts[0]) return "major";
+	if (newParts[1] > oldParts[1]) return "minor";
+	if (newParts[2] > oldParts[2]) return "patch";
+	return "none";
+}
+const messageColorMap = {
+	feat: farver.green,
+	feature: farver.green,
+	refactor: farver.cyan,
+	style: farver.cyan,
+	docs: farver.blue,
+	doc: farver.blue,
+	types: farver.blue,
+	type: farver.blue,
+	chore: farver.gray,
+	ci: farver.gray,
+	build: farver.gray,
+	deps: farver.gray,
+	dev: farver.gray,
+	fix: farver.yellow,
+	test: farver.yellow,
+	perf: farver.magenta,
+	revert: farver.red,
+	breaking: farver.red
+};
+function formatCommitsForDisplay(commits) {
+	if (commits.length === 0) return farver.dim("No commits found");
+	const maxCommitsToShow = 10;
+	const commitsToShow = commits.slice(0, maxCommitsToShow);
+	const hasMore = commits.length > maxCommitsToShow;
+	const typeLength = commits.map(({ type }) => type.length).reduce((a, b) => Math.max(a, b), 0);
+	const scopeLength = commits.map(({ scope }) => scope?.length).reduce((a, b) => Math.max(a || 0, b || 0), 0) || 0;
+	const formattedCommits = commitsToShow.map((commit) => {
+		let color = messageColorMap[commit.type] || ((c) => c);
+		if (commit.isBreaking) color = (s) => farver.inverse.red(s);
+		const paddedType = commit.type.padStart(typeLength + 1, " ");
+		const paddedScope = !commit.scope ? " ".repeat(scopeLength ? scopeLength + 2 : 0) : farver.dim("(") + commit.scope + farver.dim(")") + " ".repeat(scopeLength - commit.scope.length);
+		return [
+			farver.dim(commit.shortHash),
+			" ",
+			color === farver.gray ? color(paddedType) : farver.bold(color(paddedType)),
+			" ",
+			paddedScope,
+			farver.dim(":"),
+			" ",
+			color === farver.gray ? color(commit.description) : commit.description
+		].join("");
+	}).join("\n");
+	if (hasMore) return `${formattedCommits}\n  ${farver.dim(`... and ${commits.length - maxCommitsToShow} more commits`)}`;
+	return formattedCommits;
+}
+async function calculateVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides: initialOverrides = {} }) {
+	const versionUpdates = [];
+	const processedPackages = /* @__PURE__ */ new Set();
+	const newOverrides = { ...initialOverrides };
+	const bumpRanks = {
+		major: 3,
+		minor: 2,
+		patch: 1,
+		none: 0
+	};
+	logger.verbose(`Starting version inference for ${packageCommits.size} packages with commits`);
+	for (const [pkgName, pkgCommits] of packageCommits) {
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) {
+			logger.error(`Package ${pkgName} not found in workspace packages, skipping`);
+			continue;
+		}
+		processedPackages.add(pkgName);
+		const globalCommits = globalCommitsPerPackage.get(pkgName) || [];
+		const allCommitsForPackage = [...pkgCommits, ...globalCommits];
+		const determinedBump = determineHighestBump(allCommitsForPackage);
+		const override = newOverrides[pkgName];
+		const effectiveBump = override?.type || determinedBump;
+		if (effectiveBump === "none") continue;
+		let newVersion = override?.version || getNextVersion(pkg.version, effectiveBump);
+		let finalBumpType = effectiveBump;
+		if (!isCI && showPrompt) {
+			logger.clearScreen();
+			logger.section(`📝 Commits for ${farver.cyan(pkg.name)}`);
+			formatCommitsForDisplay(allCommitsForPackage).split("\n").forEach((line) => logger.item(line));
+			logger.emptyLine();
+			const selectedVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, newVersion);
+			if (selectedVersion === null) continue;
+			const userBump = _calculateBumpType(pkg.version, selectedVersion);
+			finalBumpType = userBump;
+			if (bumpRanks[userBump] < bumpRanks[determinedBump]) {
+				newOverrides[pkgName] = {
+					type: userBump,
+					version: selectedVersion
+				};
+				logger.info(`Version override recorded for ${pkgName}: ${determinedBump} → ${userBump}`);
+			} else if (newOverrides[pkgName] && bumpRanks[userBump] >= bumpRanks[determinedBump]) {
+				delete newOverrides[pkgName];
+				logger.info(`Version override removed for ${pkgName}.`);
+			}
+			newVersion = selectedVersion;
 		}
-		result.push({
+		versionUpdates.push({
 			package: pkg,
-			level: maxDepLevel
+			currentVersion: pkg.version,
+			newVersion,
+			bumpType: finalBumpType,
+			hasDirectChanges: allCommitsForPackage.length > 0
 		});
 	}
-	for (const pkg of toUpdate) visit(pkg, 0);
-	result.sort((a, b) => a.level - b.level);
-	return result;
+	if (!isCI && showPrompt) for (const pkg of workspacePackages) {
+		if (processedPackages.has(pkg.name)) continue;
+		logger.clearScreen();
+		logger.section(`📦 Package: ${pkg.name}`);
+		logger.item("No direct commits found");
+		const newVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, pkg.version);
+		if (newVersion === null) break;
+		if (newVersion !== pkg.version) {
+			const bumpType = _calculateBumpType(pkg.version, newVersion);
+			versionUpdates.push({
+				package: pkg,
+				currentVersion: pkg.version,
+				newVersion,
+				bumpType,
+				hasDirectChanges: false
+			});
+		}
+	}
+	return {
+		updates: versionUpdates,
+		overrides: newOverrides
+	};
+}
+/**
+* Calculate version updates and prepare dependent updates
+* Returns both the updates and a function to apply them
+*/
+async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides }) {
+	const { updates: directUpdates, overrides: newOverrides } = await calculateVersionUpdates({
+		workspacePackages,
+		packageCommits,
+		workspaceRoot,
+		showPrompt,
+		globalCommitsPerPackage,
+		overrides
+	});
+	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, directUpdates);
+	const applyUpdates = async () => {
+		await Promise.all(allUpdates.map(async (update) => {
+			const depUpdates = getDependencyUpdates(update.package, allUpdates);
+			await updatePackageJson(update.package, update.newVersion, depUpdates);
+		}));
+	};
+	return {
+		allUpdates,
+		applyUpdates,
+		overrides: newOverrides
+	};
+}
+async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
+	const packageJsonPath = join(pkg.path, "package.json");
+	const content = await readFile(packageJsonPath, "utf-8");
+	const packageJson = JSON.parse(content);
+	packageJson.version = newVersion;
+	function updateDependency(deps, depName, depVersion, isPeerDependency = false) {
+		if (!deps) return;
+		const oldVersion = deps[depName];
+		if (!oldVersion) return;
+		if (oldVersion === "workspace:*") {
+			logger.verbose(`  - Skipping workspace:* dependency: ${depName}`);
+			return;
+		}
+		if (isPeerDependency) {
+			const majorVersion = depVersion.split(".")[0];
+			deps[depName] = `>=${depVersion} <${Number(majorVersion) + 1}.0.0`;
+		} else deps[depName] = `^${depVersion}`;
+		logger.verbose(`  - Updated dependency ${depName}: ${oldVersion} → ${deps[depName]}`);
+	}
+	for (const [depName, depVersion] of dependencyUpdates) {
+		updateDependency(packageJson.dependencies, depName, depVersion);
+		updateDependency(packageJson.devDependencies, depName, depVersion);
+		updateDependency(packageJson.peerDependencies, depName, depVersion, true);
+	}
+	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+	logger.verbose(`  - Successfully wrote updated package.json`);
+}
+/**
+* Get all dependency updates needed for a package
+*/
+function getDependencyUpdates(pkg, allUpdates) {
+	const updates = /* @__PURE__ */ new Map();
+	const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
+	for (const dep of allDeps) {
+		const update = allUpdates.find((u) => u.package.name === dep);
+		if (update) {
+			logger.verbose(`  - Dependency ${dep} will be updated: ${update.currentVersion} → ${update.newVersion} (${update.bumpType})`);
+			updates.set(dep, update.newVersion);
+		}
+	}
+	if (updates.size === 0) logger.verbose(`  - No dependency updates needed`);
+	return updates;
 }
 
 //#endregion
-//#region src/release.ts
-const isCI = process.env.CI === "true";
-async function release(options) {
-	const { dryRun: dryRun$1 = false, safeguards = true, workspaceRoot = process.cwd(), releaseBranch = "release/next", githubToken } = options;
-	globalOptions.dryRun = dryRun$1;
-	if (githubToken.trim() === "" || githubToken == null) throw new Error("GitHub token is required");
-	const [owner, repo] = options.repo.split("/");
-	if (!owner || !repo) throw new Error(`Invalid repo format: ${options.repo}. Expected "owner/repo".`);
-	if (safeguards && !isWorkingDirectoryClean(workspaceRoot)) {
-		console.error("Working directory is not clean. Please commit or stash your changes before proceeding.");
-		return null;
+//#region src/core/prompts.ts
+async function selectPackagePrompt(packages) {
+	const response = await prompts({
+		type: "multiselect",
+		name: "selectedPackages",
+		message: "Select packages to release",
+		choices: packages.map((pkg) => ({
+			title: `${pkg.name} (${farver.bold(pkg.version)})`,
+			value: pkg.name,
+			selected: true
+		})),
+		min: 1,
+		hint: "Space to select/deselect. Return to submit.",
+		instructions: false
+	});
+	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
+	return response.selectedPackages;
+}
+async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggestedVersion) {
+	const answers = await prompts([{
+		type: "autocomplete",
+		name: "version",
+		message: `${pkg.name}: ${farver.green(pkg.version)}`,
+		choices: [
+			{
+				value: "skip",
+				title: `skip ${farver.dim("(no change)")}`
+			},
+			{
+				value: "major",
+				title: `major ${farver.bold(getNextVersion(pkg.version, "major"))}`
+			},
+			{
+				value: "minor",
+				title: `minor ${farver.bold(getNextVersion(pkg.version, "minor"))}`
+			},
+			{
+				value: "patch",
+				title: `patch ${farver.bold(getNextVersion(pkg.version, "patch"))}`
+			},
+			{
+				value: "suggested",
+				title: `suggested ${farver.bold(suggestedVersion)}`
+			},
+			{
+				value: "custom",
+				title: "custom"
+			}
+		],
+		initial: suggestedVersion === currentVersion ? 0 : 4
+	}, {
+		type: (prev) => prev === "custom" ? "text" : null,
+		name: "custom",
+		message: "Enter the new version number:",
+		initial: suggestedVersion,
+		validate: (custom) => {
+			if (isValidSemver(custom)) return true;
+			return "That's not a valid version number";
+		}
+	}]);
+	if (!answers.version) return null;
+	if (answers.version === "skip") return null;
+	else if (answers.version === "suggested") return suggestedVersion;
+	else if (answers.version === "custom") {
+		if (!answers.custom) return null;
+		return answers.custom;
+	} else return getNextVersion(pkg.version, answers.version);
+}
+
+//#endregion
+//#region src/core/workspace.ts
+async function discoverWorkspacePackages(workspaceRoot, options) {
+	let workspaceOptions;
+	let explicitPackages;
+	if (options.packages == null || options.packages === true) workspaceOptions = { excludePrivate: false };
+	else if (Array.isArray(options.packages)) {
+		workspaceOptions = {
+			excludePrivate: false,
+			include: options.packages
+		};
+		explicitPackages = options.packages;
+	} else {
+		workspaceOptions = options.packages;
+		if (options.packages.include) explicitPackages = options.packages.include;
+	}
+	let workspacePackages = await findWorkspacePackages(workspaceRoot, workspaceOptions);
+	if (explicitPackages) {
+		const foundNames = new Set(workspacePackages.map((p) => p.name));
+		const missing = explicitPackages.filter((p) => !foundNames.has(p));
+		if (missing.length > 0) exitWithError(`Package${missing.length > 1 ? "s" : ""} not found in workspace: ${missing.join(", ")}`, "Check your package names or run 'pnpm ls' to see available packages");
 	}
-	const { workspacePackages, packagesToAnalyze: initialPackages } = await discoverPackages(workspaceRoot, options);
-	if (initialPackages.length === 0) return null;
 	const isPackagePromptEnabled = options.prompts?.packages !== false;
-	const isPackagesPreConfigured = Array.isArray(options.packages) || typeof options.packages === "object" && options.packages.included != null;
-	let packagesToAnalyze = initialPackages;
-	if (!isCI && isPackagePromptEnabled && !isPackagesPreConfigured) {
-		const selectedNames = await promptPackageSelection(initialPackages);
-		packagesToAnalyze = initialPackages.filter((pkg) => selectedNames.includes(pkg.name));
-	}
-	const changedPackages = await analyzeCommits(packagesToAnalyze, workspaceRoot);
-	if (changedPackages.size === 0) throw new Error("No packages have changes requiring a release");
-	let versionUpdates = calculateVersions(workspacePackages, changedPackages);
-	const isVersionPromptEnabled = options.prompts?.versions !== false;
-	if (!isCI && isVersionPromptEnabled) {
-		const versionOverrides = await promptVersionOverrides(versionUpdates.map((u) => ({
-			name: u.package.name,
-			currentVersion: u.currentVersion,
-			suggestedVersion: u.newVersion,
-			bumpType: u.bumpType
-		})));
-		versionUpdates = versionUpdates.map((update) => {
-			const overriddenVersion = versionOverrides.get(update.package.name);
-			if (overriddenVersion && overriddenVersion !== update.newVersion) return {
-				...update,
-				newVersion: overriddenVersion
-			};
-			return update;
-		});
+	if (!isCI && isPackagePromptEnabled && !explicitPackages) {
+		const selectedNames = await selectPackagePrompt(workspacePackages);
+		workspacePackages = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
 	}
-	const allUpdates = createDependentUpdates(getPackageUpdateOrder(buildDependencyGraph(workspacePackages), new Set(versionUpdates.map((u) => u.package.name))), versionUpdates);
-	const currentBranch = await getCurrentBranch(workspaceRoot);
-	const existingPullRequest = await getExistingPullRequest({
-		owner,
-		repo,
-		branch: releaseBranch,
-		githubToken
-	});
-	const prExists = !!existingPullRequest;
-	if (prExists) console.log("Existing pull request found:", existingPullRequest.html_url);
-	else console.log("No existing pull request found, will create new one");
-	const branchExists = await doesBranchExist(releaseBranch, workspaceRoot);
-	if (!branchExists) {
-		console.log("Creating release branch:", releaseBranch);
-		await createBranch(releaseBranch, currentBranch, workspaceRoot);
-	}
-	if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
-	if (branchExists) {
-		console.log("Pulling latest changes from remote");
-		if (!await pullLatestChanges(releaseBranch, workspaceRoot)) console.log("Warning: Failed to pull latest changes, continuing anyway");
-	}
-	console.log("Rebasing release branch onto", currentBranch);
-	await rebaseBranch(currentBranch, workspaceRoot);
-	await updatePackageJsonFiles(allUpdates);
-	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
-	const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
-	if (!hasCommitted && !isBranchAhead) {
-		console.log("No changes to commit and branch is in sync with remote");
-		await checkoutBranch(currentBranch, workspaceRoot);
-		if (prExists) {
-			console.log("No updates needed, PR is already up to date");
+	return workspacePackages;
+}
+async function findWorkspacePackages(workspaceRoot, options) {
+	try {
+		const result = await run("pnpm", [
+			"-r",
+			"ls",
+			"--json"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const rawProjects = JSON.parse(result.stdout);
+		const allPackageNames = new Set(rawProjects.map((p) => p.name));
+		const excludedPackages = /* @__PURE__ */ new Set();
+		const promises = rawProjects.map(async (rawProject) => {
+			const content = await readFile(join(rawProject.path, "package.json"), "utf-8");
+			const packageJson = JSON.parse(content);
+			if (!shouldIncludePackage(packageJson, options)) {
+				excludedPackages.add(rawProject.name);
+				return null;
+			}
 			return {
-				updates: allUpdates,
-				prUrl: existingPullRequest.html_url,
-				created: false
+				name: rawProject.name,
+				version: rawProject.version,
+				path: rawProject.path,
+				packageJson,
+				workspaceDependencies: Object.keys(rawProject.dependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				}),
+				workspaceDevDependencies: Object.keys(rawProject.devDependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				})
 			};
-		} else {
-			console.error("No changes to commit, and no existing PR. Nothing to do.");
-			return null;
-		}
+		});
+		const packages = await Promise.all(promises);
+		if (excludedPackages.size > 0) logger.info(`Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
+		return packages.filter((pkg) => pkg !== null);
+	} catch (err) {
+		logger.error("Error discovering workspace packages:", err);
+		throw err;
+	}
+}
+function shouldIncludePackage(pkg, options) {
+	if (!options) return true;
+	if (options.excludePrivate && pkg.private) return false;
+	if (options.include && options.include.length > 0) {
+		if (!options.include.includes(pkg.name)) return false;
 	}
-	console.log("Pushing changes to remote");
-	await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
-	const prTitle = existingPullRequest?.title || "Release: Update package versions";
-	const prBody = generatePRBody(allUpdates);
-	const pullRequest = await upsertPullRequest({
+	if (options.exclude?.includes(pkg.name)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/shared/options.ts
+const DEFAULT_COMMIT_GROUPS = [
+	{
+		name: "features",
+		title: "Features",
+		types: ["feat"]
+	},
+	{
+		name: "fixes",
+		title: "Bug Fixes",
+		types: ["fix", "perf"]
+	},
+	{
+		name: "refactor",
+		title: "Refactoring",
+		types: ["refactor"]
+	},
+	{
+		name: "docs",
+		title: "Documentation",
+		types: ["docs"]
+	}
+];
+function normalizeSharedOptions(options) {
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, prompts: prompts$1 = {
+		packages: true,
+		versions: true
+	}, groups = DEFAULT_COMMIT_GROUPS } = options;
+	if (!githubToken.trim()) exitWithError("GitHub token is required", "Set GITHUB_TOKEN environment variable or pass it in options");
+	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) exitWithError("Repository (repo) is required", "Specify the repository in 'owner/repo' format (e.g., 'octocat/hello-world')");
+	const [owner, repo] = fullRepo.split("/");
+	if (!owner || !repo) exitWithError(`Invalid repo format: "${fullRepo}"`, "Expected format: \"owner/repo\" (e.g., \"octocat/hello-world\")");
+	return {
+		packages: typeof packages === "object" && !Array.isArray(packages) ? {
+			exclude: packages.exclude ?? [],
+			include: packages.include ?? [],
+			excludePrivate: packages.excludePrivate ?? false
+		} : packages,
+		prompts: {
+			packages: prompts$1?.packages ?? true,
+			versions: prompts$1?.versions ?? true
+		},
+		workspaceRoot,
+		githubToken,
 		owner,
 		repo,
-		pullNumber: existingPullRequest?.number,
-		title: prTitle,
-		body: prBody,
-		head: releaseBranch,
-		base: currentBranch,
-		githubToken
-	});
-	console.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
-	await checkoutBranch(currentBranch, workspaceRoot);
+		groups
+	};
+}
+async function normalizeReleaseOptions(options) {
+	const normalized = normalizeSharedOptions(options);
+	let defaultBranch = options.branch?.default?.trim();
+	const releaseBranch = options.branch?.release?.trim() ?? "release/next";
+	if (defaultBranch == null || defaultBranch === "") {
+		defaultBranch = await getDefaultBranch(normalized.workspaceRoot);
+		if (!defaultBranch) exitWithError("Could not determine default branch", "Please specify the default branch in options");
+	}
+	if (defaultBranch === releaseBranch) exitWithError(`Default branch and release branch cannot be the same: "${defaultBranch}"`, "Specify different branches for default and release");
+	const availableBranches = await getAvailableBranches(normalized.workspaceRoot);
+	if (!availableBranches.includes(defaultBranch)) exitWithError(`Default branch "${defaultBranch}" does not exist in the repository`, `Available branches: ${availableBranches.join(", ")}`);
+	logger.verbose(`Using default branch: ${farver.green(defaultBranch)}`);
 	return {
-		updates: allUpdates,
-		prUrl: pullRequest?.html_url,
-		created: !prExists
+		...normalized,
+		branch: {
+			release: releaseBranch,
+			default: defaultBranch
+		},
+		safeguards: options.safeguards ?? true,
+		globalCommitMode: options.globalCommitMode ?? "dependencies",
+		pullRequest: {
+			title: options.pullRequest?.title ?? "chore: release new version",
+			body: options.pullRequest?.body ?? DEFAULT_PR_BODY_TEMPLATE
+		},
+		changelog: {
+			enabled: options.changelog?.enabled ?? true,
+			template: options.changelog?.template ?? DEFAULT_CHANGELOG_TEMPLATE
+		}
 	};
 }
-async function discoverPackages(workspaceRoot, options) {
-	let workspacePackages;
-	let packagesToAnalyze;
-	if (typeof options.packages === "boolean" && options.packages === true) {
-		workspacePackages = await findWorkspacePackages(workspaceRoot, { excludePrivate: false });
-		packagesToAnalyze = workspacePackages;
-		return {
-			workspacePackages,
-			packagesToAnalyze
-		};
+
+//#endregion
+//#region src/release.ts
+async function release(options) {
+	const { workspaceRoot,...normalizedOptions } = await normalizeReleaseOptions(options);
+	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
+	const workspacePackages = await discoverWorkspacePackages(workspaceRoot, options);
+	if (workspacePackages.length === 0) {
+		logger.warn("No packages found to release");
+		return null;
 	}
-	if (Array.isArray(options.packages)) {
-		const packageNames = options.packages;
-		workspacePackages = await findWorkspacePackages(workspaceRoot, {
-			excludePrivate: false,
-			included: packageNames
-		});
-		packagesToAnalyze = workspacePackages.filter((pkg) => packageNames.includes(pkg.name));
-		if (packagesToAnalyze.length !== packageNames.length) {
-			const found = new Set(packagesToAnalyze.map((p) => p.name));
-			const missing = packageNames.filter((p) => !found.has(p));
-			throw new Error(`Packages not found in workspace: ${missing.join(", ")}`);
+	logger.section("📦 Workspace Packages");
+	logger.item(`Found ${workspacePackages.length} packages`);
+	for (const pkg of workspacePackages) {
+		logger.item(`${farver.cyan(pkg.name)} (${farver.bold(pkg.version)})`);
+		logger.item(`  ${farver.gray("→")} ${farver.gray(pkg.path)}`);
+	}
+	logger.emptyLine();
+	const groupedPackageCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
+	const globalCommitsPerPackage = await getGlobalCommitsPerPackage(workspaceRoot, groupedPackageCommits, workspacePackages, normalizedOptions.globalCommitMode);
+	const githubClient = createGitHubClient({
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		githubToken: normalizedOptions.githubToken
+	});
+	const prOps = await orchestrateReleasePullRequest({
+		workspaceRoot,
+		githubClient,
+		releaseBranch: normalizedOptions.branch.release,
+		defaultBranch: normalizedOptions.branch.default,
+		pullRequestTitle: options.pullRequest?.title,
+		pullRequestBody: options.pullRequest?.body
+	});
+	await prOps.prepareBranch();
+	const overridesPath = join(workspaceRoot, ucdjsReleaseOverridesPath);
+	let existingOverrides = {};
+	try {
+		const overridesContent = await readFile(overridesPath, "utf-8");
+		existingOverrides = JSON.parse(overridesContent);
+		logger.info("Found existing version overrides file.");
+	} catch {
+		logger.info("No existing version overrides file found. Continuing...");
+	}
+	const { allUpdates, applyUpdates, overrides: newOverrides } = await calculateAndPrepareVersionUpdates({
+		workspacePackages,
+		packageCommits: groupedPackageCommits,
+		workspaceRoot,
+		showPrompt: options.prompts?.versions !== false,
+		globalCommitsPerPackage,
+		overrides: existingOverrides
+	});
+	if (Object.keys(newOverrides).length > 0) {
+		logger.info("Writing version overrides file...");
+		try {
+			await mkdir(join(workspaceRoot, ".github"), { recursive: true });
+			await writeFile(overridesPath, JSON.stringify(newOverrides, null, 2), "utf-8");
+			logger.success("Successfully wrote version overrides file.");
+		} catch (e) {
+			logger.error("Failed to write version overrides file:", e);
+		}
+	}
+	if (Object.keys(newOverrides).length === 0 && Object.keys(existingOverrides).length > 0) {
+		let shouldRemoveOverrides = false;
+		for (const update of allUpdates) {
+			const overriddenVersion = existingOverrides[update.package.name];
+			if (overriddenVersion) {
+				if (compare(update.newVersion, overriddenVersion.version) > 0) {
+					shouldRemoveOverrides = true;
+					break;
+				}
+			}
 		}
+		if (shouldRemoveOverrides) {
+			logger.info("Removing obsolete version overrides file...");
+			try {
+				await rm(overridesPath);
+				logger.success("Successfully removed obsolete version overrides file.");
+			} catch (e) {
+				logger.error("Failed to remove obsolete version overrides file:", e);
+			}
+		}
+	}
+	if (allUpdates.filter((u) => u.hasDirectChanges).length === 0) logger.warn("No packages have changes requiring a release");
+	logger.section("🔄 Version Updates");
+	logger.item(`Updating ${allUpdates.length} packages (including dependents)`);
+	for (const update of allUpdates) logger.item(`${update.package.name}: ${update.currentVersion} → ${update.newVersion}`);
+	await applyUpdates();
+	if (normalizedOptions.changelog.enabled) {
+		logger.step("Updating changelogs");
+		const changelogPromises = allUpdates.map((update) => {
+			const pkgCommits = groupedPackageCommits.get(update.package.name) || [];
+			const globalCommits = globalCommitsPerPackage.get(update.package.name) || [];
+			const allCommits = [...pkgCommits, ...globalCommits];
+			if (allCommits.length === 0) {
+				logger.verbose(`No commits for ${update.package.name}, skipping changelog`);
+				return Promise.resolve();
+			}
+			logger.verbose(`Updating changelog for ${farver.cyan(update.package.name)}`);
+			return updateChangelog({
+				normalizedOptions: {
+					...normalizedOptions,
+					workspaceRoot
+				},
+				githubClient,
+				workspacePackage: update.package,
+				version: update.newVersion,
+				previousVersion: update.currentVersion !== "0.0.0" ? update.currentVersion : void 0,
+				commits: allCommits,
+				date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+			});
+		}).filter((p) => p != null);
+		const updates = await Promise.all(changelogPromises);
+		logger.success(`Updated ${updates.length} changelog(s)`);
+	}
+	if (!await prOps.syncChanges(true)) if (prOps.doesReleasePRExist && prOps.existingPullRequest) {
+		logger.item("No updates needed, PR is already up to date");
+		const { pullRequest: pullRequest$1, created: created$1 } = await prOps.syncPullRequest(allUpdates);
+		await prOps.cleanup();
 		return {
-			workspacePackages,
-			packagesToAnalyze
+			updates: allUpdates,
+			prUrl: pullRequest$1?.html_url,
+			created: created$1
 		};
+	} else {
+		logger.error("No changes to commit, and no existing PR. Nothing to do.");
+		return null;
+	}
+	const { pullRequest, created } = await prOps.syncPullRequest(allUpdates);
+	await prOps.cleanup();
+	if (pullRequest?.html_url) {
+		logger.section("🚀 Pull Request");
+		logger.success(`Pull request ${created ? "created" : "updated"}: ${pullRequest.html_url}`);
 	}
-	workspacePackages = await findWorkspacePackages(workspaceRoot, options.packages);
-	packagesToAnalyze = workspacePackages;
 	return {
-		workspacePackages,
-		packagesToAnalyze
+		updates: allUpdates,
+		prUrl: pullRequest?.html_url,
+		created
 	};
 }
-async function analyzeCommits(packages, workspaceRoot) {
-	const changedPackages = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const bump = await analyzePackageCommits(pkg, workspaceRoot);
-		if (bump !== "none") changedPackages.set(pkg.name, bump);
-	}
-	return changedPackages;
+async function orchestrateReleasePullRequest({ workspaceRoot, githubClient, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody }) {
+	const currentBranch = await getCurrentBranch(workspaceRoot);
+	if (currentBranch !== defaultBranch) exitWithError(`Current branch is '${currentBranch}'. Please switch to the default branch '${defaultBranch}' before proceeding.`, `git checkout ${defaultBranch}`);
+	const existingPullRequest = await githubClient.getExistingPullRequest(releaseBranch);
+	const doesReleasePRExist = !!existingPullRequest;
+	if (doesReleasePRExist) logger.item("Found existing release pull request");
+	else logger.item("Will create new pull request");
+	const branchExists = await doesBranchExist(releaseBranch, workspaceRoot);
+	return {
+		existingPullRequest,
+		doesReleasePRExist,
+		async prepareBranch() {
+			if (!branchExists) await createBranch(releaseBranch, defaultBranch, workspaceRoot);
+			logger.step(`Checking out release branch: ${releaseBranch}`);
+			if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
+			if (branchExists) {
+				logger.step("Pulling latest changes from remote");
+				if (!await pullLatestChanges(releaseBranch, workspaceRoot)) logger.warn("Failed to pull latest changes, continuing anyway");
+			}
+			logger.step(`Rebasing onto ${defaultBranch}`);
+			if (!await rebaseBranch(defaultBranch, workspaceRoot)) throw new Error(`Failed to rebase onto ${defaultBranch}. Please resolve conflicts manually.`);
+		},
+		async syncChanges(hasChanges) {
+			const hasCommitted = hasChanges ? await commitChanges("chore: update release versions", workspaceRoot) : false;
+			const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
+			if (!hasCommitted && !isBranchAhead) {
+				logger.item("No changes to commit and branch is in sync with remote");
+				return false;
+			}
+			logger.step("Pushing changes to remote");
+			if (!await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true })) throw new Error(`Failed to push changes to ${releaseBranch}. Remote may have been updated.`);
+			return true;
+		},
+		async syncPullRequest(updates) {
+			const prTitle = existingPullRequest?.title || pullRequestTitle || "chore: update package versions";
+			const prBody = generatePullRequestBody(updates, pullRequestBody);
+			const pullRequest = await githubClient.upsertPullRequest({
+				pullNumber: existingPullRequest?.number,
+				title: prTitle,
+				body: prBody,
+				head: releaseBranch,
+				base: defaultBranch
+			});
+			logger.success(`${doesReleasePRExist ? "Updated" : "Created"} pull request: ${pullRequest?.html_url}`);
+			return {
+				pullRequest,
+				created: !doesReleasePRExist
+			};
+		},
+		async cleanup() {
+			await checkoutBranch(defaultBranch, workspaceRoot);
+		}
+	};
 }
-function calculateVersions(allPackages, changedPackages) {
-	const updates = [];
-	for (const [pkgName, bump] of changedPackages) {
-		const pkg = allPackages.find((p) => p.name === pkgName);
-		if (!pkg) continue;
-		updates.push(createVersionUpdate(pkg, bump, true));
+
+//#endregion
+//#region src/verify.ts
+async function verify(options) {
+	const { workspaceRoot,...normalizedOptions } = await normalizeReleaseOptions(options);
+	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
+	const githubClient = createGitHubClient({
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		githubToken: normalizedOptions.githubToken
+	});
+	const releaseBranch = normalizedOptions.branch.release;
+	const defaultBranch = normalizedOptions.branch.default;
+	const releasePr = await githubClient.getExistingPullRequest(releaseBranch);
+	if (!releasePr || !releasePr.head) {
+		logger.warn(`No open release pull request found for branch "${releaseBranch}". Nothing to verify.`);
+		return;
+	}
+	logger.info(`Found release PR #${releasePr.number}. Verifying against default branch "${defaultBranch}"...`);
+	const originalBranch = await getCurrentBranch(workspaceRoot);
+	if (originalBranch !== defaultBranch) await checkoutBranch(defaultBranch, workspaceRoot);
+	const overridesPath = join(workspaceRoot, ucdjsReleaseOverridesPath);
+	let existingOverrides = {};
+	try {
+		const overridesContent = await readFileFromGit(workspaceRoot, releasePr.head.sha, overridesPath);
+		if (overridesContent) {
+			existingOverrides = JSON.parse(overridesContent);
+			logger.info("Found existing version overrides file on release branch.");
+		}
+	} catch {
+		logger.info("No version overrides file found on release branch. Continuing...");
+	}
+	const mainPackages = await discoverWorkspacePackages(workspaceRoot, options);
+	const mainCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, mainPackages);
+	const { allUpdates: expectedUpdates } = await calculateAndPrepareVersionUpdates({
+		workspacePackages: mainPackages,
+		packageCommits: mainCommits,
+		workspaceRoot,
+		showPrompt: false,
+		globalCommitsPerPackage: await getGlobalCommitsPerPackage(workspaceRoot, mainCommits, mainPackages, normalizedOptions.globalCommitMode),
+		overrides: existingOverrides
+	});
+	const expectedVersionMap = new Map(expectedUpdates.map((u) => [u.package.name, u.newVersion]));
+	const prVersionMap = /* @__PURE__ */ new Map();
+	for (const pkg of mainPackages) {
+		const pkgJsonPath = join(pkg.path.replace(workspaceRoot, ""), "package.json").substring(1);
+		const pkgJsonContent = await readFileFromGit(workspaceRoot, releasePr.head.sha, pkgJsonPath);
+		if (pkgJsonContent) {
+			const pkgJson = JSON.parse(pkgJsonContent);
+			prVersionMap.set(pkg.name, pkgJson.version);
+		}
+	}
+	if (originalBranch !== defaultBranch) await checkoutBranch(originalBranch, workspaceRoot);
+	let isOutOfSync = false;
+	for (const [pkgName, expectedVersion] of expectedVersionMap.entries()) {
+		const prVersion = prVersionMap.get(pkgName);
+		if (!prVersion) {
+			logger.warn(`Package "${pkgName}" found in default branch but not in release branch. Skipping.`);
+			continue;
+		}
+		if (gt(expectedVersion, prVersion)) {
+			logger.error(`Package "${pkgName}" is out of sync. Expected version >= ${expectedVersion}, but PR has ${prVersion}.`);
+			isOutOfSync = true;
+		} else logger.success(`Package "${pkgName}" is up to date (PR version: ${prVersion}, Expected: ${expectedVersion})`);
+	}
+	const statusContext = "ucdjs/release-verify";
+	if (isOutOfSync) {
+		await githubClient.setCommitStatus({
+			sha: releasePr.head.sha,
+			state: "failure",
+			context: statusContext,
+			description: "Release PR is out of sync with the default branch. Please re-run the release process."
+		});
+		logger.error("Verification failed. Commit status set to 'failure'.");
+	} else {
+		await githubClient.setCommitStatus({
+			sha: releasePr.head.sha,
+			state: "success",
+			context: statusContext,
+			description: "Release PR is up to date."
+		});
+		logger.success("Verification successful. Commit status set to 'success'.");
 	}
-	return updates;
-}
-async function updatePackageJsonFiles(updates) {
-	await Promise.all(updates.map(async (update) => {
-		const depUpdates = getDependencyUpdates(update.package, updates);
-		await updatePackageJson(update.package, update.newVersion, depUpdates);
-	}));
 }
 
 //#endregion
-export { release };
+export { publish, release, verify };