@ucdjs/release-scripts 0.0.0 → 0.1.0-beta.10

package/dist/index.mjs

@@ -1,21 +1,41 @@
-import process from "node:process";
+import { t as Eta } from "./eta-Boh7yPZi.mjs";
 import { getCommits } from "commit-parser";
-import createDebug from "debug";
+import process from "node:process";
 import farver from "farver";
 import { exec } from "tinyexec";
-import { readFile, writeFile } from "node:fs/promises";
+import { dedent } from "@luxass/utils";
 import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
 import prompts from "prompts";
 
-//#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 };
+const globalOptions = {
+	dryRun: false,
+	verbose: false
+};
+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);
+	},
+	debug: (...args) => {
+		console.debug(farver.gray("[debug]:"), ...args);
+	},
+	warn: (...args) => {
+		console.warn(farver.yellow("[warn]:"), ...args);
+	},
+	error: (...args) => {
+		console.error(farver.red("[error]:"), ...args);
+	},
+	log: (...args) => {
+		if (!globalOptions.verbose) return;
+		console.log(...args);
+	}
+};
 async function run(bin, args, opts = {}) {
 	return exec(bin, args, {
 		throwOnError: true,
@@ -27,19 +47,49 @@ async function run(bin, args, opts = {}) {
 	});
 }
 async function dryRun(bin, args, opts) {
-	return console.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
+	return logger.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
 }
 const runIfNotDry = globalOptions.dryRun ? 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 = {
+		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("/");
+	if (!owner || !repo) exitWithError(`Invalid repo format: "${fullRepo}"`, "Expected format: \"owner/repo\" (e.g., \"octocat/hello-world\")");
+	return {
+		...rest,
+		packages,
+		prompts: prompts$1,
+		workspaceRoot,
+		githubToken,
+		owner,
+		repo,
+		verbose
+	};
+}
 
 //#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}@`));
+	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";
@@ -52,21 +102,43 @@ function determineHighestBump(commits) {
 	}
 	return highestBump;
 }
