@peiyanlu/release 0.0.3 → 0.0.5

package/dist/cli.mjs

@@ -1,21 +1,26 @@
 import path, { join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { eol, execAsync, isGitRepo, parseGitHubRepo, readJsonFile, runGit, runNpm } from "@peiyanlu/cli-utils";
-import { dim, gray, green, red, rgb, underline, yellow } from "ansis";
+import { bumpPackageVersion, coloredChangeset, eol, execAsync, getAllRemotes, getAuthenticatedUser, getCurrentBranch, getGithubReleaseUrl, getGithubUrl, getLatestTag, getLog, getPackageInfo, getPackageUrl, getPublishedVersion, getRemote, getStatus, gitAddAll, gitAddTracked, gitCommit, gitTagAnnotated, hasWriteAccess, isGitRepo, isWorkingDirClean, parseGitHubRepo, pingRegistry, publishPackage, pushBranch, pushTag, readJsonFile, resolveChangelogRange, runGit } from "@peiyanlu/cli-utils";
+import { dim, green, red, rgb, underline, yellow } from "ansis";
 import { program } from "commander";
+import { createReadStream, createWriteStream, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { cancel, confirm, group, intro, isCancel, log, outro, select, tasks, text } from "@clack/prompts";
-import { clean, coerce, gt, gte, inc, parse, prerelease, valid } from "semver";
+import { publint } from "publint";
+import { formatMessage } from "publint/utils";
+import { coerce, eq, inc, lt, parse, prerelease, valid } from "semver";
 import { castArray, isPlainObject, isUndefined } from "@peiyanlu/ts-utils";
-import { createReadStream, existsSync, statSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { inspect, styleText } from "node:util";
 import { Octokit } from "@octokit/rest";
 import { contentType } from "mime-types";
 import open from "open";
 import { glob } from "tinyglobby";
-import { readFile, writeFile } from "node:fs/promises";
+import { inspect } from "node:util";
+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 = /* @__PURE__ */ getDirname();
@@ -26,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;
@@ -41,11 +44,16 @@ 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 isFunction = (v) => typeof v === "function";
 const mergeConfig = (defaults, overrides) => {
@@ -69,8 +77,8 @@ const mergeConfig = (defaults, overrides) => {
 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()} ${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",
@@ -80,11 +88,11 @@ 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: {
@@ -110,6 +118,7 @@ const MSG = {
 		}
 	},
 	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})`)}?`,
@@ -130,14 +139,20 @@ 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/github/release.ts
-const getGithubUrl = (owner, repo) => {
-	return `https://github.com/${owner}/${repo}`;
-};
 const truncateBody = (body) => {
 	if (body && body.length >= 124e3) return body.substring(0, 124e3) + "...";
 	return body;
@@ -164,28 +179,28 @@ const uploadAssets = async (ctx, config) => {
 	}));
 };
 const createWebRelease = async (ctx, config) => {
-	const { pkg: { next, toPreRelease }, github: { owner, repo, changelog, releaseName } } = ctx;
+	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", next);
-	url.searchParams.set("title", releaseName ?? `Release ${next}`);
+	url.searchParams.set("tag", currentTag);
+	url.searchParams.set("title", releaseName);
 	url.searchParams.set("body", truncateBody(changelog));
 	url.searchParams.set("prelease", String(toPreRelease || prerelease$1));
 	const isWindows = process.platform === "win32";
 	await open(url.toString(), { wait: isWindows });
 };
 const createCiRelease = async (ctx, config) => {
-	const { pkg: { next, toPreRelease }, github: { owner, repo, token, changelog, releaseName } } = ctx;
+	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: next,
+			tag_name: currentTag,
 			target_commitish: void 0,
-			name: releaseName ?? `Release ${next}`,
+			name: releaseName,
 			body: autoGenerate ? "" : truncateBody(changelog),
 			draft: draft ?? false,
 			prerelease: (toPreRelease || prerelease$1) ?? false,
@@ -202,7 +217,7 @@ const createCiRelease = async (ctx, config) => {
 			discussionUrl: discussion_url
 		});
 	} catch (e) {
-		if (e?.status === 422) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(next));
+		if (e?.status === 422) throw new Error(MSG.ERROR.GITHUB_TAG_EXIT(currentTag));
 		throw e;
 	}
 };
