Shorten git sync success notifications

Author: pallyoung

packages/server/src/__tests__/git/cli.test.ts

@@ -918,6 +918,10 @@ describe("runGitPush", () => {
     const result = await runGitPush(testDir);
 
     expect(result.success).toBe(true);
+    expect(result.message).toBe("Push completed successfully");
+    expect(result.remote).toBe("origin");
+    expect(result.branch).toBe("feature/push-test");
+    expect(result.updated).toBe(true);
 
     const { stdout: upstreamOutput } = await execFileAsync(
       "git",
@@ -934,6 +938,23 @@ describe("runGitPush", () => {
     expect(remoteOutput).toContain("feature/push-test");
   });
 
+  it("returns a stable no-op summary when push is already up to date", async () => {
+    await writeFile(join(testDir, "README.md"), "init\n");
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "initial"], { cwd: testDir });
+    await execFileAsync("git", ["remote", "add", "origin", remoteDir], { cwd: testDir });
+    const defaultBranch = await getCurrentBranch(testDir);
+    await execFileAsync("git", ["push", "-u", "origin", defaultBranch], { cwd: testDir });
+
+    const result = await runGitPush(testDir);
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Push completed successfully");
+    expect(result.remote).toBe("origin");
+    expect(result.branch).toBe(defaultBranch);
+    expect(result.updated).toBe(false);
+  });
+
   it("persists successful HTTP credentials through the configured credential helper", async () => {
     const helperLog = join(testDir, "credential-helper.log");
     const helperScript = join(testDir, "credential-helper.sh");
@@ -1250,6 +1271,10 @@ describe("runGitPull", () => {
     const result = await runGitPull(primaryDir);
 
     expect(result.success).toBe(true);
+    expect(result.message).toBe("Pull completed successfully");
+    expect(result.remote).toBe("origin");
+    expect(result.branch).toBe(contributorBranch);
+    expect(result.updated).toBe(true);
 
     const { stdout } = await execFileAsync("git", ["rev-parse", "@{upstream}"], {
       cwd: primaryDir,
@@ -1259,4 +1284,14 @@ describe("runGitPull", () => {
     });
     expect(headStdout.trim()).toBe(stdout.trim());
   });
+
+  it("returns a stable no-op summary when pull is already up to date", async () => {
+    const result = await runGitPull(primaryDir);
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Pull completed successfully");
+    expect(result.remote).toBe("origin");
+    expect(result.branch).toBe(await getCurrentBranch(primaryDir));
+    expect(result.updated).toBe(false);
+  });
 });

packages/server/src/git/cli.ts

@@ -34,6 +34,14 @@ export interface GitHttpAuth {
   password: string;
 }
 
+interface GitSyncSuccessResult {
+  success: boolean;
+  message: string;
+  remote?: string;
+  branch?: string;
+  updated?: boolean;
+}
+
 export interface GitAuthFailureDetails {
   operation: "push" | "pull" | "fetch";
   remote?: string;
@@ -306,7 +314,7 @@ export async function runGitPush(
     force?: boolean;
     auth?: GitHttpAuth;
   }
-): Promise<{ success: boolean; message: string }> {
+): Promise<GitSyncSuccessResult> {
   const args = ["push"];
   let remote = options?.remote;
   let branch = options?.branch;
@@ -335,6 +343,8 @@ export async function runGitPush(
     remote = (await getPreferredRemote(cwd)) ?? undefined;
   }
 
+  const summaryBranch = branch ?? (await getCurrentBranchName(cwd));
+
   if (remote && branch) {
     args.push(remote, `HEAD:${branch}`);
   } else if (remote) {
@@ -355,10 +365,13 @@ export async function runGitPush(
       await persistGitHttpCredentials(cwd, options.auth, remoteMetadata);
     }
 
-    // Combine output for message
-    const message = stdout || stderr || "Push completed successfully";
-
-    return { success: true, message };
+    return {
+      success: true,
+      message: "Push completed successfully",
+      remote,
+      branch: summaryBranch,
+      updated: !isPushUpToDate(stdout, stderr),
+    };
   } catch (error) {
     throw normalizeGitAuthFailure(error, {
       operation: "push",
@@ -381,7 +394,7 @@ export async function runGitPull(
     branch?: string;
     auth?: GitHttpAuth;
   }
-): Promise<{ success: boolean; message: string; updatedFiles?: string[] }> {
+): Promise<GitSyncSuccessResult & { updatedFiles?: string[] }> {
   const args = ["pull"];
   let remote = options?.remote;
   let branch = options?.branch;
@@ -396,6 +409,8 @@ export async function runGitPull(
     remote = (await getPreferredRemote(cwd)) ?? "origin";
   }
 
+  const summaryBranch = branch ?? (await getCurrentBranchName(cwd));
+
   if (remote && branch) {
     args.push(remote, branch);
   }
@@ -430,9 +445,14 @@ export async function runGitPull(
       }
     }
 
-    const message = stdout || stderr || "Pull completed successfully";
-
-    return { success: true, message, updatedFiles };
+    return {
+      success: true,
+      message: "Pull completed successfully",
+      remote,
+      branch: summaryBranch,
+      updated: !isPullUpToDate(stdout, stderr),
+      updatedFiles,
+    };
   } catch (error) {
     throw normalizeGitAuthFailure(error, {
       operation: "pull",
@@ -707,6 +727,24 @@ async function resolveRemoteBranchTarget(
   }
 }
 
+async function getCurrentBranchName(cwd: string): Promise<string | undefined> {
+  try {
+    const { stdout } = await runGit(cwd, ["branch", "--show-current"]);
+    const branch = stdout.trim();
+    return branch || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isPushUpToDate(stdout: string, stderr: string): boolean {
+  return /Everything up-to-date/i.test(`${stdout}\n${stderr}`);
+}
+
+function isPullUpToDate(stdout: string, stderr: string): boolean {
+  return /Already up[ -]to[ -]date\.?/i.test(`${stdout}\n${stderr}`);
+}
+
 async function getPreferredRemote(cwd: string): Promise<string | null> {
   try {
     const { stdout } = await runGit(cwd, ["remote"]);

packages/web/src/features/workspace/actions/use-git-actions.ts

@@ -43,6 +43,9 @@ interface GitCheckoutResult {
 interface GitSyncResult {
   success: boolean;
   message: string;
+  remote?: string;
+  branch?: string;
+  updated?: boolean;
   updatedFiles?: string[];
 }
 
@@ -76,6 +79,13 @@ const GIT_OPERATION_LABELS: Record<"push" | "pull" | "fetch", string> = {
   fetch: "git.operation_fetch",
 };
 
+function formatGitSyncTarget(remote?: string, branch?: string): string | null {
+  if (remote && branch) {
+    return `${remote}/${branch}`;
+  }
+  return null;
+}
+
 export function useGitSyncActions(workspaceId: string) {
   const t = useTranslation();
   const dispatch = useAtomValue(dispatchCommandAtom);
@@ -109,6 +119,34 @@ export function useGitSyncActions(workspaceId: string) {
     [t]
   );
 
+  const getSuccessToastBody = useCallback(
+    (
+      op: "git.push" | "git.pull" | "git.fetch",
+      result: GitSyncResult,
+      fallbackSuccessBody?: string
+    ) => {
+      if (op === "git.fetch") {
+        return result.message || fallbackSuccessBody;
+      }
+
+      const target = formatGitSyncTarget(result.remote, result.branch);
+      if (target) {
+        if (op === "git.push") {
+          return result.updated
+            ? t("git.push_success_target", { target })
+            : t("git.sync_up_to_date", { target });
+        }
+
+        return result.updated
+          ? t("git.pull_success_target", { target })
+          : t("git.sync_up_to_date", { target });
+      }
+
+      return result.message || fallbackSuccessBody;
+    },
+    [t]
+  );
+
   const refreshBranchState = useCallback(async () => {
     if (!workspaceId) {
       return false;
@@ -261,7 +299,7 @@ export function useGitSyncActions(workspaceId: string) {
         pushToast({
           kind: "success",
           title: options.successTitle,
-          body: result.data.message || options.fallbackSuccessBody,
+          body: getSuccessToastBody(op, result.data, options.fallbackSuccessBody),
         });
 
         return true;
@@ -272,6 +310,7 @@ export function useGitSyncActions(workspaceId: string) {
     [
       authPrompt,
       dispatch,
+      getSuccessToastBody,
       pushToast,
       refreshBranchState,
       setFetchState,

packages/web/src/features/workspace/views/shared/git-status-bar.test.tsx

@@ -71,7 +71,13 @@ describe("GitStatusBar", () => {
     const sendCommand = vi.fn().mockImplementation(async (op: string) => {
       if (op === "git.push") {
         await pushPromise;
-        return { success: true, message: "Push completed successfully" };
+        return {
+          success: true,
+          message: "Push completed successfully",
+          remote: "origin",
+          branch: "main",
+          updated: true,
+        };
       }
 
       if (op === "git.branches") {
@@ -126,6 +132,7 @@ describe("GitStatusBar", () => {
 
     expect(store.get(gitStateAtomFamily("ws-test"))?.ahead).toBe(0);
     expect(store.get(toastsAtom)[0]?.title).toBe("Push completed");
+    expect(store.get(toastsAtom)[0]?.body).toBe("Pushed to origin/main");
   });
 
   it("shows pull confirmation and does not dispatch when cancelled", async () => {
@@ -151,6 +158,58 @@ describe("GitStatusBar", () => {
     expect(sendCommand).not.toHaveBeenCalledWith("git.pull", { workspaceId: "ws-test" });
   });
 
+  it("formats a short localized no-op pull success body", async () => {
+    const sendCommand = vi.fn().mockImplementation(async (op: string) => {
+      if (op === "git.pull") {
+        return {
+          success: true,
+          message: "Pull completed successfully",
+          remote: "origin",
+          branch: "main",
+          updated: false,
+        };
+      }
+
+      if (op === "git.branches") {
+        return {
+          current: "main",
+          branches: [{ name: "main", isRemote: false, isCurrent: true }],
+        };
+      }
+
+      if (op === "git.status") {
+        return {
+          ...baseStatus,
+          behind: 0,
+        };
+      }
+
+      throw new Error(`Unexpected command: ${op}`);
+    });
+
+    const { store } = renderStatusBar({
+      locale: "zh",
+      status: {
+        ...baseStatus,
+        ahead: 0,
+        behind: 1,
+      },
+      sendCommand,
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "拉取" }));
+    const modal = screen.getByText("拉取更改").closest(".modal-card");
+    expect(modal).not.toBeNull();
+    fireEvent.click(within(modal as HTMLElement).getByRole("button", { name: "拉取" }));
+
+    await waitFor(() => {
+      expect(store.get(toastsAtom)[0]).toMatchObject({
+        title: "拉取完成",
+        body: "origin/main 已是最新",
+      });
+    });
+  });
+
   it("renders sync dialog text actions with shared button compatibility classes", async () => {
     const sendCommand = vi.fn();
 

packages/web/src/locales/en.json

@@ -348,8 +348,11 @@
     "sync_confirm_helper": "This action updates your current branch and workspace state.",
     "push_success_title": "Push completed",
     "push_success_body": "Local commits were pushed to the remote.",
+    "push_success_target": "Pushed to {target}",
     "pull_success_title": "Pull completed",
     "pull_success_body": "Latest remote commits were pulled into your local branch.",
+    "pull_success_target": "Pulled updates from {target}",
+    "sync_up_to_date": "{target} is already up to date",
     "push_in_progress": "Pushing...",
     "pull_in_progress": "Pulling...",
     "push_failed_title": "Push failed",

packages/web/src/locales/zh.json

@@ -348,8 +348,11 @@
     "sync_confirm_helper": "该操作会更新当前分支和工作区状态。",
     "push_success_title": "推送完成",
     "push_success_body": "本地提交已推送到远端。",
+    "push_success_target": "已推送到 {target}",
     "pull_success_title": "拉取完成",
     "pull_success_body": "已拉取远端最新提交到当前分支。",
+    "pull_success_target": "已从 {target} 拉取更新",
+    "sync_up_to_date": "{target} 已是最新",
     "push_in_progress": "推送中...",
     "pull_in_progress": "拉取中...",
     "push_failed_title": "推送失败",