@ucdjs/release-scripts 0.1.0-beta.45 → 0.1.0-beta.47

package/dist/index.d.mts

@@ -90,6 +90,10 @@ interface PackageRelease {
    * Whether this package has direct changes (vs being updated due to dependency changes)
    */
   hasDirectChanges: boolean;
+  /**
+   * Why/how this release entry exists.
+   */
+  changeKind: "auto" | "manual" | "as-is" | "dependent";
 }
 //#endregion
 //#region src/types.d.ts

package/dist/index.mjs

@@ -8,8 +8,8 @@ import farver from "farver";
 import mri from "mri";
 import { exec } from "tinyexec";
 import { dedent } from "@luxass/utils";
+import semver, { compare, gt } from "semver";
 import prompts from "prompts";
-import { compare, gt } from "semver";
 
 //#region src/operations/changelog-format.ts
 function formatCommitLine({ commit, owner, repo, authors }) {
@@ -1003,42 +1003,38 @@ function parseChangelog(content) {
 //#endregion
 //#region src/operations/semver.ts
 function isValidSemver(version) {
-	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+	return semver.valid(version) != null;
 }
 function getNextVersion(currentVersion, bump) {
 	if (bump === "none") return currentVersion;
 	if (!isValidSemver(currentVersion)) throw new Error(`Cannot bump version for invalid semver: ${currentVersion}`);
-	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
-	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
-	const [, major, minor, patch] = match;
-	let newMajor = Number.parseInt(major, 10);
-	let newMinor = Number.parseInt(minor, 10);
-	let newPatch = Number.parseInt(patch, 10);
-	switch (bump) {
-		case "major":
-			newMajor += 1;
-			newMinor = 0;
-			newPatch = 0;
-			break;
-		case "minor":
-			newMinor += 1;
-			newPatch = 0;
-			break;
-		case "patch":
-			newPatch += 1;
-			break;
-	}
-	return `${newMajor}.${newMinor}.${newPatch}`;
+	const next = semver.inc(currentVersion, bump);
+	if (!next) throw new Error(`Failed to bump version ${currentVersion} with bump ${bump}`);
+	return next;
 }
 function calculateBumpType(oldVersion, newVersion) {
 	if (!isValidSemver(oldVersion) || !isValidSemver(newVersion)) throw new Error(`Cannot calculate bump type for invalid semver: ${oldVersion} or ${newVersion}`);
-	const oldParts = oldVersion.split(".").map(Number);
-	const newParts = newVersion.split(".").map(Number);
-	if (newParts[0] > oldParts[0]) return "major";
-	if (newParts[1] > oldParts[1]) return "minor";
-	if (newParts[2] > oldParts[2]) return "patch";
+	const diff = semver.diff(oldVersion, newVersion);
+	if (!diff) return "none";
+	if (diff === "major" || diff === "premajor") return "major";
+	if (diff === "minor" || diff === "preminor") return "minor";
+	if (diff === "patch" || diff === "prepatch" || diff === "prerelease") return "patch";
+	if (semver.gt(newVersion, oldVersion)) return "patch";
 	return "none";
 }
+function getPrereleaseIdentifier(version) {
+	const parsed = semver.parse(version);
+	if (!parsed || parsed.prerelease.length === 0) return;
+	const identifier = parsed.prerelease[0];
+	return typeof identifier === "string" ? identifier : void 0;
+}
+function getNextPrereleaseVersion(currentVersion, mode, identifier) {
+	if (!isValidSemver(currentVersion)) throw new Error(`Cannot bump prerelease for invalid semver: ${currentVersion}`);
+	const releaseType = mode === "next" ? "prerelease" : mode;
+	const next = identifier ? semver.inc(currentVersion, releaseType, identifier) : semver.inc(currentVersion, releaseType);
+	if (!next) throw new Error(`Failed to compute prerelease version for ${currentVersion}`);
+	return next;
+}
 
 //#endregion
 //#region src/core/prompts.ts
@@ -1059,7 +1055,20 @@ async function selectPackagePrompt(packages) {
 	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
 	return response.selectedPackages;
 }
-async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggestedVersion) {
+async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggestedVersion, options) {
+	const defaultChoice = options?.defaultChoice ?? "auto";
+	const suggestedSuffix = options?.suggestedHint ? farver.dim(` (${options.suggestedHint})`) : "";
+	const prereleaseIdentifier = getPrereleaseIdentifier(currentVersion);
+	const nextDefaultPrerelease = getNextPrereleaseVersion(currentVersion, "next", prereleaseIdentifier === "alpha" || prereleaseIdentifier === "beta" ? prereleaseIdentifier : "beta");
+	const nextBeta = getNextPrereleaseVersion(currentVersion, "next", "beta");
+	const nextAlpha = getNextPrereleaseVersion(currentVersion, "next", "alpha");
+	const prePatchBeta = getNextPrereleaseVersion(currentVersion, "prepatch", "beta");
+	const preMinorBeta = getNextPrereleaseVersion(currentVersion, "preminor", "beta");
+	const preMajorBeta = getNextPrereleaseVersion(currentVersion, "premajor", "beta");
+	const prePatchAlpha = getNextPrereleaseVersion(currentVersion, "prepatch", "alpha");
+	const preMinorAlpha = getNextPrereleaseVersion(currentVersion, "preminor", "alpha");
+	const preMajorAlpha = getNextPrereleaseVersion(currentVersion, "premajor", "alpha");
+	const initial = defaultChoice === "skip" ? 0 : defaultChoice === "suggested" ? 4 : defaultChoice === "as-is" ? 5 : suggestedVersion === currentVersion ? 0 : 4;
 	const answers = await prompts([{
 		type: "autocomplete",
 		name: "version",
@@ -1081,9 +1090,45 @@ async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggested
 				value: "patch",
 				title: `patch ${farver.bold(getNextVersion(pkg.version, "patch"))}`
 			},
+			{
+				value: "next",
+				title: `next ${farver.bold(nextDefaultPrerelease)}`
+			},
+			{
+				value: "prepatch-beta",
+				title: `pre-patch (beta) ${farver.bold(prePatchBeta)}`
+			},
+			{
+				value: "preminor-beta",
+				title: `pre-minor (beta) ${farver.bold(preMinorBeta)}`
+			},
+			{
+				value: "premajor-beta",
+				title: `pre-major (beta) ${farver.bold(preMajorBeta)}`
+			},
+			{
+				value: "prepatch-alpha",
+				title: `pre-patch (alpha) ${farver.bold(prePatchAlpha)}`
+			},
+			{
+				value: "preminor-alpha",
+				title: `pre-minor (alpha) ${farver.bold(preMinorAlpha)}`
+			},
+			{
+				value: "premajor-alpha",
+				title: `pre-major (alpha) ${farver.bold(preMajorAlpha)}`
+			},
+			{
+				value: "next-beta",
+				title: `next beta ${farver.bold(nextBeta)}`
+			},
+			{
+				value: "next-alpha",
+				title: `next alpha ${farver.bold(nextAlpha)}`
+			},
 			{
 				value: "suggested",
-				title: `suggested ${farver.bold(suggestedVersion)}`
+				title: `suggested ${farver.bold(suggestedVersion)}${suggestedSuffix}`
 			},
 			{
 				value: "as-is",
@@ -1094,7 +1139,7 @@ async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggested
 				title: "custom"
 			}
 		],
-		initial: suggestedVersion === currentVersion ? 0 : 4
+		initial
 	}, {
 		type: (prev) => prev === "custom" ? "text" : null,
 		name: "custom",
@@ -1112,6 +1157,15 @@ async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggested
 		if (!answers.custom) return null;
 		return answers.custom;
 	} else if (answers.version === "as-is") return currentVersion;
+	else if (answers.version === "next") return nextDefaultPrerelease;
+	else if (answers.version === "next-beta") return nextBeta;
+	else if (answers.version === "next-alpha") return nextAlpha;
+	else if (answers.version === "prepatch-beta") return prePatchBeta;
+	else if (answers.version === "preminor-beta") return preMinorBeta;
+	else if (answers.version === "premajor-beta") return preMajorBeta;
+	else if (answers.version === "prepatch-alpha") return prePatchAlpha;
+	else if (answers.version === "preminor-alpha") return preMinorAlpha;
+	else if (answers.version === "premajor-alpha") return preMajorAlpha;
 	else return getNextVersion(pkg.version, answers.version);
 }
 
@@ -1415,7 +1469,8 @@ function createVersionUpdate(pkg, bump, hasDirectChanges) {
 		currentVersion: pkg.version,
 		newVersion,
 		bumpType: bump,
-		hasDirectChanges
+		hasDirectChanges,
+		changeKind: "dependent"
 	};
 }
 function determineBumpType(commit) {
@@ -1637,40 +1692,50 @@ async function calculateVersionUpdates({ workspacePackages, packageCommits, work
 			logger.section(`📝 Commits for ${farver.cyan(pkg.name)}`);
 			formatCommitsForDisplay(allCommitsForPackage).split("\n").forEach((line) => logger.item(line));
 			logger.emptyLine();
-			const selectedVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, newVersion);
+			const selectedVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, newVersion, {
+				defaultChoice: override ? "suggested" : "auto",
+				suggestedHint: override ? "from override" : void 0
+			});
 			if (selectedVersion === null) continue;
 			const userBump = calculateBumpType(pkg.version, selectedVersion);
 			finalBumpType = userBump;
 			if (selectedVersion === pkg.version) {
 				excludedPackages.add(pkgName);
 				if (determinedBump !== "none") {
-					newOverrides[pkgName] = {
+					const nextOverride = {
 						type: "none",
 						version: pkg.version
 					};
-					logger.info(`Version override recorded for ${pkgName}: ${determinedBump} → none`);
+					if (!override || override.type !== nextOverride.type || override.version !== nextOverride.version) {
+						newOverrides[pkgName] = nextOverride;
+						logger.info(`Override set for ${pkgName}: suggested as-is (${pkg.version}) from auto ${determinedBump}`);
+					}
 				} else if (newOverrides[pkgName]) {
 					delete newOverrides[pkgName];
-					logger.info(`Version override removed for ${pkgName}.`);
+					logger.info(`Override cleared for ${pkgName}.`);
 				}
 				versionUpdates.push({
 					package: pkg,
 					currentVersion: pkg.version,
 					newVersion: pkg.version,
 					bumpType: "none",
-					hasDirectChanges: allCommitsForPackage.length > 0
+					hasDirectChanges: allCommitsForPackage.length > 0,
+					changeKind: "as-is"
 				});
 				continue;
 			}
 			if (bumpRanks[userBump] < bumpRanks[determinedBump]) {
-				newOverrides[pkgName] = {
+				const nextOverride = {
 					type: userBump,
 					version: selectedVersion
 				};
-				logger.info(`Version override recorded for ${pkgName}: ${determinedBump} → ${userBump}`);
+				if (!override || override.type !== nextOverride.type || override.version !== nextOverride.version) {
+					newOverrides[pkgName] = nextOverride;
+					logger.info(`Override set for ${pkgName}: suggested ${userBump} (${selectedVersion}) from auto ${determinedBump}`);
+				}
 			} else if (newOverrides[pkgName] && bumpRanks[userBump] >= bumpRanks[determinedBump]) {
 				delete newOverrides[pkgName];
-				logger.info(`Version override removed for ${pkgName}.`);
+				logger.info(`Override cleared for ${pkgName}.`);
 			}
 			newVersion = selectedVersion;
 		}
@@ -1679,7 +1744,8 @@ async function calculateVersionUpdates({ workspacePackages, packageCommits, work
 			currentVersion: pkg.version,
 			newVersion,
 			bumpType: finalBumpType,
-			hasDirectChanges: allCommitsForPackage.length > 0
+			hasDirectChanges: allCommitsForPackage.length > 0,
+			changeKind: canPrompt ? "manual" : "auto"
 		});
 	}
 	if (!isCI && showPrompt) for (const pkg of workspacePackages) {
@@ -1699,7 +1765,8 @@ async function calculateVersionUpdates({ workspacePackages, packageCommits, work
 			currentVersion: pkg.version,
 			newVersion,
 			bumpType,
-			hasDirectChanges: false
+			hasDirectChanges: false,
+			changeKind: "manual"
 		});
 	}
 	return {
@@ -1896,8 +1963,9 @@ async function prepareWorkflow(options) {
 	});
 	if (!updatesResult.ok) exitWithError("Failed to calculate package updates.", void 0, updatesResult.error);
 	const { allUpdates, applyUpdates, overrides: newOverrides } = updatesResult.value;
-	if (Object.keys(newOverrides).length > 0) {
-		logger.info("Writing version overrides file...");
+	const hasOverrideChanges = JSON.stringify(existingOverrides) !== JSON.stringify(newOverrides);
+	if (Object.keys(newOverrides).length > 0 && hasOverrideChanges) {
+		logger.step("Writing version overrides file...");
 		try {
 			await mkdir(join(options.workspaceRoot, ".github"), { recursive: true });
 			await writeFile(overridesPath, JSON.stringify(newOverrides, null, 2), "utf-8");
@@ -1905,7 +1973,7 @@ async function prepareWorkflow(options) {
 		} catch (e) {
 			logger.error("Failed to write version overrides file:", e);
 		}
-	}
+	} else if (Object.keys(newOverrides).length > 0) logger.step("Version overrides unchanged. Skipping write.");
 	if (Object.keys(newOverrides).length === 0 && Object.keys(existingOverrides).length > 0) {
 		let shouldRemoveOverrides = false;
 		for (const update of allUpdates) {
@@ -1931,7 +1999,7 @@ async function prepareWorkflow(options) {
 	logger.section("🔄 Version Updates");
 	logger.item(`Updating ${allUpdates.length} packages (including dependents)`);
 	for (const update of allUpdates) {
-		const suffix = update.currentVersion === update.newVersion ? farver.dim(" (as-is)") : "";
+		const suffix = update.changeKind === "as-is" ? farver.dim(" (as-is)") : "";
 		logger.item(`${update.package.name}: ${update.currentVersion} → ${update.newVersion}${suffix}`);
 	}
 	await applyUpdates();
@@ -1983,6 +2051,8 @@ async function prepareWorkflow(options) {
 		if (!prResult.ok) exitWithError("Failed to sync release pull request.", void 0, prResult.error);
 		if (prResult.value.pullRequest) {
 			logger.item("No updates needed, PR is already up to date");
+			const checkoutResult = await checkoutBranch(options.branch.default, options.workspaceRoot);
+			if (!checkoutResult.ok) exitWithError(`Failed to checkout branch: ${options.branch.default}`, void 0, checkoutResult.error);
 			return {
 				updates: allUpdates,
 				prUrl: prResult.value.pullRequest.html_url,
@@ -2095,11 +2165,12 @@ async function buildPackage(packageName, workspaceRoot, options) {
 * Publish a package to NPM
 * Uses pnpm to handle workspace protocol and catalog: resolution automatically
 * @param packageName - The package name to publish
+* @param version - The package version to publish
 * @param workspaceRoot - Path to the workspace root
 * @param options - Normalized release scripts options
 * @returns Result indicating success or failure
 */
-async function publishPackage(packageName, workspaceRoot, options) {
+async function publishPackage(packageName, version, workspaceRoot, options) {
 	const args = [
 		"--filter",
 		packageName,
@@ -2109,7 +2180,16 @@ async function publishPackage(packageName, workspaceRoot, options) {
 		"--no-git-checks"
 	];
 	if (options.npm.otp) args.push("--otp", options.npm.otp);
-	if (process.env.NPM_CONFIG_TAG) args.push("--tag", process.env.NPM_CONFIG_TAG);
+	const explicitTag = process.env.NPM_CONFIG_TAG;
+	const prereleaseTag = (() => {
+		const prerelease = semver.prerelease(version);
+		if (!prerelease || prerelease.length === 0) return;
+		const identifier = prerelease[0];
+		if (identifier === "alpha" || identifier === "beta") return identifier;
+		return "next";
+	})();
+	const publishTag = explicitTag || prereleaseTag;
+	if (publishTag) args.push("--tag", publishTag);
 	const env = { ...process.env };
 	if (options.npm.provenance) env.NPM_CONFIG_PROVENANCE = "true";
 	try {
@@ -2173,7 +2253,7 @@ async function publishWorkflow(options) {
 			}
 		}
 		logger.step(`Publishing ${farver.cyan(`${packageName}@${version}`)} to NPM...`);
-		const publishResult = await publishPackage(packageName, options.workspaceRoot, options);
+		const publishResult = await publishPackage(packageName, version, options.workspaceRoot, options);
 		if (!publishResult.ok) {
 			logger.error(`Failed to publish: ${publishResult.error.message}`);
 			status.failed.push(packageName);

package/package.json

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