@@ -252,133 +267,9 @@ const createRelease = async (ctx, config) => {
 		await uploadAssets(ctx, config);
 	}
 };
-const getGithubReleaseUrl = (ctx) => {
-	const { github: { owner, repo }, git: { currentTag } } = ctx;
-	return `${getGithubUrl(owner, repo)}/releases/tag/${normalizeTag(currentTag)}`;
-};
 
 //#endregion
 //#region src/git/commit.ts
-const getBranchName = () => {
-	return runGit([
-		"rev-parse",
-		"--abbrev-ref",
-		"HEAD"
-	]);
-};
-const getRemoteForBranch = (branch) => {
-	return runGit([
-		"config",
-		"--get",
-		`branch.${branch}.remote`
-	]);
-};
-const getStatus = () => {
-	return runGit([
-		"status",
-		"--short",
-		"--untracked-files=no"
-	], { trim: false });
-};
-const coloredChangeset = (log$1) => {
-	const colorStatusChar = (ch) => {
-		switch (ch) {
-			case "M": return `\x1b[33m${ch}\x1b[0m`;
-			case "A": return `\x1b[32m${ch}\x1b[0m`;
-			case "D": return `\x1b[31m${ch}\x1b[0m`;
-			default: return ch;
-		}
-	};
-	const colorStatus = (status) => status.split("").map(colorStatusChar).join("");
-	return log$1.split("\n").filter(Boolean).map((line) => {
-		const status = line.slice(0, 2);
-		const file = line.slice(3);
-		return `${colorStatus(status)} ${styleText(["dim"], file)}`;
-	}).join("\n");
-};
-const getRemote = async () => {
-	const branch = await getBranchName();
-	const remoteName = branch && await getRemoteForBranch(branch) || "origin";
-	return {
-		remoteName,
-		remoteUrl: await runGit([
-			"remote",
-			"get-url",
-			remoteName
-		]).catch((_) => runGit([
-			"config",
-			"--get",
-			`remote.${remoteName}.url`
-		]))
-	};
-};
-const getLatestTag = async (match = "*", exclude = "*-beta.*") => {
-	return runGit([
-		"describe",
-		"--tags",
-		"--abbrev=0",
-		`--match=${match}`,
-		`--exclude=${exclude}`
-	]);
-};
-const getPreviousTag = async (current) => {
-	return runGit([
-		"describe",
-		"--tags",
-		"--abbrev=0",
-		`${await runGit([
-			"rev-list",
-			"--tags",
-			current || "--skip=1",
-			"--max-count=1"
-		])}^`
-	]);
-};
-const resolveChangelogRange = async (isIncrement) => {
-	const latestTag = await getLatestTag();
-	const previousTag = await getPreviousTag(latestTag);
-	if (!latestTag) return {
-		from: "",
-		to: "HEAD"
-	};
-	if (!isIncrement && previousTag) return {
-		from: previousTag,
-		to: `${latestTag}^1`
-	};
-	return {
-		from: latestTag,
-		to: "HEAD"
-	};
-};
-const getLog = async (print, isIncrement) => {
-	const cmd = ["log", `--pretty=format:${print ? "* %s (%h)" : "%s %h %H"}`];
-	const { from, to } = await resolveChangelogRange(isIncrement);
-	if (from) cmd.push(`${from}...${to}`);
-	return runGit(cmd, { trim: false });
-};
-const isWorkingDirClean = async () => {
-	return (await runGit(["status", "-s"]))?.length === 0;
-};
-const hasUpstreamBranch = async () => {
-	const branch = await runGit([
-		"for-each-ref",
-		"--format=%(upstream:short)",
-		await runGit(["symbolic-ref", "HEAD"])
-	]);
-	return Boolean(branch);
-};
-const getUpstreamArgs = async (remoteName) => {
-	const hasUpstream = await hasUpstreamBranch();
-	const branch = await getBranchName();
-	if (!hasUpstream) return [
-		"--set-upstream",
-		remoteName || "origin",
-		branch
-	];
-	if (remoteName) return [remoteName];
-	return [];
-};
-const normalizeTag = (tag) => clean(tag) ?? tag;
 const gitCheck = async (ctx, config) => {
 	const { pkg: { name } } = ctx;
 	const { git: { requireRepository, requireRemote, requireWorkDirClean } } = config;
@@ -405,42 +296,25 @@ const commitAndTag = async (ctx, config) => {
 	const { git: { commit, tag, push, addUntrackedFiles, commitArgs, tagArgs, pushArgs } } = config;
 	if (!commit) return;
 	const args = dryRun ? ["--dry-run"] : [];
-	await runGit([
-		"add",
-		".",
-		addUntrackedFiles ? "--all" : "--update",
-		...args
-	]);
-	await runGit([
-		"commit",
-		"--message",
-		commitMessage,
-		...commitArgs,
-		...args
-	]);
+	addUntrackedFiles ? await gitAddAll() : await gitAddTracked(args);
+	await gitCommit(commitMessage, [...commitArgs, ...args]);
 	if (!dryRun) Object.assign(ctx.git, { isCommitted: true });
 	if (tag) {
-		await runGit([
-			"tag",
-			"--annotate",
-			"--message",
-			tagMessage,
-			currentTag,
-			...tagArgs,
-			...args
-		]);
+		await gitTagAnnotated(currentTag, tagMessage, [...tagArgs, ...args]);
 		if (!dryRun) Object.assign(ctx.git, { isTagged: true });
 	}
-	if (push) await runGit([
-		"push",
-		...await getUpstreamArgs(remoteName),
-		"--follow-tags",
-		...pushArgs,
-		...args
-	]);
+	if (push) {
+		const remotes = await getAllRemotes();
+		for (const remoteName$1 of remotes) {
+			await pushTag(remoteName$1, currentTag, args);
+			await pushBranch(remoteName$1, await getCurrentBranch(), [...pushArgs, ...args]);
+		}
+		if (!dryRun) Object.assign(ctx.git, { isPushed: true });
+	}
 };
-const gitRollback$1 = (ctx) => {
-	const { git: { currentTag, isCommitted, isTagged } } = ctx;
+const gitRollback = (ctx) => {
+	const { git: { currentTag, isCommitted, isTagged, isPushed } } = ctx;
+	if (isPushed) return;
 	spawnSync("git", ["restore", "."]);
 	if (isTagged) spawnSync("git", [
 		"tag",
@@ -454,16 +328,41 @@ const gitRollback$1 = (ctx) => {
 	]);
 };
 
+//#endregion
+//#region src/prompts.ts
+const abortTask = (msg$1) => {
+	cancel(`${red("✕")} ${msg$1}`);
+	process.exit(0);
+};
+const abortSinglePrompt = (value) => {
+	if (isCancel(value)) abortTask(MSG.ABORT.CANCEL);
+};
+const abortGroupPrompt = (ctx) => {
+	ctx && gitRollback(ctx);
+	abortTask(MSG.ABORT.CANCEL);
+};
+const abortOnError = (err, ctx) => {
+	ctx && gitRollback(ctx);
+	const msg$1 = err.message.replace(/^\[(github|npm|git)]/, (a) => red(a));
+	log.message(`\n${msg$1}\n`);
+	process.exit(1);
+};
+const taskEnd = (msg$1) => {
+	outro(msg$1);
+	process.exit(0);
+};
+
 //#endregion
 //#region src/utils.ts
 const info = (msg$1) => {
-	console.log(`${rgb(33, 91, 184)(`i`)} ${gray(msg$1)}`);
+	console.log(`${rgb(33, 91, 184)(`i`)} ${msg$1}`);
 };
 const msg = (prefix, msg$1) => {
-	log.message(gray`${rgb(33, 91, 184)(`[${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),
@@ -476,7 +375,7 @@ const success = (msg$1, dryRun) => {
 const runLifeCycleHook = async (hooks, key, dryRun) => {
 	const handler = hooks[key];
 	if (typeof handler === "function") {
-		if (!dryRun) await handler();
+		if (!dryRun) await handler(log);
 		log.success(success(`${dim`run`} ${inspect(handler)}`, dryRun));
 		return;
 	}
@@ -485,33 +384,19 @@ const runLifeCycleHook = async (hooks, key, dryRun) => {
 		log.success(success(hook.replace(/^echo$/, dim("echo")), dryRun));
 	}));
 };
-const gitRollback = (ctx) => {
-	const { git: { currentTag, isCommitted, isTagged } } = ctx;
-	spawnSync("git", ["restore", "."]);
-	if (isTagged) spawnSync("git", [
-		"tag",
-		"--delete",
-		currentTag
-	]);
-	spawnSync("git", [
-		"reset",
-		"--hard",
-		isCommitted ? "HEAD~1" : "HEAD"
-	]);
-};
 const diff = (from, to, separator = ".") => {
 	const a = from.split(separator);
 	return to.split(separator).map((v, i) => v === a[i] ? dim(v) : green(v)).join(separator);
 };
 const formatTemplate = async (ctx, config) => {
-	const { pkg: { next } } = ctx;
-	const { git: { commitMessage: cm, tagMessage: tm, tagName }, github: { releaseName: rm } } = config;
-	const f = (s, v) => s.replace("${version}", v);
+	const { 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 = f(tagName || (latestTag.match(/^v/) ? "v${version}" : "${version}"), next);
-	const commitMessage = f(cm, next);
-	const tagMessage = f(tm, next);
-	const releaseName = f(rm, next);
+	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,
@@ -521,30 +406,6 @@ const formatTemplate = async (ctx, config) => {
 	Object.assign(ctx.github, { releaseName });
 };
 
-//#endregion
-//#region src/prompts.ts
-const abortTask = (msg$1) => {
-	cancel(`${red("✕")} ${msg$1}`);
-	process.exit(0);
-};
-const abortSinglePrompt = (value) => {
-	if (isCancel(value)) abortTask("Operation cancelled.");
-};
-const abortGroupPrompt = (ctx) => {
-	ctx && gitRollback(ctx);
-	abortTask("Operation cancelled.");
-};
-const abortOnError = (err, ctx) => {
-	ctx && gitRollback(ctx);
-	const msg$1 = err.message.replace(/^\[(github|npm|git)]/, (a) => red(a));
-	log.message(`\n${msg$1}\n`);
-	process.exit(1);
-};
-const taskEnd = (msg$1) => {
-	outro(msg$1);
-	process.exit(0);
-};
-
 //#endregion
 //#region src/version/bump.ts
 const isPreRelease = (version) => {
@@ -679,7 +540,7 @@ const runVersionPrompts = async (ctx, config) => {
 	};
 	const type = await selectVersion();
 	const next = type === "custom" ? await inputVersion() : type === "ignore" ? current : type;
-	ctx.isIncrement = gte(next, current);
+	ctx.isIncrement = !eq(next, current);
 	return { next };
 };
 
@@ -698,6 +559,7 @@ const createDefaultContext = () => {
 		increment: "",
 		isIncrement: false,
 		configFileExists: false,
+		selectedPkg: "",
 		pkg: {
 			current: "",
 			next: "",
@@ -725,9 +587,9 @@ const createDefaultContext = () => {
 			currentTag: "",
 			isCommitted: false,
 			isTagged: false,
+			isPushed: false,
 			commitMessage: "",
-			tagMessage: "",
-			tagName: ""
+			tagMessage: ""
 		},
 		github: {
 			username: "",
@@ -757,14 +619,22 @@ const createDefaultConfig = (isCI) => {
 			"before:release": "",
 			"after:release": ""
 		},
+		isMonorepo: false,
+		packages: [],
+		getPkgDir(pkg$1) {
+			return ".";
+		},
+		toTag(pkg$1, version) {
+			return `v${version}`;
+		},
+		tagPrefix: void 0,
 		git: {
 			commit: isCI,
 			tag: isCI,
 			push: isCI,
-			commitMessage: "chore(release): ${version}",
+			commitMessage: "chore(release): ${tag}",
 			commitArgs: [],
-			tagMessage: "Release ${version}",
-			tagName: "${version}",
+			tagMessage: "${tag}",
 			tagArgs: [],
 			pushArgs: [],
 			addUntrackedFiles: false,
@@ -780,17 +650,13 @@ const createDefaultConfig = (isCI) => {
 		},
 		github: {
 			release: isCI,
-			releaseName: "Release ${version}",
+			releaseName: "${tag}",
 			autoGenerate: false,
 			prerelease: false,
 			draft: false,
 			tokenRef: "GITHUB_TOKEN",
 			assets: [],
 			skipChecks: false
-		},
-		changelog: {
-			infile: "CHANGELOG.md",
-			types: []
 		}
 	};
 };
@@ -803,15 +669,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",
@@ -823,26 +699,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: "👷‍ 构建系统",
@@ -882,94 +753,80 @@ const defaultTypes = [
 		type: "hotfix",
 		section: "🔥 热修复",
 		description: "紧急修复"
-	},
-	{
-		type: "break",
-		section: "💥 破坏性变更",
-		description: "破坏性变更"
 	}
 ];
-const mergeTypes = (types) => {
-	types.forEach((item) => {
-		const index = defaultTypes.findIndex((it) => it.type === item.type);
-		if (index >= 0) defaultTypes.splice(index, 1, { ...item });
-		else defaultTypes.push({ ...item });
-	});
-};
-const findType = (type) => {
-	return defaultTypes.find((item) => item.type === type)?.section ?? type;
-};
 
 //#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
-		]);
+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 sections;
-};
-const renderChangelog = async (ctx, sections) => {
-	const { github: { owner, repo }, git: { latestTag, currentTag } } = ctx;
-	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-	const github = getGithubUrl(owner, repo);
-	return [
-		latestTag ? `## [${currentTag}](${github}/compare/${latestTag}...${currentTag}) (${date})` : `## ${currentTag} (${date})`,
-		Object.entries(sections).map((entry) => {
-			const [type, items] = entry;
-			return [`### ${findType(type)}`, items.map((item) => {
-				const [desc, hash, fullHash] = item;
-				return `* **${type}** ${desc} [${hash}](${github}/commit/${fullHash})`;
-			}).join(eol(1))].join(eol(2));
-		}).join(eol(2)),
-		latestTag ? `**Full Changelog**: ${github}/compare/${latestTag}...${currentTag}` : ""
-	].join(eol(3));
-};
-const generateChangelog = async (ctx) => {
-	const { isIncrement } = ctx;
-	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 (file, newContent) => {
-	const infile = file || "CHANGELOG.md";
-	const target = join(process.cwd(), infile);
-	const SHORT_TITLE = "# Changelog";
-	const exist = (existsSync(target) ? await readFile(target, "utf-8") : "").replace(/\r\n/g, "\n");
-	await writeFile(target, [
-		SHORT_TITLE,
-		newContent,
-		exist.startsWith(SHORT_TITLE) ? exist.slice(11) : exist
-	].map((k) => k.trim()).join(eol(4)) + eol());
-	await runGit(["add", infile]);
-};
-const writeChangelog = async (ctx, config) => {
-	const { changelog: { infile, types } } = config;
-	mergeTypes(types);
-	await updateChangelog(infile, await generateChangelog(ctx));
-};
 
 //#endregion
 //#region src/git/prompts.ts
@@ -1063,108 +920,45 @@ const runNpmOptPrompts = async (ctx, config) => {
 
 //#endregion
 //#region src/npm/publish.ts
-const getRegistry = (publishConfig = {}) => {
-	return (publishConfig.registry ? [publishConfig.registry] : Object.keys(publishConfig).filter((key) => key.endsWith("registry")).map((key) => publishConfig[key]))[0];
-};
-const isRegistryUp = async (registry) => {
-	return void 0 !== await runNpm(["ping", ...registry ? ["--registry", registry] : []]);
-};
-const isAuthenticated = (registry) => {
-	return runNpm(["whoami", ...registry ? ["--registry", registry] : []]);
-};
-const getLatestRegistryVersion = (name, tag, registry) => {
-	const registryArg = registry ? ["--registry", registry] : [];
-	return runNpm([
-		"show",
-		`${name}@${tag}`,
-		"version",
-		...registryArg
-	]);
-};
-const bump = (version, allowSameVersion, args = []) => {
-	allowSameVersion && args.push(`--allow-same-version`);
-	return runNpm([
-		"version",
-		version,
-		"--no-git-tag-version",
-		"--workspaces=false",
-		...args
-	]);
-};
-const resolveTag = async (version) => {
+const resolvePublishTag = async (pkgName, version) => {
 	const { toPreRelease, preId } = parseVersion(version);
-	if (!toPreRelease) return "latest";
-	else return preId || "next";
-};
-const isCollaborator = async (ctx) => {
-	const { pkg: { name, publishConfig }, npm: { username } } = ctx;
-	const registry = getRegistry(publishConfig);
-	const registryArg = registry ? ["--registry", registry] : [];
-	let npmVersion = await runNpm(["--version"]);
-	let accessCommand;
-	if (gt(npmVersion, "9.0.0")) accessCommand = [
-		"access",
-		"list",
-		"collaborators",
-		"--json"
-	];
-	else accessCommand = ["access", "ls-collaborators"];
-	const res = await runNpm([
-		...accessCommand,
-		name,
-		...registryArg
-	]);
-	if (res) {
-		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 (!toPreRelease) {
+		const active = await getPublishedVersion(pkgName);
+		return active && lt(version, active) ? "previous" : "latest";
+	} else return preId || "prerelease";
 };
+const isOtpError = (err) => err instanceof Error && /one-time password|otp/i.test(err.message);
 const npmCheck = async (ctx, config) => {
-	const { pkg: { name, current, publishConfig }, npm: { username } } = ctx;
+	const { pkg: { name, current, publishConfig: { registry } } } = ctx;
 	const { npm: { skipChecks } } = config;
-	const registry = getRegistry(publishConfig);
-	const tag = await resolveTag(current);
+	const tag = await resolvePublishTag(name, current);
 	Object.assign(ctx.npm, { tag });
 	if (skipChecks) return "";
-	if (!await isRegistryUp()) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
-	const getUser = async () => {
-		const username$1 = await isAuthenticated(registry);
-		if (!username$1) return false;
-		Object.assign(ctx.npm, { username: username$1 });
-		return true;
-	};
-	if (!await getUser()) throw new Error(MSG.ERROR.NPM_AUTH);
-	const latestPublish = await getLatestRegistryVersion(name, tag, registry);
-	if (latestPublish) {
-		if (!await isCollaborator(ctx)) throw new Error(MSG.ERROR.NPM_USER(username, name));
+	const [pinged, username] = await Promise.all([pingRegistry(registry), getAuthenticatedUser(registry)]);
+	if (!pinged) throw new Error(MSG.ERROR.NPM_REGISTRY(registry));
+	if (!username) throw new Error(MSG.ERROR.NPM_AUTH);
+	Object.assign(ctx.npm, { username });
+	const latest = await getPublishedVersion(`${name}@${tag}`);
+	if (latest) {
+		if (!await hasWriteAccess(name, username, registry)) throw new Error(MSG.ERROR.NPM_USER(username, name));
 	}
-	return underline(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, tag }, pkg: { publishConfig } } = ctx;
-	const { npm: { publish, publishPath, pushArgs } } = config;
-	const registry = getRegistry(publishConfig);
+	const { dryRun, selectedPkg, npm: { otp, tag } } = ctx;
+	const { npm: { publish, pushArgs }, getPkgDir } = config;
 	if (!publish) return;
 	const otpArgs = otp ? ["--otp", otp] : [];
 	const dryRunArg = dryRun ? ["--dry-run"] : [];
-	const registryArg = registry ? ["--registry", registry] : [];
-	return runNpm([
-		"publish",
-		publishPath,
-		"--tag",
+	return publishPackage({
 		tag,
-		"--workspaces=false",
-		...otpArgs,
-		...pushArgs,
-		...registryArg,
-		...dryRunArg
-	]);
+		args: [
+			...otpArgs,
+			...pushArgs,
+			...dryRunArg
+		],
+		cwd: getPkgDir(selectedPkg)
+	});
 };
 
 //#endregion
@@ -1172,17 +966,38 @@ const publishNpm = async (ctx, config) => {
 var Action = class {
 	async handle(cmdArgs, options) {
 		const { version: cVersion, name: cName } = readJsonFile(join(__dirname, "../package.json"));
-		info(`${cName} ${dim(`v${cVersion}`)} `);
-		const { otp, ...others } = options;
+		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,
@@ -1208,15 +1023,18 @@ var Action = class {
 			},
 			noNpm: pkgPrivate
 		});
-		console.log();
-		intro(MSG.INTRO(pkgName, dryRun));
+		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);
+		if (dryRun) gitRollback(ctx);
 		taskEnd(MSG.OUTRO(dryRun));
 	}
 	async checkTask(ctx, config) {
@@ -1239,8 +1057,8 @@ var Action = class {
 		}]).catch(abortOnError);
 	}
 	async bumpTask(ctx, config) {
-		const { pkg: { current }, dryRun, isCI, showRelease, showChangelog } = ctx;
-		const { hooks } = config;
+		const { pkg: { current }, dryRun, isCI, showRelease, showChangelog, selectedPkg } = ctx;
+		const { isMonorepo, hooks, getPkgDir, tagPrefix } = config;
 		const need = (ctx$1) => {
 			const { pkg: { next: next$1 }, isIncrement: isIncrement$1 } = ctx$1;
 			return !next$1 && isIncrement$1;
@@ -1255,32 +1073,39 @@ var Action = class {
 		await tasks([{
 			title: MSG.TASK.VERSION.START,
 			task: async () => {
-				await bump(next, isIncrement);
+				await bumpPackageVersion(next, [], getPkgDir(selectedPkg));
 				await formatTemplate(ctx, config);
-				const to = `(${current}...${diff(current, next)})`;
-				return success(MSG.TASK.VERSION.END(to), dryRun);
+				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 logStr = (await getLog(true, isIncrement))?.split("\n").filter((line) => /^(\*\s+)?(\w+):\s(.+)\s\((\w{7})\)$/.test(line)).join("\n");
+		const { from, to } = await resolveChangelogRange(isIncrement, isMonorepo ? `${tagPrefix?.(selectedPkg)}*` : "*");
+		const logStr = await getLog(from, to, getPkgDir(selectedPkg));
 		if (logStr) {
-			msg("GIT", `Changelog:${eol(2)}` + dim(logStr));
+			msg("GIT", `Changelog(${from}...${to}):${eol(2)}` + logStr);
 			if (showChangelog) taskEnd(MSG.LOG.SHOW_CHANGELOG);
 		} else msg("GIT", MSG.LOG.CHANGELOG_EMPTY);
-		const changeset = await getStatus();
-		if (changeset) msg("GIT", `Changes:${eol(2)}` + coloredChangeset(changeset));
-		else msg("GIT", MSG.LOG.CHANGES_EMPTY);
 	}
 	async changelogTask(ctx, config) {
-		const { isIncrement, dryRun } = ctx;
+		const { isIncrement, dryRun, selectedPkg } = ctx;
+		const { getPkgDir, tagPrefix } = config;
 		await tasks([{
 			title: MSG.TASK.CHANGELOG.START,
 			task: async () => {
-				await writeChangelog(ctx, config);
+				const changelog = await generateChangelog({
+					getPkgDir: () => getPkgDir(selectedPkg),
+					tagPrefix: tagPrefix?.(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;
@@ -1298,7 +1123,7 @@ var Action = class {
 		await runLifeCycleHook(hooks, "after:push", dryRun);
 	}
 	async npmTask(ctx, config) {
-		const { noNpm, dryRun, isCI } = ctx;
+		const { noNpm, dryRun, isCI, pkg: { name, next } } = ctx;
 		const { hooks } = config;
 		if (noNpm) return;
 		await runNpmPublishPrompts(ctx, config);
@@ -1312,7 +1137,7 @@ var Action = class {
 						await publishNpm(ctx, config);
 					} else throw err;
 				});
-				const url = getPackageUrl(ctx);
+				const url = getPackageUrl(name, next);
 				return success(MSG.TASK.NPM.END(url), dryRun);
 			}
 		}]).catch((err) => abortOnError(err, ctx));
@@ -1327,8 +1152,9 @@ var Action = class {
 		await tasks([{
 			title: MSG.TASK.GITHUB.START,
 			task: async () => {
+				const { github: { owner, repo }, git: { currentTag } } = ctx;
 				await createRelease(ctx, config);
-				const url = getGithubReleaseUrl(ctx);
+				const url = getGithubReleaseUrl(owner, repo, currentTag);
 				return success(MSG.TASK.GITHUB.END(url), dryRun);
 			}
 		}]).catch((err) => abortOnError(err, ctx));
@@ -1339,9 +1165,33 @@ var Action = class {
 //#endregion
 //#region src/cli.ts
 const pkg = readJsonFile(join(__dirname, "..", "package.json"));
-program.name(pkg.name).description(pkg.description).version(pkg.version, "-v, --version", "Output the current version.").usage("[ARGUMENT] [OPTION]...").argument("[argument]", "patch|minor|major").option("-n, --dry-run", "Report actions that would be performed without writing out results.", false).option("--ci", "CI mode", false).option("--otp", "npm publish otp", "").option("--show-changelog", "Skip npm publish", false).option("--show-release", "Skip github release", false).action(async (argName, options) => {
-	await new Action().handle(argName, options);
-}).helpOption("-h, --help", "Output usage information.").parse(process.argv);
+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 }\`,
+  tagPrefix: (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`);