From f081bba51639bc5da60503f9296a69fb70efd294 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 17:45:41 -0800
Subject: [PATCH 1/8] merge main

---
 .../trpc/routers/changes/git-operations.ts    | 157 ++++++++
 .../src/lib/trpc/routers/changes/index.ts     |   5 +
 .../Sidebar/ChangesView/ChangesView.tsx       |  33 +-
 .../components/CommitInput/CommitInput.tsx    | 356 ++++++++++++++++++
 .../components/CommitInput/index.ts           |   1 +
 5 files changed, 551 insertions(+), 1 deletion(-)
 create mode 100644 apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
 create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
 create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/index.ts

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
new file mode 100644
index 00000000000..847b18f4e17
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -0,0 +1,157 @@
+import { execFile } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import simpleGit from "simple-git";
+import { z } from "zod";
+import { publicProcedure, router } from "../..";
+
+const execFileAsync = promisify(execFile);
+
+export const createGitOperationsRouter = () => {
+	return router({
+		saveFile: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string(),
+					filePath: z.string(),
+					content: z.string(),
+				}),
+			)
+			.mutation(async ({ input }): Promise<{ success: boolean }> => {
+				const fullPath = join(input.worktreePath, input.filePath);
+				await writeFile(fullPath, input.content, "utf-8");
+				return { success: true };
+			}),
+
+		commit: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string(),
+					message: z.string(),
+				}),
+			)
+			.mutation(
+				async ({ input }): Promise<{ success: boolean; hash: string }> => {
+					const git = simpleGit(input.worktreePath);
+					const result = await git.commit(input.message);
+					return { success: true, hash: result.commit };
+				},
+			),
+
+		push: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string(),
+					setUpstream: z.boolean().optional(),
+				}),
+			)
+			.mutation(async ({ input }): Promise<{ success: boolean }> => {
+				const git = simpleGit(input.worktreePath);
+				if (input.setUpstream) {
+					const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+					await git.push(["--set-upstream", "origin", branch.trim()]);
+				} else {
+					await git.push();
+				}
+				return { success: true };
+			}),
+
+		pull: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string(),
+				}),
+			)
+			.mutation(async ({ input }): Promise<{ success: boolean }> => {
+				const git = simpleGit(input.worktreePath);
+				try {
+					await git.pull();
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					// If upstream doesn't exist, provide a clearer error
+					if (
+						message.includes("no such ref was fetched") ||
+						message.includes("no tracking information")
+					) {
+						throw new Error(
+							"No upstream branch to pull from. The remote branch may have been deleted.",
+						);
+					}
+					throw error;
+				}
+				return { success: true };
+			}),
+
+		sync: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string(),
+				}),
+			)
+			.mutation(async ({ input }): Promise<{ success: boolean }> => {
+				const git = simpleGit(input.worktreePath);
+				// Try to pull first, but handle case where upstream doesn't exist
+				try {
+					await git.pull();
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					// If upstream doesn't exist, skip pull and just push
+					if (
+						message.includes("no such ref was fetched") ||
+						message.includes("no tracking information")
+					) {
+						// Just push instead
+						const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+						await git.push(["--set-upstream", "origin", branch.trim()]);
+						return { success: true };
+					}
+					throw error;
+				}
+				await git.push();
+				return { success: true };
+			}),
+
+		createPR: publicProcedure
+			.input(
+				z.object({
+					worktreePath: z.string(),
+					title: z.string(),
+					body: z.string().optional(),
+					draft: z.boolean().optional(),
+				}),
+			)
+			.mutation(
+				async ({
+					input,
+				}): Promise<{ success: boolean; url: string; number: number }> => {
+					const args = [
+						"pr",
+						"create",
+						"--title",
+						input.title,
+						"--json",
+						"url,number",
+					];
+					if (input.body) {
+						args.push("--body", input.body);
+					}
+					if (input.draft) {
+						args.push("--draft");
+					}
+
+					const { stdout } = await execFileAsync("gh", args, {
+						cwd: input.worktreePath,
+					});
+					const result = JSON.parse(stdout);
+					return {
+						success: true,
+						url: result.url,
+						number: result.number,
+					};
+				},
+			),
+	});
+};
diff --git a/apps/desktop/src/lib/trpc/routers/changes/index.ts b/apps/desktop/src/lib/trpc/routers/changes/index.ts
index ef56da13b30..e931f8f54af 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/index.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/index.ts
@@ -1,6 +1,7 @@
 import { router } from "../..";
 import { createBranchesRouter } from "./branches";
 import { createFileContentsRouter } from "./file-contents";
+import { createGitOperationsRouter } from "./git-operations";
 import { createStagingRouter } from "./staging";
 import { createStatusRouter } from "./status";
 
@@ -9,6 +10,7 @@ export const createChangesRouter = () => {
 	const statusRouter = createStatusRouter();
 	const fileContentsRouter = createFileContentsRouter();
 	const stagingRouter = createStagingRouter();
+	const gitOperationsRouter = createGitOperationsRouter();
 
 	return router({
 		// Branch operations
@@ -22,5 +24,8 @@ export const createChangesRouter = () => {
 
 		// Staging operations
 		...stagingRouter._def.procedures,
+
+		// Git operations (commit, push, pull, sync, createPR)
+		...gitOperationsRouter._def.procedures,
 	});
 };
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
index 61836d30ed1..f6ea865416a 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
@@ -9,6 +9,7 @@ import { useChangesStore } from "renderer/stores/changes";
 import type { ChangeCategory, ChangedFile } from "shared/changes-types";
 import { CategorySection } from "./components/CategorySection";
 import { ChangesHeader } from "./components/ChangesHeader";
+import { CommitInput } from "./components/CommitInput";
 import { CommitItem } from "./components/CommitItem";
 import { FileList } from "./components/FileList";
 
@@ -38,6 +39,20 @@ export function ChangesView() {
 		},
 	);
 
