@ucdjs/release-scripts 0.1.0-beta.16 → 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,23 +395,25 @@ 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) { %>
+  <% if (it.previousVersion) { -%>
   ## [<%= it.version %>](<%= it.compareUrl %>) (<%= it.date %>)
-  <% } else { %>
+  <% } else { -%>
   ## <%= it.version %> (<%= it.date %>)
   <% } %>
 
   <% it.groups.forEach((group) => { %>
   <% if (group.commits.length > 0) { %>
-  ### <%= group.title %>
 
+  ### <%= group.title %>
   <% group.commits.forEach((commit) => { %>
+
   * <%= commit.line %>
-  <% }) %>
+  <% }); %>
 
   <% } %>
-  <% }) %>
+  <% }); %>
 `;
 async function generateChangelogEntry(options) {
 	const { packageName, version, previousVersion, date, commits, owner, repo, groups, template, githubClient } = options;
@@ -411,16 +422,7 @@ async function generateChangelogEntry(options) {
 		includeNonConventional: false,
 		mergeKeys: Object.fromEntries(groups.map((g) => [g.name, g.types]))
 	});
-	for (const commit of commits) {
-		if (commit.authors.length === 0) continue;
-		commit.resolvedAuthors = await Promise.all(commit.authors.map(async (author) => {
-			const username = await githubClient.resolveAuthorInfo(author.email);
-			return {
-				...author,
-				username
-			};
-		}));
-	}
+	const commitAuthors = await resolveCommitAuthors(commits, githubClient);
 	const templateData = {
 		packageName,
 		version,
@@ -432,27 +434,12 @@ async function generateChangelogEntry(options) {
 		groups: groups.map((group) => {
 			const commitsInGroup = grouped.get(group.name) ?? [];
 			if (commitsInGroup.length > 0) logger.verbose(`Found ${commitsInGroup.length} commits for group "${group.name}".`);
-			const formattedCommits = commitsInGroup.map((commit) => {
-				const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
-				let line = `${commit.description}`;
-				if (commit.references.length > 0) logger.verbose("Located references in commit", commit.references.length);
-				for (const ref of commit.references) {
-					if (!ref.value) continue;
-					const number = Number.parseInt(ref.value.replace(/^#/, ""), 10);
-					if (Number.isNaN(number)) continue;
-					if (ref.type === "issue") {
-						line += ` ([Issue ${ref.value}](https://github.com/${owner}/${repo}/issues/${number}))`;
-						continue;
-					}
-					line += ` ([PR ${ref.value}](https://github.com/${owner}/${repo}/pull/${number}))`;
-				}
-				line += ` ([${commit.shortHash}](${commitUrl}))`;
-				if (commit.authors.length > 0) {
-					console.log(commit.resolvedAuthors);
-					line += ` (by ${commit.authors.map((a) => a.name).join(", ")})`;
-				}
-				return { line };
-			});
+			const formattedCommits = commitsInGroup.map((commit) => ({ line: formatCommitLine({
+				commit,
+				owner,
+				repo,
+				authors: commitAuthors.get(commit.hash) ?? []
+			}) }));
 			return {
 				name: group.name,
 				title: group.title,
@@ -465,7 +452,7 @@ async function generateChangelogEntry(options) {
 	return eta.renderString(templateToUse, templateData).trim();
 }
 async function updateChangelog(options) {
-	const { version, previousVersion, commits, date, normalizedOptions, workspacePackage } = options;
+	const { version, previousVersion, commits, date, normalizedOptions, workspacePackage, githubClient } = options;
 	const changelogPath = join(workspacePackage.path, "CHANGELOG.md");
 	const changelogRelativePath = relative(normalizedOptions.workspaceRoot, join(workspacePackage.path, "CHANGELOG.md"));
 	const existingContent = await readFileFromGit(normalizedOptions.workspaceRoot, normalizedOptions.branch.default, changelogRelativePath);
@@ -480,7 +467,7 @@ async function updateChangelog(options) {
 		repo: normalizedOptions.repo,
 		groups: normalizedOptions.groups,
 		template: normalizedOptions.changelog?.template,
-		githubClient: options.githubClient
+		githubClient
 	});
 	let updatedContent;
 	if (!existingContent) {
@@ -514,6 +501,56 @@ async function updateChangelog(options) {
 	}
 	await writeFile(changelogPath, updatedContent, "utf-8");
 }
+async function resolveCommitAuthors(commits, githubClient) {
+	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;
+			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(authorsToResolve).map((info) => githubClient.resolveAuthorInfo(info)));
+	return commitAuthors;
+}
+function formatCommitLine({ commit, owner, repo, authors }) {
+	const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
+	let line = `${commit.description}`;
+	const references = commit.references ?? [];
+	if (references.length > 0) logger.verbose("Located references in commit", references.length);
+	for (const ref of references) {
+		if (!ref.value) continue;
+		const number = Number.parseInt(ref.value.replace(/^#/, ""), 10);
+		if (Number.isNaN(number)) continue;
+		if (ref.type === "issue") {
+			line += ` ([Issue ${ref.value}](https://github.com/${owner}/${repo}/issues/${number}))`;
+			continue;
+		}
+		line += ` ([PR ${ref.value}](https://github.com/${owner}/${repo}/pull/${number}))`;
+	}
+	line += ` ([${commit.shortHash}](${commitUrl}))`;
+	if (authors.length > 0) {
+		const authorList = authors.map((author) => {
+			if (author.login) return `[@${author.login}](https://github.com/${author.login})`;
+			return author.name;
+		}).join(", ");
+		line += ` (by ${authorList})`;
+	}
+	return line;
+}
 function parseChangelog(content) {
 	const lines = content.split("\n");
 	let packageName = null;
@@ -647,11 +684,24 @@ var GitHubClient = class {
 		});
 		logger.info(`Commit status set to ${farver.cyan(state)} for ${farver.gray(sha.substring(0, 7))}`);
 	}
-	async resolveAuthorInfo(email) {
-		const q = encodeURIComponent(`${email} type:user in:email`);
-		const data = await this.request(`/search/users?q=${q}`);
-		if (!data.items || data.items.length === 0) return null;
-		return data.items[0].login;
+	async resolveAuthorInfo(info) {
+		if (info.login) return info;
+		try {
+			const q = encodeURIComponent(`${info.email} type:user in:email`);
+			const data = await this.request(`/search/users?q=${q}`);
+			if (!data.items || data.items.length === 0) return info;
+			info.login = data.items[0].login;
+		} catch (err) {
+			logger.warn(`Failed to resolve author info for email ${info.email}: ${err.message}`);
+		}
+		if (info.login) return info;
+		if (info.commits.length > 0) try {
+			const data = await this.request(`/repos/${this.owner}/${this.repo}/commits/${info.commits[0]}`);
+			if (data.author && data.author.login) info.login = data.author.login;
+		} catch (err) {
+			logger.warn(`Failed to resolve author info from commits for email ${info.email}: ${err.message}`);
+		}
+		return info;
 	}
 };
 function createGitHubClient(options) {
@@ -1051,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);
@@ -1063,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);
@@ -1102,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 () => {
@@ -1125,7 +1195,8 @@ async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCom
 	};
 	return {
 		allUpdates,
-		applyUpdates
+		applyUpdates,
+		overrides: newOverrides
 	};
 }
 async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
@@ -1396,7 +1467,10 @@ async function normalizeReleaseOptions(options) {
 			title: options.pullRequest?.title ?? "chore: release new version",
 			body: options.pullRequest?.body ?? DEFAULT_PR_BODY_TEMPLATE
 		},
-		changelog: { enabled: options.changelog?.enabled ?? true }
+		changelog: {
+			enabled: options.changelog?.enabled ?? true,
+			template: options.changelog?.template ?? DEFAULT_CHANGELOG_TEMPLATE
+		}
 	};
 }
 
@@ -1419,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,
@@ -1444,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");
@@ -1554,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.16",
+  "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",