@ucdjs/release-scripts 0.1.0-beta.17 → 0.1.0-beta.18

package/dist/index.d.mts

@@ -180,7 +180,13 @@ interface ReleaseResult {
 declare function release(options: ReleaseOptions): Promise<ReleaseResult | null>;
 //#endregion
 //#region src/verify.d.ts
-interface VerifyOptions extends SharedOptions {}
-declare function verify(_options: VerifyOptions): void;
+interface VerifyOptions extends SharedOptions {
+  branch?: {
+    release?: string;
+    default?: string;
+  };
+  safeguards?: boolean;
+}
+declare function verify(options: VerifyOptions): Promise<void>;
 //#endregion
 export { type PublishOptions, type ReleaseOptions, type ReleaseResult, type VerifyOptions, publish, release, verify };

package/dist/index.mjs

@@ -1,13 +1,15 @@
 import { t as Eta } from "./eta-j5TFRbI4.mjs";
-import { readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, relative } from "node:path";
 import process from "node:process";
+import readline from "node:readline";
 import farver from "farver";
 import mri from "mri";
 import { exec } from "tinyexec";
 import { dedent } from "@luxass/utils";
 import { getCommits, groupByType } from "commit-parser";
 import prompts from "prompts";
+import { gt } from "semver";
 
 //#region src/publish.ts
 function publish(_options) {}
@@ -57,6 +59,13 @@ const logger = {
 	},
 	success: (message) => {
 		console.log(`  ${farver.green("✓")} ${message}`);
+	},
+	clearScreen: () => {
+		const repeatCount = process.stdout.rows - 2;
+		const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+		console.log(blank);
+		readline.cursorTo(process.stdout, 0, 0);
+		readline.clearScreenDown(process.stdout);
 	}
 };
 async function run(bin, args$1, opts = {}) {
@@ -386,6 +395,7 @@ async function getGroupedFilesByCommitSha(workspaceRoot, from, to) {
 
 //#endregion
 //#region src/core/changelog.ts
+const globalAuthorCache = /* @__PURE__ */ new Map();
 const DEFAULT_CHANGELOG_TEMPLATE = dedent`
   <% if (it.previousVersion) { -%>
   ## [<%= it.version %>](<%= it.compareUrl %>) (<%= it.date %>)
@@ -492,24 +502,28 @@ async function updateChangelog(options) {
 	await writeFile(changelogPath, updatedContent, "utf-8");
 }
 async function resolveCommitAuthors(commits, githubClient) {
-	const authorsByEmail = /* @__PURE__ */ new Map();
+	const authorsToResolve = /* @__PURE__ */ new Set();
 	const commitAuthors = /* @__PURE__ */ new Map();
 	for (const commit of commits) {
 		const authorsForCommit = [];
 		commit.authors.forEach((author, idx) => {
 			if (!author.email || !author.name) return;
-			if (!authorsByEmail.has(author.email)) authorsByEmail.set(author.email, {
-				commits: [],
-				name: author.name,
-				email: author.email
-			});
-			const info = authorsByEmail.get(author.email);
+			let info = globalAuthorCache.get(author.email);
+			if (!info) {
+				info = {
+					commits: [],
+					name: author.name,
+					email: author.email
+				};
+				globalAuthorCache.set(author.email, info);
+			}
 			if (idx === 0) info.commits.push(commit.shortHash);
 			authorsForCommit.push(info);
+			if (!info.login) authorsToResolve.add(info);
 		});
 		commitAuthors.set(commit.hash, authorsForCommit);
 	}
-	await Promise.all(Array.from(authorsByEmail.values()).map((info) => githubClient.resolveAuthorInfo(info)));
+	await Promise.all(Array.from(authorsToResolve).map((info) => githubClient.resolveAuthorInfo(info)));
 	return commitAuthors;
 }
 function formatCommitLine({ commit, owner, repo, authors }) {
@@ -1087,9 +1101,16 @@ function formatCommitsForDisplay(commits) {
 /**
 * Calculate version updates for packages based on their commits
 */
-async function calculateVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage }) {
+async function calculateVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides: initialOverrides = {} }) {
 	const versionUpdates = [];
 	const processedPackages = /* @__PURE__ */ new Set();
+	const newOverrides = { ...initialOverrides };
+	const bumpRanks = {
+		major: 3,
+		minor: 2,
+		patch: 1,
+		none: 0
+	};
 	logger.verbose(`Starting version inference for ${packageCommits.size} packages with commits`);
 	for (const [pkgName, pkgCommits] of packageCommits) {
 		const pkg = workspacePackages.find((p) => p.name === pkgName);
@@ -1099,30 +1120,39 @@ async function calculateVersionUpdates({ workspacePackages, packageCommits, work
 		}
 		processedPackages.add(pkgName);
 		const globalCommits = globalCommitsPerPackage.get(pkgName) || [];
-		if (globalCommits.length > 0) logger.verbose(`  - Global commits for this package: ${globalCommits.length}`);
 		const allCommitsForPackage = [...pkgCommits, ...globalCommits];
-		const bump = determineHighestBump(allCommitsForPackage);
-		if (bump === "none") continue;
-		let newVersion = getNextVersion(pkg.version, bump);
+		const determinedBump = determineHighestBump(allCommitsForPackage);
+		const effectiveBump = newOverrides[pkgName] || determinedBump;
+		if (effectiveBump === "none") continue;
+		let newVersion = getNextVersion(pkg.version, effectiveBump);
 		if (!isCI && showPrompt) {
-			logger.section("📝 Commits affecting this package");
+			logger.clearScreen();
+			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);
 			if (selectedVersion === null) continue;
+			const userBump = _calculateBumpType(pkg.version, selectedVersion);
+			if (bumpRanks[userBump] < bumpRanks[determinedBump]) {
+				newOverrides[pkgName] = userBump;
+				logger.info(`Version override recorded for ${pkgName}: ${determinedBump} → ${userBump}`);
+			} else if (newOverrides[pkgName] && bumpRanks[userBump] >= bumpRanks[determinedBump]) {
+				delete newOverrides[pkgName];
+				logger.info(`Version override removed for ${pkgName}.`);
+			}
 			newVersion = selectedVersion;
 		}
-		logger.verbose(`Version update: ${pkg.version} → ${newVersion}`);
 		versionUpdates.push({
 			package: pkg,
 			currentVersion: pkg.version,
 			newVersion,
-			bumpType: bump,
-			hasDirectChanges: true
+			bumpType: effectiveBump,
+			hasDirectChanges: allCommitsForPackage.length > 0
 		});
 	}
 	if (!isCI && showPrompt) for (const pkg of workspacePackages) {
 		if (processedPackages.has(pkg.name)) continue;
+		logger.clearScreen();
 		logger.section(`📦 Package: ${pkg.name}`);
 		logger.item("No direct commits found");
 		const newVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, pkg.version);
@@ -1138,19 +1168,23 @@ async function calculateVersionUpdates({ workspacePackages, packageCommits, work
 			});
 		}
 	}
-	return versionUpdates;
+	return {
+		updates: versionUpdates,
+		overrides: newOverrides
+	};
 }
 /**
 * Calculate version updates and prepare dependent updates
 * Returns both the updates and a function to apply them
 */
-async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage }) {
-	const directUpdates = await calculateVersionUpdates({
+async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides }) {
+	const { updates: directUpdates, overrides: newOverrides } = await calculateVersionUpdates({
 		workspacePackages,
 		packageCommits,
 		workspaceRoot,
 		showPrompt,
-		globalCommitsPerPackage
+		globalCommitsPerPackage,
+		overrides
 	});
 	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, directUpdates);
 	const applyUpdates = async () => {
@@ -1161,7 +1195,8 @@ async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCom
 	};
 	return {
 		allUpdates,
-		applyUpdates
+		applyUpdates,
+		overrides: newOverrides
 	};
 }
 async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
@@ -1458,17 +1493,6 @@ async function release(options) {
 	logger.emptyLine();
 	const groupedPackageCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
 	const globalCommitsPerPackage = await getGlobalCommitsPerPackage(workspaceRoot, groupedPackageCommits, workspacePackages, normalizedOptions.globalCommitMode);
-	const { allUpdates, applyUpdates } = await calculateAndPrepareVersionUpdates({
-		workspacePackages,
-		packageCommits: groupedPackageCommits,
-		workspaceRoot,
-		showPrompt: options.prompts?.versions !== false,
-		globalCommitsPerPackage
-	});
-	if (allUpdates.filter((u) => u.hasDirectChanges).length === 0) logger.warn("No packages have changes requiring a release");
-	logger.section("🔄 Version Updates");
-	logger.item(`Updating ${allUpdates.length} packages (including dependents)`);
-	for (const update of allUpdates) logger.item(`${update.package.name}: ${update.currentVersion} → ${update.newVersion}`);
 	const githubClient = createGitHubClient({
 		owner: normalizedOptions.owner,
 		repo: normalizedOptions.repo,
@@ -1483,6 +1507,38 @@ async function release(options) {
 		pullRequestBody: options.pullRequest?.body
 	});
 	await prOps.prepareBranch();
+	const overridesPath = join(workspaceRoot, ".github", "ucdjs.release.overrides.json");
+	let existingOverrides = {};
+	try {
+		const overridesContent = await readFile(overridesPath, "utf-8");
+		existingOverrides = JSON.parse(overridesContent);
+		logger.info("Found existing version overrides file.");
+	} catch {
+		logger.info("No existing version overrides file found. Continuing...");
+	}
+	const { allUpdates, applyUpdates, overrides: newOverrides } = await calculateAndPrepareVersionUpdates({
+		workspacePackages,
+		packageCommits: groupedPackageCommits,
+		workspaceRoot,
+		showPrompt: options.prompts?.versions !== false,
+		globalCommitsPerPackage,
+		overrides: existingOverrides
+	});
+	if (Object.keys(newOverrides).length > 0) {
+		logger.info("Writing version overrides file...");
+		try {
+			await mkdir(join(workspaceRoot, ".github"), { recursive: true });
+			await writeFile(overridesPath, JSON.stringify(newOverrides, null, 2), "utf-8");
+			logger.success("Successfully wrote version overrides file.");
+		} catch (e) {
+			logger.error("Failed to write version overrides file:", e);
+		}
+	}
+	if (allUpdates.filter((u) => u.hasDirectChanges).length === 0) logger.warn("No packages have changes requiring a release");
+	logger.section("🔄 Version Updates");
+	logger.item(`Updating ${allUpdates.length} packages (including dependents)`);
+	for (const update of allUpdates) logger.item(`${update.package.name}: ${update.currentVersion} → ${update.newVersion}`);
+	await prOps.prepareBranch();
 	await applyUpdates();
 	if (normalizedOptions.changelog.enabled) {
 		logger.step("Updating changelogs");
@@ -1593,7 +1649,87 @@ async function orchestrateReleasePullRequest({ workspaceRoot, githubClient, rele
 
 //#endregion
 //#region src/verify.ts
-function verify(_options) {}
+async function verify(options) {
+	const { workspaceRoot,...normalizedOptions } = await normalizeReleaseOptions(options);
+	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
+	const githubClient = createGitHubClient({
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		githubToken: normalizedOptions.githubToken
+	});
+	const releaseBranch = normalizedOptions.branch.release;
+	const defaultBranch = normalizedOptions.branch.default;
+	const releasePr = await githubClient.getExistingPullRequest(releaseBranch);
+	if (!releasePr || !releasePr.head) {
+		logger.warn(`No open release pull request found for branch "${releaseBranch}". Nothing to verify.`);
+		return;
+	}
+	logger.info(`Found release PR #${releasePr.number}. Verifying against default branch "${defaultBranch}"...`);
+	const originalBranch = await getCurrentBranch(workspaceRoot);
+	if (originalBranch !== defaultBranch) await checkoutBranch(defaultBranch, workspaceRoot);
+	const overridesPath = join(".github", "ucdjs.release.overrides.json");
+	let existingOverrides = {};
+	try {
+		const overridesContent = await readFileFromGit(workspaceRoot, releasePr.head.sha, overridesPath);
+		if (overridesContent) {
+			existingOverrides = JSON.parse(overridesContent);
+			logger.info("Found existing version overrides file on release branch.");
+		}
+	} catch {
+		logger.info("No version overrides file found on release branch. Continuing...");
+	}
+	const mainPackages = await discoverWorkspacePackages(workspaceRoot, options);
+	const mainCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, mainPackages);
+	const { allUpdates: expectedUpdates } = await calculateAndPrepareVersionUpdates({
+		workspacePackages: mainPackages,
+		packageCommits: mainCommits,
+		workspaceRoot,
+		showPrompt: false,
+		globalCommitsPerPackage: await getGlobalCommitsPerPackage(workspaceRoot, mainCommits, mainPackages, normalizedOptions.globalCommitMode),
+		overrides: existingOverrides
+	});
+	const expectedVersionMap = new Map(expectedUpdates.map((u) => [u.package.name, u.newVersion]));
+	const prVersionMap = /* @__PURE__ */ new Map();
+	for (const pkg of mainPackages) {
+		const pkgJsonPath = join(pkg.path.replace(workspaceRoot, ""), "package.json").substring(1);
+		const pkgJsonContent = await readFileFromGit(workspaceRoot, releasePr.head.sha, pkgJsonPath);
+		if (pkgJsonContent) {
+			const pkgJson = JSON.parse(pkgJsonContent);
+			prVersionMap.set(pkg.name, pkgJson.version);
+		}
+	}
+	if (originalBranch !== defaultBranch) await checkoutBranch(originalBranch, workspaceRoot);
+	let isOutOfSync = false;
+	for (const [pkgName, expectedVersion] of expectedVersionMap.entries()) {
+		const prVersion = prVersionMap.get(pkgName);
+		if (!prVersion) {
+			logger.warn(`Package "${pkgName}" found in default branch but not in release branch. Skipping.`);
+			continue;
+		}
+		if (gt(expectedVersion, prVersion)) {
+			logger.error(`Package "${pkgName}" is out of sync. Expected version >= ${expectedVersion}, but PR has ${prVersion}.`);
+			isOutOfSync = true;
+		} else logger.success(`Package "${pkgName}" is up to date (PR version: ${prVersion}, Expected: ${expectedVersion})`);
+	}
+	const statusContext = "ucdjs/release-verify";
+	if (isOutOfSync) {
+		await githubClient.setCommitStatus({
+			sha: releasePr.head.sha,
+			state: "failure",
+			context: statusContext,
+			description: "Release PR is out of sync with the default branch. Please re-run the release process."
+		});
+		logger.error("Verification failed. Commit status set to 'failure'.");
+	} else {
+		await githubClient.setCommitStatus({
+			sha: releasePr.head.sha,
+			state: "success",
+			context: statusContext,
+			description: "Release PR is up to date."
+		});
+		logger.success("Verification successful. Commit status set to 'success'.");
+	}
+}
 
 //#endregion
 export { publish, release, verify };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.17",
+  "version": "0.1.0-beta.18",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",
@@ -32,12 +32,14 @@
     "farver": "1.0.0-beta.1",
     "mri": "1.2.0",
     "prompts": "2.4.2",
+    "semver": "7.7.3",
     "tinyexec": "1.0.2"
   },
   "devDependencies": {
     "@luxass/eslint-config": "6.0.1",
     "@types/node": "22.18.12",
     "@types/prompts": "2.4.9",
+    "@types/semver": "7.7.1",
     "eslint": "9.39.1",
     "eta": "4.0.1",
     "tsdown": "0.16.0",