@peiyanlu/release 0.0.2 → 0.0.4

package/dist/cli.mjs

@@ -1,23 +1,29 @@
-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, green, red, rgb, underline, yellow } from "ansis";
 import { program } from "commander";
+import { createReadStream, createWriteStream, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { cancel, confirm, group, intro, isCancel, log, outro, select, tasks, text } from "@clack/prompts";
-import { clean, coerce, gt, gte, inc, parse, prerelease, valid } from "semver";
-import { createReadStream, existsSync, statSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { publint } from "publint";
+import { formatMessage } from "publint/utils";
+import { clean, coerce, eq, gt, inc, lt, parse, prerelease, valid } from "semver";
+import { castArray, isPlainObject, isUndefined } from "@peiyanlu/ts-utils";
+import { spawnSync } from "node:child_process";
+import { inspect } from "node:util";
 import { Octokit } from "@octokit/rest";
 import { contentType } from "mime-types";
 import open from "open";
 import { glob } from "tinyglobby";
-import { inspect, styleText } from "node:util";
-import { castArray, isUndefined } from "@peiyanlu/ts-utils";
+import { ConventionalChangelog } from "conventional-changelog";
+import createPreset from "conventional-changelog-conventionalcommits";
+import { writeFile } from "node:fs/promises";
+import { finished } from "node:stream/promises";
 
-//#region node_modules/.pnpm/tsdown@0.18.4_typescript@5.9.3/node_modules/tsdown/esm-shims.js
+//#region node_modules/.pnpm/tsdown@0.18.4_publint@0.3.17_typescript@5.9.3/node_modules/tsdown/esm-shims.js
 const getFilename = () => fileURLToPath(import.meta.url);
 const getDirname = () => path.dirname(getFilename());
-const __dirname$1 = /* @__PURE__ */ getDirname();
+const __dirname = /* @__PURE__ */ getDirname();
 
 //#endregion
 //#region src/config.ts
@@ -25,10 +31,8 @@ const findConfigFile = (cwd = process.cwd()) => {
 	for (const ext of [
 		"ts",
 		"mts",
-		"cts",
 		"js",
-		"mjs",
-		"cjs"
+		"mjs"
 	]) {
 		const path$1 = resolve(cwd, `release.config.${ext}`);
 		if (existsSync(path$1)) return path$1;
@@ -40,15 +44,18 @@ const loadConfig = async (file) => {
 	const temp = mod.default ?? mod;
 	return typeof temp === "function" ? temp() : temp;
 };
-const resolveConfig = async (cwd, log$1) => {
+const resolveConfig = async (cwd) => {
 	const configFile = findConfigFile(cwd);
-	if (!configFile) return {};
-	log$1?.(configFile);
-	return loadConfig(configFile);
+	if (!configFile) return {
+		configPath: "",
+		config: {}
+	};
+	return {
+		configPath: configFile,
+		config: await 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 +74,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)} `,
+	INTRO: (dryRun) => `🚀  Starting release ${n(dryRun)}`,
+	OUTRO: (dryRun) => `🎉  Release finished successfully in ${t()} ${n(dryRun)}`,
 	LOG: {
 		SHOW_VERSION: (version) => `🎉  Released ${green(version)}`,
 		SHOW_CHANGELOG: "🎉  Changelog collected",
@@ -85,21 +88,25 @@ const MSG = {
 	CHECK: {
 		GIT: {
 			CHECKING: "Checking Git repository",
-			CHECKED: (name, url) => `Git remote resolved: ${dim(name)} → ${underline(dim(url))}`
+			CHECKED: (name, url) => `Git remote resolved: ${url ? `${dim(name)} → ${underline(dim(url))}` : "not found"}`
 		},
 		NPM: {
 			CHECKING: "Checking npm registry",
-			CHECKED: (registry, msg$1) => `NPM registry: ${underline(dim(registry))}${msg$1 ? ` ${msg$1}` : ""}`
+			CHECKED: (registry, msg$1) => `NPM registry: ${underline(dim(registry))} ${underline(dim(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",
@@ -107,10 +114,11 @@ const MSG = {
 		},
 		GITHUB: {
 			START: "Creating GitHub release",
-			END: "GitHub release created"
+			END: (url) => `GitHub release created: ${underline(dim(url))}`
 		}
 	},
 	PROMPT: {
+		SELECT_PACKAGE: "Select package release:",
 		SELECT_VERSION: "Select version bump:",
 		INPUT_VERSION: "Enter custom version:",
 		NPM_PUBLISH: (pkg$1) => `Publish to npm ${underline(dim`(${pkg$1})`)}?`,
@@ -121,6 +129,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`,
@@ -130,326 +139,173 @@ const MSG = {
 		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)}.`
+	},
+	ABORT: {
+		CANCEL: "Operation cancelled",
+		MONOREPO_CI_NO_PACKAGE: "CI mode requires a target package in monorepo. Please specify it via \"--package <pkg>\"",
+		MONOREPO_NO_PACKAGES: "Monorepo detected, but no packages found. Please configure \"config.packages\""
+	},
+	INFO: {
+		TOOL: (name, version) => `${name} ${dim(`v${version}`)}`,
+		CONFIG: (path$1) => `config file: ${underline(dim(path$1 || "not found"))}`
 	}
 };
 
 //#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: { toPreRelease }, github: { owner, repo, changelog, releaseName }, git: { currentTag } } = ctx;
+	const { github: { prerelease: prerelease$1 } } = config;
+	const github = getGithubUrl(owner, repo);
+	const url = new URL(`${github}/releases/new`);
+	url.searchParams.set("tag", currentTag);
+	url.searchParams.set("title", releaseName);
+	url.searchParams.set("body", truncateBody(changelog));
+	url.searchParams.set("prelease", String(toPreRelease || prerelease$1));
+	const isWindows = process.platform === "win32";
+	await open(url.toString(), { wait: isWindows });
 };
-const 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: { toPreRelease }, github: { owner, repo, token, changelog, releaseName }, git: { currentTag } } = ctx;
+	const { github: { prerelease: prerelease$1, draft, autoGenerate } } = config;
+	const octokit = new Octokit({ auth: token });
+	try {
+		const { data } = await octokit.repos.createRelease({
+			owner,
+			repo,
+			tag_name: currentTag,
+			target_commitish: void 0,
+			name: releaseName,
+			body: autoGenerate ? "" : truncateBody(changelog),
+			draft: draft ?? false,
+			prerelease: (toPreRelease || prerelease$1) ?? false,
+			discussion_category_name: void 0,
+			generate_release_notes: autoGenerate,
+			make_latest: "true"
 		});
-		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)}${eol()}  to ${diff(current, next)}`);
-	return { next };
+	} catch (e) {
+		if (e?.status === 422) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(currentTag));
+		throw e;
+	}
 };
-
-//#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 parseGithubUrl = (ctx) => {
+	const { git: { remoteUrl } } = ctx;
+	const [owner, repo] = parseGitHubRepo(remoteUrl);
+	Object.assign(ctx.github, {
+		owner,
+		repo
+	});
 };
-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 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);
 		}
-	};
-};
-
-//#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 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, { shell: true }).catch(console.error);
-		log.success(success(hook.replace("echo", dim("echo")), dryRun));
-	}));
+	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 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([
-		"rev-parse",
-		"--abbrev-ref",
-		"HEAD"
-	]);
+const getBranchName = async () => {
+	let branch = await runGit(["branch", "--show-current"]);
+	if (!branch) {
+		branch = await runGit([
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]);
+		if (branch === "HEAD") return void 0;
+	}
+	return branch;
 };
 const getRemoteForBranch = (branch) => {
-	return runGitProxy([
+	return runGit([
 		"config",
 		"--get",
 		`branch.${branch}.remote`
 	]);
 };
+const getAllRemotes = async () => {
+	return (await runGit(["remote"]))?.split("\n").filter(Boolean) ?? [];
+};
 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) {
@@ -463,7 +319,7 @@ const coloredChangeset = (log$1) => {
 	return log$1.split("\n").filter(Boolean).map((line) => {
 		const status = line.slice(0, 2);
 		const file = line.slice(3);
-		return `${colorStatus(status)} ${styleText(["dim"], file)}`;
+		return `${colorStatus(status)} ${dim(file)}`;
 	}).join("\n");
 };
 const getRemote = async () => {
@@ -471,11 +327,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 +339,7 @@ const getRemote = async () => {
 	};
 };
 const getLatestTag = async (match = "*", exclude = "*-beta.*") => {
-	return runGitProxy([
+	return runGit([
 		"describe",
 		"--tags",
 		"--abbrev=0",
@@ -492,11 +348,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",
@@ -504,7 +360,7 @@ const getPreviousTag = async (current) => {
 		])}^`
 	]);
 };