-async function getPackageCommits(pkg, workspaceRoot) {
+/**
+* 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"
+		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
 	});
-	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}`);
+	const packageCommits = allCommits.filter((commit) => touchedSet.has(commit));
+	logger.log(`${packageCommits.length} commits affect ${pkg.name}`);
 	return packageCommits;
 }
-async function analyzePackageCommits(pkg, workspaceRoot) {
-	return determineHighestBump(await getPackageCommits(pkg, workspaceRoot));
+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;
 }
 function determineBumpType(commit) {
 	if (commit.isBreaking) return "major";
@@ -86,148 +158,6 @@ function determineBumpType(commit) {
 		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));
-}
 
 //#endregion
 //#region src/git.ts
@@ -244,7 +174,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;
 	}
 }
@@ -297,12 +227,20 @@ async function pullLatestChanges(branch, workspaceRoot) {
 * @param workspaceRoot - The root directory of the workspace
 */
 async function createBranch(branch, base, workspaceRoot) {
-	await runIfNotDry("git", [
-		"checkout",
-		"-b",
-		branch,
-		base
-	], { nodeOptions: { cwd: workspaceRoot } });
+	try {
+		logger.info(`Creating branch: ${farver.green(branch)} from ${farver.cyan(base)}`);
+		await runIfNotDry("git", [
+			"checkout",
+			"-b",
+			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`);
+	}
 }
 /**
 * Checkout a git branch
@@ -312,7 +250,11 @@ async function createBranch(branch, base, workspaceRoot) {
 */
 async function checkoutBranch(branch, workspaceRoot) {
 	try {
-		await run("git", ["checkout", branch], { nodeOptions: { cwd: workspaceRoot } });
+		logger.info(`Switching to branch: ${farver.green(branch)}`);
+		await run("git", ["checkout", branch], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
 		return true;
 	} catch {
 		return false;
@@ -339,7 +281,36 @@ async function getCurrentBranch(workspaceRoot) {
 * @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 run("git", ["rebase", ontoBranch], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+	} 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", [
+			"rev-list",
+			`origin/${branch}..${branch}`,
+			"--count"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return Number.parseInt(result.stdout.trim(), 10) > 0;
+	} catch {
+		return true;
+	}
 }
 /**
 * Check if there are any changes to commit (staged or unstaged)
@@ -359,14 +330,25 @@ async function hasChangesToCommit(workspaceRoot) {
 * @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 hasChangesToCommit(workspaceRoot)) return false;
+		logger.info(`Committing changes: ${farver.dim(message)}`);
+		await run("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
@@ -377,48 +359,33 @@ async function commitChanges(message, workspaceRoot) {
 * @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");
+	try {
+		const args = [
+			"push",
+			"origin",
+			branch
+		];
+		if (options?.forceWithLease) {
+			args.push("--force-with-lease");
+			logger.info(`Pushing branch: ${farver.green(branch)} ${farver.dim("(with lease)")}`);
+		} else if (options?.force) {
+			args.push("--force");
+			logger.info(`Force pushing branch: ${farver.green(branch)}`);
+		} else logger.info(`Pushing branch: ${farver.green(branch)}`);
+		await run("git", args, { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+	} catch {
+		exitWithError(`Failed to push branch: ${branch}`, `Make sure you have permission to push to the remote repository`);
+	}
 }
 
 //#endregion
 //#region src/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})`);
 		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}`
@@ -435,10 +402,10 @@ async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
 			draft: firstPullRequest.draft,
 			html_url: firstPullRequest.html_url
 		};
-		console.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
+		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
 		return pullRequest;
 	} catch (err) {
-		console.error("Error fetching pull request:", err);
+		logger.error("Error fetching pull request:", err);
 		return null;
 	}
 }
@@ -456,6 +423,7 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			head,
 			base
 		};
+		logger.debug(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${url})`);
 		const res = await fetch(url, {
 			method,
 			headers: {
@@ -468,7 +436,7 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 		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,
@@ -477,30 +445,63 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			html_url: pr.html_url
 		};
 	} catch (err) {
-		console.error(`Error upserting pull request:`, err);
+		logger.error(`Error upserting pull request:`, err);
 		throw err;
 	}
 }
+const defaultTemplate = 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) : defaultTemplate;
+	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) {
+async function selectPackagePrompt(packages) {
 	const response = await prompts({
 		type: "multiselect",
 		name: "selectedPackages",
 		message: "Select packages to release",
 		choices: packages.map((pkg) => ({
-			title: `${pkg.name} (${pkg.version})`,
+			title: `${pkg.name} (${farver.bold(pkg.version)})`,
 			value: pkg.name,
 			selected: true
 		})),
 		min: 1,
-		hint: "Space to select/deselect. Return to submit."
+		hint: "Space to select/deselect. Return to submit.",
+		instructions: false
 	});
-	if (!response.selectedPackages || response.selectedPackages.length === 0) throw new Error("No packages selected");
+	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
 	return response.selectedPackages;
 }
-async function promptVersionOverride(packageName, currentVersion, suggestedVersion, suggestedBumpType) {
+async function promptVersionOverride(pkg, workspaceRoot, currentVersion, suggestedVersion, suggestedBumpType) {
 	const choices = [{
 		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
 		value: "suggested"
@@ -510,7 +511,7 @@ async function promptVersionOverride(packageName, currentVersion, suggestedVersi
 		"minor",
 		"major"
 	]) if (bumpType !== suggestedBumpType) {
-		const version = calculateNewVersion(currentVersion, bumpType);
+		const version = getNextVersion(currentVersion, bumpType);
 		choices.push({
 			title: `${bumpType}: ${version}`,
 			value: bumpType
@@ -523,7 +524,7 @@ async function promptVersionOverride(packageName, currentVersion, suggestedVersi
 	const response = await prompts([{
 		type: "select",
 		name: "choice",
-		message: `${packageName} (${currentVersion}):`,
+		message: `${pkg.name} (${currentVersion}):`,
 		choices,
 		initial: 0
 	}, {
@@ -537,68 +538,134 @@ async function promptVersionOverride(packageName, currentVersion, suggestedVersi
 	}]);
 	if (response.choice === "suggested") return suggestedVersion;
 	else if (response.choice === "custom") return response.customVersion;
-	else return calculateNewVersion(currentVersion, response.choice);
-}
-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);
-	}
-	return overrides;
+	else return getNextVersion(currentVersion, response.choice);
 }
 
 //#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;
+//#region src/version.ts
+function isValidSemver(version) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+}
+function validateSemver(version) {
+	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
+}
+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;
 	}
-	if (options.excluded?.includes(pkg.name)) return false;
-	return true;
+	return `${newMajor}.${newMinor}.${newPatch}`;
 }
-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}`);
+/**
+* Create a version update object
+*/
+function createVersionUpdate(pkg, bump, hasDirectChanges) {
+	const newVersion = getNextVersion(pkg.version, bump);
+	return {
+		package: pkg,
+		currentVersion: pkg.version,
+		newVersion,
+		bumpType: bump,
+		hasDirectChanges
+	};
+}
+/**
+* Infer version updates from package commits with optional interactive overrides
+*
+* @param workspacePackages - All workspace packages
+* @param packageCommits - Map of package names to their commits
+* @param workspaceRoot - Root directory for prompts
+* @param showPrompt - Whether to show prompts for version overrides
+* @returns Version updates for packages with changes
+*/
+async function inferVersionUpdates(workspacePackages, packageCommits, workspaceRoot, showPrompt) {
+	const versionUpdates = [];
+	for (const [pkgName, commits] of packageCommits) {
+		if (commits.length === 0) continue;
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) continue;
+		const bump = determineHighestBump(commits);
+		if (bump === "none") {
+			logger.info(`No version bump needed for package ${pkg.name}`);
 			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
+		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
 		});
 	}
-	return packages;
+	return versionUpdates;
 }
-function extractWorkspaceDependencies(dependencies, workspacePackages) {
-	if (!dependencies) return [];
-	return Object.keys(dependencies).filter((dep) => {
-		return workspacePackages.has(dep);
-	});
+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;
 }
-function buildDependencyGraph(packages) {
+
+//#endregion
+//#region src/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) {
@@ -617,136 +684,218 @@ 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);
 	}
-	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;
-		}
-		result.push({
-			package: pkg,
-			level: maxDepLevel
-		});
+	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) {
+		if (directUpdateMap.has(pkgName)) continue;
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) continue;
+		allUpdates.push(createVersionUpdate(pkg, "patch", false));
 	}
-	for (const pkg of toUpdate) visit(pkg, 0);
-	result.sort((a, b) => a.level - b.level);
-	return result;
+	return allUpdates;
+}
+/**
+* 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
+*/
+async function updateAllPackageJsonFiles(updates) {
+	await Promise.all(updates.map(async (update) => {
+		const depUpdates = getDependencyUpdates(update.package, updates);
+		await updatePackageJson(update.package, update.newVersion, depUpdates);
+	}));
 }
 
 //#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/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
+	if (!isCI && isPackagePromptEnabled && !explicitPackages) {
+		const selectedNames = await selectPackagePrompt(workspacePackages);
+		workspacePackages = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
+	}
+	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 {
+				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);
+				})
 			};
-			return update;
 		});
+		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;
+	}
+	if (options.exclude?.includes(pkg.name)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/release.ts
+async function release(options) {
+	const normalizedOptions = normalizeSharedOptions(options);
+	normalizedOptions.dryRun ??= false;
+	normalizedOptions.releaseBranch ??= "release/next";
+	normalizedOptions.safeguards ??= true;
+	globalOptions.dryRun = normalizedOptions.dryRun;
+	const workspaceRoot = normalizedOptions.workspaceRoot;
+	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.");
+		return null;
 	}
-	const allUpdates = createDependentUpdates(getPackageUpdateOrder(buildDependencyGraph(workspacePackages), new Set(versionUpdates.map((u) => u.package.name))), versionUpdates);
+	const versionUpdates = await inferVersionUpdates(workspacePackages, await getWorkspacePackageCommits(workspaceRoot, workspacePackages), workspaceRoot, options.prompts?.versions !== false);
+	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);
 	const existingPullRequest = await getExistingPullRequest({
-		owner,
-		repo,
-		branch: releaseBranch,
-		githubToken
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		branch: normalizedOptions.releaseBranch,
+		githubToken: normalizedOptions.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 (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.releaseBranch, workspaceRoot);
 	if (!branchExists) {
-		console.log("Creating release branch:", releaseBranch);
-		await createBranch(releaseBranch, currentBranch, workspaceRoot);
+		logger.log("Creating release branch:", normalizedOptions.releaseBranch);
+		await createBranch(normalizedOptions.releaseBranch, currentBranch, workspaceRoot);
 	}
-	if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
+	if (!await checkoutBranch(normalizedOptions.releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${normalizedOptions.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");
+		logger.log("Pulling latest changes from remote");
+		if (!await pullLatestChanges(normalizedOptions.releaseBranch, workspaceRoot)) logger.log("Warning: Failed to pull latest changes, continuing anyway");
 	}
-	console.log("Rebasing release branch onto", currentBranch);
+	logger.log("Rebasing release branch onto", currentBranch);
 	await rebaseBranch(currentBranch, workspaceRoot);
-	await updatePackageJsonFiles(allUpdates);
-	if (!await commitChanges("chore: update release versions", workspaceRoot)) {
-		console.log("No changes to commit");
+	await updateAllPackageJsonFiles(allUpdates);
+	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
+	const isBranchAhead = await isBranchAheadOfRemote(normalizedOptions.releaseBranch, workspaceRoot);
+	if (!hasCommitted && !isBranchAhead) {
+		logger.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");
+			logger.log("No updates needed, PR is already up to date");
 			return {
 				updates: allUpdates,
 				prUrl: existingPullRequest.html_url,
 				created: false
 			};
 		} else {
-			console.error("No changes to commit, and no existing PR. Nothing to do.");
+			logger.error("No changes to commit, and no existing PR. Nothing to do.");
 			return null;
 		}
 	}
-	console.log("Pushing changes to remote");
-	await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
-	const prTitle = existingPullRequest?.title || "Release: Update package versions";
-	const prBody = generatePRBody(allUpdates);
+	logger.log("Pushing changes to remote");
+	await pushBranch(normalizedOptions.releaseBranch, 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,
-		repo,
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
 		pullNumber: existingPullRequest?.number,
 		title: prTitle,
 		body: prBody,
-		head: releaseBranch,
+		head: normalizedOptions.releaseBranch,
 		base: currentBranch,
-		githubToken
+		githubToken: normalizedOptions.githubToken
 	});
-	console.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
+	logger.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
 	await checkoutBranch(currentBranch, workspaceRoot);
 	return {
 		updates: allUpdates,
@@ -754,64 +903,6 @@ async function release(options) {
 		created: !prExists
 	};
 }
-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
-		};
-	}
-	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(", ")}`);
-		}
-		return {
-			workspacePackages,
-			packagesToAnalyze
-		};
-	}
-	workspacePackages = await findWorkspacePackages(workspaceRoot, options.packages);
-	packagesToAnalyze = workspacePackages;
-	return {
-		workspacePackages,
-		packagesToAnalyze
-	};
-}
-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;
-}
-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));
-	}
-	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 };