@peiyanlu/release 0.0.4 → 0.0.6

package/dist/cli.mjs

@@ -1,24 +1,24 @@
 import path, { join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { eol, execAsync, isGitRepo, parseGitHubRepo, readJsonFile, runGit, runNpm } from "@peiyanlu/cli-utils";
+import { bumpPackageVersion, coloredChangeset, eol, execAsync, getAllRemotes, getAuthenticatedUser, getCurrentBranch, getGithubReleaseUrl, getGithubUrl, getLatestTag, getLog, getPackageInfo, getPackageUrl, getPublishedVersion, getRemote, getStatus, gitAddAll, gitAddTracked, gitCommit, gitTagAnnotated, hasWriteAccess, isGitRepo, isWorkingDirClean, parseGitHubRepo, pingRegistry, publishPackage, pushBranch, pushTag, readJsonFile, resolveChangelogRange } from "@peiyanlu/cli-utils";
 import { dim, green, red, rgb, underline, yellow } from "ansis";
 import { program } from "commander";
 import { createReadStream, createWriteStream, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { cancel, confirm, group, intro, isCancel, log, outro, select, tasks, text } from "@clack/prompts";
 import { publint } from "publint";
 import { formatMessage } from "publint/utils";
-import { clean, coerce, eq, gt, inc, lt, parse, prerelease, valid } from "semver";
+import { coerce, inc, lt, neq, parse, prerelease, valid } from "semver";
 import { castArray, isPlainObject, isUndefined } from "@peiyanlu/ts-utils";
 import { spawnSync } from "node:child_process";
 import { inspect } from "node:util";
-import { Octokit } from "@octokit/rest";
-import { contentType } from "mime-types";
-import open from "open";
-import { glob } from "tinyglobby";
 import { ConventionalChangelog } from "conventional-changelog";
 import createPreset from "conventional-changelog-conventionalcommits";
 import { writeFile } from "node:fs/promises";
 import { finished } from "node:stream/promises";
+import { Octokit } from "@octokit/rest";
+import { contentType } from "mime-types";
+import open from "open";
+import { glob } from "tinyglobby";
 
 //#region node_modules/.pnpm/tsdown@0.18.4_publint@0.3.17_typescript@5.9.3/node_modules/tsdown/esm-shims.js
 const getFilename = () => fileURLToPath(import.meta.url);
@@ -79,6 +79,7 @@ const t = () => green(`${Math.floor(process.uptime())}s`);
 const MSG = {
 	INTRO: (dryRun) => `🚀  Starting release ${n(dryRun)}`,
 	OUTRO: (dryRun) => `🎉  Release finished successfully in ${t()} ${n(dryRun)}`,
+	OUTRO_PREPARE: (dryRun) => `🎉  PrepareRelease finished successfully in ${t()} ${n(dryRun)}`,
 	LOG: {
 		SHOW_VERSION: (version) => `🎉  Released ${green(version)}`,
 		SHOW_CHANGELOG: "🎉  Changelog collected",
@@ -93,6 +94,10 @@ const MSG = {
 		NPM: {
 			CHECKING: "Checking npm registry",
 			CHECKED: (registry, msg$1) => `NPM registry: ${underline(dim(registry))} ${underline(dim(msg$1))}`
+		},
+		GITHUB: {
+			CHECKING: "Checking github repository",
+			CHECKED: (repository, msg$1) => `GitHub repository: ${underline(dim(repository))} ${underline(dim(msg$1))}`
 		}
 	},
 	TASK: {
@@ -151,259 +156,8 @@ const MSG = {
 	}
 };
 
-//#endregion
-//#region src/github/release.ts
-const getGithubUrl = (owner, repo) => {
-	return `https://github.com/${owner}/${repo}`;
-};
-const truncateBody = (body) => {
-	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
-	return body;
-};
-const uploadAssets = async (ctx, config) => {
-	const { github: { assets } } = config;
-	const { github: { isReleased, owner, repo, uploadUrl, releaseId, token }, pkg: { name } } = ctx;
-	if (!assets?.length || !isReleased) return;
-	const octokit = new Octokit({ auth: token });
-	const files = await glob(assets);
-	await Promise.all(files.map((file) => {
-		return octokit.repos.uploadReleaseAsset({
-			owner,
-			repo,
-			name,
-			url: uploadUrl,
-			release_id: releaseId,
-			data: createReadStream(file),
-			headers: {
-				"content-type": contentType(file) || "application/octet-stream",
-				"content-length": statSync(file).size
-			}
-		});
-	}));
-};
-const createWebRelease = async (ctx, config) => {
-	const { pkg: { toPreRelease }, github: { owner, repo, changelog, releaseName }, git: { currentTag } } = ctx;
-	const { github: { prerelease: prerelease$1 } } = config;
-	const github = getGithubUrl(owner, repo);
-	const url = new URL(`${github}/releases/new`);
-	url.searchParams.set("tag", currentTag);
-	url.searchParams.set("title", releaseName);
-	url.searchParams.set("body", truncateBody(changelog));
-	url.searchParams.set("prelease", String(toPreRelease || prerelease$1));
-	const isWindows = process.platform === "win32";
-	await open(url.toString(), { wait: isWindows });
-};
-const createCiRelease = async (ctx, config) => {
-	const { pkg: { toPreRelease }, github: { owner, repo, token, changelog, releaseName }, git: { currentTag } } = ctx;
-	const { github: { prerelease: prerelease$1, draft, autoGenerate } } = config;
-	const octokit = new Octokit({ auth: token });
-	try {
-		const { data } = await octokit.repos.createRelease({
-			owner,
-			repo,
-			tag_name: currentTag,
-			target_commitish: void 0,
-			name: releaseName,
-			body: autoGenerate ? "" : truncateBody(changelog),
-			draft: draft ?? false,
-			prerelease: (toPreRelease || prerelease$1) ?? false,
-			discussion_category_name: void 0,
-			generate_release_notes: autoGenerate,
-			make_latest: "true"
-		});
-		const { html_url, upload_url, id, discussion_url } = data;
-		Object.assign(ctx.github, {
-			isReleased: true,
-			releaseId: id,
-			releaseUrl: html_url,
-			uploadUrl: upload_url,
-			discussionUrl: discussion_url
-		});
-	} catch (e) {
-		if (e?.status === 422) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(currentTag));
-		throw e;
-	}
-};
-const parseGithubUrl = (ctx) => {
-	const { git: { remoteUrl } } = ctx;
-	const [owner, repo] = parseGitHubRepo(remoteUrl);
-	Object.assign(ctx.github, {
-		owner,
-		repo
-	});
-};
-const createRelease = async (ctx, config) => {
-	const { github: { owner, repo }, isCI } = ctx;
-	const { github: { tokenRef, release, skipChecks } } = config;
-	if (!release) return;
-	const token = tokenRef ? process.env[tokenRef] : process.env.GITHUB_TOKEN;
-	if (!token) {
-		Object.assign(ctx.github, { isWeb: true });
-		if (isCI && process.env.GITHUB_ACTIONS) throw new Error(MSG.ERROR.GITHUB_TOKEN(tokenRef));
-	}
-	Object.assign(ctx.github, { token });
-	const octokit = new Octokit({ auth: token });
-	if (token && !skipChecks) if (process.env.GITHUB_ACTIONS) Object.assign(ctx.github, { username: process.env.GITHUB_ACTOR });
-	else {
-		try {
-			const { data: { login: username } } = await octokit.users.getAuthenticated();
-			Object.assign(ctx.github, { username });
-		} catch (e) {
-			throw new Error(MSG.ERROR.GITHUB_AUTH);
-		}
-		try {
-			const { github: { username } } = ctx;
-			await octokit.repos.checkCollaborator({
-				owner,
-				repo,
-				username
-			});
-		} catch (e) {
-			throw new Error(MSG.ERROR.GITHUB_USER);
-		}
-	}
-	const { github: { isWeb }, dryRun } = ctx;
-	if (dryRun) return true;
-	if (isWeb) await createWebRelease(ctx, config);
-	else if (isCI) {
-		await createCiRelease(ctx, config);
-		await uploadAssets(ctx, config);
-	}
-};
-const getGithubReleaseUrl = (ctx) => {
-	const { github: { owner, repo }, git: { currentTag } } = ctx;
-	return `${getGithubUrl(owner, repo)}/releases/tag/${normalizeTag(currentTag)}`;
-};
-
 //#endregion
 //#region src/git/commit.ts
-const getBranchName = async () => {
-	let branch = await runGit(["branch", "--show-current"]);
-	if (!branch) {
-		branch = await runGit([
-			"rev-parse",
-			"--abbrev-ref",
-			"HEAD"
-		]);
-		if (branch === "HEAD") return void 0;
-	}
-	return branch;
-};
-const getRemoteForBranch = (branch) => {
-	return runGit([
-		"config",
-		"--get",
-		`branch.${branch}.remote`
-	]);
-};
-const getAllRemotes = async () => {
-	return (await runGit(["remote"]))?.split("\n").filter(Boolean) ?? [];
-};
-const getStatus = () => {
-	return runGit([
-		"status",
-		"--short",
-		"--untracked-files=no"
-	], { trim: false });
-};
-const coloredChangeset = (log$1) => {
-	const colorStatusChar = (ch) => {
-		switch (ch) {
-			case "M": return `\x1b[33m${ch}\x1b[0m`;
-			case "A": return `\x1b[32m${ch}\x1b[0m`;
-			case "D": return `\x1b[31m${ch}\x1b[0m`;
-			default: return ch;
-		}
-	};
-	const colorStatus = (status) => status.split("").map(colorStatusChar).join("");
-	return log$1.split("\n").filter(Boolean).map((line) => {
-		const status = line.slice(0, 2);
-		const file = line.slice(3);
-		return `${colorStatus(status)} ${dim(file)}`;
-	}).join("\n");
-};
-const getRemote = async () => {
-	const branch = await getBranchName();
-	const remoteName = branch && await getRemoteForBranch(branch) || "origin";
-	return {
-		remoteName,
-		remoteUrl: await runGit([
-			"remote",
-			"get-url",
-			remoteName
-		]).catch((_) => runGit([
-			"config",
-			"--get",
-			`remote.${remoteName}.url`
-		]))
-	};
-};
-const getLatestTag = async (match = "*", exclude = "*-beta.*") => {
-	return runGit([
-		"describe",
-		"--tags",
-		"--abbrev=0",
-		`--match=${match}`,
-		`--exclude=${exclude}`
-	]);
-};
-const getPreviousTag = async (current) => {
-	return runGit([
-		"describe",
-		"--tags",
-		"--abbrev=0",
-		`${await runGit([
-			"rev-list",
-			"--tags",
-			current || "--skip=1",
-			"--max-count=1"
-		])}^`
-	]);
-};
-const resolveChangelogRange = async (isIncrement = true) => {
-	const latestTag = await getLatestTag();
-	const previousTag = await getPreviousTag(latestTag);
-	if (!latestTag) return {
-		from: "",
-		to: "HEAD"
-	};
-	if (!isIncrement && previousTag) return {
-		from: previousTag,
-		to: `${latestTag}^1`
-	};
-	return {
-		from: latestTag,
-		to: "HEAD"
-	};
-};
-const getLog = async (from = "", to = "HEAD", scope) => {
-	const cmd = ["log", `--pretty=format:* %s (%h)`];
-	if (from) cmd.push(`${from}...${to}`);
-	if (scope) cmd.push(...["--", scope]);
-	return runGit(cmd, { trim: false });
-};
-const isWorkingDirClean = async () => {
-	return (await runGit(["status", "-s"]))?.length === 0;
-};
-const hasUpstreamBranch = async () => {
-	const branch = await runGit([
-		"for-each-ref",
-		"--format=%(upstream:short)",
-		await runGit(["symbolic-ref", "HEAD"])
-	]);
-	return Boolean(branch);
-};
-const getUpstreamArgs = async (remoteName) => {
-	const hasUpstream = await hasUpstreamBranch();
-	const branch = await getBranchName();
-	if (!hasUpstream) return [
-		"--set-upstream",
-		remoteName,
-		branch
-	];
-	return [remoteName, branch];
-};
-const normalizeTag = (tag) => clean(tag) ?? tag;
 const gitCheck = async (ctx, config) => {
 	const { pkg: { name } } = ctx;
 	const { git: { requireRepository, requireRemote, requireWorkDirClean } } = config;
@@ -423,60 +177,34 @@ const gitCheck = async (ctx, config) => {
 		remoteName,
 		remoteUrl
 	});
-	parseGithubUrl(ctx);
+	const [owner, repo] = parseGitHubRepo(remoteUrl);
+	Object.assign(ctx.github, {
+		owner,
+		repo
+	});
 };
 const commitAndTag = async (ctx, config) => {
 	const { git: { remoteName, currentTag, commitMessage, tagMessage }, dryRun } = ctx;
 	const { git: { commit, tag, push, addUntrackedFiles, commitArgs, tagArgs, pushArgs } } = config;
 	if (!commit) return;
 	const args = dryRun ? ["--dry-run"] : [];
-	await runGit([
-		"add",
-		".",
-		addUntrackedFiles ? "--all" : "--update",
-		...args
-	]);
-	await runGit([
-		"commit",
-		"--message",
-		commitMessage,
-		...commitArgs,
-		...args
-	]);
+	addUntrackedFiles ? await gitAddAll() : await gitAddTracked(args);
+	await gitCommit(commitMessage, [...commitArgs, ...args]);
 	if (!dryRun) Object.assign(ctx.git, { isCommitted: true });
 	if (tag) {
-		await runGit([
-			"tag",
-			"--annotate",
-			"--message",
-			tagMessage,
-			currentTag,
-			...tagArgs,
-			...args
-		]);
+		await gitTagAnnotated(currentTag, tagMessage, [...tagArgs, ...args]);
 		if (!dryRun) Object.assign(ctx.git, { isTagged: true });
 	}
 	if (push) {
 		const remotes = await getAllRemotes();
 		for (const remoteName$1 of remotes) {
-			const upstreamArgs = await getUpstreamArgs(remoteName$1);
-			await runGit([
-				"push",
-				remoteName$1,
-				`refs/tags/${currentTag}`,
-				...args
-			]);
-			await runGit([
-				"push",
-				...upstreamArgs,
-				...pushArgs,
-				...args
-			]);
+			await pushTag(remoteName$1, currentTag, args);
+			await pushBranch(remoteName$1, await getCurrentBranch(), [...pushArgs, ...args]);
 		}
 		if (!dryRun) Object.assign(ctx.git, { isPushed: true });
 	}
 };
-const gitRollback$1 = (ctx) => {
+const gitRollback = (ctx) => {
 	const { git: { currentTag, isCommitted, isTagged, isPushed } } = ctx;
 	if (isPushed) return;
 	spawnSync("git", ["restore", "."]);
@@ -492,6 +220,30 @@ const gitRollback$1 = (ctx) => {
 	]);
 };
 
+//#endregion
+//#region src/prompts.ts
+const abortTask = (msg$1) => {
+	cancel(`${red("✕")} ${msg$1}`);
+	process.exit(0);
+};
+const abortSinglePrompt = (value) => {
+	if (isCancel(value)) abortTask(MSG.ABORT.CANCEL);
+};
+const abortGroupPrompt = (ctx) => {
+	ctx && gitRollback(ctx);
+	abortTask(MSG.ABORT.CANCEL);
+};
+const abortOnError = (err, ctx) => {
+	ctx && gitRollback(ctx);
+	const msg$1 = err.message.replace(/^\[(github|npm|git)]/, (a) => red(a));
+	log.message(`\n${msg$1}\n`);
+	process.exit(1);
+};
+const taskEnd = (msg$1) => {
+	outro(msg$1);
+	process.exit(0);
+};
+
 //#endregion
 //#region src/utils.ts
 const info = (msg$1) => {
@@ -524,20 +276,6 @@ const runLifeCycleHook = async (hooks, key, dryRun) => {
 		log.success(success(hook.replace(/^echo$/, dim("echo")), dryRun));
 	}));
 };
