@mznjs/mbump 2.1.0 → 2.2.0

package/dist/{VersionManager-CwsuNWyP.js → path-Dxq6zEl-.js}

@@ -1,12 +1,13 @@
-import { __export } from "./chunk-Cl8Af3a2.js";
+import { __export, __require } from "./chunk-DAa1jVm7.js";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { consola } from "consola";
 import ora from "ora";
 import { execSync } from "node:child_process";
-import process from "node:process";
+import * as toml from "@iarna/toml";
 import semver from "semver";
+import process from "node:process";
 
 //#region src/utils/logger.ts
 const logger = consola.create({ formatOptions: { date: false } });
@@ -228,8 +229,8 @@ const parsers = {
 	} },
 	js: { parse(_, configPath) {
 		try {
-			const require = createRequire(import.meta.url);
-			const jsModule = require(configPath);
+			const require$1 = createRequire(import.meta.url);
+			const jsModule = require$1(configPath);
 			return jsModule.default || jsModule;
 		} catch {
 			return null;
@@ -272,9 +273,9 @@ async function loadConfigAsyncImpl(rootDir) {
 			let config;
 			try {
 				if (configPath.endsWith(".ts")) {
-					const require = createRequire(import.meta.url);
-					require("tsx");
-					const tsModule = require(absPath);
+					const require$1 = createRequire(import.meta.url);
+					require$1("tsx");
+					const tsModule = require$1(absPath);
 					config = tsModule.default || tsModule;
 				} else if (configPath.endsWith(".mjs")) {
 					const jsModule = await import(`file://${absPath}`);
@@ -283,13 +284,13 @@ async function loadConfigAsyncImpl(rootDir) {
 					const jsModule = await import(`file://${absPath}`);
 					config = jsModule.default || jsModule;
 				} catch {
-					const require = createRequire(import.meta.url);
-					const cjsModule = require(absPath);
+					const require$1 = createRequire(import.meta.url);
+					const cjsModule = require$1(absPath);
 					config = cjsModule.default || cjsModule;
 				}
 				else if (configPath.endsWith(".cjs")) {
-					const require = createRequire(import.meta.url);
-					const cjsModule = require(absPath);
+					const require$1 = createRequire(import.meta.url);
+					const cjsModule = require$1(absPath);
 					config = cjsModule.default || cjsModule;
 				}
 				if (typeof config === "function") config = config();
@@ -340,8 +341,8 @@ function loadConfigSyncImpl(rootDir) {
 	for (const configPath of configPaths) try {
 		const ext = getFileExtension(configPath);
 		if (ext === "js") try {
-			const require = createRequire(import.meta.url);
-			const jsModule = require(configPath);
+			const require$1 = createRequire(import.meta.url);
+			const jsModule = require$1(configPath);
 			let config = jsModule.default || jsModule;
 			if (typeof config === "function") config = config();
 			if (config && typeof config === "object") return {
@@ -577,7 +578,7 @@ var ChangelogManager = class {
 		const today = new Date().toISOString().split("T")[0];
 		const versionTitle = packageName ? `${packageName}@${newVersion}` : newVersion;
 		const categorized = {};
-		for (const { message, files } of commits) {
+		for (const { hash, message, files } of commits) {
 			const typeConfig = this.getTypeConfig(message);
 			const typeKey = typeConfig.title;
 			if (!categorized[typeKey]) categorized[typeKey] = {
@@ -587,7 +588,7 @@ var ChangelogManager = class {
 			const fileNames = this.formatFileNames(files);
 			const fileTag = fileNames.length > 0 ? ` (${fileNames.join(", ")})` : "";
 			categorized[typeKey].items.push({
-				message: message + fileTag,
+				message: `${hash} ${message}${fileTag}`,
 				files
 			});
 		}
@@ -692,7 +693,7 @@ var GitManager = class {
 		try {
 			const lastTag = this.getLastTag();
 			const range = lastTag ? `${lastTag}..HEAD` : "--max-count=50";
-			const output = execSync(`git log ${range} --format="COMMIT_START%n%s" --name-only`, {
+			const output = execSync(`git log ${range} --format="COMMIT_START%n%H%n%s" --name-only`, {
 				cwd: this.rootDir,
 				encoding: "utf8",
 				stdio: "pipe"
@@ -702,11 +703,12 @@ var GitManager = class {
 			for (const block of blocks) {
 				const lines = block.trim().split("\n");
 				if (lines.length === 0) continue;
-				const messageLines = lines.filter((line) => line.trim());
-				if (messageLines.length === 0) continue;
-				const message = messageLines[0].trim();
-				const files = lines.slice(1).map((f) => f.trim()).filter((f) => f && !f.startsWith("COMMIT_START"));
+				const hash = lines[0]?.trim() || "";
+				const message = lines[1]?.trim() || "";
+				if (!hash || !message) continue;
+				const files = lines.slice(2).map((f) => f.trim()).filter((f) => f && !f.startsWith("COMMIT_START"));
 				commits.push({
+					hash,
 					message,
 					files
 				});
@@ -716,9 +718,10 @@ var GitManager = class {
 			return [];
 		}
 	}
-	checkVersionExists(version, tagPrefix = "v") {
+	checkVersionExists(version, tagPrefix = "v", packageName) {
 		try {
-			execSync(`git rev-parse --verify ${tagPrefix}${version}`, {
+			const tag = packageName ? `${packageName}@${version}` : `${tagPrefix}${version}`;
+			execSync(`git rev-parse --verify ${tag}`, {
 				cwd: this.rootDir,
 				stdio: "pipe"
 			});
@@ -798,6 +801,182 @@ var GitManager = class {
 	}
 };
 
+//#endregion
+//#region src/core/RustManager.ts
+var RustManager = class {
+	cargoTomlPath;
+	gitManager;
+	changelogManager;
+	rootDir;
+	constructor(rootDir) {
+		this.rootDir = rootDir;
+		this.cargoTomlPath = join(rootDir, "Cargo.toml");
+		this.gitManager = new GitManager(rootDir);
+		this.changelogManager = new ChangelogManager(rootDir);
+	}
+	exists() {
+		return existsSync(this.cargoTomlPath);
+	}
+	getCurrentVersion() {
+		try {
+			const content = readFileSync(this.cargoTomlPath, "utf8");
+			const parsed = toml.parse(content);
+			if (parsed.package && typeof parsed.package.version === "string") return parsed.package.version;
+			return null;
+		} catch {
+			return null;
+		}
+	}
+	getPackageName() {
+		try {
+			const content = readFileSync(this.cargoTomlPath, "utf8");
+			const parsed = toml.parse(content);
+			if (parsed.package && typeof parsed.package.name === "string") return parsed.package.name;
+			return null;
+		} catch {
+			return null;
+		}
+	}
+	updateVersion(releaseType, options = {}) {
+		const { dryRun: dryRun$1 = false, verbose = false, customVersion = null, autoCommit = true, push = true, tag = true, tagPrefix = "v", changelog = true, allowUncommitted = false } = options;
+		if (!this.exists()) throw new Error(`Cargo.toml 文件不存在: ${this.cargoTomlPath}`);
+		const oldVersion = this.getCurrentVersion();
+		if (!oldVersion) throw new Error(`Cargo.toml 文件中未找到 [package] 部分的 version 字段`);
+		const packageName = this.getPackageName() || "rust";
+		let newVersion = null;
+		if (customVersion) {
+			if (!semver.valid(customVersion)) throw new Error(`无效的自定义版本号: ${customVersion}`);
+			newVersion = customVersion;
+		} else {
+			let semverType = releaseType;
+			let prerelease;
+			if (releaseType === "pre-patch") {
+				semverType = "prepatch";
+				prerelease = "beta";
+			} else if (releaseType === "pre-minor") {
+				semverType = "preminor";
+				prerelease = "beta";
+			} else if (releaseType === "pre-major") {
+				semverType = "premajor";
+				prerelease = "beta";
+			} else if (releaseType === "prerelease") {
+				semverType = "prerelease";
+				prerelease = "beta";
+			}
+			if (prerelease) newVersion = semver.inc(oldVersion, semverType, prerelease);
+			else newVersion = semver.inc(oldVersion, semverType);
+			if (!newVersion) throw new Error(`无法计算新版本，当前版本 "${oldVersion}"，版本类型 "${releaseType}"`);
+		}
+		if (!semver.valid(newVersion)) throw new Error(`计算出的新版本 "${newVersion}" 不是有效的 semver 版本号`);
+		if (verbose) {
+			logger_default.info(`读取 Cargo.toml: ${this.cargoTomlPath}`);
+			logger_default.info(`当前版本: ${oldVersion}`);
+			logger_default.info(`新版本: ${newVersion}`);
+		}
+		if (!dryRun$1 && autoCommit && !allowUncommitted && this.gitManager.hasUncommittedChanges()) throw new Error("存在未提交的更改，请先提交或使用 --allow-uncommitted 选项");
+		if (dryRun$1) {
+			const tagName = `${packageName}@${newVersion}`;
+			logger_default.info(`\n🔍 Dry-run 模式 - Cargo.toml 版本更新预览:`);
+			logger_default.info(`   当前版本: ${oldVersion}`);
+			logger_default.info(`   新版本:   ${newVersion}`);
+			logger_default.info(`   Tag:      ${tag ? tagName : "跳过"}`);
+			logger_default.info(`   CHANGELOG: ${changelog ? "是" : "跳过"}`);
+			logger_default.info(`   Git Commit: ${autoCommit ? "是" : "否"}`);
+			logger_default.info(`   Git Push: ${push ? "是" : "否"}`);
+			logger_default.info(`\n✅ 以上为预览，未执行任何实际操作`);
+			return {
+				success: true,
+				oldVersion,
+				newVersion
+			};
+		}
+		this.writeVersion(newVersion);
+		const verifiedVersion = this.getCurrentVersion();
+		if (verifiedVersion !== newVersion) throw new Error(`版本更新验证失败，期望版本 "${newVersion}"，实际版本 "${verifiedVersion}"`);
+		logger_default.success(`Cargo.toml 版本更新完成: ${oldVersion} → ${newVersion}`);
+		if (changelog) try {
+			const commits = this.gitManager.getCommitsSinceLastTag();
+			this.changelogManager.updateChangelog(newVersion, commits);
+			logger_default.success(`已更新 CHANGELOG.md`);
+		} catch (error$1) {
+			logger_default.warn(`更新 CHANGELOG.md 失败: ${error$1.message}`);
+		}
+		if (autoCommit) {
+			try {
+				this.gitManager.addFiles(["-u"]);
+				this.gitManager.commit(`chore: bump version to ${newVersion}`);
+				logger_default.success(`已提交更改`);
+			} catch (error$1) {
+				logger_default.warn(`提交更改失败: ${error$1.message}`);
+			}
+			if (tag) {
+				const tagName = `${packageName}@${newVersion}`;
+				try {
+					execSync(`git tag -a ${tagName} -m "Release ${tagName}"`, {
+						cwd: this.rootDir,
+						stdio: "pipe"
+					});
+					logger_default.success(`已创建 tag: ${tagName}`);
+				} catch (error$1) {
+					logger_default.warn(`创建 tag ${tagName} 失败: ${error$1.message}`);
+				}
+			}
+			if (push) try {
+				this.gitManager.push(tag);
+				logger_default.success(`已推送 commits 和 tags`);
+			} catch (error$1) {
+				logger_default.warn(`推送失败: ${error$1.message}`);
+			}
+		}
+		return {
+			success: true,
+			oldVersion,
+			newVersion
+		};
+	}
+	writeVersion(newVersion) {
+		try {
+			const content = readFileSync(this.cargoTomlPath, "utf8");
+			const lines = content.split("\n");
+			let inPackageSection = false;
+			let versionUpdated = false;
+			const newLines = lines.map((line) => {
+				const trimmedLine = line.trim();
+				if (trimmedLine.startsWith("[package]")) {
+					inPackageSection = true;
+					return line;
+				}
+				if (trimmedLine.startsWith("[") && inPackageSection) {
+					inPackageSection = false;
+					return line;
+				}
+				if (inPackageSection) {
+					const versionMatch = trimmedLine.match(/^version\s*=\s*["'](.+?)["']/);
+					if (versionMatch) {
+						versionUpdated = true;
+						const spaces = line.match(/^\s*/)?.[0] || "";
+						const quote = versionMatch[0].includes("\"") ? "\"" : "'";
+						return `${spaces}version = ${quote}${newVersion}${quote}`;
+					}
+				}
+				return line;
+			});
+			if (!versionUpdated) {
+				let packageSectionIndex = -1;
+				for (let i = 0; i < lines.length; i++) if (lines[i].trim().startsWith("[package]")) {
+					packageSectionIndex = i;
+					break;
+				}
+				if (packageSectionIndex !== -1) newLines.splice(packageSectionIndex + 1, 0, `version = "${newVersion}"`);
+				else newLines.unshift("[package]", `version = "${newVersion}"`);
+			}
+			writeFileSync(this.cargoTomlPath, newLines.join("\n"), { encoding: "utf8" });
+		} catch (error$1) {
+			throw new Error(`写入 Cargo.toml 失败: ${error$1.message}`);
+		}
+	}
+};
+
 //#endregion
 //#region src/utils/security.ts
 var security_exports = {};
@@ -825,6 +1004,61 @@ function sanitizeFileName(name) {
 	return name.replace(/[<>:"/\\|?*]/g, "_");
 }
 
+//#endregion
+//#region src/utils/semver.ts
+var semver_exports = {};
+__export(semver_exports, {
+	coerceVersion: () => coerceVersion,
+	compareVersions: () => compareVersions,
+	getMajor: () => getMajor,
+	getMinor: () => getMinor,
+	getPatch: () => getPatch,
+	getVersionDiff: () => getVersionDiff,
+	incrementVersion: () => incrementVersion,
+	isPrerelease: () => isPrerelease,
+	isValidVersion: () => isValidVersion,
+	parseVersion: () => parseVersion
+});
+function isValidVersion(version) {
+	return semver.valid(version) !== null;
+}
+function parseVersion(version) {
+	return semver.parse(version);
+}
+function incrementVersion(currentVersion, releaseType, identifier) {
+	if (identifier) return semver.inc(currentVersion, releaseType, identifier);
+	return semver.inc(currentVersion, releaseType);
+}
+function compareVersions(v1, v2) {
+	return semver.compare(v1, v2);
+}
+function getVersionDiff(oldVersion, newVersion) {
+	if (!semver.valid(oldVersion) || !semver.valid(newVersion)) return null;
+	if (semver.major(newVersion) > semver.major(oldVersion)) return "major";
+	if (semver.minor(newVersion) > semver.minor(oldVersion)) return "minor";
+	if (semver.patch(newVersion) > semver.patch(oldVersion)) return "patch";
+	return null;
+}
+function isPrerelease(version) {
+	return semver.prerelease(version) !== null;
+}
+function coerceVersion(version) {
+	const coerced = semver.coerce(version);
+	return coerced?.version || null;
+}
+function getMajor(version) {
+	const parsed = semver.parse(version);
+	return parsed?.major ?? null;
+}
+function getMinor(version) {
+	const parsed = semver.parse(version);
+	return parsed?.minor ?? null;
+}
+function getPatch(version) {
+	const parsed = semver.parse(version);
+	return parsed?.patch ?? null;
+}
+
 //#endregion
 //#region src/core/VersionManager.ts
 var VersionManager = class {
@@ -891,6 +1125,140 @@ var VersionManager = class {
 			packages: Array.from(this.packageCache.keys())
 		};
 	}
+	async previewUpdate(pkgName, releaseType = "patch", options = {}) {
+		const { packagePaths = this.packagePaths, customVersion = null, autoCommit = this.gitConfig.autoCommit !== false, push = this.gitConfig.push !== false, npm = false, changelog = this.gitConfig.changelog !== false, tagPrefix = this.gitConfig.tagPrefix || "v", packageVersionSelections } = options;
+		const packages = [];
+		if (pkgName === "all" && packageVersionSelections) for (const [packageName, selection] of Object.entries(packageVersionSelections)) {
+			const pkgPath = packagePaths[packageName];
+			if (!pkgPath) throw new Error(`无效的包名: ${packageName}`);
+			const pkg = this.getPackageInfo(pkgPath);
+			let newVersion = null;
+			if (selection.customVersion) {
+				if (!isValidVersion(selection.customVersion)) throw new Error(`无效的自定义版本号: ${selection.customVersion}`);
+				newVersion = selection.customVersion;
+			} else try {
+				switch (selection.type) {
+					case "major":
+					case "minor":
+					case "patch":
+						newVersion = incrementVersion(pkg.version, selection.type);
+						break;
+					case "next":
+						newVersion = incrementVersion(pkg.version, "patch");
+						break;
+					case "pre-patch":
+						if (isPrerelease(pkg.version)) newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+						else newVersion = incrementVersion(pkg.version, "prepatch", "beta");
+						break;
+					case "pre-minor":
+						if (isPrerelease(pkg.version)) {
+							const currentMinor = getMinor(pkg.version) ?? 0;
+							const potentialVersion = incrementVersion(pkg.version, "preminor", "beta");
+							if (potentialVersion && (getMinor(potentialVersion) ?? 0) > currentMinor) newVersion = potentialVersion;
+							else newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+						} else newVersion = incrementVersion(pkg.version, "preminor", "beta");
+						break;
+					case "pre-major":
+						if (isPrerelease(pkg.version)) {
+							const currentMajor = getMajor(pkg.version) ?? 0;
+							const potentialVersion = incrementVersion(pkg.version, "premajor", "beta");
+							if (potentialVersion && (getMajor(potentialVersion) ?? 0) > currentMajor) newVersion = potentialVersion;
+							else newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+						} else newVersion = incrementVersion(pkg.version, "premajor", "beta");
+						break;
+					case "as-is":
+						newVersion = pkg.version;
+						break;
+					case "conventional":
+						newVersion = incrementVersion(pkg.version, "patch");
+						break;
+					default: throw new Error(`不支持的版本类型: ${selection.type}`);
+				}
+			} catch (error$1) {
+				throw new Error(`版本计算失败: ${error$1.message}`);
+			}
+			if (!newVersion) throw new Error(`无法计算新版本号，当前版本: ${pkg.version}，类型: ${selection.type}`);
+			const isDefaultPackage = packageName === "default" || packagePaths[packageName] === "package.json";
+			const tagName = isDefaultPackage ? `${tagPrefix}${newVersion}` : `${pkg.name}@${newVersion}`;
+			packages.push({
+				name: packageName,
+				oldVersion: pkg.version,
+				newVersion,
+				tagName,
+				changelogEnabled: changelog && isDefaultPackage,
+				isDefaultPackage
+			});
+		}
+		else {
+			const targets = pkgName === "all" ? Object.values(packagePaths) : [packagePaths[pkgName]];
+			if (!targets.length || targets.some((path) => !path)) throw new Error(`无效的包名: ${pkgName}`);
+			for (const pkgPath of targets) {
+				const pkg = this.getPackageInfo(pkgPath);
+				let newVersion = null;
+				if (customVersion) {
+					if (!isValidVersion(customVersion)) throw new Error(`无效的自定义版本号: ${customVersion}`);
+					newVersion = customVersion;
+				} else try {
+					switch (releaseType) {
+						case "major":
+						case "minor":
+						case "patch":
+							newVersion = incrementVersion(pkg.version, releaseType);
+							break;
+						case "next":
+							newVersion = incrementVersion(pkg.version, "patch");
+							break;
+						case "pre-patch":
+							if (isPrerelease(pkg.version)) newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+							else newVersion = incrementVersion(pkg.version, "prepatch", "beta");
+							break;
+						case "pre-minor":
+							if (isPrerelease(pkg.version)) {
+								const currentMinor = getMinor(pkg.version) ?? 0;
+								const potentialVersion = incrementVersion(pkg.version, "preminor", "beta");
+								if (potentialVersion && (getMinor(potentialVersion) ?? 0) > currentMinor) newVersion = potentialVersion;
+								else newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+							} else newVersion = incrementVersion(pkg.version, "preminor", "beta");
+							break;
+						case "pre-major":
+							if (isPrerelease(pkg.version)) {
+								const currentMajor = getMajor(pkg.version) ?? 0;
+								const potentialVersion = incrementVersion(pkg.version, "premajor", "beta");
+								if (potentialVersion && (getMajor(potentialVersion) ?? 0) > currentMajor) newVersion = potentialVersion;
+								else newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+							} else newVersion = incrementVersion(pkg.version, "premajor", "beta");
+							break;
+						case "as-is":
+							newVersion = pkg.version;
+							break;
+						case "conventional":
+							newVersion = incrementVersion(pkg.version, "patch");
+							break;
+						default: throw new Error(`不支持的版本类型: ${releaseType}`);
+					}
+				} catch (error$1) {
+					throw new Error(`版本计算失败: ${error$1.message}`);
+				}
+				if (!newVersion) throw new Error(`无法计算新版本号，当前版本: ${pkg.version}，类型: ${releaseType}`);
+				const isDefaultPackage = pkgName === "default" || packagePaths[pkgName] === "package.json";
+				const tagName = isDefaultPackage ? `${tagPrefix}${newVersion}` : `${pkg.name}@${newVersion}`;
+				packages.push({
+					name: pkg.name,
+					oldVersion: pkg.version,
+					newVersion,
+					tagName,
+					changelogEnabled: changelog && isDefaultPackage,
+					isDefaultPackage
+				});
+			}
+		}
+		return {
+			packages,
+			autoCommit,
+			push,
+			npm
+		};
+	}
 	async updateVersion(pkgName, releaseType = "patch", options = {}) {
 		const { dryRun: dryRun$1 = false, verbose = false, packagePaths = this.packagePaths, customVersion = null, autoCommit = this.gitConfig.autoCommit !== false, npm = false, changelog = this.gitConfig.changelog !== false, tag = this.gitConfig.tag !== false, tagPrefix = this.gitConfig.tagPrefix || "v", isBatchMode = false } = options;
 		const result = {
@@ -908,43 +1276,43 @@ var VersionManager = class {
 					const pkg = this.getPackageInfo(pkgPath);
 					let newVersion = null;
 					if (customVersion) {
-						if (!semver.valid(customVersion)) throw new Error(`无效的自定义版本号: ${customVersion}`);
+						if (!isValidVersion(customVersion)) throw new Error(`无效的自定义版本号: ${customVersion}`);
 						newVersion = customVersion;
 					} else try {
 						switch (releaseType) {
 							case "major":
 							case "minor":
 							case "patch":
-								newVersion = semver.inc(pkg.version, releaseType);
+								newVersion = incrementVersion(pkg.version, releaseType);
 								break;
 							case "next":
-								newVersion = semver.inc(pkg.version, "patch");
+								newVersion = incrementVersion(pkg.version, "patch");
 								break;
 							case "pre-patch":
-								if (semver.prerelease(pkg.version)) newVersion = semver.inc(pkg.version, "prerelease");
-								else newVersion = semver.inc(pkg.version, "prepatch", "beta");
+								if (isPrerelease(pkg.version)) newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+								else newVersion = incrementVersion(pkg.version, "prepatch", "beta");
 								break;
 							case "pre-minor":
-								if (semver.prerelease(pkg.version)) {
-									const currentMinor = semver.minor(pkg.version);
-									const potentialVersion = semver.inc(pkg.version, "preminor", "beta");
-									if (potentialVersion && semver.minor(potentialVersion) > currentMinor) newVersion = potentialVersion;
-									else newVersion = semver.inc(pkg.version, "prerelease");
-								} else newVersion = semver.inc(pkg.version, "preminor", "beta");
+								if (isPrerelease(pkg.version)) {
+									const currentMinor = getMinor(pkg.version) ?? 0;
+									const potentialVersion = incrementVersion(pkg.version, "preminor", "beta");
+									if (potentialVersion && (getMinor(potentialVersion) ?? 0) > currentMinor) newVersion = potentialVersion;
+									else newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+								} else newVersion = incrementVersion(pkg.version, "preminor", "beta");
 								break;
 							case "pre-major":
-								if (semver.prerelease(pkg.version)) {
-									const currentMajor = semver.major(pkg.version);
-									const potentialVersion = semver.inc(pkg.version, "premajor", "beta");
-									if (potentialVersion && semver.major(potentialVersion) > currentMajor) newVersion = potentialVersion;
-									else newVersion = semver.inc(pkg.version, "prerelease");
-								} else newVersion = semver.inc(pkg.version, "premajor", "beta");
+								if (isPrerelease(pkg.version)) {
+									const currentMajor = getMajor(pkg.version) ?? 0;
+									const potentialVersion = incrementVersion(pkg.version, "premajor", "beta");
+									if (potentialVersion && (getMajor(potentialVersion) ?? 0) > currentMajor) newVersion = potentialVersion;
+									else newVersion = incrementVersion(pkg.version, "prerelease", "beta");
+								} else newVersion = incrementVersion(pkg.version, "premajor", "beta");
 								break;
 							case "as-is":
 								newVersion = pkg.version;
 								break;
 							case "conventional":
-								newVersion = semver.inc(pkg.version, "patch");
+								newVersion = incrementVersion(pkg.version, "patch");
 								break;
 							default: throw new Error(`不支持的版本类型: ${releaseType}`);
 						}
@@ -954,7 +1322,9 @@ var VersionManager = class {
 					if (!newVersion) throw new Error(`无法计算新版本号，当前版本: ${pkg.version}，类型: ${releaseType}`);
 					if (!finalVersion) {
 						finalVersion = newVersion;
-						if (!dryRun$1 && this.gitManager.checkVersionExists(newVersion, tagPrefix)) throw new Error(`版本 ${tagPrefix}${newVersion} 已存在，请使用其他版本`);
+						const isDefaultPackage$1 = pkgName === "default" || this.config.packagePaths[pkgName] === "package.json";
+						const versionTag = isDefaultPackage$1 ? `${tagPrefix}${newVersion}` : `${pkg.name}@${newVersion}`;
+						if (!dryRun$1 && this.gitManager.checkVersionExists(newVersion, tagPrefix, isDefaultPackage$1 ? void 0 : pkg.name)) throw new Error(`版本 ${versionTag} 已存在，请使用其他版本`);
 					}
 					if (dryRun$1) logger_default.dryRun(`将更新 ${pkg.name} 从 v${pkg.version} 到 v${newVersion}`);
 					else {
@@ -968,7 +1338,8 @@ var VersionManager = class {
 					result.updatedPackages.push({
 						name: pkg.name,
 						oldVersion: pkg.version,
-						newVersion
+						newVersion,
+						pkgKey: pkgName
 					});
 				}
 				const isDefaultPackage = pkgName === "default" || this.config.packagePaths[pkgName] === "package.json";
@@ -1116,17 +1487,37 @@ var VersionManager = class {
 		}
 	}
 	isValidVersion(version) {
-		return semver.valid(version) !== null;
+		return isValidVersion(version);
 	}
 	getVersionDiff(oldVersion, newVersion) {
-		if (!semver.valid(oldVersion) || !semver.valid(newVersion)) return null;
-		if (semver.major(newVersion) > semver.major(oldVersion)) return "major";
-		if (semver.minor(newVersion) > semver.minor(oldVersion)) return "minor";
-		if (semver.patch(newVersion) > semver.patch(oldVersion)) return "patch";
+		if (!isValidVersion(oldVersion) || !isValidVersion(newVersion)) return null;
+		if ((getMajor(newVersion) ?? 0) > (getMajor(oldVersion) ?? 0)) return "major";
+		if ((getMinor(newVersion) ?? 0) > (getMinor(oldVersion) ?? 0)) return "minor";
+		if ((getPatch(newVersion) ?? 0) > (getPatch(oldVersion) ?? 0)) return "patch";
 		return null;
 	}
 };
 
 //#endregion
-export { BASE_CONFIG, ChangelogManager, GitManager, VersionManager, clearConfigCache, loadConfig, loadConfigAsync, logger_default, security_exports };
-//# sourceMappingURL=VersionManager-CwsuNWyP.js.map
+//#region src/utils/path.ts
+var path_exports = {};
+__export(path_exports, {
+	isAbsolutePath: () => isAbsolutePath,
+	isPathLike: () => isPathLike,
+	resolvePath: () => resolvePath
+});
+function isPathLike(arg) {
+	return arg.startsWith("./") || arg.startsWith("../") || arg.startsWith(".\\") || arg.startsWith("..\\") || arg.startsWith("/") || arg.startsWith("\\") || /^[A-Za-z]:[\\/].*/.test(arg) || arg.startsWith("~") || arg === "." || arg.startsWith("\\\\") || arg.startsWith("//") || arg.includes("/") || arg.includes("\\") || arg.includes(".");
+}
+function resolvePath(basePath, targetPath) {
+	const { resolve: resolve$1 } = __require("node:path");
+	if (targetPath.startsWith("/") || /^[a-z]:\\/i.test(targetPath)) return resolve$1(targetPath);
+	return resolve$1(basePath, targetPath);
+}
+function isAbsolutePath(path) {
+	return path.startsWith("/") || /^[a-z]:\\/i.test(path) || path.startsWith("\\\\") || path.startsWith("//");
+}
+
+//#endregion
+export { BASE_CONFIG, ChangelogManager, GitManager, RustManager, VersionManager, clearConfigCache, isPathLike, loadConfig, loadConfigAsync, logger_default, path_exports, security_exports, semver_exports };
+//# sourceMappingURL=path-Dxq6zEl-.js.map