@ucdjs/release-scripts 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+import "commit-parser";
+
 //#region src/workspace.d.ts
 interface WorkspacePackage {
   name: string;
@@ -10,6 +12,7 @@ interface WorkspacePackage {
 //#endregion
 //#region src/types.d.ts
 type BumpKind = "none" | "patch" | "minor" | "major";
+type GlobalCommitMode = false | "dependencies" | "all";
 interface SharedOptions {
   /**
    * Repository identifier (e.g., "owner/repo")
@@ -99,12 +102,38 @@ interface VersionUpdate {
 interface PublishOptions extends SharedOptions {}
 declare function publish(_options: PublishOptions): void;
 //#endregion
-//#region src/release.d.ts
-interface ReleaseOptions extends SharedOptions {
+//#region src/changelog.d.ts
+interface ChangelogOptions {
+  /**
+   * Whether to generate changelogs
+   * @default false
+   */
+  enabled?: boolean;
   /**
-   * Branch name for the release PR (defaults to "release/next")
+   * Transform function to customize the changelog content
    */
-  releaseBranch?: string;
+  transform?: (changelog: string, pkg: WorkspacePackage) => string | Promise<string>;
+  /**
+   * Repository information for generating links
+   */
+  repository?: {
+    owner: string;
+    repo: string;
+  };
+}
+//#endregion
+//#region src/release.d.ts
+interface ReleaseOptions extends SharedOptions {
+  branch?: {
+    /**
+     * Branch name for the release PR (defaults to "release/next")
+     */
+    release?: string;
+    /**
+     * Default branch name (e.g., "main")
+     */
+    default?: string;
+  };
   /**
    * Whether to perform a dry run (no changes pushed or PR created)
    * @default false
@@ -133,6 +162,11 @@ interface ReleaseOptions extends SharedOptions {
      */
     body?: string;
   };
+  /**
+   * Changelog configuration
+   */
+  changelog?: ChangelogOptions;
+  globalCommitMode?: GlobalCommitMode;
 }
 interface ReleaseResult {
   /**

package/dist/index.mjs

@@ -1,11 +1,12 @@
 import { t as Eta } from "./eta-Boh7yPZi.mjs";
-import { getCommits } from "commit-parser";
-import process from "node:process";
 import farver from "farver";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
 import { exec } from "tinyexec";
+import { getCommits } from "commit-parser";
 import { dedent } from "@luxass/utils";
-import { join } from "node:path";
-import { readFile, writeFile } from "node:fs/promises";
 import prompts from "prompts";
 
 //#region src/publish.ts
@@ -77,6 +78,114 @@ function normalizeSharedOptions(options) {
 	};
 }
 
+//#endregion
+//#region src/changelog.ts
+/**
+* Get section label for commit type
+*/
+function getSectionLabel(type) {
+	return {
+		feat: "Features",
+		fix: "Bug Fixes",
+		docs: "Documentation",
+		style: "Styles",
+		refactor: "Code Refactoring",
+		perf: "Performance Improvements",
+		test: "Tests",
+		build: "Build System",
+		ci: "Continuous Integration",
+		chore: "Miscellaneous Chores",
+		revert: "Reverts"
+	}[type] || "Other Changes";
+}
+/**
+* Generate changelog content from commits
+*/
+function generateChangelog(pkg, newVersion, commits, previousVersion, repository) {
+	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	let versionHeader = `## `;
+	if (repository && previousVersion) {
+		const compareUrl = `https://github.com/${repository.owner}/${repository.repo}/compare/${pkg.name}@${previousVersion}...${pkg.name}@${newVersion}`;
+		versionHeader += `[${newVersion}](${compareUrl})`;
+	} else versionHeader += newVersion;
+	versionHeader += ` (${date})\n\n`;
+	let changelog = versionHeader;
+	const grouped = /* @__PURE__ */ new Map();
+	for (const commit of commits) {
+		if (!commit.isConventional || !commit.type) continue;
+		const type = commit.type;
+		if (!grouped.has(type)) grouped.set(type, []);
+		grouped.get(type).push(commit);
+	}
+	for (const type of [
+		"feat",
+		"fix",
+		"perf",
+		"refactor",
+		"docs",
+		"test",
+		"build",
+		"ci",
+		"chore",
+		"revert",
+		"style"
+	]) {
+		const commits$1 = grouped.get(type);
+		if (!commits$1 || commits$1.length === 0) continue;
+		const label = getSectionLabel(type);
+		changelog += `### ${label}\n\n`;
+		for (const commit of commits$1) {
+			const scope = commit.scope ? `**${commit.scope}:** ` : "";
+			const breaking = commit.isBreaking ? " **BREAKING CHANGE**" : "";
+			let entry = `* ${scope}${commit.description}${breaking}`;
+			if (repository) {
+				const commitUrl = `https://github.com/${repository.owner}/${repository.repo}/commit/${commit.shortHash}`;
+				entry += ` ([${commit.shortHash}](${commitUrl}))`;
+			} else entry += ` (${commit.shortHash})`;
+			changelog += `${entry}\n`;
+		}
+		changelog += "\n";
+	}
+	return changelog.trim();
+}
+/**
+* Write changelog to package's CHANGELOG.md file
+*/
+async function writeChangelog(pkg, newContent, version) {
+	const changelogPath = join(pkg.path, "CHANGELOG.md");
+	let existingContent = "";
+	if (existsSync(changelogPath)) existingContent = await readFile(changelogPath, "utf-8");
+	let updatedContent;
+	if (existingContent) {
+		const withoutTitle = existingContent.replace(/^# Changelog\n\n/, "");
+		if (new RegExp(`^## ${version.replace(/\./g, "\\.")}(\\s|$)`, "m").test(withoutTitle)) {
+			const versionSectionRegex = new RegExp(`^## ${version.replace(/\./g, "\\.")}[\\s\\S]*?(?=^## |$)`, "m");
+			updatedContent = `# Changelog\n\n${withoutTitle.replace(versionSectionRegex, `${newContent}\n\n`)}`;
+		} else updatedContent = `# Changelog\n\n${newContent}\n\n${withoutTitle}`;
+	} else updatedContent = `# Changelog\n\n${newContent}\n`;
+	await writeFile(changelogPath, updatedContent, "utf-8");
+	logger.log(`Updated changelog: ${changelogPath}`);
+}
+/**
+* Generate and write changelogs for all updated packages
+*/
+async function updateChangelogs(updates, packageCommits, options) {
+	if (!options?.enabled) {
+		logger.log("Changelog generation is disabled");
+		return;
+	}
+	logger.log("Generating changelogs...");
+	for (const update of updates) {
+		if (!update.hasDirectChanges) continue;
+		const commits = packageCommits.get(update.package.name) || [];
+		if (commits.length === 0) continue;
+		let changelog = generateChangelog(update.package, update.newVersion, commits, update.currentVersion, options.repository);
+		if (options.transform) changelog = await options.transform(changelog, update.package);
+		logger.info(`Generating changelog for package ${update.package.name}`);
+		await writeChangelog(update.package, changelog, update.newVersion);
+	}
+}
+
 //#endregion
 //#region src/commits.ts
 async function getLastPackageTag(packageName, workspaceRoot) {
@@ -140,6 +249,58 @@ async function getWorkspacePackageCommits(workspaceRoot, packages) {
 	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
 	return changedPackages;
 }
+/**
+* Get all commits for the workspace (not filtered by package)
+*/
+async function getAllWorkspaceCommits(workspaceRoot, lastTag) {
+	return getCommits({
+		from: lastTag,
+		to: "HEAD",
+		cwd: workspaceRoot
+	});
+}
+/**
+* Get files changed in a specific commit
+*/
+async function getFilesChangedInCommit(commitHash, workspaceRoot) {
+	try {
+		const { stdout } = await run("git", [
+			"diff-tree",
+			"--no-commit-id",
+			"--name-only",
+			"-r",
+			commitHash
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return stdout.split("\n").map((file) => file.trim()).filter(Boolean);
+	} catch {
+		return null;
+	}
+}
+/**
+* Filter and combine package commits with global commits
+*/
+function combineWithGlobalCommits(workspaceRoot, packageCommits, allCommits, mode) {
+	if (!mode) return packageCommits;
+	const packageCommitShas = new Set(packageCommits.map((c) => c.shortHash));
+	const globalCommits = allCommits.filter((c) => !packageCommitShas.has(c.shortHash));
+	if (mode === "all") return [...packageCommits, ...globalCommits];
+	if (mode === "dependencies") {
+		const dependencyCommits = globalCommits.filter(async (c) => {
+			const affectedFiles = await getFilesChangedInCommit(c.shortHash, workspaceRoot);
+			if (affectedFiles == null) return false;
+			return affectedFiles.some((file) => [
+				"package.json",
+				"pnpm-lock.yaml",
+				"pnpm-workspace.yaml"
+			].includes(file));
+		});
+		return [...packageCommits, ...dependencyCommits];
+	}
+	return packageCommits;
+}
 function determineBumpType(commit) {
 	if (commit.isBreaking) return "major";
 	if (!commit.isConventional || !commit.type) return "none";
@@ -380,6 +541,15 @@ async function pushBranch(branch, workspaceRoot, options) {
 		exitWithError(`Failed to push branch: ${branch}`, `Make sure you have permission to push to the remote repository`);
 	}
 }
+async function getDefaultBranch() {
+	try {
+		const match = (await run("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { nodeOptions: { stdio: "pipe" } })).stdout.trim().match(/^refs\/remotes\/origin\/(.+)$/);
+		if (match && match[1]) return match[1];
+		return "main";
+	} catch {
+		return "main";
+	}
+}
 
 //#endregion
 //#region src/github.ts
@@ -590,19 +760,15 @@ function createVersionUpdate(pkg, bump, hasDirectChanges) {
 /**
 * Infer version updates from package commits with optional interactive overrides
 *
-* @param workspacePackages - All workspace packages
-* @param packageCommits - Map of package names to their commits
-* @param workspaceRoot - Root directory for prompts
-* @param showPrompt - Whether to show prompts for version overrides
 * @returns Version updates for packages with changes
 */
-async function inferVersionUpdates(workspacePackages, packageCommits, workspaceRoot, showPrompt) {
+async function inferVersionUpdates({ workspacePackages, packageCommits, allCommits, workspaceRoot, showPrompt, globalCommitMode }) {
 	const versionUpdates = [];
-	for (const [pkgName, commits] of packageCommits) {
-		if (commits.length === 0) continue;
+	for (const [pkgName, pkgCommits] of packageCommits) {
+		if (pkgCommits.length === 0) continue;
 		const pkg = workspacePackages.find((p) => p.name === pkgName);
 		if (!pkg) continue;
-		const bump = determineHighestBump(commits);
+		const bump = determineHighestBump(combineWithGlobalCommits(workspaceRoot, pkgCommits, allCommits, globalCommitMode));
 		if (bump === "none") {
 			logger.info(`No version bump needed for package ${pkg.name}`);
 			continue;
@@ -828,8 +994,12 @@ function shouldIncludePackage(pkg, options) {
 async function release(options) {
 	const normalizedOptions = normalizeSharedOptions(options);
 	normalizedOptions.dryRun ??= false;
-	normalizedOptions.releaseBranch ??= "release/next";
+	normalizedOptions.branch ??= {};
+	normalizedOptions.branch.release ??= "release/next";
+	normalizedOptions.branch.default = await getDefaultBranch();
 	normalizedOptions.safeguards ??= true;
+	normalizedOptions.changelog ??= { enabled: true };
+	normalizedOptions.globalCommitMode ??= "dependencies";
 	globalOptions.dryRun = normalizedOptions.dryRun;
 	const workspaceRoot = normalizedOptions.workspaceRoot;
 	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
@@ -838,37 +1008,53 @@ async function release(options) {
 		logger.log("No packages found to release.");
 		return null;
 	}
-	const versionUpdates = await inferVersionUpdates(workspacePackages, await getWorkspacePackageCommits(workspaceRoot, workspacePackages), workspaceRoot, options.prompts?.versions !== false);
+	const packageCommits = await getWorkspacePackageCommits(workspaceRoot, workspacePackages);
+	const versionUpdates = await inferVersionUpdates({
+		workspacePackages,
+		packageCommits,
+		workspaceRoot,
+		showPrompt: options.prompts?.versions !== false,
+		allCommits: await getAllWorkspaceCommits(workspaceRoot),
+		globalCommitMode: options.globalCommitMode
+	});
 	if (versionUpdates.length === 0) logger.warn("No packages have changes requiring a release");
 	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, versionUpdates);
 	const currentBranch = await getCurrentBranch(workspaceRoot);
+	if (currentBranch !== normalizedOptions.branch.default) exitWithError(`Current branch is '${currentBranch}'. Please switch to the default branch '${normalizedOptions.branch.default}' before proceeding.`, `git checkout ${normalizedOptions.branch.default}`);
 	const existingPullRequest = await getExistingPullRequest({
 		owner: normalizedOptions.owner,
 		repo: normalizedOptions.repo,
-		branch: normalizedOptions.releaseBranch,
+		branch: normalizedOptions.branch.release,
 		githubToken: normalizedOptions.githubToken
 	});
 	const prExists = !!existingPullRequest;
 	if (prExists) logger.log("Existing pull request found:", existingPullRequest.html_url);
 	else logger.log("No existing pull request found, will create new one");
-	const branchExists = await doesBranchExist(normalizedOptions.releaseBranch, workspaceRoot);
+	const branchExists = await doesBranchExist(normalizedOptions.branch.release, workspaceRoot);
 	if (!branchExists) {
-		logger.log("Creating release branch:", normalizedOptions.releaseBranch);
-		await createBranch(normalizedOptions.releaseBranch, currentBranch, workspaceRoot);
+		logger.log("Creating release branch:", normalizedOptions.branch.release);
+		await createBranch(normalizedOptions.branch.release, normalizedOptions.branch.default, workspaceRoot);
 	}
-	if (!await checkoutBranch(normalizedOptions.releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${normalizedOptions.releaseBranch}`);
+	if (!await checkoutBranch(normalizedOptions.branch.release, workspaceRoot)) throw new Error(`Failed to checkout branch: ${normalizedOptions.branch.release}`);
 	if (branchExists) {
 		logger.log("Pulling latest changes from remote");
-		if (!await pullLatestChanges(normalizedOptions.releaseBranch, workspaceRoot)) logger.log("Warning: Failed to pull latest changes, continuing anyway");
+		if (!await pullLatestChanges(normalizedOptions.branch.release, workspaceRoot)) logger.log("Warning: Failed to pull latest changes, continuing anyway");
 	}
-	logger.log("Rebasing release branch onto", currentBranch);
-	await rebaseBranch(currentBranch, workspaceRoot);
+	logger.log("Rebasing release branch onto", normalizedOptions.branch.default);
+	await rebaseBranch(normalizedOptions.branch.default, workspaceRoot);
 	await updateAllPackageJsonFiles(allUpdates);
+	await updateChangelogs(versionUpdates, packageCommits, {
+		...options.changelog,
+		repository: options.changelog?.repository || {
+			owner: normalizedOptions.owner,
+			repo: normalizedOptions.repo
+		}
+	});
 	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
-	const isBranchAhead = await isBranchAheadOfRemote(normalizedOptions.releaseBranch, workspaceRoot);
+	const isBranchAhead = await isBranchAheadOfRemote(normalizedOptions.branch.release, workspaceRoot);
 	if (!hasCommitted && !isBranchAhead) {
 		logger.log("No changes to commit and branch is in sync with remote");
-		await checkoutBranch(currentBranch, workspaceRoot);
+		await checkoutBranch(normalizedOptions.branch.default, workspaceRoot);
 		if (prExists) {
 			logger.log("No updates needed, PR is already up to date");
 			return {
@@ -882,7 +1068,7 @@ async function release(options) {
 		}
 	}
 	logger.log("Pushing changes to remote");
-	await pushBranch(normalizedOptions.releaseBranch, workspaceRoot, { forceWithLease: true });
+	await pushBranch(normalizedOptions.branch.release, workspaceRoot, { forceWithLease: true });
 	const prTitle = existingPullRequest?.title || options.pullRequest?.title || "chore: update package versions";
 	const prBody = generatePullRequestBody(allUpdates, options.pullRequest?.body);
 	const pullRequest = await upsertPullRequest({
@@ -891,12 +1077,16 @@ async function release(options) {
 		pullNumber: existingPullRequest?.number,
 		title: prTitle,
 		body: prBody,
-		head: normalizedOptions.releaseBranch,
-		base: currentBranch,
+		head: normalizedOptions.branch.release,
+		base: normalizedOptions.branch.default,
 		githubToken: normalizedOptions.githubToken
 	});
 	logger.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
-	await checkoutBranch(currentBranch, workspaceRoot);
+	await checkoutBranch(normalizedOptions.branch.default, workspaceRoot);
+	if (pullRequest?.html_url) {
+		logger.info();
+		logger.info(`${farver.green("✓")} Pull request ${prExists ? "updated" : "created"}: ${farver.cyan(pullRequest.html_url)}`);
+	}
 	return {
 		updates: allUpdates,
 		prUrl: pullRequest?.html_url,

package/package.json

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