@peiyanlu/release 0.0.2 → 0.0.3

package/dist/cli.mjs

@@ -1,23 +1,24 @@
-import path, { dirname, join, resolve } from "node:path";
+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 { blue, dim, gray, green, red, rgb, underline, yellow } from "ansis";
+import { dim, gray, green, red, rgb, underline, yellow } from "ansis";
 import { program } from "commander";
 import { cancel, confirm, group, intro, isCancel, log, outro, select, tasks, text } from "@clack/prompts";
 import { clean, coerce, gt, gte, inc, parse, prerelease, valid } from "semver";
+import { castArray, isPlainObject, isUndefined } from "@peiyanlu/ts-utils";
 import { createReadStream, existsSync, statSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+import { inspect, styleText } from "node:util";
 import { Octokit } from "@octokit/rest";
 import { contentType } from "mime-types";
 import open from "open";
 import { glob } from "tinyglobby";
-import { inspect, styleText } from "node:util";
-import { castArray, isUndefined } from "@peiyanlu/ts-utils";
+import { readFile, writeFile } from "node:fs/promises";
 
 //#region node_modules/.pnpm/tsdown@0.18.4_typescript@5.9.3/node_modules/tsdown/esm-shims.js
 const getFilename = () => fileURLToPath(import.meta.url);
 const getDirname = () => path.dirname(getFilename());
-const __dirname$1 = /* @__PURE__ */ getDirname();
+const __dirname = /* @__PURE__ */ getDirname();
 
 //#endregion
 //#region src/config.ts
@@ -46,9 +47,7 @@ const resolveConfig = async (cwd, log$1) => {
 	log$1?.(configFile);
 	return loadConfig(configFile);
 };
-const toString = (self) => Object.prototype.toString.call(self);
-const isPlainObject = (v) => toString(v) === "[object Object]";
-const isFunction = (v) => toString(v) === "[object Function]";
+const isFunction = (v) => typeof v === "function";
 const mergeConfig = (defaults, overrides) => {
 	if (!overrides) return structuredClone(defaults);
 	if (Object.keys(defaults).length === 0) return structuredClone(overrides);
@@ -67,15 +66,11 @@ const mergeConfig = (defaults, overrides) => {
 
 //#endregion
 //#region src/messages.ts
-const n = (b) => {
-	return b ? "(dry run)" : "";
-};
-const t = () => {
-	return green(Math.floor(process.uptime()));
-};
+const n = (b) => b ? "(dry run)" : "";
+const t = () => green(`${Math.floor(process.uptime())}s`);
 const MSG = {
 	INTRO: (pkgName, dryRun) => `🚀  Starting release ${yellow(pkgName)} ${n(dryRun)}`,
-	OUTRO: (dryRun) => `🎉  Release finished successfully in ${t()}s ${n(dryRun)} `,
+	OUTRO: (dryRun) => `🎉  Release finished successfully in ${t()} ${n(dryRun)}.`,
 	LOG: {
 		SHOW_VERSION: (version) => `🎉  Released ${green(version)}`,
 		SHOW_CHANGELOG: "🎉  Changelog collected",
@@ -95,11 +90,15 @@ const MSG = {
 	TASK: {
 		VERSION: {
 			START: "Bumping version",
-			END: (version) => `Version bumped to ${green(version)}`
+			END: (to) => `Version bumped: ${underline(dim(to))}`
+		},
+		CHANGELOG: {
+			START: "Generating changelog",
+			END: `Changelog generated`
 		},
 		NPM: {
 			START: "Publishing npm package",
-			END: "NPM package published"
+			END: (url) => `NPM package published: ${underline(dim(url))}`
 		},
 		GIT: {
 			START: "Creating git commit, tag & push",
@@ -107,7 +106,7 @@ const MSG = {
 		},
 		GITHUB: {
 			START: "Creating GitHub release",
-			END: "GitHub release created"
+			END: (url) => `GitHub release created: ${underline(dim(url))}`
 		}
 	},
 	PROMPT: {
@@ -121,6 +120,7 @@ const MSG = {
 		GIT_PUSH: "Push commits and tags to remote?"
 	},
 	ERROR: {
+		GIT_WORKDIR: `[git] Working dir must be clean`,
 		GIT_REGISTRY: (name) => `[git] Repository not found for ${dim(name)}`,
 		GIT_REMOTE: (name) => `[git] Remote "${dim(name)}" not found`,
 		GITHUB_TAG_EXIT: (tag) => `[github] Release or tag "${tag}" already exists`,
@@ -134,322 +134,152 @@ const MSG = {
 };
 
 //#endregion
-//#region src/prompts.ts
-const abortTask = (msg$1) => {
-	cancel(`${red("✕")} ${msg$1}`);
-	process.exit(0);
-};
-const abortOnCancel = (value) => {
-	if (isCancel(value)) abortTask("Operation cancelled.");
-};
-const abortOnError = (err) => {
-	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);
-};
-const msg = (prefix, msg$1) => {
-	log.message(gray`${rgb(33, 91, 184)(`[${prefix}]`)} ${msg$1}`);
-};
-const prompt = (msg$1) => {
-	return `${blue`?`} ${msg$1}`;
-};
-
-//#endregion
-//#region src/version/bump.ts
-const isPreRelease = (version) => {
-	return Boolean(prerelease(version));
-};
-const isValid = (version) => {
-	return Boolean(valid(version));
-};
-const parseVersion = (raw) => {
-	const next = isValid(raw) ? raw : coerce(raw)?.toString();
-	if (!next) return {};
-	const { prerelease: prerelease$1 } = parse(next);
-	const toPreRelease = Boolean(prerelease$1.length);
-	const [preId, preBase] = prerelease$1.map(String);
-	return {
-		next,
-		toPreRelease,
-		preId,
-		preBase
-	};
-};
-const getCIVersion = (current) => {
-	return inc(current, Release.PATCH);
+//#region src/github/release.ts
+const getGithubUrl = (owner, repo) => {
+	return `https://github.com/${owner}/${repo}`;
 };
-
-//#endregion
-//#region src/version/prompts.ts
-let Release = /* @__PURE__ */ function(Release$1) {
-	Release$1["MAJOR"] = "major";
-	Release$1["MINOR"] = "minor";
-	Release$1["PATCH"] = "patch";
-	return Release$1;
-}({});
-let PreRelease = /* @__PURE__ */ function(PreRelease$1) {
-	PreRelease$1["MAJOR"] = "premajor";
-	PreRelease$1["MINOR"] = "preminor";
-	PreRelease$1["PATCH"] = "prepatch";
-	PreRelease$1["RELEASE"] = "prerelease";
-	return PreRelease$1;
-}({});
-let PreId = /* @__PURE__ */ function(PreId$1) {
-	PreId$1["ALPHA"] = "alpha";
-	PreId$1["BETA"] = "beta";
-	PreId$1["RC"] = "rc";
-	PreId$1["NET"] = "next";
-	PreId$1["CANARY"] = "canary";
-	PreId$1["NIGHT"] = "nightly";
-	PreId$1["DEV"] = "dev";
-	return PreId$1;
-}({});
-const diff = (from, to) => {
-	const a = from.split(".");
-	return to.split(".").map((v, i) => v === a[i] ? dim(v) : green(v)).join(".");
+const truncateBody = (body) => {
+	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
+	return body;
 };
-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 custom = [{
-			label: "As-Is",
-			value: "ignore",
-			hint: current
-		}, {
-			label: "Custom",
-			value: "custom",
-			hint: "custom specified"
-		}];
-		const version = await select({
-			message: prompt(MSG.PROMPT.SELECT_VERSION),
-			options: [
-				...fromPreRelease ? pr : [],
-				...release,
-				...fromPreRelease ? [] : pre,
-				...custom
-			],
-			initialValue: fromPreRelease ? prerelease$1 : patch
-		});
-		abortOnCancel(version);
-		return version;
-	};
-	const inputVersion = async () => {
-		const version = await text({
-			message: prompt(MSG.PROMPT.INPUT_VERSION),
-			initialValue: current,
-			validate: (val) => {
-				if (!isValid(val)) return "Invalid version";
+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
 			}
 		});
-		abortOnCancel(version);
-		return version;
-	};
-	const type = await selectVersion();
-	const next = type === "custom" ? await inputVersion() : type === "ignore" ? current : type;
-	const parsed = parseVersion(next);
-	Object.assign(ctx.pkg, { ...parsed });
-	ctx.isIncrement = gte(next, current);
-	log.message(gray`from ${dim(current)}${eol()}  to ${diff(current, next)}`);
-	return { next };
-};
-
-//#endregion
-//#region src/defaults.ts
-const createDefaultContext = () => {
-	return {
-		ci: false,
-		release: false,
-		dryRun: false,
-		changelog: false,
-		increment: "",
-		isIncrement: false,
-		configFileExists: false,
-		pkg: {
-			current: "",
-			next: "",
-			name: "",
-			isPrivate: false,
-			fromPreRelease: false,
-			toPreRelease: false,
-			publishConfig: {
-				access: "public",
-				registry: "https://registry.npmjs.org"
-			},
-			preId: PreId.BETA,
-			preBase: "0"
-		},
-		npm: {
-			username: "",
-			otp: ""
-		},
-		git: {
-			remoteName: "origin",
-			remoteUrl: "",
-			latestTag: "",
-			previousTag: "",
-			currentTag: "",
-			isCommitted: false,
-			isTagged: false
-		},
-		github: {
-			username: "",
-			repo: "",
-			changelog: "",
-			owner: "",
-			isWeb: false,
-			skipChecks: false,
-			isReleased: false,
-			releaseId: 0,
-			releaseUrl: "",
-			uploadUrl: "",
-			discussionUrl: "",
-			token: ""
-		}
-	};
+	}));
 };
-const createDefaultConfig = (isCI) => {
-	return {
-		hooks: {
-			"before:bump": "",
-			"after:bump": "",
-			"before:publish": "",
-			"after:publish": "",
-			"before:push": "",
-			"after:push": "",
-			"before:release": "",
-			"after:release": ""
-		},
-		git: {
-			commit: isCI,
-			tag: isCI,
-			push: isCI,
-			commitMessage: "chore(release): ${version}",
-			tagMessage: "Release ${version}",
-			tagName: "${version}"
-		},
-		npm: {
-			publish: isCI,
-			tag: "",
-			allowSameVersion: false
-		},
-		github: {
-			release: isCI,
-			releaseName: "Release ${version}",
-			prerelease: false,
-			draft: false,
-			tokenRef: "GITHUB_TOKEN",
-			assets: []
-		}
-	};
+const createWebRelease = async (ctx, config) => {
+	const { pkg: { next, toPreRelease }, github: { owner, repo, changelog, releaseName } } = ctx;
+	const { github: { prerelease: prerelease$1 } } = config;
+	const github = getGithubUrl(owner, repo);
+	const url = new URL(`${github}/releases/new`);
+	url.searchParams.set("tag", next);
+	url.searchParams.set("title", releaseName ?? `Release ${next}`);
+	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 });
 };
-
-//#endregion
-//#region src/utils.ts
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const info = (msg$1) => {
-	console.log(`${rgb(33, 91, 184)(`ℹ`)} ${gray(msg$1)}`);
+const createCiRelease = async (ctx, config) => {
+	const { pkg: { next, toPreRelease }, github: { owner, repo, token, changelog, releaseName } } = 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: next,
+			target_commitish: void 0,
+			name: releaseName ?? `Release ${next}`,
+			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(next));
+		throw e;
+	}
 };
-const success = (msg$1, dryRun) => {
-	return `${(dryRun ? rgb(123, 115, 66) : green)("✔")} ${msg$1}`;
+const parseGithubUrl = (ctx) => {
+	const { git: { remoteUrl } } = ctx;
+	const [owner, repo] = parseGitHubRepo(remoteUrl);
+	Object.assign(ctx.github, {
+		owner,
+		repo
+	});
 };
-const runLifeCycleHook = async (hooks, key, dryRun) => {
-	const handler = hooks[key];
-	if (typeof handler === "function") {
-		if (!dryRun) await handler();
-		log.success(success(`${dim`run`} ${inspect(handler)}`, dryRun));
-		return;
+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);
 	}
-	return Promise.allSettled(castArray(handler).filter(Boolean).map(async (hook) => {
-		if (!dryRun) await execAsync(hook, { shell: true }).catch(console.error);
-		log.success(success(hook.replace("echo", dim("echo")), dryRun));
-	}));
 };
-const format = (str, ctx) => {
-	const { pkg: { next } } = ctx;
-	return str.replace("${version}", next);
+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 runGitProxy = (...args) => {
-	if (process.env["dryRun"]) log.message(`${dim("$")} ${gray(["git", ...args[0]].join(" "))}`);
-	return runGit(...args);
-};
 const getBranchName = () => {
-	return runGitProxy([
+	return runGit([
 		"rev-parse",
 		"--abbrev-ref",
 		"HEAD"
 	]);
 };
 const getRemoteForBranch = (branch) => {
-	return runGitProxy([
+	return runGit([
 		"config",
 		"--get",
 		`branch.${branch}.remote`
 	]);
 };
 const getStatus = () => {
-	return runGitProxy([
+	return runGit([
 		"status",
 		"--short",
 		"--untracked-files=no"
 	], { trim: false });
 };
-const gitRestore = () => {
-	return runGitProxy(["restore", "."]);
-};
 const coloredChangeset = (log$1) => {
 	const colorStatusChar = (ch) => {
 		switch (ch) {
@@ -471,11 +301,11 @@ const getRemote = async () => {
 	const remoteName = branch && await getRemoteForBranch(branch) || "origin";
 	return {
 		remoteName,
-		remoteUrl: await runGitProxy([
+		remoteUrl: await runGit([
 			"remote",
 			"get-url",
 			remoteName
-		]).catch((_) => runGitProxy([
+		]).catch((_) => runGit([
 			"config",
 			"--get",
 			`remote.${remoteName}.url`
@@ -483,7 +313,7 @@ const getRemote = async () => {
 	};
 };
 const getLatestTag = async (match = "*", exclude = "*-beta.*") => {
-	return runGitProxy([
+	return runGit([
 		"describe",
 		"--tags",
 		"--abbrev=0",
@@ -492,11 +322,11 @@ const getLatestTag = async (match = "*", exclude = "*-beta.*") => {
 	]);
 };
 const getPreviousTag = async (current) => {
-	return runGitProxy([
+	return runGit([
 		"describe",
 		"--tags",
 		"--abbrev=0",
-		`${await runGitProxy([
+		`${await runGit([
 			"rev-list",
 			"--tags",
 			current || "--skip=1",
@@ -524,98 +354,100 @@ const getLog = async (print, isIncrement) => {
 	const cmd = ["log", `--pretty=format:${print ? "* %s (%h)" : "%s %h %H"}`];
 	const { from, to } = await resolveChangelogRange(isIncrement);
 	if (from) cmd.push(`${from}...${to}`);
-	return runGitProxy(cmd, { trim: false });
+	return runGit(cmd, { trim: false });
 };
-const normalizeTag = (tag) => clean(tag) ?? tag;
-const resolveTag$1 = async (ctx, config) => {
-	const { git: { tagName: tagTemplate } } = config;
-	const latestTag = await getLatestTag() ?? "";
-	const currentTag = format(tagTemplate || ((latestTag || "").match(/^v/) ? "v${version}" : "${version}"), ctx);
-	Object.assign(ctx.git, {
-		latestTag,
-		currentTag
-	});
-	return true;
-};
-const gitCheck = async (ctx, config) => {
-	const { pkg: { name } } = ctx;
-	if (!await isGitRepo()) throw new Error(MSG.ERROR.GIT_REGISTRY(name));
-	const { remoteName, remoteUrl } = await getRemote();
-	if (!remoteUrl) throw new Error(MSG.ERROR.GIT_REMOTE(name));
-	Object.assign(ctx.git, {
-		remoteName,
-		remoteUrl
-	});
-	parseGithubUrl(ctx);
+const isWorkingDirClean = async () => {
+	return (await runGit(["status", "-s"]))?.length === 0;
 };
 const hasUpstreamBranch = async () => {
-	const branch = await runGitProxy([
+	const branch = await runGit([
 		"for-each-ref",
 		"--format=%(upstream:short)",
-		await runGitProxy(["symbolic-ref", "HEAD"])
+		await runGit(["symbolic-ref", "HEAD"])
 	]);
 	return Boolean(branch);
 };
 const getUpstreamArgs = async (remoteName) => {
 	const hasUpstream = await hasUpstreamBranch();
 	const branch = await getBranchName();
-	if (!hasUpstream) return remoteName ? [
-		"--set-upstream",
-		remoteName,
-		branch
-	] : [
+	if (!hasUpstream) return [
 		"--set-upstream",
-		"origin",
+		remoteName || "origin",
 		branch
 	];
 	if (remoteName) return [remoteName];
 	return [];
 };
+const normalizeTag = (tag) => clean(tag) ?? tag;
+const gitCheck = async (ctx, config) => {
+	const { pkg: { name } } = ctx;
+	const { git: { requireRepository, requireRemote, requireWorkDirClean } } = config;
+	if (!await isGitRepo()) if (requireRepository) throw new Error(MSG.ERROR.GIT_REGISTRY(name));
+	else {
+		ctx.noGit = true;
+		return;
+	}
+	if (requireWorkDirClean && !await isWorkingDirClean()) throw new Error(MSG.ERROR.GIT_WORKDIR);
+	const { remoteName, remoteUrl } = await getRemote();
+	if (!remoteUrl) if (requireRemote) throw new Error(MSG.ERROR.GIT_REMOTE(name));
+	else {
+		ctx.noGitHub = true;
+		return;
+	}
+	Object.assign(ctx.git, {
+		remoteName,
+		remoteUrl
+	});
+	parseGithubUrl(ctx);
+};
 const commitAndTag = async (ctx, config) => {
-	const { git: { currentTag, remoteName }, dryRun } = ctx;
-	const { git: { commit, tag, push, tagMessage, commitMessage } } = 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 runGitProxy([
+	await runGit([
 		"add",
 		".",
-		"--all",
+		addUntrackedFiles ? "--all" : "--update",
 		...args
 	]);
-	await runGitProxy([
+	await runGit([
 		"commit",
 		"--message",
-		format(commitMessage, ctx),
+		commitMessage,
+		...commitArgs,
 		...args
 	]);
 	if (!dryRun) Object.assign(ctx.git, { isCommitted: true });
 	if (tag) {
-		await runGitProxy([
+		await runGit([
 			"tag",
 			"--annotate",
 			"--message",
-			format(tagMessage, ctx),
+			tagMessage,
 			currentTag,
+			...tagArgs,
 			...args
 		]);
 		if (!dryRun) Object.assign(ctx.git, { isTagged: true });
 	}
-	if (push) await runGitProxy([
+	if (push) await runGit([
 		"push",
 		...await getUpstreamArgs(remoteName),
 		"--follow-tags",
+		...pushArgs,
 		...args
 	]);
 };
-const gitRollback = async (ctx) => {
+const gitRollback$1 = (ctx) => {
 	const { git: { currentTag, isCommitted, isTagged } } = ctx;
-	await gitRestore();
-	if (isTagged) await runGitProxy([
+	spawnSync("git", ["restore", "."]);
+	if (isTagged) spawnSync("git", [
 		"tag",
 		"--delete",
 		currentTag
 	]);
-	await runGitProxy([
+	spawnSync("git", [
 		"reset",
 		"--hard",
 		isCommitted ? "HEAD~1" : "HEAD"
@@ -623,123 +455,344 @@ const gitRollback = async (ctx) => {
 };
 
 //#endregion
-//#region src/github/release.ts
-const getGithubUrl = (owner, repo) => {
-	return `https://github.com/${owner}/${repo}`;
+//#region src/utils.ts
+const info = (msg$1) => {
+	console.log(`${rgb(33, 91, 184)(`i`)} ${gray(msg$1)}`);
 };
-const truncateBody = (body) => {
-	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
-	return body;
+const msg = (prefix, msg$1) => {
+	log.message(gray`${rgb(33, 91, 184)(`[${prefix}]`)} ${msg$1}`);
 };
-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 question = (msg$1, type) => {
+	return `${{
+		version: green,
+		git: rgb(220, 94, 62),
+		npm: rgb(186, 70, 61),
+		github: rgb(64, 110, 228)
+	}[type]`?`} ${msg$1}`;
+};
+const success = (msg$1, dryRun) => {
+	return `${(dryRun ? rgb(123, 115, 66) : green)("✔")} ${msg$1}`;
+};
+const runLifeCycleHook = async (hooks, key, dryRun) => {
+	const handler = hooks[key];
+	if (typeof handler === "function") {
+		if (!dryRun) await handler();
+		log.success(success(`${dim`run`} ${inspect(handler)}`, dryRun));
+		return;
+	}
+	return Promise.allSettled(castArray(handler).filter(Boolean).map(async (hook) => {
+		if (!dryRun) await execAsync(hook).catch(log.error);
+		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);
+};
+const formatTemplate = async (ctx, config) => {
+	const { pkg: { next } } = ctx;
+	const { git: { commitMessage: cm, tagMessage: tm, tagName }, github: { releaseName: rm } } = config;
+	const f = (s, v) => s.replace("${version}", v);
+	const latestTag = await getLatestTag() ?? "";
+	const currentTag = f(tagName || (latestTag.match(/^v/) ? "v${version}" : "${version}"), next);
+	const commitMessage = f(cm, next);
+	const tagMessage = f(tm, next);
+	const releaseName = f(rm, next);
+	Object.assign(ctx.git, {
+		latestTag,
+		currentTag,
+		commitMessage,
+		tagMessage
+	});
+	Object.assign(ctx.github, { releaseName });
+};
+
+//#endregion
+//#region src/prompts.ts
+const abortTask = (msg$1) => {
+	cancel(`${red("✕")} ${msg$1}`);
+	process.exit(0);
+};
+const abortSinglePrompt = (value) => {
+	if (isCancel(value)) abortTask("Operation cancelled.");
+};
+const abortGroupPrompt = (ctx) => {
+	ctx && gitRollback(ctx);
+	abortTask("Operation cancelled.");
+};
+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
+const isPreRelease = (version) => {
+	return Boolean(prerelease(version));
+};
+const isValid = (version) => {
+	return Boolean(valid(version));
+};
+const parseVersion = (raw) => {
+	const next = isValid(raw) ? raw : coerce(raw)?.toString();
+	if (!next) return {};
+	const { prerelease: prerelease$1 } = parse(next);
+	const toPreRelease = Boolean(prerelease$1.length);
+	const [preId, preBase] = prerelease$1.map(String);
+	return {
+		next,
+		toPreRelease,
+		preId,
+		preBase
+	};
+};
+const getCIVersion = (current) => {
+	return inc(current, Release.PATCH) ?? "";
+};
+
+//#endregion
+//#region src/version/prompts.ts
+let Release = /* @__PURE__ */ function(Release$1) {
+	Release$1["MAJOR"] = "major";
+	Release$1["MINOR"] = "minor";
+	Release$1["PATCH"] = "patch";
+	return Release$1;
+}({});
+let PreRelease = /* @__PURE__ */ function(PreRelease$1) {
+	PreRelease$1["MAJOR"] = "premajor";
+	PreRelease$1["MINOR"] = "preminor";
+	PreRelease$1["PATCH"] = "prepatch";
+	PreRelease$1["RELEASE"] = "prerelease";
+	return PreRelease$1;
+}({});
+let PreId = /* @__PURE__ */ function(PreId$1) {
+	PreId$1["ALPHA"] = "alpha";
+	PreId$1["BETA"] = "beta";
+	PreId$1["RC"] = "rc";
+	PreId$1["NET"] = "next";
+	PreId$1["CANARY"] = "canary";
+	PreId$1["NIGHT"] = "nightly";
+	PreId$1["DEV"] = "dev";
+	return PreId$1;
+}({});
+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 custom = [{
+			label: "As-Is",
+			value: "ignore",
+			hint: current
+		}, {
+			label: "Custom",
+			value: "custom",
+			hint: "custom specified"
+		}];
+		const version = await select({
+			message: question(MSG.PROMPT.SELECT_VERSION, "version"),
+			options: [
+				...fromPreRelease ? pr : [],
+				...release,
+				...fromPreRelease ? [] : pre,
+				...custom
+			],
+			initialValue: fromPreRelease ? prerelease$1 : patch
 		});
-	}));
-};
-const createWebRelease = async (ctx, config) => {
-	const { pkg: { next, toPreRelease }, github: { owner, repo, changelog } } = ctx;
-	const { github: { prerelease: prerelease$1, releaseName } } = config;
-	const github = getGithubUrl(owner, repo);
-	const url = new URL(`${github}/releases/new`);
-	url.searchParams.set("tag", next);
-	url.searchParams.set("title", format(releaseName, ctx) ?? `Release ${next}`);
-	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: { next, toPreRelease }, github: { owner, repo, token, changelog } } = ctx;
-	const { github: { prerelease: prerelease$1, releaseName, draft } } = config;
-	const octokit = new Octokit({ auth: token });
-	try {
-		const { data } = await octokit.repos.createRelease({
-			owner,
-			repo,
-			tag_name: next,
-			name: format(releaseName, ctx) ?? `Release ${next}`,
-			body: truncateBody(changelog),
-			draft: draft ?? false,
-			prerelease: (toPreRelease || prerelease$1) ?? false
-		});
-		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
+		abortSinglePrompt(version);
+		return version;
+	};
+	const inputVersion = async () => {
+		const version = await text({
+			message: question(MSG.PROMPT.INPUT_VERSION, "version"),
+			initialValue: current,
+			validate: (val) => {
+				if (!isValid(val)) return "Invalid version";
+			}
 		});
-	} catch (e) {
-		if (e?.status === 422) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(next));
-		throw e;
-	}
-};
-const parseGithubUrl = (ctx) => {
-	const { git: { remoteUrl } } = ctx;
-	const [owner, repo] = parseGitHubRepo(remoteUrl);
-	Object.assign(ctx.github, {
-		owner,
-		repo
-	});
+		abortSinglePrompt(version);
+		return version;
+	};
+	const type = await selectVersion();
+	const next = type === "custom" ? await inputVersion() : type === "ignore" ? current : type;
+	ctx.isIncrement = gte(next, current);
+	return { next };
 };
-const createRelease = async (ctx, config) => {
-	const { github: { owner, repo, skipChecks }, ci } = ctx;
-	const { github: { tokenRef, release } } = config;
-	if (!release) return;
-	const token = tokenRef ? process.env[tokenRef] : process.env.GITHUB_TOKEN;
-	if (!token) {
-		Object.assign(ctx.github, { isWeb: true });
-		if (ci && 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);
+
+//#endregion
+//#region src/defaults.ts
+const createDefaultContext = () => {
+	return {
+		isCI: false,
+		release: false,
+		showRelease: false,
+		showChangelog: false,
+		dryRun: false,
+		noGit: false,
+		noNpm: false,
+		noGitHub: false,
+		increment: "",
+		isIncrement: false,
+		configFileExists: false,
+		pkg: {
+			current: "",
+			next: "",
+			name: "",
+			isPrivate: false,
+			fromPreRelease: false,
+			toPreRelease: false,
+			publishConfig: {
+				access: "public",
+				registry: "https://registry.npmjs.org"
+			},
+			preId: PreId.BETA,
+			preBase: "0"
+		},
+		npm: {
+			username: "",
+			otp: "",
+			tag: "latest"
+		},
+		git: {
+			remoteName: "origin",
+			remoteUrl: "",
+			latestTag: "",
+			previousTag: "",
+			currentTag: "",
+			isCommitted: false,
+			isTagged: false,
+			commitMessage: "",
+			tagMessage: "",
+			tagName: ""
+		},
+		github: {
+			username: "",
+			repo: "",
+			changelog: "",
+			owner: "",
+			isWeb: false,
+			isReleased: false,
+			releaseId: 0,
+			releaseUrl: "",
+			uploadUrl: "",
+			discussionUrl: "",
+			token: "",
+			releaseName: ""
 		}
-	}
-	const { github: { isWeb }, dryRun } = ctx;
-	if (dryRun) return true;
-	if (isWeb) await createWebRelease(ctx, config);
-	else if (ci) {
-		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)}`;
+const createDefaultConfig = (isCI) => {
+	return {
+		hooks: {
+			"before:bump": "",
+			"after:bump": "",
+			"before:publish": "",
+			"after:publish": "",
+			"before:push": "",
+			"after:push": "",
+			"before:release": "",
+			"after:release": ""
+		},
+		git: {
+			commit: isCI,
+			tag: isCI,
+			push: isCI,
+			commitMessage: "chore(release): ${version}",
+			commitArgs: [],
+			tagMessage: "Release ${version}",
+			tagName: "${version}",
+			tagArgs: [],
+			pushArgs: [],
+			addUntrackedFiles: false,
+			requireRemote: true,
+			requireRepository: true,
+			requireWorkDirClean: true
+		},
+		npm: {
+			publish: isCI,
+			publishPath: ".",
+			pushArgs: [],
+			skipChecks: false
+		},
+		github: {
+			release: isCI,
+			releaseName: "Release ${version}",
+			autoGenerate: false,
+			prerelease: false,
+			draft: false,
+			tokenRef: "GITHUB_TOKEN",
+			assets: [],
+			skipChecks: false
+		},
+		changelog: {
+			infile: "CHANGELOG.md",
+			types: []
+		}
+	};
 };
 
 //#endregion
@@ -836,6 +889,13 @@ const defaultTypes = [
 		description: "破坏性变更"
 	}
 ];
+const mergeTypes = (types) => {
+	types.forEach((item) => {
+		const index = defaultTypes.findIndex((it) => it.type === item.type);
+		if (index >= 0) defaultTypes.splice(index, 1, { ...item });
+		else defaultTypes.push({ ...item });
+	});
+};
 const findType = (type) => {
 	return defaultTypes.find((item) => item.type === type)?.section ?? type;
 };
@@ -870,23 +930,20 @@ const classify = (commits) => {
 	return sections;
 };
 const renderChangelog = async (ctx, sections) => {
-	const { pkg: { next: to }, github: { owner, repo }, git: { latestTag } } = ctx;
+	const { github: { owner, repo }, git: { latestTag, currentTag } } = ctx;
 	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
 	const github = getGithubUrl(owner, repo);
-	let md;
-	if (!latestTag) md = `## ${to} (${date})${eol(2)}`;
-	else md = `## [${to}](${github}/compare/${latestTag}...${to}) (${date})${eol(2)}`;
-	for (const [type, items] of Object.entries(sections)) {
-		if (!items.length) continue;
-		md += `### ${findType(type)}${eol(2)}`;
-		for (const [desc, hash, fullHash] of items) md += `* **${type}** ${desc} [${hash}](${github}/commit/${fullHash})${eol(1)}`;
-		md += eol(2);
-	}
-	if (latestTag) {
-		md += `**Full Changelog**: ${github}/compare/${latestTag}...${to}`;
-		md += eol(3);
-	}
-	return md;
+	return [
+		latestTag ? `## [${currentTag}](${github}/compare/${latestTag}...${currentTag}) (${date})` : `## ${currentTag} (${date})`,
+		Object.entries(sections).map((entry) => {
+			const [type, items] = entry;
+			return [`### ${findType(type)}`, items.map((item) => {
+				const [desc, hash, fullHash] = item;
+				return `* **${type}** ${desc} [${hash}](${github}/commit/${fullHash})`;
+			}).join(eol(1))].join(eol(2));
+		}).join(eol(2)),
+		latestTag ? `**Full Changelog**: ${github}/compare/${latestTag}...${currentTag}` : ""
+	].join(eol(3));
 };
 const generateChangelog = async (ctx) => {
 	const { isIncrement } = ctx;
@@ -896,36 +953,46 @@ const generateChangelog = async (ctx) => {
 	Object.assign(ctx.github, { changelog });
 	return changelog;
 };
-const updateChangelog = async (newContent) => {
-	const file = "CHANGELOG.md";
-	const title = `# Changelog${eol(3)}`;
-	await writeFile(file, `${(existsSync(file) && await readFile(file, "utf-8") || title).replace(/* @__PURE__ */ new RegExp(`^${title}`), `${title}${newContent}`).trim()}${eol()}`);
-	await runGitProxy(["add", file]);
+const updateChangelog = async (file, newContent) => {
+	const infile = file || "CHANGELOG.md";
+	const target = join(process.cwd(), infile);
+	const SHORT_TITLE = "# Changelog";
+	const exist = (existsSync(target) ? await readFile(target, "utf-8") : "").replace(/\r\n/g, "\n");
+	await writeFile(target, [
+		SHORT_TITLE,
+		newContent,
+		exist.startsWith(SHORT_TITLE) ? exist.slice(11) : exist
+	].map((k) => k.trim()).join(eol(4)) + eol());
+	await runGit(["add", infile]);
+};
+const writeChangelog = async (ctx, config) => {
+	const { changelog: { infile, types } } = config;
+	mergeTypes(types);
+	await updateChangelog(infile, await generateChangelog(ctx));
 };
 
 //#endregion
 //#region src/git/prompts.ts
 const runGitPrompts = async (ctx, config) => {
-	const { git: { currentTag }, configFileExists: cfe, dryRun } = ctx;
-	const { git: { commit, tag, push, commitMessage } } = config;
+	const { git: { currentTag, commitMessage }, configFileExists: cfe, dryRun } = ctx;
+	const { git: { commit, tag, push } } = config;
 	const logs = [];
-	const cMsg = format(commitMessage, ctx);
 	const shouldPrompt = (val) => isUndefined(val) || dryRun;
 	const { log: _, ...reset } = await group({
 		commit: () => {
-			return shouldPrompt(commit) ? confirm({ message: prompt(MSG.PROMPT.GIT_COMMIT(cMsg)) }) : (() => {
+			return shouldPrompt(commit) ? confirm({ message: question(MSG.PROMPT.GIT_COMMIT(commitMessage), "git") }) : (() => {
 				logs.push(yellow`git.commit`);
 				return Promise.resolve(commit);
 			})();
 		},
 		tag: () => {
-			return shouldPrompt(tag) ? confirm({ message: prompt(MSG.PROMPT.GIT_TAG(currentTag)) }) : (() => {
+			return shouldPrompt(tag) ? confirm({ message: question(MSG.PROMPT.GIT_TAG(currentTag), "git") }) : (() => {
 				logs.push(yellow`git.tag`);
 				return Promise.resolve(tag);
 			})();
 		},
 		push: () => {
-			return shouldPrompt(push) ? confirm({ message: prompt(MSG.PROMPT.GIT_PUSH) }) : (() => {
+			return shouldPrompt(push) ? confirm({ message: question(MSG.PROMPT.GIT_PUSH, "git") }) : (() => {
 				logs.push(yellow`git.push`);
 				return Promise.resolve(push);
 			})();
@@ -934,9 +1001,8 @@ const runGitPrompts = async (ctx, config) => {
 			if (logs.length) msg("GIT", `Using ${cfe ? "user" : "default"} config: ${logs.join(", ")}`);
 			return Promise.resolve();
 		}
-	}, { onCancel: async ({ results }) => {
-		await gitRollback(ctx);
-		abortTask("Operation cancelled.");
+	}, { onCancel: ({ results }) => {
+		abortGroupPrompt(ctx);
 	} });
 	Object.assign(config.git, reset);
 };
@@ -944,13 +1010,12 @@ const runGitPrompts = async (ctx, config) => {
 //#endregion
 //#region src/github/prompts.ts
 const runGithubPrompts = async (ctx, config) => {
-	const { configFileExists: cfe, dryRun } = ctx;
-	const { github: { release, releaseName } } = config;
+	const { configFileExists: cfe, dryRun, github: { releaseName } } = ctx;
+	const { github: { release } } = config;
 	const logs = [];
-	const title = format(releaseName, ctx);
 	const shouldPrompt = (val) => isUndefined(val) || dryRun;
 	const res = await group({
-		release: () => shouldPrompt(release) ? confirm({ message: prompt(MSG.PROMPT.GITHUB_RELEASE(title)) }) : (() => {
+		release: () => shouldPrompt(release) ? confirm({ message: question(MSG.PROMPT.GITHUB_RELEASE(releaseName), "github") }) : (() => {
 			logs.push(yellow`github.release`);
 			return Promise.resolve(release);
 		})(),
@@ -958,9 +1023,8 @@ const runGithubPrompts = async (ctx, config) => {
 			if (logs.length) msg("GITHUB", `Using ${cfe ? "user" : "default"} config: ${logs.join(", ")}`);
 			return Promise.resolve();
 		}
-	}, { onCancel: async ({ results }) => {
-		await gitRollback(ctx);
-		abortTask("Operation cancelled.");
+	}, { onCancel: ({ results }) => {
+		abortGroupPrompt(ctx);
 	} });
 	Object.assign(config.github, { release: res.release });
 	return res;
@@ -975,7 +1039,7 @@ const runNpmPublishPrompts = async (ctx, config) => {
 	const target = `${name}@${next}`;
 	const shouldPrompt = (val) => isUndefined(val) || dryRun;
 	const res = await group({
-		publish: () => shouldPrompt(publish) ? confirm({ message: prompt(MSG.PROMPT.NPM_PUBLISH(target)) }) : (() => {
+		publish: () => shouldPrompt(publish) ? confirm({ message: question(MSG.PROMPT.NPM_PUBLISH(target), "npm") }) : (() => {
 			logs.push(yellow`npm.publish`);
 			return Promise.resolve(publish);
 		})(),
@@ -984,16 +1048,14 @@ const runNpmPublishPrompts = async (ctx, config) => {
 			return Promise.resolve();
 		}
 	}, { onCancel: async ({ results }) => {
-		await gitRollback(ctx);
-		abortTask("Operation cancelled.");
+		abortGroupPrompt(ctx);
 	} });
 	Object.assign(config.npm, { publish: res.publish });
 	return res;
 };
 const runNpmOptPrompts = async (ctx, config) => {
-	const res = await group({ otp: () => text({ message: MSG.PROMPT.NPM_OTP }) }, { onCancel: async ({ results }) => {
-		await gitRollback(ctx);
-		abortTask("Operation cancelled.");
+	const res = await group({ otp: () => text({ message: MSG.PROMPT.NPM_OTP }) }, { onCancel: ({ results }) => {
+		abortGroupPrompt(ctx);
 	} });
 	Object.assign(ctx.npm, { otp: res.otp });
 	return res;
@@ -1001,43 +1063,27 @@ const runNpmOptPrompts = async (ctx, config) => {
 
 //#endregion
 //#region src/npm/publish.ts
-const runNpmProxy = (...args) => {
-	if (process.env["dryRun"]) log.message(`${dim("$")} ${gray(["npm", ...args[0]].join(" "))}`);
-	return runNpm(...args);
-};
-const DEFAULT_TAG = "latest";
-const DEFAULT_TAG_PRERELEASE = "next";
 const getRegistry = (publishConfig = {}) => {
 	return (publishConfig.registry ? [publishConfig.registry] : Object.keys(publishConfig).filter((key) => key.endsWith("registry")).map((key) => publishConfig[key]))[0];
 };
 const isRegistryUp = async (registry) => {
-	return void 0 !== await runNpmProxy(["ping", ...registry ? [`--registry ${registry}`] : []]);
+	return void 0 !== await runNpm(["ping", ...registry ? ["--registry", registry] : []]);
 };
 const isAuthenticated = (registry) => {
-	return runNpmProxy(["whoami", ...registry ? [`--registry ${registry}`] : []]);
+	return runNpm(["whoami", ...registry ? ["--registry", registry] : []]);
 };
 const getLatestRegistryVersion = (name, tag, registry) => {
-	const registryArg = registry ? [`--registry ${registry}`] : [];
-	return runNpmProxy([
+	const registryArg = registry ? ["--registry", registry] : [];
+	return runNpm([
 		"show",
 		`${name}@${tag}`,
 		"version",
 		...registryArg
 	]);
 };
-const getRegistryTags = async (name, registry) => {
-	const res = await runNpmProxy([
-		"view",
-		name,
-		"dist-tags",
-		"--json",
-		...registry ? [`--registry ${registry}`] : []
-	]);
-	return Object.keys(JSON.parse(res || "{}"));
-};
 const bump = (version, allowSameVersion, args = []) => {
 	allowSameVersion && args.push(`--allow-same-version`);
-	return runNpmProxy([
+	return runNpm([
 		"version",
 		version,
 		"--no-git-tag-version",
@@ -1045,21 +1091,16 @@ const bump = (version, allowSameVersion, args = []) => {
 		...args
 	]);
 };
-const guessPreReleaseTag = async (name) => {
-	return (await getRegistryTags(name)).filter((tag) => DEFAULT_TAG !== tag)[0] ?? DEFAULT_TAG_PRERELEASE;
-};
-const resolveTag = async (ctx, config) => {
-	const { npm: { tag } } = config;
-	const { pkg: { name, current } } = ctx;
-	const { toPreRelease, preId } = parseVersion(current);
-	if (!toPreRelease) return DEFAULT_TAG;
-	else return tag || preId || await guessPreReleaseTag(name);
+const resolveTag = async (version) => {
+	const { toPreRelease, preId } = parseVersion(version);
+	if (!toPreRelease) return "latest";
+	else return preId || "next";
 };
 const isCollaborator = async (ctx) => {
 	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
 	const registry = getRegistry(publishConfig);
-	const registryArg = registry ? [`--registry ${registry}`] : [];
-	let npmVersion = await runNpmProxy(["--version"]);
+	const registryArg = registry ? ["--registry", registry] : [];
+	let npmVersion = await runNpm(["--version"]);
 	let accessCommand;
 	if (gt(npmVersion, "9.0.0")) accessCommand = [
 		"access",
@@ -1068,7 +1109,7 @@ const isCollaborator = async (ctx) => {
 		"--json"
 	];
 	else accessCommand = ["access", "ls-collaborators"];
-	const res = await runNpmProxy([
+	const res = await runNpm([
 		...accessCommand,
 		name,
 		...registryArg
@@ -1084,40 +1125,53 @@ const getPackageUrl = (ctx) => {
 	return `https://www.npmjs.com/package/${name}/v/${next}`;
 };
 const npmCheck = async (ctx, config) => {
-	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
+	const { pkg: { name, current, publishConfig }, npm: { username } } = ctx;
+	const { npm: { skipChecks } } = config;
 	const registry = getRegistry(publishConfig);
-	const tag = await resolveTag(ctx, config);
+	const tag = await resolveTag(current);
+	Object.assign(ctx.npm, { tag });
+	if (skipChecks) return "";
+	if (!await isRegistryUp()) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
 	const getUser = async () => {
 		const username$1 = await isAuthenticated(registry);
 		if (!username$1) return false;
 		Object.assign(ctx.npm, { username: username$1 });
 		return true;
 	};
-	if (!await isRegistryUp()) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
 	if (!await getUser()) throw new Error(MSG.ERROR.NPM_AUTH);
 	const latestPublish = await getLatestRegistryVersion(name, tag, registry);
 	if (latestPublish) {
 		if (!await isCollaborator(ctx)) throw new Error(MSG.ERROR.NPM_USER(username, name));
 	}
-	return dim(latestPublish ? `(latest is ${latestPublish})` : "(new publish)");
+	return underline(dim(latestPublish ? `(latest is ${latestPublish})` : "(new publish)"));
 };
 const isOtpError = (err) => /one-time password|otp/i.test(err.message);
 const publishNpm = async (ctx, config) => {
-	const { dryRun, npm: { otp } } = ctx;
-	const { npm: { publish, tag } } = config;
+	const { dryRun, npm: { otp, tag }, pkg: { publishConfig } } = ctx;
+	const { npm: { publish, publishPath, pushArgs } } = config;
+	const registry = getRegistry(publishConfig);
 	if (!publish) return;
-	const args = ["publish"];
-	if (tag) args.push("--tag", tag);
-	if (otp) args.push("--otp", otp);
-	if (dryRun) args.push("--dry-run");
-	return runNpmProxy(args);
+	const otpArgs = otp ? ["--otp", otp] : [];
+	const dryRunArg = dryRun ? ["--dry-run"] : [];
+	const registryArg = registry ? ["--registry", registry] : [];
+	return runNpm([
+		"publish",
+		publishPath,
+		"--tag",
+		tag,
+		"--workspaces=false",
+		...otpArgs,
+		...pushArgs,
+		...registryArg,
+		...dryRunArg
+	]);
 };
 
 //#endregion
 //#region src/action.ts
 var Action = class {
 	async handle(cmdArgs, options) {
-		const { version: cVersion, name: cName } = readJsonFile(join(__dirname$1, "../package.json"));
+		const { version: cVersion, name: cName } = readJsonFile(join(__dirname, "../package.json"));
 		info(`${cName} ${dim(`v${cVersion}`)} `);
 		const { otp, ...others } = options;
 		const { showChangelog, showRelease, ci, dryRun } = Object.fromEntries(Object.entries(others).map(([k, v]) => [k, Boolean(v)]));
@@ -1131,10 +1185,12 @@ var Action = class {
 		const ctx = mergeConfig(createDefaultContext(), {
 			configFileExists: Object.keys(local).length > 0,
 			dryRun,
+			showRelease,
+			showChangelog,
 			npm: { otp: String(otp) },
 			increment: cmdArgs,
 			isIncrement: true,
-			ci: [
+			isCI: [
 				ci,
 				showChangelog,
 				showRelease,
@@ -1146,14 +1202,25 @@ var Action = class {
 				isPrivate: pkgPrivate,
 				fromPreRelease: isPreRelease(pkgVersion),
 				current: pkgVersion,
-				next: "",
+				next: nextVersion,
 				toPreRelease: false,
 				publishConfig: { ...publishConfig }
-			}
+			},
+			noNpm: pkgPrivate
 		});
 		console.log();
 		intro(MSG.INTRO(pkgName, dryRun));
-		const { hooks } = config;
+		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));
+	}
+	async checkTask(ctx, config) {
+		const { noNpm, dryRun } = ctx;
 		await tasks([{
 			title: MSG.CHECK.GIT.CHECKING,
 			task: async () => {
@@ -1167,73 +1234,58 @@ var Action = class {
 				const msg$1 = await npmCheck(ctx, config);
 				const { pkg: { publishConfig: { registry } } } = ctx;
 				return success(MSG.CHECK.NPM.CHECKED(registry, msg$1), dryRun);
-			}
+			},
+			enabled: !noNpm
 		}]).catch(abortOnError);
-		{
-			const { pkg: { current, next }, isIncrement, ci: ci$1 } = ctx;
-			if (ci$1) {
-				if (!next && isIncrement) {
-					const next$1 = nextVersion || getCIVersion(current);
-					if (next$1) {
-						const parsed = parseVersion(next$1);
-						Object.assign(ctx.pkg, { ...parsed });
-					}
-				}
-				if (showRelease) {
-					const { pkg: { next: next$1 } } = ctx;
-					taskEnd(MSG.LOG.SHOW_VERSION(next$1));
-				}
-			}
-		}
-		{
-			const logStr = await getLog(true, ctx.isIncrement);
-			if (logStr) {
-				msg("GIT", `Changelog:${eol(2)}` + dim(logStr));
-				if (showChangelog) taskEnd(MSG.LOG.SHOW_CHANGELOG);
-			} else msg("GIT", MSG.LOG.CHANGELOG_EMPTY);
-		}
-		{
-			const { pkg: { next }, isIncrement } = ctx;
-			if (!next && isIncrement) await runVersionPrompts(ctx, config);
-			await runLifeCycleHook(hooks, "before:bump", dryRun);
-			await tasks([{
-				title: MSG.TASK.VERSION.START,
-				task: async () => {
-					const { pkg: { next: next$1 }, isIncrement: isIncrement$1 } = ctx;
-					await bump(next$1, isIncrement$1);
-					await resolveTag$1(ctx, config);
-					await updateChangelog(await generateChangelog(ctx));
-					return success(MSG.TASK.VERSION.END(next$1), dryRun);
-				}
-			}]).catch(abortOnError);
-			await runLifeCycleHook(hooks, "after:bump", dryRun);
-		}
-		{
-			const changeset = await getStatus();
-			if (changeset) msg("GIT", `Changes:${eol(2)}` + coloredChangeset(changeset));
-			else msg("GIT", MSG.LOG.CHANGES_EMPTY);
+	}
+	async bumpTask(ctx, config) {
+		const { pkg: { current }, dryRun, isCI, showRelease, showChangelog } = ctx;
+		const { hooks } = 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);
+			Object.assign(ctx.pkg, { ...parsed });
 		}
-		{
-			const { pkg: { isPrivate }, ci: ci$1 } = ctx;
-			if (!isPrivate) {
-				await runNpmPublishPrompts(ctx, config);
-				await runLifeCycleHook(hooks, "before:publish", dryRun);
-				await tasks([{
-					title: MSG.TASK.NPM.START,
-					task: async () => {
-						await publishNpm(ctx, config).catch(async (err) => {
-							if (isOtpError(err) && !ci$1) {
-								await runNpmOptPrompts(ctx, config);
-								await publishNpm(ctx, config);
-							} else throw err;
-						});
-						const url = getPackageUrl(ctx);
-						return success(MSG.TASK.NPM.END + `: ${url}`, dryRun);
-					}
-				}]).catch(abortOnError);
-				await runLifeCycleHook(hooks, "after:publish", dryRun);
+		const { pkg: { next }, isIncrement } = ctx;
+		if (showRelease) taskEnd(MSG.LOG.SHOW_VERSION(next));
+		await runLifeCycleHook(hooks, "before:bump", dryRun);
+		await tasks([{
+			title: MSG.TASK.VERSION.START,
+			task: async () => {
+				await bump(next, isIncrement);
+				await formatTemplate(ctx, config);
+				const to = `(${current}...${diff(current, next)})`;
+				return success(MSG.TASK.VERSION.END(to), dryRun);
 			}
-		}
+		}]).catch((err) => abortOnError(err, ctx));
+		await runLifeCycleHook(hooks, "after:bump", dryRun);
+		const logStr = (await getLog(true, isIncrement))?.split("\n").filter((line) => /^(\*\s+)?(\w+):\s(.+)\s\((\w{7})\)$/.test(line)).join("\n");
+		if (logStr) {
+			msg("GIT", `Changelog:${eol(2)}` + dim(logStr));
+			if (showChangelog) taskEnd(MSG.LOG.SHOW_CHANGELOG);
+		} else msg("GIT", MSG.LOG.CHANGELOG_EMPTY);
+		const changeset = await getStatus();
+		if (changeset) msg("GIT", `Changes:${eol(2)}` + coloredChangeset(changeset));
+		else msg("GIT", MSG.LOG.CHANGES_EMPTY);
+	}
+	async changelogTask(ctx, config) {
+		const { isIncrement, dryRun } = ctx;
+		await tasks([{
+			title: MSG.TASK.CHANGELOG.START,
+			task: async () => {
+				await writeChangelog(ctx, config);
+				return success(MSG.TASK.CHANGELOG.END, dryRun);
+			},
+			enabled: isIncrement
+		}]).catch((err) => abortOnError(err, ctx));
+	}
+	async gitTask(ctx, config) {
+		const { noGit, dryRun } = ctx;
+		const { hooks } = config;
+		if (noGit) return;
 		await runGitPrompts(ctx, config);
 		await runLifeCycleHook(hooks, "before:push", dryRun);
 		await tasks([{
@@ -1242,8 +1294,34 @@ var Action = class {
 				await commitAndTag(ctx, config);
 				return success(MSG.TASK.GIT.END, dryRun);
 			}
-		}]).catch(abortOnError);
+		}]).catch((err) => abortOnError(err, ctx));
 		await runLifeCycleHook(hooks, "after:push", dryRun);
+	}
+	async npmTask(ctx, config) {
+		const { noNpm, dryRun, isCI } = ctx;
+		const { hooks } = config;
+		if (noNpm) return;
+		await runNpmPublishPrompts(ctx, config);
+		await runLifeCycleHook(hooks, "before:publish", dryRun);
+		await tasks([{
+			title: MSG.TASK.NPM.START,
+			task: async () => {
+				await publishNpm(ctx, config).catch(async (err) => {
+					if (isOtpError(err) && !isCI) {
+						await runNpmOptPrompts(ctx, config);
+						await publishNpm(ctx, config);
+					} else throw err;
+				});
+				const url = getPackageUrl(ctx);
+				return success(MSG.TASK.NPM.END(url), dryRun);
+			}
+		}]).catch((err) => abortOnError(err, ctx));
+		await runLifeCycleHook(hooks, "after:publish", dryRun);
+	}
+	async githubTask(ctx, config) {
+		const { noGitHub, dryRun } = ctx;
+		const { hooks } = config;
+		if (noGitHub) return;
 		await runGithubPrompts(ctx, config);
 		await runLifeCycleHook(hooks, "before:release", dryRun);
 		await tasks([{
@@ -1251,18 +1329,16 @@ var Action = class {
 			task: async () => {
 				await createRelease(ctx, config);
 				const url = getGithubReleaseUrl(ctx);
-				return success(MSG.TASK.GITHUB.END + `: ${url}`, dryRun);
+				return success(MSG.TASK.GITHUB.END(url), dryRun);
 			}
-		}]).catch(abortOnError);
+		}]).catch((err) => abortOnError(err, ctx));
 		await runLifeCycleHook(hooks, "after:release", dryRun);
-		if (dryRun) await gitRollback(ctx);
-		taskEnd(MSG.OUTRO(dryRun));
 	}
 };
 
 //#endregion
 //#region src/cli.ts
-const pkg = readJsonFile(join(__dirname$1, "..", "package.json"));
+const pkg = readJsonFile(join(__dirname, "..", "package.json"));
 program.name(pkg.name).description(pkg.description).version(pkg.version, "-v, --version", "Output the current version.").usage("[ARGUMENT] [OPTION]...").argument("[argument]", "patch|minor|major").option("-n, --dry-run", "Report actions that would be performed without writing out results.", false).option("--ci", "CI mode", false).option("--otp", "npm publish otp", "").option("--show-changelog", "Skip npm publish", false).option("--show-release", "Skip github release", false).action(async (argName, options) => {
 	await new Action().handle(argName, options);
 }).helpOption("-h, --help", "Output usage information.").parse(process.argv);