@ucdjs/release-scripts 0.0.0

package/README.md

@@ -0,0 +1,3 @@
+# @ucdjs/release-scripts
+
+This repository contains release and publish scripts for the UCDJS organization.

package/dist/index.d.mts

@@ -0,0 +1,121 @@
+//#region src/types.d.ts
+type BumpKind = "none" | "patch" | "minor" | "major";
+interface PackageJson {
+  name: string;
+  version: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+interface WorkspacePackage {
+  name: string;
+  version: string;
+  path: string;
+  packageJson: PackageJson;
+  workspaceDependencies: string[];
+  workspaceDevDependencies: string[];
+}
+interface FindWorkspacePackagesOptions {
+  /**
+   * Package names to exclude
+   */
+  excluded?: string[];
+  /**
+   * Only include these packages (if specified, all others are excluded)
+   */
+  included?: string[];
+  /**
+   * Whether to exclude private packages (default: false)
+   */
+  excludePrivate?: boolean;
+}
+interface VersionUpdate {
+  /**
+   * The package being updated
+   */
+  package: WorkspacePackage;
+  /**
+   * Current version
+   */
+  currentVersion: string;
+  /**
+   * New version to release
+   */
+  newVersion: string;
+  /**
+   * Type of version bump
+   */
+  bumpType: BumpKind;
+  /**
+   * Whether this package has direct changes (vs being updated due to dependency changes)
+   */
+  hasDirectChanges: boolean;
+}
+interface ReleaseOptions {
+  /**
+   * Repository identifier (e.g., "owner/repo")
+   */
+  repo: string;
+  /**
+   * Root directory of the workspace (defaults to process.cwd())
+   */
+  workspaceRoot?: string;
+  /**
+   * Specific packages to prepare for release.
+   * - true: discover all packages
+   * - FindWorkspacePackagesOptions: discover with filters
+   * - string[]: specific package names
+   */
+  packages?: true | FindWorkspacePackagesOptions | string[];
+  /**
+   * Branch name for the release PR (defaults to "release/next")
+   */
+  releaseBranch?: string;
+  /**
+   * Interactive prompt configuration
+   */
+  prompts?: {
+    /**
+     * Enable package selection prompt (defaults to true when not in CI)
+     */
+    packages?: boolean;
+    /**
+     * Enable version override prompt (defaults to true when not in CI)
+     */
+    versions?: boolean;
+  };
+  /**
+   * Whether to perform a dry run (no changes pushed or PR created)
+   * @default false
+   */
+  dryRun?: boolean;
+  /**
+   * Whether to enable safety safeguards (e.g., checking for clean working directory)
+   * @default true
+   */
+  safeguards?: boolean;
+  /**
+   * GitHub token for authentication
+   */
+  githubToken: string;
+}
+interface ReleaseResult {
+  /**
+   * Packages that will be updated
+   */
+  updates: VersionUpdate[];
+  /**
+   * URL of the created or updated PR
+   */
+  prUrl?: string;
+  /**
+   * Whether a new PR was created (vs updating existing)
+   */
+  created: boolean;
+}
+//#endregion
+//#region src/release.d.ts
+declare function release(options: ReleaseOptions): Promise<ReleaseResult | null>;
+//#endregion
+export { release };

package/dist/index.mjs

@@ -0,0 +1,817 @@
+import process from "node:process";
+import { getCommits } from "commit-parser";
+import createDebug from "debug";
+import farver from "farver";
+import { exec } from "tinyexec";
+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 };
+async function run(bin, args, opts = {}) {
+	return exec(bin, args, {
+		throwOnError: true,
+		...opts,
+		nodeOptions: {
+			stdio: "inherit",
+			...opts.nodeOptions
+		}
+	});
+}
+async function dryRun(bin, args, opts) {
+	return console.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
+}
+const runIfNotDry = globalOptions.dryRun ? dryRun : run;
+
+//#endregion
+//#region src/commits.ts
+const debug$1 = createDebugger("ucdjs:release-scripts:commits");
+async function getLastPackageTag(packageName, workspaceRoot) {
+	const { stdout } = await run("git", ["tag", "--list"], { nodeOptions: {
+		cwd: workspaceRoot,
+		stdio: "pipe"
+	} });
+	return stdout.split("\n").map((tag) => tag.trim()).filter(Boolean).reverse().find((tag) => tag.startsWith(`${packageName}@`));
+}
+function determineHighestBump(commits) {
+	if (commits.length === 0) return "none";
+	let highestBump = "none";
+	for (const commit of commits) {
+		const bump = determineBumpType(commit);
+		if (bump === "major") return "major";
+		if (bump === "minor") highestBump = "minor";
+		else if (bump === "patch" && highestBump === "none") highestBump = "patch";
+	}
+	return highestBump;
+}
+async function getPackageCommits(pkg, workspaceRoot) {
+	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
+	const allCommits = getCommits({
+		from: lastTag,
+		to: "HEAD"
+	});
+	debug$1?.(`Found ${allCommits.length} commits for ${pkg.name} since ${lastTag || "beginning"}`);
+	const touchedCommitHashes = await getCommitsTouchingPackage(lastTag || "HEAD", "HEAD", pkg.path, workspaceRoot);
+	const touchedSet = new Set(touchedCommitHashes);
+	const packageCommits = allCommits.filter((commit) => touchedSet.has(commit.shortHash));
+	debug$1?.(`${packageCommits.length} commits affect ${pkg.name}`);
+	return packageCommits;
+}
+async function analyzePackageCommits(pkg, workspaceRoot) {
+	return determineHighestBump(await getPackageCommits(pkg, workspaceRoot));
+}
+function determineBumpType(commit) {
+	if (commit.isBreaking) return "major";
+	if (!commit.isConventional || !commit.type) return "none";
+	switch (commit.type) {
+		case "feat": return "minor";
+		case "fix":
+		case "perf": return "patch";
+		case "docs":
+		case "style":
+		case "refactor":
+		case "test":
+		case "build":
+		case "ci":
+		case "chore":
+		case "revert": return "none";
+		default: return "none";
+	}
+}
+async function getCommitsTouchingPackage(from, to, packagePath, workspaceRoot) {
+	try {
+		const { stdout } = await run("git", [
+			"log",
+			"--pretty=format:%h",
+			from === "HEAD" ? "HEAD" : `${from}...${to}`,
+			"--",
+			packagePath
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	} catch (error) {
+		debug$1?.(`Error getting commits touching package: ${error}`);
+		return [];
+	}
+}
+
+//#endregion
+//#region src/validation.ts
+/**
+* Validation utilities for release scripts
+*/
+function isValidSemver(version) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+}
+function validateSemver(version) {
+	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
+}
+
+//#endregion
+//#region src/version.ts
+/**
+* Calculate the new version based on current version and bump type
+* Pure function - no side effects, easily testable
+*/
+function calculateNewVersion(currentVersion, bump) {
+	if (bump === "none") return currentVersion;
+	validateSemver(currentVersion);
+	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
+	const [, major, minor, patch, suffix] = match;
+	let newMajor = Number.parseInt(major, 10);
+	let newMinor = Number.parseInt(minor, 10);
+	let newPatch = Number.parseInt(patch, 10);
+	switch (bump) {
+		case "major":
+			newMajor += 1;
+			newMinor = 0;
+			newPatch = 0;
+			break;
+		case "minor":
+			newMinor += 1;
+			newPatch = 0;
+			break;
+		case "patch":
+			newPatch += 1;
+			break;
+	}
+	return `${newMajor}.${newMinor}.${newPatch}`;
+}
+/**
+* Create a version update object
+*/
+function createVersionUpdate(pkg, bump, hasDirectChanges) {
+	const newVersion = calculateNewVersion(pkg.version, bump);
+	return {
+		package: pkg,
+		currentVersion: pkg.version,
+		newVersion,
+		bumpType: bump,
+		hasDirectChanges
+	};
+}
+/**
+* Update a package.json file with new version and dependency versions
+*/
+async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
+	const packageJsonPath = join(pkg.path, "package.json");
+	const content = await readFile(packageJsonPath, "utf-8");
+	const packageJson = JSON.parse(content);
+	packageJson.version = newVersion;
+	for (const [depName, depVersion] of dependencyUpdates) {
+		if (packageJson.dependencies?.[depName]) {
+			if (packageJson.dependencies[depName] === "workspace:*") continue;
+			packageJson.dependencies[depName] = `^${depVersion}`;
+		}
+		if (packageJson.devDependencies?.[depName]) {
+			if (packageJson.devDependencies[depName] === "workspace:*") continue;
+			packageJson.devDependencies[depName] = `^${depVersion}`;
+		}
+		if (packageJson.peerDependencies?.[depName]) {
+			if (packageJson.peerDependencies[depName] === "workspace:*") continue;
+			packageJson.peerDependencies[depName] = `^${depVersion}`;
+		}
+	}
+	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+}
+/**
+* Get all dependency updates needed for a package
+*/
+function getDependencyUpdates(pkg, allUpdates) {
+	const updates = /* @__PURE__ */ new Map();
+	const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
+	for (const dep of allDeps) {
+		const update = allUpdates.find((u) => u.package.name === dep);
+		if (update) updates.set(dep, update.newVersion);
+	}
+	return updates;
+}
+
+//#endregion
+//#region src/dependencies.ts
+/**
+* Pure function: Determine which packages need updates due to dependency changes
+*
+* When a package is updated, all packages that depend on it should also be updated.
+* This function calculates which additional packages need patch bumps.
+*
+* @param updateOrder - Packages in topological order with their dependency levels
+* @param directUpdates - Packages with direct code changes
+* @returns All updates including dependent packages
+*/
+function createDependentUpdates(updateOrder, directUpdates) {
+	const allUpdates = [...directUpdates];
+	const updatedPackages = new Set(directUpdates.map((u) => u.package.name));
+	for (const { package: pkg } of updateOrder) {
+		if (updatedPackages.has(pkg.name)) continue;
+		if (hasUpdatedDependencies(pkg, updatedPackages)) {
+			allUpdates.push(createVersionUpdate(pkg, "patch", false));
+			updatedPackages.add(pkg.name);
+		}
+	}
+	return allUpdates;
+}
+/**
+* Pure function: Check if a package has any updated dependencies
+*/
+function hasUpdatedDependencies(pkg, updatedPackages) {
+	return [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies].some((dep) => updatedPackages.has(dep));
+}
+
+//#endregion
+//#region src/git.ts
+/**
+* Check if the working directory is clean (no uncommitted changes)
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<boolean>} A Promise resolving to true if clean, false otherwise
+*/
+async function isWorkingDirectoryClean(workspaceRoot) {
+	try {
+		if ((await run("git", ["status", "--porcelain"], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.trim() !== "") return false;
+		return true;
+	} catch (err) {
+		console.error("Error checking git status:", err);
+		return false;
+	}
+}
+/**
+* Check if a git branch exists locally
+* @param {string} branch - The branch name to check
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<boolean>} Promise resolving to true if branch exists, false otherwise
+*/
+async function doesBranchExist(branch, workspaceRoot) {
+	try {
+		await run("git", [
+			"rev-parse",
+			"--verify",
+			branch
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 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
+*/
+async function pullLatestChanges(branch, workspaceRoot) {
+	try {
+		await run("git", [
+			"pull",
+			"origin",
+			branch
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 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
+*/
+async function createBranch(branch, base, workspaceRoot) {
+	await runIfNotDry("git", [
+		"checkout",
+		"-b",
+		branch,
+		base
+	], { nodeOptions: { cwd: workspaceRoot } });
+}
+/**
+* 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 {
+		await run("git", ["checkout", branch], { nodeOptions: { cwd: workspaceRoot } });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Get the current branch name
+* @param workspaceRoot - The root directory of the workspace
+* @returns Promise resolving to the current branch name
+*/
+async function getCurrentBranch(workspaceRoot) {
+	return (await run("git", [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	], { nodeOptions: {
+		cwd: workspaceRoot,
+		stdio: "pipe"
+	} })).stdout.trim();
+}
+/**
+* Rebase current branch onto another branch
+* @param ontoBranch - The target branch to rebase onto
+* @param workspaceRoot - The root directory of the workspace
+*/
+async function rebaseBranch(ontoBranch, workspaceRoot) {
+	await run("git", ["rebase", ontoBranch], { nodeOptions: { cwd: workspaceRoot } });
+}
+/**
+* Check if there are any changes to commit (staged or unstaged)
+* @param workspaceRoot - The root directory of the workspace
+* @returns Promise resolving to true if there are changes, false otherwise
+*/
+async function hasChangesToCommit(workspaceRoot) {
+	return (await run("git", ["status", "--porcelain"], { nodeOptions: {
+		cwd: workspaceRoot,
+		stdio: "pipe"
+	} })).stdout.trim() !== "";
+}
+/**
+* Commit changes with a message
+* @param message - The commit message
+* @param workspaceRoot - The root directory of the workspace
+* @returns Promise resolving to true if commit was made, false if there were no changes
+*/
+async function commitChanges(message, workspaceRoot) {
+	await run("git", ["add", "."], { nodeOptions: { cwd: workspaceRoot } });
+	if (!await hasChangesToCommit(workspaceRoot)) return false;
+	await run("git", [
+		"commit",
+		"-m",
+		message
+	], { nodeOptions: { cwd: workspaceRoot } });
+	return true;
+}
+/**
+* Push branch to remote
+* @param branch - The branch name to push
+* @param workspaceRoot - The root directory of the workspace
+* @param options - Push options
+* @param options.force - Force push (overwrite remote)
+* @param options.forceWithLease - Force push with safety check (won't overwrite unexpected changes)
+*/
+async function pushBranch(branch, workspaceRoot, options) {
+	const args = [
+		"push",
+		"origin",
+		branch
+	];
+	if (options?.forceWithLease) args.push("--force-with-lease");
+	else if (options?.force) args.push("--force");
+	await run("git", args, { nodeOptions: { cwd: workspaceRoot } });
+}
+/**
+* Generate PR body from version updates
+* @param updates - Array of version updates to include in the PR body
+* @returns Formatted PR body as a string
+*/
+function generatePRBody(updates) {
+	const lines = [];
+	lines.push("## Packages");
+	lines.push("");
+	const directChanges = updates.filter((u) => u.hasDirectChanges);
+	const dependencyUpdates = updates.filter((u) => !u.hasDirectChanges);
+	if (directChanges.length > 0) {
+		lines.push("### Direct Changes");
+		lines.push("");
+		for (const update of directChanges) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (${update.bumpType})`);
+		lines.push("");
+	}
+	if (dependencyUpdates.length > 0) {
+		lines.push("### Dependency Updates");
+		lines.push("");
+		for (const update of dependencyUpdates) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (dependencies changed)`);
+		lines.push("");
+	}
+	lines.push("---");
+	lines.push("");
+	lines.push("This release PR was automatically generated.");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/github.ts
+async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
+	try {
+		const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch}`, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			Authorization: `token ${githubToken}`
+		} });
+		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
+		const pulls = await res.json();
+		if (pulls == null || !Array.isArray(pulls) || pulls.length === 0) return null;
+		const firstPullRequest = pulls[0];
+		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
+		const pullRequest = {
+			number: firstPullRequest.number,
+			title: firstPullRequest.title,
+			body: firstPullRequest.body,
+			draft: firstPullRequest.draft,
+			html_url: firstPullRequest.html_url
+		};
+		console.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
+		return pullRequest;
+	} catch (err) {
+		console.error("Error fetching pull request:", err);
+		return null;
+	}
+}
+async function upsertPullRequest({ owner, repo, title, body, head, base, pullNumber, githubToken }) {
+	try {
+		const isUpdate = pullNumber != null;
+		const url = isUpdate ? `https://api.github.com/repos/${owner}/${repo}/pulls/${pullNumber}` : `https://api.github.com/repos/${owner}/${repo}/pulls`;
+		const method = isUpdate ? "PATCH" : "POST";
+		const requestBody = isUpdate ? {
+			title,
+			body
+		} : {
+			title,
+			body,
+			head,
+			base
+		};
+		const res = await fetch(url, {
+			method,
+			headers: {
+				Accept: "application/vnd.github.v3+json",
+				Authorization: `token ${githubToken}`
+			},
+			body: JSON.stringify(requestBody)
+		});
+		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
+		const pr = await res.json();
+		if (typeof pr !== "object" || pr === null || !("number" in pr) || typeof pr.number !== "number" || !("title" in pr) || typeof pr.title !== "string" || !("body" in pr) || typeof pr.body !== "string" || !("draft" in pr) || typeof pr.draft !== "boolean" || !("html_url" in pr) || typeof pr.html_url !== "string") throw new TypeError("Pull request data validation failed");
+		const action = isUpdate ? "Updated" : "Created";
+		console.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
+		return {
+			number: pr.number,
+			title: pr.title,
+			body: pr.body,
+			draft: pr.draft,
+			html_url: pr.html_url
+		};
+	} catch (err) {
+		console.error(`Error upserting pull request:`, err);
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/prompts.ts
+async function promptPackageSelection(packages) {
+	const response = await prompts({
+		type: "multiselect",
+		name: "selectedPackages",
+		message: "Select packages to release",
+		choices: packages.map((pkg) => ({
+			title: `${pkg.name} (${pkg.version})`,
+			value: pkg.name,
+			selected: true
+		})),
+		min: 1,
+		hint: "Space to select/deselect. Return to submit."
+	});
+	if (!response.selectedPackages || response.selectedPackages.length === 0) throw new Error("No packages selected");
+	return response.selectedPackages;
+}
+async function promptVersionOverride(packageName, currentVersion, suggestedVersion, suggestedBumpType) {
+	const choices = [{
+		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
+		value: "suggested"
+	}];
+	for (const bumpType of [
+		"patch",
+		"minor",
+		"major"
+	]) if (bumpType !== suggestedBumpType) {
+		const version = calculateNewVersion(currentVersion, bumpType);
+		choices.push({
+			title: `${bumpType}: ${version}`,
+			value: bumpType
+		});
+	}
+	choices.push({
+		title: "Custom version",
+		value: "custom"
+	});
+	const response = await prompts([{
+		type: "select",
+		name: "choice",
+		message: `${packageName} (${currentVersion}):`,
+		choices,
+		initial: 0
+	}, {
+		type: (prev) => prev === "custom" ? "text" : null,
+		name: "customVersion",
+		message: "Enter custom version:",
+		initial: suggestedVersion,
+		validate: (value) => {
+			return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(value) || "Invalid semver version (e.g., 1.0.0)";
+		}
+	}]);
+	if (response.choice === "suggested") return suggestedVersion;
+	else if (response.choice === "custom") return response.customVersion;
+	else return calculateNewVersion(currentVersion, response.choice);
+}
+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;
+}
+
+//#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;
+	}
+	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)) {
+		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 changedPackages = await analyzeCommits(packagesToAnalyze, workspaceRoot);
+	if (changedPackages.size === 0) throw new Error("No packages have changes requiring a release");
+	let versionUpdates = calculateVersions(workspacePackages, changedPackages);
+	const isVersionPromptEnabled = options.prompts?.versions !== false;
+	if (!isCI && isVersionPromptEnabled) {
+		const versionOverrides = await promptVersionOverrides(versionUpdates.map((u) => ({
+			name: u.package.name,
+			currentVersion: u.currentVersion,
+			suggestedVersion: u.newVersion,
+			bumpType: u.bumpType
+		})));
+		versionUpdates = versionUpdates.map((update) => {
+			const overriddenVersion = versionOverrides.get(update.package.name);
+			if (overriddenVersion && overriddenVersion !== update.newVersion) return {
+				...update,
+				newVersion: overriddenVersion
+			};
+			return update;
+		});
+	}
+	const allUpdates = createDependentUpdates(getPackageUpdateOrder(buildDependencyGraph(workspacePackages), new Set(versionUpdates.map((u) => u.package.name))), versionUpdates);
+	const currentBranch = await getCurrentBranch(workspaceRoot);
+	const existingPullRequest = await getExistingPullRequest({
+		owner,
+		repo,
+		branch: releaseBranch,
+		githubToken
+	});
+	const prExists = !!existingPullRequest;
+	if (prExists) console.log("Existing pull request found:", existingPullRequest.html_url);
+	else console.log("No existing pull request found, will create new one");
+	const branchExists = await doesBranchExist(releaseBranch, workspaceRoot);
+	if (!branchExists) {
+		console.log("Creating release branch:", releaseBranch);
+		await createBranch(releaseBranch, currentBranch, workspaceRoot);
+	}
+	if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
+	if (branchExists) {
+		console.log("Pulling latest changes from remote");
+		if (!await pullLatestChanges(releaseBranch, workspaceRoot)) console.log("Warning: Failed to pull latest changes, continuing anyway");
+	}
+	console.log("Rebasing release branch onto", currentBranch);
+	await rebaseBranch(currentBranch, workspaceRoot);
+	await updatePackageJsonFiles(allUpdates);
+	if (!await commitChanges("chore: update release versions", workspaceRoot)) {
+		console.log("No changes to commit");
+		await checkoutBranch(currentBranch, workspaceRoot);
+		if (prExists) {
+			console.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.");
+			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);
+	const pullRequest = await upsertPullRequest({
+		owner,
+		repo,
+		pullNumber: existingPullRequest?.number,
+		title: prTitle,
+		body: prBody,
+		head: releaseBranch,
+		base: currentBranch,
+		githubToken
+	});
+	console.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
+	await checkoutBranch(currentBranch, workspaceRoot);
+	return {
+		updates: allUpdates,
+		prUrl: pullRequest?.html_url,
+		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

@@ -0,0 +1,46 @@
+{
+  "name": "@ucdjs/release-scripts",
+  "version": "0.0.0",
+  "description": "@ucdjs release scripts",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ucdjs/release-scripts.git"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commit-parser": "0.4.5",
+    "debug": "4.4.3",
+    "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",
+    "tsdown": "0.16.0",
+    "typescript": "5.9.3",
+    "vitest": "4.0.4"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit"
+  }
+}