@peiyanlu/release 0.0.1 → 0.0.3

package/dist/cli.mjs

@@ -1,24 +1,24 @@
-import { execAsync, isGitRepo, readJsonFile } from "@peiyanlu/cli-utils";
-import { blue, dim, gray, green, red, rgb, yellow } from "ansis";
-import { program } from "commander";
-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 { 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 { inspect, styleText } from "node:util";
 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 { EOL } from "node:os";
-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 { spawn } from "node:child_process";
+import { readFile, writeFile } from "node:fs/promises";
 
-//#region node_modules/.pnpm/tsdown@0.18.2_typescript@5.9.3/node_modules/tsdown/esm-shims.js
+//#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
@@ -47,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);
@@ -66,57 +64,13 @@ const mergeConfig = (defaults, overrides) => {
 	return result;
 };
 
-//#endregion
-//#region src/utils.ts
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-function joinUrl(input) {
-	const temps = Array.isArray(input) ? input : [...arguments];
-	if (temps.length === 0) return "";
-	const result = [];
-	const parts = [...temps];
-	/** 协议正则 */
-	const PROTOCOL_RE = /^[^/:]+:\/*$/;
-	const FILE_PROTOCOL_RE = /^file:\/\/\//;
-	if (PROTOCOL_RE.test(parts[0]) && parts.length > 1) {
-		parts[1] = parts[0] + parts[1];
-		parts.shift();
-	}
-	if (FILE_PROTOCOL_RE.test(parts[0])) parts[0] = parts[0].replace(/^([^/:]+):\/*/, "$1:///");
-	else parts[0] = parts[0].replace(/^([^/:]+):\/*/, "$1://");
-	parts.forEach((part, index) => {
-		if (!part) return;
-		let segment = part;
-		if (index > 0) segment = segment.replace(/^\/+/, "");
-		if (index < parts.length - 1) segment = segment.replace(/\/+$/, "");
-		else segment = segment.replace(/\/+$/, "/");
-		result.push(segment);
-	});
-	let url = result.join("/");
-	url = url.replace(/\/(\?|&|#[^!])/g, "$1");
-	const [base, ...queryParts] = url.split("?");
-	url = base + (queryParts.length ? "?" + queryParts.join("&") : "");
-	return url;
-}
-const isUndefined = (val) => {
-	return void 0 === val;
-};
-const eol = (n$1 = 1) => EOL.repeat(n$1);
-const underline = (text$1) => {
-	return styleText(["dim", "underline"], text$1);
-};
-const castArray = (arr) => {
-	return Array.isArray(arr) ? arr : [arr];
-};
-
 //#endregion
 //#region src/messages.ts
-const n = (b) => {
-	return b ? " (dry run)" : "";
-};
+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${n(dryRun)}`,
+	INTRO: (pkgName, dryRun) => `🚀  Starting release ${yellow(pkgName)} ${n(dryRun)}`,
+	OUTRO: (dryRun) => `🎉  Release finished successfully in ${t()} ${n(dryRun)}.`,
 	LOG: {
 		SHOW_VERSION: (version) => `🎉  Released ${green(version)}`,
 		SHOW_CHANGELOG: "🎉  Changelog collected",
@@ -126,21 +80,25 @@ const MSG = {
 	CHECK: {
 		GIT: {
 			CHECKING: "Checking Git repository",
-			CHECKED: (name, url) => `Git remote resolved: ${dim(name)} → ${underline(url)}`
+			CHECKED: (name, url) => `Git remote resolved: ${dim(name)} → ${underline(dim(url))}`
 		},
 		NPM: {
 			CHECKING: "Checking npm registry",
-			CHECKED: (registry, msg$1) => `NPM registry: ${underline(registry)}${msg$1 ? ` ${msg$1}` : ""}`
+			CHECKED: (registry, msg$1) => `NPM registry: ${underline(dim(registry))}${msg$1 ? ` ${msg$1}` : ""}`
 		}
 	},
 	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",
@@ -148,333 +106,159 @@ const MSG = {
 		},
 		GITHUB: {
 			START: "Creating GitHub release",
-			END: "GitHub release created"
+			END: (url) => `GitHub release created: ${underline(dim(url))}`
 		}
 	},
 	PROMPT: {
 		SELECT_VERSION: "Select version bump:",
 		INPUT_VERSION: "Enter custom version:",
-		NPM_PUBLISH: (pkg$1) => `Publish to npm ${underline(`(${pkg$1})`)}?`,
+		NPM_PUBLISH: (pkg$1) => `Publish to npm ${underline(dim`(${pkg$1})`)}?`,
 		NPM_OTP: "Enter npm one-time password (OTP):",
-		GITHUB_RELEASE: (title) => `Create a new GitHub release ${underline(`(${title})`)}?`,
-		GIT_COMMIT: (msg$1) => `Create git commit ${underline(`(${msg$1})`)}?`,
-		GIT_TAG: (msg$1) => `Create git tag ${underline(`(${msg$1})`)}?`,
+		GITHUB_RELEASE: (title) => `Create a new GitHub release ${underline(dim`(${title})`)}?`,
+		GIT_COMMIT: (msg$1) => `Create git commit ${underline(dim`(${msg$1})`)}?`,
+		GIT_TAG: (msg$1) => `Create git tag ${underline(dim`(${msg$1})`)}?`,
 		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`,
 		GITHUB_TOKEN: (tokenRef) => `[github] Missing GitHub token. Please set ${yellow(tokenRef ?? "GITHUB_TOKEN")}`,
 		GITHUB_AUTH: "[github] Invalid GitHub token or insufficient permissions",
 		GITHUB_USER: "[github] User does not have permission to create releases",
-		NPM_REGISTRY: (registry) => `[npm] Unable to reach npm registry ${underline(registry)}`,
+		NPM_REGISTRY: (registry) => `[npm] Unable to reach npm registry ${underline(dim(registry))}`,
 		NPM_AUTH: `[npm] Not authenticated with npm. Please run ${yellow("npm login")} and try again.`,
 		NPM_USER: (user, name) => `[npm] User ${dim(user)} is not a collaborator of ${dim(name)}.`
 	}
 };
 
 //#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));
+//#region src/github/release.ts
+const getGithubUrl = (owner, repo) => {
+	return `https://github.com/${owner}/${repo}`;
 };
-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 truncateBody = (body) => {
+	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
+	return body;
 };
-const getCIVersion = (current) => {
-	return inc(current, Release.PATCH);
+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
+			}
+		});
+	}));
 };
-
-//#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 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 });
 };
-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
+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"
 		});
-		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 { 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
 		});
-		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)}
-      to ${diff(current, next)}
-  `);
-	return { next };
+	} catch (e) {
+		if (e?.status === 422) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(next));
+		throw e;
+	}
 };
-
-//#endregion
-//#region src/defaults.ts
-const createDefaultContext = () => {
-	return {
-		ci: false,
-		release: false,
-		noNpm: false,
-		dryRun: false,
-		changelog: false,
-		increment: "",
-		isIncrement: false,
-		noGithub: false,
-		pkg: {
-			current: "",
-			next: "",
-			name: "",
-			isPrivate: false,
-			fromPreRelease: false,
-			toPreRelease: false,
-			publishConfig: {
-				access: "public",
-				registry: "https://registry.npmjs.org",
-				publicPath: ""
-			},
-			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 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 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 getGithubReleaseUrl = (ctx) => {
+	const { github: { owner, repo }, git: { currentTag } } = ctx;
+	return `${getGithubUrl(owner, repo)}/releases/tag/${normalizeTag(currentTag)}`;
 };
 
 //#endregion
 //#region src/git/commit.ts
-const spawnAsync = (cmd, args, options) => {
-	return new Promise((resolve$1) => {
-		const { trim, error, dryRun, ...others } = options ?? {};
-		const fullCmd = [cmd, ...args].join(" ");
-		const dim$1 = (text$1) => styleText(["dim"], text$1);
-		const red$1 = (text$1) => styleText(["red"], text$1);
-		if (dryRun) {
-			console.log(`${dim$1("[dry-run]")} ${fullCmd}`);
-			return resolve$1(void 0);
-		}
-		const child = spawn(cmd, args, { ...others });
-		let stdout = "";
-		child.stdout?.setEncoding("utf-8");
-		child.stdout?.on("data", (data) => stdout += trim ? data.trim() : data);
-		let stderr = "";
-		child.stderr?.setEncoding("utf-8");
-		child.stderr?.on("data", (data) => stderr += trim ? data.trim() : data);
-		child.on("close", (code) => {
-			if (stderr) {
-				const err = `${red$1("spawnAsync")} ${dim$1(fullCmd)} ${stderr}`;
-				switch (error) {
-					case "log":
-						console.error(err);
-						break;
-					case "throw": throw new Error(err);
-				}
-			}
-			resolve$1(0 === code ? stdout : void 0);
-		});
-	});
-};
-const runGit = async (args, trim = true) => {
-	return spawnAsync("git", args, { trim });
-};
 const getBranchName = () => {
 	return runGit([
 		"rev-parse",
@@ -494,10 +278,7 @@ const getStatus = () => {
 		"status",
 		"--short",
 		"--untracked-files=no"
-	], false);
-};
-const gitRestore = () => {
-	return runGit(["restore", "."]);
+	], { trim: false });
 };
 const coloredChangeset = (log$1) => {
 	const colorStatusChar = (ch) => {
@@ -531,10 +312,6 @@ const getRemote = async () => {
 		]))
 	};
 };
-const parseGitHubRepo = (url) => {
-	const match = url.trim().match(/github(?:\.com)?[:/](.+?)\/(.+?)(\/.+?)?(\.git)?$/);
-	return match ? match.slice(1, 3) : [];
-};
 const getLatestTag = async (match = "*", exclude = "*-beta.*") => {
 	return runGit([
 		"describe",
@@ -577,29 +354,10 @@ 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 runGit(cmd, 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;
+	return runGit(cmd, { trim: false });
 };
-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 runGit([
@@ -612,37 +370,52 @@ const hasUpstreamBranch = async () => {
 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 format = (str, ctx) => {
-	const { pkg: { next } } = ctx;
-	return str.replace("${version}", next);
+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 runGit([
 		"add",
 		".",
-		"--all",
+		addUntrackedFiles ? "--all" : "--update",
 		...args
 	]);
 	await runGit([
 		"commit",
 		"--message",
-		format(commitMessage, ctx),
+		commitMessage,
+		...commitArgs,
 		...args
 	]);
 	if (!dryRun) Object.assign(ctx.git, { isCommitted: true });
@@ -651,8 +424,9 @@ const commitAndTag = async (ctx, config) => {
 			"tag",
 			"--annotate",
 			"--message",
-			format(tagMessage, ctx),
+			tagMessage,
 			currentTag,
+			...tagArgs,
 			...args
 		]);
 		if (!dryRun) Object.assign(ctx.git, { isTagged: true });
@@ -661,18 +435,19 @@ const commitAndTag = async (ctx, config) => {
 		"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 runGit([
+	spawnSync("git", ["restore", "."]);
+	if (isTagged) spawnSync("git", [
 		"tag",
 		"--delete",
 		currentTag
 	]);
-	await runGit([
+	spawnSync("git", [
 		"reset",
 		"--hard",
 		isCommitted ? "HEAD~1" : "HEAD"
@@ -680,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
@@ -893,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;
 };
@@ -927,24 +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);
-	const eol$1 = (n$1) => EOL.repeat(n$1);
-	let md;
-	if (!latestTag) md = `## ${to} (${date})${eol$1(2)}`;
-	else md = `## [${to}](${github}/compare/${latestTag}...${to}) (${date})${eol$1(2)}`;
-	for (const [type, items] of Object.entries(sections)) {
-		if (!items.length) continue;
-		md += `### ${findType(type)}${eol$1(2)}`;
-		for (const [desc, hash, fullHash] of items) md += `* **${type}** ${desc} [${hash}](${github}/commit/${fullHash})${eol$1(1)}`;
-		md += eol$1(2);
-	}
-	if (latestTag) {
-		md += `**Full Changelog**: ${github}/compare/${latestTag}...${to}`;
-		md += eol$1(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;
@@ -954,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 runGit(["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);
 			})();
@@ -992,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);
 };
@@ -1002,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);
 		})(),
@@ -1016,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;
@@ -1033,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);
 		})(),
@@ -1042,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;
@@ -1059,22 +1063,17 @@ const runNpmOptPrompts = async (ctx, config) => {
 
 //#endregion
 //#region src/npm/publish.ts
-const DEFAULT_TAG = "latest";
-const DEFAULT_TAG_PRERELEASE = "next";
-const runNpm = (args) => {
-	return execAsync(["npm", ...args].join(" "));
-};
 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 runNpm(["ping", ...registry ? [`--registry ${registry}`] : []]);
+	return void 0 !== await runNpm(["ping", ...registry ? ["--registry", registry] : []]);
 };
 const isAuthenticated = (registry) => {
-	return runNpm(["whoami", ...registry ? [`--registry ${registry}`] : []]);
+	return runNpm(["whoami", ...registry ? ["--registry", registry] : []]);
 };
 const getLatestRegistryVersion = (name, tag, registry) => {
-	const registryArg = registry ? [`--registry ${registry}`] : [];
+	const registryArg = registry ? ["--registry", registry] : [];
 	return runNpm([
 		"show",
 		`${name}@${tag}`,
@@ -1082,16 +1081,6 @@ const getLatestRegistryVersion = (name, tag, registry) => {
 		...registryArg
 	]);
 };
-const getRegistryTags = async (name, registry) => {
-	const res = await runNpm([
-		"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 runNpm([
@@ -1102,20 +1091,15 @@ 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 { name, publishConfig } = ctx.pkg;
+	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
 	const registry = getRegistry(publishConfig);
-	const registryArg = registry ? [`--registry ${registry}`] : [];
+	const registryArg = registry ? ["--registry", registry] : [];
 	let npmVersion = await runNpm(["--version"]);
 	let accessCommand;
 	if (gt(npmVersion, "9.0.0")) accessCommand = [
@@ -1131,88 +1115,82 @@ const isCollaborator = async (ctx) => {
 		...registryArg
 	]);
 	if (res) {
-		const permissions = JSON.parse(res ?? "{}")[ctx.npm.username];
+		const permissions = JSON.parse(res ?? "{}")[username];
 		return permissions && permissions.includes("write");
 	}
-	log.error(`Unable to verify if user ${ctx.npm.username} is a collaborator for ${name}.`);
+	log.error(`Unable to verify if user ${username} is a collaborator for ${name}.`);
 };
 const getPackageUrl = (ctx) => {
-	const { name } = ctx.pkg;
-	return joinUrl([
-		"https://www.npmjs.com",
-		"/package",
-		name
-	]);
+	const { pkg: { name, next } } = 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 runNpm(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
-const info = (msg$1) => {
-	console.log(`${rgb(33, 91, 184)(`ℹ`)} ${gray(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).map(async (hook) => {
-		if (!dryRun) await execAsync(hook).catch(console.error);
-		handler && log.success(success(hook.replace("echo", dim("echo")), dryRun));
-	}));
-};
 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)]));
+		process.env["dryRun"] = String(dryRun);
 		const { version: pkgVersion, private: pkgPrivate, name: pkgName, publishConfig = {} } = readJsonFile("package.json");
 		const nextVersion = inc(pkgVersion, cmdArgs) ?? "";
 		const local = await resolveConfig(process.cwd(), (path$1) => {
-			info(`config file: ${underline(path$1)}`);
+			info(`config file: ${underline(dim(path$1))}`);
 		});
 		const config = mergeConfig(createDefaultConfig(ci ? true : void 0), local);
 		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,
@@ -1224,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 () => {
@@ -1245,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([{
@@ -1320,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([{
@@ -1329,12 +1329,10 @@ 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));
 	}
 };