@ucdjs/release-scripts 0.1.0-beta.51 → 0.1.0-beta.53

package/dist/index.d.mts

@@ -25,6 +25,7 @@ interface ReleaseScriptsOptionsInput {
     enabled?: boolean;
     template?: string;
     emojis?: boolean;
+    combinePrereleaseIntoFirstStable?: boolean;
   };
   npm?: {
     otp?: string;

package/dist/index.mjs

@@ -8,7 +8,7 @@ import farver from "farver";
 import mri from "mri";
 import { exec } from "tinyexec";
 import { dedent } from "@luxass/utils";
-import semver, { compare, gt } from "semver";
+import semver, { gt } from "semver";
 import prompts from "prompts";
 
 //#region src/operations/changelog-format.ts
@@ -524,7 +524,8 @@ function normalizeReleaseScriptsOptions(options) {
 		changelog: {
 			enabled: changelog.enabled ?? true,
 			template: changelog.template ?? DEFAULT_CHANGELOG_TEMPLATE,
-			emojis: changelog.emojis ?? true
+			emojis: changelog.emojis ?? true,
+			combinePrereleaseIntoFirstStable: changelog.combinePrereleaseIntoFirstStable ?? false
 		},
 		types: types ? {
 			...DEFAULT_TYPES,
@@ -740,6 +741,42 @@ async function commitChanges(message, workspaceRoot) {
 		return err(gitError);
 	}
 }
+async function commitPaths(paths, message, workspaceRoot) {
+	try {
+		if (paths.length === 0) return ok(false);
+		await run("git", [
+			"add",
+			"--",
+			...paths
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		if ((await run("git", [
+			"diff",
+			"--cached",
+			"--name-only"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.trim() === "") return ok(false);
+		logger.info(`Committing changes: ${farver.dim(message)}`);
+		await runIfNotDry("git", [
+			"commit",
+			"-m",
+			message
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return ok(true);
+	} catch (error) {
+		const gitError = toGitError("commitPaths", error);
+		logger.error(`Git commit failed: ${gitError.message}`);
+		if (gitError.stderr) logger.error(`Git stderr: ${gitError.stderr}`);
+		return err(gitError);
+	}
+}
 async function pushBranch(branch, workspaceRoot, options) {
 	try {
 		const args = [
@@ -804,6 +841,28 @@ async function getMostRecentPackageTag(workspaceRoot, packageName) {
 		return err(toGitError("getMostRecentPackageTag", error));
 	}
 }
+async function getMostRecentPackageStableTag(workspaceRoot, packageName) {
+	try {
+		const { stdout } = await run("git", [
+			"tag",
+			"--list",
+			`${packageName}@*`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const tags = stdout.split("\n").map((tag) => tag.trim()).filter(Boolean).reverse();
+		for (const tag of tags) {
+			const atIndex = tag.lastIndexOf("@");
+			if (atIndex === -1) continue;
+			const version = tag.slice(atIndex + 1);
+			if (semver.valid(version) && semver.prerelease(version) == null) return ok(tag);
+		}
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("getMostRecentPackageStableTag", error));
+	}
+}
 /**
 * Builds a mapping of commit SHAs to the list of files changed in each commit
 * within a given inclusive range.
@@ -1120,6 +1179,7 @@ async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggested
 	const prePatchAlpha = getNextPrereleaseVersion(currentVersion, "prepatch", "alpha");
 	const preMinorAlpha = getNextPrereleaseVersion(currentVersion, "preminor", "alpha");
 	const preMajorAlpha = getNextPrereleaseVersion(currentVersion, "premajor", "alpha");
+	const isCurrentPrerelease = prereleaseIdentifier != null;
 	const choices = [
 		{
 			value: "skip",
@@ -1133,6 +1193,10 @@ async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggested
 			value: "as-is",
 			title: `as-is ${farver.dim("(keep current version)")}`
 		},
+		...isCurrentPrerelease ? [{
+			value: "next-prerelease",
+			title: `next prerelease ${farver.bold(nextDefaultPrerelease)}`
+		}] : [],
 		{
 			value: "patch",
 			title: `patch ${farver.bold(getNextVersion(pkg.version, "patch"))}`
@@ -1157,6 +1221,7 @@ async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggested
 	const initialValue = defaultChoice === "auto" ? suggestedVersion === currentVersion ? "skip" : "suggested" : defaultChoice;
 	const initial = Math.max(0, choices.findIndex((choice) => choice.value === initialValue));
 	const prereleaseVersionByChoice = {
+		"next-prerelease": nextDefaultPrerelease,
 		"next": nextDefaultPrerelease,
 		"next-beta": nextBeta,
 		"next-alpha": nextAlpha,
@@ -1410,6 +1475,16 @@ async function getWorkspacePackageGroupedCommits(workspaceRoot, packages) {
 	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
 	return changedPackages;
 }
+async function getPackageCommitsSinceTag(workspaceRoot, pkg, fromTag) {
+	const allCommits = await getCommits({
+		from: fromTag,
+		to: "HEAD",
+		cwd: workspaceRoot,
+		folder: pkg.path
+	});
+	logger.verbose(`Found ${farver.cyan(allCommits.length)} commits for package ${farver.bold(pkg.name)} since ${farver.cyan(fromTag ?? "start")}`);
+	return allCommits;
+}
 /**
 * Check if a file path touches any package folder.
 * @param file - The file path to check
@@ -2052,25 +2127,13 @@ async function prepareWorkflow(options) {
 			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) {
-			const overriddenVersion = existingOverrides[update.package.name];
-			if (overriddenVersion) {
-				if (compare(update.newVersion, overriddenVersion.version) > 0) {
-					shouldRemoveOverrides = true;
-					break;
-				}
-			}
-		}
-		if (shouldRemoveOverrides) {
-			logger.info("Removing obsolete version overrides file...");
-			try {
-				await rm(overridesPath);
-				logger.success("Successfully removed obsolete version overrides file.");
-			} catch (e) {
-				logger.error("Failed to remove obsolete version overrides file:", e);
-			}
+	if (Object.keys(newOverrides).length === 0 && hasOverrideChanges) {
+		logger.info("Removing obsolete version overrides file...");
+		try {
+			await rm(overridesPath);
+			logger.success("Successfully removed obsolete version overrides file.");
+		} catch (e) {
+			if (formatUnknownError(e).code !== "ENOENT") logger.error("Failed to remove obsolete version overrides file:", e);
 		}
 	}
 	if (allUpdates.filter((u) => u.hasDirectChanges).length === 0) logger.warn("No packages have changes requiring a release");
@@ -2086,26 +2149,44 @@ async function prepareWorkflow(options) {
 		const groupedPackageCommits = await getWorkspacePackageGroupedCommits(options.workspaceRoot, workspacePackages);
 		const globalCommitsPerPackage = await getGlobalCommitsPerPackage(options.workspaceRoot, groupedPackageCommits, workspacePackages, options.globalCommitMode === "none" ? false : options.globalCommitMode);
 		const changelogPromises = allUpdates.map((update) => {
-			const pkgCommits = groupedPackageCommits.get(update.package.name) || [];
-			const globalCommits = globalCommitsPerPackage.get(update.package.name) || [];
-			const allCommits = [...pkgCommits, ...globalCommits];
-			if (allCommits.length === 0) {
-				logger.verbose(`No commits for ${update.package.name}, skipping changelog`);
-				return Promise.resolve();
-			}
-			logger.verbose(`Updating changelog for ${farver.cyan(update.package.name)}`);
-			return updateChangelog({
-				normalizedOptions: {
-					...options,
-					workspaceRoot: options.workspaceRoot
-				},
-				githubClient: options.githubClient,
-				workspacePackage: update.package,
-				version: update.newVersion,
-				previousVersion: update.currentVersion !== "0.0.0" ? update.currentVersion : void 0,
-				commits: allCommits,
-				date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-			});
+			return (async () => {
+				let pkgCommits = groupedPackageCommits.get(update.package.name) || [];
+				let globalCommits = globalCommitsPerPackage.get(update.package.name) || [];
+				let previousVersionForChangelog = update.currentVersion !== "0.0.0" ? update.currentVersion : void 0;
+				if (options.changelog.combinePrereleaseIntoFirstStable && semver.prerelease(update.currentVersion) != null && semver.prerelease(update.newVersion) == null) {
+					const stableTagResult = await getMostRecentPackageStableTag(options.workspaceRoot, update.package.name);
+					if (!stableTagResult.ok) logger.warn(`Failed to resolve stable tag for ${update.package.name}: ${stableTagResult.error.message}`);
+					else {
+						const stableTag = stableTagResult.value;
+						if (stableTag) {
+							logger.verbose(`Combining prerelease changelog entries into stable release for ${update.package.name} using base tag ${stableTag}`);
+							const stableBaseCommits = await getPackageCommitsSinceTag(options.workspaceRoot, update.package, stableTag);
+							pkgCommits = stableBaseCommits;
+							globalCommits = (await getGlobalCommitsPerPackage(options.workspaceRoot, new Map([[update.package.name, stableBaseCommits]]), workspacePackages, options.globalCommitMode === "none" ? false : options.globalCommitMode)).get(update.package.name) || [];
+							const atIndex = stableTag.lastIndexOf("@");
+							if (atIndex !== -1) previousVersionForChangelog = stableTag.slice(atIndex + 1);
+						}
+					}
+				}
+				const allCommits = [...pkgCommits, ...globalCommits];
+				if (allCommits.length === 0) {
+					logger.verbose(`No commits for ${update.package.name}, skipping changelog`);
+					return;
+				}
+				logger.verbose(`Updating changelog for ${farver.cyan(update.package.name)}`);
+				await updateChangelog({
+					normalizedOptions: {
+						...options,
+						workspaceRoot: options.workspaceRoot
+					},
+					githubClient: options.githubClient,
+					workspacePackage: update.package,
+					version: update.newVersion,
+					previousVersion: previousVersionForChangelog,
+					commits: allCommits,
+					date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+				});
+			})();
 		}).filter((p) => p != null);
 		const updates = await Promise.all(changelogPromises);
 		logger.success(`Updated ${updates.length} changelog(s)`);
@@ -2176,6 +2257,16 @@ function toNPMError(operation, error, code) {
 		status: formatted.status
 	};
 }
+function classifyPublishErrorCode(error) {
+	const formatted = formatUnknownError(error);
+	const combined = [formatted.message, formatted.stderr].filter(Boolean).join("\n");
+	if (combined.includes("E403") || combined.toLowerCase().includes("access token expired or revoked")) return "E403";
+	if (combined.includes("EPUBLISHCONFLICT") || combined.includes("E409") || combined.includes("409 Conflict") || combined.includes("Failed to save packument")) return "EPUBLISHCONFLICT";
+	if (combined.includes("EOTP")) return "EOTP";
+}
+function wait(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
 /**
 * Get the NPM registry URL
 * Respects NPM_CONFIG_REGISTRY environment variable, defaults to npmjs.org
@@ -2247,7 +2338,13 @@ async function publishPackage(packageName, version, workspaceRoot, options) {
 	if (publishTag) args.push("--tag", publishTag);
 	const env = { ...process.env };
 	if (options.npm.provenance) env.NPM_CONFIG_PROVENANCE = "true";
-	try {
+	const maxAttempts = 4;
+	const backoffMs = [
+		3e3,
+		8e3,
+		15e3
+	];
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
 		await runIfNotDry("pnpm", args, { nodeOptions: {
 			cwd: workspaceRoot,
 			stdio: "inherit",
@@ -2255,13 +2352,57 @@ async function publishPackage(packageName, version, workspaceRoot, options) {
 		} });
 		return ok(void 0);
 	} catch (error) {
-		const errorMessage = formatUnknownError(error).message;
-		return err(toNPMError("publishPackage", error, errorMessage.includes("E403") ? "E403" : errorMessage.includes("EPUBLISHCONFLICT") ? "EPUBLISHCONFLICT" : errorMessage.includes("EOTP") ? "EOTP" : void 0));
+		const code = classifyPublishErrorCode(error);
+		if (code === "EPUBLISHCONFLICT" && attempt < maxAttempts) {
+			const delay = backoffMs[attempt - 1] ?? backoffMs[backoffMs.length - 1];
+			logger.warn(`Publish conflict for ${packageName}@${version} (attempt ${attempt}/${maxAttempts}). Retrying in ${Math.ceil(delay / 1e3)}s...`);
+			await wait(delay);
+			continue;
+		}
+		return err(toNPMError("publishPackage", error, code));
 	}
+	return err(toNPMError("publishPackage", /* @__PURE__ */ new Error(`Failed to publish ${packageName}@${version} after ${maxAttempts} attempts`), "EPUBLISHCONFLICT"));
 }
 
 //#endregion
 //#region src/workflows/publish.ts
+async function cleanupPublishedOverrides(options, workspacePackages, publishedPackageNames) {
+	if (publishedPackageNames.length === 0) return false;
+	if (options.dryRun) {
+		logger.verbose("Dry-run: skipping override cleanup");
+		return false;
+	}
+	const overridesPath = join(options.workspaceRoot, ucdjsReleaseOverridesPath);
+	let overrides;
+	try {
+		overrides = JSON.parse(await readFile(overridesPath, "utf-8"));
+	} catch {
+		return false;
+	}
+	const versionsByPackage = new Map(workspacePackages.map((pkg) => [pkg.name, pkg.version]));
+	const publishedSet = new Set(publishedPackageNames);
+	const removed = [];
+	for (const [pkgName, override] of Object.entries(overrides)) {
+		if (!publishedSet.has(pkgName)) continue;
+		const currentVersion = versionsByPackage.get(pkgName);
+		const current = currentVersion ? semver.valid(currentVersion) : null;
+		const target = semver.valid(override.version);
+		if (current && target && semver.gte(current, target)) {
+			delete overrides[pkgName];
+			removed.push(pkgName);
+		}
+	}
+	if (removed.length === 0) return false;
+	logger.step(`Cleaning up satisfied overrides (${removed.length})...`);
+	if (Object.keys(overrides).length === 0) {
+		await rm(overridesPath, { force: true });
+		logger.success("Removed release override file (all entries satisfied)");
+		return true;
+	}
+	await writeFile(overridesPath, JSON.stringify(overrides, null, 2), "utf-8");
+	logger.success(`Removed satisfied overrides: ${removed.join(", ")}`);
+	return true;
+}
 async function publishWorkflow(options) {
 	logger.section("📦 Publishing Packages");
 	const discovered = await discoverWorkspacePackages(options.workspaceRoot, options);
@@ -2346,6 +2487,18 @@ async function publishWorkflow(options) {
 		for (const pkg of status.failed) logger.item(`  ${farver.red("•")} ${pkg}`);
 	}
 	if (status.failed.length > 0) exitWithError(`Publishing completed with ${status.failed.length} failure(s)`);
+	if (await cleanupPublishedOverrides(options, workspacePackages, status.published) && !options.dryRun) {
+		logger.step("Committing override cleanup...");
+		const commitResult = await commitPaths([ucdjsReleaseOverridesPath], "chore: cleanup release overrides", options.workspaceRoot);
+		if (!commitResult.ok) exitWithError("Failed to commit override cleanup.", void 0, commitResult.error);
+		if (commitResult.value) {
+			const currentBranch = await getCurrentBranch(options.workspaceRoot);
+			if (!currentBranch.ok) exitWithError("Failed to detect current branch for override cleanup push.", void 0, currentBranch.error);
+			const pushResult = await pushBranch(currentBranch.value, options.workspaceRoot);
+			if (!pushResult.ok) exitWithError("Failed to push override cleanup commit.", void 0, pushResult.error);
+			logger.success(`Pushed override cleanup commit to ${farver.cyan(currentBranch.value)}`);
+		}
+	}
 	logger.success("All packages published successfully!");
 }
 

package/package.json

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