@ucdjs/release-scripts 0.1.0-beta.50 → 0.1.0-beta.52

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
@@ -347,6 +347,59 @@ var GitHubClient = class {
 		});
 		logger.info(`Commit status set to ${farver.cyan(state)} for ${farver.gray(sha.substring(0, 7))}`);
 	}
+	async upsertReleaseByTag({ tagName, name, body, prerelease = false }) {
+		const encodedTag = encodeURIComponent(tagName);
+		let existingRelease = null;
+		try {
+			existingRelease = await this.request(`/repos/${this.owner}/${this.repo}/releases/tags/${encodedTag}`);
+		} catch (error) {
+			if (formatUnknownError(error).status !== 404) throw error;
+		}
+		if (existingRelease) {
+			logger.verbose(`Updating release for tag ${farver.cyan(tagName)}`);
+			const updated = await this.request(`/repos/${this.owner}/${this.repo}/releases/${existingRelease.id}`, {
+				method: "PATCH",
+				body: JSON.stringify({
+					name,
+					body,
+					prerelease,
+					draft: false
+				})
+			});
+			logger.info(`Updated GitHub release for ${farver.cyan(tagName)}`);
+			return {
+				release: {
+					id: updated.id,
+					tagName: updated.tag_name,
+					name: updated.name ?? name,
+					htmlUrl: updated.html_url
+				},
+				created: false
+			};
+		}
+		logger.verbose(`Creating release for tag ${farver.cyan(tagName)}`);
+		const created = await this.request(`/repos/${this.owner}/${this.repo}/releases`, {
+			method: "POST",
+			body: JSON.stringify({
+				tag_name: tagName,
+				name,
+				body,
+				prerelease,
+				draft: false,
+				generate_release_notes: body == null
+			})
+		});
+		logger.info(`Created GitHub release for ${farver.cyan(tagName)}`);
+		return {
+			release: {
+				id: created.id,
+				tagName: created.tag_name,
+				name: created.name ?? name,
+				htmlUrl: created.html_url
+			},
+			created: true
+		};
+	}
 	async resolveAuthorInfo(info) {
 		if (info.login) return info;
 		try {
@@ -471,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,
@@ -687,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 = [
@@ -751,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.
@@ -1067,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",
@@ -1080,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"))}`
@@ -1104,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,
@@ -1357,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
@@ -1999,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");
@@ -2033,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)`);
@@ -2209,6 +2343,43 @@ async function publishPackage(packageName, version, workspaceRoot, options) {
 
 //#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);
@@ -2260,10 +2431,26 @@ async function publishWorkflow(options) {
 		status.published.push(packageName);
 		logger.step(`Creating git tag ${farver.cyan(`${packageName}@${version}`)}...`);
 		const tagResult = await createAndPushPackageTag(packageName, version, options.workspaceRoot);
+		const tagName = `${packageName}@${version}`;
 		if (!tagResult.ok) {
 			logger.error(`Failed to create/push tag: ${tagResult.error.message}`);
-			logger.warn(`Package was published but tag was not created. You may need to create it manually.`);
-		} else logger.success(`Created and pushed tag ${farver.cyan(`${packageName}@${version}`)}`);
+			status.failed.push(packageName);
+			exitWithError(`Publishing failed for ${packageName}: could not create git tag`, "Ensure the workflow token can push tags (contents: write) and git credentials are configured", tagResult.error);
+		}
+		logger.success(`Created and pushed tag ${farver.cyan(tagName)}`);
+		logger.step(`Creating GitHub release for ${farver.cyan(tagName)}...`);
+		try {
+			const releaseResult = await options.githubClient.upsertReleaseByTag({
+				tagName,
+				name: tagName,
+				prerelease: Boolean(semver.prerelease(version))
+			});
+			if (releaseResult.release.htmlUrl) logger.success(`${releaseResult.created ? "Created" : "Updated"} GitHub release: ${releaseResult.release.htmlUrl}`);
+			else logger.success(`${releaseResult.created ? "Created" : "Updated"} GitHub release for ${farver.cyan(tagName)}`);
+		} catch (error) {
+			status.failed.push(packageName);
+			exitWithError(`Publishing failed for ${packageName}: could not create GitHub release`, "Ensure the workflow token can write repository contents and releases", error);
+		}
 	}
 	logger.section("📊 Publishing Summary");
 	logger.item(`${farver.green("✓")} Published: ${status.published.length} package(s)`);
@@ -2277,6 +2464,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.50",
+  "version": "0.1.0-beta.52",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",