-const gitRollback = (ctx) => {
-	const { git: { currentTag, isCommitted, isTagged } } = ctx;
-	spawnSync("git", ["restore", "."]);
-	if (isTagged) spawnSync("git", [
-		"tag",
-		"--delete",
-		currentTag
-	]);
-	spawnSync("git", [
-		"reset",
-		"--hard",
-		isCommitted ? "HEAD~1" : "HEAD"
-	]);
-};
 const diff = (from, to, separator = ".") => {
 	const a = from.split(separator);
 	return to.split(separator).map((v, i) => v === a[i] ? dim(v) : green(v)).join(separator);
@@ -559,39 +297,6 @@ const formatTemplate = async (ctx, config) => {
 	});
 	Object.assign(ctx.github, { releaseName });
 };
-const getPackageInfo = (pkgName, getPkgDir = (pkg$1) => `packages/${pkg$1}`) => {
-	const pkgDir = resolve(getPkgDir(pkgName));
-	const pkgPath = resolve(pkgDir, "package.json");
-	return {
-		pkg: readJsonFile(pkgPath),
-		pkgDir,
-		pkgPath
-	};
-};
-
-//#endregion
-//#region src/prompts.ts
-const abortTask = (msg$1) => {
-	cancel(`${red("✕")} ${msg$1}`);
-	process.exit(0);
-};
-const abortSinglePrompt = (value) => {
-	if (isCancel(value)) abortTask(MSG.ABORT.CANCEL);
-};
-const abortGroupPrompt = (ctx) => {
-	ctx && gitRollback(ctx);
-	abortTask(MSG.ABORT.CANCEL);
-};
-const abortOnError = (err, ctx) => {
-	ctx && gitRollback(ctx);
-	const msg$1 = err.message.replace(/^\[(github|npm|git)]/, (a) => red(a));
-	log.message(`\n${msg$1}\n`);
-	process.exit(1);
-};
-const taskEnd = (msg$1) => {
-	outro(msg$1);
-	process.exit(0);
-};
 
 //#endregion
 //#region src/version/bump.ts
