@ucdjs/release-scripts 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/{eta-Boh7yPZi.mjs → eta-j5TFRbI4.mjs}

@@ -1,5 +1,5 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
+import * as fs from "node:fs";
 
 //#region node_modules/.pnpm/eta@4.0.1/node_modules/eta/dist/index.js
 var EtaError = class extends Error {
@@ -90,8 +90,8 @@ function resolvePath(templatePath, options) {
 	} else throw new EtaFileResolutionError(`Template '${templatePath}' is not in the views directory`);
 }
 function dirIsChild(parent, dir) {
-	const relative = path.relative(parent, dir);
-	return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+	const relative$1 = path.relative(parent, dir);
+	return relative$1 && !relative$1.startsWith("..") && !path.isAbsolute(relative$1);
 }
 const absolutePathRegExp = /^\\|^\//;
 /* istanbul ignore next */

package/dist/index.d.mts

@@ -11,11 +11,25 @@ interface WorkspacePackage {
 //#region src/shared/types.d.ts
 type BumpKind = "none" | "patch" | "minor" | "major";
 type GlobalCommitMode = false | "dependencies" | "all";
+interface CommitGroup {
+  /**
+   * Unique identifier for the group
+   */
+  name: string;
+  /**
+   * Display title (e.g., "Features", "Bug Fixes")
+   */
+  title: string;
+  /**
+   * Conventional commit types to include in this group
+   */
+  types: string[];
+}
 interface SharedOptions {
   /**
    * Repository identifier (e.g., "owner/repo")
    */
-  repo: string;
+  repo: `${string}/${string}`;
   /**
    * Root directory of the workspace (defaults to process.cwd())
    */
@@ -44,6 +58,12 @@ interface SharedOptions {
      */
     versions?: boolean;
   };
+  /**
+   * Commit grouping configuration
+   * Used for changelog generation and commit display
+   * @default DEFAULT_COMMIT_GROUPS
+   */
+  groups?: CommitGroup[];
 }
 interface PackageJson {
   name: string;
@@ -136,6 +156,10 @@ interface ReleaseOptions extends SharedOptions {
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Custom changelog entry template (ETA format)
+     */
+    template?: string;
   };
   globalCommitMode?: GlobalCommitMode;
 }
@@ -155,4 +179,8 @@ interface ReleaseResult {
 }
 declare function release(options: ReleaseOptions): Promise<ReleaseResult | null>;
 //#endregion
-export { type PublishOptions, type ReleaseOptions, type ReleaseResult, publish, release };
+//#region src/verify.d.ts
+interface VerifyOptions extends SharedOptions {}
+declare function verify(_options: VerifyOptions): void;
+//#endregion
+export { type PublishOptions, type ReleaseOptions, type ReleaseResult, type VerifyOptions, publish, release, verify };

package/dist/index.mjs

@@ -1,12 +1,12 @@
-import { t as Eta } from "./eta-Boh7yPZi.mjs";
+import { t as Eta } from "./eta-j5TFRbI4.mjs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
 import process from "node:process";
 import farver from "farver";
 import mri from "mri";
 import { exec } from "tinyexec";
 import { dedent } from "@luxass/utils";
-import { join } from "node:path";
-import { readFile, writeFile } from "node:fs/promises";
-import { getCommits } from "commit-parser";
+import { getCommits, groupByType } from "commit-parser";
 import prompts from "prompts";
 
 //#region src/publish.ts
@@ -49,8 +49,8 @@ const logger = {
 	emptyLine: () => {
 		console.log();
 	},
-	item: (message) => {
-		console.log(`  ${message}`);
+	item: (message, ...args$1) => {
+		console.log(`  ${message}`, ...args$1);
 	},
 	step: (message) => {
 		console.log(`  ${farver.blue("→")} ${message}`);
@@ -78,28 +78,6 @@ function exitWithError(message, hint) {
 	if (hint) console.error(farver.gray(`  ${hint}`));
 	process.exit(1);
 }
-function normalizeSharedOptions(options) {
-	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, prompts: prompts$1 = {
-		packages: true,
-		versions: true
-	},...rest } = options;
-	if (!githubToken.trim()) exitWithError("GitHub token is required", "Set GITHUB_TOKEN environment variable or pass it in options");
-	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) exitWithError("Repository (repo) is required", "Specify the repository in 'owner/repo' format (e.g., 'octocat/hello-world')");
-	const [owner, repo] = fullRepo.split("/");
-	if (!owner || !repo) exitWithError(`Invalid repo format: "${fullRepo}"`, "Expected format: \"owner/repo\" (e.g., \"octocat/hello-world\")");
-	return {
-		...rest,
-		packages,
-		prompts: {
-			packages: prompts$1?.packages ?? true,
-			versions: prompts$1?.versions ?? true
-		},
-		workspaceRoot,
-		githubToken,
-		owner,
-		repo
-	};
-}
 if (isDryRun || isVerbose || isForce) {
 	logger.verbose(farver.inverse(farver.yellow(" Running with special flags ")));
 	logger.verbose({
@@ -284,21 +262,15 @@ async function isBranchAheadOfRemote(branch, workspaceRoot) {
 		return true;
 	}
 }
-async function hasChangesToCommit(workspaceRoot) {
-	return (await run("git", ["status", "--porcelain"], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} })).stdout.trim() !== "";
-}
 async function commitChanges(message, workspaceRoot) {
 	try {
 		await run("git", ["add", "."], { nodeOptions: {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
-		if (!await hasChangesToCommit(workspaceRoot)) return false;
+		if (await isWorkingDirectoryClean(workspaceRoot)) return false;
 		logger.info(`Committing changes: ${farver.dim(message)}`);
-		await run("git", [
+		await runIfNotDry("git", [
 			"commit",
 			"-m",
 			message
@@ -334,19 +306,291 @@ 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 readFileFromGit(workspaceRoot, ref, filePath) {
+	try {
+		return (await run("git", ["show", `${ref}:${filePath}`], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout;
+	} catch {
+		return null;
+	}
+}
+async function getMostRecentPackageTag(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);
+		if (tags.length === 0) return;
+		return tags.reverse()[0];
+	} catch (err) {
+		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
+		return;
+	}
+}
+/**
+* Builds a mapping of commit SHAs to the list of files changed in each commit
+* within a given inclusive range.
+*
+* Internally runs:
+*   git log --name-only --format=%H <from>^..<to>
+*
+* Notes
+* - This includes the commit identified by `from` (via `from^..to`).
+* - Order of commits in the resulting Map follows `git log` output
+*   (reverse chronological, newest first).
+* - On failure (e.g., invalid refs), the function returns null.
+*
+* @param {string} workspaceRoot Absolute path to the git repository root used as cwd.
+* @param {string} from          Starting commit/ref (inclusive).
+* @param {string} to            Ending commit/ref (inclusive).
+* @returns {Promise<Map<string, string[]> | null>} Promise resolving to a Map where keys are commit SHAs and values are
+*          arrays of file paths changed by that commit, or null on error.
+*/
+async function getGroupedFilesByCommitSha(workspaceRoot, from, to) {
+	const commitsMap = /* @__PURE__ */ new Map();
+	try {
+		const { stdout } = await run("git", [
+			"log",
+			"--name-only",
+			"--format=%H",
+			`${from}^..${to}`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const lines = stdout.trim().split("\n").filter((line) => line.trim() !== "");
+		let currentSha = null;
+		const HASH_REGEX = /^[0-9a-f]{40}$/i;
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (HASH_REGEX.test(trimmedLine)) {
+				currentSha = trimmedLine;
+				commitsMap.set(currentSha, []);
+				continue;
+			}
+			if (currentSha === null) continue;
+			commitsMap.get(currentSha).push(trimmedLine);
+		}
+		return commitsMap;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/core/changelog.ts
+const DEFAULT_CHANGELOG_TEMPLATE = dedent`
+  <% if (it.previousVersion) { %>
+  ## [<%= it.version %>](<%= it.compareUrl %>) (<%= it.date %>)
+  <% } else { %>
+  ## <%= it.version %> (<%= it.date %>)
+  <% } %>
+
+  <% it.groups.forEach((group) => { %>
+  <% if (group.commits.length > 0) { %>
+  ### <%= group.title %>
+
+  <% group.commits.forEach((commit) => { %>
+  * <%= commit.line %>
+  <% }) %>
+
+  <% } %>
+  <% }) %>
+`;
+async function generateChangelogEntry(options) {
+	const { packageName, version, previousVersion, date, commits, owner, repo, groups, template, githubClient } = options;
+	const compareUrl = previousVersion ? `https://github.com/${owner}/${repo}/compare/${packageName}@${previousVersion}...${packageName}@${version}` : void 0;
+	const grouped = groupByType(commits, {
+		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 templateData = {
+		packageName,
+		version,
+		previousVersion,
+		date,
+		compareUrl,
+		owner,
+		repo,
+		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 };
+			});
+			return {
+				name: group.name,
+				title: group.title,
+				commits: formattedCommits
+			};
+		})
+	};
+	const eta = new Eta();
+	const templateToUse = template || DEFAULT_CHANGELOG_TEMPLATE;
+	return eta.renderString(templateToUse, templateData).trim();
+}
+async function updateChangelog(options) {
+	const { version, previousVersion, commits, date, normalizedOptions, workspacePackage } = 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);
+	logger.verbose("Existing content found: ", Boolean(existingContent));
+	const newEntry = await generateChangelogEntry({
+		packageName: workspacePackage.name,
+		version,
+		previousVersion,
+		date,
+		commits,
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		groups: normalizedOptions.groups,
+		template: normalizedOptions.changelog?.template,
+		githubClient: options.githubClient
+	});
+	let updatedContent;
+	if (!existingContent) {
+		updatedContent = `# ${workspacePackage.name}\n\n${newEntry}\n`;
+		await writeFile(changelogPath, updatedContent, "utf-8");
+		return;
+	}
+	const parsed = parseChangelog(existingContent);
+	const lines = existingContent.split("\n");
+	const existingVersionIndex = parsed.versions.findIndex((v) => v.version === version);
+	if (existingVersionIndex !== -1) {
+		const existingVersion = parsed.versions[existingVersionIndex];
+		const before = lines.slice(0, existingVersion.lineStart);
+		const after = lines.slice(existingVersion.lineEnd + 1);
+		updatedContent = [
+			...before,
+			newEntry,
+			...after
+		].join("\n");
+	} else {
+		const insertAt = parsed.headerLineEnd + 1;
+		const before = lines.slice(0, insertAt);
+		const after = lines.slice(insertAt);
+		if (before.length > 0 && before[before.length - 1] !== "") before.push("");
+		updatedContent = [
+			...before,
+			newEntry,
+			"",
+			...after
+		].join("\n");
+	}
+	await writeFile(changelogPath, updatedContent, "utf-8");
+}
+function parseChangelog(content) {
+	const lines = content.split("\n");
+	let packageName = null;
+	let headerLineEnd = -1;
+	const versions = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("# ")) {
+			packageName = line.slice(2).trim();
+			headerLineEnd = i;
+			break;
+		}
+	}
+	for (let i = headerLineEnd + 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("## ")) {
+			const versionMatch = line.match(/##\s+(?:<small>)?\[?([^\](\s<]+)/);
+			if (versionMatch) {
+				const version = versionMatch[1];
+				const lineStart = i;
+				let lineEnd = lines.length - 1;
+				for (let j = i + 1; j < lines.length; j++) if (lines[j].trim().startsWith("## ")) {
+					lineEnd = j - 1;
+					break;
+				}
+				const versionContent = lines.slice(lineStart, lineEnd + 1).join("\n");
+				versions.push({
+					version,
+					lineStart,
+					lineEnd,
+					content: versionContent
+				});
+			}
+		}
+	}
+	return {
+		packageName,
+		versions,
+		headerLineEnd
+	};
+}
 
 //#endregion
 //#region src/core/github.ts
-async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
-	try {
-		logger.verbose(`Requesting pull request for branch: ${branch} (url: https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch})`);
-		const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch}`, { headers: {
-			Accept: "application/vnd.github.v3+json",
-			Authorization: `token ${githubToken}`
-		} });
-		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
-		const pulls = await res.json();
-		if (pulls == null || !Array.isArray(pulls) || pulls.length === 0) return null;
+var GitHubClient = class {
+	owner;
+	repo;
+	githubToken;
+	apiBase = "https://api.github.com";
+	constructor({ owner, repo, githubToken }) {
+		this.owner = owner;
+		this.repo = repo;
+		this.githubToken = githubToken;
+	}
+	async request(path, init = {}) {
+		const url = path.startsWith("http") ? path : `${this.apiBase}${path}`;
+		const res = await fetch(url, {
+			...init,
+			headers: {
+				...init.headers,
+				Accept: "application/vnd.github.v3+json",
+				Authorization: `token ${this.githubToken}`
+			}
+		});
+		if (!res.ok) {
+			const errorText = await res.text();
+			throw new Error(`GitHub API request failed with status ${res.status}: ${errorText || "No response body"}`);
+		}
+		if (res.status === 204) return;
+		return res.json();
+	}
+	async getExistingPullRequest(branch) {
+		const head = branch.includes(":") ? branch : `${this.owner}:${branch}`;
+		const endpoint = `/repos/${this.owner}/${this.repo}/pulls?state=open&head=${encodeURIComponent(head)}`;
+		logger.verbose(`Requesting pull request for branch: ${branch} (url: ${this.apiBase}${endpoint})`);
+		const pulls = await this.request(endpoint);
+		if (!Array.isArray(pulls) || pulls.length === 0) return null;
 		const firstPullRequest = pulls[0];
 		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
 		const pullRequest = {
@@ -354,20 +598,15 @@ async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
 			title: firstPullRequest.title,
 			body: firstPullRequest.body,
 			draft: firstPullRequest.draft,
-			html_url: firstPullRequest.html_url
+			html_url: firstPullRequest.html_url,
+			head: "head" in firstPullRequest && typeof firstPullRequest.head === "object" && firstPullRequest.head !== null && "sha" in firstPullRequest.head && typeof firstPullRequest.head.sha === "string" ? { sha: firstPullRequest.head.sha } : void 0
 		};
 		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
 		return pullRequest;
-	} catch (err) {
-		logger.error("Error fetching pull request:", err);
-		return null;
 	}
-}
-async function upsertPullRequest({ owner, repo, title, body, head, base, pullNumber, githubToken }) {
-	try {
-		const isUpdate = pullNumber != null;
-		const url = isUpdate ? `https://api.github.com/repos/${owner}/${repo}/pulls/${pullNumber}` : `https://api.github.com/repos/${owner}/${repo}/pulls`;
-		const method = isUpdate ? "PATCH" : "POST";
+	async upsertPullRequest({ title, body, head, base, pullNumber }) {
+		const isUpdate = typeof pullNumber === "number";
+		const endpoint = isUpdate ? `/repos/${this.owner}/${this.repo}/pulls/${pullNumber}` : `/repos/${this.owner}/${this.repo}/pulls`;
 		const requestBody = isUpdate ? {
 			title,
 			body
@@ -378,17 +617,11 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			base,
 			draft: true
 		};
-		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${url})`);
-		const res = await fetch(url, {
-			method,
-			headers: {
-				Accept: "application/vnd.github.v3+json",
-				Authorization: `token ${githubToken}`
-			},
+		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${this.apiBase}${endpoint})`);
+		const pr = await this.request(endpoint, {
+			method: isUpdate ? "PATCH" : "POST",
 			body: JSON.stringify(requestBody)
 		});
-		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
-		const pr = await res.json();
 		if (typeof pr !== "object" || pr === null || !("number" in pr) || typeof pr.number !== "number" || !("title" in pr) || typeof pr.title !== "string" || !("body" in pr) || typeof pr.body !== "string" || !("draft" in pr) || typeof pr.draft !== "boolean" || !("html_url" in pr) || typeof pr.html_url !== "string") throw new TypeError("Pull request data validation failed");
 		const action = isUpdate ? "Updated" : "Created";
 		logger.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
@@ -399,12 +632,32 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			draft: pr.draft,
 			html_url: pr.html_url
 		};
-	} catch (err) {
-		logger.error(`Error upserting pull request:`, err);
-		throw err;
 	}
+	async setCommitStatus({ sha, state, targetUrl, description, context }) {
+		const endpoint = `/repos/${this.owner}/${this.repo}/statuses/${sha}`;
+		logger.verbose(`Setting commit status on ${sha} to ${state} (url: ${this.apiBase}${endpoint})`);
+		await this.request(endpoint, {
+			method: "POST",
+			body: JSON.stringify({
+				state,
+				target_url: targetUrl,
+				description: description || "",
+				context
+			})
+		});
+		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;
+	}
+};
+function createGitHubClient(options) {
+	return new GitHubClient(options);
 }
-const defaultTemplate = dedent`
+const DEFAULT_PR_BODY_TEMPLATE = dedent`
   This PR was automatically generated by the release script.
 
   The following packages have been prepared for release:
@@ -427,7 +680,7 @@ function dedentString(str) {
 }
 function generatePullRequestBody(updates, body) {
 	const eta = new Eta();
-	const bodyTemplate = body ? dedentString(body) : defaultTemplate;
+	const bodyTemplate = body ? dedentString(body) : DEFAULT_PR_BODY_TEMPLATE;
 	return eta.renderString(bodyTemplate, { packages: updates.map((u) => ({
 		name: u.package.name,
 		currentVersion: u.currentVersion,
@@ -439,22 +692,6 @@ function generatePullRequestBody(updates, body) {
 
 //#endregion
 //#region src/versioning/commits.ts
-async function getLastPackageTag(packageName, workspaceRoot) {
-	try {
-		const { stdout } = await run("git", [
-			"tag",
-			"--list",
-			`${packageName}@*`
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return stdout.split("\n").map((tag) => tag.trim()).filter(Boolean).reverse()[0];
-	} catch (err) {
-		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
-		return;
-	}
-}
 function determineHighestBump(commits) {
 	if (commits.length === 0) return "none";
 	let highestBump = "none";
@@ -467,78 +704,33 @@ function determineHighestBump(commits) {
 	return highestBump;
 }
 /**
-* Retrieves commits that affect a specific workspace package since its last tag.
+* Get commits grouped by workspace package.
+* For each package, retrieves all commits since its last release tag that affect that package.
 *
-* @param {string} workspaceRoot - The root directory of the workspace.
-* @param {WorkspacePackage} pkg - The workspace package to analyze.
-* @returns {Promise<GitCommit[]>} A promise that resolves to an array of GitCommit objects affecting the package.
+* @param {string} workspaceRoot - The root directory of the workspace
+* @param {WorkspacePackage[]} packages - Array of workspace packages to analyze
+* @returns {Promise<Map<string, GitCommit[]>>} A map of package names to their commits since their last release
 */
-async function getCommitsForWorkspacePackage(workspaceRoot, pkg) {
-	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
-	const allCommits = getCommits({
-		from: lastTag,
-		to: "HEAD",
-		cwd: workspaceRoot
-	});
-	logger.verbose("Found commits for package", `${farver.cyan(allCommits.length)} for ${farver.bold(pkg.name)} since ${lastTag || "beginning"}`);
-	const commitsAffectingPackage = getCommits({
-		from: lastTag,
-		to: "HEAD",
-		cwd: workspaceRoot,
-		folder: pkg.path
-	});
-	const affectingCommitShas = /* @__PURE__ */ new Set();
-	for (const commit of commitsAffectingPackage) affectingCommitShas.add(commit.shortHash);
-	const packageCommits = allCommits.filter((commit) => {
-		return affectingCommitShas.has(commit.shortHash);
-	});
-	logger.verbose("Commits affect package", `${farver.cyan(packageCommits.length)} affect ${farver.bold(pkg.name)}`);
-	return packageCommits;
-}
-async function getWorkspacePackageCommits(workspaceRoot, packages) {
+async function getWorkspacePackageGroupedCommits(workspaceRoot, packages) {
 	const changedPackages = /* @__PURE__ */ new Map();
 	const promises = packages.map(async (pkg) => {
+		const lastTag = await getMostRecentPackageTag(workspaceRoot, pkg.name);
+		const allCommits = await getCommits({
+			from: lastTag,
+			to: "HEAD",
+			cwd: workspaceRoot,
+			folder: pkg.path
+		});
+		logger.verbose(`Found ${farver.cyan(allCommits.length)} commits for package ${farver.bold(pkg.name)} since tag ${farver.cyan(lastTag ?? "N/A")}`);
 		return {
 			pkgName: pkg.name,
-			commits: await getCommitsForWorkspacePackage(workspaceRoot, pkg)
+			commits: allCommits
 		};
 	});
 	const results = await Promise.all(promises);
 	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
 	return changedPackages;
 }
-async function getCommitFileList(workspaceRoot, from, to) {
-	const map = /* @__PURE__ */ new Map();
-	try {
-		const { stdout } = await run("git", [
-			"log",
-			"--name-only",
-			"--format=%H",
-			`${from}^..${to}`
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		const lines = stdout.trim().split("\n");
-		let currentSha = null;
-		for (const line of lines) {
-			const trimmedLine = line.trim();
-			if (trimmedLine === "") {
-				currentSha = null;
-				continue;
-			}
-			if (currentSha === null) {
-				currentSha = trimmedLine;
-				map.set(currentSha, []);
-				continue;
-			}
-			map.get(currentSha).push(trimmedLine);
-		}
-		return map;
-	} catch {
-		return null;
-	}
-}
 /**
 * Check if a file path touches any package folder.
 * @param file - The file path to check
@@ -556,15 +748,43 @@ function fileMatchesPackageFolder(file, packagePaths, workspaceRoot) {
 }
 /**
 * Check if a commit is a "global" commit (doesn't touch any package folder).
+* @param workspaceRoot - The workspace root
 * @param files - Array of files changed in the commit
 * @param packagePaths - Set of normalized package paths
-* @param workspaceRoot - The workspace root
 * @returns true if this is a global commit
 */
-function isGlobalCommit(files, packagePaths, workspaceRoot) {
+function isGlobalCommit(workspaceRoot, files, packagePaths) {
 	if (!files || files.length === 0) return false;
 	return !files.some((file) => fileMatchesPackageFolder(file, packagePaths, workspaceRoot));
 }
+const DEPENDENCY_FILES = [
+	"package.json",
+	"pnpm-lock.yaml",
+	"pnpm-workspace.yaml",
+	"yarn.lock",
+	"package-lock.json"
+];
+/**
+* Find the oldest and newest commits across all packages.
+* @param packageCommits - Map of package commits
+* @returns Object with oldest and newest commit SHAs, or null if no commits
+*/
+function findCommitRange(packageCommits) {
+	let oldestCommit = null;
+	let newestCommit = null;
+	for (const commits of packageCommits.values()) {
+		if (commits.length === 0) continue;
+		const firstCommit = commits[0].shortHash;
+		const lastCommit = commits[commits.length - 1].shortHash;
+		if (!newestCommit) newestCommit = firstCommit;
+		oldestCommit = lastCommit;
+	}
+	if (!oldestCommit || !newestCommit) return null;
+	return {
+		oldest: oldestCommit,
+		newest: newestCommit
+	};
+}
 /**
 * Get global commits for each package based on their individual commit timelines.
 * This solves the problem where packages with different release histories need different global commits.
@@ -587,18 +807,13 @@ async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPack
 		return result;
 	}
 	logger.verbose(`Computing global commits per-package (mode: ${farver.cyan(mode)})`);
-	let oldestCommit = null;
-	let newestCommit = null;
-	for (const commits of packageCommits.values()) if (commits.length > 0) {
-		if (!newestCommit) newestCommit = commits[0].shortHash;
-		oldestCommit = commits[commits.length - 1].shortHash;
-	}
-	if (!oldestCommit || !newestCommit) {
+	const commitRange = findCommitRange(packageCommits);
+	if (!commitRange) {
 		logger.verbose("No commits found across packages");
 		return result;
 	}
-	logger.verbose("Fetching files for commits range", `${farver.cyan(oldestCommit)}..${farver.cyan(newestCommit)}`);
-	const commitFilesMap = await getCommitFileList(workspaceRoot, oldestCommit, newestCommit);
+	logger.verbose("Fetching files for commits range", `${farver.cyan(commitRange.oldest)}..${farver.cyan(commitRange.newest)}`);
+	const commitFilesMap = await getGroupedFilesByCommitSha(workspaceRoot, commitRange.oldest, commitRange.newest);
 	if (!commitFilesMap) {
 		logger.warn("Failed to get commit file list, returning empty global commits");
 		return result;
@@ -606,34 +821,29 @@ async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPack
 	logger.verbose("Got file lists for commits", `${farver.cyan(commitFilesMap.size)} commits in ONE git call`);
 	const packagePaths = new Set(allPackages.map((p) => p.path));
 	for (const [pkgName, commits] of packageCommits) {
-		const globalCommitsForPackage = [];
+		const globalCommitsAffectingPackage = [];
 		logger.verbose("Filtering global commits for package", `${farver.bold(pkgName)} from ${farver.cyan(commits.length)} commits`);
-		for (const commit of commits) if (isGlobalCommit(commitFilesMap.get(commit.shortHash), packagePaths, workspaceRoot)) globalCommitsForPackage.push(commit);
-		logger.verbose("Package global commits found", `${farver.bold(pkgName)}: ${farver.cyan(globalCommitsForPackage.length)} global commits`);
-		if (mode === "all") result.set(pkgName, globalCommitsForPackage);
-		else if (mode === "dependencies") {
-			const dependencyCommits = [];
-			const dependencyFiles = [
-				"package.json",
-				"pnpm-lock.yaml",
-				"pnpm-workspace.yaml",
-				"yarn.lock",
-				"package-lock.json"
-			];
-			for (const commit of globalCommitsForPackage) {
-				const files = commitFilesMap.get(commit.shortHash);
-				if (!files) continue;
-				if (files.some((file) => {
-					const normalizedFile = file.startsWith("./") ? file.slice(2) : file;
-					return dependencyFiles.includes(normalizedFile);
-				})) {
-					logger.verbose("Global commit affects dependencies", `${farver.bold(pkgName)}: commit ${farver.cyan(commit.shortHash)} affects dependencies`);
-					dependencyCommits.push(commit);
-				}
+		for (const commit of commits) {
+			const files = commitFilesMap.get(commit.shortHash);
+			if (!files) continue;
+			if (isGlobalCommit(workspaceRoot, files, packagePaths)) globalCommitsAffectingPackage.push(commit);
+		}
+		logger.verbose("Package global commits found", `${farver.bold(pkgName)}: ${farver.cyan(globalCommitsAffectingPackage.length)} global commits`);
+		if (mode === "all") {
+			result.set(pkgName, globalCommitsAffectingPackage);
+			continue;
+		}
+		const dependencyCommits = [];
+		for (const commit of globalCommitsAffectingPackage) {
+			const files = commitFilesMap.get(commit.shortHash);
+			if (!files) continue;
+			if (files.some((file) => DEPENDENCY_FILES.includes(file.startsWith("./") ? file.slice(2) : file))) {
+				logger.verbose("Global commit affects dependencies", `${farver.bold(pkgName)}: commit ${farver.cyan(commit.shortHash)} affects dependencies`);
+				dependencyCommits.push(commit);
 			}
-			logger.verbose("Global commits affect dependencies", `${farver.bold(pkgName)}: ${farver.cyan(dependencyCommits.length)} global commits affect dependencies`);
-			result.set(pkgName, dependencyCommits);
 		}
+		logger.verbose("Global commits affect dependencies", `${farver.bold(pkgName)}: ${farver.cyan(dependencyCommits.length)} global commits affect dependencies`);
+		result.set(pkgName, dependencyCommits);
 	}
 	return result;
 }
@@ -818,7 +1028,7 @@ function formatCommitsForDisplay(commits) {
 	const commitsToShow = commits.slice(0, maxCommitsToShow);
 	const hasMore = commits.length > maxCommitsToShow;
 	const typeLength = commits.map(({ type }) => type.length).reduce((a, b) => Math.max(a, b), 0);
-	const scopeLength = commits.map(({ scope }) => scope.length).reduce((a, b) => Math.max(a, b), 0);
+	const scopeLength = commits.map(({ scope }) => scope?.length).reduce((a, b) => Math.max(a || 0, b || 0), 0) || 0;
 	const formattedCommits = commitsToShow.map((commit) => {
 		let color = messageColorMap[commit.type] || ((c) => c);
 		if (commit.isBreaking) color = (s) => farver.inverse.red(s);
@@ -866,7 +1076,7 @@ async function calculateVersionUpdates({ workspacePackages, packageCommits, work
 			if (selectedVersion === null) continue;
 			newVersion = selectedVersion;
 		}
-		logger.item(`Version update: ${pkg.version} → ${newVersion}`);
+		logger.verbose(`Version update: ${pkg.version} → ${newVersion}`);
 		versionUpdates.push({
 			package: pkg,
 			currentVersion: pkg.version,
@@ -923,35 +1133,24 @@ async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
 	const content = await readFile(packageJsonPath, "utf-8");
 	const packageJson = JSON.parse(content);
 	packageJson.version = newVersion;
-	for (const [depName, depVersion] of dependencyUpdates) {
-		if (packageJson.dependencies?.[depName]) {
-			const oldVersion = packageJson.dependencies[depName];
-			if (oldVersion === "workspace:*") {
-				logger.verbose(`  - Skipping workspace:* dependency: ${depName}`);
-				continue;
-			}
-			packageJson.dependencies[depName] = `^${depVersion}`;
-			logger.verbose(`  - Updated dependency ${depName}: ${oldVersion} → ^${depVersion}`);
-		}
-		if (packageJson.devDependencies?.[depName]) {
-			const oldVersion = packageJson.devDependencies[depName];
-			if (oldVersion === "workspace:*") {
-				logger.verbose(`  - Skipping workspace:* devDependency: ${depName}`);
-				continue;
-			}
-			packageJson.devDependencies[depName] = `^${depVersion}`;
-			logger.verbose(`  - Updated devDependency ${depName}: ${oldVersion} → ^${depVersion}`);
+	function updateDependency(deps, depName, depVersion, isPeerDependency = false) {
+		if (!deps) return;
+		const oldVersion = deps[depName];
+		if (!oldVersion) return;
+		if (oldVersion === "workspace:*") {
+			logger.verbose(`  - Skipping workspace:* dependency: ${depName}`);
+			return;
 		}
-		if (packageJson.peerDependencies?.[depName]) {
-			const oldVersion = packageJson.peerDependencies[depName];
-			if (oldVersion === "workspace:*") {
-				logger.verbose(`  - Skipping workspace:* peerDependency: ${depName}`);
-				continue;
-			}
+		if (isPeerDependency) {
 			const majorVersion = depVersion.split(".")[0];
-			packageJson.peerDependencies[depName] = `>=${depVersion} <${Number(majorVersion) + 1}.0.0`;
-			logger.verbose(`  - Updated peerDependency ${depName}: ${oldVersion} → ^${depVersion}`);
-		}
+			deps[depName] = `>=${depVersion} <${Number(majorVersion) + 1}.0.0`;
+		} else deps[depName] = `^${depVersion}`;
+		logger.verbose(`  - Updated dependency ${depName}: ${oldVersion} → ${deps[depName]}`);
+	}
+	for (const [depName, depVersion] of dependencyUpdates) {
+		updateDependency(packageJson.dependencies, depName, depVersion);
+		updateDependency(packageJson.devDependencies, depName, depVersion);
+		updateDependency(packageJson.peerDependencies, depName, depVersion, true);
 	}
 	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
 	logger.verbose(`  - Successfully wrote updated package.json`);
@@ -1123,6 +1322,84 @@ function shouldIncludePackage(pkg, options) {
 	return true;
 }
 
+//#endregion
+//#region src/shared/options.ts
+const DEFAULT_COMMIT_GROUPS = [
+	{
+		name: "features",
+		title: "Features",
+		types: ["feat"]
+	},
+	{
+		name: "fixes",
+		title: "Bug Fixes",
+		types: ["fix", "perf"]
+	},
+	{
+		name: "refactor",
+		title: "Refactoring",
+		types: ["refactor"]
+	},
+	{
+		name: "docs",
+		title: "Documentation",
+		types: ["docs"]
+	}
+];
+function normalizeSharedOptions(options) {
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, prompts: prompts$1 = {
+		packages: true,
+		versions: true
+	}, groups = DEFAULT_COMMIT_GROUPS } = options;
+	if (!githubToken.trim()) exitWithError("GitHub token is required", "Set GITHUB_TOKEN environment variable or pass it in options");
+	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) exitWithError("Repository (repo) is required", "Specify the repository in 'owner/repo' format (e.g., 'octocat/hello-world')");
+	const [owner, repo] = fullRepo.split("/");
+	if (!owner || !repo) exitWithError(`Invalid repo format: "${fullRepo}"`, "Expected format: \"owner/repo\" (e.g., \"octocat/hello-world\")");
+	return {
+		packages: typeof packages === "object" && !Array.isArray(packages) ? {
+			exclude: packages.exclude ?? [],
+			include: packages.include ?? [],
+			excludePrivate: packages.excludePrivate ?? false
+		} : packages,
+		prompts: {
+			packages: prompts$1?.packages ?? true,
+			versions: prompts$1?.versions ?? true
+		},
+		workspaceRoot,
+		githubToken,
+		owner,
+		repo,
+		groups
+	};
+}
+async function normalizeReleaseOptions(options) {
+	const normalized = normalizeSharedOptions(options);
+	let defaultBranch = options.branch?.default?.trim();
+	const releaseBranch = options.branch?.release?.trim() ?? "release/next";
+	if (defaultBranch == null || defaultBranch === "") {
+		defaultBranch = await getDefaultBranch(normalized.workspaceRoot);
+		if (!defaultBranch) exitWithError("Could not determine default branch", "Please specify the default branch in options");
+	}
+	if (defaultBranch === releaseBranch) exitWithError(`Default branch and release branch cannot be the same: "${defaultBranch}"`, "Specify different branches for default and release");
+	const availableBranches = await getAvailableBranches(normalized.workspaceRoot);
+	if (!availableBranches.includes(defaultBranch)) exitWithError(`Default branch "${defaultBranch}" does not exist in the repository`, `Available branches: ${availableBranches.join(", ")}`);
+	logger.verbose(`Using default branch: ${farver.green(defaultBranch)}`);
+	return {
+		...normalized,
+		branch: {
+			release: releaseBranch,
+			default: defaultBranch
+		},
+		safeguards: options.safeguards ?? true,
+		globalCommitMode: options.globalCommitMode ?? "dependencies",
+		pullRequest: {
+			title: options.pullRequest?.title ?? "chore: release new version",
+			body: options.pullRequest?.body ?? DEFAULT_PR_BODY_TEMPLATE
+		},
+		changelog: { enabled: options.changelog?.enabled ?? true }
+	};
+}
+
 //#endregion
 //#region src/release.ts
 async function release(options) {
@@ -1140,11 +1417,11 @@ async function release(options) {
 		logger.item(`  ${farver.gray("→")} ${farver.gray(pkg.path)}`);
 	}
 	logger.emptyLine();
-	const packageCommits = await getWorkspacePackageCommits(workspaceRoot, workspacePackages);
-	const globalCommitsPerPackage = await getGlobalCommitsPerPackage(workspaceRoot, packageCommits, workspacePackages, normalizedOptions.globalCommitMode);
+	const groupedPackageCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
+	const globalCommitsPerPackage = await getGlobalCommitsPerPackage(workspaceRoot, groupedPackageCommits, workspacePackages, normalizedOptions.globalCommitMode);
 	const { allUpdates, applyUpdates } = await calculateAndPrepareVersionUpdates({
 		workspacePackages,
-		packageCommits,
+		packageCommits: groupedPackageCommits,
 		workspaceRoot,
 		showPrompt: options.prompts?.versions !== false,
 		globalCommitsPerPackage
@@ -1153,11 +1430,14 @@ async function release(options) {
 	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 prOps = await orchestrateReleasePullRequest({
-		workspaceRoot,
+	const githubClient = createGitHubClient({
 		owner: normalizedOptions.owner,
 		repo: normalizedOptions.repo,
-		githubToken: normalizedOptions.githubToken,
+		githubToken: normalizedOptions.githubToken
+	});
+	const prOps = await orchestrateReleasePullRequest({
+		workspaceRoot,
+		githubClient,
 		releaseBranch: normalizedOptions.branch.release,
 		defaultBranch: normalizedOptions.branch.default,
 		pullRequestTitle: options.pullRequest?.title,
@@ -1165,12 +1445,41 @@ async function release(options) {
 	});
 	await prOps.prepareBranch();
 	await applyUpdates();
+	if (normalizedOptions.changelog.enabled) {
+		logger.step("Updating changelogs");
+		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: {
+					...normalizedOptions,
+					workspaceRoot
+				},
+				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]
+			});
+		}).filter((p) => p != null);
+		const updates = await Promise.all(changelogPromises);
+		logger.success(`Updated ${updates.length} changelog(s)`);
+	}
 	if (!await prOps.syncChanges(true)) if (prOps.doesReleasePRExist && prOps.existingPullRequest) {
 		logger.item("No updates needed, PR is already up to date");
+		const { pullRequest: pullRequest$1, created: created$1 } = await prOps.syncPullRequest(allUpdates);
+		await prOps.cleanup();
 		return {
 			updates: allUpdates,
-			prUrl: prOps.existingPullRequest.html_url,
-			created: false
+			prUrl: pullRequest$1?.html_url,
+			created: created$1
 		};
 	} else {
 		logger.error("No changes to commit, and no existing PR. Nothing to do.");
@@ -1188,39 +1497,10 @@ async function release(options) {
 		created
 	};
 }
-async function normalizeReleaseOptions(options) {
-	const normalized = normalizeSharedOptions(options);
-	let defaultBranch = options.branch?.default?.trim();
-	const releaseBranch = options.branch?.release?.trim() ?? "release/next";
-	if (defaultBranch == null || defaultBranch === "") {
-		defaultBranch = await getDefaultBranch(normalized.workspaceRoot);
-		if (!defaultBranch) exitWithError("Could not determine default branch", "Please specify the default branch in options");
-	}
-	if (defaultBranch === releaseBranch) exitWithError(`Default branch and release branch cannot be the same: "${defaultBranch}"`, "Specify different branches for default and release");
-	const availableBranches = await getAvailableBranches(normalized.workspaceRoot);
-	if (!availableBranches.includes(defaultBranch)) exitWithError(`Default branch "${defaultBranch}" does not exist in the repository`, `Available branches: ${availableBranches.join(", ")}`);
-	logger.verbose(`Using default branch: ${farver.green(defaultBranch)}`);
-	return {
-		...normalized,
-		branch: {
-			release: releaseBranch,
-			default: defaultBranch
-		},
-		safeguards: options.safeguards ?? true,
-		globalCommitMode: options.globalCommitMode ?? "dependencies",
-		pullRequest: options.pullRequest,
-		changelog: { enabled: options.changelog?.enabled ?? true }
-	};
-}
-async function orchestrateReleasePullRequest({ workspaceRoot, owner, repo, githubToken, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody }) {
+async function orchestrateReleasePullRequest({ workspaceRoot, githubClient, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody }) {
 	const currentBranch = await getCurrentBranch(workspaceRoot);
 	if (currentBranch !== defaultBranch) exitWithError(`Current branch is '${currentBranch}'. Please switch to the default branch '${defaultBranch}' before proceeding.`, `git checkout ${defaultBranch}`);
-	const existingPullRequest = await getExistingPullRequest({
-		owner,
-		repo,
-		branch: releaseBranch,
-		githubToken
-	});
+	const existingPullRequest = await githubClient.getExistingPullRequest(releaseBranch);
 	const doesReleasePRExist = !!existingPullRequest;
 	if (doesReleasePRExist) logger.item("Found existing release pull request");
 	else logger.item("Will create new pull request");
@@ -1244,7 +1524,6 @@ async function orchestrateReleasePullRequest({ workspaceRoot, owner, repo, githu
 			const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
 			if (!hasCommitted && !isBranchAhead) {
 				logger.item("No changes to commit and branch is in sync with remote");
-				await checkoutBranch(defaultBranch, workspaceRoot);
 				return false;
 			}
 			logger.step("Pushing changes to remote");
@@ -1253,16 +1532,13 @@ async function orchestrateReleasePullRequest({ workspaceRoot, owner, repo, githu
 		},
 		async syncPullRequest(updates) {
 			const prTitle = existingPullRequest?.title || pullRequestTitle || "chore: update package versions";
-			const prBody = pullRequestBody || generatePullRequestBody(updates);
-			const pullRequest = await upsertPullRequest({
-				owner,
-				repo,
+			const prBody = generatePullRequestBody(updates, pullRequestBody);
+			const pullRequest = await githubClient.upsertPullRequest({
 				pullNumber: existingPullRequest?.number,
 				title: prTitle,
 				body: prBody,
 				head: releaseBranch,
-				base: defaultBranch,
-				githubToken
+				base: defaultBranch
 			});
 			logger.success(`${doesReleasePRExist ? "Updated" : "Created"} pull request: ${pullRequest?.html_url}`);
 			return {
@@ -1277,4 +1553,8 @@ async function orchestrateReleasePullRequest({ workspaceRoot, owner, repo, githu
 }
 
 //#endregion
-export { publish, release };
+//#region src/verify.ts
+function verify(_options) {}
+
+//#endregion
+export { publish, release, verify };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.14",
+  "version": "0.1.0-beta.16",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",
@@ -13,7 +13,8 @@
     "#versioning/*": "./src/versioning/*.ts",
     "#shared/*": "./src/shared/*.ts",
     "#release": "./src/release.ts",
-    "#publish": "./src/publish.ts"
+    "#publish": "./src/publish.ts",
+    "#verify": "./src/verify.ts"
   },
   "exports": {
     ".": "./dist/index.mjs",
@@ -27,7 +28,7 @@
   ],
   "dependencies": {
     "@luxass/utils": "2.7.2",
-    "commit-parser": "0.4.5",
+    "commit-parser": "1.3.0",
     "farver": "1.0.0-beta.1",
     "mri": "1.2.0",
     "prompts": "2.4.2",
@@ -41,7 +42,8 @@
     "eta": "4.0.1",
     "tsdown": "0.16.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.4"
+    "vitest": "4.0.4",
+    "vitest-testdirs": "4.3.0"
   },
   "scripts": {
     "build": "tsdown",