@nemo-cli/git 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,10 +1,220 @@
 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 { BigText, ErrorMessage, Message, renderHistViewer, renderStashList, renderStatusViewer } from "@nemo-cli/ui";
+import path, { dirname, join } from "node:path";
+import readline from "node:readline";
 import { spawn } from "node:child_process";
-import { unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 
+//#region src/commands/blame.ts
+const MAX_DIFF_LINES = 50;
+/**
+* Registers the 'ng blame' command for viewing file commit history with interactive navigation
+* @param command - The commander Command instance
+* @returns The modified command instance
+*/
+const blameCommand = (command) => {
+	command.command("blame [file]").description("View file commit history with interactive navigation").action(async (file) => {
+		if (!file) {
+			log.show("Please specify a file path.", { type: "error" });
+			return;
+		}
+		await handleBlame(file);
+	});
+	return command;
+};
+const commitCache = /* @__PURE__ */ new Map();
+/**
+* Finalizes a commit object from partial data
+* @param currentCommit - Partial commit data
+* @param diffLines - Array of diff lines
+* @returns Complete Commit object or null if invalid
+*/
+const finalizeCommit = (currentCommit, diffLines) => {
+	if (!currentCommit?.hash || !currentCommit.author || !currentCommit.message) return null;
+	return {
+		hash: currentCommit.hash,
+		author: currentCommit.author,
+		date: currentCommit.date ?? "",
+		message: currentCommit.message,
+		diff: diffLines.join("\n")
+	};
+};
+const handleBlame = async (filePath) => {
+	const resolvedPath = path.resolve(filePath);
+	const cwd = process.cwd();
+	if (!resolvedPath.startsWith(cwd + path.sep) && resolvedPath !== cwd) {
+		log.show("❌ Error: File path must be within current directory", { type: "error" });
+		return;
+	}
+	const [statError] = await xASync("test", ["-f", resolvedPath], { quiet: true });
+	if (statError) {
+		log.show(`❌ Error: File not found: ${filePath}`, { type: "error" });
+		return;
+	}
+	if (!commitCache.has(resolvedPath)) {
+		const [error, result] = await xASync("git", [
+			"log",
+			"--follow",
+			"-p",
+			`--pretty=format:%H%x00%an%x00%ad%x00%s`,
+			"--",
+			resolvedPath
+		]);
+		if (error) {
+			handleGitError(error, "git log");
+			return;
+		}
+		commitCache.set(resolvedPath, parseCommitsFromLog(result.stdout));
+	}
+	const commits = commitCache.get(resolvedPath);
+	if (commits.length === 0) {
+		log.show(`No git history found for ${filePath}`, { type: "warn" });
+		return;
+	}
+	log.show(colors.bold(`Found ${commits.length} commits for ${filePath}`));
+	log.show(colors.dim("Use [n/p] to navigate, [j] to jump, [q] to quit"));
+	await enterInteractiveBlameMode(resolvedPath, commits);
+};
+/**
+* Parses git log output into structured Commit objects
+* @param logOutput - Raw git log output with null separators
+* @returns Array of parsed Commit objects
+*/
+const parseCommitsFromLog = (logOutput) => {
+	const commits = [];
+	const lines = logOutput.split("\n");
+	let currentCommit = null;
+	let diffLines = [];
+	for (const line of lines) if (line.includes("\0")) {
+		const finalized = finalizeCommit(currentCommit, diffLines);
+		if (finalized) commits.push(finalized);
+		const [hash, author, date, message] = line.split("\0");
+		if (hash && hash.length >= 8) {
+			currentCommit = {
+				hash: hash.substring(0, 8),
+				author: author?.trim() ?? "",
+				date: date?.trim() ?? "",
+				message: message?.trim() ?? ""
+			};
+			diffLines = [];
+		}
+	} else if (currentCommit) diffLines.push(line);
+	const finalized = finalizeCommit(currentCommit, diffLines);
+	if (finalized) commits.push(finalized);
+	return commits;
+};
+const showCommit = (commit, index, total) => {
+	log.clearScreen();
+	log.show(`📝 Commit ${index}/${total}`);
+	log.show(`${colors.cyan(commit.hash)} - ${colors.yellow(commit.author)} - ${colors.dim(commit.date)}`);
+	log.show(`${commit.message}`);
+	log.show(colors.bold("--- Diff ---"));
+	if (commit.diff.includes("Binary files differ")) {
+		log.show("📄 Binary file - diff not available");
+		log.show(commit.diff);
+	} else {
+		const diffLines = commit.diff.split("\n");
+		if (diffLines.length > MAX_DIFF_LINES) {
+			log.show(colors.dim(`(Showing first ${MAX_DIFF_LINES} lines of ${diffLines.length})`));
+			log.show(diffLines.slice(0, MAX_DIFF_LINES).join("\n"));
+			log.show(colors.dim("\n... (truncated)"));
+		} else log.show(commit.diff);
+	}
+	log.show(colors.bold("\n--- Actions ---"));
+	log.show("[n] Next commit [p] Previous commit [j] Jump [q] Quit");
+};
+const enterInteractiveBlameMode = async (filePath, commits) => {
+	if (commits.length === 0) {
+		log.show("No commits to display", { type: "warn" });
+		return;
+	}
+	let currentIndex = 0;
+	while (true) {
+		const currentCommit = commits[currentIndex];
+		if (!currentCommit) break;
+		await showCommit(currentCommit, currentIndex + 1, commits.length);
+		let input;
+		try {
+			input = await createCheckbox({
+				message: "Enter action:",
+				options: [
+					{
+						label: currentIndex < commits.length - 1 ? "Next commit" : "Next commit (already at latest)",
+						value: "n"
+					},
+					{
+						label: currentIndex > 0 ? "Previous commit" : "Previous commit (already at earliest)",
+						value: "p"
+					},
+					{
+						label: "Jump to commit",
+						value: "j"
+					},
+					{
+						label: "Quit",
+						value: "q"
+					}
+				]
+			});
+		} catch (error) {
+			log.show("Error reading input. Exiting...", { type: "error" });
+			return;
+		}
+		if (!input || input.length === 0) {
+			log.show("No input received. Exiting...", { type: "warn" });
+			break;
+		}
+		if (input[0] === "q") exit(0);
+		if (input[0] === "n" && currentIndex < commits.length - 1) currentIndex++;
+		else if (input[0] === "p" && currentIndex > 0) currentIndex--;
+		else if (input[0] === "j") {
+			log.show(`\nEnter commit number (1-${commits.length}):`);
+			const jumpInput = await readUserInput();
+			const jumpNum = Number.parseInt(jumpInput, 10);
+			if (!isNaN(jumpNum) && jumpNum >= 1 && jumpNum <= commits.length) currentIndex = jumpNum - 1;
+			else {
+				log.show(`Invalid number. Please enter 1-${commits.length}`, { type: "error" });
+				await new Promise((resolve) => setTimeout(resolve, 1500));
+			}
+		}
+	}
+};
+const readUserInput = () => {
+	return new Promise((resolve) => {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		const cleanup = () => {
+			rl.close();
+			rl.removeAllListeners();
+		};
+		rl.on("SIGINT", () => {
+			cleanup();
+			exit(0);
+		});
+		rl.question("", (answer) => {
+			cleanup();
+			resolve(answer.trim());
+		});
+	});
+};
+const handleGitError = (error, context) => {
+	const errorMessage = error.message || String(error);
+	if (errorMessage.includes("not a git repository")) {
+		log.show("❌ Error: Not in a git repository", { type: "error" });
+		return;
+	}
+	if (errorMessage.includes("does not exist") || errorMessage.includes("no such file")) {
+		log.show("❌ Error: File not found", { type: "error" });
+		return;
+	}
+	log.show(`❌ Error: ${errorMessage}`, { type: "error" });
+};
+
+//#endregion
 //#region src/constants/index.ts
 const HELP_MESSAGE$1 = {
 	main: createHelpExample("ng --version", "ng --help", "ng <command> [option]"),
@@ -13,9 +223,142 @@ const HELP_MESSAGE$1 = {
 	branchClean: createHelpExample("ng branch clean --version", "ng branch clean --help")
 };
 
+//#endregion
+//#region src/utils/stash-index.ts
+/**
+* Stash 索引文件路径
+*/
+const STASH_INDEX_FILENAME = "ng-stash-index.json";
+/**
+* 获取 Stash 索引文件的完整路径
+* @returns Stash 索引文件路径，如果不在 Git 仓库中则返回 null
+*/
+async function getStashIndexPath() {
+	const gitRoot = await getGitRoot();
+	if (!gitRoot) return null;
+	return join(gitRoot, ".git", STASH_INDEX_FILENAME);
+}
+/**
+* 读取 Stash 索引文件
+* @returns Stash 索引对象，如果文件不存在或读取失败则返回空对象
+*/
+async function readStashIndex() {
+	const indexPath = await getStashIndexPath();
+	if (!indexPath) {
+		log.show("Not in a Git repository. Cannot read stash index.", { type: "error" });
+		return {};
+	}
+	try {
+		const content = await readFile(indexPath, "utf-8");
+		const index = JSON.parse(content);
+		if (typeof index !== "object" || index === null || Array.isArray(index)) throw new Error("Invalid stash index format: expected an object");
+		for (const [branchName, stashes] of Object.entries(index)) {
+			if (!Array.isArray(stashes)) throw new Error(`Invalid stash index format: branch "${branchName}" should have an array of stashes`);
+			for (const stash of stashes) if (typeof stash.stashRef !== "string" || typeof stash.timestamp !== "string" || typeof stash.createdAt !== "string" || typeof stash.message !== "string") throw new Error(`Invalid stash index format: stash metadata for branch "${branchName}" is missing required fields`);
+		}
+		return index;
+	} catch (error) {
+		const err = error;
+		if (err.code === "ENOENT") return {};
+		if (err instanceof SyntaxError) {
+			log.show(`Failed to parse stash index file: ${err.message}. The file may be corrupted.`, { type: "error" });
+			return {};
+		}
+		log.show(`Failed to read stash index file: ${err.message}`, { type: "error" });
+		return {};
+	}
+}
+/**
+* 写入 Stash 索引文件
+* @param index - Stash 索引对象
+* @throws 如果写入失败会抛出错误
+*/
+async function writeStashIndex(index) {
+	const indexPath = await getStashIndexPath();
+	if (!indexPath) throw new Error("Not in a Git repository. Cannot write stash index.");
+	try {
+		await mkdir(dirname(indexPath), { recursive: true });
+		await writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+	} catch (error) {
+		const err = error;
+		log.show(`Failed to write stash index file: ${err.message}`, { type: "error" });
+		throw new Error(`Failed to write stash index: ${err.message}`);
+	}
+}
+/**
+* 获取分支的所有 Stash 元数据
+* @param branchName - 分支名称
+* @returns Stash 元数据数组，如果分支不存在则返回空数组
+*/
+async function getBranchStashes(branchName) {
+	return (await readStashIndex())[branchName] ?? [];
+}
+async function addStashMetadataWithDetails(branchName, metadata) {
+	const index = await readStashIndex();
+	if (!index[branchName]) index[branchName] = [];
+	index[branchName].push(metadata);
+	const indexPath = await getStashIndexPath();
+	if (!indexPath) throw new Error("Not in a Git repository");
+	const tmpPath = `${indexPath}.tmp.${Date.now()}`;
+	await mkdir(dirname(indexPath), { recursive: true });
+	await writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
+	try {
+		await rename(tmpPath, indexPath);
+	} catch (renameError) {
+		const err = renameError;
+		if (err.code === "EACCES" || err.code === "EBUSY" || err.code === "ENOENT") for (let i = 0; i < 3; i++) {
+			await new Promise((resolve) => setTimeout(resolve, 100));
+			try {
+				await rename(tmpPath, indexPath);
+				return;
+			} catch {
+				if (i === 2) throw new Error(`Failed to write stash index after 3 retries: ${err.message}`);
+			}
+		}
+		else throw err;
+	}
+}
+async function updateStashStatus(branchName, internalId, status, error) {
+	const index = await readStashIndex();
+	if (!index[branchName]) return;
+	const stash = index[branchName].find((s) => s.internalId === internalId);
+	if (!stash) return;
+	stash.status = status;
+	if (error) stash.error = error;
+	await writeStashIndex(index);
+}
+async function cleanOldStashes(days = 30) {
+	const index = await readStashIndex();
+	const cutoffDate = Date.now() - days * 24 * 60 * 60 * 1e3;
+	let count = 0;
+	for (const [branchName, stashes] of Object.entries(index)) {
+		const before = stashes.length;
+		index[branchName] = stashes.filter((stash) => {
+			if (stash.status === "active") return true;
+			return new Date(stash.timestamp).getTime() >= cutoffDate;
+		});
+		count += before - index[branchName].length;
+		if (index[branchName].length === 0) delete index[branchName];
+	}
+	await writeStashIndex(index);
+	return count;
+}
+async function getAllStashes(filterStatus) {
+	const index = await readStashIndex();
+	const allStashes = [];
+	for (const stashes of Object.values(index)) allStashes.push(...stashes);
+	if (filterStatus) return allStashes.filter((s) => s.status === filterStatus);
+	return allStashes;
+}
+
 //#endregion
 //#region src/utils.ts
 const remotePrefix = /^origin\//;
+const getRemotes = async () => {
+	const [error, result] = await xASync("git", ["remote"]);
+	if (error) throw new Error(`Failed to get remote repositories: ${error instanceof Error ? error.message : String(error)}`);
+	return { remotes: result.stdout.split("\n").filter((line) => line.trim()) };
+};
 const getRemoteBranches = async () => {
 	return { branches: (await x("git", [
 		"branch",
@@ -56,6 +399,18 @@ const getLocalOptions = async () => {
 		currentBranch
 	};
 };
+const getRemoteOptionsForRemotes = async () => {
+	const { remotes } = await getRemotes();
+	const validRemotes = remotes.filter((remote) => remote.trim().length > 0);
+	const uniqueRemotes = Array.from(new Set(validRemotes));
+	return {
+		options: uniqueRemotes.map((remote) => ({
+			label: remote,
+			value: remote
+		})),
+		remotes: uniqueRemotes
+	};
+};
 /**
 * 处理合并提交信息
 */
@@ -164,30 +519,100 @@ const handleGitPull = async (branch, options = {}) => {
 		return;
 	}
 };
-const createStashName = () => `NEMO-CLI-STASH:${Date.now()}`;
-const handleGitStash = async (name = createStashName()) => {
+const handleGitStash = async (message, options) => {
+	const [unstagedError, unstagedResult] = await xASync("git", ["diff", "--name-only"]);
+	const unstagedFiles = unstagedError ? [] : unstagedResult.stdout.split("\n").filter(Boolean);
+	const [stagedError, stagedResult] = await xASync("git", [
+		"diff",
+		"--cached",
+		"--name-only"
+	]);
+	const stagedFiles = stagedError ? [] : stagedResult.stdout.split("\n").filter(Boolean);
+	const [untrackedError, untrackedResult] = await xASync("git", [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	]);
+	const untrackedFiles = untrackedError ? [] : untrackedResult.stdout.split("\n").filter(Boolean);
+	const files = [...new Set([
+		...unstagedFiles,
+		...stagedFiles,
+		...untrackedFiles
+	])];
+	if (files.length === 0) {
+		log.show("No file changes to stash.");
+		return null;
+	}
+	const [, commitResult] = await xASync("git", ["rev-parse", "HEAD"]);
+	const commitHash = commitResult?.stdout.trim() || "";
+	const currentBranch = await getCurrentBranch();
+	const { branch = void 0, operation = "manual" } = options || {};
+	const now = /* @__PURE__ */ new Date();
+	let stashName;
+	if (message && message.trim()) stashName = message.trim();
+	else stashName = `${operation}:${currentBranch}@${now.toISOString().replace(/[:.]/g, "-").slice(0, 19)}`;
+	const internalId = `${Date.now()}_${operation}_${currentBranch.replace(/[/]/g, "_")}`;
 	const [error, result] = await xASync("git", [
 		"stash",
 		"save",
-		name
+		"-u",
+		stashName
 	]);
 	if (error) {
-		log.show(`Failed to stash changes. ${name}`, { type: "error" });
+		log.show(`Failed to stash changes. ${stashName}`, { type: "error" });
 		return null;
 	}
-	if (result?.stdout.includes(name)) {
-		log.show(`Successfully stashed changes. ${name}`, { type: "success" });
-		return name;
+	if (!result?.stdout.includes(stashName)) {
+		log.show("No file changes to stash.");
+		return null;
 	}
-	log.show("No file changes.");
-	return null;
+	const stashRefMatch = result.stdout.match(/stash@\{(\d+)\}/);
+	const metadata = {
+		stashRef: stashRefMatch ? stashRefMatch[0] : "stash@{0}",
+		timestamp: now.toISOString(),
+		createdAt: now.toISOString(),
+		message: stashName,
+		internalId,
+		operation,
+		currentBranch,
+		targetBranch: branch,
+		files,
+		status: "active",
+		commitHash
+	};
+	await addStashMetadataWithDetails(currentBranch, metadata);
+	log.show(`Successfully stashed changes. ${stashName}`, { type: "success" });
+	return {
+		metadata,
+		stashName
+	};
 };
 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 handleGitPop = async (stashOrResult) => {
+	if (typeof stashOrResult !== "string") {
+		const { metadata } = stashOrResult;
+		const [error, result] = await xASync("git", [
+			"stash",
+			"pop",
+			metadata.stashRef
+		]);
+		if (error) {
+			log.show(`Failed to pop stash: ${error.message}`, { type: "error" });
+			if (metadata.internalId && metadata.currentBranch) await updateStashStatus(metadata.currentBranch, metadata.internalId, "popped", error.message);
+			return;
+		}
+		createNote({
+			message: result.stdout,
+			title: "Successfully popped changes."
+		});
+		if (metadata.internalId && metadata.currentBranch) await updateStashStatus(metadata.currentBranch, metadata.internalId, "popped");
+		return;
+	}
+	const branch = stashOrResult;
 	const stashName = (await handleGitStashCheck()).find((stash) => stash.includes(branch));
 	if (!stashName) {
 		log.show(`No stash found for this branch: ${colors.bgRed(branch)}.`, { type: "warn" });
@@ -231,12 +656,17 @@ const isBranchMergedToMain = async (branches) => {
 		};
 	}));
 };
+const getGitRoot = async () => {
+	const [error, result] = await xASync("git", ["rev-parse", "--show-toplevel"]);
+	if (error) return "";
+	return 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) {
+	} catch (_err) {
 		return false;
 	}
 };
@@ -373,20 +803,46 @@ function branchCommand(command) {
 
 //#endregion
 //#region src/commands/checkout.ts
+/**
+* 查找并恢复当前分支的 stash
+* 当用户 checkout 回之前的分支时，自动恢复该分支的 stash
+*/
+const restoreBranchStash = async (branchName) => {
+	try {
+		const activeStashes = (await getBranchStashes(branchName)).filter((s) => s.status === "active" && s.operation === "checkout").sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+		if (activeStashes.length === 0) return;
+		const latestStash = activeStashes[0];
+		if (!latestStash) return;
+		log.show(`Found stashed changes from previous checkout to ${colors.bgYellow(latestStash.targetBranch || "unknown")}. Restoring...`, { type: "info" });
+		await handleGitPop({
+			metadata: latestStash,
+			stashName: latestStash.message
+		});
+	} catch (_error) {
+		log.show(`Failed to restore stash for branch ${branchName}`, { type: "warn" });
+	}
+};
 const handleCheckout = async (branch, { isNew = false, isRemote = false } = {}) => {
+	const currentBranchName = await getCurrentBranch();
 	const args = ["checkout"];
 	if (isNew || isRemote) args.push("-b");
 	args.push(branch);
 	if (isRemote) args.push(`origin/${branch}`);
-	const stashName = await handleGitStash(branch);
+	const stashResult = branch !== currentBranchName ? await handleGitStash(void 0, {
+		branch,
+		operation: "checkout"
+	}) : null;
 	const process = x("git", args);
+	log.show(stashResult?.stashName, { type: "info" });
 	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);
+	} else {
+		log.show(`Successfully checked out branch ${branch}.`, { type: "success" });
+		await restoreBranchStash(branch);
+	}
 };
 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) => {
@@ -581,7 +1037,7 @@ const commitlintConfig = {
 };
 const mergeCommitTypeEnumOptions = (options) => {
 	return options.map((option) => {
-		const commitTypeOption = commitTypeOptions.find((commitTypeOption$1) => commitTypeOption$1.value === option);
+		const commitTypeOption = commitTypeOptions.find((commitTypeOption) => commitTypeOption.value === option);
 		return {
 			value: commitTypeOption?.value ?? option,
 			label: commitTypeOption?.label ?? option,
@@ -593,7 +1049,7 @@ const mergeCommitTypeEnumOptions = (options) => {
 };
 const mergeCommitScopeEnumOptions = (options) => {
 	return (options.includes("none") ? options : options.concat("none")).map((option) => {
-		const commitScopeOption = commitScopeOptions.find((commitScopeOption$1) => commitScopeOption$1.label === option);
+		const commitScopeOption = commitScopeOptions.find((commitScopeOption) => commitScopeOption.label === option);
 		return {
 			value: commitScopeOption?.value ?? option,
 			label: commitScopeOption?.label ?? option
@@ -603,21 +1059,22 @@ const mergeCommitScopeEnumOptions = (options) => {
 
 //#endregion
 //#region src/commands/push.ts
-const handlePush = async (branch) => {
-	const spinner = createSpinner(`Pushing branch ${branch} to remote...`);
+const handlePush = async (branch, remote = "origin") => {
+	const spinner = createSpinner(`Pushing branch ${branch} to ${remote}...`);
 	try {
-		const process = x("git", [
+		const [error, result] = await xASync("git", [
 			"push",
-			"origin",
+			remote,
 			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.`));
+		if (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			throw new Error(`Failed with error: ${errorMessage}`);
+		}
+		spinner.stop(colors.green(`Successfully pushed branch ${colors.bgGreen(branch)} to ${remote}.`));
 	} catch (error) {
 		spinner.stop();
-		BigText({ text: `Failed to push branch ${branch}.` });
+		BigText({ text: `Failed to push branch ${branch} to ${remote}.` });
 		log.error(error);
 	}
 };
@@ -632,16 +1089,50 @@ const pushInteractive = async () => {
 		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);
+	let remotes;
+	try {
+		remotes = (await getRemoteOptionsForRemotes()).remotes;
+	} catch (error) {
+		log.error(`Failed to get remote repositories: ${error instanceof Error ? error.message : String(error)}`);
+		log.show("Hint: Make sure you're in a git repository and have configured remotes.", { type: "info" });
+		return;
+	}
+	if (remotes.length === 0) {
+		log.error("No remote repositories found. Aborting push operation.");
+		log.show("Hint: Run `git remote add <name> <url>` to add a remote repository.", { type: "info" });
+		return;
+	}
+	let selectedRemote = remotes[0];
+	if (remotes.length > 1) selectedRemote = await createSelect({
+		message: "Select remote repository",
+		options: remotes.map((remote) => ({
+			label: remote,
+			value: remote
+		})),
+		initialValue: remotes[0]
+	});
+	if (await createConfirm({ message: `Do you want to push ${colors.bgGreen(currentBranch)} to ${selectedRemote}?` })) {
+		await handlePush(currentBranch, selectedRemote);
 		return;
 	}
 	const { options } = await getRemoteOptions();
-	await handlePush(await createSelect({
+	const selectedBranch = await createSelect({
 		message: "Select the branch to push",
 		options,
 		initialValue: "main"
-	}));
+	});
+	let pushRemote = selectedRemote;
+	if (remotes.length > 1) {
+		if (!await createConfirm({ message: `Push ${colors.bgGreen(selectedBranch)} to ${selectedRemote}?` })) pushRemote = await createSelect({
+			message: "Select remote repository",
+			options: remotes.map((remote) => ({
+				label: remote,
+				value: remote
+			})),
+			initialValue: selectedRemote
+		});
+	}
+	await handlePush(selectedBranch, pushRemote);
 };
 
 //#endregion
@@ -765,6 +1256,459 @@ const getTicket = async () => {
 	return branch;
 };
 
+//#endregion
+//#region src/commands/config.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: need any */
+const GITCONFIG_PATH = join(homedir(), ".gitconfig");
+const readGitConfig = () => {
+	try {
+		const content = readFileSync(GITCONFIG_PATH, "utf-8");
+		const config = {};
+		let currentSection = null;
+		let subsection = null;
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+			if (sectionMatch) {
+				currentSection = sectionMatch[1] || null;
+				subsection = null;
+				if (currentSection && !config[currentSection]) config[currentSection] = {};
+				continue;
+			}
+			const subsectionMatch = trimmed.match(/^\[([^\s]+) "([^"]+)"\]$/);
+			if (subsectionMatch) {
+				currentSection = subsectionMatch[1] || null;
+				subsection = subsectionMatch[2] || null;
+				if (currentSection && !config[currentSection]) config[currentSection] = {};
+				if (subsection && currentSection && typeof config[currentSection] === "object") {
+					if (!config[currentSection][subsection]) config[currentSection][subsection] = {};
+				}
+				continue;
+			}
+			const keyValueMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+			if (keyValueMatch && currentSection) {
+				const key = keyValueMatch[1];
+				const value = keyValueMatch[2];
+				let target = config[currentSection];
+				if (subsection && typeof target === "object") {
+					if (!target[subsection]) target[subsection] = {};
+					target = target[subsection];
+				}
+				if (key && value === "true") target[key] = true;
+				else if (key && value === "false") target[key] = false;
+				else if (key) target[key] = value;
+			}
+		}
+		return config;
+	} catch {
+		return {};
+	}
+};
+const writeGitConfig = (config) => {
+	const lines = [];
+	const sections = Object.keys(config).sort();
+	for (const section of sections) {
+		const value = config[section];
+		if (!value || typeof value !== "object") continue;
+		if (Object.keys(value).length === 0) continue;
+		let isSubsection = false;
+		for (const key of Object.keys(value)) if (typeof value[key] === "object" && key !== "alias") {
+			isSubsection = true;
+			break;
+		}
+		if (isSubsection) for (const [subsection, subValue] of Object.entries(value)) {
+			if (typeof subValue !== "object" || subValue === null) continue;
+			lines.push(`[${section} "${subsection}"]`);
+			for (const [key, val] of Object.entries(subValue)) lines.push(`\t${key} = ${val}`);
+			lines.push("");
+		}
+		else {
+			lines.push(`[${section}]`);
+			for (const [key, val] of Object.entries(value)) if (typeof val === "object" && val !== null) for (const [subKey, subVal] of Object.entries(val)) lines.push(`\t${subKey} = ${subVal}`);
+			else lines.push(`\t${key} = ${val}`);
+			lines.push("");
+		}
+	}
+	writeFileSync(GITCONFIG_PATH, lines.join("\n"), "utf-8");
+};
+const displayConfig = (config) => {
+	const lines = [];
+	if (config.user) {
+		lines.push("👤 User Information:");
+		if (config.user.name) lines.push(`  Name: ${config.user.name}`);
+		if (config.user.email) lines.push(`  Email: ${config.user.email}`);
+		lines.push("");
+	}
+	if (config.init?.defaultBranch) {
+		lines.push("🌳 Initial Branch:");
+		lines.push(`  Default: ${config.init.defaultBranch}`);
+		lines.push("");
+	}
+	if (config.pull) {
+		lines.push("📥 Pull Strategy:");
+		if (config.pull.rebase !== void 0) lines.push(`  Rebase: ${config.pull.rebase}`);
+		lines.push("");
+	}
+	if (config.push) {
+		lines.push("📤 Push Strategy:");
+		if (config.push.default) lines.push(`  Default: ${config.push.default}`);
+		if (config.push.autoSetupRemote !== void 0) lines.push(`  Auto Setup Remote: ${config.push.autoSetupRemote}`);
+		lines.push("");
+	}
+	if (config.color) {
+		lines.push("🎨 Color:");
+		if (config.color.ui !== void 0) lines.push(`  UI: ${config.color.ui}`);
+		lines.push("");
+	}
+	if (config.alias && Object.keys(config.alias).length > 0) {
+		lines.push("⚡ Aliases:");
+		for (const [alias, command] of Object.entries(config.alias)) lines.push(`  ${alias} = ${String(command)}`);
+		lines.push("");
+	}
+	return lines.join("\n");
+};
+const configureUserInfo = async (config) => {
+	const action = await createSelect({
+		message: "What would you like to configure?",
+		options: [
+			{
+				label: "Name",
+				value: "name"
+			},
+			{
+				label: "Email",
+				value: "email"
+			},
+			{
+				label: "Both",
+				value: "both"
+			}
+		]
+	});
+	if (action === "name" || action === "both") {
+		const name = await createInput({
+			message: "Enter your name:",
+			initialValue: config.user?.name || "",
+			placeholder: config.user?.name || "Your name"
+		});
+		if (!config.user) config.user = {};
+		config.user.name = name || config.user.name;
+	}
+	if (action === "email" || action === "both") {
+		const email = await createInput({
+			message: "Enter your email:",
+			initialValue: config.user?.email || "",
+			placeholder: config.user?.email || "your@email.com"
+		});
+		if (!config.user) config.user = {};
+		config.user.email = email || config.user.email;
+	}
+	return config;
+};
+const configureCommonOptions = async (config) => {
+	const options = await createCheckbox({
+		message: "Select options to configure:",
+		options: [
+			{
+				label: "Default branch name",
+				value: "defaultBranch"
+			},
+			{
+				label: "Pull rebase strategy",
+				value: "pullRebase"
+			},
+			{
+				label: "Push default strategy",
+				value: "pushDefault"
+			},
+			{
+				label: "Enable color output",
+				value: "colorUi"
+			},
+			{
+				label: "Auto stash on rebase",
+				value: "autoStash"
+			}
+		],
+		required: false
+	});
+	for (const option of options) switch (option) {
+		case "defaultBranch": {
+			const branch = await createInput({
+				message: "Enter default branch name:",
+				initialValue: config.init?.defaultBranch || "main",
+				placeholder: "main"
+			});
+			if (!config.init) config.init = {};
+			config.init.defaultBranch = branch || config.init.defaultBranch || "main";
+			break;
+		}
+		case "pullRebase": {
+			const rebase = await createSelect({
+				message: "Select pull rebase strategy:",
+				options: [
+					{
+						label: "False (merge)",
+						value: "false"
+					},
+					{
+						label: "True (rebase)",
+						value: "true"
+					},
+					{
+						label: "Interactive",
+						value: "interactive"
+					}
+				]
+			});
+			if (!config.pull) config.pull = {};
+			config.pull.rebase = rebase === "false" ? false : rebase;
+			break;
+		}
+		case "pushDefault": {
+			const pushDefault = await createSelect({
+				message: "Select push default strategy:",
+				options: [
+					{
+						label: "current",
+						value: "current"
+					},
+					{
+						label: "upstream",
+						value: "upstream"
+					},
+					{
+						label: "simple",
+						value: "simple"
+					},
+					{
+						label: "matching",
+						value: "matching"
+					}
+				]
+			});
+			if (!config.push) config.push = {};
+			config.push.default = pushDefault;
+			break;
+		}
+		case "colorUi": {
+			const color = await createSelect({
+				message: "Select color output:",
+				options: [
+					{
+						label: "Auto",
+						value: "auto"
+					},
+					{
+						label: "Always",
+						value: "always"
+					},
+					{
+						label: "Never",
+						value: "false"
+					}
+				]
+			});
+			if (!config.color) config.color = {};
+			config.color.ui = color === "false" ? false : color;
+			break;
+		}
+		case "autoStash": {
+			const autoStash = await createConfirm({
+				message: "Enable auto stash on rebase?",
+				initialValue: config.rebase?.autoStash === true
+			});
+			if (!config.rebase) config.rebase = {};
+			config.rebase.autoStash = autoStash;
+			break;
+		}
+	}
+	return config;
+};
+const configureAliases = async (config) => {
+	const action = await createSelect({
+		message: "What would you like to do?",
+		options: [
+			{
+				label: "Add new alias",
+				value: "add"
+			},
+			{
+				label: "Remove alias",
+				value: "remove"
+			},
+			{
+				label: "List all aliases",
+				value: "list"
+			}
+		]
+	});
+	if (action === "add") {
+		const alias = await createInput({
+			message: "Enter alias name:",
+			initialValue: "",
+			placeholder: "st"
+		});
+		const command = await createInput({
+			message: "Enter git command:",
+			initialValue: "",
+			placeholder: "status"
+		});
+		if (!alias || !command) {
+			Message({ text: "Alias name and command cannot be empty." });
+			return config;
+		}
+		if (!config.alias) config.alias = {};
+		config.alias[alias] = command;
+		Message({ text: `Added alias: ${alias} = ${command}` });
+	} else if (action === "remove") {
+		if (!config.alias || Object.keys(config.alias).length === 0) {
+			Message({ text: "No aliases to remove." });
+			return config;
+		}
+		const toRemove = await createSelect({
+			message: "Select alias to remove:",
+			options: Object.keys(config.alias).map((key) => ({
+				label: `${key} = ${config.alias[key]}`,
+				value: key
+			}))
+		});
+		delete config.alias[toRemove];
+		Message({ text: `Removed alias: ${toRemove}` });
+	} else if (action === "list") if (!config.alias || Object.keys(config.alias).length === 0) Message({ text: "No aliases configured." });
+	else {
+		const aliasList = Object.entries(config.alias).map(([alias, command]) => `${alias} = ${command}`).join("\n");
+		log.show(aliasList, { type: "info" });
+	}
+	return config;
+};
+const initializeConfig = async (config) => {
+	Message({ text: "🚀 Let's set up your git configuration!" });
+	const name = await createInput({
+		message: "What is your name?",
+		initialValue: config.user?.name || "",
+		placeholder: "GaoZimeng"
+	});
+	if (name) {
+		if (!config.user) config.user = {};
+		config.user.name = name;
+	}
+	const email = await createInput({
+		message: "What is your email?",
+		initialValue: config.user?.email || "",
+		placeholder: "your@email.com"
+	});
+	if (email) {
+		if (!config.user) config.user = {};
+		config.user.email = email;
+	}
+	const defaultBranch = await createInput({
+		message: "What should be the default branch name?",
+		initialValue: config.init?.defaultBranch || "main",
+		placeholder: "main"
+	});
+	if (defaultBranch) {
+		if (!config.init) config.init = {};
+		config.init.defaultBranch = defaultBranch;
+	}
+	const enableColor = await createConfirm({
+		message: "Enable colored output?",
+		initialValue: config.color?.ui !== false
+	});
+	if (!config.color) config.color = {};
+	config.color.ui = enableColor ? "auto" : false;
+	const autoSetupRemote = await createConfirm({
+		message: "Automatically setup remote branch when pushing?",
+		initialValue: config.push?.autoSetupRemote !== false
+	});
+	if (!config.push) config.push = {};
+	config.push.autoSetupRemote = autoSetupRemote;
+	const autoStash = await createConfirm({
+		message: "Auto stash before rebase?",
+		initialValue: config.rebase?.autoStash !== false
+	});
+	if (!config.rebase) config.rebase = {};
+	config.rebase.autoStash = autoStash;
+	return config;
+};
+const configCommand = (command) => {
+	const subCommand = command.command("config").description("Interactive git configuration manager");
+	subCommand.command("init").description("Quick setup basic git configuration").action(async () => {
+		const updatedConfig = await initializeConfig(readGitConfig());
+		const spinner = createSpinner("Saving configuration...");
+		writeGitConfig(updatedConfig);
+		spinner.stop("✓ Git configuration initialized successfully!");
+		const display = displayConfig(updatedConfig);
+		if (display) log.show(`\n${display}`);
+	});
+	subCommand.action(async () => {
+		let continueRunning = true;
+		while (continueRunning) {
+			const action = await createSelect({
+				message: "What would you like to do?",
+				options: [
+					{
+						label: "📖 View current config",
+						value: "view"
+					},
+					{
+						label: "👤 Configure user info",
+						value: "user"
+					},
+					{
+						label: "⚙️  Configure options",
+						value: "options"
+					},
+					{
+						label: "⚡ Manage aliases",
+						value: "aliases"
+					},
+					{
+						label: "🧹 Clear all config",
+						value: "clear"
+					},
+					{
+						label: "❌ Exit",
+						value: "exit"
+					}
+				]
+			});
+			if (action === "exit") {
+				continueRunning = false;
+				continue;
+			}
+			if (action === "view") {
+				const display = displayConfig(readGitConfig());
+				if (display) log.show(`\n${display}`);
+				else Message({ text: "No configuration found." });
+			} else if (action === "user") {
+				const updatedConfig = await configureUserInfo(readGitConfig());
+				const spinner = createSpinner("Saving configuration...");
+				writeGitConfig(updatedConfig);
+				spinner.stop("✓ Configuration saved successfully!");
+			} else if (action === "options") {
+				const updatedConfig = await configureCommonOptions(readGitConfig());
+				const spinner = createSpinner("Saving configuration...");
+				writeGitConfig(updatedConfig);
+				spinner.stop("✓ Configuration saved successfully!");
+			} else if (action === "aliases") {
+				const updatedConfig = await configureAliases(readGitConfig());
+				const spinner = createSpinner("Saving configuration...");
+				writeGitConfig(updatedConfig);
+				spinner.stop("✓ Configuration saved successfully!");
+			} else if (action === "clear") {
+				if (await createConfirm({ message: "Are you sure you want to clear all git configuration?" })) {
+					const spinner = createSpinner("Clearing configuration...");
+					writeGitConfig({});
+					spinner.stop("✓ Configuration cleared successfully!");
+				}
+			}
+		}
+	});
+	return command;
+};
+
 //#endregion
 //#region src/commands/diff.ts
 const handleDiff = async (branch, { isLocal }) => {
@@ -807,6 +1751,15 @@ function diffCommand(command) {
 	});
 }
 
+//#endregion
+//#region src/commands/hist.ts
+const histCommand = (command) => {
+	command.command("hist").alias("history").description("Show git history with beautiful graph format").option("-n, --number <count>", "Limit number of commits to show").action(async (options) => {
+		await renderHistViewer(options.number ? Number.parseInt(options.number, 10) : void 0);
+	});
+	return command;
+};
+
 //#endregion
 //#region src/commands/list.ts
 function listCommand(command) {
@@ -855,11 +1808,17 @@ function listCommand(command) {
 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);
+	const stashResult = await handleGitStash(void 0, {
+		branch,
+		operation: "merge"
+	});
+	try {
+		const [error] = await xASync("git", args, { nodeOptions: { stdio: "inherit" } });
+		if (error) log.show(`Failed to merge branch ${branch}.`, { type: "error" });
+		else spinner.stop(`Successfully merged branch ${branch}.`);
+	} finally {
+		stashResult && handleGitPop(stashResult);
+	}
 };
 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) => {
@@ -928,16 +1887,19 @@ function pullCommand(command) {
 			}],
 			initialValue: "merge"
 		}) === "rebase";
-		const stashName = await handleGitStash();
+		const stashResult = await handleGitStash(void 0, {
+			branch: selectedBranch,
+			operation: "pull"
+		});
 		await handleGitPull(selectedBranch, { rebase: useRebase });
-		stashName && handleGitPop(stashName);
+		stashResult && handleGitPop(stashResult);
 	});
 }
 
 //#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"),
+	main: createHelpExample("ng stash", "ng blame [file]", "ng blame [file] [line]", "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"),
@@ -1002,17 +1964,31 @@ const handlePop = handleCheck(async (stashes) => {
 		else log.show("Successfully popped changes.", { type: "success" });
 	}
 });
+const parseStashEntry = (stashEntry) => {
+	const match = stashEntry.match(/^(stash@\{\d+\}):\s+On\s+(\S+):\s+(.+)$/);
+	if (match) return {
+		ref: match[1] || stashEntry,
+		branch: match[2] || "unknown",
+		message: match[3] || stashEntry
+	};
+	return {
+		ref: stashEntry.match(/^(stash@\{\d+\})/)?.[1] ?? stashEntry.split(":")[0] ?? stashEntry,
+		branch: "unknown",
+		message: stashEntry
+	};
+};
 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("");
-	}
+	await renderStashList(await Promise.all(stashes.map(async (stash) => {
+		const stashInfo = parseStashEntry(stash);
+		const files = await getStashFiles(stashInfo.ref);
+		return {
+			ref: stashInfo.ref,
+			branch: stashInfo.branch,
+			message: stashInfo.message,
+			files,
+			fileCount: files.length
+		};
+	})));
 });
 const handleDrop = handleCheck(async (stashes) => {
 	const selectedStashes = await createCheckbox({
@@ -1039,10 +2015,58 @@ const handleClear = handleCheck(async () => {
 	if (error) log.show("Failed to clear stashes.", { type: "error" });
 	else log.show("Successfully cleared stashes.", { type: "success" });
 });
+const handleHistory = async (options) => {
+	if (options.clean) {
+		const days = Number.parseInt(options.clean, 10) || 30;
+		const count = await cleanOldStashes(days);
+		log.show(`Cleaned ${count} old stash records (${days} days)`, { type: "success" });
+		return;
+	}
+	const stashes = await getAllStashes(options.active ? "active" : void 0);
+	const displayList = options.all ? stashes : stashes.slice(0, 10);
+	displayList.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+	if (displayList.length === 0) {
+		log.show("No stash records found.", { type: "info" });
+		return;
+	}
+	log.show(`\n${colors.bold(`📚 Stash History (${displayList.length} records)`)}\n`);
+	for (const stash of displayList) {
+		const statusEmoji = stash.status === "active" ? "📦" : "✅";
+		const statusColor = stash.status === "active" ? colors.yellow : colors.green;
+		log.show(colors.cyan(`━━━ ${statusEmoji} ${stash.message} ━━━`));
+		log.show(colors.dim(`    Operation: ${stash.operation || "unknown"}`));
+		log.show(colors.dim(`    Status: ${statusColor(stash.status || "unknown")}`));
+		log.show(colors.dim(`    Branch: ${stash.currentBranch || "unknown"}`));
+		log.show(colors.dim(`    Time: ${new Date(stash.timestamp).toLocaleString()}`));
+		if (stash.files && stash.files.length > 0) {
+			log.show(colors.dim(`    Files (${stash.files.length}):`));
+			const filesToShow = stash.files.slice(0, 5);
+			for (const file of filesToShow) log.show(colors.yellow(`      • ${file}`));
+			if (stash.files.length > 5) log.show(colors.dim(`      ... and ${stash.files.length - 5} more`));
+		}
+		if (stash.error) log.show(colors.red(`    Error: ${stash.error}`));
+		log.show("");
+	}
+	if (!options.all && stashes.length > 10) log.show(colors.dim(`\nShowing 10 of ${stashes.length} records. Use --all to see all.\n`));
+};
 const stashCommand = (command) => {
 	const stashCmd = command.command("stash").alias("st").description("Git stash management").addHelpText("after", HELP_MESSAGE.main);
+	stashCmd.action(async () => {
+		if (!await handleGitStash(void 0, { operation: "manual" })) log.show("No changes to stash.", { type: "info" });
+	});
 	stashCmd.command("save [message]").alias("s").description("Save current changes to stash").action(async (message) => {
-		await handleGitStash(message);
+		if (message) {
+			if (!await handleGitStash(message, { operation: "manual" })) log.show("No changes to stash.", { type: "info" });
+		} else try {
+			if (!await handleGitStash(await createInput({
+				message: "Enter stash message (press Enter to use default)",
+				validate: (value) => {
+					if (!value?.trim()) return "Message cannot be empty";
+				}
+			}), { operation: "manual" })) log.show("No changes to stash.", { type: "info" });
+		} catch (error) {
+			log.show("Stash cancelled.", { type: "info" });
+		}
 	});
 	stashCmd.command("list").alias("ls").alias("l").description("List all stashes").action(async () => {
 		await handleList();
@@ -1056,9 +2080,57 @@ const stashCommand = (command) => {
 	stashCmd.command("clear").alias("c").description("clear stashes").action(async () => {
 		await handleClear();
 	});
+	stashCmd.command("history").alias("his").alias("h").description("View stash history from persistent index").option("--all", "Show all records (no limit)").option("--active", "Show only active records").option("--clean [days]", "Clean old records (default: 30 days)").action(async (options) => {
+		await handleHistory(options);
+	});
 	return stashCmd;
 };
 
+//#endregion
+//#region src/commands/status.ts
+/**
+* 获取修改的文件列表
+*/
+const getStatusFiles = async () => {
+	const [error, result] = await xASync("git", ["status", "--porcelain"], { quiet: true });
+	if (error) return [];
+	const lines = result.stdout.split("\n").filter((line) => line.trim());
+	const files = [];
+	for (const line of lines) {
+		if (line.length < 3) continue;
+		const stagedStatus = line[0] ?? " ";
+		const unstagedStatus = line[1] ?? " ";
+		const path = line.slice(3).trim();
+		let status = unstagedStatus;
+		let staged = false;
+		if (unstagedStatus === " " && stagedStatus !== " " && stagedStatus !== "?") {
+			status = stagedStatus;
+			staged = true;
+		} else if (unstagedStatus !== " ") {
+			status = unstagedStatus;
+			staged = false;
+		}
+		if (status === "?") continue;
+		files.push({
+			path,
+			status,
+			staged
+		});
+	}
+	return files;
+};
+const statusCommand = (command) => {
+	command.command("status").alias("s").description("Show working tree status (interactive viewer)").action(async () => {
+		const files = await getStatusFiles();
+		if (files.length === 0) {
+			log.show("✓ Working directory clean", { type: "success" });
+			return;
+		}
+		renderStatusViewer(files);
+	});
+	return command;
+};
+
 //#endregion
 //#region src/index.ts
 const pkg = readPackage(import.meta, "..");
@@ -1072,7 +2144,11 @@ const init = () => {
 	diffCommand(command);
 	mergeCommand(command);
 	stashCommand(command);
+	blameCommand(command);
 	commitCommand(command);
+	statusCommand(command);
+	histCommand(command);
+	configCommand(command);
 	return command;
 };
 const run = async () => {