@nemo-cli/git 0.0.1-beta.4

package/dist/index.js

@@ -0,0 +1,1088 @@
+import { addFiles, colors, createCheckbox, createCommand, createConfirm, createHelpExample, createInput, createNote, createOptions, createSearch, createSelect, createSpinner, exit, getCurrentBranch, getGitStatus, intro, isEmpty, isString, loadConfig, log, outro, readPackage, x, xASync } from "@nemo-cli/shared";
+import { BigText, ErrorMessage, Message } from "@nemo-cli/ui";
+import { spawn } from "node:child_process";
+import { unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+//#region src/constants/index.ts
+const HELP_MESSAGE$1 = {
+	main: createHelpExample("ng --version", "ng --help", "ng <command> [option]"),
+	branch: createHelpExample("ng branch --version", "ng branch --help", "ng branch <command> [option]"),
+	branchDelete: createHelpExample("ng branch delete --version", "ng branch delete --help", "ng branch delete <command> [option]"),
+	branchClean: createHelpExample("ng branch clean --version", "ng branch clean --help")
+};
+
+//#endregion
+//#region src/utils.ts
+const remotePrefix = /^origin\//;
+const getRemoteBranches = async () => {
+	return { branches: (await x("git", [
+		"branch",
+		"-r",
+		"--sort=-committerdate"
+	])).stdout.split("\n").filter((line) => line.trim() && !line.includes("->")).map((line) => line.trim().replace(remotePrefix, "")) };
+};
+const currentBranchPrefix = /^\* /;
+const formatBranch$1 = (branch) => branch?.trim().replace(currentBranchPrefix, "");
+const getLocalBranches = async () => {
+	const list = (await x("git", ["branch", "--sort=-committerdate"])).stdout.split("\n");
+	const currentBranch = list.find((line) => line.includes("*"));
+	return {
+		branches: list.filter((line) => line.trim() && !line.includes("->")).map((line) => line.trim().replace(currentBranchPrefix, "")),
+		currentBranch: formatBranch$1(currentBranch)
+	};
+};
+const getRemoteOptions = async () => {
+	const { branches } = await getRemoteBranches();
+	const currentBranch = await getCurrentBranch();
+	return {
+		options: branches.map((branch) => ({
+			label: branch,
+			value: branch,
+			hint: branch === currentBranch ? "current branch" : void 0
+		})),
+		currentBranch
+	};
+};
+const getLocalOptions = async () => {
+	const { branches, currentBranch } = await getLocalBranches();
+	return {
+		options: branches.map((branch) => ({
+			label: branch,
+			value: branch,
+			hint: branch === currentBranch ? "current branch" : void 0
+		})),
+		currentBranch
+	};
+};
+/**
+* 处理合并提交信息
+*/
+const handleMergeCommit = async () => {
+	try {
+		const [error, result] = await xASync("git", ["status", "--porcelain"]);
+		if (error) return;
+		if (!(result.stdout.trim().length > 0)) return;
+		log.show("\n📝 Merge commit detected. You can customize the commit message.", { type: "info" });
+		if (!await createConfirm({ message: "Do you want to customize the merge commit message?" })) {
+			await xASync("git", ["commit", "--no-edit"]);
+			log.show("Using default merge commit message.", { type: "info" });
+			return;
+		}
+		const [processError, processResult] = await xASync("git", [
+			"log",
+			"--format=%B",
+			"-n",
+			"1",
+			"HEAD"
+		]);
+		if (processError) return;
+		const defaultMessage = processResult.stdout;
+		const tempFile = join(tmpdir(), `merge-commit-${Date.now()}.txt`);
+		writeFileSync(tempFile, defaultMessage);
+		const editor = process.env.EDITOR || process.env.VISUAL || "vim";
+		log.show(`Opening ${editor} to edit commit message...`, { type: "info" });
+		log.show("Save and close the editor to continue, or close without saving to cancel.", { type: "info" });
+		const editProcess = spawn(editor, [tempFile], {
+			stdio: "inherit",
+			shell: true
+		});
+		if (await new Promise((resolve) => {
+			editProcess.on("close", (code) => {
+				resolve(code || 0);
+			});
+		}) !== 0) {
+			log.show("Editor was closed without saving. Using default commit message.", { type: "warn" });
+			await xASync("git", ["commit", "--no-edit"]);
+			unlinkSync(tempFile);
+			return;
+		}
+		const { readFileSync } = await import("node:fs");
+		const editedMessage = readFileSync(tempFile, "utf-8");
+		unlinkSync(tempFile);
+		if (!editedMessage.trim()) {
+			log.show("Commit message is empty. Using default commit message.", { type: "warn" });
+			await xASync("git", ["commit", "--no-edit"]);
+			return;
+		}
+		const commitProcess = spawn("git", [
+			"commit",
+			"-F",
+			"-"
+		], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			shell: true
+		});
+		commitProcess.stdin?.write(editedMessage);
+		commitProcess.stdin?.end();
+		if (await new Promise((resolve) => {
+			commitProcess.on("close", (code) => {
+				resolve(code || 0);
+			});
+		}) === 0) log.show("Merge commit completed with custom message.", { type: "success" });
+		else throw new Error("Failed to create merge commit with custom message");
+	} catch (error) {
+		log.show("Error handling merge commit:", { type: "error" });
+		log.error(error);
+		try {
+			await xASync("git", ["commit", "--no-edit"]);
+			log.show("Fallback: Using default merge commit message.", { type: "info" });
+		} catch (fallbackError) {
+			log.show("Failed to create merge commit. Please handle manually.", { type: "error" });
+			throw fallbackError;
+		}
+	}
+};
+const handleGitPull = async (branch, options = {}) => {
+	const { rebase = false } = options;
+	const modeText = rebase ? "rebase" : "merge";
+	log.show(`Pulling from remote (${modeText} mode)...`, { type: "step" });
+	try {
+		const [error, result] = await xASync("git", rebase ? [
+			"pull",
+			"--rebase",
+			"origin",
+			branch
+		] : [
+			"pull",
+			"origin",
+			branch
+		], { nodeOptions: { stdio: "inherit" } });
+		if (error) {
+			log.show(`Failed to pull from remote. Command exited with code ${error.message}.`, { type: "error" });
+			return;
+		}
+		if (!rebase && (result.stdout.includes("Merge branch") || result.stdout.includes("Merge made by"))) await handleMergeCommit();
+		log.show(`Successfully pulled from remote: ${colors.bgGreen(branch)} (${modeText})`, { type: "success" });
+	} catch (error) {
+		log.error(error);
+		return;
+	}
+};
+const createStashName = () => `NEMO-CLI-STASH:${Date.now()}`;
+const handleGitStash = async (name = createStashName()) => {
+	const [error, result] = await xASync("git", [
+		"stash",
+		"save",
+		name
+	]);
+	if (error) {
+		log.show(`Failed to stash changes. ${name}`, { type: "error" });
+		return null;
+	}
+	if (result?.stdout.includes(name)) {
+		log.show(`Successfully stashed changes. ${name}`, { type: "success" });
+		return name;
+	}
+	log.show("No file changes.");
+	return null;
+};
+const handleGitStashCheck = async () => {
+	const [error, result] = await xASync("git", ["stash", "list"]);
+	if (error) return [];
+	return result.stdout.split("\n").filter((line) => line.trim());
+};
+const handleGitPop = async (branch) => {
+	const stashName = (await handleGitStashCheck()).find((stash) => stash.includes(branch));
+	if (!stashName) {
+		log.show(`No stash found for this branch: ${colors.bgRed(branch)}.`, { type: "warn" });
+		return;
+	}
+	const name = stashName.split(":")[0];
+	if (!name) {
+		log.error(name, "is not valid");
+		return;
+	}
+	const [error, result] = await xASync("git", [
+		"stash",
+		"pop",
+		name
+	]);
+	if (!error) createNote({
+		message: result.stdout,
+		title: "Successfully popped changes."
+	});
+};
+const isBranchMergedToMain = async (branches) => {
+	const spinner = createSpinner("Fetching latest changes from remote");
+	const [fetchError] = await xASync("git", [
+		"fetch",
+		"origin",
+		"--prune"
+	]);
+	if (fetchError) spinner.stop("Failed to fetch latest changes from remote. Proceeding with local information.");
+	else spinner.stop("Fetching latest changes from remote Done");
+	const remoteMainBranch = await getRemoteMainBranch();
+	if (!remoteMainBranch) return [];
+	return Promise.all(branches.map(async (branch) => {
+		const [error, result] = await xASync("git", ["log", `${remoteMainBranch}..${branch}`], { quiet: true });
+		if (error) return {
+			branch,
+			isMerged: false
+		};
+		return {
+			branch,
+			isMerged: !result?.stdout.trim()
+		};
+	}));
+};
+const checkGitRepository = async () => {
+	try {
+		const [error, result] = await xASync("git", ["rev-parse", "--is-inside-work-tree"], { quiet: true });
+		if (error) return false;
+		return result.stdout.trim() === "true";
+	} catch (err) {
+		return false;
+	}
+};
+const getRemoteMainBranch = async () => {
+	const [error, result] = await xASync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+	if (error) return null;
+	return result.stdout.trim().split("/").splice(2).join("/");
+};
+const getBranchCommitTime = async (branch) => {
+	const [_, result] = await xASync("git", [
+		"show",
+		"--format=%at",
+		`${branch}`
+	]);
+	return result?.stdout.split("\n")[0] ?? Date.now();
+};
+
+//#endregion
+//#region src/commands/branch.ts
+const formatTime = (time) => (/* @__PURE__ */ new Date(time * 1e3)).toLocaleString();
+const formatBranch = (branch) => branch.startsWith("origin/") ? branch.slice(7) : branch;
+const handleDelete = async (branch, { isRemote }) => {
+	if (!branch.isMerged) {
+		if (!await createConfirm({ message: `Branch ${branch.branch} is not merged to main. Are you sure you want to delete it?` })) return;
+	}
+	const spinner = createSpinner(`Deleting branch ${branch.branch}...`);
+	const process = x("git", isRemote ? [
+		"push",
+		"origin",
+		"--delete",
+		formatBranch(branch.branch)
+	] : [
+		"branch",
+		"-D",
+		branch.branch
+	]);
+	for await (const line of process) spinner.message(line);
+	if (process.exitCode) spinner.stop(`Failed to delete branch ${branch}. Command exited with code ${process.exitCode}.`);
+	else spinner.stop(`Successfully deleted branch ${branch.branch}`);
+};
+const excludeBranch = [
+	"main",
+	"master",
+	"develop"
+];
+const oneDay = 3600 * 24;
+function branchCommand(command) {
+	const subCommand = command.command("branch").description("Git branch management").addHelpText("after", HELP_MESSAGE$1.branch);
+	subCommand.command("clean").description("Git branch clean merged to main").addHelpText("after", HELP_MESSAGE$1.branchClean).action(async () => {
+		const timeRange = await createSelect({
+			message: "Select the time range",
+			options: [
+				{
+					label: "all",
+					value: 0
+				},
+				{
+					label: "1 month",
+					value: oneDay * 30
+				},
+				{
+					label: "1 year",
+					value: oneDay * 365
+				},
+				{
+					label: "3 months",
+					value: oneDay * 90
+				}
+			]
+		});
+		const { branches } = await getLocalBranches();
+		const mergedBranches = (await isBranchMergedToMain(branches.filter((branch) => !excludeBranch.includes(branch)))).filter((branch) => branch.isMerged).map((branch) => branch.branch);
+		const lastCommitBranches = await Promise.all(mergedBranches.map(async (branch) => {
+			const time = await getBranchCommitTime(branch);
+			return {
+				branch,
+				lastCommitTime: Number(time)
+			};
+		}));
+		const now = Date.now() / 1e3;
+		const deleteBranches = lastCommitBranches.filter((branch) => now - branch.lastCommitTime >= timeRange);
+		if (deleteBranches.length === 0) {
+			Message({ text: "No branches to delete. Please check your git repository." });
+			return;
+		}
+		createNote({
+			message: `Found ${deleteBranches.length} branches, will delete\n${deleteBranches.map((branch) => colors.red(branch.branch)).join("\n")}`,
+			title: "Delete Branches"
+		});
+		if (!await createConfirm({ message: "Are you sure you want to delete these branches?" })) return;
+		await Promise.all(deleteBranches.map((branch) => handleDelete({
+			branch: branch.branch,
+			isMerged: true
+		}, { isRemote: false })));
+		Message({ text: "Successfully deleted branches" });
+	});
+	subCommand.command("delete").description("Git branch delete").addHelpText("after", HELP_MESSAGE$1.branchDelete).option("-r, --remote", "remote branch").action(async (options) => {
+		const { branches } = options.remote ? await getRemoteBranches() : await getLocalBranches();
+		if (!branches || branches.length === 0) {
+			ErrorMessage({ text: "No branches found. Please check your git repository." });
+			return;
+		}
+		const mergeInfoList = await isBranchMergedToMain((options.remote ? branches.map((branch) => `origin/${branch}`) : branches).filter((branch) => !excludeBranch.includes(branch)));
+		if (mergeInfoList.length === 0) {
+			ErrorMessage({ text: "No branches to delete. Please check your git repository." });
+			return;
+		}
+		const deleteBranches = await createCheckbox({
+			message: "Select the branch to delete",
+			options: await Promise.all(mergeInfoList.map(async (branch) => {
+				const lastCommitTime = await getBranchCommitTime(branch.branch);
+				return {
+					label: `${branch.branch} ${branch.isMerged ? colors.green("(merged)") : colors.yellow("(not merged)")}`,
+					value: {
+						lastCommitTime,
+						branch: branch.branch,
+						isMerged: branch.isMerged
+					},
+					hint: `last commit: ${formatTime(Number(lastCommitTime))}`
+				};
+			}))
+		});
+		if (!deleteBranches.length) {
+			log.error("No branch selected. Aborting delete operation.");
+			return;
+		}
+		await Promise.all(deleteBranches.map((branch) => handleDelete({
+			branch: branch.branch,
+			isMerged: true
+		}, { isRemote: options.remote ?? false })));
+		Message({ text: "Successfully deleted branches" });
+	});
+}
+
+//#endregion
+//#region src/commands/checkout.ts
+const handleCheckout = async (branch, { isNew = false, isRemote = false } = {}) => {
+	const args = ["checkout"];
+	if (isNew || isRemote) args.push("-b");
+	args.push(branch);
+	if (isRemote) args.push(`origin/${branch}`);
+	const stashName = await handleGitStash(branch);
+	const process = x("git", args);
+	for await (const line of process) log.show(line);
+	const { exitCode, stderr } = await process;
+	if (exitCode) {
+		log.show(`Failed to checkout branch ${branch}. Command exited with code ${exitCode}.`, { type: "error" });
+		log.show(stderr, { type: "error" });
+	} else log.show(`Successfully checked out branch ${branch}.`, { type: "success" });
+	stashName && handleGitPop(stashName);
+};
+function checkoutCommand(command) {
+	command.command("checkout").alias("co").option("-l, --local", "Checkout a local branch", true).option("-r, --remote", "Checkout a remote branch").option("-b, --branch [branch]", "Create and checkout a new branch").description("Checkout a branch").action(async (params) => {
+		let isLocal = params.local && !params.remote;
+		const branch = params.branch;
+		if (branch) {
+			if (isString(branch)) {
+				handleCheckout(branch, { isNew: true });
+				return;
+			}
+			handleCheckout(`${await createSelect({
+				message: "Enter the new branch name:",
+				options: createOptions([
+					"feature/PRIME-",
+					"feature/",
+					"bugfix/"
+				])
+			})}${await createInput({
+				message: "Enter the new branch name:",
+				validate: (value) => {
+					if (!value?.trim()) return "Branch name is required";
+					if (value.length > 15) return "Branch name must be less than 15 characters";
+				}
+			})}`, { isNew: true });
+			return;
+		}
+		if (isEmpty(params)) isLocal = await createSelect({
+			message: "Select the branch type",
+			options: [{
+				label: "Remote",
+				value: false
+			}, {
+				label: "Local",
+				value: true
+			}],
+			initialValue: true
+		});
+		if (isLocal) {
+			const { options } = await getLocalOptions();
+			handleCheckout(await createSelect({
+				message: `Select the ${colors.bgGreen(" local ")} branch to checkout`,
+				options
+			}));
+		} else {
+			const { options } = await getRemoteOptions();
+			const selectedBranch = await createSelect({
+				message: `Select the ${colors.bgYellow(" remote ")} branch to checkout`,
+				options
+			});
+			if (await createConfirm({ message: `Do you want to checkout ${colors.bgRed(selectedBranch)}?` })) handleCheckout(selectedBranch, { isRemote: true });
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/commit-options.ts
+const commitScopeOptions = [
+	{
+		value: "app",
+		label: "app"
+	},
+	{
+		value: "shared",
+		label: "shared"
+	},
+	{
+		value: "server",
+		label: "server"
+	},
+	{
+		value: "tools",
+		label: "tools"
+	},
+	{
+		value: "",
+		label: "none"
+	}
+];
+const commitTypeOptions = [
+	{
+		value: "feat",
+		label: "feat",
+		hint: "A new feature",
+		emoji: "🌟",
+		trailer: "Changelog: feature"
+	},
+	{
+		value: "fix",
+		label: "fix",
+		hint: "A bug fix",
+		emoji: "🐛",
+		trailer: "Changelog: fix"
+	},
+	{
+		value: "docs",
+		label: "docs",
+		hint: "Documentation only changes",
+		emoji: "📚",
+		trailer: "Changelog: documentation"
+	},
+	{
+		value: "refactor",
+		label: "refactor",
+		hint: "A code change that neither fixes a bug nor adds a feature",
+		emoji: "🔨",
+		trailer: "Changelog: refactor"
+	},
+	{
+		value: "perf",
+		label: "perf",
+		hint: "A code change that improves performance",
+		emoji: "🚀",
+		trailer: "Changelog: performance"
+	},
+	{
+		value: "test",
+		label: "test",
+		hint: "Adding missing tests or correcting existing tests",
+		emoji: "🚨",
+		trailer: "Changelog: test"
+	},
+	{
+		value: "build",
+		label: "build",
+		hint: "Changes that affect the build system or external dependencies",
+		emoji: "🚧",
+		trailer: "Changelog: build"
+	},
+	{
+		value: "ci",
+		label: "ci",
+		hint: "Changes to our CI configuration files and scripts",
+		emoji: "🤖",
+		trailer: "Changelog: ci"
+	},
+	{
+		value: "chore",
+		label: "chore",
+		hint: "Other changes that do not modify src or test files",
+		emoji: "🧹",
+		trailer: "Changelog: chore"
+	},
+	{
+		value: "revert",
+		label: "revert",
+		hint: "Revert a previous commit",
+		emoji: "🔙",
+		trailer: "Changelog: revert"
+	},
+	{
+		value: "",
+		label: "none"
+	}
+];
+const commitlintConfig = {
+	extends: ["@commitlint/config-conventional"],
+	rules: {
+		"subject-empty": [2, "never"],
+		"type-empty": [2, "never"],
+		"type-enum": [
+			2,
+			"always",
+			[
+				"feat",
+				"fix",
+				"docs",
+				"style",
+				"refactor",
+				"perf",
+				"test",
+				"build",
+				"ci",
+				"chore",
+				"revert",
+				"wip",
+				"release"
+			]
+		],
+		"scope-empty": [1, "always"],
+		"scope-enum": [
+			1,
+			"always",
+			[
+				"app",
+				"shared",
+				"server",
+				"tools",
+				""
+			]
+		]
+	}
+};
+const mergeCommitTypeEnumOptions = (options) => {
+	return options.map((option) => {
+		const commitTypeOption = commitTypeOptions.find((commitTypeOption$1) => commitTypeOption$1.value === option);
+		return {
+			value: commitTypeOption?.value ?? option,
+			label: commitTypeOption?.label ?? option,
+			hint: commitTypeOption?.hint,
+			emoji: commitTypeOption?.emoji,
+			trailer: commitTypeOption?.trailer
+		};
+	});
+};
+const mergeCommitScopeEnumOptions = (options) => {
+	return (options.includes("none") ? options : options.concat("none")).map((option) => {
+		const commitScopeOption = commitScopeOptions.find((commitScopeOption$1) => commitScopeOption$1.label === option);
+		return {
+			value: commitScopeOption?.value ?? option,
+			label: commitScopeOption?.label ?? option
+		};
+	});
+};
+
+//#endregion
+//#region src/commands/push.ts
+const handlePush = async (branch) => {
+	const spinner = createSpinner(`Pushing branch ${branch} to remote...`);
+	try {
+		const process = x("git", [
+			"push",
+			"origin",
+			branch
+		]);
+		for await (const line of process) spinner.message(line);
+		const code = process.exitCode;
+		if (code) throw new Error(`Failed code ${code}`);
+		spinner.stop(colors.green(`Successfully pushed branch ${colors.bgGreen(branch)} to remote.`));
+	} catch (error) {
+		spinner.stop();
+		BigText({ text: `Failed to push branch ${branch}.` });
+		log.error(error);
+	}
+};
+function pushCommand(command) {
+	command.command("push").alias("ps").description("Push current branch to remote").action(async () => {
+		await pushInteractive();
+	});
+}
+const pushInteractive = async () => {
+	const currentBranch = await getCurrentBranch();
+	if (!currentBranch) {
+		log.error("No branch selected. Aborting push operation.");
+		return;
+	}
+	if (await createConfirm({ message: `Do you want to push ${colors.bgGreen(currentBranch)} to remote?` })) {
+		await handlePush(currentBranch);
+		return;
+	}
+	const { options } = await getRemoteOptions();
+	await handlePush(await createSelect({
+		message: "Select the branch to push",
+		options,
+		initialValue: "main"
+	}));
+};
+
+//#endregion
+//#region src/commands/commit.ts
+const lintHandle = async () => {
+	const [error, result] = await xASync("lint-staged");
+	if (error?.message === "spawn lint-staged ENOENT") return true;
+	if (error) return false;
+	return true;
+};
+const handleCommit = async (message) => {
+	const spinner = createSpinner("Committing...");
+	const [error, _result] = await xASync("git", [
+		"commit",
+		"-m",
+		message
+	]);
+	if (error) spinner.stop("Failed to commit");
+	else spinner.stop("Committed");
+};
+const handleLint = async () => {
+	const spinner = createSpinner("run lint-staged linting...");
+	if (!await lintHandle()) !await createConfirm({
+		message: "Lint failed. Do you want to continue?",
+		initialValue: false
+	}) && exit(0);
+	spinner.stop("lint-staged done");
+};
+const commitCommand = (command) => {
+	command.command("commit").description("Commit a message").action(async () => {
+		console.clear();
+		const title = colors.bgRed(`  ${await getCurrentBranch()}  `);
+		intro(`${colors.bgCyan(" Current Branch: ")} ${title}`);
+		const { staged, unstaged } = await getGitStatus();
+		if (staged.length === 0 && unstaged.length === 0) {
+			ErrorMessage({ text: "No changes detected. Nothing to commit." });
+			exit(0);
+		}
+		log.show(`Changes to be committed:\n${staged.map((text) => colors.green(text)).join("\n")}`, { type: "success" });
+		const selectedStaged = staged;
+		if (unstaged.length > 0) {
+			const selectedFiles = await createCheckbox({
+				message: "Select files to stage for commit (optional):",
+				options: createOptions(unstaged),
+				required: false
+			});
+			selectedStaged.push(...selectedFiles);
+			if (selectedFiles.length > 0) {
+				await addFiles(selectedFiles);
+				createNote({
+					message: `Added ${selectedFiles.length} unstaged file(s) to staging area.\n${selectedFiles.map((file) => colors.green(file)).join("\n")}`,
+					title: "Add Files"
+				});
+			}
+		}
+		if (selectedStaged.length === 0) {
+			ErrorMessage({ text: "No staged files. Nothing to commit." });
+			exit(0);
+		}
+		await handleLint();
+		const options = await loadConfig({ sources: [{
+			files: "commitlint.config",
+			extensions: [
+				"js",
+				"ts",
+				"cjs",
+				"mjs",
+				"json",
+				""
+			]
+		}] });
+		const commitType = await createSelect({
+			message: "Select type:",
+			options: mergeCommitTypeEnumOptions((options.config ?? commitlintConfig).rules["type-enum"][2])
+		});
+		const commitScope = await createSelect({
+			message: "Select scope:",
+			options: mergeCommitScopeEnumOptions((options.config ?? commitlintConfig).rules["scope-enum"][2])
+		});
+		const commitTitle = await createInput({
+			message: "Write a brief title describing the commit:",
+			validate(value) {
+				if (!value?.trim()) return "Title is required";
+				if (value.length > 80) return "Title must be less than 80 characters";
+			}
+		});
+		const commitBody = await createInput({ message: "Write a detailed description of the changes (optional):" });
+		const ticket = await getTicket();
+		const scopeMessage = commitScope ? `(${commitScope})` : "";
+		const message = `${commitType}${scopeMessage}: ${ticket} ${commitTitle}\n${commitBody}`;
+		createNote({
+			message: `${colors.blue(commitType)}${colors.green(scopeMessage)}: ${colors.redBright(ticket)} ${commitTitle}\n${commitBody}`,
+			title: "Commit Message"
+		});
+		if (!await createConfirm({ message: "Are you sure you want to commit?" })) return;
+		await handleCommit(message);
+		await createConfirm({ message: "Do you want to push to remote?" }) && await pushInteractive();
+		outro(colors.bgGreen(" Git Commit Success "));
+	});
+};
+const REGEX_SLASH_TAG = /* @__PURE__ */ new RegExp(/\/(\w+-\d+)/);
+const REGEX_START_TAG = /* @__PURE__ */ new RegExp(/^(\w+-\d+)/);
+const REGEX_START_UND = /* @__PURE__ */ new RegExp(/^([A-Z]+-[[a-zA-Z\]\d]+)_/);
+const REGEX_SLASH_UND = /* @__PURE__ */ new RegExp(/\/([A-Z]+-[[a-zA-Z\]\d]+)_/);
+const REGEX_SLASH_NUM = /* @__PURE__ */ new RegExp(/\/(\d+)/);
+const REGEX_START_NUM = /* @__PURE__ */ new RegExp(/^(\d+)/);
+const getTicket = async () => {
+	const branch = await getCurrentBranch();
+	const chain = [
+		REGEX_START_UND,
+		REGEX_SLASH_UND,
+		REGEX_SLASH_TAG,
+		REGEX_SLASH_NUM,
+		REGEX_START_TAG,
+		REGEX_START_NUM
+	];
+	for (const regex of chain) {
+		const match = branch.match(regex);
+		if (match) return match[1];
+	}
+	return branch;
+};
+
+//#endregion
+//#region src/commands/diff.ts
+const handleDiff = async (branch, { isLocal }) => {
+	console.log("🚀 : handleDiff : branch:", branch, isLocal);
+	const currentBranch = await getCurrentBranch();
+	if (!currentBranch) {
+		log.error("Could not determine current branch");
+		return;
+	}
+	const diffArgs = branch === currentBranch ? ["diff"] : ["diff", `${branch}...${currentBranch}`];
+	log.show(`Showing diff between ${branch === currentBranch ? "working directory and HEAD" : `${branch} and ${currentBranch}`}`);
+	const process = x("git", diffArgs);
+	let hasOutput = false;
+	for await (const line of process) {
+		hasOutput = true;
+		log.show(line);
+	}
+	const { exitCode, stderr } = await process;
+	if (exitCode) {
+		log.error(`Failed to diff. Command exited with code ${exitCode}.`);
+		if (stderr) log.error(stderr);
+	} else if (!hasOutput) log.show("No differences found.", { type: "info" });
+};
+function diffCommand(command) {
+	command.command("diff").alias("di").description("Show differences between branches or working directory").option("-l, --local", "Diff local branch", true).option("-r, --remote", "Diff remote branch").action(async (options) => {
+		const { branches } = options.remote ? await getRemoteBranches() : await getLocalBranches();
+		if (!branches || branches.length === 0) {
+			log.error("No branches found. Please check your git repository.");
+			return;
+		}
+		const selectedBranch = await createSelect({
+			message: "Select the branch to diff",
+			options: createOptions(branches)
+		});
+		if (!selectedBranch) {
+			log.error("No branch selected. Aborting diff operation.");
+			return;
+		}
+		await handleDiff(selectedBranch, { isLocal: !options.remote });
+	});
+}
+
+//#endregion
+//#region src/commands/list.ts
+function listCommand(command) {
+	command.command("list").alias("ls").description("List git branches").option("-l, --local", "List local branches").option("-r, --remote", "List remote branches").option("-a, --all", "List all branches", true).action(async (options) => {
+		if (options.all) {
+			const { branches: localBranches, currentBranch } = await getLocalBranches();
+			const { branches: remoteBranches } = await getRemoteBranches();
+			if (!localBranches.length && !remoteBranches.length) {
+				log.error("No branches found. Please check your git repository.");
+				return;
+			}
+			log.show(`Local ${localBranches.length} branches`, {
+				symbol: "🔖",
+				colors: colors.bgGreen
+			});
+			for (const branch of localBranches) if (branch === currentBranch) log.show(`${branch}  (current)`, { type: "info" });
+			else log.show(branch, { type: "step" });
+			log.show(`Remote ${remoteBranches.length} branches`, {
+				symbol: "🔖",
+				colors: colors.bgYellow
+			});
+			for (const branch of remoteBranches) if (branch === currentBranch) log.show(`${branch}  (current)`, { type: "info" });
+			else log.show(branch, { type: "step" });
+		} else if (options.local) {
+			const { branches } = await getLocalBranches();
+			if (!branches || branches.length === 0) {
+				log.error("No local branches found. Please check your git repository.");
+				return;
+			}
+			log.info(`Found ${branches.length} local branches:`);
+			for (const branch of branches) log.info(branch);
+		} else {
+			const { branches } = await getRemoteBranches();
+			if (!branches || branches.length === 0) {
+				log.error("No remote branches found. Please check your git repository.");
+				return;
+			}
+			log.info(`Found ${branches.length} remote branches:`);
+			for (const branch of branches) log.info(branch);
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/merge.ts
+const handleMerge = async (branch) => {
+	const spinner = createSpinner(`Merging branch ${branch}...`);
+	const args = ["merge", branch];
+	const stashName = await handleGitStash();
+	const [error] = await xASync("git", args, { nodeOptions: { stdio: "inherit" } });
+	if (error) return;
+	spinner.stop(`Successfully merged branch ${branch}.`);
+	stashName && handleGitPop(stashName);
+};
+function mergeCommand(command) {
+	command.command("merge").alias("mg").argument("[branch]", "The branch to merge").option("-l, --local", "Merge a local branch").option("-r, --remote", "Merge a remote branch").option("-b, --branch <branch>", "Create and merge a new branch").description("Merge a branch").action(async (branch, params) => {
+		let isLocal = params.local;
+		if (branch) {
+			handleMerge(branch);
+			return;
+		}
+		if (isEmpty(params)) isLocal = await createSelect({
+			message: "Select the branch type",
+			options: [{
+				label: "Remote",
+				value: false
+			}, {
+				label: "Local",
+				value: true
+			}],
+			initialValue: false
+		});
+		if (isLocal) {
+			const { options } = await getLocalOptions();
+			handleMerge(await createSearch({
+				message: "Select the branch to merge",
+				options
+			}));
+		} else {
+			const { options } = await getRemoteOptions();
+			const selectedBranch = await createSearch({
+				message: "Select the branch to merge",
+				options
+			});
+			if (await createConfirm({ message: `Do you want to merge ${colors.bgRed(selectedBranch)}?` })) handleMerge(selectedBranch);
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/pull.ts
+function pullCommand(command) {
+	command.command("pull").alias("pl").description("Pull git branch").option("-r, --rebase", "Use rebase mode instead of merge").option("-m, --merge", "Use merge mode (default)").action(async (options) => {
+		const { options: branchOptions, currentBranch } = await getRemoteOptions();
+		if (!branchOptions.length) {
+			log.error("No branches found. Please check your git repository.");
+			return;
+		}
+		const selectedBranch = await createSelect({
+			message: "Select the branch to pull",
+			options: branchOptions,
+			initialValue: currentBranch
+		});
+		if (!selectedBranch) {
+			log.error("No branch selected. Aborting pull operation.");
+			return;
+		}
+		let useRebase = options.rebase === true;
+		if (!options.rebase && !options.merge) useRebase = await createSelect({
+			message: "Select pull mode",
+			options: [{
+				label: "Merge (default)",
+				value: "merge",
+				hint: "git pull origin <branch>"
+			}, {
+				label: "Rebase",
+				value: "rebase",
+				hint: "git pull --rebase origin <branch>"
+			}],
+			initialValue: "merge"
+		}) === "rebase";
+		const stashName = await handleGitStash();
+		await handleGitPull(selectedBranch, { rebase: useRebase });
+		stashName && handleGitPop(stashName);
+	});
+}
+
+//#endregion
+//#region src/constants/stash.ts
+const HELP_MESSAGE = {
+	main: createHelpExample("ng stash", "ng stash save \"work in progress\"", "ng stash ls", "ng stash pop", "ng stash drop"),
+	save: createHelpExample("ng stash save \"work in progress\""),
+	list: createHelpExample("ng stash ls"),
+	pop: createHelpExample("ng stash pop"),
+	drop: createHelpExample("ng stash drop")
+};
+
+//#endregion
+//#region src/commands/stash.ts
+var StashCommand = /* @__PURE__ */ function(StashCommand) {
+	StashCommand["POP"] = "pop";
+	StashCommand["LIST"] = "list";
+	StashCommand["SAVE"] = "save";
+	StashCommand["DROP"] = "drop";
+	return StashCommand;
+}(StashCommand || {});
+const handleCheck = (callback) => async () => {
+	const stashes = await handleGitStashCheck();
+	if (stashes.length === 0) {
+		log.show("No stash found.", { type: "error" });
+		return;
+	}
+	return callback(stashes);
+};
+/**
+* 获取 stash 中的文件列表
+* @param stashRef - stash 引用，如 "stash@{0}"
+*/
+const getStashFiles = async (stashRef) => {
+	const [error, result] = await xASync("git", [
+		"stash",
+		"show",
+		stashRef,
+		"--name-only"
+	], { quiet: true });
+	if (error) return [];
+	return result.stdout.split("\n").filter((line) => line.trim());
+};
+/**
+* 从 stash 条目中提取 stash 引用
+* @param stashEntry - 完整的 stash 条目，如 "stash@{0}: On main: message"
+*/
+const extractStashRef = (stashEntry) => {
+	const match = stashEntry.match(/^(stash@\{\d+\})/);
+	if (match?.[1]) return match[1];
+	return stashEntry.split(":")[0] ?? stashEntry;
+};
+const handlePop = handleCheck(async (stashes) => {
+	const selectedStashes = await createCheckbox({
+		message: "Select the stash to pop",
+		options: stashes.map((stash) => ({
+			label: stash,
+			value: stash
+		}))
+	});
+	for await (const stash of selectedStashes) {
+		const [error] = await xASync("git", [
+			"stash",
+			"pop",
+			extractStashRef(stash)
+		]);
+		if (error) log.show("Failed to pop stash.", { type: "error" });
+		else log.show("Successfully popped changes.", { type: "success" });
+	}
+});
+const handleList = handleCheck(async (stashes) => {
+	log.show(`\n${colors.bold(`📦 Found ${stashes.length} stash(es)`)}\n`);
+	for await (const stash of stashes) {
+		const files = await getStashFiles(extractStashRef(stash));
+		log.show(colors.cyan(`━━━ ${stash} ━━━`));
+		if (files.length > 0) {
+			log.show(colors.dim(`    ${files.length} file(s) changed:`));
+			for (const file of files) log.show(colors.yellow(`      • ${file}`));
+		} else log.show(colors.dim("    (no files)"));
+		log.show("");
+	}
+});
+const handleDrop = handleCheck(async (stashes) => {
+	const selectedStashes = await createCheckbox({
+		message: "Select the stash to clear",
+		options: createOptions(stashes)
+	});
+	for await (const stash of selectedStashes) {
+		const stashRef = extractStashRef(stash);
+		if (!stashRef) {
+			log.show("Invalid stash name.", { type: "error" });
+			exit(0);
+		}
+		const [error] = await xASync("git", [
+			"stash",
+			StashCommand.DROP,
+			stashRef
+		]);
+		if (error) log.show("Failed to drop stash.", { type: "error" });
+		else log.show(`Successfully dropped stash: ${stashRef}`, { type: "success" });
+	}
+});
+const handleClear = handleCheck(async () => {
+	const [error] = await xASync("git", ["stash", "clear"]);
+	if (error) log.show("Failed to clear stashes.", { type: "error" });
+	else log.show("Successfully cleared stashes.", { type: "success" });
+});
+const stashCommand = (command) => {
+	const stashCmd = command.command("stash").alias("st").description("Git stash management").addHelpText("after", HELP_MESSAGE.main);
+	stashCmd.command("save [message]").alias("s").description("Save current changes to stash").action(async (message) => {
+		await handleGitStash(message);
+	});
+	stashCmd.command("list").alias("ls").alias("l").description("List all stashes").action(async () => {
+		await handleList();
+	});
+	stashCmd.command("pop").alias("p").description("Pop the most recent stash").action(async () => {
+		await handlePop();
+	});
+	stashCmd.command("drop").alias("d").description("Drop/clear stashes").action(async () => {
+		await handleDrop();
+	});
+	stashCmd.command("clear").alias("c").description("clear stashes").action(async () => {
+		await handleClear();
+	});
+	return stashCmd;
+};
+
+//#endregion
+//#region src/index.ts
+const pkg = readPackage(import.meta, "..");
+const init = () => {
+	const command = createCommand("ng").version(pkg.version).description(`${pkg.name} CLI helper for git`).addHelpText("after", HELP_MESSAGE$1.main);
+	pullCommand(command);
+	listCommand(command);
+	pushCommand(command);
+	checkoutCommand(command);
+	branchCommand(command);
+	diffCommand(command);
+	mergeCommand(command);
+	stashCommand(command);
+	commitCommand(command);
+	return command;
+};
+const run = async () => {
+	if (!await checkGitRepository()) {
+		ErrorMessage({ text: "Not a git repository" });
+		exit(0);
+	}
+	init().parse(process.argv);
+};
+
+//#endregion
+export { init, pkg, run };
+//# sourceMappingURL=index.js.map