@ucdjs/release-scripts 0.1.0-beta.5 → 0.1.0-beta.6

package/dist/index.d.mts

@@ -10,6 +10,45 @@ interface WorkspacePackage {
 //#endregion
 //#region src/types.d.ts
 type BumpKind = "none" | "patch" | "minor" | "major";
+interface SharedOptions {
+  /**
+   * 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[];
+  /**
+   * Whether to enable verbose logging
+   * @default false
+   */
+  verbose?: boolean;
+  /**
+   * GitHub token for authentication
+   */
+  githubToken: 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;
+  };
+}
 interface PackageJson {
   name: string;
   version: string;
@@ -23,11 +62,11 @@ interface FindWorkspacePackagesOptions {
   /**
    * Package names to exclude
    */
-  excluded?: string[];
+  exclude?: string[];
   /**
    * Only include these packages (if specified, all others are excluded)
    */
-  included?: string[];
+  include?: string[];
   /**
    * Whether to exclude private packages (default: false)
    */
@@ -55,39 +94,17 @@ interface VersionUpdate {
    */
   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[];
+//#endregion
+//#region src/publish.d.ts
+interface PublishOptions extends SharedOptions {}
+declare function publish(_options: PublishOptions): void;
+//#endregion
+//#region src/release.d.ts
+interface ReleaseOptions extends SharedOptions {
   /**
    * 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
@@ -99,9 +116,8 @@ interface ReleaseOptions {
    */
   safeguards?: boolean;
   /**
-   * GitHub token for authentication
+   * Pull request configuration
    */
-  githubToken: string;
   pullRequest?: {
     /**
      * Title for the release pull request
@@ -132,8 +148,6 @@ interface ReleaseResult {
    */
   created: boolean;
 }
-//#endregion
-//#region src/release.d.ts
 declare function release(options: ReleaseOptions): Promise<ReleaseResult | null>;
 //#endregion
-export { release };
+export { type PublishOptions, type ReleaseOptions, type ReleaseResult, publish, release };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { t as Eta } from "./eta-Boh7yPZi.mjs";
-import process from "node:process";
 import { getCommits } from "commit-parser";
+import process from "node:process";
 import farver from "farver";
 import { exec } from "tinyexec";
 import { dedent } from "@luxass/utils";
@@ -8,9 +8,34 @@ import { join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 import prompts from "prompts";
 
+//#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,
@@ -22,18 +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, 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 (!repo || !repo.trim() || !repo.includes("/")) exitWithError("Repository (repo) is required", "Specify the repository in 'owner/repo' format (e.g., 'octocat/hello-world')");
+	const [owner, name] = options.repo.split("/");
+	if (!owner || !name) exitWithError(`Invalid repo format: "${options.repo}"`, "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
 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";
@@ -46,35 +102,42 @@ 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
 	});
-	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));
-	console.log(`${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));
-}
-/**
-* 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) {
+async function getWorkspacePackageCommits(workspaceRoot, packages) {
 	const changedPackages = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const bump = await analyzePackageCommits(pkg, workspaceRoot);
-		if (bump !== "none") changedPackages.set(pkg.name, bump);
-	}
+	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) {
@@ -95,24 +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) {
-		console.error(`Error getting commits touching package: ${error}`);
-		return [];
-	}
-}
 
 //#endregion
 //#region src/git.ts
@@ -129,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;
 	}
 }
@@ -313,10 +358,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;
 	}
 }
@@ -346,7 +391,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,
@@ -355,7 +400,7 @@ 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;
 	}
 }
@@ -392,6 +437,65 @@ function generatePullRequestBody(updates, body) {
 	})) });
 }
 
+//#endregion
+//#region src/prompts.ts
+async function selectPackagePrompt(packages) {
+	const response = await prompts({
+		type: "multiselect",
+		name: "selectedPackages",
+		message: "Select packages to release",
+		choices: packages.map((pkg) => ({
+			title: `${pkg.name} (${farver.bold(pkg.version)})`,
+			value: pkg.name,
+			selected: true
+		})),
+		min: 1,
+		hint: "Space to select/deselect. Return to submit.",
+		instructions: false
+	});
+	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
+	return response.selectedPackages;
+}
+async function promptVersionOverride(pkg, workspaceRoot, currentVersion, suggestedVersion, suggestedBumpType) {
+	const choices = [{
+		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
+		value: "suggested"
+	}];
+	for (const bumpType of [
+		"patch",
+		"minor",
+		"major"
+	]) if (bumpType !== suggestedBumpType) {
+		const version = getNextVersion(currentVersion, bumpType);
+		choices.push({
+			title: `${bumpType}: ${version}`,
+			value: bumpType
+		});
+	}
+	choices.push({
+		title: "Custom version",
+		value: "custom"
+	});
+	const response = await prompts([{
+		type: "select",
+		name: "choice",
+		message: `${pkg.name} (${currentVersion}):`,
+		choices,
+		initial: 0
+	}, {
+		type: (prev) => prev === "custom" ? "text" : null,
+		name: "customVersion",
+		message: "Enter custom version:",
+		initial: suggestedVersion,
+		validate: (value) => {
+			return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(value) || "Invalid semver version (e.g., 1.0.0)";
+		}
+	}]);
+	if (response.choice === "suggested") return suggestedVersion;
+	else if (response.choice === "custom") return response.customVersion;
+	else return getNextVersion(currentVersion, response.choice);
+}
+
 //#endregion
 //#region src/version.ts
 function isValidSemver(version) {
@@ -400,11 +504,7 @@ function isValidSemver(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) {
+function getNextVersion(currentVersion, bump) {
 	if (bump === "none") return currentVersion;
 	validateSemver(currentVersion);
 	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
@@ -433,7 +533,7 @@ function calculateNewVersion(currentVersion, bump) {
 * Create a version update object
 */
 function createVersionUpdate(pkg, bump, hasDirectChanges) {
-	const newVersion = calculateNewVersion(pkg.version, bump);
+	const newVersion = getNextVersion(pkg.version, bump);
 	return {
 		package: pkg,
 		currentVersion: pkg.version,
@@ -443,8 +543,37 @@ function createVersionUpdate(pkg, bump, hasDirectChanges) {
 	};
 }
 /**
-* Update a package.json file with new version and dependency versions
+* 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;
+		}
+		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 versionUpdates;
+}
 async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
 	const packageJsonPath = join(pkg.path, "package.json");
 	const content = await readFile(packageJsonPath, "utf-8");
@@ -569,148 +698,6 @@ async function updateAllPackageJsonFiles(updates) {
 	}));
 }
 
-//#endregion
-//#region src/prompts.ts
-/**
-* 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} (${farver.bold(pkg.version)})`,
-			value: pkg.name,
-			selected: true
-		})),
-		min: 1,
-		hint: "Space to select/deselect. Return to submit.",
-		instructions: false
-	});
-	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
-	return response.selectedPackages;
-}
-async function promptVersionOverride(pkg, workspaceRoot, currentVersion, suggestedVersion, suggestedBumpType) {
-	const 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"
-	}];
-	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: `${pkg.name} (${currentVersion}):`,
-		choices,
-		initial: 0
-	}, {
-		type: (prev) => prev === "custom" ? "text" : null,
-		name: "customVersion",
-		message: "Enter custom version:",
-		initial: suggestedVersion,
-		validate: (value) => {
-			return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(value) || "Invalid semver version (e.g., 1.0.0)";
-		}
-	}]);
-	if (response.choice === "suggested") return suggestedVersion;
-	else if (response.choice === "custom") return response.customVersion;
-	else return calculateNewVersion(currentVersion, response.choice);
-}
-async function promptVersionOverrides(packages, workspaceRoot) {
-	const overrides = /* @__PURE__ */ new Map();
-	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
 async function discoverWorkspacePackages(workspaceRoot, options) {
@@ -720,29 +707,25 @@ async function discoverWorkspacePackages(workspaceRoot, options) {
 	else if (Array.isArray(options.packages)) {
 		workspaceOptions = {
 			excludePrivate: false,
-			included: options.packages
+			include: options.packages
 		};
 		explicitPackages = options.packages;
 	} else {
 		workspaceOptions = options.packages;
-		if (options.packages.included) explicitPackages = options.packages.included;
+		if (options.packages.include) explicitPackages = options.packages.include;
 	}
-	const workspacePackages = await findWorkspacePackages(workspaceRoot, workspaceOptions);
+	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) throw new Error(`Packages not found in workspace: ${missing.join(", ")}`);
+		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");
 	}
-	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));
+		workspacePackages = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
 	}