-const resolveChangelogRange = async (isIncrement) => {
+const resolveChangelogRange = async (isIncrement = true) => {
 	const latestTag = await getLatestTag();
 	const previousTag = await getPreviousTag(latestTag);
 	if (!latestTag) return {
@@ -520,226 +376,476 @@ const resolveChangelogRange = async (isIncrement) => {
 		to: "HEAD"
 	};
 };
-const getLog = async (print, isIncrement) => {
-	const cmd = ["log", `--pretty=format:${print ? "* %s (%h)" : "%s %h %H"}`];
-	const { from, to } = await resolveChangelogRange(isIncrement);
+const getLog = async (from = "", to = "HEAD", scope) => {
+	const cmd = ["log", `--pretty=format:* %s (%h)`];
 	if (from) cmd.push(`${from}...${to}`);
-	return runGitProxy(cmd, { trim: false });
+	if (scope) cmd.push(...["--", scope]);
+	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 ? [
+	if (!hasUpstream) return [
 		"--set-upstream",
 		remoteName,
 		branch
-	] : [
-		"--set-upstream",
-		"origin",
-		branch
 	];
-	if (remoteName) return [remoteName];
-	return [];
+	return [remoteName, branch];
+};
+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([
-		"push",
-		...await getUpstreamArgs(remoteName),
-		"--follow-tags",
-		...args
+	if (push) {
+		const remotes = await getAllRemotes();
+		for (const remoteName$1 of remotes) {
+			const upstreamArgs = await getUpstreamArgs(remoteName$1);
+			await runGit([
+				"push",
+				remoteName$1,
+				`refs/tags/${currentTag}`,
+				...args
+			]);
+			await runGit([
+				"push",
+				...upstreamArgs,
+				...pushArgs,
+				...args
+			]);
+		}
+		if (!dryRun) Object.assign(ctx.git, { isPushed: true });
+	}
+};
+const gitRollback$1 = (ctx) => {
+	const { git: { currentTag, isCommitted, isTagged, isPushed } } = ctx;
+	if (isPushed) return;
+	spawnSync("git", ["restore", "."]);
+	if (isTagged) spawnSync("git", [
+		"tag",
+		"--delete",
+		currentTag
 	]);
+	spawnSync("git", [
+		"reset",
+		"--hard",
+		isCommitted ? "HEAD~1" : "HEAD"
+	]);
+};
+
+//#endregion
+//#region src/utils.ts
+const info = (msg$1) => {
+	console.log(`${rgb(33, 91, 184)(`i`)} ${msg$1}`);
+};
+const msg = (prefix, msg$1) => {
+	log.message(`${rgb(33, 91, 184)(`[${prefix}]`)} ${dim(msg$1)}`);
+};
+const question = (msg$1, type) => {
+	return `${{
+		package: yellow,
+		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);
+		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 = async (ctx) => {
+const gitRollback = (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"
 	]);
 };
+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 }, selectedPkg } = ctx;
+	const { git: { commitMessage: cm, tagMessage: tm }, github: { releaseName: rm }, toTag } = config;
+	const f = (s, v) => s.replace("${tag}", v);
+	const latestTag = await getLatestTag() ?? "";
+	const currentTag = toTag(selectedPkg, next);
+	const commitMessage = f(cm, currentTag);
+	const tagMessage = f(tm, currentTag);
+	const releaseName = f(rm, currentTag);
+	Object.assign(ctx.git, {
+		latestTag,
+		currentTag,
+		commitMessage,
+		tagMessage
+	});
+	Object.assign(ctx.github, { releaseName });
+};
+const getPackageInfo = (pkgName, getPkgDir = (pkg$1) => `packages/${pkg$1}`) => {
+	const pkgDir = resolve(getPkgDir(pkgName));
+	const pkgPath = resolve(pkgDir, "package.json");
+	return {
+		pkg: readJsonFile(pkgPath),
+		pkgDir,
+		pkgPath
+	};
+};
 
 //#endregion
-//#region src/github/release.ts
-const getGithubUrl = (owner, repo) => {
-	return `https://github.com/${owner}/${repo}`;
+//#region src/prompts.ts
+const abortTask = (msg$1) => {
+	cancel(`${red("✕")} ${msg$1}`);
+	process.exit(0);
 };
-const truncateBody = (body) => {
-	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
-	return body;
+const abortSinglePrompt = (value) => {
+	if (isCancel(value)) abortTask(MSG.ABORT.CANCEL);
 };
-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 abortGroupPrompt = (ctx) => {
+	ctx && gitRollback(ctx);
+	abortTask(MSG.ABORT.CANCEL);
 };
-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 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 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 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 { 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 = !eq(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,
+		selectedPkg: "",
+		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,
+			isPushed: false,
+			commitMessage: "",
+			tagMessage: ""
+		},
+		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": ""
+		},
+		isMonorepo: false,
+		packages: [],
+		getPkgDir(pkg$1) {
+			return ".";
+		},
+		toTag(pkg$1, version) {
+			return `v${version}`;
+		},
+		changelogTagPrefix: void 0,
+		git: {
+			commit: isCI,
+			tag: isCI,
+			push: isCI,
+			commitMessage: "chore(release): ${tag}",
+			commitArgs: [],
+			tagMessage: "${tag}",
+			tagArgs: [],
+			pushArgs: [],
+			addUntrackedFiles: false,
+			requireRemote: true,
+			requireRepository: true,
+			requireWorkDirClean: true
+		},
+		npm: {
+			publish: isCI,
+			publishPath: ".",
+			pushArgs: [],
+			skipChecks: false
+		},
+		github: {
+			release: isCI,
+			releaseName: "${tag}",
+			autoGenerate: false,
+			prerelease: false,
+			draft: false,
+			tokenRef: "GITHUB_TOKEN",
+			assets: [],
+			skipChecks: false
+		}
+	};
 };
 
 //#endregion
@@ -750,15 +856,25 @@ const defaultTypes = [
 		section: "✨ 新功能",
 		description: "新增功能"
 	},
+	{
+		type: "feature",
+		section: "✨ 新功能",
+		description: "新增功能"
+	},
 	{
 		type: "fix",
 		section: "🐛 Bug 修复",
 		description: "修复 bug"
 	},
 	{
-		type: "chore",
-		section: "🎫 其他更新",
-		description: "非功能性更改"
+		type: "perf",
+		section: "⚡ 性能优化",
+		description: "提升性能"
+	},
+	{
+		type: "revert",
+		section: "⏪ 回退",
+		description: "回退到之前版本"
 	},
 	{
 		type: "docs",
@@ -770,26 +886,21 @@ const defaultTypes = [
 		section: "💄 样式调整",
 		description: "样式或格式修改"
 	},
+	{
+		type: "chore",
+		section: "🎫 其他更新",
+		description: "非功能性更改"
+	},
 	{
 		type: "refactor",
 		section: "♻ 代码重构",
 		description: "重构代码"
 	},
-	{
-		type: "perf",
-		section: "⚡ 性能优化",
-		description: "提升性能"
-	},
 	{
 		type: "test",
 		section: "✅ 测试",
 		description: "测试更新"
 	},
-	{
-		type: "revert",
-		section: "⏪ 回退",
-		description: "回退到之前版本"
-	},
 	{
 		type: "build",
 		section: "👷‍ 构建系统",
@@ -829,103 +940,103 @@ const defaultTypes = [
 		type: "hotfix",
 		section: "🔥 热修复",
 		description: "紧急修复"
-	},
-	{
-		type: "break",
-		section: "💥 破坏性变更",
-		description: "破坏性变更"
 	}
 ];
-const findType = (type) => {
-	return defaultTypes.find((item) => item.type === type)?.section ?? type;
-};
 
 //#endregion
 //#region src/git/changelog.ts
-const getCommits = async (isIncrement) => {
-	return (await getLog(false, isIncrement))?.split("\n").filter(Boolean);
-};
-const parseCommit = (message) => {
-	const match = message.match(/^(\w+):\s(.+)\s(\w{7})\s(\w{40})$/);
-	if (!match) return;
-	return {
-		type: match[1],
-		description: match[2],
-		hash: match[3],
-		fullHash: match[4]
-	};
-};
-const classify = (commits) => {
-	const sections = {};
-	for (const msg$1 of commits) {
-		const parsed = parseCommit(msg$1);
-		if (!parsed) continue;
-		const { type, description, hash, fullHash } = parsed;
-		(sections[type] ??= []).push([
-			description,
-			hash,
-			fullHash
-		]);
-	}
-	return sections;
-};
-const renderChangelog = async (ctx, sections) => {
-	const { pkg: { next: to }, github: { owner, repo }, git: { latestTag } } = 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);
+const generateChangelog = async ({ getPkgDir, tagPrefix }) => {
+	const pkgDir = getPkgDir();
+	const infile = join(pkgDir, "CHANGELOG.md");
+	if (!existsSync(infile)) await writeFile(infile, "");
+	const originalChangelog = readFileSync(infile, "utf-8");
+	const preset = await createPreset({ types: defaultTypes.map((t$1) => ({
+		...t$1,
+		hidden: false
+	})) });
+	preset.writer ??= {};
+	preset.writer.headerPartial = `
+## {{#if isPatch~}} <small> {{~/if~}}
+{{#if @root.linkCompare~}}
+[{{version}}](
+{{~#if @root.repository~}}
+  {{~#if @root.host}}
+    {{~@root.host}}/
+  {{~/if}}
+  {{~#if @root.owner}}
+    {{~@root.owner}}/
+  {{~/if}}
+  {{~@root.repository}}
+{{~else}}
+  {{~@root.repoUrl}}
+{{~/if~}}
+/compare/{{previousTag}}...{{currentTag}})
+{{~else}}
+{{~version}}
+{{~/if}}
+{{~#if title}} "{{title}}"
+{{~/if}}
+{{~#if date}} ({{date}})
+{{~/if}}
+{{~#if isPatch~}} </small> {{~/if}}
+`.trim() + eol();
+	preset.writer.mainTemplate = `
+{{> header}}
+{{#if noteGroups}}
+{{#each noteGroups}}
+
+### ⚠ {{title}}
+
+{{#each notes}}
+* {{#if commit.scope}}**{{commit.scope}}:** {{/if}}{{commit.subject}} {{#if commit.hash}}([{{commit.shortHash}}](https://github.com/{{@root.owner}}/{{@root.repository}}/commit/{{commit.hash}})){{/if}}
+{{/each}}
+{{/each}}
+{{/if}}
+{{#each commitGroups}}
+
+{{#if title}}
+### {{title}}
+
+{{/if}}
+{{#each commits}}
+{{> commit root=@root}}
+{{/each}}
+{{/each}}`.trim() + eol(2);
+	const generator = new ConventionalChangelog().readPackage(`${pkgDir}/package.json`).config(preset).options({ releaseCount: 1 }).commits({ path: pkgDir }).tags({ prefix: tagPrefix });
+	const writeStream = createWriteStream(infile);
+	let changelog = "";
+	for await (const chunk of generator.write()) {
+		changelog += chunk;
+		writeStream.write(chunk);
 	}
-	return md;
-};
-const generateChangelog = async (ctx) => {
-	const { isIncrement } = ctx;
-	const commits = await getCommits(isIncrement);
-	if (!commits) return "";
-	const changelog = await renderChangelog(ctx, classify(commits));
-	Object.assign(ctx.github, { changelog });
+	writeStream.write(originalChangelog);
+	writeStream.end();
+	await finished(writeStream);
 	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]);
-};
 
 //#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 +1045,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 +1054,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 +1067,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 +1083,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 +1092,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,65 +1107,67 @@ 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 resolvePublishRegistry = (publishConfig = {}) => {
+	if (publishConfig.registry) return publishConfig.registry;
+	return Object.keys(publishConfig).filter((k) => k.endsWith("registry")).map((k) => publishConfig[k])[0];
 };
-const isRegistryUp = async (registry) => {
-	return void 0 !== await runNpmProxy(["ping", ...registry ? [`--registry ${registry}`] : []]);
+const pingRegistry = async () => {
+	return void 0 !== await runNpm(["ping"]);
 };
-const isAuthenticated = (registry) => {
-	return runNpmProxy(["whoami", ...registry ? [`--registry ${registry}`] : []]);
+const getAuthenticatedUser = () => {
+	return runNpm(["whoami"]);
 };
-const getLatestRegistryVersion = (name, tag, registry) => {
-	const registryArg = registry ? [`--registry ${registry}`] : [];
-	return runNpmProxy([
+const getVersionByTag = (name, tag) => {
+	return runNpm([
 		"show",
 		`${name}@${tag}`,
-		"version",
-		...registryArg
+		"version"
 	]);
 };
-const getRegistryTags = async (name, registry) => {
-	const res = await runNpmProxy([
-		"view",
+const getPublishedVersion = (name) => {
+	return runNpm([
+		"info",
 		name,
-		"dist-tags",
-		"--json",
-		...registry ? [`--registry ${registry}`] : []
+		"version"
 	]);
-	return Object.keys(JSON.parse(res || "{}"));
 };
-const bump = (version, allowSameVersion, args = []) => {
-	allowSameVersion && args.push(`--allow-same-version`);
-	return runNpmProxy([
+const resolvePublishTag = async (pkgName, version) => {
+	const { toPreRelease, preId } = parseVersion(version);
+	if (!toPreRelease) {
+		const active = await getPublishedVersion(pkgName);
+		return active && lt(version, active) ? "previous" : "latest";
+	} else return preId || "prerelease";
+};
+const bumpPackageVersion = (version, args = [], cwd = ".") => {
+	return runNpm([
 		"version",
 		version,
 		"--no-git-tag-version",
 		"--workspaces=false",
+		"--allow-same-version",
 		...args
-	]);
-};
-const guessPreReleaseTag = async (name) => {
-	return (await getRegistryTags(name)).filter((tag) => DEFAULT_TAG !== tag)[0] ?? DEFAULT_TAG_PRERELEASE;
+	], { cwd });
+};
+const isOtpError = (err) => err instanceof Error && /one-time password|otp/i.test(err.message);
+const publishPackage = (pkg$1 = ".", tag = "latest", args = []) => {
+	return runNpm([
+		"publish",
+		"--access",
+		"public",
+		"--tag",
+		tag,
+		"--workspaces=false",
+		...args
+	], { cwd: pkg$1 });
 };
-const 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 getPackageUrl = (name, next) => {
+	return `https://www.npmjs.com/package/${name}/v/${next}`;
 };
 const isCollaborator = async (ctx) => {
 	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
-	const registry = getRegistry(publishConfig);
-	const registryArg = registry ? [`--registry ${registry}`] : [];
-	let npmVersion = await runNpmProxy(["--version"]);
+	const registry = resolvePublishRegistry(publishConfig);
+	const registryArg = registry ? ["--registry", registry] : [];
+	let npmVersion = await runNpm(["--version"]);
 	let accessCommand;
 	if (gt(npmVersion, "9.0.0")) accessCommand = [
 		"access",
@@ -1068,73 +1176,92 @@ const isCollaborator = async (ctx) => {
 		"--json"
 	];
 	else accessCommand = ["access", "ls-collaborators"];
-	const res = await runNpmProxy([
+	const res = await runNpm([
 		...accessCommand,
 		name,
 		...registryArg
 	]);
-	if (res) {
-		const permissions = JSON.parse(res ?? "{}")[username];
-		return permissions && permissions.includes("write");
-	}
-	log.error(`Unable to verify if user ${username} is a collaborator for ${name}.`);
-};
-const getPackageUrl = (ctx) => {
-	const { pkg: { name, next } } = ctx;
-	return `https://www.npmjs.com/package/${name}/v/${next}`;
+	if (res) return JSON.parse(res ?? "{}")[username]?.includes("write");
+	return false;
 };
 const npmCheck = async (ctx, config) => {
-	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
-	const registry = getRegistry(publishConfig);
-	const tag = await resolveTag(ctx, config);
+	const { pkg: { name, current, publishConfig: { registry } }, npm: { username } } = ctx;
+	const { npm: { skipChecks } } = config;
+	const tag = await resolvePublishTag(name, current);
+	Object.assign(ctx.npm, { tag });
+	if (skipChecks) return "";
+	if (!await pingRegistry()) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
 	const getUser = async () => {
-		const username$1 = await isAuthenticated(registry);
+		const username$1 = await getAuthenticatedUser();
 		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) {
+	const latest = await getVersionByTag(name, tag);
+	if (latest) {
 		if (!await isCollaborator(ctx)) throw new Error(MSG.ERROR.NPM_USER(username, name));
 	}
-	return dim(latestPublish ? `(latest is ${latestPublish})` : "(new publish)");
+	return latest ? `(${tag} → ${latest})` : `(${tag} → no published version)`;
 };
-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, selectedPkg, npm: { otp, tag } } = ctx;
+	const { npm: { publish, pushArgs }, getPkgDir } = config;
 	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"] : [];
+	return publishPackage(getPkgDir(selectedPkg), tag, [
+		...otpArgs,
+		...pushArgs,
+		...dryRunArg
+	]);
 };
 
 //#endregion
 //#region src/action.ts
 var Action = class {
 	async handle(cmdArgs, options) {
-		const { version: cVersion, name: cName } = readJsonFile(join(__dirname$1, "../package.json"));
-		info(`${cName} ${dim(`v${cVersion}`)} `);
-		const { otp, ...others } = options;
+		const { version: cVersion, name: cName } = readJsonFile(join(__dirname, "../package.json"));
+		const { otp, package: defPkg, ...others } = options;
 		const { showChangelog, showRelease, ci, dryRun } = Object.fromEntries(Object.entries(others).map(([k, v]) => [k, Boolean(v)]));
 		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(dim(path$1))}`);
-		});
+		const { configPath, config: local } = await resolveConfig(process.cwd());
 		const config = mergeConfig(createDefaultConfig(ci ? true : void 0), local);
+		info(MSG.INFO.TOOL(cName, cVersion));
+		info(MSG.INFO.CONFIG(configPath));
+		console.log();
+		intro(MSG.INTRO(dryRun));
+		const { isMonorepo, packages, getPkgDir } = config;
+		if (isMonorepo) {
+			if (ci) {
+				if (!defPkg) abortTask(MSG.ABORT.MONOREPO_CI_NO_PACKAGE);
+			} else if (packages.length < 1) abortTask(MSG.ABORT.MONOREPO_NO_PACKAGES);
+		}
+		const selectPackage = async () => {
+			const pkg$2 = await select({
+				message: question(MSG.PROMPT.SELECT_PACKAGE, "package"),
+				options: packages.map((pkg$3) => ({
+					label: pkg$3,
+					value: pkg$3
+				}))
+			});
+			abortSinglePrompt(pkg$2);
+			return pkg$2;
+		};
+		const selectedPkg = !isMonorepo ? "" : ci ? defPkg : packages.length === 1 ? packages[0] : await selectPackage();
+		const { pkg: pkg$1, pkgDir } = getPackageInfo(selectedPkg, getPkgDir);
+		const { version: pkgVersion, private: pkgPrivate = false, name: pkgName, publishConfig = {} } = pkg$1;
+		const nextVersion = inc(pkgVersion, cmdArgs) ?? "";
 		const ctx = mergeConfig(createDefaultContext(), {
+			selectedPkg,
 			configFileExists: Object.keys(local).length > 0,
 			dryRun,
+			showRelease,
+			showChangelog,
 			npm: { otp: String(otp) },
 			increment: cmdArgs,
 			isIncrement: true,
-			ci: [
+			isCI: [
 				ci,
 				showChangelog,
 				showRelease,
@@ -1146,14 +1273,28 @@ 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;
+		const { messages } = await publint({ pkgDir });
+		for (const message of messages) {
+			const formated = formatMessage(message, pkg$1);
+			formated && msg("PKG", formated);
+		}
+		await this.checkTask(ctx, config);
+		await this.bumpTask(ctx, config);
+		await this.changelogTask(ctx, config);
+		await this.gitTask(ctx, config);
+		await this.npmTask(ctx, config);
+		await this.githubTask(ctx, config);
+		if (dryRun) gitRollback$1(ctx);
+		taskEnd(MSG.OUTRO(dryRun));
+	}
+	async checkTask(ctx, config) {
+		const { noNpm, dryRun } = ctx;
 		await tasks([{
 			title: MSG.CHECK.GIT.CHECKING,
 			task: async () => {
@@ -1167,73 +1308,65 @@ 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, selectedPkg } = ctx;
+		const { hooks, getPkgDir } = 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 bumpPackageVersion(next, [], getPkgDir(selectedPkg));
+				await formatTemplate(ctx, config);
+				const to$1 = `(${current}...${diff(current, next)})`;
+				return success(MSG.TASK.VERSION.END(to$1), dryRun);
 			}
-		}
+		}]).catch((err) => abortOnError(err, ctx));
+		await runLifeCycleHook(hooks, "after:bump", dryRun);
+		const { from, to } = await resolveChangelogRange(isIncrement);
+		const logStr = await getLog(from, to, getPkgDir(selectedPkg));
+		if (logStr) {
+			msg("GIT", `Changelog:${eol(2)}` + logStr);
+			if (showChangelog) taskEnd(MSG.LOG.SHOW_CHANGELOG);
+		} else msg("GIT", MSG.LOG.CHANGELOG_EMPTY);
+	}
+	async changelogTask(ctx, config) {
+		const { isIncrement, dryRun, selectedPkg } = ctx;
+		const { getPkgDir, changelogTagPrefix } = config;
+		await tasks([{
+			title: MSG.TASK.CHANGELOG.START,
+			task: async () => {
+				const changelog = await generateChangelog({
+					getPkgDir: () => getPkgDir(selectedPkg),
+					tagPrefix: changelogTagPrefix?.(selectedPkg)
+				});
+				await runGit(["add", `${getPkgDir(selectedPkg)}/CHANGELOG.md`]);
+				Object.assign(ctx.github, { changelog });
+				return success(MSG.TASK.CHANGELOG.END, dryRun);
+			},
+			enabled: isIncrement
+		}]).catch((err) => abortOnError(err, ctx));
+		const changeset = await getStatus();
+		if (changeset) msg("GIT", `Changes:${eol(2)}` + coloredChangeset(changeset));
+		else msg("GIT", MSG.LOG.CHANGES_EMPTY);
+	}
+	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 +1375,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, pkg: { name, next } } = 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(name, next);
+				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,21 +1410,43 @@ 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"));
-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);
+const pkg = readJsonFile(join(__dirname, "..", "package.json"));
+program.name("release").description(pkg.description).version(pkg.version, "-v, --version", "Print the tool version and exit.").usage("[release-type] [options]").argument("[release-type]", "Version bump type: patch | minor | major").option("-n, --dry-run", "Run in dry mode: show what would be released without making any changes.", false).option("-p, --package <pkg>", "Specify package name for mono-repo release (CI only).", "").option("--otp <code>", "One-time password for npm publish (used for 2FA).", "").option("--ci", "Enable CI mode: disable prompts and fail on missing required options.", false).option("--show-changelog", "Print the generated changelog and exit.", false).option("--show-release", "Print the version that would be released and exit.", false).helpOption("-h, --help", "Display help information.").action(async (releaseType, options) => {
+	await new Action().handle(releaseType, options);
+});
+program.command("init").description("Create a release configuration file").option("-f, --force", "Overwrite existing config file", false).option("-m, --monorepo", "Mono-repo project", false).action((options) => {
+	const { force = false, monorepo = false } = options;
+	const cwd = process.cwd();
+	const { type } = readJsonFile(join(cwd, "package.json"));
+	const isESM = type === "module";
+	const isTS = existsSync(join(cwd, "tsconfig.json"));
+	const configPath = join(cwd, `release.config.${isESM ? "" : "m"}${isTS ? "ts" : "js"}`);
+	if (existsSync(configPath) && !force) {
+		console.error(`${red`Error:`} ${yellow`release.config.ts`} already exists.\nUse ${green`--force`} to overwrite.`);
+		process.exit(1);
+	}
+	const monoConfigToString = () => `{
+  isMonorepo: true,
+  packages: [ 'demo-a', 'demo-b' ],
+  getPkgDir: (pkg) => \`packages/\${ pkg }\`,
+  toTag: (pkg, version) => \`\${ pkg }@\${ version }\`,
+  changelogTagPrefix: (pkg) => \`\${ pkg }@\`,
+}`;
+	writeFileSync(configPath, `import { defineConfig } from '@peiyanlu/release'
+
+export default defineConfig(${monorepo ? monoConfigToString() : "{}"})`, "utf-8");
+	console.log(`${green`✔ release.config.ts`} created successfully`);
+});
+program.parse(process.argv);
 program.on("command:*", () => {
 	console.error(`\n${red`Error`} Invalid command: ${red`%s`}`, program.args.join(" "));
 	console.log(`See ${red`--help`} for a list of available commands.\n`);