@peiyanlu/release 1.3.0 → 2.0.0

package/dist/cli.mjs

@@ -1,1487 +1,954 @@
-import { bold, compareUrl, each, heading, link, list, newline, segments, small, words } from "@conventional-changelog/template";
-import { bumpPackageVersion, coloredStatus, eol, execAsync, getAuthenticatedUser, getGithubReleaseUrl, getGithubUrl, getLatestTag, getLogSince, getPackageInfo, getPackageUrl, getPublishedVersion, getRemoteList, getRemoteNames, getShortStatus, gitAddAll, gitAddSync, gitAddTracked, gitBranchCurrent, gitCommitMessage, gitPushBranch, gitPushTag, gitResetHardSync, gitTagAnnotated, gitTagDeleteSync, hasWriteAccess, isGitRepo, isOtpError, isPrerelease, isValidVersion, isWorkingTreeClean, parseGitHubRepo, parseVersion, pingRegistry, publishPackage, registryArg, resolveChangelogRange, resolvePublishTag, runNpm } from "@peiyanlu/cli-utils";
-import { copyDir, createMatcher, createTempDir, editFile, normalizePath, readJsonFile, readJsonFileSync, writeJsonFile } from "@peiyanlu/node-utils";
-import { castArray, dedent, isBoolean, isEmpty, isEmptyObject, isFunction, isNotEmpty, isNumber, isPlainObject, isUndefined, isZero, nonNullable, omit, partition, unset } from "@peiyanlu/ts-utils";
-import { dim, green, red, rgb, underline, yellow } from "ansis";
+import path, { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { newline } from "@conventional-changelog/template";
+import { gitAdd, gitAddSync, gitBranch, gitBranchCurrent, gitCheckoutBranch, gitCheckoutBranchForce, gitCommitMessage, gitConfigGet, gitConfigSet, gitFetch, gitLsRemote, gitPush, gitPushBranch, gitRevParse, gitTag, isGitRepo, isPrerelease, isValidVersion, isWorkingTreeClean } from "@peiyanlu/cli-utils";
+import { readJsonFileSync } from "@peiyanlu/node-utils";
+import { assert, equals, isString, isUndefined, omit, throwError } from "@peiyanlu/ts-utils";
 import { program } from "commander";
-import { createReadStream, createWriteStream, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { cancel, confirm, group, intro, isCancel, log, outro, select, tasks, text } from "@clack/prompts";
-import { publint } from "publint";
-import { formatMessage } from "publint/utils";
-import { inc, neq } from "semver";
-import { pathToFileURL } from "node:url";
-import { inspect } from "node:util";
-import { ConventionalChangelog } from "conventional-changelog";
-import createPreset from "conventional-changelog-conventionalcommits";
-import { Bumper } from "conventional-recommended-bump";
-import { writeFile } from "node:fs/promises";
-import { finished } from "node:stream/promises";
-import { Octokit } from "@octokit/rest";
-import { contentType } from "mime-types";
-import open from "open";
-import { glob, globSync } from "tinyglobby";
-import { parse } from "yaml";
-//#region package.json
-var name = "@peiyanlu/release";
-var version = "1.2.1";
-var description = "Release project tool.";
+import Handlebars from "handlebars";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { cancel, confirm, group, intro, isCancel, log, note, outro, select, text } from "@clack/prompts";
+import { blue, blueBright, cyan, cyanBright, dim, green, greenBright, magenta, magentaBright, red, redBright, yellow } from "ansis";
+import { inc, lt } from "semver";
+import "conventional-changelog";
+import "conventional-changelog-conventionalcommits";
+import "conventional-recommended-bump";
+//#region node_modules/.pnpm/tsdown@0.23.1_publint@0.3.22_typescript@6.0.3/node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
 //#endregion
-//#region src/config.ts
-const findConfigFile = (cwd = process.cwd()) => {
-	for (const ext of [
-		"ts",
-		"mts",
-		"js",
-		"mjs"
-	]) {
-		const path = resolve(cwd, `release.config.${ext}`);
-		if (existsSync(path)) return path;
-	}
+//#region package.json
+var package_default = {
+	name: "@peiyanlu/release",
+	version: "2.0.0",
+	description: "Tool to automate version bumps, changelogs, and releases.",
+	license: "MIT",
+	type: "module",
+	"private": false,
+	bin: { "release": "index.js" },
+	exports: {
+		".": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		},
+		"./package.json": "./package.json"
+	},
+	scripts: {
+		"dev": "tsdown -w",
+		"build": "tsdown",
+		"prepublishOnly": "tsdown",
+		"release": "node index.js",
+		"release:dry": "node index.js -C -n",
+		"test": "vitest run",
+		"test:cov": "vitest run --coverage"
+	},
+	dependencies: {
+		"@actions/core": "^3.0.1",
+		"@actions/github": "^9.1.1",
+		"@clack/prompts": "^1.7.0",
+		"@conventional-changelog/template": "^1.2.1",
+		"@octokit/rest": "^22.0.1",
+		"@peiyanlu/cli-utils": "^0.0.15",
+		"@peiyanlu/node-utils": "^0.0.4",
+		"@peiyanlu/ts-utils": "^0.0.12",
+		"ansis": "^4.3.1",
+		"commander": "^15.0.0",
+		"conventional-changelog": "^8.1.0",
+		"conventional-changelog-conventionalcommits": "^10.2.1",
+		"conventional-recommended-bump": "^12.1.0",
+		"open": "^11.0.0",
+		"publint": "^0.3.22",
+		"semver": "^7.8.5",
+		"tinyglobby": "^0.2.17",
+		"yaml": "^2.9.0",
+		"handlebars": "^4.7.9"
+	},
+	devDependencies: {
+		"@peiyanlu/test-tools": "^0.0.7",
+		"@types/node": "^24.13.3",
+		"@types/semver": "^7.7.1",
+		"@vitest/coverage-v8": "^4.1.10",
+		"tsdown": "^0.23.1",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.10"
+	},
+	author: {
+		"name": "YanluPei",
+		"email": "peiyanlu@vip.qq.com"
+	},
+	engines: { "node": ">=20" },
+	keywords: ["typescript", "cli"],
+	files: ["dist", "template"],
+	publishConfig: {
+		"access": "public",
+		"registry": "https://registry.npmjs.org"
+	},
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/peiyanlu/release.git"
+	},
+	bugs: { "url": "https://github.com/peiyanlu/release/issues" },
+	homepage: "https://github.com/peiyanlu/release#readme"
 };
-const loadConfig = async (file) => {
+//#endregion
+//#region src/config/index.ts
+const loadJavaScriptFile = async (file) => {
 	const { href } = pathToFileURL(file);
 	const mod = await import(href);
-	const temp = mod.default ?? mod;
+	const temp = "default" in mod ? mod.default : mod;
 	return typeof temp === "function" ? temp() : temp;
 };
-const resolveConfig = async (cwd) => {
-	const configFile = findConfigFile(cwd);
-	if (!configFile) return {
-		configFile: "",
+const findFile = (cwd, filename, extensions) => {
+	for (const ext of extensions) {
+		const path = resolve(cwd, `${filename}.${ext}`);
+		if (existsSync(path)) return path;
+	}
+};
+const loadConfig = async (cwd = process.cwd()) => {
+	const file = findFile(cwd, "release.config", [
+		"ts",
+		"mts",
+		"js",
+		"mjs"
+	]);
+	if (!file) return {
+		file: "",
 		config: {}
 	};
 	return {
-		configFile,
-		config: await loadConfig(configFile)
+		file,
+		config: await loadJavaScriptFile(file)
 	};
 };
-const mergeConfig = (defaults, overrides) => {
-	const result = {};
-	for (const key of Object.keys(defaults)) {
-		const defaultValue = defaults[key];
-		const overrideValue = overrides[key];
-		if (isUndefined(overrideValue)) if (isFunction(defaultValue)) result[key] = defaultValue;
-		else if (isPlainObject(defaultValue)) result[key] = mergeConfig(defaultValue, {});
-		else result[key] = structuredClone(defaultValue);
-		else if (isPlainObject(defaultValue) && isPlainObject(overrideValue)) result[key] = mergeConfig(defaultValue, overrideValue);
-		else if (isFunction(overrideValue)) result[key] = overrideValue;
-		else result[key] = structuredClone(overrideValue);
+//#endregion
+//#region src/core/logger.ts
+const defaultPrinter = ({ dryRun, stage, message }) => {
+	console.log(`${dryRun ? `[dry-run]` : ""}[${stage}]:`, message);
+};
+/** 一个子消息记录器，绑定到特定阶段 */
+var ChildLogger = class {
+	parent;
+	stage;
+	/**
+	* 创建子日志记录器。
+	* @param parent - 要继承其选项的父日志记录器。
+	* @param stage - 此日志记录器所属的处理阶段。
+	*/
+	constructor(parent, stage) {
+		this.parent = parent;
+		this.stage = stage;
+	}
+	/**
+	* 记录一条普通信息。
+	* @param message - 要记录的信息。
+	*/
+	info(message) {
+		this.parent.info(this.stage, message);
+	}
+	/**
+	* 记录一条详细信息。
+	* @param message - 要记录的信息。
+	*/
+	verbose(message) {
+		this.parent.verbose(this.stage, message);
 	}
-	return result;
 };
-//#endregion
-//#region src/messages.ts
-const n = (b) => b ? "(dry run)" : "";
-const t = () => green(`${Math.floor(process.uptime())}s`);
-const MSG = {
-	INTRO: (dryRun) => `🚀  Starting release ${n(dryRun)}`,
-	INTRO_PREPARE: (dryRun) => `🚀  Starting prepare release ${n(dryRun)}`,
-	OUTRO: (dryRun) => `🎉  Release finished successfully in ${t()} ${n(dryRun)}`,
-	OUTRO_PREPARE: (dryRun) => `🎉  Prepare release finished successfully in ${t()} ${n(dryRun)}`,
-	LOG: {
-		SHOW_VERSION: (version) => `🎉  Released ${green(version)}`,
-		SHOW_CHANGELOG: "🎉  Changelog collected",
-		CHANGELOG_EMPTY: "No commits found since last release",
-		CHANGES_EMPTY: "Working tree clean. No files changed",
-		ONLY_CHANGELOG: "🎉  Changelog generation completed"
-	},
-	CHECK: {
-		GIT: {
-			CHECKING: "Checking Git repository",
-			CHECKED: (name, url) => `Git remote resolved: ${url ? `${dim(name)} → ${underline(dim(url))}` : "not found"}`
-		},
-		NPM: {
-			CHECKING: "Checking npm registry",
-			CHECKED: (registry, msg) => `NPM registry: ${underline(dim(registry))} ${dim(msg)}`
-		},
-		GITHUB: {
-			CHECKING: "Checking github repository",
-			CHECKED: (repository) => `GitHub repository: ${underline(dim(repository))}`
+/** 消息记录器 */
+var Logger = class {
+	options;
+	printer;
+	colors;
+	colorMap = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.options = options;
+		const { colors = [], printer = defaultPrinter } = options;
+		this.colors = colors;
+		this.printer = printer;
+	}
+	info(stage, message) {
+		const { silent, dryRun } = this.options;
+		if (!silent) {
+			const color = this.getColor(stage);
+			this.printer({
+				dryRun,
+				stage,
+				message,
+				color
+			});
 		}
-	},
-	TASK: {
-		VERSION: {
-			START: "Bumping version",
-			END: (to) => `Version bumped: ${underline(dim(to))}`
-		},
-		CHANGELOG: {
-			START: "Generating changelog",
-			END: `Changelog generated`
-		},
-		NPM: {
-			START: "Publishing npm package",
-			END: (url) => url ? `Published npm package: ${underline(dim(url))}` : "NPM publish skipped"
-		},
-		GIT: {
-			START: "Creating git commit, tag & push",
-			END: (push) => push ? "Git commit, tag & push completed" : "Git commit, tag & push skipped"
-		},
-		GITHUB: {
-			START: "Creating GitHub release",
-			END: (url) => url ? `Created GitHub release: ${underline(dim(url))}` : "GitHub release skipped"
+	}
+	verbose(stage, message) {
+		const { silent, verbose, dryRun } = this.options;
+		if (!silent && (verbose || dryRun)) {
+			const color = this.getColor(stage);
+			this.printer({
+				dryRun,
+				stage,
+				message,
+				color
+			});
 		}
-	},
-	PROMPT: {
-		SELECT_PACKAGE: "Select package release:",
-		SELECT_VERSION: "Select version bump:",
-		INPUT_VERSION: "Enter custom version:",
-		NPM_PUBLISH: (pkg) => `Publish to npm ${underline(dim`(${pkg})`)}?`,
-		NPM_OTP: "Enter npm one-time password (OTP):",
-		GITHUB_RELEASE: (title) => `Create a new GitHub release ${underline(dim`(${title})`)}?`,
-		GIT_COMMIT: (msg) => `Create git commit ${underline(dim`(${msg})`)}?`,
-		GIT_TAG: (msg) => `Create git tag ${underline(dim`(${msg})`)}?`,
-		GIT_PUSH: "Push commits and tags to remote?"
-	},
-	ERROR: {
-		GIT_WORKDIR: `[git] Working tree must be clean`,
-		GIT_REGISTRY: (name) => `[git] Repository not found for package "${dim(name)}"`,
-		GIT_REMOTE: (name) => `[git] Remote "${dim(name)}" not found`,
-		GITHUB_TAG_EXIT: (tag) => `[github] Release for tag "${tag}" already exists and is not a draft`,
-		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(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) => `config file: ${underline(dim(path || "not found"))}`
+	}
+	createChild(stage) {
+		return new ChildLogger(this, stage);
+	}
+	getColor(stage) {
+		const cached = this.colorMap.get(stage);
+		if (cached) return cached;
+		const index = this.colorMap.size % this.colors.length;
+		const color = this.colors[index] ?? ((text) => text);
+		this.colorMap.set(stage, color);
+		return color;
 	}
 };
 //#endregion
-//#region src/git/commit.ts
-const gitCheck = async (ctx, config) => {
-	const { pkg: { name } } = ctx;
-	const { git: { requireRepository, requireRemote, requireCleanWorkingTree } } = config;
-	if (!await isGitRepo()) if (requireRepository) throw new Error(MSG.ERROR.GIT_REGISTRY(name));
-	else {
-		ctx.noGit = true;
-		return;
+//#region src/core/utils.ts
+const when = (condition, ...value) => condition ? [...value] : [];
+//#endregion
+//#region src/core/releaser.ts
+var Releaser = class {
+	options;
+	project;
+	hosting;
+	logger;
+	stepsOptions = {};
+	skippedSteps = {};
+	state = {};
+	queue = [];
+	constructor(options) {
+		this.options = options;
+		const { project, hosting, logger, ...log } = options;
+		this.project = project;
+		this.hosting = hosting;
+		this.logger = logger ?? new Logger(log);
 	}
-	if (requireCleanWorkingTree && !await isWorkingTreeClean()) throw new Error(MSG.ERROR.GIT_WORKDIR);
-	const remote = (await getRemoteList())[0];
-	const { name: remoteName = "origin", url: remoteUrl } = remote ?? {};
-	if (!remote || !remoteUrl) {
-		if (requireRemote) throw new Error(MSG.ERROR.GIT_REMOTE(remoteName));
+	enqueue(fn) {
+		this.queue.push(fn);
+		return this;
 	}
-	Object.assign(ctx.git, {
-		remoteName,
-		remoteUrl
-	});
-};
-const commitAndTag = async (ctx, config) => {
-	const { git: { currentTag, commitMessage, tagMessage }, dryRun } = ctx;
-	const { git: { commit, tag, push, addUntrackedFiles, commitArgs, tagArgs, pushArgs } } = config;
-	if (!commit) return;
-	const args = dryRun ? ["--dry-run"] : [];
-	addUntrackedFiles ? await gitAddAll(args) : await gitAddTracked(args);
-	await gitCommitMessage(commitMessage, [...commitArgs, ...args]);
-	if (!dryRun) Object.assign(ctx.git, { isCommitted: true });
-	if (tag) {
-		await gitTagAnnotated(currentTag, tagMessage, [...tagArgs, ...args]);
-		if (!dryRun) Object.assign(ctx.git, { isTagged: true });
+	setOptions(options) {
+		const logger = this.logger.createChild("set-options");
+		logger.verbose("Setting options for steps:");
+		logger.verbose(options);
+		for (const [key, value] of Object.entries(options)) Object.assign(this.stepsOptions[key] ??= {}, value);
+		logger.verbose("Final options for steps:");
+		logger.verbose(this.stepsOptions);
+		return this;
 	}
-	if (push) {
-		const remotes = await getRemoteNames();
-		for (const remoteName of remotes) {
-			await gitPushTag(remoteName, currentTag, args);
-			await gitPushBranch(remoteName, await gitBranchCurrent(), [...pushArgs, ...args]);
-		}
-		if (!dryRun) Object.assign(ctx.git, { isPushed: true });
+	setUser(options) {
+		return this.enqueue(async () => {
+			const { options: { dryRun }, stepsOptions: { setUser } } = this;
+			const { username, email } = {
+				...setUser,
+				...options
+			};
+			const logger = this.logger.createChild("set-user");
+			if (this.shouldSkip("setUser")) {
+				logger.info("Skipping set git user.");
+				return;
+			}
+			logger.info("Setting git user...");
+			if (!username && !email) {
+				logger.info("No git user configuration provided.");
+				return;
+			}
+			if (username) {
+				logger.verbose(`Setting git user.name to "${username}".`);
+				if (!dryRun) await gitConfigSet("user.name", username);
+			}
+			if (email) {
+				logger.verbose(`Setting git user.email to "${email}".`);
+				if (!dryRun) await gitConfigSet("user.email", email);
+			}
+		});
 	}
-};
-const gitRollback = (ctx) => {
-	const { git: { currentTag, isCommitted, isTagged, isPushed } } = ctx;
-	if (isPushed) return;
-	if (isTagged) gitTagDeleteSync(currentTag);
-	gitResetHardSync(isCommitted ? 1 : 0);
-};
-//#endregion
-//#region src/utils.ts
-const info = (msg) => {
-	console.log(`${rgb(33, 91, 184)(`i`)} ${msg}`);
-};
-const msg = (prefix, msg) => {
-	log.message(`${rgb(33, 91, 184)(`[${prefix}]`)} ${dim(msg)}`);
-};
-const question = (msg, type) => {
-	return `${{
-		package: yellow,
-		version: green,
-		git: rgb(220, 94, 62),
-		npm: rgb(186, 70, 61),
-		github: rgb(64, 110, 228)
-	}[type]`?`} ${msg}`;
-};
-const success = (msg, dryRun) => {
-	return `${(dryRun ? rgb(123, 115, 66) : green)("✔")} ${msg}`;
-};
-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;
+	setSkippedSteps(options) {
+		const logger = this.logger.createChild("set-skipped-steps");
+		logger.verbose("Setting skipped for steps:");
+		logger.verbose(options);
+		Object.assign(this.skippedSteps, options);
+		logger.verbose("Final skipped for steps:");
+		logger.verbose(this.skippedSteps);
+		return this;
 	}
-	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 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 abortTask = (msg) => {
-	cancel(`${red("✕")} ${msg}`);
-	process.exit(0);
-};
-const abortSinglePrompt = (value) => {
-	if (isCancel(value)) abortTask(MSG.ABORT.CANCEL);
-};
-const abortGroupPrompt = (ctx) => {
-	ctx && gitRollback(ctx);
-	abortTask(MSG.ABORT.CANCEL);
-};
-const abortOnError = (err, ctx, exit = true) => {
-	ctx && gitRollback(ctx);
-	const msg = err.message.replace(/^\[(github|npm|git)]/, (a) => red(a));
-	log.message(`\n${msg}\n`);
-	exit && process.exit(1);
-};
-const taskEnd = (msg) => {
-	outro(msg);
-	process.exit(0);
-};
-//#endregion
-//#region src/version/prompts.ts
-const createVersionMap = (current) => ({
-	patch: inc(current, "patch"),
-	minor: inc(current, "minor"),
-	major: inc(current, "major"),
-	release: inc(current, "release"),
-	prerelease: inc(current, "prerelease"),
-	prepatch: inc(current, "prepatch", "beta"),
-	preminor: inc(current, "preminor", "beta"),
-	premajor: inc(current, "premajor", "beta")
-});
-const option = (label, value, hint) => ({
-	label,
-	value,
-	hint: hint ?? value
-});
-const runVersionPrompts = async (ctx, config, inferred) => {
-	const { pkg: { current, fromPreRelease } } = ctx;
-	const selectVersion = async () => {
-		const versions = createVersionMap(current);
-		const options = [
-			...fromPreRelease ? [option("Pre-Release", "prerelease", versions.prerelease)] : [],
-			option("Patch", "patch", versions.patch),
-			option("Minor", "minor", versions.minor),
-			option("Major", "major", versions.major),
-			...!fromPreRelease ? [
-				option("Pre-Patch", "prepatch", versions.prepatch),
-				option("Pre-Minor", "preminor", versions.preminor),
-				option("Pre-Major", "premajor", versions.premajor)
-			] : [],
-			option("As-Is", "ignore", current),
-			option("Custom", "custom", "custom specified")
-		];
-		const type = await select({
-			message: question(MSG.PROMPT.SELECT_VERSION, "version"),
-			options,
-			initialValue: inferred ?? (fromPreRelease ? "prerelease" : "patch")
+	checkout(options) {
+		return this.enqueue(async () => {
+			const { options: { dryRun }, stepsOptions: { checkout } } = this;
+			const { branch: headBranch = "release-branch", fetch, force } = {
+				...checkout,
+				...options
+			};
+			const logger = this.logger.createChild("checkout");
+			if (this.shouldSkip("checkout")) {
+				logger.info("Skipping checkout.");
+				return;
+			}
+			logger.info(`Checking out branch ${headBranch}...`);
+			this.state.headBranch = headBranch;
+			this.state.baseBranch = await this.getBaseBranch();
+			if (fetch) {
+				logger.verbose(`Fetching all commits and tags from the remote repository...`);
+				if (!dryRun) await gitFetch([
+					"--prune",
+					"--unshallow",
+					"--tags",
+					"--",
+					"origin",
+					"HEAD"
+				]);
+			}
+			if (force) {
+				logger.verbose(`Force checking out branch ${headBranch}...`);
+				if (!dryRun) await gitCheckoutBranchForce(headBranch);
+			} else {
+				logger.verbose(`Checking out branch ${headBranch}...`);
+				if (!dryRun) await gitCheckoutBranch(headBranch);
+			}
 		});
-		abortSinglePrompt(type);
-		return type;
-	};
-	const inputVersion = async () => {
-		const version = await text({
-			message: question(MSG.PROMPT.INPUT_VERSION, "version"),
-			initialValue: current,
-			validate: (val) => {
-				if (isUndefined(val) || !isValidVersion(val)) return "Invalid version";
+	}
+	bump(options) {
+		return this.enqueue(async () => {
+			const { project, options: { dryRun }, stepsOptions: { bump } } = this;
+			const logger = this.logger.createChild("bump");
+			if (this.shouldSkip("bump")) {
+				logger.info("Skipping bump.");
+				return;
 			}
+			logger.info("Bumping version...");
+			const done = await project.bump({
+				dryRun,
+				logger,
+				...bump,
+				...options
+			});
+			this.state.bump = done;
+			if (!done) logger.info("No version changes detected.");
 		});
-		abortSinglePrompt(version);
-		return version;
-	};
-	const resolveNextVersion = async (type, current) => {
-		if (type === "ignore") return current;
-		if (type === "custom") return inputVersion();
-		return createVersionMap(current)[type];
-	};
-	return await resolveNextVersion(await selectVersion(), current);
-};
-//#endregion
-//#region src/defaults.ts
-const createDefaultContext = () => {
-	return {
-		isCI: false,
-		release: false,
-		showRelease: false,
-		showChangelog: false,
-		onlyChangelog: 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: "beta",
-			preBase: "0",
-			scope: void 0
-		},
-		npm: {
-			username: "",
-			otp: "",
-			tag: "latest"
-		},
-		git: {
-			remoteName: "origin",
-			remoteUrl: "",
-			latestTag: "",
-			previousTag: "",
-			currentTag: "",
-			isCommitted: false,
-			isTagged: false,
-			isPushed: false,
-			commitMessage: "",
-			tagMessage: ""
-		},
-		github: {
-			url: "",
-			username: "",
-			repo: "",
-			changelog: "",
-			owner: "",
-			isWeb: false,
-			isReleased: false,
-			releaseId: 0,
-			releaseUrl: "",
-			uploadUrl: "",
-			discussionUrl: "",
-			token: "",
-			releaseName: ""
-		}
-	};
-};
-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) {
-			return ".";
-		},
-		toTag(pkg, version) {
-			return `v${version}`;
-		},
-		changelog: {
-			tagPrefix(pkg) {
-				return "";
-			},
-			releaseCount: 1,
-			includeHidden: false,
-			transformTypes: (t) => t
-		},
-		skipGit: false,
-		skipNpm: false,
-		skipGithub: false,
-		git: {
-			commit: isCI,
-			tag: isCI,
-			push: isCI,
-			commitMessage: "chore(release): ${tag}",
-			commitArgs: [],
-			tagMessage: "${tag}",
-			tagArgs: [],
-			pushArgs: [],
-			addUntrackedFiles: false,
-			requireRemote: true,
-			requireRepository: true,
-			requireCleanWorkingTree: true
-		},
-		npm: {
-			publish: isCI,
-			publishArgs: [],
-			skipChecks: false,
-			cleanup: {
-				packageJson: true,
-				readme: false,
-				removeTempDir: true
+	}
+	commit(options) {
+		return this.enqueue(async () => {
+			const { project, options: { dryRun }, state, stepsOptions: { commit } } = this;
+			const { sign, allowEmpty } = {
+				...commit,
+				...options
+			};
+			const logger = this.logger.createChild("commit");
+			if (this.shouldSkip("commit")) {
+				logger.info("Skipping commit.");
+				return;
 			}
-		},
-		github: {
-			release: isCI,
-			releaseName: "${tag}",
-			autoGenerate: false,
-			prerelease: false,
-			draft: false,
-			tokenRef: "GITHUB_TOKEN",
-			assets: [],
-			skipChecks: false,
-			shortNotes: false
+			logger.info(`Committing changes...`);
+			if (!state.bump) {
+				logger.info("No changes to commit.");
+				return;
+			}
+			const files = project.changedFiles;
+			const message = await project.getCommitMessage();
+			logger.verbose(`Files to commit:`);
+			files.forEach((file) => {
+				logger.verbose(`- ${file}`);
+			});
+			logger.verbose(message.includes("\n") ? `Commit message:\n\n${message}` : `Commit message: ${message}`);
+			if (!dryRun) {
+				await gitAdd(["--", ...files]);
+				await gitCommitMessage(message, [
+					...when(sign, "--gpg-sign"),
+					...when(allowEmpty, "--allow-empty"),
+					"--no-verify"
+				]);
+			}
+		});
+	}
+	revert() {
+		return this.enqueue(async () => {
+			const { project, logger, options: { dryRun } } = this;
+			logger.info("revert", "Reverting version updates...");
+			if (!await project.revert({
+				dryRun,
+				logger: logger.createChild("revert")
+			})) {
+				logger.info("revert", "No version updates to revert.");
+				return;
+			}
+			this.state.bump = false;
+		});
+	}
+	maintenanceBranch(options) {
+		return this.enqueue(async () => {
+			const { project, options: { dryRun }, stepsOptions: { maintenanceBranch } } = this;
+			const { enabled, force } = {
+				...maintenanceBranch,
+				...options
+			};
+			const logger = this.logger.createChild("maintenance-branch");
+			if (this.shouldSkip("maintenanceBranch")) {
+				logger.info("Skipping create maintenance branches.");
+				return;
+			}
+			logger.info("Creating maintenance branches...");
+			if (!enabled) {
+				logger.info("Maintenance branch creation is disabled.");
+				return;
+			}
+			logger.verbose("Fetching fresh tags from the remote repository...");
+			if (!dryRun) await gitFetch(["--tags"]);
+			const branches = await project.getMaintenanceBranches();
+			if (!branches.length) {
+				logger.info("No maintenance branches to create.");
+				return;
+			}
+			logger.verbose("Branches to create:");
+			for (const { from, to } of branches) {
+				logger.verbose(`- ${to} from ${from}`);
+				if (dryRun) continue;
+				if ((await gitRevParse(["--verify", `refs/heads/${to}`]) || await gitLsRemote([
+					"--heads",
+					"origin",
+					to
+				])) && !force) {
+					logger.info(`Branch ${to} already exists, skipping.`);
+					continue;
+				}
+				const args = when(force, "--force");
+				await gitBranch([
+					...args,
+					"--",
+					to,
+					from
+				]);
+				await gitPushBranch("origin", to, ["--no-verify", ...args]);
+			}
+		});
+	}
+	tag(options) {
+		return this.enqueue(async () => {
+			const { project, options: { dryRun }, stepsOptions: { tag } } = this;
+			const { fetch, sign } = {
+				...tag,
+				...options
+			};
+			const logger = this.logger.createChild("tag");
+			if (this.shouldSkip("tag")) {
+				logger.info("Skipping tag.");
+				return;
+			}
+			logger.info("Tagging version...");
+			if (fetch) {
+				logger.verbose("Fetching fresh tags from the remote repository...");
+				if (!dryRun) await gitFetch(["--tags"]);
+			}
+			const tags = await project.getTags();
+			this.state.tags = tags.length > 0;
+			if (!this.state.tags) {
+				logger.info("No version changes detected.");
+				return;
+			}
+			logger.verbose(`Tags to create:`);
+			for (const tag of tags) {
+				logger.verbose(`- ${tag}`);
+				if (!dryRun) await gitTag([
+					sign ? "--sign" : "--annotate",
+					"--message",
+					tag,
+					tag
+				]);
+			}
+		});
+	}
+	push(options) {
+		return this.enqueue(async () => {
+			const { options: { dryRun }, state, stepsOptions: { push } } = this;
+			const { force } = {
+				...push,
+				...options
+			};
+			const logger = this.logger.createChild("push");
+			if (this.shouldSkip("push")) {
+				logger.info("Skipping push.");
+				return;
+			}
+			const branch = await gitBranchCurrent();
+			logger.info(`Pushing changes to "${branch}"...`);
+			if (!state.bump && !state.tags) {
+				logger.info("Nothing to push.");
+				return;
+			}
+			if (!dryRun) {
+				if (state.bump) await gitPushBranch("origin", branch, [...when(force, "--force"), "--no-verify"]);
+				if (state.tags) await gitPush([
+					"origin",
+					"--tags",
+					"--no-verify"
+				]);
+			}
+		});
+	}
+	publish(options) {
+		return this.enqueue(async () => {
+			const { project, options: { dryRun }, stepsOptions: { publish } } = this;
+			const logger = this.logger.createChild("publish");
+			if (this.shouldSkip("publish")) {
+				logger.info("Skipping publish.");
+				return;
+			}
+			logger.info("Publishing...");
+			const tagsMap = await project.getDefaultPublishTag();
+			const name = await project.manifest.getName();
+			const tag = tagsMap.get(name);
+			await project.publish({
+				dryRun,
+				logger,
+				tag,
+				...publish,
+				...options
+			});
+		});
+	}
+	release(option) {
+		const { hosting } = this;
+		if (!hosting) throwError("Hosting service is not configured. Please set the hosting option.");
+		return this.enqueue(async () => {
+			const { project, options: { dryRun }, stepsOptions: { release } } = this;
+			const logger = this.logger.createChild("release");
+			if (this.shouldSkip("release")) {
+				logger.info("Skipping release.");
+				return;
+			}
+			logger.info("Creating release...");
+			await hosting.createRelease({
+				project,
+				dryRun,
+				logger,
+				...release,
+				...option
+			});
+		});
+	}
+	pullRequest(option) {
+		const { hosting } = this;
+		if (!hosting) throwError("Hosting service is not configured. Please set the hosting option.");
+		return this.enqueue(async () => {
+			const { project, state, options: { dryRun }, stepsOptions: { pullRequest } } = this;
+			const logger = this.logger.createChild("pull-request");
+			if (this.shouldSkip("pullRequest")) {
+				logger.info("Skipping pull request.");
+				return;
+			}
+			logger.info("Creating pull request...");
+			if (!state.bump) {
+				logger.info("No version changes detected, skipping pull request creation.");
+				return;
+			}
+			if (!state.headBranch) {
+				logger.info("Head branch is not set, skipping pull request creation.");
+				return;
+			}
+			await hosting.createPullRequest({
+				project,
+				dryRun,
+				logger,
+				from: state.headBranch,
+				to: await this.getBaseBranch(),
+				...pullRequest,
+				...option
+			});
+		});
+	}
+	async run(condition) {
+		let shouldRun = true;
+		if (condition) {
+			const logger = this.logger.createChild("run");
+			logger.info("Checking condition...");
+			shouldRun = await condition(this);
+			if (shouldRun) logger.info("Condition passed, running release steps...");
+			else logger.info("Condition failed, skipping release steps.");
 		}
-	};
-};
-//#endregion
-//#region src/git/changetype.ts
-const defaultTypes = [
-	{
-		type: "feat",
-		section: "✨ 新功能",
-		effect: "bump",
-		description: "新增功能"
-	},
-	{
-		type: "feature",
-		section: "✨ 新功能",
-		effect: "bump",
-		description: "新增功能"
-	},
-	{
-		type: "fix",
-		section: "🐛 Bug 修复",
-		effect: "bump",
-		description: "修复 bug"
-	},
-	{
-		type: "perf",
-		section: "⚡ 性能优化",
-		effect: "bump",
-		description: "提升性能"
-	},
-	{
-		type: "revert",
-		section: "⏪ 回退",
-		effect: "bump",
-		description: "回退到之前版本"
-	},
-	{
-		type: "docs",
-		section: "📝 文档",
-		effect: "changelog",
-		description: "文档更新"
-	},
-	{
-		type: "style",
-		section: "💄 样式调整",
-		effect: "hidden",
-		description: "样式或格式修改"
-	},
-	{
-		type: "chore",
-		section: "🧹 其他更新",
-		effect: "hidden",
-		description: "非功能性更改"
-	},
-	{
-		type: "refactor",
-		section: "♻️ 代码重构",
-		effect: "changelog",
-		description: "重构代码"
-	},
-	{
-		type: "test",
-		section: "🧪 测试",
-		effect: "hidden",
-		description: "测试更新"
-	},
-	{
-		type: "build",
-		section: "🏗️ 构建系统",
-		effect: "hidden",
-		description: "构建工具和系统修改"
-	},
-	{
-		type: "ci",
-		section: "🤖 CI",
-		effect: "hidden",
-		description: "持续集成配置"
-	},
-	{
-		type: "security",
-		section: "🛡️ 安全修复",
-		effect: "changelog",
-		description: "安全性更新"
-	},
-	{
-		type: "hotfix",
-		section: "🚑 热修复",
-		effect: "changelog",
-		description: "紧急修复"
-	},
-	{
-		type: "i18n",
-		section: "🌐 国际化",
-		effect: "changelog",
-		description: "国际化相关更新"
-	},
-	{
-		type: "ux",
-		section: "🎨 用户体验",
-		effect: "changelog",
-		description: "用户体验改进"
-	},
-	{
-		type: "deps",
-		section: "📦 依赖更新",
-		effect: "changelog",
-		description: "依赖版本变更"
-	},
-	{
-		type: "tool",
-		section: "🛠️ 工具链",
-		effect: "hidden",
-		description: "工具链变更"
-	},
-	{
-		type: "config",
-		section: "⚙️ 配置",
-		effect: "hidden",
-		description: "配置文件更新"
+		if (shouldRun) for (const fn of this.queue) await fn();
+		const logger = this.logger.createChild("done");
+		this.queue.length = 0;
+		logger.info(`Done!`);
 	}
-];
-//#endregion
-//#region src/git/templates.ts
-const isLikelyHash = (value) => /^[0-9a-f]{7,40}$/i.test(value);
-function headerPartial(context) {
-	const { isPatch, linkCompare, version, title, date, previousTag } = context;
-	const fullTitle = words(linkCompare && !isLikelyHash(previousTag) ? link(version, compareUrl(context)) : version, title && `"${title}"`, date && `(${date})`);
-	return heading(2, isPatch ? small(fullTitle) : fullTitle);
-}
-function preamblePartial(contest) {
-	const { preamble, commitGroups, noteGroups } = contest;
-	return segments(preamble, isEmpty(preamble) && isEmpty(commitGroups) && isEmpty(noteGroups) && "Version bump without any changes.");
-}
-function template(context) {
-	const { headerPartial, preamblePartial, commitPartial, footerPartial, noteGroups, commitGroups } = context;
-	return segments(headerPartial(context), preamblePartial(context), each(noteGroups, (group) => segments(heading(3, words("⚠", group.title)), list(group.notes, (note) => {
-		return each([words(note.commit.scope && bold(`${note.commit.scope}:`), commitPartial(context, note.commit)), note.commit.subject.trim() !== note.text.trim() ? list([note.text], (t) => t) : ""], (t) => t, newline());
-	})), newline(2)), each(commitGroups, (group) => segments(group.title && heading(3, group.title), list(group.commits, (commit) => commitPartial(context, commit))), newline(2)), footerPartial(context));
-}
-//#endregion
-//#region src/git/changelog.ts
-const parsePreset = (options = {}) => {
-	const { includeHidden, transformTypes, scope } = options;
-	let types = [...defaultTypes];
-	if (includeHidden) types.forEach((type) => {
-		if (type.effect === "hidden") type.effect = "changelog";
-	});
-	types = transformTypes?.(types) ?? types;
-	const preset = createPreset({
-		types,
-		scope
-	});
-	preset.writer ??= {};
-	preset.writer.preamblePartial = preamblePartial;
-	preset.writer.headerPartial = headerPartial;
-	preset.writer.template = template;
-	return preset;
-};
-const inferReleaseType = async (options) => {
-	const preset = parsePreset(options);
-	const res = await new Bumper().config(preset).bump(preset.whatBump);
-	if (!("releaseType" in res)) return void 0;
-	const { releaseType, reason } = res;
-	return options?.json ? {
-		releaseType,
-		reason
-	} : releaseType;
-};
-const createGenerator = async (options) => {
-	const { getPkgDir, tagPrefix, releaseCount = 1, includeHidden, transformTypes, scope } = options;
-	const pkgDir = getPkgDir();
-	return new ConventionalChangelog().readPackage(`${pkgDir}/package.json`).config(parsePreset({
-		includeHidden,
-		transformTypes,
-		scope
-	})).options({ releaseCount }).commits({ path: pkgDir }).tags({ prefix: tagPrefix });
-};
-const getChangelog = async (options) => {
-	const generator = await createGenerator(options);
-	let changelog = "";
-	for await (const chunk of generator.write()) changelog += chunk;
-	return changelog.trimEnd();
-};
-const generateChangelog = async (options) => {
-	const { getPkgDir, releaseCount = 1 } = options;
-	const infile = join(getPkgDir(), "CHANGELOG.md");
-	if (!existsSync(infile)) await writeFile(infile, "");
-	const exist = readFileSync(infile, "utf-8");
-	const writeStream = createWriteStream(infile);
-	const generator = await createGenerator(options);
-	for await (const chunk of generator.write()) writeStream.write(chunk);
-	const override = isZero(releaseCount);
-	if (!(isZero(exist.trim().length) || override)) {
-		writeStream.write(eol());
-		writeStream.write(exist);
+	shouldSkip(step) {
+		return this.skippedSteps[step] === true;
+	}
+	async getBaseBranch() {
+		const { state: { baseBranch } } = this;
+		if (baseBranch) return baseBranch;
+		return gitBranchCurrent();
 	}
-	writeStream.end();
-	await finished(writeStream);
 };
 //#endregion
-//#region src/git/prompts.ts
-const runGitPrompts = async (ctx, config) => {
-	const { git: { currentTag, commitMessage }, configFileExists: cfe, dryRun, isCI } = ctx;
-	const { git: { commit, tag, push } } = config;
-	const logs = [];
-	const shouldPrompt = (val) => isUndefined(val) || dryRun && !isCI;
-	const { log: _, ...reset } = await group({
-		commit: () => {
-			return shouldPrompt(commit) ? confirm({ message: question(MSG.PROMPT.GIT_COMMIT(commitMessage), "git") }) : (() => {
-				logs.push(yellow`git.commit`);
-				return Promise.resolve(commit);
-			})();
-		},
-		tag: ({ results: { commit } }) => {
-			return shouldPrompt(tag) ? commit ? confirm({ message: question(MSG.PROMPT.GIT_TAG(currentTag), "git") }) : (() => {
-				return Promise.resolve(false);
-			})() : (() => {
-				logs.push(yellow`git.tag`);
-				return Promise.resolve(tag);
-			})();
+//#region src/releaser-cli/prompts.ts
+const abortTask = (msg) => {
+	cancel(`${red("✕")} ${msg ?? "Release cancelled."}`);
+	process.exit(0);
+};
+const singlePrompt = async (fn, abortMsg) => {
+	const value = await fn();
+	if (isCancel(value)) abortTask(abortMsg);
+	return value;
+};
+const question = (msg, dryRun) => {
+	return `${(dryRun ? yellow : red)("?")} ${msg}`;
+};
+const getVersionHint = async (project, options = {}) => await project.getNextVersion(options) ?? "No version change";
+const createVersionOptions = async (project, options = {}, current, tagPrefix) => {
+	const firstRelease = await project.isFirstRelease({ tagPrefix });
+	if (firstRelease) return [
+		{
+			label: "Initial release",
+			value: "initial",
+			hint: `Release ${current}`,
+			bump: {
+				version: current,
+				firstRelease
+			}
 		},
-		push: ({ results: { commit, tag } }) => {
-			return shouldPrompt(push) ? commit || tag ? confirm({ message: question(MSG.PROMPT.GIT_PUSH, "git") }) : (() => {
-				return Promise.resolve(false);
-			})() : (() => {
-				logs.push(yellow`git.push`);
-				return Promise.resolve(push);
-			})();
+		{
+			label: "Custom",
+			value: "custom",
+			hint: "Specify an exact version"
 		},
-		log: () => {
-			if (logs.length) msg("GIT", `Using ${cfe ? "user" : "default"} config: ${logs.join(", ")}`);
-			return Promise.resolve();
+		{
+			label: "As-is",
+			value: "ignore",
+			hint: `Do not update the version ${current}`,
+			bump: { version: current }
 		}
-	}, { onCancel: ({ results }) => {
-		abortGroupPrompt(ctx);
-	} });
-	Object.assign(config.git, reset);
-};
-//#endregion
-//#region src/github/prompts.ts
-const runGithubPrompts = async (ctx, config) => {
-	const { configFileExists: cfe, dryRun, github: { releaseName }, isCI } = ctx;
-	const { github: { release } } = config;
-	const logs = [];
-	const shouldPrompt = (val) => isUndefined(val) || dryRun && !isCI;
-	const res = await group({
-		release: () => shouldPrompt(release) ? confirm({ message: question(MSG.PROMPT.GITHUB_RELEASE(releaseName), "github") }) : (() => {
-			logs.push(yellow`github.release`);
-			return Promise.resolve(release);
-		})(),
-		log: () => {
-			if (logs.length) msg("GITHUB", `Using ${cfe ? "user" : "default"} config: ${logs.join(", ")}`);
-			return Promise.resolve();
+	];
+	const fromPreRelease = isPrerelease(current);
+	const candidates = [
+		{
+			label: fromPreRelease ? "Release" : "Patch",
+			value: "patch",
+			hint: await getVersionHint(project, {
+				...options,
+				tagPrefix,
+				as: "patch"
+			}),
+			bump: { as: "patch" }
+		},
+		{
+			label: "Minor",
+			value: "minor",
+			hint: await getVersionHint(project, {
+				...options,
+				tagPrefix,
+				as: "minor"
+			}),
+			bump: { as: "minor" }
+		},
+		{
+			label: "Major",
+			value: "major",
+			hint: await getVersionHint(project, {
+				...options,
+				tagPrefix,
+				as: "major"
+			}),
+			bump: { as: "major" }
 		}
-	}, { onCancel: ({ results }) => {
-		abortGroupPrompt(ctx);
-	} });
-	Object.assign(config.github, { release: res.release });
-	return res;
-};
-//#endregion
-//#region src/github/release.ts
-const truncateBody = (body) => {
-	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
-	return body;
-};
-const getReleaseByTagSafe = async (octokit, options) => {
-	try {
-		const { data } = await octokit.repos.getReleaseByTag({ ...options });
-		return data;
-	} catch (e) {
-		if (e?.status === 404) return null;
-		throw e;
-	}
-};
-const createCRelease = async (octokit, options) => {
-	const { owner, repo, tag, name, body, draft, prerelease, generateReleaseNotes, makeLatest, targetCommitish, discussionCategoryName } = options;
-	const { data } = await octokit.repos.createRelease({
-		owner,
-		repo,
-		tag_name: tag,
-		name,
-		body,
-		draft,
-		prerelease,
-		generate_release_notes: generateReleaseNotes,
-		make_latest: makeLatest,
-		target_commitish: targetCommitish,
-		discussion_category_name: discussionCategoryName
+	];
+	if (fromPreRelease) candidates.unshift({
+		label: "Pre-release",
+		value: "prerelease",
+		hint: await getVersionHint(project, {
+			...options,
+			tagPrefix,
+			as: "prerelease"
+		}),
+		bump: { as: "prerelease" }
 	});
-	return data;
-};
-const updateCRelease = async (octokit, options) => {
-	const { owner, repo, tag, name, body, draft, prerelease, generateReleaseNotes, makeLatest, targetCommitish, discussionCategoryName, releaseId } = options;
-	const { data } = await octokit.repos.updateRelease({
-		owner,
-		repo,
-		release_id: releaseId,
-		tag_name: tag,
-		name,
-		body,
-		draft,
-		prerelease,
-		generate_release_notes: generateReleaseNotes,
-		make_latest: makeLatest,
-		target_commitish: targetCommitish,
-		discussion_category_name: discussionCategoryName
+	else for (const as of [
+		"patch",
+		"minor",
+		"major"
+	]) candidates.push({
+		label: `Pre-${as[0].toUpperCase()}${as.slice(1)}`,
+		value: `pre${as}`,
+		hint: await getVersionHint(project, {
+			...options,
+			tagPrefix,
+			as,
+			prerelease: "beta"
+		}),
+		bump: {
+			as,
+			prerelease: "beta"
+		}
 	});
-	return data;
-};
-const createCReleaseByTag = async (octokit, options) => {
-	const existing = await getReleaseByTagSafe(octokit, options);
-	if (!existing) return createCRelease(octokit, { ...options });
-	const { draft, id: releaseId } = existing;
-	if (!draft) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(options.tag));
-	return updateCRelease(octokit, {
-		releaseId,
-		...options
+	candidates.push({
+		label: "Custom",
+		value: "custom",
+		hint: "Specify an exact version"
+	}, {
+		label: "As-is",
+		value: "ignore",
+		hint: `Do not update the version ${current}`,
+		bump: { version: current }
 	});
-};
-const uploadAssets = async (octokit, options) => {
-	const { owner, repo, name, uploadUrl, releaseId, assets } = options;
-	const files = await glob(assets);
-	await Promise.all(files.map((file) => {
-		return octokit.repos.uploadReleaseAsset({
-			owner,
-			repo,
-			name,
-			url: uploadUrl,
-			release_id: releaseId,
-			data: createReadStream(file),
-			headers: {
-				"content-type": contentType(file) || "application/octet-stream",
-				"content-length": statSync(file).size
-			}
+	return candidates;
+};
+const runBumpPrompts = async (project, options = {}) => {
+	const { bump: bumpOpts = {}, run = {} } = options;
+	const bump = { ...bumpOpts };
+	const { dryRun = false, ci = false } = run;
+	if (bump.version || bump.as || bump.snapshot) return bump;
+	const runVersionPrompts = async (project, tagPrefix) => {
+		const promptsRes = {};
+		const inferred = await project.inferReleaseType({
+			...bump,
+			tagPrefix
 		});
-	}));
-};
-const createWebRelease = async (options) => {
-	const { owner, repo, tag, title, body, prerelease } = options;
-	const url = new URL(`${getGithubUrl(owner, repo)}/releases/new`);
-	Object.entries({
-		tag,
-		title,
-		body,
-		prerelease
-	}).forEach(([key, value]) => {
-		url.searchParams.set(key, value);
-	});
-	await open(url.toString());
-};
-const isGitHubActions = Boolean(process.env.GITHUB_ACTIONS);
-const githubCheck = async (ctx, config) => {
-	const { git: { remoteUrl } } = ctx;
-	const { github: { tokenRef, skipChecks } } = config;
-	if (!remoteUrl || isEmpty(parseGitHubRepo(remoteUrl))) {
-		ctx.noGitHub = true;
-		return;
-	}
-	const [owner, repo] = parseGitHubRepo(remoteUrl);
-	const url = getGithubUrl(owner, repo);
-	Object.assign(ctx.github, {
-		owner,
-		repo,
-		url
-	});
-	const token = tokenRef ? process.env[tokenRef] : process.env.GITHUB_TOKEN;
-	if (!token) {
-		Object.assign(ctx.github, { isWeb: true });
-		if (isGitHubActions) throw new Error(MSG.ERROR.GITHUB_TOKEN(tokenRef));
-		return;
-	}
-	Object.assign(ctx.github, { token });
-	if (!isGitHubActions && !skipChecks) {
-		const octokit = new Octokit({ auth: token });
-		let username = "";
-		try {
-			const { data: { login } } = await octokit.users.getAuthenticated();
-			username = login;
-		} catch (e) {
-			throw new Error(MSG.ERROR.GITHUB_AUTH);
+		const name = await project.manifest.getName();
+		const current = await project.manifest.getVersion();
+		let useCustom = false;
+		let customVersion = current;
+		if (project.isMonorepoMode() && project.isFixedMode) {
+			const { version: maxVersion, packages } = await project.getMaxVersion();
+			if (lt(current, maxVersion)) {
+				useCustom = true;
+				customVersion = inc(maxVersion, inferred ?? "patch");
+				note(`
+            Current version: ${current}
+            Highest package version: ${maxVersion}
+            Packages at this version:\n${packages.map((name) => `- ${name}`).join("\n")}
+            
+            Minimum release version: ${maxVersion}
+            Suggested release version: ${customVersion} (used in CI)
+          `.trim(), "Monorepo version mismatch", { format(line) {
+					return line.trim();
+				} });
+			}
 		}
-		try {
-			await octokit.repos.checkCollaborator({
-				owner,
-				repo,
-				username
-			});
-		} catch (e) {
-			throw new Error(MSG.ERROR.GITHUB_USER);
+		const versionOptions = await createVersionOptions(project, bump, current, tagPrefix);
+		const find = (val) => versionOptions.find((option) => option.value === val);
+		const fromPreRelease = isPrerelease(current);
+		const initialValue = useCustom ? "custom" : inferred && find(inferred) ? inferred : fromPreRelease && find("prerelease") ? "prerelease" : "patch";
+		const type = ci ? initialValue : await singlePrompt(() => select({
+			message: question(`Select "${cyan`${name}`}" release version type:`, dryRun),
+			options: versionOptions,
+			initialValue
+		}));
+		if (equals(type, "custom")) promptsRes.version = ci ? customVersion : await singlePrompt(() => text({
+			message: question("Enter release version:", dryRun),
+			initialValue: customVersion,
+			placeholder: customVersion,
+			validate: (val) => {
+				if (isUndefined(val) || !isValidVersion(val)) return "Invalid version.";
+			}
+		}));
+		else {
+			const selected = find(type);
+			Object.assign(promptsRes, selected?.bump);
 		}
+		return promptsRes;
+	};
+	if (project.isMonorepoMode() && project.isIndependentMode) for await (const subProject of project.getProjects()) {
+		const name = await subProject.manifest.getName();
+		const scope = await project.getScope(name);
+		const tagPrefix = await project.getTagPrefix(scope);
+		const monoBump = bump;
+		(monoBump.byProject ??= {})[name] = {
+			...monoBump.byProject?.[name],
+			...await runVersionPrompts(subProject, tagPrefix)
+		};
 	}
-};
-const createRelease = async (ctx, config) => {
-	const { pkg: { name, toPreRelease }, git: { currentTag }, isCI, dryRun } = ctx;
-	const { github: { isWeb, token, owner, repo, changelog, releaseName } } = ctx;
-	const { github: { release, assets, prerelease, autoGenerate, draft } } = config;
-	if (!release || dryRun) return;
-	const octokit = new Octokit({ auth: token });
-	if (isWeb) await createWebRelease({
-		owner,
-		repo,
-		tag: currentTag,
-		title: releaseName,
-		body: truncateBody(changelog),
-		prerelease: String(toPreRelease || prerelease)
-	});
-	else if (isCI) {
-		const res = await createCReleaseByTag(octokit, {
-			owner,
-			repo,
-			tag: currentTag,
-			name: releaseName,
-			body: autoGenerate ? "" : truncateBody(changelog),
-			draft,
-			prerelease: toPreRelease || prerelease,
-			generateReleaseNotes: autoGenerate,
-			makeLatest: "true"
-		});
-		if (!res) return;
-		if (assets.length) {
-			const { id: releaseId, upload_url: uploadUrl } = res;
-			await uploadAssets(octokit, {
-				owner,
-				repo,
-				name,
-				uploadUrl,
-				releaseId,
-				assets
-			});
-		}
+	else {
+		const result = await runVersionPrompts(project);
+		Object.assign(bump, result);
 	}
+	return bump;
 };
-//#endregion
-//#region src/npm/prompts.ts
-const runNpmPublishPrompts = async (ctx, config) => {
-	const { pkg: { name, next }, configFileExists: cfe, dryRun, isCI } = ctx;
-	const { npm: { publish } } = config;
-	const logs = [];
-	const target = `${name}@${next}`;
-	const shouldPrompt = (val) => isUndefined(val) || dryRun && !isCI;
+const getCliPromptOptions = async (options = {}) => {
+	const { dryRun = false, ci = false } = options;
+	const shouldPrompt = (v) => !ci && (isUndefined(v) || dryRun);
 	const res = await group({
-		publish: () => shouldPrompt(publish) ? confirm({ message: question(MSG.PROMPT.NPM_PUBLISH(target), "npm") }) : (() => {
-			logs.push(yellow`npm.publish`);
-			return Promise.resolve(publish);
-		})(),
-		log: () => {
-			if (logs.length) msg("NPM", `Using ${cfe ? "user" : "default"} config: ${logs.join(", ")}`);
-			return Promise.resolve();
-		}
-	}, { onCancel: async ({ results }) => {
-		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: ({ results }) => {
-		abortGroupPrompt(ctx);
+		commit: () => options.skipGit ? Promise.resolve(false) : shouldPrompt(options.skipGit) ? confirm({ message: question("Commit release changes?", dryRun) }) : Promise.resolve(true),
+		tag: () => options.skipGit ? Promise.resolve(false) : shouldPrompt(options.skipGit) ? confirm({ message: question("Create release tags?", dryRun) }) : Promise.resolve(true),
+		push: () => options.skipGit ? Promise.resolve(false) : shouldPrompt(options.skipGit) ? confirm({ message: question("Push release changes?", dryRun) }) : Promise.resolve(true),
+		publish: () => options.skipPublish ? Promise.resolve(false) : shouldPrompt(options.skipPublish) ? confirm({ message: question("Publish project?", dryRun) }) : Promise.resolve(true),
+		release: () => options.skipRelease || options.skipGit ? Promise.resolve(false) : shouldPrompt(options.skipRelease) ? confirm({ message: question("Create repository release?", dryRun) }) : Promise.resolve(true)
+	}, { onCancel: () => {
+		abortTask();
 	} });
-	Object.assign(ctx.npm, { otp: res.otp });
-	return res;
-};
-//#endregion
-//#region src/npm/cleanup.ts
-const PUBLISH_CONFIG_FIELDS = [
-	"bin",
-	"main",
-	"exports",
-	"types",
-	"typings",
-	"module",
-	"browser",
-	"esnext",
-	"es2015",
-	"unpkg",
-	"umd:main",
-	"typesVersions",
-	"cpu",
-	"os",
-	"engines"
-];
-const IGNORE_FIELDS = [
-	"babel",
-	"browserslist",
-	"c8",
-	"commitlint",
-	"devDependencies",
-	"eslintConfig",
-	"eslintIgnore",
-	"husky",
-	"jest",
-	"lint-staged",
-	"nano-staged",
-	"pre-commit",
-	"prettier",
-	"pwmetrics",
-	"remarkConfig",
-	"renovate",
-	"resolutions",
-	"sharec",
-	"simple-git-hooks",
-	"simple-pre-commit",
-	"size-limit",
-	"typeCoverage",
-	"yaspeller",
-	"pnpm",
-	"packageManager"
-];
-const KEEP_SCRIPT_NAMES = [
-	"preinstall",
-	"install",
-	"postinstall"
-];
-const IGNORE_FILES = [
-	".DS_Store",
-	".git",
-	".vscode",
-	".idea",
-	"node_modules"
-];
-const clearPackageJSON = async (dir, options) => {
-	const file = join(dir, "package.json");
-	const json = await readJsonFile(file);
-	const { ignoreFields = [], keepScripts = [] } = options ?? {};
-	const mergePublishConfig = (json) => {
-		if (!json.publishConfig) return json;
-		const publishConfig = { ...json.publishConfig };
-		PUBLISH_CONFIG_FIELDS.forEach((field) => {
-			if (publishConfig[field]) {
-				json[field] = publishConfig[field];
-				delete publishConfig[field];
-			}
-		});
-		return {
-			...json,
-			publishConfig
-		};
-	};
-	const removeIgnoredFields = (json) => {
-		const [matched, unmatched] = partition([...ignoreFields, ...IGNORE_FIELDS], (i) => i.includes("."));
-		matched.forEach((field) => unset(json, field));
-		return omit(json, unmatched);
-	};
-	const cleanScripts = (json) => {
-		if (!json.scripts) return json;
-		const keep = [...keepScripts, ...KEEP_SCRIPT_NAMES];
-		const excludes = Object.keys(json.scripts).filter((k) => !keep.includes(k));
-		json.scripts = omit(json.scripts, excludes);
-		return json;
-	};
-	const removeEmptyObjects = (json) => {
-		return omit(json, Object.entries(json).filter(([k, v]) => isEmptyObject(v)).map(([k, v]) => k));
+	return {
+		commit: !res.commit,
+		tag: !res.tag,
+		push: !res.push,
+		publish: !res.publish,
+		release: !res.release
 	};
-	await writeJsonFile(file, removeEmptyObjects(cleanScripts(removeIgnoredFields(structuredClone(mergePublishConfig(json))))));
 };
-const cleanReadme = async (dir, homepage) => {
-	const file = join(dir, "README.md");
-	homepage && await editFile(file, (str) => {
-		return str.split(/^##\s+\S.*$/m)[0] + `## Docs
-
-Read full docs **[here](${homepage})**.`;
-	});
+const runConfirmPrompts = async (ci = false, dryRun = false) => {
+	if (!(ci ? true : await singlePrompt(() => confirm({ message: question(red("Confirm start workflow?"), dryRun) })))) abortTask();
 };
 //#endregion
-//#region src/npm/publish.ts
-const canPublish = async (registry, cwd) => {
-	const res = await runNpm([
-		"publish",
-		"--dry-run",
-		"--access",
-		"public",
-		...registryArg(registry)
-	], {
-		error: "throw",
-		cwd
-	}).catch((err) => err);
-	const allowedErr = (err) => {
-		return [/previously published versions/i, /cannot publish over/i].some((reg) => reg.test(err.message));
-	};
-	if (!(res instanceof Error) || allowedErr(res)) return true;
-	throw res;
-};
-const npmCheck = async (ctx, config) => {
-	const { pkg: { name, current, publishConfig: { registry } }, selectedPkg } = ctx;
-	const { npm: { skipChecks }, getPkgDir } = config;
-	const tag = await resolvePublishTag(name, current);
-	Object.assign(ctx.npm, { tag });
-	if (skipChecks) return "";
-	const [pinged, username] = await Promise.all([
-		pingRegistry(registry),
-		getAuthenticatedUser(registry),
-		canPublish(registry, getPkgDir(selectedPkg))
-	]);
-	if (!pinged) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
-	if (!username) throw new Error(MSG.ERROR.NPM_AUTH);
-	Object.assign(ctx.npm, { username });
-	const latest = await getPublishedVersion(`${name}@${tag}`);
-	if (latest) {
-		if (!await hasWriteAccess(name, username, registry)) throw new Error(MSG.ERROR.NPM_USER(username, name));
-	}
-	return latest ? `(${tag} → ${latest})` : `(${tag} → no published version)`;
-};
-const publishNpm = async (ctx, config) => {
-	const { dryRun, selectedPkg, npm: { otp, tag }, github: { url } } = ctx;
-	const { npm: { publish, publishArgs, cleanup: { packageJson, readme, removeTempDir } }, getPkgDir } = config;
-	if (!publish) return;
-	const otpArgs = otp ? ["--otp", otp] : [];
-	const dryRunArg = dryRun ? ["--dry-run"] : [];
-	const args = [
-		...otpArgs,
-		...publishArgs,
-		...dryRunArg
-	];
-	if (packageJson || readme) {
-		const parent = resolve(getPkgDir(selectedPkg));
-		const temp = await createTempDir(parent);
-		await copyDir(parent, temp.path, { ignore: [(name) => {
-			return [temp.name, ...IGNORE_FILES].map((pattern) => createMatcher(pattern)).some((matcher) => matcher(name));
-		}] });
-		const options = typeof packageJson === "boolean" ? void 0 : packageJson;
-		packageJson && await clearPackageJSON(temp.path, options);
-		readme && await cleanReadme(temp.path, `${url}#readme`);
-		await publishPackage({
-			tag,
-			args,
-			cwd: temp.path
+//#region src/releaser-cli/releaser.ts
+var ReleaserCli = class extends Releaser {
+	constructor(options) {
+		const { silent, dryRun, verbose } = options;
+		super({
+			logger: new Logger({
+				silent,
+				dryRun,
+				verbose,
+				colors: [
+					blue,
+					blueBright,
+					cyan,
+					cyanBright,
+					green,
+					greenBright,
+					magenta,
+					magentaBright,
+					red,
+					redBright
+				].sort(() => Math.random() - .5),
+				printer: ({ dryRun, stage, message, color }) => {
+					const msg = isString(message) ? message : JSON.stringify(message, null, 2);
+					log.message(dim`${dryRun ? yellow`[dry-run]` : ""}${color(`[${stage}]`)}: ${msg}`);
+				}
+			}),
+			...options
 		});
-		removeTempDir && await temp.remove();
-	} else await publishPackage({
-		tag,
-		args,
-		cwd: getPkgDir(selectedPkg)
-	});
-};
-//#endregion
-//#region src/action.ts
-var Action = class {
-	async handleRelease(cmdArgs, options) {
-		const { ctx, config } = await this.createContext(cmdArgs, options);
-		await this.checkTask(ctx, config);
-		await this.bumpTask(ctx, config);
-		await this.changelogTask(ctx, config);
-		await this.gitTask(ctx, config);
-		await this.npmTask(ctx, config);
-		await this.githubTask(ctx, config);
-		if (ctx.dryRun) gitRollback(ctx);
-		taskEnd(MSG.OUTRO(ctx.dryRun));
 	}
-	async handlePrepareRelease(cmdArgs, options) {
-		const { ctx, config } = await this.createContext(cmdArgs, options);
-		await this.checkTask(ctx, config);
-		await this.bumpTask(ctx, config);
-		await this.changelogTask(ctx, config);
-		await this.gitTask(ctx, config);
-		if (ctx.dryRun) gitRollback(ctx);
-		taskEnd(MSG.OUTRO_PREPARE(ctx.dryRun));
-	}
-	async createContext(cmdArgs, options) {
-		const { configFile, config } = await this.createConfig(options);
-		info(MSG.INFO.TOOL(name, version));
-		info(MSG.INFO.CONFIG(configFile));
-		console.log();
-		const { otp, package: defPkg, prepare, showChangelog, showRelease, ci, dryRun, onlyChangelog } = options;
-		intro(prepare ? MSG.INTRO_PREPARE(dryRun) : MSG.INTRO(dryRun));
-		const { isMonorepo, packages, getPkgDir, skipGit, skipNpm, skipGithub } = 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 = await select({
-				message: question(MSG.PROMPT.SELECT_PACKAGE, "package"),
-				options: packages.map((pkg) => ({
-					label: pkg,
-					value: pkg
-				}))
-			});
-			abortSinglePrompt(pkg);
-			return pkg;
-		};
-		const selectedPkg = !isMonorepo ? "" : ci ? defPkg : packages.length === 1 ? packages[0] : await selectPackage();
-		const { pkg, pkgDir } = getPackageInfo(selectedPkg, getPkgDir);
-		const { version: pkgVersion, private: pkgPrivate = false, name: pkgName, publishConfig = {} } = pkg;
-		const nextVersion = inc(pkgVersion, cmdArgs) ?? "";
-		const ctx = mergeConfig(createDefaultContext(), {
-			selectedPkg,
-			configFileExists: isNotEmpty(configFile),
-			dryRun,
-			showRelease,
-			showChangelog,
-			onlyChangelog,
-			npm: { otp: String(otp) },
-			increment: cmdArgs,
-			isIncrement: true,
-			isCI: [
-				ci,
-				showChangelog,
-				showRelease,
-				process.env.GITHUB_ACTIONS,
-				process.env.CI
-			].some(Boolean),
-			pkg: {
-				name: pkgName,
-				isPrivate: pkgPrivate,
-				fromPreRelease: isPrerelease(pkgVersion),
-				current: pkgVersion,
-				next: nextVersion,
-				toPreRelease: false,
-				publishConfig: { ...publishConfig },
-				scope: isEmpty(selectedPkg) ? void 0 : selectedPkg
-			},
-			noGit: skipGit,
-			noNpm: pkgPrivate || skipNpm,
-			noGitHub: skipGit || skipGithub
+	tag(options = {}) {
+		return super.tag({
+			fetch: true,
+			...options
 		});
-		const { messages } = await publint({ pkgDir });
-		for (const message of messages) {
-			const formated = formatMessage(message, pkg);
-			formated && msg("PKG", formated);
-		}
-		return {
-			ctx,
-			config
-		};
 	}
-	async createConfig(options) {
-		const { ci, requireCleanWorkingTree, skipGit, skipNpm, skipGithub, isMonorepo, includeHidden, releaseCount } = options;
-		const toFalse = (value) => {
-			return isBoolean(value) && !value ? value : void 0;
-		};
-		const toNumber = (value) => {
-			return isNumber(value) ? value : void 0;
-		};
-		const defaultConfig = createDefaultConfig(ci ? true : void 0);
-		const { configFile, config: local } = await this.resolveUserConfig(process.cwd());
-		return {
-			configFile,
-			config: mergeConfig(mergeConfig(defaultConfig, local), {
-				changelog: {
-					releaseCount: toNumber(releaseCount),
-					includeHidden
-				},
-				git: { requireCleanWorkingTree: toFalse(requireCleanWorkingTree) },
-				skipGit,
-				skipNpm,
-				skipGithub,
-				isMonorepo
-			})
-		};
-	}
-	async resolveUserConfig(cwd = process.cwd()) {
-		return resolveConfig(cwd);
-	}
-	async printChangelog(ctx, config) {
-		const { showChangelog, selectedPkg, noGit, isIncrement, pkg: { scope } } = ctx;
-		const { isMonorepo, getPkgDir, changelog: { tagPrefix, releaseCount, includeHidden, transformTypes } } = config;
-		const { github: { shortNotes } } = config;
-		if (noGit) return;
-		const match = isMonorepo ? `${tagPrefix?.(selectedPkg)}*` : "*";
-		const { from, to } = isZero(releaseCount) ? {
-			from: "",
-			to: "HEAD"
-		} : await resolveChangelogRange(isIncrement, match);
-		const commits = await getLogSince(from, to, getPkgDir(selectedPkg));
-		const changelog = await getChangelog({
-			getPkgDir: () => getPkgDir(selectedPkg),
-			tagPrefix: tagPrefix?.(selectedPkg),
-			scope: isEmpty(nonNullable([scope])) ? void 0 : nonNullable([scope]),
-			releaseCount,
-			includeHidden,
-			transformTypes
+	push(options = {}) {
+		return super.push({
+			force: true,
+			...options
 		});
-		const short = `Please refer to [CHANGELOG.md](${getPkgDir(selectedPkg)}/CHANGELOG.md) for details.`;
-		Object.assign(ctx.github, { changelog: shortNotes ? short : changelog });
-		if (commits) {
-			msg("GIT", `Changelog(${from}...${to}):${eol(2)}` + changelog);
-			msg("GIT", `Commits(${from}...${to}):${eol(2)}` + commits);
-			if (showChangelog) taskEnd(MSG.LOG.SHOW_CHANGELOG);
-		} else msg("GIT", MSG.LOG.CHANGELOG_EMPTY);
 	}
-	async checkTask(ctx, config) {
-		const { dryRun, onlyChangelog } = ctx;
-		await tasks([
-			{
-				title: MSG.CHECK.GIT.CHECKING,
-				task: async () => {
-					await gitCheck(ctx, config);
-					const { git: { remoteName, remoteUrl } } = ctx;
-					return success(MSG.CHECK.GIT.CHECKED(remoteName, remoteUrl), dryRun);
-				},
-				enabled: !ctx.noGit
-			},
-			{
-				title: MSG.CHECK.NPM.CHECKING,
-				task: async () => {
-					const msg = await npmCheck(ctx, config);
-					const { pkg: { publishConfig: { registry } } } = ctx;
-					return success(MSG.CHECK.NPM.CHECKED(registry, msg), dryRun);
-				},
-				enabled: !(ctx.noNpm || onlyChangelog)
-			},
-			{
-				title: MSG.CHECK.GITHUB.CHECKING,
-				task: async () => {
-					await githubCheck(ctx, config);
-					const { github: { owner, repo } } = ctx;
-					const repository = getGithubUrl(owner, repo);
-					return success(MSG.CHECK.GITHUB.CHECKED(repository), dryRun);
-				},
-				enabled: !(ctx.noGitHub || onlyChangelog)
-			}
-		]).catch(abortOnError);
+	async run(...args) {
+		await super.run(...args);
+		this.end();
 	}
-	async bumpTask(ctx, config) {
-		const { pkg: { current }, dryRun, isCI, showRelease, selectedPkg, onlyChangelog } = ctx;
-		const { hooks, getPkgDir, changelog: { includeHidden, transformTypes } } = config;
-		if (onlyChangelog) return;
-		const need = (ctx) => {
-			const { pkg: { next }, isIncrement } = ctx;
-			return !next && isIncrement;
-		};
-		if (need(ctx)) {
-			const res = await inferReleaseType({
-				includeHidden,
-				transformTypes,
-				json: true
-			});
-			if (res) msg("BUMP", res.reason);
-			const inferred = res?.releaseType;
-			const nextVersion = (isCI ? inc(current, inferred ?? "patch") : void 0) || await runVersionPrompts(ctx, config, inferred);
-			ctx.isIncrement = neq(current, nextVersion);
-			const { version: next, isPrerelease: toPreRelease, preId, preBase } = parseVersion(nextVersion);
-			Object.assign(ctx.pkg, {
-				next,
-				toPreRelease,
-				preId,
-				preBase
+	setCliOptions(options) {
+		return this.enqueue(async () => {
+			const { ci, dryRun, releaseType: as } = options;
+			const { project, stepsOptions: { bump: bumpOpts } } = this;
+			const bump = await runBumpPrompts(project, {
+				bump: {
+					...bumpOpts,
+					as
+				},
+				run: options
 			});
-		}
-		const { pkg: { next } } = 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 = `(${current}...${diff(current, next)})`;
-				return success(MSG.TASK.VERSION.END(to), dryRun);
-			},
-			enabled: true
-		}]).catch((err) => abortOnError(err, ctx));
-		await runLifeCycleHook(hooks, "after:bump", dryRun);
-		await this.printChangelog(ctx, config);
-	}
-	async changelogTask(ctx, config) {
-		const { isIncrement, dryRun, selectedPkg, noGit, onlyChangelog, pkg: { scope } } = ctx;
-		const { getPkgDir, changelog: { tagPrefix, releaseCount, includeHidden, transformTypes } } = config;
-		if (noGit) return;
-		await tasks([{
-			title: MSG.TASK.CHANGELOG.START,
-			task: async () => {
-				await generateChangelog({
-					getPkgDir: () => getPkgDir(selectedPkg),
-					tagPrefix: tagPrefix?.(selectedPkg),
-					scope: isEmpty(nonNullable([scope])) ? void 0 : nonNullable([scope]),
-					releaseCount,
-					includeHidden,
-					transformTypes
-				});
-				await gitAddAll();
-				return success(MSG.TASK.CHANGELOG.END, dryRun);
-			},
-			enabled: isIncrement
-		}]).catch((err) => abortOnError(err, ctx));
-		const changeset = await getShortStatus();
-		if (changeset) msg("GIT", `Changes:${eol(2)}` + coloredStatus(changeset));
-		else msg("GIT", MSG.LOG.CHANGES_EMPTY);
-		if (onlyChangelog) taskEnd(MSG.LOG.ONLY_CHANGELOG);
+			this.setOptions({ bump }).setSkippedSteps(await getCliPromptOptions(options));
+			await runConfirmPrompts(ci, dryRun);
+		});
 	}
-	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([{
-			title: MSG.TASK.GIT.START,
-			task: async () => {
-				await commitAndTag(ctx, config);
-				const { git: { push } } = config;
-				return success(MSG.TASK.GIT.END(Boolean(push)), dryRun);
+	setLegacyOptions() {
+		return this.enqueue(async () => {
+			const logger = this.logger.createChild("legacy-options");
+			const { config, file } = await loadConfig(process.cwd());
+			const legacySteps = omit(config, [
+				"project",
+				"hosting",
+				"releaser"
+			]);
+			if (file) {
+				logger.verbose(`Legacy config file: ${file}`);
+				logger.verbose("Legacy config for steps:");
+				logger.verbose(legacySteps);
 			}
-		}]).catch((err) => abortOnError(err, ctx));
-		await runLifeCycleHook(hooks, "after:push", dryRun);
+			this.setOptions(legacySteps);
+		});
 	}
-	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 { npm: { publish } } = config;
-				const url = publish ? getPackageUrl(name, next) : void 0;
-				return success(MSG.TASK.NPM.END(url), dryRun);
+	check() {
+		return this.enqueue(async () => {
+			const { project, hosting } = this;
+			const logger = this.logger.createChild("check");
+			logger.info("Checking release environment...");
+			if (![
+				"commit",
+				"tag",
+				"push"
+			].every((k) => this.shouldSkip(k))) {
+				logger.verbose("Checking Git repository...");
+				const isRepo = await isGitRepo();
+				assert(isRepo, "Current directory is not a Git repository");
+				logger.verbose("Checking working tree...");
+				const isClean = await isWorkingTreeClean();
+				assert(isClean, "Git working tree is not clean");
+				logger.verbose("Checking remote repository...");
+				const hasRemote = await gitConfigGet("remote.origin.url");
+				assert(hasRemote, "Git remote \"origin\" is not configured");
 			}
-		}]).catch((err) => abortOnError(err, ctx, false));
-		await runLifeCycleHook(hooks, "after:publish", dryRun);
+			if (!this.shouldSkip("publish")) await project.publishCheck({ logger });
+			if (!this.shouldSkip("release")) await hosting?.releaseCheck({ logger });
+		});
 	}
-	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([{
-			title: MSG.TASK.GITHUB.START,
-			task: async () => {
-				await createRelease(ctx, config);
-				const { github: { owner, repo }, git: { currentTag } } = ctx;
-				const { github: { release } } = config;
-				const url = release ? getGithubReleaseUrl(owner, repo, currentTag) : void 0;
-				return success(MSG.TASK.GITHUB.END(url), dryRun);
-			}
-		}]).catch((err) => abortOnError(err, ctx, false));
-		await runLifeCycleHook(hooks, "after:release", dryRun);
+	start() {
+		return this.enqueue(async () => {
+			const { name, version } = package_default;
+			console.log(`${blue`i`} ${name} v${version}\n`);
+			intro("🚀 Starting release");
+		});
+	}
+	end() {
+		const { options: { dryRun = false } } = this;
+		outro(`🎉 ${dryRun ? "Dry run complete" : "Release complete"}`);
+		process.exit(0);
+	}
+	async runAction(options) {
+		await this.start().setLegacyOptions().setCliOptions(options).check().bump().commit().tag().push().publish().release().run();
 	}
-};
-//#endregion
-//#region src/monorepo/packages.ts
-const scanWorkspacePackages = (cwd) => {
-	const workspaceFile = join(cwd, "pnpm-workspace.yaml");
-	if (!existsSync(workspaceFile)) return [];
-	const { packages = [] } = parse(readFileSync(workspaceFile, "utf8"));
-	return globSync(packages.map((pattern) => normalizePath(join(pattern, "package.json"))), {
-		cwd,
-		absolute: false
-	});
-};
-const getPackages = (cwd) => {
-	return scanWorkspacePackages(cwd).reduce(((acc, file) => {
-		const workspace = dirname(dirname(file));
-		(acc[workspace] ??= []).push(basename(dirname(file)));
-		return acc;
-	}), {});
-};
-const monoConfig = (packages = [], workspace = "packages") => {
-	const subs = isEmpty(packages) ? "[]" : `[ ${[...packages].map((k) => `'${k}'`).join(", ")} ]`;
-	return dedent(`
-    import { defineConfig } from '@peiyanlu/release'
-    ${newline(1)}
-    export default defineConfig({
-      isMonorepo: true,
-      packages: ${subs},
-      getPkgDir: (pkg) => \`${workspace}/\${ pkg }\`,
-      toTag: (pkg, version) => \`\${ pkg }@\${ version }\`,
-      changelog: {
-        tagPrefix: (pkg) => \`\${ pkg }@\`,
-      },
-    })
-  `);
-};
-const generateMonoConfig = (cwd = process.cwd()) => {
-	const entries = Object.entries(getPackages(cwd));
-	const [workspace, packages] = entries.length === 1 ? entries[0] : [];
-	return monoConfig(packages, workspace);
 };
 //#endregion
 //#region src/cli.ts
-program.name("release").description(description).version(version, "-v, --version", "Print the tool version and exit.").usage("[release-type] [options]").argument("[release-type]", "Version bump type: patch | minor | major").enablePositionalOptions().option("-n, --dry-run", "Run in dry mode", false).option("-p, --package <pkg>", "Specify package name (Mono-repo CI only).", "").option("--otp <code>", "One-time password for npm publish.", "").option("--prepare", "Prepare a release.", false).option("--ci", "Enable CI mode.", false).option("--show-changelog", "Print changelog and exit.", false).option("--show-release", "Print release version and exit.", false).option("--only-changelog", "Only update the changelog.", false).option("-r, --release-count <count>", "Release count for release.", (val) => Number(val)).option("--include-hidden", "Include hidden commit types in the changelog.").option("-C, --no-require-clean-working-tree", "Allow releasing with uncommitted changes.").option("--skip-git", "Skip all Git-related checks and operations.").option("--skip-npm", "Skip all npm-related checks and operations.").option("--skip-github", "Skip all GitHub-related checks and operations.").option("-m, --is-monorepo", "Mono-repo project").helpOption("-h, --help", "Display help information.").action(async (releaseType, options) => {
-	const { prepare } = options;
-	const action = new Action();
-	prepare ? await action.handlePrepareRelease(releaseType, options) : await action.handleRelease(releaseType, options);
+program.name("release").description(package_default.description).version(package_default.version, "-v, --version", "Print the tool version and exit.").usage("[release-type] [options]").argument("[release-type]", `Release type. One of 'major', 'minor', 'patch', or 'prerelease'.`).enablePositionalOptions().option("-n, --dry-run", "Run in dry mode.").option("--ci", "Enable CI mode.").option("--skip-git", "Skip all Git-related checks and operations.").option("--skip-publish", "Skip the package publishing step.").option("--skip-release", "Skip the repository release step.").helpOption("-h, --help", "Display help information.").action(async (releaseType, options) => {
+	const { config: { project, hosting, releaser } } = await loadConfig(process.cwd());
+	const { dryRun } = options;
+	if (!project) throwError("Project not found");
+	if (!hosting) throwError("GitRepositoryHosting not found");
+	await new ReleaserCli({
+		...releaser,
+		project,
+		hosting,
+		dryRun
+	}).runAction({
+		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).option("-a, --add", "Automatically stage the config file.", false).action(async (options) => {
-	const { force = false, monorepo = false, add = false } = options;
+program.command("init").description("Create a release configuration file").option("--npm", "Use npm as the package manager", false).option("--pnpm", "Use pnpm as the package manager", false).option("--monorepo", "Configure a monorepo", false).option("--fixed", "Use fixed versioning for the monorepo", false).option("--github-workflow", "Create a GitHub Actions release workflow", false).option("--force", "Overwrite existing configuration or workflow files", false).option("--add", "Stage generated files with Git", false).action(async (options) => {
+	const { npm, pnpm, monorepo, fixed, githubWorkflow, force, add } = options;
 	const cwd = process.cwd();
-	const { type } = readJsonFileSync(join(cwd, "package.json"));
-	const isESM = type === "module";
-	const isTS = existsSync(join(cwd, "tsconfig.json"));
-	const infile = `release.config.${isESM ? "" : "m"}${isTS ? "ts" : "js"}`;
-	const configFile = join(cwd, infile);
-	if (existsSync(configFile) && !force) {
-		console.error(`${red`Error:`} ${yellow(infile)} already exists.\nUse ${green`--force`} to overwrite.`);
-		process.exit(1);
+	const tplDir = resolve(__dirname, "..", "template");
+	const { dependencies, devDependencies } = readJsonFileSync(join(cwd, "package.json"));
+	const isTS = existsSync(join(cwd, "tsconfig.json")) || Object.keys({
+		...dependencies,
+		...devDependencies
+	}).includes("typescript");
+	const configFile = join(cwd, `release.config.${isTS ? "ts" : "js"}`);
+	const workflowFile = join(cwd, ".github/workflows", "release.yml");
+	if (existsSync(configFile) && !force) throwError(`"${configFile}" already exists`);
+	if (githubWorkflow && existsSync(workflowFile) && !force) throwError(`"${workflowFile}" already exists`);
+	const template = readFileSync(join(tplDir, `release.config.hbs`), "utf-8");
+	const configContent = Handlebars.compile(template)({
+		monorepo,
+		fixed,
+		npm,
+		pnpm,
+		npmOrPnpm: npm || pnpm
+	});
+	writeFileSync(configFile, configContent.trimEnd() + newline(), "utf-8");
+	if (githubWorkflow) {
+		const workflowContent = readFileSync(join(tplDir, `release.text`), "utf-8");
+		await mkdir(".github/workflows", { recursive: true });
+		writeFileSync(workflowFile, workflowContent.trimEnd() + newline(), "utf-8");
 	}
-	const config = () => dedent(`
-      import { defineConfig } from '@peiyanlu/release'
-      ${newline(1)}
-      export default defineConfig({})
-    `);
-	const content = monorepo ? generateMonoConfig(process.cwd()) : config();
-	writeFileSync(configFile, content + newline(), "utf-8");
-	console.log(`Wrote to ${underline(dim(configFile))}`);
-	if (add) gitAddSync([infile]);
-	console.log(`\n${content}`);
+	if (add) gitAddSync(githubWorkflow ? [configFile, workflowFile] : [configFile]);
 });
-program.addHelpText("afterAll", "\nCASE: release -C -r0 --include-hidden --only-changelog\n\nThanks for using!");
 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`);
-	process.exit(1);
-});
 //#endregion
 export {};