fix(vscode): fall back to git CLI for diffs

Author: yzlu0917

extensions/vscode/src/util/gitDiffFallback.ts

@@ -0,0 +1,69 @@
+export type ExecFn = (
+  command: string,
+  options: { cwd: string; maxBuffer?: number },
+) => Promise<{
+  stdout: string;
+  stderr?: string;
+}>;
+
+const GIT_DIFF_MAX_BUFFER = 10 * 1024 * 1024;
+
+export function splitGitDiff(diffString: string): string[] {
+  const fileDiffHeaderRegex = /(?=diff --git a\/.* b\/.*)/;
+  const diffs = diffString.split(fileDiffHeaderRegex);
+
+  if (diffs[0]?.trim() === "") {
+    diffs.shift();
+  }
+
+  return diffs.filter((diff) => diff.trim().length > 0);
+}
+
+export async function collectGitDiffsWithCli(
+  candidateDirs: string[],
+  includeUnstaged: boolean,
+  execFn: ExecFn,
+): Promise<string[]> {
+  const visitedRoots = new Set<string>();
+  const diffs: string[] = [];
+
+  for (const candidateDir of candidateDirs) {
+    if (!candidateDir) {
+      continue;
+    }
+
+    let root: string;
+    try {
+      const { stdout } = await execFn("git rev-parse --show-toplevel", {
+        cwd: candidateDir,
+        maxBuffer: GIT_DIFF_MAX_BUFFER,
+      });
+      root = stdout.trim();
+    } catch {
+      continue;
+    }
+
+    if (!root || visitedRoots.has(root)) {
+      continue;
+    }
+    visitedRoots.add(root);
+
+    const commands = includeUnstaged
+      ? ["git diff --cached", "git diff"]
+      : ["git diff --cached"];
+
+    for (const command of commands) {
+      try {
+        const { stdout } = await execFn(command, {
+          cwd: root,
+          maxBuffer: GIT_DIFF_MAX_BUFFER,
+        });
+        diffs.push(...splitGitDiff(stdout));
+      } catch {
+        // Skip directories where git diff cannot be retrieved via CLI.
+      }
+    }
+  }
+
+  return diffs;
+}

extensions/vscode/src/util/gitDiffFallback.vitest.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { collectGitDiffsWithCli, splitGitDiff } from "./gitDiffFallback";
+
+describe("splitGitDiff", () => {
+  it("splits combined git diff output into per-file entries", () => {
+    const combined = [
+      "diff --git a/a.txt b/a.txt\n+hello",
+      "diff --git a/b.txt b/b.txt\n+world",
+    ].join("\n");
+
+    expect(splitGitDiff(combined)).toEqual([
+      "diff --git a/a.txt b/a.txt\n+hello\n",
+      "diff --git a/b.txt b/b.txt\n+world",
+    ]);
+  });
+});
+
+describe("collectGitDiffsWithCli", () => {
+  it("falls back to git CLI and returns staged and unstaged diffs", async () => {
+    const execFn = vi.fn(async (command: string, options: { cwd: string }) => {
+      if (command === "git rev-parse --show-toplevel") {
+        return { stdout: "/repo\n" };
+      }
+      if (command === "git diff --cached") {
+        expect(options.cwd).toBe("/repo");
+        return { stdout: "diff --git a/staged.ts b/staged.ts\n+staged\n" };
+      }
+      if (command === "git diff") {
+        expect(options.cwd).toBe("/repo");
+        return { stdout: "diff --git a/unstaged.ts b/unstaged.ts\n+unstaged\n" };
+      }
+      throw new Error("unexpected command: " + command);
+    });
+
+    await expect(
+      collectGitDiffsWithCli(["/repo", "/repo/subdir"], true, execFn),
+    ).resolves.toEqual([
+      "diff --git a/staged.ts b/staged.ts\n+staged\n",
+      "diff --git a/unstaged.ts b/unstaged.ts\n+unstaged\n",
+    ]);
+
+    expect(execFn).toHaveBeenCalledTimes(4);
+  });
+
+  it("skips non-git directories and only uses staged diff when requested", async () => {
+    const execFn = vi.fn(async (command: string, options: { cwd: string }) => {
+      if (
+        command === "git rev-parse --show-toplevel" &&
+        options.cwd === "/not-a-repo"
+      ) {
+        throw new Error("fatal: not a git repository");
+      }
+      if (command === "git rev-parse --show-toplevel" && options.cwd === "/repo") {
+        return { stdout: "/repo\n" };
+      }
+      if (command === "git diff --cached") {
+        return { stdout: "diff --git a/file.ts b/file.ts\n+only-staged\n" };
+      }
+      throw new Error("unexpected command: " + command);
+    });
+
+    await expect(
+      collectGitDiffsWithCli(["/not-a-repo", "/repo"], false, execFn),
+    ).resolves.toEqual(["diff --git a/file.ts b/file.ts\n+only-staged\n"]);
+
+    expect(execFn).toHaveBeenCalledTimes(3);
+  });
+});

extensions/vscode/src/util/ideUtils.ts

@@ -14,6 +14,7 @@ import {
   showSuggestion as showSuggestionInEditor,
 } from "../suggestions";
 
+import { collectGitDiffsWithCli, splitGitDiff } from "./gitDiffFallback";
 import { getUniqueId, openEditorAndRevealRange } from "./vscode";
 
 import type { Range, Thread } from "core";
@@ -604,37 +605,37 @@ export class VsCodeIdeUtils {
     return repo?.state?.HEAD?.name || "NONE";
   }
 
-  private splitDiff(diffString: string): string[] {
-    const fileDiffHeaderRegex = /(?=diff --git a\/.* b\/.*)/;
-
-    const diffs = diffString.split(fileDiffHeaderRegex);
-
-    if (diffs[0].trim() === "") {
-      diffs.shift();
-    }
-
-    return diffs;
-  }
-
   async getDiff(includeUnstaged: boolean): Promise<string[]> {
-    const diffs: string[] = [];
-
+    const apiDiffs: string[] = [];
     const repos = this._getRepositories();
 
     try {
       if (repos) {
         for (const repo of repos) {
-          const staged = await repo.diff(true);
-
-          diffs.push(staged);
+          apiDiffs.push(await repo.diff(true));
           if (includeUnstaged) {
-            const unstaged = await repo.diff(false);
-            diffs.push(unstaged);
+            apiDiffs.push(await repo.diff(false));
           }
         }
       }
 
-      return diffs.flatMap((diff) => this.splitDiff(diff));
+      const parsedApiDiffs = apiDiffs.flatMap((diff) => splitGitDiff(diff));
+      if (parsedApiDiffs.length > 0) {
+        return parsedApiDiffs;
+      }
+
+      const candidateDirs = Array.from(
+        new Set([
+          ...(repos?.map((repo) => repo.rootUri.fsPath) ?? []),
+          ...this.getWorkspaceDirectories().map((dir) => dir.fsPath),
+        ]),
+      );
+
+      return await collectGitDiffsWithCli(
+        candidateDirs,
+        includeUnstaged,
+        asyncExec,
+      );
     } catch (e) {
       console.error(e);
       return [];