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

package/dist/index.d.mts

@@ -1,3 +1,13 @@
+//#region src/workspace.d.ts
+interface WorkspacePackage {
+  name: string;
+  version: string;
+  path: string;
+  packageJson: PackageJson;
+  workspaceDependencies: string[];
+  workspaceDevDependencies: string[];
+}
+//#endregion
 //#region src/types.d.ts
 type BumpKind = "none" | "patch" | "minor" | "major";
 interface PackageJson {
@@ -6,16 +16,9 @@ interface PackageJson {
   dependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
+  private?: boolean;
   [key: string]: unknown;
 }
-interface WorkspacePackage {
-  name: string;
-  version: string;
-  path: string;
-  packageJson: PackageJson;
-  workspaceDependencies: string[];
-  workspaceDevDependencies: string[];
-}
 interface FindWorkspacePackagesOptions {
   /**
    * Package names to exclude
@@ -99,6 +102,21 @@ interface ReleaseOptions {
    * GitHub token for authentication
    */
   githubToken: string;
+  pullRequest?: {
+    /**
+     * Title for the release pull request
+     */
+    title?: string;
+    /**
+     * Body for the release pull request
+     *
+     * If not provided, a default body will be generated.
+     *
+     * NOTE:
+     * You can use custom template expressions, see [h3js/rendu](https://github.com/h3js/rendu)
+     */
+    body?: string;
+  };
 }
 interface ReleaseResult {
   /**

package/dist/index.mjs

@@ -1,21 +1,16 @@
 import process from "node:process";
 import { getCommits } from "commit-parser";
-import createDebug from "debug";
 import farver from "farver";
 import { exec } from "tinyexec";
+import { dedent } from "@luxass/utils";
+import { Eta } from "eta";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import prompts from "prompts";
 
-//#region src/logger.ts
-function createDebugger(namespace) {
-	const debug$2 = createDebug(namespace);
-	if (debug$2.enabled) return debug$2;
-}
-
-//#endregion
 //#region src/utils.ts
 const globalOptions = { dryRun: false };
+const isCI = typeof process.env.CI === "string" && process.env.CI !== "" && process.env.CI.toLowerCase() !== "false";
 async function run(bin, args, opts = {}) {
 	return exec(bin, args, {
 		throwOnError: true,
@@ -33,7 +28,6 @@ const runIfNotDry = globalOptions.dryRun ? dryRun : run;
 
 //#endregion
 //#region src/commits.ts
-const debug$1 = createDebugger("ucdjs:release-scripts:commits");
 async function getLastPackageTag(packageName, workspaceRoot) {
 	const { stdout } = await run("git", ["tag", "--list"], { nodeOptions: {
 		cwd: workspaceRoot,
@@ -58,16 +52,31 @@ async function getPackageCommits(pkg, workspaceRoot) {
 		from: lastTag,
 		to: "HEAD"
 	});
-	debug$1?.(`Found ${allCommits.length} commits for ${pkg.name} since ${lastTag || "beginning"}`);
+	console.log(`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}`);
+	console.log(`${packageCommits.length} commits affect ${pkg.name}`);
 	return packageCommits;
 }
 async function analyzePackageCommits(pkg, workspaceRoot) {
 	return determineHighestBump(await getPackageCommits(pkg, workspaceRoot));
 }
+/**
+* Analyze commits for multiple packages to determine version bumps
+*
+* @param packages - Packages to analyze
+* @param workspaceRoot - Root directory of the workspace
+* @returns Map of package names to their bump types
+*/
+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 determineBumpType(commit) {
 	if (commit.isBreaking) return "major";
 	if (!commit.isConventional || !commit.type) return "none";
@@ -100,135 +109,11 @@ async function getCommitsTouchingPackage(from, to, packagePath, workspaceRoot) {
 		} });
 		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
 	} catch (error) {
-		debug$1?.(`Error getting commits touching package: ${error}`);
+		console.error(`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
 /**
@@ -407,34 +292,6 @@ async function pushBranch(branch, workspaceRoot, options) {
 	else if (options?.force) args.push("--force");
 	await run("git", args, { nodeOptions: { cwd: workspaceRoot } });
 }
-/**
-* Generate PR body from version updates
-* @param updates - Array of version updates to include in the PR body
-* @returns Formatted PR body as a string
-*/
-function generatePRBody(updates) {
-	const lines = [];
-	lines.push("## Packages");
-	lines.push("");
-	const directChanges = updates.filter((u) => u.hasDirectChanges);
-	const dependencyUpdates = updates.filter((u) => !u.hasDirectChanges);
-	if (directChanges.length > 0) {
-		lines.push("### Direct Changes");
-		lines.push("");
-		for (const update of directChanges) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (${update.bumpType})`);
-		lines.push("");
-	}
-	if (dependencyUpdates.length > 0) {
-		lines.push("### Dependency Updates");
-		lines.push("");
-		for (const update of dependencyUpdates) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (dependencies changed)`);
-		lines.push("");
-	}
-	lines.push("---");
-	lines.push("");
-	lines.push("This release PR was automatically generated.");
-	return lines.join("\n");
-}
 
 //#endregion
 //#region src/github.ts
@@ -502,26 +359,311 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 		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/version.ts
+function isValidSemver(version) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+}
+function validateSemver(version) {
+	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
+}
+/**
+* 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] = 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/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) {
+		packagesMap.set(pkg.name, pkg);
+		dependents.set(pkg.name, /* @__PURE__ */ new Set());
+	}
+	for (const pkg of packages) {
+		const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
+		for (const dep of allDeps) {
+			const depSet = dependents.get(dep);
+			if (depSet) depSet.add(pkg.name);
+		}
+	}
+	return {
+		packages: packagesMap,
+		dependents
+	};
+}
+/**
+* Get all packages affected by changes (including transitive dependents)
+*
+* Uses graph traversal to find all packages that need updates:
+* - Packages with direct changes
+* - All packages that depend on changed packages (transitively)
+*
+* @param graph - Dependency graph
+* @param changedPackages - Set of package names with direct changes
+* @returns Set of all package names that need updates
+*/
+function getAllAffectedPackages(graph, changedPackages) {
+	const affected = /* @__PURE__ */ new Set();
+	function visitDependents(pkgName) {
+		if (affected.has(pkgName)) return;
+		affected.add(pkgName);
+		const dependents = graph.dependents.get(pkgName);
+		if (dependents) for (const dependent of dependents) visitDependents(dependent);
+	}
+	for (const pkg of changedPackages) visitDependents(pkg);
+	return affected;
+}
+/**
+* Create version updates for all packages affected by dependency changes
+*
+* When a package is updated, all packages that depend on it should also be updated.
+* This function calculates which additional packages need patch bumps due to dependency changes.
+*
+* @param graph - Dependency graph
+* @param workspacePackages - All workspace packages
+* @param directUpdates - Packages with direct code changes
+* @returns All updates including dependent packages that need patch bumps
+*/
+function createDependentUpdates(graph, workspacePackages, directUpdates) {
+	const allUpdates = [...directUpdates];
+	const directUpdateMap = new Map(directUpdates.map((u) => [u.package.name, u]));
+	const affectedPackages = getAllAffectedPackages(graph, new Set(directUpdates.map((u) => u.package.name)));
+	for (const pkgName of affectedPackages) {
+		if (directUpdateMap.has(pkgName)) continue;
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) continue;
+		allUpdates.push(createVersionUpdate(pkg, "patch", false));
+	}
+	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/prompts.ts
-async function promptPackageSelection(packages) {
+/**
+* Get commits for a package grouped by conventional commit type
+*
+* @param pkg - The workspace package
+* @param workspaceRoot - Root directory of the workspace
+* @param limit - Maximum number of commits to return (default: 10)
+* @returns Commits grouped by type
+*/
+async function getCommitsForPackage(pkg, workspaceRoot, limit = 10) {
+	const limitedCommits = (await getPackageCommits(pkg, workspaceRoot)).slice(0, limit);
+	const grouped = {
+		feat: [],
+		fix: [],
+		perf: [],
+		chore: [],
+		docs: [],
+		style: [],
+		refactor: [],
+		test: [],
+		build: [],
+		ci: [],
+		revert: [],
+		other: []
+	};
+	for (const commit of limitedCommits) if (commit.type && commit.type in grouped) grouped[commit.type].push(commit);
+	else grouped.other.push(commit);
+	return grouped;
+}
+/**
+* Format grouped commits into a readable string
+*/
+function formatCommitGroups(grouped) {
+	const lines = [];
+	const typeLabels = {
+		feat: "Features",
+		fix: "Bug Fixes",
+		perf: "Performance",
+		chore: "Chores",
+		docs: "Documentation",
+		style: "Styling",
+		refactor: "Refactoring",
+		test: "Tests",
+		build: "Build",
+		ci: "CI",
+		revert: "Reverts",
+		other: "Other"
+	};
+	for (const type of [
+		"feat",
+		"fix",
+		"perf",
+		"refactor",
+		"test",
+		"docs",
+		"style",
+		"build",
+		"ci",
+		"chore",
+		"revert",
+		"other"
+	]) {
+		const commits = grouped[type];
+		if (commits.length > 0) {
+			lines.push(`\n${typeLabels[type]}:`);
+			for (const commit of commits) {
+				const scope = commit.scope ? `(${commit.scope})` : "";
+				const breaking = commit.isBreaking ? " ⚠️  BREAKING" : "";
+				lines.push(`  • ${commit.type}${scope}: ${commit.message}${breaking}`);
+			}
+		}
+	}
+	return lines.join("\n");
+}
+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 commitSummary = formatCommitGroups(await getCommitsForPackage(pkg, workspaceRoot));
+	if (commitSummary.trim()) console.log(`\nRecent changes in ${pkg.name}:${commitSummary}\n`);
 	const choices = [{
 		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
 		value: "suggested"
@@ -544,7 +686,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
 	}, {
@@ -560,18 +702,85 @@ async function promptVersionOverride(packageName, currentVersion, suggestedVersi
 	else if (response.choice === "custom") return response.customVersion;
 	else return calculateNewVersion(currentVersion, response.choice);
 }
-async function promptVersionOverrides(packages) {
+async function promptVersionOverrides(packages, workspaceRoot) {
 	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);
+	for (const item of packages) {
+		const newVersion = await promptVersionOverride(item.package, workspaceRoot, item.currentVersion, item.suggestedVersion, item.bumpType);
+		overrides.set(item.package.name, newVersion);
 	}
 	return overrides;
 }
 
 //#endregion
 //#region src/workspace.ts
-const debug = createDebugger("ucdjs:release-scripts:workspace");
+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,
+			included: options.packages
+		};
+		explicitPackages = options.packages;
+	} else {
+		workspaceOptions = options.packages;
+		if (options.packages.included) explicitPackages = options.packages.included;
+	}
+	const 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) throw new Error(`Packages not found in workspace: ${missing.join(", ")}`);
+	}
+	let packagesToAnalyze = workspacePackages;
+	const isPackagePromptEnabled = options.prompts?.packages !== false;
+	if (!isCI && isPackagePromptEnabled && !explicitPackages) {
+		const selectedNames = await selectPackagePrompt(workspacePackages);
+		packagesToAnalyze = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
+	}
+	return {
+		workspacePackages,
+		packagesToAnalyze
+	};
+}
+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: extractWorkspaceDependencies(rawProject.dependencies, allPackageNames),
+				workspaceDevDependencies: extractWorkspaceDependencies(rawProject.devDependencies, allPackageNames)
+			};
+		});
+		const packages = await Promise.all(promises);
+		if (excludedPackages.size > 0) console.info(`${farver.cyan("[info]:")} Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
+		return packages.filter((pkg) => pkg !== null);
+	} catch (err) {
+		console.error("Error discovering workspace packages:", err);
+		throw err;
+	}
+}
 function shouldIncludePackage(pkg, options) {
 	if (!options) return true;
 	if (options.excludePrivate && pkg.private) return false;
@@ -581,130 +790,45 @@ function shouldIncludePackage(pkg, options) {
 	if (options.excluded?.includes(pkg.name)) return false;
 	return true;
 }
-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}`);
-			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
-		});
-	}
-	return packages;
-}
 function extractWorkspaceDependencies(dependencies, workspacePackages) {
 	if (!dependencies) return [];
 	return Object.keys(dependencies).filter((dep) => {
 		return workspacePackages.has(dep);
 	});
 }
-function buildDependencyGraph(packages) {
-	const packagesMap = /* @__PURE__ */ new Map();
-	const dependents = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		packagesMap.set(pkg.name, pkg);
-		dependents.set(pkg.name, /* @__PURE__ */ new Set());
-	}
-	for (const pkg of packages) {
-		const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
-		for (const dep of allDeps) {
-			const depSet = dependents.get(dep);
-			if (depSet) depSet.add(pkg.name);
-		}
-	}
-	return {
-		packages: packagesMap,
-		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);
-		}
-	}
-	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 toUpdate) visit(pkg, 0);
-	result.sort((a, b) => a.level - b.level);
-	return result;
-}
 
 //#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)) {
+	if (safeguards && !await isWorkingDirectoryClean(workspaceRoot)) {
 		console.error("Working directory is not clean. Please commit or stash your changes before proceeding.");
 		return null;
 	}
-	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 { workspacePackages, packagesToAnalyze } = await discoverWorkspacePackages(workspaceRoot, options);
+	if (packagesToAnalyze.length === 0) {
+		console.log("No packages found to analyze for release.");
+		return null;
 	}
 	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);
+	let versionUpdates = [];
+	for (const [pkgName, bump] of changedPackages) {
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (pkg) versionUpdates.push(createVersionUpdate(pkg, bump, true));
+	}
 	const isVersionPromptEnabled = options.prompts?.versions !== false;
 	if (!isCI && isVersionPromptEnabled) {
 		const versionOverrides = await promptVersionOverrides(versionUpdates.map((u) => ({
-			name: u.package.name,
+			package: u.package,
 			currentVersion: u.currentVersion,
 			suggestedVersion: u.newVersion,
 			bumpType: u.bumpType
-		})));
+		})), workspaceRoot);
 		versionUpdates = versionUpdates.map((update) => {
 			const overriddenVersion = versionOverrides.get(update.package.name);
 			if (overriddenVersion && overriddenVersion !== update.newVersion) return {
@@ -714,7 +838,7 @@ async function release(options) {
 			return update;
 		});
 	}
-	const allUpdates = createDependentUpdates(getPackageUpdateOrder(buildDependencyGraph(workspacePackages), new Set(versionUpdates.map((u) => u.package.name))), versionUpdates);
+	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, versionUpdates);
 	const currentBranch = await getCurrentBranch(workspaceRoot);
 	const existingPullRequest = await getExistingPullRequest({
 		owner,
@@ -737,7 +861,7 @@ async function release(options) {
 	}
 	console.log("Rebasing release branch onto", currentBranch);
 	await rebaseBranch(currentBranch, workspaceRoot);
-	await updatePackageJsonFiles(allUpdates);
+	await updateAllPackageJsonFiles(allUpdates);
 	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
 	const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
 	if (!hasCommitted && !isBranchAhead) {
@@ -757,8 +881,8 @@ async function release(options) {
 	}
 	console.log("Pushing changes to remote");
 	await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
-	const prTitle = existingPullRequest?.title || "Release: Update package versions";
-	const prBody = generatePRBody(allUpdates);
+	const prTitle = existingPullRequest?.title || options.pullRequest?.title || "chore: update package versions";
+	const prBody = generatePullRequestBody(allUpdates, options.pullRequest?.body);
 	const pullRequest = await upsertPullRequest({
 		owner,
 		repo,
@@ -777,64 +901,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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",
@@ -19,15 +19,15 @@
     "dist"
   ],
   "dependencies": {
+    "@luxass/utils": "2.7.2",
     "commit-parser": "0.4.5",
-    "debug": "4.4.3",
+    "eta": "4.0.1",
     "farver": "1.0.0-beta.1",
     "prompts": "2.4.2",
     "tinyexec": "1.0.2"
   },
   "devDependencies": {
     "@luxass/eslint-config": "6.0.1",
-    "@types/debug": "4.1.12",
     "@types/node": "22.18.12",
     "@types/prompts": "2.4.9",
     "eslint": "9.39.1",