keepchanges 0.0.2 → 1.0.0-beta.1

package/dist/cli.mjs

@@ -1,107 +1,14 @@
 #!/usr/bin/env node
-import { realpathSync } from "node:fs";
+import { a as insertRelease, c as defaultConfig, i as hasRelease, n as parseCommits, o as readChangelog, r as generateChangelog, s as writeChangelog } from "./commit-FX77u6Sj.mjs";
+import { readFile, writeFile } from "node:fs/promises";
+import { normalizeFull } from "verkit";
 import process from "node:process";
-import { fileURLToPath } from "node:url";
 import { cac } from "cac";
 import { resolve } from "node:path";
 import ansis from "ansis";
-import { readFile, writeFile } from "node:fs/promises";
-import { normalizeFull } from "verkit";
 import { x } from "tinyexec";
 //#region package.json
-var version = "0.0.2";
-//#endregion
-//#region src/changelog.ts
-function createChangelog(version, commits, repository, comparisonFrom) {
-	const body = [
-		...renderSection(commits.filter((commit) => commit.isBreaking), "🚨 Breaking Changes", repository),
-		...renderSection(commits.filter((commit) => !commit.isBreaking && commit.type === "feat"), "🚀 Features", repository),
-		...renderSection(commits.filter((commit) => !commit.isBreaking && commit.type === "fix"), "🐞 Bug Fixes", repository),
-		...repository && comparisonFrom ? ["", `#####     [View changes on ${repository.provider.name}](${repository.provider.compareUrl(repository, comparisonFrom, `v${version}`)})`] : []
-	].join("\n").trim();
-	return {
-		body,
-		release: [
-			`## v${version}`,
-			"",
-			body,
-			""
-		].join("\n")
-	};
-}
-async function readChangelog(path) {
-	return readFile(path, "utf8").catch((error) => {
-		if (error.code === "ENOENT") return "# Changelog\n";
-		throw error;
-	});
-}
-function writeChangelog(path, changelog) {
-	return writeFile(path, changelog);
-}
-function hasRelease(changelog, version) {
-	const releaseVersion = normalizeFull(version);
-	return releaseHeadings(changelog).some((heading) => heading.version === releaseVersion);
-}
-function insertRelease(changelog, release) {
-	const releaseVersion = releaseHeadings(release)[0]?.version;
-	const headings = releaseHeadings(changelog);
-	const existingReleaseIndex = headings.findIndex((heading) => heading.version === releaseVersion);
-	if (existingReleaseIndex !== -1) {
-		const start = headings[existingReleaseIndex].index;
-		const end = headings[existingReleaseIndex + 1]?.index ?? changelog.length;
-		changelog = changelog.slice(0, start) + changelog.slice(end);
-	}
-	const firstRelease = releaseHeadings(changelog)[0];
-	if (!firstRelease) return `${changelog.trimEnd()}\n\n${release.trim()}\n`;
-	const preamble = changelog.slice(0, firstRelease.index).trimEnd();
-	const history = changelog.slice(firstRelease.index).trim();
-	return `${preamble}\n\n${release.trim()}\n\n${history}\n`;
-}
-function releaseHeadings(changelog) {
-	return [...changelog.matchAll(/^##\s+(\S+).*$/gm)].flatMap((heading) => {
-		const version = normalizeFull(heading[1]);
-		return version ? [{
-			index: heading.index,
-			version
-		}] : [];
-	});
-}
-function renderSection(commits, title, repository) {
-	const lines = commits.map((commit) => {
-		const scope = commit.scope ? `**${escapeHtml(commit.scope)}**: ` : "";
-		const reference = repository ? `[<samp>(${commit.hash.slice(0, 5)})</samp>](${repository.provider.commitUrl(repository, commit.hash)})` : "";
-		const authorNames = commit.authors.map((author) => author.login ? `@${author.login}` : `**${escapeHtml(author.name)}**`);
-		const authors = authorNames.length > 1 ? `${authorNames.slice(0, -1).join(", ")} and ${authorNames.at(-1)}` : authorNames[0] || "";
-		const pullRequests = commit.pullRequests.map((pullRequest) => repository ? `[${pullRequest}](${repository.provider.pullRequestUrl(repository, pullRequest)})` : pullRequest).join(", ");
-		const details = [
-			authors ? `by ${authors}` : "",
-			pullRequests ? `in ${pullRequests}` : "",
-			reference
-		].filter(Boolean).join(" ");
-		const suffix = details ? ` &nbsp;-&nbsp; ${details}` : "";
-		return `${scope}${escapeHtml(capitalize$1(commit.description))}${suffix}`;
-	}).reverse();
-	if (!lines.length) return [];
-	return [
-		"",
-		`### ${title}`,
-		"",
-		...lines.map((line) => `- ${line}`)
-	];
-}
-function capitalize$1(value) {
-	return value.charAt(0).toUpperCase() + value.slice(1);
-}
-function escapeHtml(value) {
-	const htmlEntities = {
-		"&": "&amp;",
-		"<": "&lt;",
-		">": "&gt;",
-		"\"": "&quot;",
-		"'": "&#39;"
-	};
-	return value.replace(/[&<>"']/g, (character) => htmlEntities[character]);
-}
+var version = "1.0.0-beta.1";
 //#endregion
 //#region src/git.ts
 async function git(cwd, ...args) {
@@ -130,11 +37,8 @@ async function getRemoteTagCommit(cwd, tag) {
 	const refs = (await git(cwd, "ls-remote", "--tags", "origin", `refs/tags/${tag}`, `refs/tags/${tag}^{}`)).trim().split("\n").filter(Boolean);
 	return (refs.find((line) => line.endsWith("^{}")) || refs[0])?.split(/\s+/)[0];
 }
-async function readCommits(cwd, from, to) {
-	return parseGitLog(await git(cwd, "log", from ? `${from}..${to}` : to, "--format=%h%x00%an%x00%ae%x00%s%x00%b%x00")).map((commit) => parseCommit(commit.hash, commit.subject, commit.body, commit.author)).filter((commit) => commit !== null);
-}
-function parseGitLog(log) {
-	const fields = log.split("\0");
+async function readGitCommits(cwd, from, to) {
+	const fields = (await git(cwd, "log", from ? `${from}..${to}` : to, "--format=%h%x00%an%x00%ae%x00%s%x00%b%x00")).split("\0");
 	const commits = [];
 	for (let index = 0; index + 4 < fields.length; index += 5) {
 		const subject = fields[index + 3].trim();
@@ -150,38 +54,100 @@ function parseGitLog(log) {
 	}
 	return commits;
 }
-function parseCommit(hash, subject, body, author) {
-	const match = /^(?<type>[a-z]+)(?:\((?<scope>[^()\r\n]+)\))?(?<breaking>!)?: (?<description>.+)$/i.exec(subject);
-	if (!match?.groups) return null;
-	const pullRequestPattern = /\([ a-z]*(#\d+)\s*\)/gi;
-	const pullRequests = [...new Set([...match.groups.description.matchAll(pullRequestPattern)].map((reference) => reference[1]))];
-	const authors = [author];
-	for (const coAuthor of body.matchAll(/^Co-Authored-By:\s*(.+?)\s*<([^>]+)>$/gim)) {
-		const email = coAuthor[2].trim();
-		if (!authors.some((author) => author.email === email)) authors.push({
-			name: coAuthor[1].trim(),
-			email
+//#endregion
+//#region src/repositories/gitea.ts
+const giteaRepository = {
+	name: "Gitea",
+	parse(source) {
+		try {
+			const url = new URL(source.replace(/^git\+/, ""));
+			if (!/^https?:$/.test(url.protocol)) return;
+			const path = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+			if (!path.includes("/")) return;
+			return {
+				provider: giteaRepository,
+				path,
+				webUrl: `${url.origin}/${path}`
+			};
+		} catch {}
+	},
+	token(explicit, env) {
+		return explicit || env.GITEA_TOKEN;
+	},
+	commitUrl(repository, hash) {
+		return `${repository.webUrl}/commit/${hash}`;
+	},
+	pullRequestUrl(repository, reference) {
+		return `${repository.webUrl}/pulls/${reference.replace(/^#/, "")}`;
+	},
+	compareUrl(repository, from, to) {
+		return `${repository.webUrl}/compare/${from}...${to}`;
+	},
+	manualReleaseUrl(repository, release) {
+		const url = new URL(`${repository.webUrl}/releases/new`);
+		url.search = new URLSearchParams({ tag: release.tag }).toString();
+		return url.toString();
+	},
+	async resolveAuthors(commits, repository, token, fetch) {
+		const headers = {
+			accept: "application/json",
+			authorization: `token ${token}`
+		};
+		const commitsByEmail = new Map(commits.flatMap((commit) => commit.authors[0] ? [[commit.authors[0].email, commit]] : []));
+		const loginsByEmail = /* @__PURE__ */ new Map();
+		await Promise.all([...commitsByEmail].map(async ([email, commit]) => {
+			try {
+				const response = await fetch(`${new URL(repository.webUrl).origin}/api/v1/repos/${repository.path}/git/commits/${commit.hash}`, { headers });
+				if (!response.ok) return;
+				const data = await response.json();
+				if (data.author?.login) loginsByEmail.set(email, data.author.login);
+			} catch {}
+		}));
+		for (const commit of commits) for (const author of commit.authors) author.login = loginsByEmail.get(author.email);
+	},
+	async publishRelease(repository, release, token, fetch) {
+		const headers = {
+			"accept": "application/json",
+			"authorization": `token ${token}`,
+			"content-type": "application/json"
+		};
+		const releasesUrl = `${new URL(repository.webUrl).origin}/api/v1/repos/${repository.path}/releases`;
+		const existing = await fetch(`${releasesUrl}/tags/${encodeURIComponent(release.tag)}`, { headers });
+		let url = releasesUrl;
+		let method = "POST";
+		let action = "created";
+		if (existing.ok) {
+			url = `${releasesUrl}/${(await existing.json()).id}`;
+			method = "PATCH";
+			action = "updated";
+		} else if (existing.status !== 404) throw new Error(`Gitea release lookup failed (${existing.status})`);
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: JSON.stringify({
+				tag_name: release.tag,
+				name: release.name,
+				body: release.body,
+				prerelease: release.prerelease,
+				draft: release.draft
+			})
 		});
+		if (!response.ok) throw new Error(`Gitea release publishing failed (${response.status})`);
+		return {
+			url: (await response.json()).html_url,
+			action
+		};
 	}
-	return {
-		hash,
-		authors: authors.filter((author) => !/\[bot\]|dependabot|\(bot\)/i.test(author.name)),
-		type: match.groups.type.toLowerCase(),
-		scope: match.groups.scope || "",
-		description: match.groups.description.replace(pullRequestPattern, "").trim(),
-		pullRequests,
-		isBreaking: Boolean(match.groups.breaking) || /^BREAKING(?: |-)CHANGE:/im.test(body)
-	};
-}
+};
 //#endregion
-//#region src/providers/github.ts
-const githubProvider = {
+//#region src/repositories/github.ts
+const githubRepository = {
 	name: "GitHub",
 	parse(source) {
 		const match = /github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/.exec(source);
 		if (!match) return;
 		return {
-			provider: githubProvider,
+			provider: githubRepository,
 			path: match[1],
 			webUrl: `https://github.com/${match[1]}`
 		};
@@ -225,8 +191,8 @@ const githubProvider = {
 	},
 	async publishRelease(repository, release, token, fetch) {
 		const headers = {
-			accept: "application/vnd.github+json",
-			authorization: `Bearer ${token}`,
+			"accept": "application/vnd.github+json",
+			"authorization": `Bearer ${token}`,
 			"content-type": "application/json"
 		};
 		const releasesUrl = `https://api.github.com/repos/${repository.path}/releases`;
@@ -246,7 +212,8 @@ const githubProvider = {
 				tag_name: release.tag,
 				name: release.name,
 				body: release.body,
-				prerelease: release.prerelease
+				prerelease: release.prerelease,
+				draft: release.draft
 			})
 		});
 		if (!response.ok) throw new Error(`GitHub release publishing failed (${response.status})`);
@@ -258,18 +225,28 @@ const githubProvider = {
 };
 //#endregion
 //#region src/repository.ts
-const providers$1 = [githubProvider];
-async function resolveRepository(cwd) {
+const repositoryProviders = {
+	github: githubRepository,
+	gitea: giteaRepository
+};
+async function resolveRepository(cwd, explicit) {
+	if (explicit) {
+		const repository = parseRepository(/^[^/:]+\/[^/]+$/.test(explicit) ? `https://github.com/${explicit}` : explicit, Object.values(repositoryProviders));
+		if (!repository) throw new Error(`Unsupported repository: ${explicit}`);
+		return repository;
+	}
+	let providerName = "";
 	let source = await readFile(resolve(cwd, "package.json"), "utf8").then((contents) => {
 		const repository = JSON.parse(contents).repository;
+		if (typeof repository === "object") providerName = repository?.provider?.toLowerCase() || "";
 		return typeof repository === "string" ? repository : repository?.url || "";
 	}).catch(() => "");
-	if (!source) source = (await x("git", [
-		"remote",
-		"get-url",
-		"origin"
-	], { nodeOptions: { cwd } })).stdout.trim();
-	for (const provider of providers$1) {
+	if (!source) source = await git(cwd, "remote", "get-url", "origin").then((output) => output.trim()).catch(() => "");
+	if (providerName) return repositoryProviders[providerName]?.parse(source);
+	return parseRepository(source, [githubRepository]);
+}
+function parseRepository(source, providers) {
+	for (const provider of providers) {
 		const repository = provider.parse(source);
 		if (repository) return repository;
 	}
@@ -298,22 +275,41 @@ async function updateVersion(cwd, version) {
 	}
 }
 //#endregion
-//#region src/run.ts
-const defaultAuthor = "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>";
-async function runChangelog(options, environment) {
-	const { version: version$1 } = options;
-	const tag = `v${version$1}`;
-	const gitIdentity = options.commit || options.release ? resolveGitIdentity(options.author) : [];
+//#region src/cli/output.ts
+function printChangesPreview(preview, stdout, colors) {
+	stdout([
+		colors.dim(`keep${colors.bold("changes")} v${version}`),
+		`${colors.cyan(preview.from)}${colors.dim(" -> ")}${colors.blue(preview.tag)}${colors.dim(` (${preview.commitCount} commits)`)}`,
+		colors.dim("--------------"),
+		"",
+		preview.body.replaceAll("&nbsp;", ""),
+		"",
+		colors.dim("--------------"),
+		""
+	].join("\n"));
+}
+function printManualReleaseUrl(repository, release, stdout, colors) {
+	const url = repository.provider.manualReleaseUrl?.(repository, release);
+	if (url) stdout(`${colors.yellow("Using the following link to create it manually:")}\n${colors.yellow(url)}\n`);
+}
+function printPublishedRelease(provider, result, stdout, colors) {
+	const action = result.action.charAt(0).toUpperCase() + result.action.slice(1);
+	stdout(`${colors.green(`${action} ${provider} release: ${result.url}`)}\n`);
+}
+//#endregion
+//#region src/cli/createChanges.ts
+async function createChanges(options, environment) {
+	if (options.commit && options.to !== defaultConfig.cli.to) {
+		const [toCommit, headCommit] = await Promise.all([git(environment.cwd, "rev-parse", options.to).then((value) => value.trim()), git(environment.cwd, "rev-parse", "HEAD").then((value) => value.trim())]);
+		if (toCommit !== headCommit) throw new Error("--to must resolve to HEAD when used with --commit");
+	}
 	const env = environment.env ?? process.env;
 	const stdout = environment.stdout ?? ((value) => process.stdout.write(value));
 	const colors = environment.colors ?? ansis;
-	const latestTag = await getLatestTag(environment.cwd);
-	const repository = await resolveRepository(environment.cwd);
+	const tag = `v${options.version}`;
+	const repository = await resolveRepository(environment.cwd, options.repository);
 	const token = repository?.provider.token(options.token, env);
-	if (options.release) {
-		if (!repository) throw new Error("A supported repository is required to release");
-		if (!repository.provider.publishRelease && !repository.provider.manualReleaseUrl) throw new Error(`${repository.provider.name} does not support releases`);
-	}
+	validateReleaseSupport(options, repository);
 	let taggedCommit = options.release ? await getTagCommit(environment.cwd, tag) : void 0;
 	let releaseRef = taggedCommit ? tag : void 0;
 	const remoteTaggedCommit = options.release ? await getRemoteTagCommit(environment.cwd, tag) : void 0;
@@ -326,85 +322,89 @@ async function runChangelog(options, environment) {
 		taggedCommit = await getTagCommit(environment.cwd, tag);
 		releaseRef = tag;
 	}
-	const from = taggedCommit ? await getPreviousTag(environment.cwd, tag, releaseRef) : latestTag;
-	const to = releaseRef || "HEAD";
-	const comparisonFrom = from || (repository ? (await git(environment.cwd, "rev-list", "--max-parents=0", to)).trim() : "");
-	const commits = await readCommits(environment.cwd, from, to);
+	const from = options.from ?? (taggedCommit ? await getPreviousTag(environment.cwd, tag, releaseRef) : await getLatestTag(environment.cwd));
+	const to = releaseRef || options.to;
+	const comparisonFrom = from || (repository ? await git(environment.cwd, "rev-list", "--max-parents=0", to).then((value) => value.trim()) : "");
+	const commits = parseCommits(await readGitCommits(environment.cwd, from, to));
 	if (token && repository && !(options.release && options.dry)) await repository.provider.resolveAuthors?.(commits, repository, token, environment.fetch ?? globalThis.fetch);
-	const { body: releaseBody, release } = createChangelog(version$1, commits, repository, comparisonFrom);
+	const style = {
+		emoji: options.emoji,
+		capitalize: options.capitalize,
+		group: options.group
+	};
+	const { body, release } = generateChangelog({
+		version: options.version,
+		commits,
+		repository,
+		comparisonFrom
+	}, style);
 	const repositoryRelease = {
 		tag,
-		name: tag,
-		body: releaseBody,
-		prerelease: version$1.includes("-")
-	};
-	const printReleasePreview = () => {
-		stdout([
-			colors.dim(`keep${colors.bold("changes")} v${version}`),
-			`${colors.cyan(from || comparisonFrom)}${colors.dim(" -> ")}${colors.blue(tag)}${colors.dim(` (${commits.length} commits)`)}`,
-			colors.dim("--------------"),
-			"",
-			releaseBody.replaceAll("&nbsp;", ""),
-			"",
-			colors.dim("--------------"),
-			""
-		].join("\n"));
-	};
-	const printManualReleaseUrl = () => {
-		const url = repository.provider.manualReleaseUrl?.(repository, repositoryRelease);
-		if (url) stdout(`${colors.yellow("Using the following link to create it manually:")}\n${colors.yellow(url)}\n`);
-		return url;
+		name: options.name ?? tag,
+		body,
+		prerelease: options.prerelease ?? options.version.includes("-"),
+		draft: options.draft
 	};
-	const publishRepositoryRelease = async () => {
-		printReleasePreview();
-		if (!token || !repository.provider.publishRelease) {
-			if (!repository.provider.manualReleaseUrl) throw new Error("A repository token is required to release");
-			stdout(`${colors.red(`No ${repository.provider.name} token found, specify it via GITHUB_TOKEN env. Release skipped.`)}\n\n`);
-			printManualReleaseUrl();
-			return;
-		}
-		const result = await repository.provider.publishRelease(repository, repositoryRelease, token, environment.fetch ?? globalThis.fetch);
-		stdout(`${colors.green(`${capitalize(result.action)} ${repository.provider.name} release: ${result.url}`)}\n`);
+	const preview = {
+		from: from || comparisonFrom,
+		tag,
+		commitCount: commits.length,
+		body
 	};
-	const outputPath = resolve(environment.cwd, options.output || "CHANGELOG.md");
-	const currentChangelog = await readChangelog(outputPath);
-	const releaseExists = hasRelease(currentChangelog, version$1);
-	const changelog = insertRelease(currentChangelog, release);
 	if (options.dry) {
+		printChangesPreview(preview, stdout, colors);
 		if (options.release) {
-			printReleasePreview();
 			stdout(`${colors.yellow("Dry run. Release skipped.")}\n\n`);
-			printManualReleaseUrl();
-		} else stdout(changelog);
+			printManualReleaseUrl(repository, repositoryRelease, stdout, colors);
+		}
 		return;
 	}
 	if (options.release && taggedCommit) {
 		if (!remoteTaggedCommit) await git(environment.cwd, "push", "origin", `refs/tags/${tag}`);
-		await publishRepositoryRelease();
+		await publishRelease(repository, repositoryRelease, token, preview, environment);
 		return;
 	}
-	await writeChangelog(outputPath, changelog);
-	const versionPath = await updateVersion(environment.cwd, version$1);
-	if (options.commit || options.release) {
-		const releasePaths = [outputPath, versionPath].filter((path) => path !== void 0);
-		if ((await git(environment.cwd, "status", "--porcelain", "--", ...releasePaths)).trim()) {
-			await git(environment.cwd, "add", "--", ...releasePaths);
-			const versionChanges = versionPath ? await git(environment.cwd, "status", "--porcelain", "--", versionPath) : "";
-			const commitMessage = versionPath && !versionChanges.trim() ? `docs(changelog): ${releaseExists ? "update" : "add"} v${version$1} release notes` : `chore(release): v${version$1}`;
-			await git(environment.cwd, ...gitIdentity, "commit", "-m", commitMessage, ...options.author ? ["--author", options.author] : [], "--only", "--", ...releasePaths);
-		}
-	}
+	const outputPath = resolve(environment.cwd, options.output);
+	const currentChangelog = await readChangelog(outputPath);
+	const releaseExists = hasRelease(currentChangelog, options.version);
+	await writeChangelog(outputPath, insertRelease(currentChangelog, release));
+	const versionPath = await updateVersion(environment.cwd, options.version);
+	if (options.commit || options.release) await commitReleaseFiles(options, environment.cwd, outputPath, versionPath, releaseExists);
 	if (options.release) {
+		const gitIdentity = resolveGitIdentity(options.author);
 		await git(environment.cwd, ...gitIdentity, "tag", "-a", tag, "-m", tag);
 		await git(environment.cwd, "push", "origin", "HEAD", `refs/tags/${tag}`);
-		await publishRepositoryRelease();
+		await publishRelease(repository, repositoryRelease, token, preview, environment);
 	}
 }
-function capitalize(value) {
-	return value.charAt(0).toUpperCase() + value.slice(1);
+function validateReleaseSupport(options, repository) {
+	if (!options.release) return;
+	if (!repository) throw new Error("A supported repository is required to release");
+	if (!repository.provider.publishRelease && !repository.provider.manualReleaseUrl) throw new Error(`${repository.provider.name} does not support releases`);
+}
+async function commitReleaseFiles(options, cwd, outputPath, versionPath, releaseExists) {
+	const releasePaths = [outputPath, versionPath].filter((path) => path !== void 0);
+	if (!(await git(cwd, "status", "--porcelain", "--", ...releasePaths)).trim()) return;
+	await git(cwd, "add", "--", ...releasePaths);
+	const versionChanges = versionPath ? await git(cwd, "status", "--porcelain", "--", versionPath) : "";
+	const commitMessage = versionPath && !versionChanges.trim() ? `docs(changelog): ${releaseExists ? "update" : "add"} v${options.version} release notes` : `chore(release): v${options.version}`;
+	await git(cwd, ...resolveGitIdentity(options.author), "commit", "-m", commitMessage, ...options.author ? ["--author", options.author] : [], "--only", "--", ...releasePaths);
+}
+async function publishRelease(repository, release, token, preview, environment) {
+	const stdout = environment.stdout ?? ((value) => process.stdout.write(value));
+	const colors = environment.colors ?? ansis;
+	printChangesPreview(preview, stdout, colors);
+	if (!token || !repository.provider.publishRelease) {
+		if (!repository.provider.manualReleaseUrl) throw new Error("A repository token is required to release");
+		stdout(`${colors.red(`No ${repository.provider.name} token found, specify it via --token or environment variable. Release skipped.`)}\n\n`);
+		printManualReleaseUrl(repository, release, stdout, colors);
+		return;
+	}
+	const result = await repository.provider.publishRelease(repository, release, token, environment.fetch ?? globalThis.fetch);
+	printPublishedRelease(repository.provider.name, result, stdout, colors);
 }
-function resolveGitIdentity(author = defaultAuthor) {
-	const match = /^(.+?)\s*<([^<>]+)>$/.exec(author);
+function resolveGitIdentity(author) {
+	const match = /^([^<>\r\n]+)<([^<>\r\n]+)>$/.exec(author);
 	if (!match) throw new Error("Author must use the \"Name <email>\" format");
 	return [
 		"-c",
@@ -414,31 +414,43 @@ function resolveGitIdentity(author = defaultAuthor) {
 	];
 }
 //#endregion
-//#region src/cli.ts
-async function runCli(args, environment) {
-	const cli = cac("changelog").version(version).option("--output <path>", "Changelog file path").option("--dry", "Print the changelog without writing it").option("--commit", "Commit the changelog").option("--release", "Publish a repository release").option("--author <author>", "Commit author in \"Name <email>\" format").option("--token <token>", "Repository token for resolving authors").help();
-	cli.command("[version]").usage("<version> [options]").action(async (versionArgument, options) => {
-		if (!versionArgument) throw new Error("A release version is required");
-		await runChangelog({
-			version: versionArgument.replace(/^v/, ""),
-			output: options.output,
-			dry: options.dry,
-			commit: options.commit,
-			release: options.release,
-			author: options.author,
-			token: options.token
-		}, environment);
-	});
-	cli.parse([
-		"node",
-		"changelog",
-		...args
-	], { run: false });
-	await cli.runMatchedCommand();
+//#region src/cli/options.ts
+function resolveOptions(versionArgument, options) {
+	if (!versionArgument) throw new Error("A release version is required");
+	const version = normalizeFull(versionArgument);
+	if (!version) throw new Error(`Invalid release version: ${versionArgument}`);
+	const commit = options.commit ?? defaultConfig.cli.commit;
+	const release = options.release ?? defaultConfig.cli.release;
+	if (options.to !== void 0 && release) throw new Error("--to cannot be used with --release");
+	if (options.author !== void 0 && !commit && !release) throw new Error("--author requires --commit or --release");
+	if (!release && (options.name !== void 0 || options.draft !== void 0 || options.prerelease !== void 0)) throw new Error("--name, --draft, and --prerelease require --release");
+	return {
+		version,
+		from: options.from,
+		to: options.to ?? defaultConfig.cli.to,
+		repository: options.repository,
+		output: options.output ?? defaultConfig.cli.output,
+		dry: options.dry ?? defaultConfig.cli.dry,
+		commit,
+		release,
+		author: options.author ?? defaultConfig.cli.author,
+		token: options.token,
+		name: options.name,
+		draft: options.draft ?? defaultConfig.cli.draft,
+		prerelease: options.prerelease,
+		emoji: options.emoji ?? defaultConfig.changelog.emoji,
+		capitalize: options.capitalize ?? defaultConfig.changelog.capitalize,
+		group: options.group ?? defaultConfig.changelog.group
+	};
 }
-if (process.argv[1] && fileURLToPath(import.meta.url) === realpathSync(process.argv[1])) runCli(process.argv.slice(2), { cwd: process.cwd() }).catch((error) => {
-	console.error(error instanceof Error ? error.message : String(error));
-	process.exitCode = 1;
+//#endregion
+//#region src/cli.ts
+const cli = cac("keepchanges").option("--from <ref>", "Start Git reference").option("--to <ref>", "End Git reference").option("--repository <source>", "Repository slug or URL").option("--output <path>", "Changelog file path").option("--dry", "Preview without modifying files or remotes").option("--commit", "Commit the changelog and version update").option("--release", "Publish a repository release").option("--author <author>", "Commit author in \"Name <email>\" format").option("-t, --token <token>", "Repository token").option("--name <name>", "Repository release name").option("-d, --draft", "Create a draft repository release").option("--prerelease", "Mark the repository release as prerelease").option("--emoji", "Use emojis in changelog section titles").option("--capitalize", "Capitalize changelog entries").option("--group", "Group repeated commit scopes");
+cli.command("[version]").usage("<version> [options]").action(async (versionArgument, options) => {
+	await createChanges(resolveOptions(versionArgument, options), { cwd: process.cwd() });
 });
+cli.help();
+cli.version(version);
+cli.parse();
 //#endregion
-export { runCli };
+export {};