@@ -615,7 +320,10 @@ const parseVersion = (raw) => {
 	};
 };
 const getCIVersion = (current) => {
-	return inc(current, Release.PATCH) ?? "";
+	return inc(current, Release.PATCH);
+};
+const isNeq = (current, next) => {
+	return neq(current, next);
 };
 
 //#endregion
@@ -624,6 +332,7 @@ let Release = /* @__PURE__ */ function(Release$1) {
 	Release$1["MAJOR"] = "major";
 	Release$1["MINOR"] = "minor";
 	Release$1["PATCH"] = "patch";
+	Release$1["RELEASE"] = "release";
 	return Release$1;
 }({});
 let PreRelease = /* @__PURE__ */ function(PreRelease$1) {
@@ -643,76 +352,45 @@ let PreId = /* @__PURE__ */ function(PreId$1) {
 	PreId$1["DEV"] = "dev";
 	return PreId$1;
 }({});
+const createVersionMap = (current) => ({
+	patch: inc(current, Release.PATCH),
+	minor: inc(current, Release.MINOR),
+	major: inc(current, Release.MAJOR),
+	release: inc(current, Release.RELEASE),
+	prerelease: inc(current, PreRelease.RELEASE),
+	prepatch: inc(current, PreRelease.PATCH, PreId.BETA),
+	preminor: inc(current, PreRelease.MINOR, PreId.BETA),
+	premajor: inc(current, PreRelease.MAJOR, PreId.BETA)
+});
+const option = (label, value, hint) => ({
+	label,
+	value,
+	hint: hint ?? value
+});
 const runVersionPrompts = async (ctx, config) => {
 	const { pkg: { current, fromPreRelease } } = ctx;
 	const selectVersion = async () => {
-		const patch = inc(current, Release.PATCH);
-		const minor = inc(current, Release.MINOR);
-		const major = inc(current, Release.MAJOR);
-		const prerelease$1 = inc(current, PreRelease.RELEASE);
-		const prepatch = inc(current, PreRelease.PATCH, PreId.BETA);
-		const preminor = inc(current, PreRelease.MINOR, PreId.BETA);
-		const premajor = inc(current, PreRelease.MAJOR, PreId.BETA);
-		const pr = [{
-			label: "Pre-Release",
-			value: prerelease$1,
-			hint: prerelease$1
-		}];
-		const pre = [
-			{
-				label: "Pre-Patch",
-				value: prepatch,
-				hint: prepatch
-			},
-			{
-				label: "Pre-Minor",
-				value: preminor,
-				hint: preminor
-			},
-			{
-				label: "Pre-Major",
-				value: premajor,
-				hint: premajor
-			}
-		];
-		const release = [
-			{
-				label: "Patch",
-				value: patch,
-				hint: patch
-			},
-			{
-				label: "Minor",
-				value: minor,
-				hint: minor
-			},
-			{
-				label: "Major",
-				value: major,
-				hint: major
-			}
+		const versions = createVersionMap(current);
+		const options = [
+			...fromPreRelease ? [option("Pre-Release", "prerelease", versions.prerelease)] : [],
+			option("Patch", "patch", versions.patch),
+			option("Minor", "minor", versions.minor),
+			option("Major", "major", versions.major),
+			...!fromPreRelease ? [
+				option("Pre-Patch", "prepatch", versions.prepatch),
+				option("Pre-Minor", "preminor", versions.preminor),
+				option("Pre-Major", "premajor", versions.premajor)
+			] : [],
+			option("As-Is", "ignore", current),
+			option("Custom", "custom", "custom specified")
 		];
-		const custom = [{
-			label: "As-Is",
-			value: "ignore",
-			hint: current
-		}, {
-			label: "Custom",
-			value: "custom",
-			hint: "custom specified"
-		}];
-		const version = await select({
+		const type = await select({
 			message: question(MSG.PROMPT.SELECT_VERSION, "version"),
-			options: [
-				...fromPreRelease ? pr : [],
-				...release,
-				...fromPreRelease ? [] : pre,
-				...custom
-			],
-			initialValue: fromPreRelease ? prerelease$1 : patch
+			options,
+			initialValue: fromPreRelease ? "prerelease" : "patch"
 		});
-		abortSinglePrompt(version);
-		return version;
+		abortSinglePrompt(type);
+		return type;
 	};
 	const inputVersion = async () => {
 		const version = await text({
@@ -725,10 +403,12 @@ const runVersionPrompts = async (ctx, config) => {
 		abortSinglePrompt(version);
 		return version;
 	};
-	const type = await selectVersion();
-	const next = type === "custom" ? await inputVersion() : type === "ignore" ? current : type;
-	ctx.isIncrement = !eq(next, current);
-	return { next };
+	const resolveNextVersion = async (type, current$1) => {
+		if (type === "ignore") return current$1;
+		if (type === "custom") return inputVersion();
+		return createVersionMap(current$1)[type];
+	};
+	return await resolveNextVersion(await selectVersion(), current);
 };
 
 //#endregion
@@ -814,7 +494,7 @@ const createDefaultConfig = (isCI) => {
 		toTag(pkg$1, version) {
 			return `v${version}`;
 		},
-		changelogTagPrefix: void 0,
+		tagPrefix: void 0,
 		git: {
 			commit: isCI,
 			tag: isCI,
@@ -831,8 +511,7 @@ const createDefaultConfig = (isCI) => {
 		},
 		npm: {
 			publish: isCI,
-			publishPath: ".",
-			pushArgs: [],
+			publishArgs: [],
 			skipChecks: false
 		},
 		github: {
@@ -945,11 +624,8 @@ const defaultTypes = [
 
 //#endregion
 //#region src/git/changelog.ts
-const generateChangelog = async ({ getPkgDir, tagPrefix }) => {
+const createGenerator = async ({ getPkgDir, tagPrefix }) => {
 	const pkgDir = getPkgDir();
-	const infile = join(pkgDir, "CHANGELOG.md");
-	if (!existsSync(infile)) await writeFile(infile, "");
-	const originalChangelog = readFileSync(infile, "utf-8");
 	const preset = await createPreset({ types: defaultTypes.map((t$1) => ({
 		...t$1,
 		hidden: false
@@ -1002,17 +678,30 @@ const generateChangelog = async ({ getPkgDir, tagPrefix }) => {
 {{> commit root=@root}}
 {{/each}}
 {{/each}}`.trim() + eol(2);
-	const generator = new ConventionalChangelog().readPackage(`${pkgDir}/package.json`).config(preset).options({ releaseCount: 1 }).commits({ path: pkgDir }).tags({ prefix: tagPrefix });
-	const writeStream = createWriteStream(infile);
+	return new ConventionalChangelog().readPackage(`${pkgDir}/package.json`).config(preset).options({ releaseCount: 1 }).commits({ path: pkgDir }).tags({ prefix: tagPrefix });
+};
+const getChangelog = async ({ getPkgDir, tagPrefix }) => {
+	const generator = await createGenerator({
+		getPkgDir,
+		tagPrefix
+	});
 	let changelog = "";
-	for await (const chunk of generator.write()) {
-		changelog += chunk;
-		writeStream.write(chunk);
-	}
+	for await (const chunk of generator.write()) changelog += chunk;
+	return changelog;
+};
+const generateChangelog = async ({ getPkgDir, tagPrefix }) => {
+	const infile = join(getPkgDir(), "CHANGELOG.md");
+	if (!existsSync(infile)) await writeFile(infile, "");
+	const originalChangelog = readFileSync(infile, "utf-8");
+	const generator = await createGenerator({
+		getPkgDir,
+		tagPrefix
+	});
+	const writeStream = createWriteStream(infile);
+	for await (const chunk of generator.write()) writeStream.write(chunk);
 	writeStream.write(originalChangelog);
 	writeStream.end();
 	await finished(writeStream);
-	return changelog;
 };
 
 //#endregion
@@ -1074,6 +763,172 @@ const runGithubPrompts = async (ctx, config) => {
 	return res;
 };
 
+//#endregion
+//#region src/github/release.ts
+const truncateBody = (body) => {
+	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
+	return body;
+};
+const getReleaseByTagSafe = async (octokit, options) => {
+	try {
+		const { data } = await octokit.repos.getReleaseByTag({ ...options });
+		return data;
+	} catch (e) {
+		if (e?.status === 404) return null;
+		throw e;
+	}
+};
+const createCRelease = async (octokit, options) => {
+	const { owner, repo, tag, name, body, draft, prerelease: prerelease$1, generateReleaseNotes, makeLatest, targetCommitish, discussionCategoryName } = options;
+	const { data } = await octokit.repos.createRelease({
+		owner,
+		repo,
+		tag_name: tag,
+		name,
+		body,
+		draft,
+		prerelease: prerelease$1,
+		generate_release_notes: generateReleaseNotes,
+		make_latest: makeLatest,
+		target_commitish: targetCommitish,
+		discussion_category_name: discussionCategoryName
+	});
+	return data;
+};
+const updateCRelease = async (octokit, options) => {
+	const { owner, repo, tag, name, body, draft, prerelease: prerelease$1, generateReleaseNotes, makeLatest, targetCommitish, discussionCategoryName, releaseId } = options;
+	const { data } = await octokit.repos.updateRelease({
+		owner,
+		repo,
+		release_id: releaseId,
+		tag_name: tag,
+		name,
+		body,
+		draft,
+		prerelease: prerelease$1,
+		generate_release_notes: generateReleaseNotes,
+		make_latest: makeLatest,
+		target_commitish: targetCommitish,
+		discussion_category_name: discussionCategoryName
+	});
+	return data;
+};
+const createCReleaseByTag = async (octokit, options) => {
+	const existing = await getReleaseByTagSafe(octokit, options);
+	if (!existing) return createCRelease(octokit, { ...options });
+	const { draft, id: releaseId } = existing;
+	if (!draft) throw new Error(`Release for tag "${options.tag}" already exists and is not a draft`);
+	return updateCRelease(octokit, {
+		releaseId,
+		...options
+	});
+};
+const uploadAssets = async (octokit, options) => {
+	const { owner, repo, name, uploadUrl, releaseId, assets } = options;
+	const files = await glob(assets);
+	await Promise.all(files.map((file) => {
+		return octokit.repos.uploadReleaseAsset({
+			owner,
+			repo,
+			name,
+			url: uploadUrl,
+			release_id: releaseId,
+			data: createReadStream(file),
+			headers: {
+				"content-type": contentType(file) || "application/octet-stream",
+				"content-length": statSync(file).size
+			}
+		});
+	}));
+};
+const createWebRelease = async (options) => {
+	const { owner, repo, tag, title, body, prerelease: prerelease$1 } = options;
+	const url = new URL(`${getGithubUrl(owner, repo)}/releases/new`);
+	Object.entries({
+		tag,
+		title,
+		body,
+		prerelease: prerelease$1
+	}).forEach(([key, value]) => {
+		url.searchParams.set(key, value);
+	});
+	const isWindows = process.platform === "win32";
+	await open(url.toString(), { wait: isWindows });
+};
+const githubCheck = async (ctx, config) => {
+	const { github: { owner, repo }, isCI } = ctx;
+	const { github: { tokenRef, skipChecks } } = config;
+	const token = tokenRef ? process.env[tokenRef] : process.env.GITHUB_TOKEN;
+	if (!token) {
+		Object.assign(ctx.github, { isWeb: true });
+		if (isCI && process.env.GITHUB_ACTIONS) throw new Error(MSG.ERROR.GITHUB_TOKEN(tokenRef));
+		return "";
+	}
+	Object.assign(ctx.github, { token });
+	if (skipChecks) return "";
+	let username = "";
+	if (process.env.GITHUB_ACTIONS) username = process.env.GITHUB_ACTOR;
+	else {
+		const octokit = new Octokit({ auth: token });
+		try {
+			const { data: { login } } = await octokit.users.getAuthenticated();
+			username = login;
+		} catch (e) {
+			throw new Error(MSG.ERROR.GITHUB_AUTH);
+		}
+		try {
+			await octokit.repos.checkCollaborator({
+				owner,
+				repo,
+				username
+			});
+		} catch (e) {
+			throw new Error(MSG.ERROR.GITHUB_USER);
+		}
+	}
+	return username;
+};
+const createRelease = async (ctx, config) => {
+	const { pkg: { name, toPreRelease }, git: { currentTag }, isCI, dryRun } = ctx;
+	const { github: { isWeb, token, owner, repo, changelog, releaseName } } = ctx;
+	const { github: { release, assets, prerelease: prerelease$1, autoGenerate, draft } } = config;
+	if (!release || dryRun) return;
+	const octokit = new Octokit({ auth: token });
+	if (isWeb) await createWebRelease({
+		owner,
+		repo,
+		tag: currentTag,
+		title: releaseName,
+		body: truncateBody(changelog),
+		prerelease: String(toPreRelease || prerelease$1)
+	});
+	else if (isCI) {
+		const res = await createCReleaseByTag(octokit, {
+			owner,
+			repo,
+			tag: currentTag,
+			name: releaseName,
+			body: autoGenerate ? "" : truncateBody(changelog),
+			draft,
+			prerelease: toPreRelease || prerelease$1,
+			generateReleaseNotes: autoGenerate,
+			makeLatest: "true"
+		});
+		if (!res) return;
+		if (assets.length) {
+			const { id: releaseId, upload_url: uploadUrl } = res;
+			await uploadAssets(octokit, {
+				owner,
+				repo,
+				name,
+				uploadUrl,
+				releaseId,
+				assets
+			});
+		}
+	}
+};
+
 //#endregion
 //#region src/npm/prompts.ts
 const runNpmPublishPrompts = async (ctx, config) => {
@@ -1107,120 +962,71 @@ const runNpmOptPrompts = async (ctx, config) => {
 
 //#endregion
 //#region src/npm/publish.ts
-const resolvePublishRegistry = (publishConfig = {}) => {
-	if (publishConfig.registry) return publishConfig.registry;
-	return Object.keys(publishConfig).filter((k) => k.endsWith("registry")).map((k) => publishConfig[k])[0];
-};
-const pingRegistry = async () => {
-	return void 0 !== await runNpm(["ping"]);
-};
-const getAuthenticatedUser = () => {
-	return runNpm(["whoami"]);
-};
-const getVersionByTag = (name, tag) => {
-	return runNpm([
-		"show",
-		`${name}@${tag}`,
-		"version"
-	]);
-};
-const getPublishedVersion = (name) => {
-	return runNpm([
-		"info",
-		name,
-		"version"
-	]);
-};
 const resolvePublishTag = async (pkgName, version) => {
 	const { toPreRelease, preId } = parseVersion(version);
-	if (!toPreRelease) {
-		const active = await getPublishedVersion(pkgName);
-		return active && lt(version, active) ? "previous" : "latest";
-	} else return preId || "prerelease";
-};
-const bumpPackageVersion = (version, args = [], cwd = ".") => {
-	return runNpm([
-		"version",
-		version,
-		"--no-git-tag-version",
-		"--workspaces=false",
-		"--allow-same-version",
-		...args
-	], { cwd });
+	if (toPreRelease) return preId || "next";
+	const active = await getPublishedVersion(pkgName);
+	if (!active) return "latest";
+	return lt(version, active) ? "previous" : "latest";
 };
 const isOtpError = (err) => err instanceof Error && /one-time password|otp/i.test(err.message);
-const publishPackage = (pkg$1 = ".", tag = "latest", args = []) => {
-	return runNpm([
-		"publish",
-		"--access",
-		"public",
-		"--tag",
-		tag,
-		"--workspaces=false",
-		...args
-	], { cwd: pkg$1 });
-};
-const getPackageUrl = (name, next) => {
-	return `https://www.npmjs.com/package/${name}/v/${next}`;
-};
-const isCollaborator = async (ctx) => {
-	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
-	const registry = resolvePublishRegistry(publishConfig);
-	const registryArg = registry ? ["--registry", registry] : [];
-	let npmVersion = await runNpm(["--version"]);
-	let accessCommand;
-	if (gt(npmVersion, "9.0.0")) accessCommand = [
-		"access",
-		"list",
-		"collaborators",
-		"--json"
-	];
-	else accessCommand = ["access", "ls-collaborators"];
-	const res = await runNpm([
-		...accessCommand,
-		name,
-		...registryArg
-	]);
-	if (res) return JSON.parse(res ?? "{}")[username]?.includes("write");
-	return false;
-};
 const npmCheck = async (ctx, config) => {
-	const { pkg: { name, current, publishConfig: { registry } }, npm: { username } } = ctx;
+	const { pkg: { name, current, publishConfig: { registry } } } = ctx;
 	const { npm: { skipChecks } } = config;
 	const tag = await resolvePublishTag(name, current);
 	Object.assign(ctx.npm, { tag });
 	if (skipChecks) return "";
-	if (!await pingRegistry()) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
-	const getUser = async () => {
-		const username$1 = await getAuthenticatedUser();
-		if (!username$1) return false;
-		Object.assign(ctx.npm, { username: username$1 });
-		return true;
-	};
-	if (!await getUser()) throw new Error(MSG.ERROR.NPM_AUTH);
-	const latest = await getVersionByTag(name, tag);
+	const [pinged, username] = await Promise.all([pingRegistry(registry), getAuthenticatedUser(registry)]);
+	if (!pinged) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
+	if (!username) throw new Error(MSG.ERROR.NPM_AUTH);
+	Object.assign(ctx.npm, { username });
+	const latest = await getPublishedVersion(`${name}@${tag}`);
 	if (latest) {
-		if (!await isCollaborator(ctx)) throw new Error(MSG.ERROR.NPM_USER(username, name));
+		if (!await hasWriteAccess(name, username, registry)) throw new Error(MSG.ERROR.NPM_USER(username, name));
 	}
 	return latest ? `(${tag} → ${latest})` : `(${tag} → no published version)`;
 };
 const publishNpm = async (ctx, config) => {
 	const { dryRun, selectedPkg, npm: { otp, tag } } = ctx;
-	const { npm: { publish, pushArgs }, getPkgDir } = config;
+	const { npm: { publish, publishArgs }, getPkgDir } = config;
 	if (!publish) return;
 	const otpArgs = otp ? ["--otp", otp] : [];
 	const dryRunArg = dryRun ? ["--dry-run"] : [];
-	return publishPackage(getPkgDir(selectedPkg), tag, [
-		...otpArgs,
-		...pushArgs,
-		...dryRunArg
-	]);
+	return publishPackage({
+		tag,
+		args: [
+			...otpArgs,
+			...publishArgs,
+			...dryRunArg
+		],
+		cwd: getPkgDir(selectedPkg)
+	});
 };
 
 //#endregion
 //#region src/action.ts
 var Action = class {
-	async handle(cmdArgs, options) {
+	async handleRelease(cmdArgs, options) {
+		const { ctx, config } = await this.createContext(cmdArgs, options);
+		await this.checkTask(ctx, config);
+		await this.bumpTask(ctx, config);
+		await this.changelogTask(ctx, config);
+		await this.gitTask(ctx, config);
+		await this.npmTask(ctx, config);
+		await this.githubTask(ctx, config);
+		if (ctx.dryRun) gitRollback(ctx);
+		taskEnd(MSG.OUTRO(ctx.dryRun));
+	}
+	async handlePrepareRelease(cmdArgs, options) {
+		const { ctx, config } = await this.createContext(cmdArgs, options);
+		await this.checkTask(ctx, config);
+		await this.bumpTask(ctx, config);
+		await this.changelogTask(ctx, config);
+		await this.gitTask(ctx, config);
+		if (ctx.dryRun) gitRollback(ctx);
+		taskEnd(MSG.OUTRO_PREPARE(ctx.dryRun));
+	}
+	async createContext(cmdArgs, options) {
 		const { version: cVersion, name: cName } = readJsonFile(join(__dirname, "../package.json"));
 		const { otp, package: defPkg, ...others } = options;
 		const { showChangelog, showRelease, ci, dryRun } = Object.fromEntries(Object.entries(others).map(([k, v]) => [k, Boolean(v)]));
@@ -1284,43 +1090,54 @@ var Action = class {
 			const formated = formatMessage(message, pkg$1);
 			formated && msg("PKG", formated);
 		}
-		await this.checkTask(ctx, config);
-		await this.bumpTask(ctx, config);
-		await this.changelogTask(ctx, config);
-		await this.gitTask(ctx, config);
-		await this.npmTask(ctx, config);
-		await this.githubTask(ctx, config);
-		if (dryRun) gitRollback$1(ctx);
-		taskEnd(MSG.OUTRO(dryRun));
+		return {
+			ctx,
+			config
+		};
 	}
 	async checkTask(ctx, config) {
-		const { noNpm, dryRun } = ctx;
-		await tasks([{
-			title: MSG.CHECK.GIT.CHECKING,
-			task: async () => {
-				await gitCheck(ctx, config);
-				const { git: { remoteName, remoteUrl } } = ctx;
-				return success(MSG.CHECK.GIT.CHECKED(remoteName, remoteUrl), dryRun);
-			}
-		}, {
-			title: MSG.CHECK.NPM.CHECKING,
-			task: async () => {
-				const msg$1 = await npmCheck(ctx, config);
-				const { pkg: { publishConfig: { registry } } } = ctx;
-				return success(MSG.CHECK.NPM.CHECKED(registry, msg$1), dryRun);
+		const { dryRun } = ctx;
+		await tasks([
+			{
+				title: MSG.CHECK.GIT.CHECKING,
+				task: async () => {
+					await gitCheck(ctx, config);
+					const { git: { remoteName, remoteUrl } } = ctx;
+					return success(MSG.CHECK.GIT.CHECKED(remoteName, remoteUrl), dryRun);
+				}
+			},
+			{
+				title: MSG.CHECK.NPM.CHECKING,
+				task: async () => {
+					const msg$1 = await npmCheck(ctx, config);
+					const { pkg: { publishConfig: { registry } } } = ctx;
+					return success(MSG.CHECK.NPM.CHECKED(registry, msg$1), dryRun);
+				},
+				enabled: !ctx.noNpm
 			},
-			enabled: !noNpm
-		}]).catch(abortOnError);
+			{
+				title: MSG.CHECK.GITHUB.CHECKING,
+				task: async () => {
+					const msg$1 = await githubCheck(ctx, config);
+					const { github: { owner, repo } } = ctx;
+					const repository = getGithubUrl(owner, repo);
+					return success(MSG.CHECK.GITHUB.CHECKED(repository, msg$1), dryRun);
+				},
+				enabled: !ctx.noGitHub
+			}
+		]).catch(abortOnError);
 	}
 	async bumpTask(ctx, config) {
 		const { pkg: { current }, dryRun, isCI, showRelease, showChangelog, selectedPkg } = ctx;
-		const { hooks, getPkgDir } = config;
+		const { isMonorepo, hooks, getPkgDir, tagPrefix } = config;
 		const need = (ctx$1) => {
 			const { pkg: { next: next$1 }, isIncrement: isIncrement$1 } = ctx$1;
 			return !next$1 && isIncrement$1;
 		};
 		if (need(ctx)) {
-			const parsed = parseVersion(isCI && getCIVersion(current) || (await runVersionPrompts(ctx, config)).next);
+			const next$1 = (isCI ? getCIVersion(current) : void 0) || await runVersionPrompts(ctx, config);
+			ctx.isIncrement = isNeq(current, next$1);
+			const parsed = parseVersion(next$1);
 			Object.assign(ctx.pkg, { ...parsed });
 		}
 		const { pkg: { next }, isIncrement } = ctx;
@@ -1336,25 +1153,30 @@ var Action = class {
 			}
 		}]).catch((err) => abortOnError(err, ctx));
 		await runLifeCycleHook(hooks, "after:bump", dryRun);
-		const { from, to } = await resolveChangelogRange(isIncrement);
-		const logStr = await getLog(from, to, getPkgDir(selectedPkg));
-		if (logStr) {
-			msg("GIT", `Changelog:${eol(2)}` + logStr);
+		const { from, to } = await resolveChangelogRange(isIncrement, isMonorepo ? `${tagPrefix?.(selectedPkg)}*` : "*");
+		const commits = await getLog(from, to, getPkgDir(selectedPkg));
+		const changelog = await getChangelog({
+			getPkgDir: () => getPkgDir(selectedPkg),
+			tagPrefix: tagPrefix?.(selectedPkg)
+		});
+		Object.assign(ctx.github, { changelog });
+		if (commits) {
+			msg("GIT", `Changelog(${from}...${to}):${eol(2)}` + changelog.trimEnd());
+			msg("GIT", `Commits(${from}...${to}):${eol(2)}` + commits);
 			if (showChangelog) taskEnd(MSG.LOG.SHOW_CHANGELOG);
 		} else msg("GIT", MSG.LOG.CHANGELOG_EMPTY);
 	}
 	async changelogTask(ctx, config) {
 		const { isIncrement, dryRun, selectedPkg } = ctx;
-		const { getPkgDir, changelogTagPrefix } = config;
+		const { getPkgDir, tagPrefix } = config;
 		await tasks([{
 			title: MSG.TASK.CHANGELOG.START,
 			task: async () => {
-				const changelog = await generateChangelog({
+				await generateChangelog({
 					getPkgDir: () => getPkgDir(selectedPkg),
-					tagPrefix: changelogTagPrefix?.(selectedPkg)
+					tagPrefix: tagPrefix?.(selectedPkg)
 				});
-				await runGit(["add", `${getPkgDir(selectedPkg)}/CHANGELOG.md`]);
-				Object.assign(ctx.github, { changelog });
+				await gitAddAll();
 				return success(MSG.TASK.CHANGELOG.END, dryRun);
 			},
 			enabled: isIncrement
@@ -1408,8 +1230,9 @@ var Action = class {
 		await tasks([{
 			title: MSG.TASK.GITHUB.START,
 			task: async () => {
+				const { github: { owner, repo }, git: { currentTag } } = ctx;
 				await createRelease(ctx, config);
-				const url = getGithubReleaseUrl(ctx);
+				const url = getGithubReleaseUrl(owner, repo, currentTag);
 				return success(MSG.TASK.GITHUB.END(url), dryRun);
 			}
 		}]).catch((err) => abortOnError(err, ctx));
@@ -1420,8 +1243,14 @@ var Action = class {
 //#endregion
 //#region src/cli.ts
 const pkg = readJsonFile(join(__dirname, "..", "package.json"));
-program.name("release").description(pkg.description).version(pkg.version, "-v, --version", "Print the tool version and exit.").usage("[release-type] [options]").argument("[release-type]", "Version bump type: patch | minor | major").option("-n, --dry-run", "Run in dry mode: show what would be released without making any changes.", false).option("-p, --package <pkg>", "Specify package name for mono-repo release (CI only).", "").option("--otp <code>", "One-time password for npm publish (used for 2FA).", "").option("--ci", "Enable CI mode: disable prompts and fail on missing required options.", false).option("--show-changelog", "Print the generated changelog and exit.", false).option("--show-release", "Print the version that would be released and exit.", false).helpOption("-h, --help", "Display help information.").action(async (releaseType, options) => {
-	await new Action().handle(releaseType, options);
+function withCommonOptions(cmd) {
+	return cmd.version(pkg.version, "-v, --version", "Print the tool version and exit.").usage("[release-type] [options]").argument("[release-type]", "Version bump type: patch | minor | major").option("-n, --dry-run", "Run in dry mode", false).option("-p, --package <pkg>", "Specify package name (CI only).", "").option("--otp <code>", "One-time password for npm publish.", "").option("--ci", "Enable CI mode.", false).option("--show-changelog", "Print changelog and exit.", false).option("--show-release", "Print release version and exit.", false).helpOption("-h, --help", "Display help information.");
+}
+withCommonOptions(program.name("release").description(pkg.description)).action(async (releaseType, options) => {
+	await new Action().handleRelease(releaseType, options);
+});
+withCommonOptions(program.command("prepare").description("Prepare a release (bump version, commit, tag)")).action(async (releaseType, options) => {
+	await new Action().handlePrepareRelease(releaseType, options);
 });
 program.command("init").description("Create a release configuration file").option("-f, --force", "Overwrite existing config file", false).option("-m, --monorepo", "Mono-repo project", false).action((options) => {
 	const { force = false, monorepo = false } = options;
@@ -1439,7 +1268,7 @@ program.command("init").description("Create a release configuration file").optio
   packages: [ 'demo-a', 'demo-b' ],
   getPkgDir: (pkg) => \`packages/\${ pkg }\`,
   toTag: (pkg, version) => \`\${ pkg }@\${ version }\`,
-  changelogTagPrefix: (pkg) => \`\${ pkg }@\`,
+  tagPrefix: (pkg) => \`\${ pkg }@\`,
 }`;
 	writeFileSync(configPath, `import { defineConfig } from '@peiyanlu/release'