-	return {
-		workspacePackages,
-		packagesToAnalyze
-	};
+	return workspacePackages;
 }
 async function findWorkspacePackages(workspaceRoot, options) {
 	try {
@@ -769,131 +752,105 @@ async function findWorkspacePackages(workspaceRoot, options) {
 				version: rawProject.version,
 				path: rawProject.path,
 				packageJson,
-				workspaceDependencies: extractWorkspaceDependencies(rawProject.dependencies, allPackageNames),
-				workspaceDevDependencies: extractWorkspaceDependencies(rawProject.devDependencies, allPackageNames)
+				workspaceDependencies: Object.keys(rawProject.dependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				}),
+				workspaceDevDependencies: Object.keys(rawProject.devDependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				})
 			};
 		});
 		const packages = await Promise.all(promises);
-		if (excludedPackages.size > 0) console.info(`${farver.cyan("[info]:")} Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
+		if (excludedPackages.size > 0) logger.info(`Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
 		return packages.filter((pkg) => pkg !== null);
 	} catch (err) {
-		console.error("Error discovering workspace packages:", 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.included && options.included.length > 0) {
-		if (!options.included.includes(pkg.name)) return false;
+	if (options.include && options.include.length > 0) {
+		if (!options.include.includes(pkg.name)) return false;
 	}
-	if (options.excluded?.includes(pkg.name)) return false;
+	if (options.exclude?.includes(pkg.name)) return false;
 	return true;
 }
-function extractWorkspaceDependencies(dependencies, workspacePackages) {
-	if (!dependencies) return [];
-	return Object.keys(dependencies).filter((dep) => {
-		return workspacePackages.has(dep);
-	});
-}
 
 //#endregion
 //#region src/release.ts
 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 && !await isWorkingDirectoryClean(workspaceRoot)) {
-		console.error("Working directory is not clean. Please commit or stash your changes before proceeding.");
-		return null;
-	}
-	const { workspacePackages, packagesToAnalyze } = await discoverWorkspacePackages(workspaceRoot, options);
-	if (packagesToAnalyze.length === 0) {
-		console.log("No packages found to analyze for release.");
+	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 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 = [];
-	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) => ({
-			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 {
-				...update,
-				newVersion: overriddenVersion
-			};
-			return update;
-		});
-	}
+	const versionUpdates = await inferVersionUpdates(workspacePackages, await getWorkspacePackageCommits(workspaceRoot, workspacePackages), workspaceRoot, options.prompts?.versions !== false);
+	if (versionUpdates.length === 0) exitWithError("No packages have changes requiring a release", "Make sure you have commits since the last 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 updateAllPackageJsonFiles(allUpdates);
 	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
-	const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
+	const isBranchAhead = await isBranchAheadOfRemote(normalizedOptions.releaseBranch, workspaceRoot);
 	if (!hasCommitted && !isBranchAhead) {
-		console.log("No changes to commit and branch is in sync with remote");
+		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 });
+	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,
@@ -903,4 +860,4 @@ async function release(options) {
 }
 
 //#endregion
-export { release };
+export { publish, release };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.6",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",