+	const { data: githubStatus, refetch: refetchGithubStatus } =
+		trpc.workspaces.getGitHubStatus.useQuery(
+			{ workspaceId: activeWorkspace?.id ?? "" },
+			{
+				enabled: !!activeWorkspace?.id,
+				refetchInterval: 10000,
+			},
+		);
+
+	const handleRefresh = () => {
+		refetch();
+		refetchGithubStatus();
+	};
+
 	const stageAllMutation = trpc.changes.stageAll.useMutation({
 		onSuccess: () => refetch(),
 		onError: (error) => {
@@ -178,18 +193,34 @@ export function ChangesView() {
 
 	const unstagedFiles = [...status.unstaged, ...status.untracked];
 
+	const hasStagedChanges = status.staged.length > 0;
+	const branchExistsOnRemote = githubStatus?.branchExistsOnRemote ?? false;
+	const hasExistingPR = !!githubStatus?.pr;
+	const prUrl = githubStatus?.pr?.url;
+
 	return (
 		<div className="flex flex-col h-full">
 			<ChangesHeader
 				ahead={status.ahead}
 				behind={status.behind}
 				isRefreshing={isFetching}
-				onRefresh={() => refetch()}
+				onRefresh={handleRefresh}
 				viewMode={fileListViewMode}
 				onViewModeChange={setFileListViewMode}
 				worktreePath={worktreePath}
 			/>
 
+			<CommitInput
+				worktreePath={worktreePath}
+				hasStagedChanges={hasStagedChanges}
+				ahead={status.ahead}
+				behind={status.behind}
+				branchExistsOnRemote={branchExistsOnRemote}
+				hasExistingPR={hasExistingPR}
+				prUrl={prUrl}
+				onRefresh={handleRefresh}
+			/>
+
 			{!hasChanges ? (
 				<div className="flex-1 flex items-center justify-center text-muted-foreground text-sm px-4 text-center">
 					No changes detected
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
new file mode 100644
index 00000000000..a1c638f9517
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
@@ -0,0 +1,356 @@
+import { Button } from "@superset/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@superset/ui/dropdown-menu";
+import { toast } from "@superset/ui/sonner";
+import { Textarea } from "@superset/ui/textarea";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
+import { useState } from "react";
+import {
+	HiArrowDown,
+	HiArrowsUpDown,
+	HiArrowTopRightOnSquare,
+	HiArrowUp,
+	HiCheck,
+	HiChevronDown,
+} from "react-icons/hi2";
+import { trpc } from "renderer/lib/trpc";
+
+interface CommitInputProps {
+	worktreePath: string;
+	hasStagedChanges: boolean;
+	ahead: number;
+	behind: number;
+	branchExistsOnRemote: boolean;
+	hasExistingPR: boolean;
+	prUrl?: string;
+	onRefresh: () => void;
+}
+
+export function CommitInput({
+	worktreePath,
+	hasStagedChanges,
+	ahead,
+	behind,
+	branchExistsOnRemote,
+	hasExistingPR,
+	prUrl,
+	onRefresh,
+}: CommitInputProps) {
+	const [commitMessage, setCommitMessage] = useState("");
+
+	const commitMutation = trpc.changes.commit.useMutation({
+		onSuccess: () => {
+			toast.success("Changes committed successfully");
+			setCommitMessage("");
+			onRefresh();
+		},
+		onError: (error) => {
+			toast.error(`Failed to commit: ${error.message}`);
+		},
+	});
+
+	const pushMutation = trpc.changes.push.useMutation({
+		onSuccess: () => {
+			toast.success("Pushed successfully");
+			onRefresh();
+		},
+		onError: (error) => {
+			toast.error(`Failed to push: ${error.message}`);
+		},
+	});
+
+	const pullMutation = trpc.changes.pull.useMutation({
+		onSuccess: () => {
+			toast.success("Pulled successfully");
+			onRefresh();
+		},
+		onError: (error) => {
+			toast.error(`Failed to pull: ${error.message}`);
+		},
+	});
+
+	const syncMutation = trpc.changes.sync.useMutation({
+		onSuccess: () => {
+			toast.success("Synced successfully");
+			onRefresh();
+		},
+		onError: (error) => {
+			toast.error(`Failed to sync: ${error.message}`);
+		},
+	});
+
+	const createPRMutation = trpc.changes.createPR.useMutation({
+		onSuccess: (data) => {
+			toast.success("PR created successfully");
+			window.open(data.url, "_blank");
+			onRefresh();
+		},
+		onError: (error) => {
+			toast.error(`Failed to create PR: ${error.message}`);
+		},
+	});
+
+	const isPending =
+		commitMutation.isPending ||
+		pushMutation.isPending ||
+		pullMutation.isPending ||
+		syncMutation.isPending ||
+		createPRMutation.isPending;
+
+	const handleCommit = () => {
+		if (!commitMessage.trim()) {
+			toast.error("Please enter a commit message");
+			return;
+		}
+		commitMutation.mutate({ worktreePath, message: commitMessage.trim() });
+	};
+
+	const handleCommitAndPush = () => {
+		if (!commitMessage.trim()) {
+			toast.error("Please enter a commit message");
+			return;
+		}
+		commitMutation.mutate(
+			{ worktreePath, message: commitMessage.trim() },
+			{
+				onSuccess: () => {
+					pushMutation.mutate({
+						worktreePath,
+						setUpstream: !branchExistsOnRemote,
+					});
+				},
+			},
+		);
+	};
+
+	const handleCommitPushAndCreatePR = () => {
+		if (!commitMessage.trim()) {
+			toast.error("Please enter a commit message");
+			return;
+		}
+		commitMutation.mutate(
+			{ worktreePath, message: commitMessage.trim() },
+			{
+				onSuccess: () => {
+					pushMutation.mutate(
+						{ worktreePath, setUpstream: !branchExistsOnRemote },
+						{
+							onSuccess: () => {
+								createPRMutation.mutate({
+									worktreePath,
+									title: commitMessage.trim().split("\n")[0],
+								});
+							},
+						},
+					);
+				},
+			},
+		);
+	};
+
+	const handlePush = () => {
+		pushMutation.mutate({ worktreePath, setUpstream: !branchExistsOnRemote });
+	};
+
+	const handlePull = () => {
+		pullMutation.mutate({ worktreePath });
+	};
+
+	const handleSync = () => {
+		syncMutation.mutate({ worktreePath });
+	};
+
+	const handleCreatePR = () => {
+		const title = commitMessage.trim().split("\n")[0] || "New pull request";
+		createPRMutation.mutate({ worktreePath, title });
+	};
+
+	const handleOpenPR = () => {
+		if (prUrl) {
+			window.open(prUrl, "_blank");
+		}
+	};
+
+	const getMainButtonAction = (): {
+		label: string;
+		icon: React.ReactNode;
+		action: () => void;
+		disabled: boolean;
+		tooltip: string;
+	} => {
+		if (hasStagedChanges && commitMessage.trim()) {
+			return {
+				label: "Commit",
+				icon: <HiCheck className="w-4 h-4" />,
+				action: handleCommit,
+				disabled: isPending,
+				tooltip: "Commit staged changes",
+			};
+		}
+		if (ahead > 0 && behind > 0) {
+			return {
+				label: "Sync",
+				icon: <HiArrowsUpDown className="w-4 h-4" />,
+				action: handleSync,
+				disabled: isPending,
+				tooltip: `Sync: pull ${behind} commit${behind !== 1 ? "s" : ""}, push ${ahead} commit${ahead !== 1 ? "s" : ""}`,
+			};
+		}
+		if (ahead > 0) {
+			return {
+				label: "Push",
+				icon: <HiArrowUp className="w-4 h-4" />,
+				action: handlePush,
+				disabled: isPending,
+				tooltip: `Push ${ahead} commit${ahead !== 1 ? "s" : ""}`,
+			};
+		}
+		if (behind > 0) {
+			return {
+				label: "Pull",
+				icon: <HiArrowDown className="w-4 h-4" />,
+				action: handlePull,
+				disabled: isPending,
+				tooltip: `Pull ${behind} commit${behind !== 1 ? "s" : ""}`,
+			};
+		}
+		return {
+			label: "Commit",
+			icon: <HiCheck className="w-4 h-4" />,
+			action: handleCommit,
+			disabled: isPending || !hasStagedChanges || !commitMessage.trim(),
+			tooltip: hasStagedChanges
+				? "Enter a commit message"
+				: "No staged changes to commit",
+		};
+	};
+
+	const mainButton = getMainButtonAction();
+
+	return (
+		<div className="flex flex-col gap-2 p-3 border-b border-border">
+			<Textarea
+				placeholder="Message"
+				value={commitMessage}
+				onChange={(e) => setCommitMessage(e.target.value)}
+				className="min-h-[60px] resize-none text-sm bg-background"
+				onKeyDown={(e) => {
+					if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+						e.preventDefault();
+						if (hasStagedChanges && commitMessage.trim()) {
+							handleCommit();
+						}
+					}
+				}}
+			/>
+			<div className="flex gap-1.5">
+				<Tooltip>
+					<TooltipTrigger asChild>
+						<Button
+							variant="default"
+							size="sm"
+							className="flex-1 gap-1.5"
+							onClick={mainButton.action}
+							disabled={mainButton.disabled}
+						>
+							{mainButton.icon}
+							{mainButton.label}
+							{(ahead > 0 || behind > 0) && (
+								<span className="text-xs opacity-70 ml-1">
+									{behind > 0 && `${behind}`}
+									{behind > 0 && ahead > 0 && "/"}
+									{ahead > 0 && `${ahead}`}
+								</span>
+							)}
+						</Button>
+					</TooltipTrigger>
+					<TooltipContent side="bottom">{mainButton.tooltip}</TooltipContent>
+				</Tooltip>
+
+				<DropdownMenu>
+					<DropdownMenuTrigger asChild>
+						<Button
+							variant="default"
+							size="sm"
+							className="px-2"
+							disabled={isPending}
+						>
+							<HiChevronDown className="w-4 h-4" />
+						</Button>
+					</DropdownMenuTrigger>
+					<DropdownMenuContent align="end" className="w-56">
+						<DropdownMenuItem
+							onClick={handleCommit}
+							disabled={!hasStagedChanges || !commitMessage.trim()}
+						>
+							<HiCheck className="w-4 h-4 mr-2" />
+							Commit
+						</DropdownMenuItem>
+						<DropdownMenuItem
+							onClick={handleCommitAndPush}
+							disabled={!hasStagedChanges || !commitMessage.trim()}
+						>
+							<HiArrowUp className="w-4 h-4 mr-2" />
+							Commit & Push
+						</DropdownMenuItem>
+						{!hasExistingPR && (
+							<DropdownMenuItem
+								onClick={handleCommitPushAndCreatePR}
+								disabled={!hasStagedChanges || !commitMessage.trim()}
+							>
+								<HiArrowTopRightOnSquare className="w-4 h-4 mr-2" />
+								Commit, Push & Create PR
+							</DropdownMenuItem>
+						)}
+						<DropdownMenuSeparator />
+						<DropdownMenuItem onClick={handlePush} disabled={ahead === 0}>
+							<HiArrowUp className="w-4 h-4 mr-2" />
+							Push
+							{ahead > 0 && (
+								<span className="ml-auto text-xs text-muted-foreground">
+									{ahead}
+								</span>
+							)}
+						</DropdownMenuItem>
+						<DropdownMenuItem onClick={handlePull} disabled={behind === 0}>
+							<HiArrowDown className="w-4 h-4 mr-2" />
+							Pull
+							{behind > 0 && (
+								<span className="ml-auto text-xs text-muted-foreground">
+									{behind}
+								</span>
+							)}
+						</DropdownMenuItem>
+						<DropdownMenuItem
+							onClick={handleSync}
+							disabled={ahead === 0 && behind === 0}
+						>
+							<HiArrowsUpDown className="w-4 h-4 mr-2" />
+							Sync
+						</DropdownMenuItem>
+						<DropdownMenuSeparator />
+						{hasExistingPR ? (
+							<DropdownMenuItem onClick={handleOpenPR}>
+								<HiArrowTopRightOnSquare className="w-4 h-4 mr-2" />
+								Open Pull Request
+							</DropdownMenuItem>
+						) : (
+							<DropdownMenuItem
+								onClick={handleCreatePR}
+								disabled={!branchExistsOnRemote && ahead === 0}
+							>
+								<HiArrowTopRightOnSquare className="w-4 h-4 mr-2" />
+								Create Pull Request
+							</DropdownMenuItem>
+						)}
+					</DropdownMenuContent>
+				</DropdownMenu>
+			</div>
+		</div>
+	);
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/index.ts
new file mode 100644
index 00000000000..20339d26041
--- /dev/null
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/index.ts
@@ -0,0 +1 @@
+export { CommitInput } from "./CommitInput";

From 2cfec2401fbacb12fa2b1bfca9428de6a2c26650 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 18:07:26 -0800
Subject: [PATCH 2/8] update git ops

---
 .../routers/changes/git-operations.test.ts    | 93 +++++++++++++++++++
 .../trpc/routers/changes/git-operations.ts    | 24 +++--
 2 files changed, 109 insertions(+), 8 deletions(-)
 create mode 100644 apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
new file mode 100644
index 00000000000..0dd2a2967e8
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import { isUpstreamMissingError } from "./git-operations";
+
+describe("git-operations error handling", () => {
+	describe("isUpstreamMissingError", () => {
+		const upstreamDeletedMessages = [
+			"Your configuration specifies to merge with the ref 'refs/heads/feature-branch' from the remote, but no such ref was fetched.",
+			"fatal: couldn't find remote ref refs/heads/deleted-branch",
+			"There is no tracking information for the current branch",
+		];
+
+		const otherErrorMessages = [
+			"fatal: not a git repository",
+			"error: failed to push some refs",
+			"CONFLICT (content): Merge conflict in file.ts",
+			"fatal: refusing to merge unrelated histories",
+		];
+
+		test("detects upstream deleted errors", () => {
+			for (const message of upstreamDeletedMessages) {
+				expect(isUpstreamMissingError(message)).toBe(true);
+			}
+		});
+
+		test("does not falsely detect other errors as upstream deleted", () => {
+			for (const message of otherErrorMessages) {
+				expect(isUpstreamMissingError(message)).toBe(false);
+			}
+		});
+	});
+
+	describe("error message patterns", () => {
+		test("commit with no staged changes", () => {
+			const message = "nothing to commit, working tree clean";
+			expect(message.includes("nothing to commit")).toBe(true);
+		});
+
+		test("push rejected - needs pull first", () => {
+			const message =
+				"error: failed to push some refs to 'origin'\nhint: Updates were rejected because the remote contains work";
+			expect(message.includes("failed to push")).toBe(true);
+			expect(message.includes("rejected")).toBe(true);
+		});
+
+		test("push rejected - no permission", () => {
+			const message =
+				"remote: Permission to user/repo.git denied to otheruser";
+			expect(message.includes("Permission")).toBe(true);
+			expect(message.includes("denied")).toBe(true);
+		});
+
+		test("merge conflict during pull", () => {
+			const message =
+				"CONFLICT (content): Merge conflict in src/file.ts\nAutomatic merge failed";
+			expect(message.includes("CONFLICT")).toBe(true);
+			expect(message.includes("Merge conflict")).toBe(true);
+		});
+
+		test("detached HEAD state", () => {
+			const message = "HEAD detached at abc1234";
+			expect(message.includes("detached")).toBe(true);
+		});
+
+		test("no remote configured", () => {
+			const message = "fatal: 'origin' does not appear to be a git repository";
+			expect(message.includes("does not appear to be a git repository")).toBe(
+				true,
+			);
+		});
+	});
+});
+
+describe("sync operation logic", () => {
+	test("should push with set-upstream when pull fails due to deleted upstream", () => {
+		// This tests the logic flow:
+		// 1. Pull fails with "no such ref was fetched"
+		// 2. Should fall back to push with --set-upstream
+
+		const pullError = new Error(
+			"Your configuration specifies to merge with the ref 'refs/heads/feature' from the remote, but no such ref was fetched.",
+		);
+
+		expect(isUpstreamMissingError(pullError.message)).toBe(true);
+	});
+
+	test("should re-throw other pull errors", () => {
+		const pullError = new Error(
+			"CONFLICT (content): Merge conflict in file.ts",
+		);
+
+		expect(isUpstreamMissingError(pullError.message)).toBe(false);
+	});
+});
diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
index 847b18f4e17..2cbe9adeb2c 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -8,6 +8,20 @@ import { publicProcedure, router } from "../..";
 
 const execFileAsync = promisify(execFile);
 
+/**
+ * Checks if an error message indicates the upstream branch is missing.
+ * This happens when:
+ * - The remote branch was deleted (e.g., after PR merge)
+ * - No tracking branch is configured
+ */
+export function isUpstreamMissingError(message: string): boolean {
+	return (
+		message.includes("no such ref was fetched") ||
+		message.includes("no tracking information") ||
+		message.includes("couldn't find remote ref")
+	);
+}
+
 export const createGitOperationsRouter = () => {
 	return router({
 		saveFile: publicProcedure
@@ -71,10 +85,7 @@ export const createGitOperationsRouter = () => {
 					const message =
 						error instanceof Error ? error.message : String(error);
 					// If upstream doesn't exist, provide a clearer error
-					if (
-						message.includes("no such ref was fetched") ||
-						message.includes("no tracking information")
-					) {
+					if (isUpstreamMissingError(message)) {
 						throw new Error(
 							"No upstream branch to pull from. The remote branch may have been deleted.",
 						);
@@ -99,10 +110,7 @@ export const createGitOperationsRouter = () => {
 					const message =
 						error instanceof Error ? error.message : String(error);
 					// If upstream doesn't exist, skip pull and just push
-					if (
-						message.includes("no such ref was fetched") ||
-						message.includes("no tracking information")
-					) {
+					if (isUpstreamMissingError(message)) {
 						// Just push instead
 						const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
 						await git.push(["--set-upstream", "origin", branch.trim()]);

From 872a35da5a7fa36dadf4415849b53924e9dea1e2 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 18:21:29 -0800
Subject: [PATCH 3/8] feat(desktop): add VSCode-style commit/push/pull UI in
 Changes tab
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add CommitInput component with commit message textarea and smart action button
- Button dynamically shows Commit/Push/Pull/Sync based on git state
- Dropdown menu with all git actions: commit, commit & push, commit & push & create PR
- Add TRPC endpoints for commit, push, pull, sync, and createPR operations
- Track pushCount/pullCount separately from ahead/behind (tracking branch vs main)
- Handle edge cases: deleted upstream branch, missing tracking branch
- Create PR opens GitHub compare URL directly in browser
- Use ButtonGroup for compound button styling

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../routers/changes/git-operations.test.ts    |   3 +-
 .../trpc/routers/changes/git-operations.ts    |  83 ++++--
 .../src/lib/trpc/routers/changes/status.ts    |  44 +++
 .../Sidebar/ChangesView/ChangesView.tsx       |   6 +-
 .../components/CommitInput/CommitInput.tsx    | 274 ++++++++----------
 apps/desktop/src/shared/changes-types.ts      |   3 +
 6 files changed, 219 insertions(+), 194 deletions(-)

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
index 0dd2a2967e8..789bf54118f 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
@@ -43,8 +43,7 @@ describe("git-operations error handling", () => {
 		});
 
 		test("push rejected - no permission", () => {
-			const message =
-				"remote: Permission to user/repo.git denied to otheruser";
+			const message = "remote: Permission to user/repo.git denied to otheruser";
 			expect(message.includes("Permission")).toBe(true);
 			expect(message.includes("denied")).toBe(true);
 		});
diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
index 2cbe9adeb2c..e5f236c2bc9 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -6,7 +6,7 @@ import simpleGit from "simple-git";
 import { z } from "zod";
 import { publicProcedure, router } from "../..";
 
-const execFileAsync = promisify(execFile);
+const _execFileAsync = promisify(execFile);
 
 /**
  * Checks if an error message indicates the upstream branch is missing.
@@ -22,6 +22,20 @@ export function isUpstreamMissingError(message: string): boolean {
 	);
 }
 
+/**
+ * Checks if the current branch has an upstream tracking branch configured.
+ */
+async function hasUpstreamBranch(
+	git: ReturnType<typeof simpleGit>,
+): Promise<boolean> {
+	try {
+		await git.raw(["rev-parse", "--abbrev-ref", "@{upstream}"]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 export const createGitOperationsRouter = () => {
 	return router({
 		saveFile: publicProcedure
@@ -62,12 +76,16 @@ export const createGitOperationsRouter = () => {
 			)
 			.mutation(async ({ input }): Promise<{ success: boolean }> => {
 				const git = simpleGit(input.worktreePath);
-				if (input.setUpstream) {
+				const hasUpstream = await hasUpstreamBranch(git);
+
+				if (input.setUpstream && !hasUpstream) {
 					const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
 					await git.push(["--set-upstream", "origin", branch.trim()]);
 				} else {
 					await git.push();
 				}
+				// Fetch to update remote tracking info so ahead/behind counts refresh
+				await git.fetch();
 				return { success: true };
 			}),
 
@@ -114,11 +132,14 @@ export const createGitOperationsRouter = () => {
 						// Just push instead
 						const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
 						await git.push(["--set-upstream", "origin", branch.trim()]);
+						await git.fetch();
 						return { success: true };
 					}
 					throw error;
 				}
 				await git.push();
+				// Fetch to update remote tracking info so ahead/behind counts refresh
+				await git.fetch();
 				return { success: true };
 			}),
 
@@ -126,39 +147,43 @@ export const createGitOperationsRouter = () => {
 			.input(
 				z.object({
 					worktreePath: z.string(),
-					title: z.string(),
-					body: z.string().optional(),
-					draft: z.boolean().optional(),
 				}),
 			)
 			.mutation(
-				async ({
-					input,
-				}): Promise<{ success: boolean; url: string; number: number }> => {
-					const args = [
-						"pr",
-						"create",
-						"--title",
-						input.title,
-						"--json",
-						"url,number",
-					];
-					if (input.body) {
-						args.push("--body", input.body);
+				async ({ input }): Promise<{ success: boolean; url: string }> => {
+					const git = simpleGit(input.worktreePath);
+					const branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+					const hasUpstream = await hasUpstreamBranch(git);
+
+					// Ensure branch is pushed first
+					if (!hasUpstream) {
+						await git.push(["--set-upstream", "origin", branch]);
+					} else {
+						// Push any unpushed commits
+						await git.push();
 					}
-					if (input.draft) {
-						args.push("--draft");
+
+					// Get the remote URL to construct the GitHub compare URL
+					const remoteUrl = (await git.remote(["get-url", "origin"])) || "";
+					const repoMatch = remoteUrl
+						.trim()
+						.match(/github\.com[:/](.+?)(?:\.git)?$/);
+
+					if (!repoMatch) {
+						throw new Error("Could not determine GitHub repository URL");
 					}
 
-					const { stdout } = await execFileAsync("gh", args, {
-						cwd: input.worktreePath,
-					});
-					const result = JSON.parse(stdout);
-					return {
-						success: true,
-						url: result.url,
-						number: result.number,
-					};
+					const repo = repoMatch[1].replace(/\.git$/, "");
+					const url = `https://github.com/${repo}/compare/${branch}?expand=1`;
+
+					// Open the URL in the browser
+					const { exec } = await import("node:child_process");
+					exec(`open "${url}"`);
+
+					// Fetch to update tracking info
+					await git.fetch();
+
+					return { success: true, url };
 				},
 			),
 	});
diff --git a/apps/desktop/src/lib/trpc/routers/changes/status.ts b/apps/desktop/src/lib/trpc/routers/changes/status.ts
index 2dbcaf4d354..fe0ffd3db7d 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/status.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/status.ts
@@ -28,6 +28,7 @@ export const createStatusRouter = () => {
 				const parsed = parseGitStatus(status);
 
 				const branchComparison = await getBranchComparison(git, defaultBranch);
+				const trackingStatus = await getTrackingBranchStatus(git);
 
 				await applyNumstatToFiles(git, parsed.staged, [
 					"diff",
@@ -49,6 +50,8 @@ export const createStatusRouter = () => {
 					untracked: parsed.untracked,
 					ahead: branchComparison.ahead,
 					behind: branchComparison.behind,
+					pushCount: trackingStatus.pushCount,
+					pullCount: trackingStatus.pullCount,
 				};
 			}),
 
@@ -151,3 +154,44 @@ async function applyUntrackedLineCount(
 		} catch {}
 	}
 }
+
+interface TrackingStatus {
+	pushCount: number;
+	pullCount: number;
+}
+
+/**
+ * Get the push/pull count relative to the tracking branch (not default branch).
+ * This tells us if there are commits to push/pull to the remote tracking branch.
+ */
+async function getTrackingBranchStatus(
+	git: ReturnType<typeof simpleGit>,
+): Promise<TrackingStatus> {
+	try {
+		// Check if there's a tracking branch configured
+		const upstream = await git.raw([
+			"rev-parse",
+			"--abbrev-ref",
+			"@{upstream}",
+		]);
+		if (!upstream.trim()) {
+			return { pushCount: 0, pullCount: 0 };
+		}
+
+		// Get ahead/behind relative to tracking branch
+		const tracking = await git.raw([
+			"rev-list",
+			"--left-right",
+			"--count",
+			"@{upstream}...HEAD",
+		]);
+		const [pullStr, pushStr] = tracking.trim().split(/\s+/);
+		return {
+			pushCount: Number.parseInt(pushStr || "0", 10),
+			pullCount: Number.parseInt(pullStr || "0", 10),
+		};
+	} catch {
+		// No tracking branch configured
+		return { pushCount: 0, pullCount: 0 };
+	}
+}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
index f6ea865416a..d283a57b40e 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
@@ -194,7 +194,6 @@ export function ChangesView() {
 	const unstagedFiles = [...status.unstaged, ...status.untracked];
 
 	const hasStagedChanges = status.staged.length > 0;
-	const branchExistsOnRemote = githubStatus?.branchExistsOnRemote ?? false;
 	const hasExistingPR = !!githubStatus?.pr;
 	const prUrl = githubStatus?.pr?.url;
 
@@ -213,9 +212,8 @@ export function ChangesView() {
 			<CommitInput
 				worktreePath={worktreePath}
 				hasStagedChanges={hasStagedChanges}
-				ahead={status.ahead}
-				behind={status.behind}
-				branchExistsOnRemote={branchExistsOnRemote}
+				pushCount={status.pushCount}
+				pullCount={status.pullCount}
 				hasExistingPR={hasExistingPR}
 				prUrl={prUrl}
 				onRefresh={handleRefresh}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
index a1c638f9517..3963b0e7d81 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
@@ -1,4 +1,5 @@
 import { Button } from "@superset/ui/button";
+import { ButtonGroup } from "@superset/ui/button-group";
 import {
 	DropdownMenu,
 	DropdownMenuContent,
@@ -23,76 +24,66 @@ import { trpc } from "renderer/lib/trpc";
 interface CommitInputProps {
 	worktreePath: string;
 	hasStagedChanges: boolean;
-	ahead: number;
-	behind: number;
-	branchExistsOnRemote: boolean;
+	pushCount: number;
+	pullCount: number;
 	hasExistingPR: boolean;
 	prUrl?: string;
 	onRefresh: () => void;
 }
 
+type GitAction = "commit" | "push" | "pull" | "sync";
+
 export function CommitInput({
 	worktreePath,
 	hasStagedChanges,
-	ahead,
-	behind,
-	branchExistsOnRemote,
+	pushCount,
+	pullCount,
 	hasExistingPR,
 	prUrl,
 	onRefresh,
 }: CommitInputProps) {
 	const [commitMessage, setCommitMessage] = useState("");
+	const [isOpen, setIsOpen] = useState(false);
 
 	const commitMutation = trpc.changes.commit.useMutation({
 		onSuccess: () => {
-			toast.success("Changes committed successfully");
+			toast.success("Committed");
 			setCommitMessage("");
 			onRefresh();
 		},
-		onError: (error) => {
-			toast.error(`Failed to commit: ${error.message}`);
-		},
+		onError: (error) => toast.error(`Commit failed: ${error.message}`),
 	});
 
 	const pushMutation = trpc.changes.push.useMutation({
 		onSuccess: () => {
-			toast.success("Pushed successfully");
+			toast.success("Pushed");
 			onRefresh();
 		},
-		onError: (error) => {
-			toast.error(`Failed to push: ${error.message}`);
-		},
+		onError: (error) => toast.error(`Push failed: ${error.message}`),
 	});
 
 	const pullMutation = trpc.changes.pull.useMutation({
 		onSuccess: () => {
-			toast.success("Pulled successfully");
+			toast.success("Pulled");
 			onRefresh();
 		},
-		onError: (error) => {
-			toast.error(`Failed to pull: ${error.message}`);
-		},
+		onError: (error) => toast.error(`Pull failed: ${error.message}`),
 	});
 
 	const syncMutation = trpc.changes.sync.useMutation({
 		onSuccess: () => {
-			toast.success("Synced successfully");
+			toast.success("Synced");
 			onRefresh();
 		},
-		onError: (error) => {
-			toast.error(`Failed to sync: ${error.message}`);
-		},
+		onError: (error) => toast.error(`Sync failed: ${error.message}`),
 	});
 
 	const createPRMutation = trpc.changes.createPR.useMutation({
-		onSuccess: (data) => {
-			toast.success("PR created successfully");
-			window.open(data.url, "_blank");
+		onSuccess: () => {
+			toast.success("Opening GitHub...");
 			onRefresh();
 		},
-		onError: (error) => {
-			toast.error(`Failed to create PR: ${error.message}`);
-		},
+		onError: (error) => toast.error(`Failed: ${error.message}`),
 	});
 
 	const isPending =
@@ -102,135 +93,109 @@ export function CommitInput({
 		syncMutation.isPending ||
 		createPRMutation.isPending;
 
+	const canCommit = hasStagedChanges && commitMessage.trim();
+
 	const handleCommit = () => {
-		if (!commitMessage.trim()) {
-			toast.error("Please enter a commit message");
-			return;
-		}
+		if (!canCommit) return;
 		commitMutation.mutate({ worktreePath, message: commitMessage.trim() });
 	};
 
+	const handlePush = () =>
+		pushMutation.mutate({ worktreePath, setUpstream: true });
+	const handlePull = () => pullMutation.mutate({ worktreePath });
+	const handleSync = () => syncMutation.mutate({ worktreePath });
+	const handleCreatePR = () => createPRMutation.mutate({ worktreePath });
+	const handleOpenPR = () => prUrl && window.open(prUrl, "_blank");
+
 	const handleCommitAndPush = () => {
-		if (!commitMessage.trim()) {
-			toast.error("Please enter a commit message");
-			return;
-		}
+		if (!canCommit) return;
 		commitMutation.mutate(
 			{ worktreePath, message: commitMessage.trim() },
-			{
-				onSuccess: () => {
-					pushMutation.mutate({
-						worktreePath,
-						setUpstream: !branchExistsOnRemote,
-					});
-				},
-			},
+			{ onSuccess: handlePush },
 		);
 	};
 
 	const handleCommitPushAndCreatePR = () => {
-		if (!commitMessage.trim()) {
-			toast.error("Please enter a commit message");
-			return;
-		}
+		if (!canCommit) return;
 		commitMutation.mutate(
 			{ worktreePath, message: commitMessage.trim() },
 			{
 				onSuccess: () => {
 					pushMutation.mutate(
-						{ worktreePath, setUpstream: !branchExistsOnRemote },
-						{
-							onSuccess: () => {
-								createPRMutation.mutate({
-									worktreePath,
-									title: commitMessage.trim().split("\n")[0],
-								});
-							},
-						},
+						{ worktreePath, setUpstream: true },
+						{ onSuccess: handleCreatePR },
 					);
 				},
 			},
 		);
 	};
 
-	const handlePush = () => {
-		pushMutation.mutate({ worktreePath, setUpstream: !branchExistsOnRemote });
-	};
-
-	const handlePull = () => {
-		pullMutation.mutate({ worktreePath });
-	};
-
-	const handleSync = () => {
-		syncMutation.mutate({ worktreePath });
-	};
-
-	const handleCreatePR = () => {
-		const title = commitMessage.trim().split("\n")[0] || "New pull request";
-		createPRMutation.mutate({ worktreePath, title });
-	};
-
-	const handleOpenPR = () => {
-		if (prUrl) {
-			window.open(prUrl, "_blank");
-		}
-	};
-
-	const getMainButtonAction = (): {
+	// Determine primary action based on state
+	const getPrimaryAction = (): {
+		action: GitAction;
 		label: string;
 		icon: React.ReactNode;
-		action: () => void;
+		handler: () => void;
 		disabled: boolean;
 		tooltip: string;
 	} => {
-		if (hasStagedChanges && commitMessage.trim()) {
+		if (canCommit) {
 			return {
+				action: "commit",
 				label: "Commit",
-				icon: <HiCheck className="w-4 h-4" />,
-				action: handleCommit,
+				icon: <HiCheck className="size-4" />,
+				handler: handleCommit,
 				disabled: isPending,
 				tooltip: "Commit staged changes",
 			};
 		}
-		if (ahead > 0 && behind > 0) {
+		if (pushCount > 0 && pullCount > 0) {
 			return {
+				action: "sync",
 				label: "Sync",
-				icon: <HiArrowsUpDown className="w-4 h-4" />,
-				action: handleSync,
+				icon: <HiArrowsUpDown className="size-4" />,
+				handler: handleSync,
 				disabled: isPending,
-				tooltip: `Sync: pull ${behind} commit${behind !== 1 ? "s" : ""}, push ${ahead} commit${ahead !== 1 ? "s" : ""}`,
+				tooltip: `Pull ${pullCount}, push ${pushCount}`,
 			};
 		}
-		if (ahead > 0) {
+		if (pushCount > 0) {
 			return {
+				action: "push",
 				label: "Push",
-				icon: <HiArrowUp className="w-4 h-4" />,
-				action: handlePush,
+				icon: <HiArrowUp className="size-4" />,
+				handler: handlePush,
 				disabled: isPending,
-				tooltip: `Push ${ahead} commit${ahead !== 1 ? "s" : ""}`,
+				tooltip: `Push ${pushCount} commit${pushCount !== 1 ? "s" : ""}`,
 			};
 		}
-		if (behind > 0) {
+		if (pullCount > 0) {
 			return {
+				action: "pull",
 				label: "Pull",
-				icon: <HiArrowDown className="w-4 h-4" />,
-				action: handlePull,
+				icon: <HiArrowDown className="size-4" />,
+				handler: handlePull,
 				disabled: isPending,
-				tooltip: `Pull ${behind} commit${behind !== 1 ? "s" : ""}`,
+				tooltip: `Pull ${pullCount} commit${pullCount !== 1 ? "s" : ""}`,
 			};
 		}
 		return {
+			action: "commit",
 			label: "Commit",
-			icon: <HiCheck className="w-4 h-4" />,
-			action: handleCommit,
-			disabled: isPending || !hasStagedChanges || !commitMessage.trim(),
-			tooltip: hasStagedChanges
-				? "Enter a commit message"
-				: "No staged changes to commit",
+			icon: <HiCheck className="size-4" />,
+			handler: handleCommit,
+			disabled: true,
+			tooltip: hasStagedChanges ? "Enter a message" : "No staged changes",
 		};
 	};
 
-	const mainButton = getMainButtonAction();
+	const primary = getPrimaryAction();
+
+	// Format count badge
+	const countBadge =
+		pushCount > 0 || pullCount > 0
+			? `${pullCount > 0 ? pullCount : ""}${pullCount > 0 && pushCount > 0 ? "/" : ""}${pushCount > 0 ? pushCount : ""}`
+			: null;
 
 	return (
 		<div className="flex flex-col gap-2 p-3 border-b border-border">
@@ -240,117 +205,108 @@ export function CommitInput({
 				onChange={(e) => setCommitMessage(e.target.value)}
 				className="min-h-[60px] resize-none text-sm bg-background"
 				onKeyDown={(e) => {
-					if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+					if (e.key === "Enter" && (e.metaKey || e.ctrlKey) && canCommit) {
 						e.preventDefault();
-						if (hasStagedChanges && commitMessage.trim()) {
-							handleCommit();
-						}
+						handleCommit();
 					}
 				}}
 			/>
-			<div className="flex gap-1.5">
+
+			<ButtonGroup className="w-full">
 				<Tooltip>
 					<TooltipTrigger asChild>
 						<Button
 							variant="default"
 							size="sm"
 							className="flex-1 gap-1.5"
-							onClick={mainButton.action}
-							disabled={mainButton.disabled}
+							onClick={primary.handler}
+							disabled={primary.disabled}
 						>
-							{mainButton.icon}
-							{mainButton.label}
-							{(ahead > 0 || behind > 0) && (
-								<span className="text-xs opacity-70 ml-1">
-									{behind > 0 && `${behind}`}
-									{behind > 0 && ahead > 0 && "/"}
-									{ahead > 0 && `${ahead}`}
-								</span>
+							{primary.icon}
+							<span>{primary.label}</span>
+							{countBadge && (
+								<span className="text-xs opacity-70">{countBadge}</span>
 							)}
 						</Button>
 					</TooltipTrigger>
-					<TooltipContent side="bottom">{mainButton.tooltip}</TooltipContent>
+					<TooltipContent side="bottom">{primary.tooltip}</TooltipContent>
 				</Tooltip>
 
-				<DropdownMenu>
+				<DropdownMenu open={isOpen} onOpenChange={setIsOpen}>
 					<DropdownMenuTrigger asChild>
-						<Button
-							variant="default"
-							size="sm"
-							className="px-2"
-							disabled={isPending}
-						>
-							<HiChevronDown className="w-4 h-4" />
+						<Button variant="default" size="sm" disabled={isPending}>
+							<HiChevronDown className="size-4" />
 						</Button>
 					</DropdownMenuTrigger>
-					<DropdownMenuContent align="end" className="w-56">
-						<DropdownMenuItem
-							onClick={handleCommit}
-							disabled={!hasStagedChanges || !commitMessage.trim()}
-						>
-							<HiCheck className="w-4 h-4 mr-2" />
+					<DropdownMenuContent align="end" className="w-52">
+						{/* Commit actions */}
+						<DropdownMenuItem onClick={handleCommit} disabled={!canCommit}>
+							<HiCheck className="size-4" />
 							Commit
 						</DropdownMenuItem>
 						<DropdownMenuItem
 							onClick={handleCommitAndPush}
-							disabled={!hasStagedChanges || !commitMessage.trim()}
+							disabled={!canCommit}
 						>
-							<HiArrowUp className="w-4 h-4 mr-2" />
+							<HiArrowUp className="size-4" />
 							Commit & Push
 						</DropdownMenuItem>
 						{!hasExistingPR && (
 							<DropdownMenuItem
 								onClick={handleCommitPushAndCreatePR}
-								disabled={!hasStagedChanges || !commitMessage.trim()}
+								disabled={!canCommit}
 							>
-								<HiArrowTopRightOnSquare className="w-4 h-4 mr-2" />
+								<HiArrowTopRightOnSquare className="size-4" />
 								Commit, Push & Create PR
 							</DropdownMenuItem>
 						)}
+
 						<DropdownMenuSeparator />
-						<DropdownMenuItem onClick={handlePush} disabled={ahead === 0}>
-							<HiArrowUp className="w-4 h-4 mr-2" />
-							Push
-							{ahead > 0 && (
-								<span className="ml-auto text-xs text-muted-foreground">
-									{ahead}
+
+						{/* Sync actions */}
+						<DropdownMenuItem onClick={handlePush} disabled={pushCount === 0}>
+							<HiArrowUp className="size-4" />
+							<span className="flex-1">Push</span>
+							{pushCount > 0 && (
+								<span className="text-xs text-muted-foreground">
+									{pushCount}
 								</span>
 							)}
 						</DropdownMenuItem>
-						<DropdownMenuItem onClick={handlePull} disabled={behind === 0}>
-							<HiArrowDown className="w-4 h-4 mr-2" />
-							Pull
-							{behind > 0 && (
-								<span className="ml-auto text-xs text-muted-foreground">
-									{behind}
+						<DropdownMenuItem onClick={handlePull} disabled={pullCount === 0}>
+							<HiArrowDown className="size-4" />
+							<span className="flex-1">Pull</span>
+							{pullCount > 0 && (
+								<span className="text-xs text-muted-foreground">
+									{pullCount}
 								</span>
 							)}
 						</DropdownMenuItem>
 						<DropdownMenuItem
 							onClick={handleSync}
-							disabled={ahead === 0 && behind === 0}
+							disabled={pushCount === 0 && pullCount === 0}
 						>
-							<HiArrowsUpDown className="w-4 h-4 mr-2" />
+							<HiArrowsUpDown className="size-4" />
 							Sync
 						</DropdownMenuItem>
+
 						<DropdownMenuSeparator />
+
+						{/* PR actions */}
 						{hasExistingPR ? (
 							<DropdownMenuItem onClick={handleOpenPR}>
-								<HiArrowTopRightOnSquare className="w-4 h-4 mr-2" />
+								<HiArrowTopRightOnSquare className="size-4" />
 								Open Pull Request
 							</DropdownMenuItem>
 						) : (
-							<DropdownMenuItem
-								onClick={handleCreatePR}
-								disabled={!branchExistsOnRemote && ahead === 0}
-							>
-								<HiArrowTopRightOnSquare className="w-4 h-4 mr-2" />
+							<DropdownMenuItem onClick={handleCreatePR}>
+								<HiArrowTopRightOnSquare className="size-4" />
 								Create Pull Request
 							</DropdownMenuItem>
 						)}
 					</DropdownMenuContent>
 				</DropdownMenu>
-			</div>
+			</ButtonGroup>
 		</div>
 	);
 }
diff --git a/apps/desktop/src/shared/changes-types.ts b/apps/desktop/src/shared/changes-types.ts
index 29eba41a9c1..b5d05853d42 100644
--- a/apps/desktop/src/shared/changes-types.ts
+++ b/apps/desktop/src/shared/changes-types.ts
@@ -48,6 +48,9 @@ export interface GitChangesStatus {
 	untracked: ChangedFile[];
 	ahead: number; // Commits ahead of default branch
 	behind: number; // Commits behind default branch
+	// Tracking branch status (for push/pull)
+	pushCount: number; // Commits to push to tracking branch
+	pullCount: number; // Commits to pull from tracking branch
 }
 
 /** Diff view mode toggle */

From a7f376eabededc0f21ad07f15d9e39ce86ec0c04 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 18:28:51 -0800
Subject: [PATCH 4/8] remove redundant comments

---
 .../trpc/routers/changes/git-operations.ts    |  17 ---
 .../src/lib/trpc/routers/changes/status.ts    |   7 --
 .../routers/changes/utils/apply-numstat.ts    |   3 -
 .../routers/changes/utils/parse-status.ts     |  28 -----
 .../lib/trpc/routers/workspaces/utils/git.ts  | 104 +-----------------
 5 files changed, 4 insertions(+), 155 deletions(-)

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
index e5f236c2bc9..ddc46b86156 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -8,12 +8,6 @@ import { publicProcedure, router } from "../..";
 
 const _execFileAsync = promisify(execFile);
 
-/**
- * Checks if an error message indicates the upstream branch is missing.
- * This happens when:
- * - The remote branch was deleted (e.g., after PR merge)
- * - No tracking branch is configured
- */
 export function isUpstreamMissingError(message: string): boolean {
 	return (
 		message.includes("no such ref was fetched") ||
@@ -22,9 +16,6 @@ export function isUpstreamMissingError(message: string): boolean {
 	);
 }
 
-/**
- * Checks if the current branch has an upstream tracking branch configured.
- */
 async function hasUpstreamBranch(
 	git: ReturnType<typeof simpleGit>,
 ): Promise<boolean> {
@@ -84,7 +75,6 @@ export const createGitOperationsRouter = () => {
 				} else {
 					await git.push();
 				}
-				// Fetch to update remote tracking info so ahead/behind counts refresh
 				await git.fetch();
 				return { success: true };
 			}),
@@ -102,7 +92,6 @@ export const createGitOperationsRouter = () => {
 				} catch (error) {
 					const message =
 						error instanceof Error ? error.message : String(error);
-					// If upstream doesn't exist, provide a clearer error
 					if (isUpstreamMissingError(message)) {
 						throw new Error(
 							"No upstream branch to pull from. The remote branch may have been deleted.",
@@ -121,15 +110,12 @@ export const createGitOperationsRouter = () => {
 			)
 			.mutation(async ({ input }): Promise<{ success: boolean }> => {
 				const git = simpleGit(input.worktreePath);
-				// Try to pull first, but handle case where upstream doesn't exist
 				try {
 					await git.pull();
 				} catch (error) {
 					const message =
 						error instanceof Error ? error.message : String(error);
-					// If upstream doesn't exist, skip pull and just push
 					if (isUpstreamMissingError(message)) {
-						// Just push instead
 						const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
 						await git.push(["--set-upstream", "origin", branch.trim()]);
 						await git.fetch();
@@ -138,7 +124,6 @@ export const createGitOperationsRouter = () => {
 					throw error;
 				}
 				await git.push();
-				// Fetch to update remote tracking info so ahead/behind counts refresh
 				await git.fetch();
 				return { success: true };
 			}),
@@ -176,11 +161,9 @@ export const createGitOperationsRouter = () => {
 					const repo = repoMatch[1].replace(/\.git$/, "");
 					const url = `https://github.com/${repo}/compare/${branch}?expand=1`;
 
-					// Open the URL in the browser
 					const { exec } = await import("node:child_process");
 					exec(`open "${url}"`);
 
-					// Fetch to update tracking info
 					await git.fetch();
 
 					return { success: true, url };
diff --git a/apps/desktop/src/lib/trpc/routers/changes/status.ts b/apps/desktop/src/lib/trpc/routers/changes/status.ts
index fe0ffd3db7d..ec7a26f4a6b 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/status.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/status.ts
@@ -160,15 +160,10 @@ interface TrackingStatus {
 	pullCount: number;
 }
 
-/**
- * Get the push/pull count relative to the tracking branch (not default branch).
- * This tells us if there are commits to push/pull to the remote tracking branch.
- */
 async function getTrackingBranchStatus(
 	git: ReturnType<typeof simpleGit>,
 ): Promise<TrackingStatus> {
 	try {
-		// Check if there's a tracking branch configured
 		const upstream = await git.raw([
 			"rev-parse",
 			"--abbrev-ref",
@@ -178,7 +173,6 @@ async function getTrackingBranchStatus(
 			return { pushCount: 0, pullCount: 0 };
 		}
 
-		// Get ahead/behind relative to tracking branch
 		const tracking = await git.raw([
 			"rev-list",
 			"--left-right",
@@ -191,7 +185,6 @@ async function getTrackingBranchStatus(
 			pullCount: Number.parseInt(pullStr || "0", 10),
 		};
 	} catch {
-		// No tracking branch configured
 		return { pushCount: 0, pullCount: 0 };
 	}
 }
diff --git a/apps/desktop/src/lib/trpc/routers/changes/utils/apply-numstat.ts b/apps/desktop/src/lib/trpc/routers/changes/utils/apply-numstat.ts
index b7ea2a5eec7..5c6b6c81334 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/utils/apply-numstat.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/utils/apply-numstat.ts
@@ -2,9 +2,6 @@ import type { ChangedFile } from "shared/changes-types";
 import type { SimpleGit } from "simple-git";
 import { parseDiffNumstat } from "./parse-status";
 
-/**
- * Fetches numstat for given diff arguments and applies stats to files
- */
 export async function applyNumstatToFiles(
 	git: SimpleGit,
 	files: ChangedFile[],
diff --git a/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts b/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts
index 8d737bcc911..b2a41ae915e 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts
@@ -6,9 +6,6 @@ import type {
 } from "shared/changes-types";
 import type { StatusResult } from "simple-git";
 
-/**
- * Maps git status codes to our FileStatus type
- */
 function mapGitStatus(gitIndex: string, gitWorking: string): FileStatus {
 	if (gitIndex === "A" || gitWorking === "A") return "added";
 	if (gitIndex === "D" || gitWorking === "D") return "deleted";
@@ -18,9 +15,6 @@ function mapGitStatus(gitIndex: string, gitWorking: string): FileStatus {
 	return "modified";
 }
 
-/**
- * Converts a simple-git FileStatusResult to our ChangedFile type
- */
 function toChangedFile(
 	path: string,
 	gitIndex: string,
@@ -34,9 +28,6 @@ function toChangedFile(
 	};
 }
 
-/**
- * Parses simple-git StatusResult into our GitChangesStatus format
- */
 export function parseGitStatus(
 	status: StatusResult,
 ): Pick<GitChangesStatus, "branch" | "staged" | "unstaged" | "untracked"> {
@@ -82,11 +73,6 @@ export function parseGitStatus(
 	};
 }
 
-/**
- * Parses git log output into CommitInfo array
- * Format: hash|shortHash|message|author|date
- * Note: Uses limit of 5 parts to preserve '|' characters in commit messages
- */
 export function parseGitLog(logOutput: string): CommitInfo[] {
 	if (!logOutput.trim()) return [];
 
@@ -96,7 +82,6 @@ export function parseGitLog(logOutput: string): CommitInfo[] {
 	for (const line of lines) {
 		if (!line.trim()) continue;
 
-		// Split into exactly 5 parts to preserve '|' in messages
 		const parts = line.split("|");
 		if (parts.length < 5) continue;
 
@@ -129,11 +114,6 @@ export function parseGitLog(logOutput: string): CommitInfo[] {
 	return commits;
 }
 
-/**
- * Parses git diff --numstat output to get addition/deletion counts
- * Format: additions\tdeletions\tfilepath
- * For renames/copies: additions\tdeletions\toldpath => newpath
- */
 export function parseDiffNumstat(
 	numstatOutput: string,
 ): Map<string, { additions: number; deletions: number }> {
@@ -146,7 +126,6 @@ export function parseDiffNumstat(
 		const rawPath = pathParts.join("\t");
 		if (!rawPath) continue;
 
-		// Binary files show "-" for additions/deletions
 		const additions = addStr === "-" ? 0 : Number.parseInt(addStr, 10) || 0;
 		const deletions = delStr === "-" ? 0 : Number.parseInt(delStr, 10) || 0;
 		const statEntry = { additions, deletions };
@@ -165,10 +144,6 @@ export function parseDiffNumstat(
 	return stats;
 }
 
-/**
- * Parses git diff --name-status output for a commit
- * Format: status\tfilepath (or status\toldpath\tnewpath for renames)
- */
 export function parseNameStatus(nameStatusOutput: string): ChangedFile[] {
 	const files: ChangedFile[] = [];
 
@@ -216,9 +191,6 @@ export function parseNameStatus(nameStatusOutput: string): ChangedFile[] {
 	return files;
 }
 
-/**
- * Detects Monaco language from file extension
- */
 export function detectLanguage(filePath: string): string {
 	const ext = filePath.split(".").pop()?.toLowerCase();
 
diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts b/apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts
index 82b6f76d28b..7f2075dece4 100644
--- a/apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts
+++ b/apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts
@@ -13,24 +13,16 @@ import { checkGitLfsAvailable, getShellEnvironment } from "./shell-env";
 
 const execFileAsync = promisify(execFile);
 
-/**
- * Builds the merged environment for git operations.
- * Takes process.env as base, then overrides only PATH from shell environment.
- * This preserves runtime vars (git credentials, proxy, ELECTRON_*, etc.)
- * while picking up PATH modifications from shell profiles (e.g., homebrew git-lfs).
- */
 async function getGitEnv(): Promise<Record<string, string>> {
 	const shellEnv = await getShellEnvironment();
 	const result: Record<string, string> = {};
 
-	// Start with process.env as base
 	for (const [key, value] of Object.entries(process.env)) {
 		if (typeof value === "string") {
 			result[key] = value;
 		}
 	}
 
-	// Only override PATH from shell env (use platform-appropriate key)
 	const pathKey = process.platform === "win32" ? "Path" : "PATH";
 	if (shellEnv[pathKey]) {
 		result[pathKey] = shellEnv[pathKey];
@@ -39,17 +31,7 @@ async function getGitEnv(): Promise<Record<string, string>> {
 	return result;
 }
 
-/**
- * Checks if a repository uses Git LFS using a hybrid approach:
- * 1. Fast path: check if .git/lfs directory exists (LFS already initialized)
- * 2. Check multiple attribute sources for filter=lfs:
- *    - Root .gitattributes
- *    - .git/info/attributes (local overrides)
- *    - .lfsconfig (LFS-specific config)
- * 3. Final fallback: check git config for LFS filter (catches nested .gitattributes)
- */
 async function repoUsesLfs(repoPath: string): Promise<boolean> {
-	// Fast path: .git/lfs exists when LFS is initialized or objects fetched
 	try {
 		const lfsDir = join(repoPath, ".git", "lfs");
 		const stats = await stat(lfsDir);
@@ -62,7 +44,6 @@ async function repoUsesLfs(repoPath: string): Promise<boolean> {
 		}
 	}
 
-	// Check multiple attribute sources for filter=lfs
 	const attributeFiles = [
 		join(repoPath, ".gitattributes"),
 		join(repoPath, ".git", "info", "attributes"),
@@ -82,16 +63,12 @@ async function repoUsesLfs(repoPath: string): Promise<boolean> {
 		}
 	}
 
-	// Final fallback: sample a few tracked files with git check-attr
-	// This catches nested .gitattributes that declare filter=lfs
 	try {
 		const git = simpleGit(repoPath);
-		// Get a small sample of tracked files (limit to 20 for performance)
 		const lsFiles = await git.raw(["ls-files"]);
 		const sampleFiles = lsFiles.split("\n").filter(Boolean).slice(0, 20);
 
 		if (sampleFiles.length > 0) {
-			// Check filter attribute on sampled files
 			const checkAttr = await git.raw([
 				"check-attr",
 				"filter",
@@ -102,9 +79,7 @@ async function repoUsesLfs(repoPath: string): Promise<boolean> {
 				return true;
 			}
 		}
-	} catch {
-		// If git commands fail, assume no LFS to avoid blocking
-	}
+	} catch {}
 
 	return false;
 }
@@ -135,17 +110,14 @@ export async function createWorktree(
 	worktreePath: string,
 	startPoint = "origin/main",
 ): Promise<void> {
-	// Check LFS usage before try block so it's available in catch for error messaging
 	const usesLfs = await repoUsesLfs(mainRepoPath);
 
 	try {
 		const parentDir = join(worktreePath, "..");
 		await mkdir(parentDir, { recursive: true });
 
-		// Get merged environment (process.env + shell env for PATH)
 		const env = await getGitEnv();
 
-		// Proactive LFS check: detect early if repo uses LFS but git-lfs is missing
 		if (usesLfs) {
 			const lfsAvailable = await checkGitLfsAvailable(env);
 			if (!lfsAvailable) {
@@ -156,7 +128,6 @@ export async function createWorktree(
 			}
 		}
 
-		// Use execFile with arg array for proper POSIX compatibility (no shell escaping needed)
 		await execFileAsync(
 			"git",
 			[
@@ -179,7 +150,6 @@ export async function createWorktree(
 		const errorMessage = error instanceof Error ? error.message : String(error);
 		const lowerError = errorMessage.toLowerCase();
 
-		// Check for git lock file errors (e.g., .git/config.lock, .git/index.lock)
 		const isLockError =
 			lowerError.includes("could not lock") ||
 			lowerError.includes("unable to lock") ||
@@ -197,11 +167,6 @@ export async function createWorktree(
 			);
 		}
 
-		// Broad check for LFS-related errors:
-		// - "git-lfs" / "filter-process" (original)
-		// - "smudge filter" (more specific than just "smudge" to avoid false positives)
-		// - "git: 'lfs' is not a git command"
-		// - Any mention of "lfs" when we detected LFS usage
 		const isLfsError =
 			lowerError.includes("git-lfs") ||
 			lowerError.includes("filter-process") ||
@@ -227,10 +192,8 @@ export async function removeWorktree(
 	worktreePath: string,
 ): Promise<void> {
 	try {
-		// Get merged environment (process.env + shell env for PATH)
 		const env = await getGitEnv();
 
-		// Use execFile with arg array for proper POSIX compatibility
 		await execFileAsync(
 			"git",
 			["-C", mainRepoPath, "worktree", "remove", worktreePath, "--force"],
@@ -255,12 +218,6 @@ export async function getGitRoot(path: string): Promise<string> {
 	}
 }
 
-/**
- * Checks if a worktree exists in git's worktree list
- * @param mainRepoPath - Path to the main repository
- * @param worktreePath - Path to the worktree to check
- * @returns true if the worktree exists in git, false otherwise
- */
 export async function worktreeExists(
 	mainRepoPath: string,
 	worktreePath: string,
@@ -269,8 +226,6 @@ export async function worktreeExists(
 		const git = simpleGit(mainRepoPath);
 		const worktrees = await git.raw(["worktree", "list", "--porcelain"]);
 
-		// Parse porcelain format to verify worktree exists
-		// Format: "worktree /path/to/worktree" followed by HEAD, branch, etc.
 		const lines = worktrees.split("\n");
 		const worktreePrefix = `worktree ${worktreePath}`;
 		return lines.some((line) => line.trim() === worktreePrefix);
@@ -280,9 +235,6 @@ export async function worktreeExists(
 	}
 }
 
-/**
- * Checks if the repository has an 'origin' remote configured
- */
 export async function hasOriginRemote(mainRepoPath: string): Promise<boolean> {
 	try {
 		const git = simpleGit(mainRepoPath);
@@ -293,13 +245,6 @@ export async function hasOriginRemote(mainRepoPath: string): Promise<boolean> {
 	}
 }
 
-/**
- * Detects the default branch of a repository by checking:
- * 1. Remote HEAD reference (origin/HEAD -> origin/main or origin/master)
- * 2. Common branch names from local refs (main, master, develop, trunk)
- * 3. Remote HEAD via ls-remote (fallback when local refs not fetched)
- * 4. Fallback to 'main'
- */
 export async function getDefaultBranch(mainRepoPath: string): Promise<string> {
 	const git = simpleGit(mainRepoPath);
 
@@ -307,9 +252,7 @@ export async function getDefaultBranch(mainRepoPath: string): Promise<string> {
 		const headRef = await git.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
 		const match = headRef.trim().match(/refs\/remotes\/origin\/(.+)/);
 		if (match) return match[1];
-	} catch {
-		// origin/HEAD not set, continue to fallback
-	}
+	} catch {}
 
 	try {
 		const branches = await git.branch(["-r"]);
@@ -320,9 +263,7 @@ export async function getDefaultBranch(mainRepoPath: string): Promise<string> {
 				return candidate;
 			}
 		}
-	} catch {
-		// Failed to list branches
-	}
+	} catch {}
 
 	try {
 		const hasRemote = await hasOriginRemote(mainRepoPath);
@@ -333,19 +274,11 @@ export async function getDefaultBranch(mainRepoPath: string): Promise<string> {
 				return symrefMatch[1];
 			}
 		}
-	} catch {
-		// Failed to query remote
-	}
+	} catch {}
 
 	return "main";
 }
 
-/**
- * Fetches the default branch from origin and returns the latest commit SHA
- * @param mainRepoPath - Path to the main repository
- * @param defaultBranch - The default branch name (e.g., 'main', 'master')
- * @returns The commit SHA of origin/{defaultBranch} after fetch
- */
 export async function fetchDefaultBranch(
 	mainRepoPath: string,
 	defaultBranch: string,
@@ -356,12 +289,6 @@ export async function fetchDefaultBranch(
 	return commit.trim();
 }
 
-/**
- * Checks if a worktree's branch is behind the default branch
- * @param worktreePath - Path to the worktree
- * @param defaultBranch - The default branch name (e.g., 'main', 'master')
- * @returns true if the branch has commits on origin/{defaultBranch} that it doesn't have
- */
 export async function checkNeedsRebase(
 	worktreePath: string,
 	defaultBranch: string,
@@ -375,11 +302,6 @@ export async function checkNeedsRebase(
 	return Number.parseInt(behindCount.trim(), 10) > 0;
 }
 
-/**
- * Checks if a worktree has uncommitted changes (staged, unstaged, or untracked files)
- * @param worktreePath - Path to the worktree
- * @returns true if there are any uncommitted changes
- */
 export async function hasUncommittedChanges(
 	worktreePath: string,
 ): Promise<boolean> {
@@ -388,18 +310,11 @@ export async function hasUncommittedChanges(
 	return !status.isClean();
 }
 
-/**
- * Checks if a worktree has commits that haven't been pushed to the remote
- * @param worktreePath - Path to the worktree
- * @returns true if there are unpushed commits, false if all commits are pushed or no upstream exists
- */
 export async function hasUnpushedCommits(
 	worktreePath: string,
 ): Promise<boolean> {
 	const git = simpleGit(worktreePath);
 	try {
-		// Count commits that are on HEAD but not on the upstream tracking branch
-		// @{upstream} refers to the configured upstream branch (e.g., origin/branch-name)
 		const aheadCount = await git.raw([
 			"rev-list",
 			"--count",
@@ -407,10 +322,7 @@ export async function hasUnpushedCommits(
 		]);
 		return Number.parseInt(aheadCount.trim(), 10) > 0;
 	} catch {
-		// No upstream configured or other error - check if any commits exist at all
-		// that aren't on origin (for branches without tracking)
 		try {
-			// If there's no upstream, check if branch has commits not on any remote
 			const localCommits = await git.raw([
 				"rev-list",
 				"--count",
@@ -420,19 +332,11 @@ export async function hasUnpushedCommits(
 			]);
 			return Number.parseInt(localCommits.trim(), 10) > 0;
 		} catch {
-			// If all else fails, assume no unpushed commits
 			return false;
 		}
 	}
 }
 
-/**
- * Checks if a branch exists on the remote (origin) by querying the remote directly.
- * Uses `git ls-remote` to check the actual remote state, not just locally fetched refs.
- * @param worktreePath - Path to the worktree
- * @param branchName - The branch name to check
- * @returns true if the branch exists on origin
- */
 export async function branchExistsOnRemote(
 	worktreePath: string,
 	branchName: string,

From cf05921ecfa0823871e42839f0a205e191cbbf94 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 18:30:31 -0800
Subject: [PATCH 5/8] add back some comments

---
 .../src/lib/trpc/routers/changes/utils/parse-status.ts       | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts b/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts
index b2a41ae915e..723473efc8e 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/utils/parse-status.ts
@@ -82,6 +82,8 @@ export function parseGitLog(logOutput: string): CommitInfo[] {
 	for (const line of lines) {
 		if (!line.trim()) continue;
 
+		// Format: hash|shortHash|message|author|date
+		// Use slice(2, -2) to preserve '|' characters in commit messages
 		const parts = line.split("|");
 		if (parts.length < 5) continue;
 
@@ -122,6 +124,8 @@ export function parseDiffNumstat(
 	for (const line of numstatOutput.trim().split("\n")) {
 		if (!line.trim()) continue;
 
+		// Format: additions\tdeletions\tfilepath
+		// For renames: additions\tdeletions\toldpath => newpath
 		const [addStr, delStr, ...pathParts] = line.split("\t");
 		const rawPath = pathParts.join("\t");
 		if (!rawPath) continue;
@@ -150,6 +154,7 @@ export function parseNameStatus(nameStatusOutput: string): ChangedFile[] {
 	for (const line of nameStatusOutput.trim().split("\n")) {
 		if (!line.trim()) continue;
 
+		// Format: status\tfilepath (or status\toldpath\tnewpath for renames)
 		const parts = line.split("\t");
 		const statusCode = parts[0];
 		if (!statusCode) continue;

From cb73ba2d4583f0399bf594803edf62f4b4a6f300 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 18:50:09 -0800
Subject: [PATCH 6/8] deslop

---
 .../trpc/routers/changes/git-operations.ts    | 13 ++++-------
 .../src/lib/trpc/routers/changes/status.ts    |  7 ++++--
 .../Sidebar/ChangesView/ChangesView.tsx       |  1 +
 .../components/CommitInput/CommitInput.tsx    | 22 +++++++++++++++++--
 apps/desktop/src/shared/changes-types.ts      |  1 +
 5 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
index ddc46b86156..7e9f74e87a5 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -1,13 +1,10 @@
-import { execFile } from "node:child_process";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { promisify } from "node:util";
+import { shell } from "electron";
 import simpleGit from "simple-git";
 import { z } from "zod";
 import { publicProcedure, router } from "../..";
 
-const _execFileAsync = promisify(execFile);
-
 export function isUpstreamMissingError(message: string): boolean {
 	return (
 		message.includes("no such ref was fetched") ||
@@ -88,7 +85,7 @@ export const createGitOperationsRouter = () => {
 			.mutation(async ({ input }): Promise<{ success: boolean }> => {
 				const git = simpleGit(input.worktreePath);
 				try {
-					await git.pull();
+					await git.pull(["--rebase"]);
 				} catch (error) {
 					const message =
 						error instanceof Error ? error.message : String(error);
@@ -111,7 +108,7 @@ export const createGitOperationsRouter = () => {
 			.mutation(async ({ input }): Promise<{ success: boolean }> => {
 				const git = simpleGit(input.worktreePath);
 				try {
-					await git.pull();
+					await git.pull(["--rebase"]);
 				} catch (error) {
 					const message =
 						error instanceof Error ? error.message : String(error);
@@ -161,9 +158,7 @@ export const createGitOperationsRouter = () => {
 					const repo = repoMatch[1].replace(/\.git$/, "");
 					const url = `https://github.com/${repo}/compare/${branch}?expand=1`;
 
-					const { exec } = await import("node:child_process");
-					exec(`open "${url}"`);
-
+					await shell.openExternal(url);
 					await git.fetch();
 
 					return { success: true, url };
diff --git a/apps/desktop/src/lib/trpc/routers/changes/status.ts b/apps/desktop/src/lib/trpc/routers/changes/status.ts
index ec7a26f4a6b..132306dc26e 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/status.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/status.ts
@@ -52,6 +52,7 @@ export const createStatusRouter = () => {
 					behind: branchComparison.behind,
 					pushCount: trackingStatus.pushCount,
 					pullCount: trackingStatus.pullCount,
+					hasUpstream: trackingStatus.hasUpstream,
 				};
 			}),
 
@@ -158,6 +159,7 @@ async function applyUntrackedLineCount(
 interface TrackingStatus {
 	pushCount: number;
 	pullCount: number;
+	hasUpstream: boolean;
 }
 
 async function getTrackingBranchStatus(
@@ -170,7 +172,7 @@ async function getTrackingBranchStatus(
 			"@{upstream}",
 		]);
 		if (!upstream.trim()) {
-			return { pushCount: 0, pullCount: 0 };
+			return { pushCount: 0, pullCount: 0, hasUpstream: false };
 		}
 
 		const tracking = await git.raw([
@@ -183,8 +185,9 @@ async function getTrackingBranchStatus(
 		return {
 			pushCount: Number.parseInt(pushStr || "0", 10),
 			pullCount: Number.parseInt(pullStr || "0", 10),
+			hasUpstream: true,
 		};
 	} catch {
-		return { pushCount: 0, pullCount: 0 };
+		return { pushCount: 0, pullCount: 0, hasUpstream: false };
 	}
 }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
index d283a57b40e..3397698b7ab 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx
@@ -214,6 +214,7 @@ export function ChangesView() {
 				hasStagedChanges={hasStagedChanges}
 				pushCount={status.pushCount}
 				pullCount={status.pullCount}
+				hasUpstream={status.hasUpstream}
 				hasExistingPR={hasExistingPR}
 				prUrl={prUrl}
 				onRefresh={handleRefresh}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
index 3963b0e7d81..e0fb7b3710d 100644
--- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
+++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/components/CommitInput/CommitInput.tsx
@@ -26,6 +26,7 @@ interface CommitInputProps {
 	hasStagedChanges: boolean;
 	pushCount: number;
 	pullCount: number;
+	hasUpstream: boolean;
 	hasExistingPR: boolean;
 	prUrl?: string;
 	onRefresh: () => void;
@@ -38,6 +39,7 @@ export function CommitInput({
 	hasStagedChanges,
 	pushCount,
 	pullCount,
+	hasUpstream,
 	hasExistingPR,
 	prUrl,
 	onRefresh,
@@ -179,6 +181,17 @@ export function CommitInput({
 				tooltip: `Pull ${pullCount} commit${pullCount !== 1 ? "s" : ""}`,
 			};
 		}
+		// No upstream - show Publish Branch option
+		if (!hasUpstream) {
+			return {
+				action: "push",
+				label: "Publish Branch",
+				icon: <HiArrowUp className="size-4" />,
+				handler: handlePush,
+				disabled: isPending,
+				tooltip: "Publish branch to remote",
+			};
+		}
 		return {
 			action: "commit",
 			label: "Commit",
@@ -264,9 +277,14 @@ export function CommitInput({
 						<DropdownMenuSeparator />
 
 						{/* Sync actions */}
-						<DropdownMenuItem onClick={handlePush} disabled={pushCount === 0}>
+						<DropdownMenuItem
+							onClick={handlePush}
+							disabled={pushCount === 0 && hasUpstream}
+						>
 							<HiArrowUp className="size-4" />
-							<span className="flex-1">Push</span>
+							<span className="flex-1">
+								{hasUpstream ? "Push" : "Publish Branch"}
+							</span>
 							{pushCount > 0 && (
 								<span className="text-xs text-muted-foreground">
 									{pushCount}
diff --git a/apps/desktop/src/shared/changes-types.ts b/apps/desktop/src/shared/changes-types.ts
index b5d05853d42..e09d19f1315 100644
--- a/apps/desktop/src/shared/changes-types.ts
+++ b/apps/desktop/src/shared/changes-types.ts
@@ -51,6 +51,7 @@ export interface GitChangesStatus {
 	// Tracking branch status (for push/pull)
 	pushCount: number; // Commits to push to tracking branch
 	pullCount: number; // Commits to pull from tracking branch
+	hasUpstream: boolean; // Whether branch has an upstream tracking branch
 }
 
 /** Diff view mode toggle */

From 913eebf3f6decbdb535cea56e4e0a91c65ac0a4a Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 18:57:01 -0800
Subject: [PATCH 7/8] fix tests

---
 .../lib/trpc/routers/changes/git-operations.test.ts    |  2 +-
 .../src/lib/trpc/routers/changes/git-operations.ts     |  9 ++-------
 apps/desktop/src/lib/trpc/routers/changes/git-utils.ts | 10 ++++++++++
 3 files changed, 13 insertions(+), 8 deletions(-)
 create mode 100644 apps/desktop/src/lib/trpc/routers/changes/git-utils.ts

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
index 789bf54118f..0d8cf966873 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { isUpstreamMissingError } from "./git-operations";
+import { isUpstreamMissingError } from "./git-utils";
 
 describe("git-operations error handling", () => {
 	describe("isUpstreamMissingError", () => {
diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
index 7e9f74e87a5..217022eca45 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -4,14 +4,9 @@ import { shell } from "electron";
 import simpleGit from "simple-git";
 import { z } from "zod";
 import { publicProcedure, router } from "../..";
+import { isUpstreamMissingError } from "./git-utils";
 
-export function isUpstreamMissingError(message: string): boolean {
-	return (
-		message.includes("no such ref was fetched") ||
-		message.includes("no tracking information") ||
-		message.includes("couldn't find remote ref")
-	);
-}
+export { isUpstreamMissingError };
 
 async function hasUpstreamBranch(
 	git: ReturnType<typeof simpleGit>,
diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-utils.ts b/apps/desktop/src/lib/trpc/routers/changes/git-utils.ts
new file mode 100644
index 00000000000..701c2e62f4c
--- /dev/null
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-utils.ts
@@ -0,0 +1,10 @@
+/**
+ * Check if the error message indicates the upstream branch is missing/deleted
+ */
+export function isUpstreamMissingError(message: string): boolean {
+	return (
+		message.includes("no such ref was fetched") ||
+		message.includes("no tracking information") ||
+		message.includes("couldn't find remote ref")
+	);
+}

From 1ff472ac7e248ea8e483b402cd991fbb9f9c7458 Mon Sep 17 00:00:00 2001
From: Kiet Ho <hoakiet98@gmail.com>
Date: Wed, 17 Dec 2025 19:03:03 -0800
Subject: [PATCH 8/8] fix traversal

---
 .../src/lib/trpc/routers/changes/git-operations.ts     | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
index 217022eca45..6e6f584cfe4 100644
--- a/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
+++ b/apps/desktop/src/lib/trpc/routers/changes/git-operations.ts
@@ -1,5 +1,5 @@
 import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { resolve } from "node:path";
 import { shell } from "electron";
 import simpleGit from "simple-git";
 import { z } from "zod";
@@ -30,7 +30,13 @@ export const createGitOperationsRouter = () => {
 				}),
 			)
 			.mutation(async ({ input }): Promise<{ success: boolean }> => {
-				const fullPath = join(input.worktreePath, input.filePath);
+				const resolvedWorktree = resolve(input.worktreePath);
+				const fullPath = resolve(resolvedWorktree, input.filePath);
+
+				if (!fullPath.startsWith(`${resolvedWorktree}/`)) {
+					throw new Error("Invalid file path: path traversal detected");
+				}
+
 				await writeFile(fullPath, input.content, "utf-8");
 				return { success: true };
 			}),