@ucdjs/release-scripts 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/index.mjs

@@ -1,44 +1,66 @@
 import { t as Eta } from "./eta-Boh7yPZi.mjs";
-import farver from "farver";
-import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import process from "node:process";
+import farver from "farver";
+import mri from "mri";
 import { exec } from "tinyexec";
-import { getCommits } from "commit-parser";
 import { dedent } from "@luxass/utils";
+import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { getCommits } from "commit-parser";
 import prompts from "prompts";
 
 //#region src/publish.ts
 function publish(_options) {}
 
 //#endregion
-//#region src/utils.ts
-const globalOptions = {
-	dryRun: false,
-	verbose: false
-};
+//#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 isCI = typeof process.env.CI === "string" && process.env.CI !== "" && process.env.CI.toLowerCase() !== "false";
 const logger = {
-	info: (...args) => {
-		console.info(farver.cyan("[info]:"), ...args);
+	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);
 	},
-	debug: (...args) => {
-		console.debug(farver.gray("[debug]:"), ...args);
+	section: (title) => {
+		console.log();
+		console.log(`  ${farver.bold(title)}`);
+		console.log(`  ${farver.gray("─".repeat(title.length + 2))}`);
 	},
-	warn: (...args) => {
-		console.warn(farver.yellow("[warn]:"), ...args);
+	emptyLine: () => {
+		console.log();
 	},
-	error: (...args) => {
-		console.error(farver.red("[error]:"), ...args);
+	item: (message) => {
+		console.log(`  ${message}`);
 	},
-	log: (...args) => {
-		if (!globalOptions.verbose) return;
-		console.log(...args);
+	step: (message) => {
+		console.log(`  ${farver.blue("→")} ${message}`);
+	},
+	success: (message) => {
+		console.log(`  ${farver.green("✓")} ${message}`);
 	}
 };
-async function run(bin, args, opts = {}) {
-	return exec(bin, args, {
+async function run(bin, args$1, opts = {}) {
+	return exec(bin, args$1, {
 		throwOnError: true,
 		...opts,
 		nodeOptions: {
@@ -47,21 +69,20 @@ async function run(bin, args, opts = {}) {
 		}
 	});
 }
-async function dryRun(bin, args, opts) {
-	return logger.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;
+const runIfNotDry = isDryRun ? dryRun : run;
 function exitWithError(message, hint) {
 	logger.error(farver.bold(message));
 	if (hint) console.error(farver.gray(`  ${hint}`));
 	process.exit(1);
 }
 function normalizeSharedOptions(options) {
-	const { workspaceRoot = process.cwd(), githubToken = "", verbose = false, repo: fullRepo, packages = true, prompts: prompts$1 = {
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, prompts: prompts$1 = {
 		packages: true,
 		versions: true
 	},...rest } = options;
-	globalOptions.verbose = verbose;
 	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("/");
@@ -69,259 +90,28 @@ function normalizeSharedOptions(options) {
 	return {
 		...rest,
 		packages,
-		prompts: prompts$1,
+		prompts: {
+			packages: prompts$1?.packages ?? true,
+			versions: prompts$1?.versions ?? true
+		},
 		workspaceRoot,
 		githubToken,
 		owner,
-		repo,
-		verbose
+		repo
 	};
 }
-
-//#endregion
-//#region src/changelog.ts
-/**
-* Get section label for commit type
-*/
-function getSectionLabel(type) {
-	return {
-		feat: "Features",
-		fix: "Bug Fixes",
-		docs: "Documentation",
-		style: "Styles",
-		refactor: "Code Refactoring",
-		perf: "Performance Improvements",
-		test: "Tests",
-		build: "Build System",
-		ci: "Continuous Integration",
-		chore: "Miscellaneous Chores",
-		revert: "Reverts"
-	}[type] || "Other Changes";
-}
-/**
-* Generate changelog content from commits
-*/
-function generateChangelog(pkg, newVersion, commits, previousVersion, repository) {
-	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-	let versionHeader = `## `;
-	if (repository && previousVersion) {
-		const compareUrl = `https://github.com/${repository.owner}/${repository.repo}/compare/${pkg.name}@${previousVersion}...${pkg.name}@${newVersion}`;
-		versionHeader += `[${newVersion}](${compareUrl})`;
-	} else versionHeader += newVersion;
-	versionHeader += ` (${date})\n\n`;
-	let changelog = versionHeader;
-	const grouped = /* @__PURE__ */ new Map();
-	for (const commit of commits) {
-		if (!commit.isConventional || !commit.type) continue;
-		const type = commit.type;
-		if (!grouped.has(type)) grouped.set(type, []);
-		grouped.get(type).push(commit);
-	}
-	for (const type of [
-		"feat",
-		"fix",
-		"perf",
-		"refactor",
-		"docs",
-		"test",
-		"build",
-		"ci",
-		"chore",
-		"revert",
-		"style"
-	]) {
-		const commits$1 = grouped.get(type);
-		if (!commits$1 || commits$1.length === 0) continue;
-		const label = getSectionLabel(type);
-		changelog += `### ${label}\n\n`;
-		for (const commit of commits$1) {
-			const scope = commit.scope ? `**${commit.scope}:** ` : "";
-			const breaking = commit.isBreaking ? " **BREAKING CHANGE**" : "";
-			let entry = `* ${scope}${commit.description}${breaking}`;
-			if (repository) {
-				const commitUrl = `https://github.com/${repository.owner}/${repository.repo}/commit/${commit.shortHash}`;
-				entry += ` ([${commit.shortHash}](${commitUrl}))`;
-			} else entry += ` (${commit.shortHash})`;
-			changelog += `${entry}\n`;
-		}
-		changelog += "\n";
-	}
-	return changelog.trim();
-}
-/**
-* Write changelog to package's CHANGELOG.md file
-*/
-async function writeChangelog(pkg, newContent, version) {
-	const changelogPath = join(pkg.path, "CHANGELOG.md");
-	let existingContent = "";
-	if (existsSync(changelogPath)) existingContent = await readFile(changelogPath, "utf-8");
-	let updatedContent;
-	if (existingContent) {
-		const withoutTitle = existingContent.replace(/^# Changelog\n\n/, "");
-		if (new RegExp(`^## ${version.replace(/\./g, "\\.")}(\\s|$)`, "m").test(withoutTitle)) {
-			const versionSectionRegex = new RegExp(`^## ${version.replace(/\./g, "\\.")}[\\s\\S]*?(?=^## |$)`, "m");
-			updatedContent = `# Changelog\n\n${withoutTitle.replace(versionSectionRegex, `${newContent}\n\n`)}`;
-		} else updatedContent = `# Changelog\n\n${newContent}\n\n${withoutTitle}`;
-	} else updatedContent = `# Changelog\n\n${newContent}\n`;
-	await writeFile(changelogPath, updatedContent, "utf-8");
-	logger.log(`Updated changelog: ${changelogPath}`);
-}
-/**
-* Generate and write changelogs for all updated packages
-*/
-async function updateChangelogs(updates, packageCommits, options) {
-	if (!options?.enabled) {
-		logger.log("Changelog generation is disabled");
-		return;
-	}
-	logger.log("Generating changelogs...");
-	for (const update of updates) {
-		if (!update.hasDirectChanges) continue;
-		const commits = packageCommits.get(update.package.name) || [];
-		if (commits.length === 0) continue;
-		let changelog = generateChangelog(update.package, update.newVersion, commits, update.currentVersion, options.repository);
-		if (options.transform) changelog = await options.transform(changelog, update.package);
-		logger.info(`Generating changelog for package ${update.package.name}`);
-		await writeChangelog(update.package, changelog, update.newVersion);
-	}
-}
-
-//#endregion
-//#region src/commits.ts
-async function getLastPackageTag(packageName, workspaceRoot) {
-	try {
-		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}@`));
-	} catch (err) {
-		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
-		return;
-	}
-}
-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;
-}
-/**
-* Retrieves commits that affect a specific workspace package since its last tag.
-*
-* @param {string} workspaceRoot - The root directory of the workspace.
-* @param {WorkspacePackage} pkg - The workspace package to analyze.
-* @returns {Promise<GitCommit[]>} A promise that resolves to an array of GitCommit objects affecting the package.
-*/
-async function getCommitsForWorkspacePackage(workspaceRoot, pkg) {
-	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
-	const allCommits = getCommits({
-		from: lastTag,
-		to: "HEAD",
-		cwd: workspaceRoot
-	});
-	logger.log(`Found ${allCommits.length} commits for ${pkg.name} since ${lastTag || "beginning"}`);
-	const touchedCommitHashes = getCommits({
-		from: lastTag,
-		to: "HEAD",
-		cwd: workspaceRoot,
-		folder: pkg.path
-	});
-	const touchedSet = new Set(touchedCommitHashes);
-	const packageCommits = allCommits.filter((commit) => touchedSet.has(commit));
-	logger.log(`${packageCommits.length} commits affect ${pkg.name}`);
-	return packageCommits;
-}
-async function getWorkspacePackageCommits(workspaceRoot, packages) {
-	const changedPackages = /* @__PURE__ */ new Map();
-	const promises = packages.map(async (pkg) => {
-		return {
-			pkgName: pkg.name,
-			commits: await getCommitsForWorkspacePackage(workspaceRoot, pkg)
-		};
-	});
-	const results = await Promise.all(promises);
-	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
-	return changedPackages;
-}
-/**
-* Get all commits for the workspace (not filtered by package)
-*/
-async function getAllWorkspaceCommits(workspaceRoot, lastTag) {
-	return getCommits({
-		from: lastTag,
-		to: "HEAD",
-		cwd: workspaceRoot
+if (isDryRun || isVerbose || isForce) {
+	logger.verbose(farver.inverse(farver.yellow(" Running with special flags ")));
+	logger.verbose({
+		isDryRun,
+		isVerbose,
+		isForce
 	});
-}
-/**
-* Get files changed in a specific commit
-*/
-async function getFilesChangedInCommit(commitHash, workspaceRoot) {
-	try {
-		const { stdout } = await run("git", [
-			"diff-tree",
-			"--no-commit-id",
-			"--name-only",
-			"-r",
-			commitHash
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return stdout.split("\n").map((file) => file.trim()).filter(Boolean);
-	} catch {
-		return null;
-	}
-}
-/**
-* Filter and combine package commits with global commits
-*/
-function combineWithGlobalCommits(workspaceRoot, packageCommits, allCommits, mode) {
-	if (!mode) return packageCommits;
-	const packageCommitShas = new Set(packageCommits.map((c) => c.shortHash));
-	const globalCommits = allCommits.filter((c) => !packageCommitShas.has(c.shortHash));
-	if (mode === "all") return [...packageCommits, ...globalCommits];
-	if (mode === "dependencies") {
-		const dependencyCommits = globalCommits.filter(async (c) => {
-			const affectedFiles = await getFilesChangedInCommit(c.shortHash, workspaceRoot);
-			if (affectedFiles == null) return false;
-			return affectedFiles.some((file) => [
-				"package.json",
-				"pnpm-lock.yaml",
-				"pnpm-workspace.yaml"
-			].includes(file));
-		});
-		return [...packageCommits, ...dependencyCommits];
-	}
-	return packageCommits;
-}
-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";
-	}
+	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
@@ -361,31 +151,64 @@ 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 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;
+	}
+}
+/**
+* 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 {
@@ -403,16 +226,29 @@ async function createBranch(branch, base, workspaceRoot) {
 		exitWithError(`Failed to create branch: ${branch}`, `Make sure the branch doesn't already exist and you have a clean working directory`);
 	}
 }
-/**
-* 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
-*/
 async function checkoutBranch(branch, workspaceRoot) {
 	try {
 		logger.info(`Switching to branch: ${farver.green(branch)}`);
-		await run("git", ["checkout", branch], { nodeOptions: {
+		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;
+	}
+}
+async function pullLatestChanges(branch, workspaceRoot) {
+	try {
+		await run("git", [
+			"pull",
+			"origin",
+			branch
+		], { nodeOptions: {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
@@ -421,43 +257,18 @@ async function checkoutBranch(branch, workspaceRoot) {
 		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();
-}
-/**
-* 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) {
 	try {
 		logger.info(`Rebasing onto: ${farver.cyan(ontoBranch)}`);
-		await run("git", ["rebase", ontoBranch], { nodeOptions: {
+		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", [
@@ -473,23 +284,12 @@ 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) {
 	try {
 		await run("git", ["add", "."], { nodeOptions: {
@@ -511,51 +311,35 @@ async function commitChanges(message, workspaceRoot) {
 		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) {
 	try {
-		const args = [
+		const args$1 = [
 			"push",
 			"origin",
 			branch
 		];
 		if (options?.forceWithLease) {
-			args.push("--force-with-lease");
+			args$1.push("--force-with-lease");
 			logger.info(`Pushing branch: ${farver.green(branch)} ${farver.dim("(with lease)")}`);
 		} else if (options?.force) {
-			args.push("--force");
+			args$1.push("--force");
 			logger.info(`Force pushing branch: ${farver.green(branch)}`);
 		} else logger.info(`Pushing branch: ${farver.green(branch)}`);
-		await run("git", args, { nodeOptions: {
+		await runIfNotDry("git", args$1, { nodeOptions: {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
+		return true;
 	} catch {
 		exitWithError(`Failed to push branch: ${branch}`, `Make sure you have permission to push to the remote repository`);
 	}
 }
-async function getDefaultBranch() {
-	try {
-		const match = (await run("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { nodeOptions: { stdio: "pipe" } })).stdout.trim().match(/^refs\/remotes\/origin\/(.+)$/);
-		if (match && match[1]) return match[1];
-		return "main";
-	} catch {
-		return "main";
-	}
-}
 
 //#endregion
-//#region src/github.ts
+//#region src/core/github.ts
 async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
 	try {
-		logger.debug(`Requesting pull request for branch: ${branch} (url: https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch})`);
+		logger.verbose(`Requesting pull request for branch: ${branch} (url: https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch})`);
 		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}`
@@ -591,9 +375,10 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			title,
 			body,
 			head,
-			base
+			base,
+			draft: true
 		};
-		logger.debug(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${url})`);
+		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${url})`);
 		const res = await fetch(url, {
 			method,
 			headers: {
@@ -653,174 +438,226 @@ function generatePullRequestBody(updates, body) {
 }
 
 //#endregion
-//#region src/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 promptVersionOverride(pkg, workspaceRoot, currentVersion, suggestedVersion, suggestedBumpType) {
-	const choices = [{
-		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
-		value: "suggested"
-	}];
-	for (const bumpType of [
-		"patch",
-		"minor",
-		"major"
-	]) if (bumpType !== suggestedBumpType) {
-		const version = getNextVersion(currentVersion, bumpType);
-		choices.push({
-			title: `${bumpType}: ${version}`,
-			value: bumpType
-		});
+//#region src/versioning/commits.ts
+async function getLastPackageTag(packageName, workspaceRoot) {
+	try {
+		const { stdout } = await run("git", [
+			"tag",
+			"--list",
+			`${packageName}@*`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return stdout.split("\n").map((tag) => tag.trim()).filter(Boolean).reverse()[0];
+	} catch (err) {
+		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
+		return;
 	}
-	choices.push({
-		title: "Custom version",
-		value: "custom"
-	});
-	const response = await prompts([{
-		type: "select",
-		name: "choice",
-		message: `${pkg.name} (${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 getNextVersion(currentVersion, response.choice);
 }
-
-//#endregion
-//#region src/version.ts
-function isValidSemver(version) {
-	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+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;
 }
-function validateSemver(version) {
-	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
+/**
+* Retrieves commits that affect a specific workspace package since its last tag.
+*
+* @param {string} workspaceRoot - The root directory of the workspace.
+* @param {WorkspacePackage} pkg - The workspace package to analyze.
+* @returns {Promise<GitCommit[]>} A promise that resolves to an array of GitCommit objects affecting the package.
+*/
+async function getCommitsForWorkspacePackage(workspaceRoot, pkg) {
+	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
+	const allCommits = getCommits({
+		from: lastTag,
+		to: "HEAD",
+		cwd: workspaceRoot
+	});
+	logger.verbose("Found commits for package", `${farver.cyan(allCommits.length)} for ${farver.bold(pkg.name)} since ${lastTag || "beginning"}`);
+	const commitsAffectingPackage = getCommits({
+		from: lastTag,
+		to: "HEAD",
+		cwd: workspaceRoot,
+		folder: pkg.path
+	});
+	const affectingCommitShas = /* @__PURE__ */ new Set();
+	for (const commit of commitsAffectingPackage) affectingCommitShas.add(commit.shortHash);
+	const packageCommits = allCommits.filter((commit) => {
+		return affectingCommitShas.has(commit.shortHash);
+	});
+	logger.verbose("Commits affect package", `${farver.cyan(packageCommits.length)} affect ${farver.bold(pkg.name)}`);
+	return packageCommits;
 }
-function getNextVersion(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] = 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;
+async function getWorkspacePackageCommits(workspaceRoot, packages) {
+	const changedPackages = /* @__PURE__ */ new Map();
+	const promises = packages.map(async (pkg) => {
+		return {
+			pkgName: pkg.name,
+			commits: await getCommitsForWorkspacePackage(workspaceRoot, pkg)
+		};
+	});
+	const results = await Promise.all(promises);
+	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
+	return changedPackages;
+}
+async function getCommitFileList(workspaceRoot, from, to) {
+	const map = /* @__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");
+		let currentSha = null;
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (trimmedLine === "") {
+				currentSha = null;
+				continue;
+			}
+			if (currentSha === null) {
+				currentSha = trimmedLine;
+				map.set(currentSha, []);
+				continue;
+			}
+			map.get(currentSha).push(trimmedLine);
+		}
+		return map;
+	} catch {
+		return null;
 	}
-	return `${newMajor}.${newMinor}.${newPatch}`;
 }
 /**
-* Create a version update object
+* 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 createVersionUpdate(pkg, bump, hasDirectChanges) {
-	const newVersion = getNextVersion(pkg.version, bump);
-	return {
-		package: pkg,
-		currentVersion: pkg.version,
-		newVersion,
-		bumpType: bump,
-		hasDirectChanges
-	};
+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 false;
 }
 /**
-* Infer version updates from package commits with optional interactive overrides
+* Check if a commit is a "global" commit (doesn't touch any package folder).
+* @param files - Array of files changed in the commit
+* @param packagePaths - Set of normalized package paths
+* @param workspaceRoot - The workspace root
+* @returns true if this is a global commit
+*/
+function isGlobalCommit(files, packagePaths, workspaceRoot) {
+	if (!files || files.length === 0) return false;
+	return !files.some((file) => fileMatchesPackageFolder(file, packagePaths, workspaceRoot));
+}
+/**
+* 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.
 *
-* @returns Version updates for packages with changes
+* @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 inferVersionUpdates({ workspacePackages, packageCommits, allCommits, workspaceRoot, showPrompt, globalCommitMode }) {
-	const versionUpdates = [];
-	for (const [pkgName, pkgCommits] of packageCommits) {
-		if (pkgCommits.length === 0) continue;
-		const pkg = workspacePackages.find((p) => p.name === pkgName);
-		if (!pkg) continue;
-		const bump = determineHighestBump(combineWithGlobalCommits(workspaceRoot, pkgCommits, allCommits, globalCommitMode));
-		if (bump === "none") {
-			logger.info(`No version bump needed for package ${pkg.name}`);
-			continue;
-		}
-		let newVersion = getNextVersion(pkg.version, bump);
-		if (!isCI && showPrompt) newVersion = await promptVersionOverride(pkg, workspaceRoot, pkg.version, newVersion, bump);
-		versionUpdates.push({
-			package: pkg,
-			currentVersion: pkg.version,
-			newVersion,
-			bumpType: bump,
-			hasDirectChanges: true
-		});
+async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPackages, mode) {
+	const result = /* @__PURE__ */ new Map();
+	if (!mode) {
+		logger.verbose("Global commits mode disabled");
+		return result;
 	}
-	return versionUpdates;
-}
-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}`;
+	logger.verbose(`Computing global commits per-package (mode: ${farver.cyan(mode)})`);
+	let oldestCommit = null;
+	let newestCommit = null;
+	for (const commits of packageCommits.values()) if (commits.length > 0) {
+		if (!newestCommit) newestCommit = commits[0].shortHash;
+		oldestCommit = commits[commits.length - 1].shortHash;
+	}
+	if (!oldestCommit || !newestCommit) {
+		logger.verbose("No commits found across packages");
+		return result;
+	}
+	logger.verbose("Fetching files for commits range", `${farver.cyan(oldestCommit)}..${farver.cyan(newestCommit)}`);
+	const commitFilesMap = await getCommitFileList(workspaceRoot, oldestCommit, newestCommit);
+	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 globalCommitsForPackage = [];
+		logger.verbose("Filtering global commits for package", `${farver.bold(pkgName)} from ${farver.cyan(commits.length)} commits`);
+		for (const commit of commits) if (isGlobalCommit(commitFilesMap.get(commit.shortHash), packagePaths, workspaceRoot)) globalCommitsForPackage.push(commit);
+		logger.verbose("Package global commits found", `${farver.bold(pkgName)}: ${farver.cyan(globalCommitsForPackage.length)} global commits`);
+		if (mode === "all") result.set(pkgName, globalCommitsForPackage);
+		else if (mode === "dependencies") {
+			const dependencyCommits = [];
+			const dependencyFiles = [
+				"package.json",
+				"pnpm-lock.yaml",
+				"pnpm-workspace.yaml",
+				"yarn.lock",
+				"package-lock.json"
+			];
+			for (const commit of globalCommitsForPackage) {
+				const files = commitFilesMap.get(commit.shortHash);
+				if (!files) continue;
+				if (files.some((file) => {
+					const normalizedFile = file.startsWith("./") ? file.slice(2) : file;
+					return dependencyFiles.includes(normalizedFile);
+				})) {
+					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);
 		}
 	}
-	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+	return result;
 }
-/**
-* 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);
+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";
 	}
-	return updates;
 }
 
 //#endregion
-//#region src/package.ts
+//#region src/versioning/package.ts
 /**
 * Build a dependency graph from workspace packages
 *
@@ -888,29 +725,326 @@ function createDependentUpdates(graph, workspacePackages, 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) {
-		if (directUpdateMap.has(pkgName)) continue;
+		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));
 	}
 	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}`;
+}
 /**
-* Update all package.json files with new versions and dependency updates
-*
-* Updates are performed in parallel for better performance.
-*
-* @param updates - Version updates to apply
+* Create a version update object
 */
-async function updateAllPackageJsonFiles(updates) {
-	await Promise.all(updates.map(async (update) => {
-		const depUpdates = getDependencyUpdates(update.package, updates);
-		await updatePackageJson(update.package, update.newVersion, depUpdates);
-	}));
+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, b), 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;
+}
+/**
+* Calculate version updates for packages based on their commits
+*/
+async function calculateVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage }) {
+	const versionUpdates = [];
+	const processedPackages = /* @__PURE__ */ new Set();
+	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) || [];
+		if (globalCommits.length > 0) logger.verbose(`  - Global commits for this package: ${globalCommits.length}`);
+		const allCommitsForPackage = [...pkgCommits, ...globalCommits];
+		const bump = determineHighestBump(allCommitsForPackage);
+		if (bump === "none") continue;
+		let newVersion = getNextVersion(pkg.version, bump);
+		if (!isCI && showPrompt) {
+			logger.section("📝 Commits affecting this package");
+			formatCommitsForDisplay(allCommitsForPackage).split("\n").forEach((line) => logger.item(line));
+			logger.emptyLine();
+			const selectedVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, newVersion);
+			if (selectedVersion === null) continue;
+			newVersion = selectedVersion;
+		}
+		logger.item(`Version update: ${pkg.version} → ${newVersion}`);
+		versionUpdates.push({
+			package: pkg,
+			currentVersion: pkg.version,
+			newVersion,
+			bumpType: bump,
+			hasDirectChanges: true
+		});
+	}
+	if (!isCI && showPrompt) for (const pkg of workspacePackages) {
+		if (processedPackages.has(pkg.name)) continue;
+		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 versionUpdates;
+}
+/**
+* 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 }) {
+	const directUpdates = await calculateVersionUpdates({
+		workspacePackages,
+		packageCommits,
+		workspaceRoot,
+		showPrompt,
+		globalCommitsPerPackage
+	});
+	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
+	};
+}
+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]) {
+			const oldVersion = packageJson.dependencies[depName];
+			if (oldVersion === "workspace:*") {
+				logger.verbose(`  - Skipping workspace:* dependency: ${depName}`);
+				continue;
+			}
+			packageJson.dependencies[depName] = `^${depVersion}`;
+			logger.verbose(`  - Updated dependency ${depName}: ${oldVersion} → ^${depVersion}`);
+		}
+		if (packageJson.devDependencies?.[depName]) {
+			const oldVersion = packageJson.devDependencies[depName];
+			if (oldVersion === "workspace:*") {
+				logger.verbose(`  - Skipping workspace:* devDependency: ${depName}`);
+				continue;
+			}
+			packageJson.devDependencies[depName] = `^${depVersion}`;
+			logger.verbose(`  - Updated devDependency ${depName}: ${oldVersion} → ^${depVersion}`);
+		}
+		if (packageJson.peerDependencies?.[depName]) {
+			const oldVersion = packageJson.peerDependencies[depName];
+			if (oldVersion === "workspace:*") {
+				logger.verbose(`  - Skipping workspace:* peerDependency: ${depName}`);
+				continue;
+			}
+			const majorVersion = depVersion.split(".")[0];
+			packageJson.peerDependencies[depName] = `>=${depVersion} <${Number(majorVersion) + 1}.0.0`;
+			logger.verbose(`  - Updated peerDependency ${depName}: ${oldVersion} → ^${depVersion}`);
+		}
+	}
+	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/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/workspace.ts
+//#region src/core/workspace.ts
 async function discoverWorkspacePackages(workspaceRoot, options) {
 	let workspaceOptions;
 	let explicitPackages;
@@ -992,105 +1126,153 @@ function shouldIncludePackage(pkg, options) {
 //#endregion
 //#region src/release.ts
 async function release(options) {
-	const normalizedOptions = normalizeSharedOptions(options);
-	normalizedOptions.dryRun ??= false;
-	normalizedOptions.branch ??= {};
-	normalizedOptions.branch.release ??= "release/next";
-	normalizedOptions.branch.default = await getDefaultBranch();
-	normalizedOptions.safeguards ??= true;
-	normalizedOptions.changelog ??= { enabled: true };
-	normalizedOptions.globalCommitMode ??= "dependencies";
-	globalOptions.dryRun = normalizedOptions.dryRun;
-	const workspaceRoot = normalizedOptions.workspaceRoot;
+	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.log("No packages found to release.");
+		logger.warn("No packages found to release");
 		return null;
 	}
+	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 packageCommits = await getWorkspacePackageCommits(workspaceRoot, workspacePackages);
-	const versionUpdates = await inferVersionUpdates({
+	const globalCommitsPerPackage = await getGlobalCommitsPerPackage(workspaceRoot, packageCommits, workspacePackages, normalizedOptions.globalCommitMode);
+	const { allUpdates, applyUpdates } = await calculateAndPrepareVersionUpdates({
 		workspacePackages,
 		packageCommits,
 		workspaceRoot,
 		showPrompt: options.prompts?.versions !== false,
-		allCommits: await getAllWorkspaceCommits(workspaceRoot),
-		globalCommitMode: options.globalCommitMode
+		globalCommitsPerPackage
 	});
-	if (versionUpdates.length === 0) logger.warn("No packages have changes requiring a release");
-	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, versionUpdates);
-	const currentBranch = await getCurrentBranch(workspaceRoot);
-	if (currentBranch !== normalizedOptions.branch.default) exitWithError(`Current branch is '${currentBranch}'. Please switch to the default branch '${normalizedOptions.branch.default}' before proceeding.`, `git checkout ${normalizedOptions.branch.default}`);
-	const existingPullRequest = await getExistingPullRequest({
+	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}`);
+	const prOps = await orchestrateReleasePullRequest({
+		workspaceRoot,
 		owner: normalizedOptions.owner,
 		repo: normalizedOptions.repo,
-		branch: normalizedOptions.branch.release,
-		githubToken: normalizedOptions.githubToken
+		githubToken: normalizedOptions.githubToken,
+		releaseBranch: normalizedOptions.branch.release,
+		defaultBranch: normalizedOptions.branch.default,
+		pullRequestTitle: options.pullRequest?.title,
+		pullRequestBody: options.pullRequest?.body
 	});
-	const prExists = !!existingPullRequest;
-	if (prExists) logger.log("Existing pull request found:", existingPullRequest.html_url);
-	else logger.log("No existing pull request found, will create new one");
-	const branchExists = await doesBranchExist(normalizedOptions.branch.release, workspaceRoot);
-	if (!branchExists) {
-		logger.log("Creating release branch:", normalizedOptions.branch.release);
-		await createBranch(normalizedOptions.branch.release, normalizedOptions.branch.default, workspaceRoot);
-	}
-	if (!await checkoutBranch(normalizedOptions.branch.release, workspaceRoot)) throw new Error(`Failed to checkout branch: ${normalizedOptions.branch.release}`);
-	if (branchExists) {
-		logger.log("Pulling latest changes from remote");
-		if (!await pullLatestChanges(normalizedOptions.branch.release, workspaceRoot)) logger.log("Warning: Failed to pull latest changes, continuing anyway");
-	}
-	logger.log("Rebasing release branch onto", normalizedOptions.branch.default);
-	await rebaseBranch(normalizedOptions.branch.default, workspaceRoot);
-	await updateAllPackageJsonFiles(allUpdates);
-	await updateChangelogs(versionUpdates, packageCommits, {
-		...options.changelog,
-		repository: options.changelog?.repository || {
-			owner: normalizedOptions.owner,
-			repo: normalizedOptions.repo
-		}
-	});
-	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
-	const isBranchAhead = await isBranchAheadOfRemote(normalizedOptions.branch.release, workspaceRoot);
-	if (!hasCommitted && !isBranchAhead) {
-		logger.log("No changes to commit and branch is in sync with remote");
-		await checkoutBranch(normalizedOptions.branch.default, workspaceRoot);
-		if (prExists) {
-			logger.log("No updates needed, PR is already up to date");
-			return {
-				updates: allUpdates,
-				prUrl: existingPullRequest.html_url,
-				created: false
-			};
-		} else {
-			logger.error("No changes to commit, and no existing PR. Nothing to do.");
-			return null;
-		}
+	await prOps.prepareBranch();
+	await applyUpdates();
+	if (!await prOps.commitAndPush(true)) if (prOps.doesReleasePRExist && prOps.existingPullRequest) {
+		logger.item("No updates needed, PR is already up to date");
+		return {
+			updates: allUpdates,
+			prUrl: prOps.existingPullRequest.html_url,
+			created: false
+		};
+	} else {
+		logger.error("No changes to commit, and no existing PR. Nothing to do.");
+		return null;
 	}
-	logger.log("Pushing changes to remote");
-	await pushBranch(normalizedOptions.branch.release, workspaceRoot, { forceWithLease: true });
-	const prTitle = existingPullRequest?.title || options.pullRequest?.title || "chore: update package versions";
-	const prBody = generatePullRequestBody(allUpdates, options.pullRequest?.body);
-	const pullRequest = await upsertPullRequest({
-		owner: normalizedOptions.owner,
-		repo: normalizedOptions.repo,
-		pullNumber: existingPullRequest?.number,
-		title: prTitle,
-		body: prBody,
-		head: normalizedOptions.branch.release,
-		base: normalizedOptions.branch.default,
-		githubToken: normalizedOptions.githubToken
-	});
-	logger.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
-	await checkoutBranch(normalizedOptions.branch.default, workspaceRoot);
+	const { pullRequest, created } = await prOps.createOrUpdatePullRequest(allUpdates);
+	await prOps.checkoutDefaultBranch();
 	if (pullRequest?.html_url) {
-		logger.info();
-		logger.info(`${farver.green("✓")} Pull request ${prExists ? "updated" : "created"}: ${farver.cyan(pullRequest.html_url)}`);
+		logger.section("🚀 Pull Request");
+		logger.success(`Pull request ${created ? "created" : "updated"}: ${pullRequest.html_url}`);
 	}
 	return {
 		updates: allUpdates,
 		prUrl: pullRequest?.html_url,
-		created: !prExists
+		created
+	};
+}
+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 {
+		...normalized,
+		branch: {
+			release: releaseBranch,
+			default: defaultBranch
+		},
+		safeguards: options.safeguards ?? true,
+		globalCommitMode: options.globalCommitMode ?? "dependencies",
+		pullRequest: options.pullRequest,
+		changelog: { enabled: options.changelog?.enabled ?? true }
+	};
+}
+async function orchestrateReleasePullRequest({ workspaceRoot, owner, repo, githubToken, 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 getExistingPullRequest({
+		owner,
+		repo,
+		branch: releaseBranch,
+		githubToken
+	});
+	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,
+		prepareBranch: async () => {
+			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.`);
+		},
+		commitAndPush: async (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");
+				await checkoutBranch(defaultBranch, workspaceRoot);
+				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;
+		},
+		createOrUpdatePullRequest: async (updates) => {
+			const prTitle = existingPullRequest?.title || pullRequestTitle || "chore: update package versions";
+			const prBody = pullRequestBody || generatePullRequestBody(updates);
+			const pullRequest = await upsertPullRequest({
+				owner,
+				repo,
+				pullNumber: existingPullRequest?.number,
+				title: prTitle,
+				body: prBody,
+				head: releaseBranch,
+				base: defaultBranch,
+				githubToken
+			});
+			logger.success(`${doesReleasePRExist ? "Updated" : "Created"} pull request: ${pullRequest?.html_url}`);
+			return {
+				pullRequest,
+				created: !doesReleasePRExist
+			};
+		},
+		checkoutDefaultBranch: async () => {
+			await checkoutBranch(defaultBranch, workspaceRoot);
+		}
 	};
 }