From a8c149bfd541b6263bd1f1bc7946981bf5a24cd5 Mon Sep 17 00:00:00 2001
From: p0ny <p0uy@outlook.com>
Date: Wed, 18 Mar 2026 16:32:42 +0800
Subject: [PATCH 1/6] Fix diff parser git header prefixes

---
 src/common/utils/git/diffParser.test.ts | 21 +++++++++++++++++++++
 src/common/utils/git/diffParser.ts      | 16 +++++++++-------
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/src/common/utils/git/diffParser.test.ts b/src/common/utils/git/diffParser.test.ts
index 7847e254e4..b43c6a305a 100644
--- a/src/common/utils/git/diffParser.test.ts
+++ b/src/common/utils/git/diffParser.test.ts
@@ -121,6 +121,27 @@ describe("git diff parser (real repository)", () => {
     expect(nonPhantomLines.every((l) => l.startsWith("+"))).toBe(true);
   });
 
+  it("should parse diff headers with non-literal path prefixes", () => {
+    const diffOutput = [
+      "diff --git c/foo.ts w/foo.ts",
+      "index 1111111..2222222 100644",
+      "--- c/foo.ts",
+      "+++ w/foo.ts",
+      "@@ -1 +1 @@",
+      "-old line",
+      "+new line",
+    ].join("\n");
+
+    const fileDiffs = parseDiff(diffOutput);
+    const allHunks = extractAllHunks(fileDiffs);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].filePath).toBe("foo.ts");
+    expect(fileDiffs[0].oldPath).toBeUndefined();
+    expect(allHunks).toHaveLength(1);
+    expect(allHunks[0].content).toContain("+new line");
+  });
+
   it("should normalize CRLF diff output (no \\r in hunk content)", () => {
     const diffOutput =
       [
diff --git a/src/common/utils/git/diffParser.ts b/src/common/utils/git/diffParser.ts
index 85e04621a8..bc70b91680 100644
--- a/src/common/utils/git/diffParser.ts
+++ b/src/common/utils/git/diffParser.ts
@@ -95,15 +95,17 @@ export function parseDiff(diffOutput: string): FileDiff[] {
   };
 
   for (const line of lines) {
-    // File header: diff --git a/... b/...
+    // File header: git emits path labels here, but they are not guaranteed to be literal a/ and b/.
     if (line.startsWith("diff --git ")) {
       finishFile();
-      // Extract file paths from "diff --git a/path b/path"
-      const regex = /^diff --git a\/(.+) b\/(.+)$/;
-      const match = regex.exec(line);
-      if (match) {
-        const oldPath = match[1];
-        const newPath = match[2];
+      // Extract the trailing paths from "diff --git <label>/path <label>/path" without
+      // assuming specific labels. Review diffs can use other prefixes (for example c/ and w/).
+      const parts = line.split(" ");
+      if (parts.length >= 4) {
+        const oldPathWithLabel = parts[2];
+        const newPathWithLabel = parts[3];
+        const oldPath = oldPathWithLabel.replace(/^[^/]+\//, "");
+        const newPath = newPathWithLabel.replace(/^[^/]+\//, "");
         currentFile = {
           filePath: newPath,
           oldPath: oldPath !== newPath ? oldPath : undefined,

From e11f3d419181b768a72fe246ae6313d4d1ae5a6e Mon Sep 17 00:00:00 2001
From: p0ny <p0uy@outlook.com>
Date: Wed, 18 Mar 2026 18:13:40 +0800
Subject: [PATCH 2/6] =?UTF-8?q?=F0=9F=A4=96=20fix:=20handle=20no-prefix=20?=
 =?UTF-8?q?diff=20paths?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Teach the diff parser to canonicalize paired git path labels, honor ---/+++ patch headers, and preserve rename metadata so --no-prefix, mnemonic-prefix, add, and delete patches resolve the correct repo-relative paths.

Add regression coverage for real git-generated --no-prefix and mnemonic-prefix diffs, and make the deletion test self-contained so it no longer depends on prior test ordering.
---
 src/common/utils/git/diffParser.test.ts |  87 +++++++++++++-
 src/common/utils/git/diffParser.ts      | 149 ++++++++++++++++++++++--
 2 files changed, 225 insertions(+), 11 deletions(-)

diff --git a/src/common/utils/git/diffParser.test.ts b/src/common/utils/git/diffParser.test.ts
index b43c6a305a..386f0385bc 100644
--- a/src/common/utils/git/diffParser.test.ts
+++ b/src/common/utils/git/diffParser.test.ts
@@ -142,6 +142,87 @@ describe("git diff parser (real repository)", () => {
     expect(allHunks[0].content).toContain("+new line");
   });
 
+  it("should preserve nested paths in --no-prefix diffs", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+    execSync("mkdir -p src/common", { cwd: testRepoPath });
+    writeFileSync(join(testRepoPath, "src", "common", "no-prefix.ts"), "old line\n");
+    execSync("git add src/common/no-prefix.ts && git commit -m 'Add nested no-prefix file'", {
+      cwd: testRepoPath,
+    });
+
+    writeFileSync(join(testRepoPath, "src", "common", "no-prefix.ts"), "new line\n");
+
+    const diff = execSync("git diff --no-prefix HEAD", { cwd: testRepoPath, encoding: "utf-8" });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].filePath).toBe("src/common/no-prefix.ts");
+    expect(fileDiffs[0].oldPath).toBeUndefined();
+    expect(fileDiffs[0].hunks).toHaveLength(1);
+    expect(fileDiffs[0].hunks[0].content).toContain("+new line");
+  });
+
+  it("should parse real mnemonic-prefix diffs", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+    execSync("mkdir -p src/mnemonic", { cwd: testRepoPath });
+    writeFileSync(join(testRepoPath, "src", "mnemonic", "real.ts"), "before\n");
+    execSync("git add src/mnemonic/real.ts && git commit -m 'Add mnemonic test file'", {
+      cwd: testRepoPath,
+    });
+
+    writeFileSync(join(testRepoPath, "src", "mnemonic", "real.ts"), "after\n");
+
+    const diff = execSync("git -c diff.mnemonicPrefix=true diff HEAD", {
+      cwd: testRepoPath,
+      encoding: "utf-8",
+    });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].filePath).toBe("src/mnemonic/real.ts");
+    expect(fileDiffs[0].oldPath).toBeUndefined();
+    expect(fileDiffs[0].hunks[0].content).toContain("+after");
+  });
+
+  it("should parse --no-prefix additions that use /dev/null", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+    execSync("mkdir -p nested/dir", { cwd: testRepoPath });
+    writeFileSync(join(testRepoPath, "nested", "dir", "added-no-prefix.ts"), "added\n");
+    execSync("git add nested/dir/added-no-prefix.ts", { cwd: testRepoPath });
+
+    const diff = execSync("git diff --cached --no-prefix", {
+      cwd: testRepoPath,
+      encoding: "utf-8",
+    });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].changeType).toBe("added");
+    expect(fileDiffs[0].filePath).toBe("nested/dir/added-no-prefix.ts");
+    expect(fileDiffs[0].oldPath).toBeUndefined();
+    expect(fileDiffs[0].hunks[0].header).toMatch(/^@@ -0,0 \+1(?:,1)? @@/);
+  });
+
+  it("should parse --no-prefix deletions that use /dev/null", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+    execSync("mkdir -p deleted/nested", { cwd: testRepoPath });
+    writeFileSync(join(testRepoPath, "deleted", "nested", "gone.ts"), "gone\n");
+    execSync("git add deleted/nested/gone.ts && git commit -m 'Add nested deleted file'", {
+      cwd: testRepoPath,
+    });
+
+    execSync("rm deleted/nested/gone.ts", { cwd: testRepoPath });
+
+    const diff = execSync("git diff --no-prefix HEAD", { cwd: testRepoPath, encoding: "utf-8" });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].changeType).toBe("deleted");
+    expect(fileDiffs[0].filePath).toBe("deleted/nested/gone.ts");
+    expect(fileDiffs[0].oldPath).toBe("deleted/nested/gone.ts");
+    expect(fileDiffs[0].hunks[0].content).toContain("-gone");
+  });
+
   it("should normalize CRLF diff output (no \\r in hunk content)", () => {
     const diffOutput =
       [
@@ -175,10 +256,10 @@ describe("git diff parser (real repository)", () => {
   });
 
   it("should parse file deletion", () => {
-    // Reset and commit newfile
-    execSync("git add . && git commit -m 'Add newfile'", { cwd: testRepoPath });
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+    writeFileSync(join(testRepoPath, "newfile.md"), "# New File\n\nContent here\n");
+    execSync("git add newfile.md && git commit -m 'Add newfile'", { cwd: testRepoPath });
 
-    // Delete file
     execSync("rm newfile.md", { cwd: testRepoPath });
 
     const diff = execSync("git diff HEAD", { cwd: testRepoPath, encoding: "utf-8" });
diff --git a/src/common/utils/git/diffParser.ts b/src/common/utils/git/diffParser.ts
index bc70b91680..86fa975c79 100644
--- a/src/common/utils/git/diffParser.ts
+++ b/src/common/utils/git/diffParser.ts
@@ -48,6 +48,70 @@ function parseHunkHeader(line: string): {
   };
 }
 
+type ParsedDiffPathLabel = {
+  raw: string;
+  prefix: string | null;
+  path: string | null;
+};
+
+function parseDiffPathLabel(label: string | undefined): ParsedDiffPathLabel | null {
+  if (label == null) {
+    return null;
+  }
+
+  if (label === "/dev/null") {
+    return {
+      raw: label,
+      prefix: null,
+      path: null,
+    };
+  }
+
+  const slashIndex = label.indexOf("/");
+  if (slashIndex === -1) {
+    return {
+      raw: label,
+      prefix: null,
+      path: label,
+    };
+  }
+
+  return {
+    raw: label,
+    prefix: label.slice(0, slashIndex),
+    path: label.slice(slashIndex + 1),
+  };
+}
+
+function choosePairedDiffLabel(
+  primaryLabel: string | undefined,
+  fallbackLabel: string | undefined
+): string | undefined {
+  return primaryLabel != null && primaryLabel !== "/dev/null" ? primaryLabel : fallbackLabel;
+}
+
+function canonicalizeDiffPathLabel(
+  label: string | undefined,
+  pairedLabel: string | undefined
+): string | undefined {
+  const parsedLabel = parseDiffPathLabel(label);
+  if (!parsedLabel || parsedLabel.path == null) {
+    return undefined;
+  }
+
+  const parsedPair = parseDiffPathLabel(pairedLabel);
+  if (
+    parsedLabel.prefix &&
+    parsedPair?.prefix &&
+    parsedLabel.prefix !== parsedPair.prefix &&
+    parsedLabel.path === parsedPair.path
+  ) {
+    return parsedLabel.path;
+  }
+
+  return parsedLabel.raw;
+}
+
 /**
  * Parse unified diff output into structured file diffs with hunks
  * Supports standard git diff format with file headers and hunk markers
@@ -63,6 +127,52 @@ export function parseDiff(diffOutput: string): FileDiff[] {
   let currentFile: FileDiff | null = null;
   let currentHunk: Partial<DiffHunk> | null = null;
   let hunkLines: string[] = [];
+  let currentHeaderOldLabel: string | undefined;
+  let currentHeaderNewLabel: string | undefined;
+  let currentPatchOldLabel: string | undefined;
+  let currentPatchNewLabel: string | undefined;
+  let currentRenameFrom: string | undefined;
+  let currentRenameTo: string | undefined;
+
+  const syncCurrentFilePaths = () => {
+    if (!currentFile) {
+      return;
+    }
+
+    const resolvedOldPath =
+      currentRenameFrom ??
+      canonicalizeDiffPathLabel(
+        currentPatchOldLabel ?? currentHeaderOldLabel,
+        choosePairedDiffLabel(currentPatchNewLabel, currentHeaderNewLabel)
+      );
+    const resolvedNewPath =
+      currentRenameTo ??
+      canonicalizeDiffPathLabel(
+        currentPatchNewLabel ?? currentHeaderNewLabel,
+        choosePairedDiffLabel(currentPatchOldLabel, currentHeaderOldLabel)
+      );
+    const filePath = resolvedNewPath ?? resolvedOldPath;
+    if (filePath) {
+      currentFile.filePath = filePath;
+    }
+
+    currentFile.oldPath =
+      resolvedOldPath &&
+      (currentFile.changeType === "deleted" ||
+        currentFile.changeType === "renamed" ||
+        (resolvedNewPath != null && resolvedOldPath !== resolvedNewPath))
+        ? resolvedOldPath
+        : undefined;
+  };
+
+  const resetCurrentFileLabels = () => {
+    currentHeaderOldLabel = undefined;
+    currentHeaderNewLabel = undefined;
+    currentPatchOldLabel = undefined;
+    currentPatchNewLabel = undefined;
+    currentRenameFrom = undefined;
+    currentRenameTo = undefined;
+  };
 
   const finishHunk = () => {
     if (currentHunk && currentFile && hunkLines.length > 0) {
@@ -89,9 +199,11 @@ export function parseDiff(diffOutput: string): FileDiff[] {
   const finishFile = () => {
     finishHunk();
     if (currentFile) {
+      syncCurrentFilePaths();
       files.push(currentFile);
       currentFile = null;
     }
+    resetCurrentFileLabels();
   };
 
   for (const line of lines) {
@@ -102,17 +214,16 @@ export function parseDiff(diffOutput: string): FileDiff[] {
       // assuming specific labels. Review diffs can use other prefixes (for example c/ and w/).
       const parts = line.split(" ");
       if (parts.length >= 4) {
-        const oldPathWithLabel = parts[2];
-        const newPathWithLabel = parts[3];
-        const oldPath = oldPathWithLabel.replace(/^[^/]+\//, "");
-        const newPath = newPathWithLabel.replace(/^[^/]+\//, "");
+        currentHeaderOldLabel = parts[2];
+        currentHeaderNewLabel = parts[3];
         currentFile = {
-          filePath: newPath,
-          oldPath: oldPath !== newPath ? oldPath : undefined,
+          filePath: "",
+          oldPath: undefined,
           changeType: "modified",
           isBinary: false,
           hunks: [],
         };
+        syncCurrentFilePaths();
       }
       continue;
     }
@@ -128,18 +239,40 @@ export function parseDiff(diffOutput: string): FileDiff[] {
     // New file mode
     if (line.startsWith("new file mode ")) {
       currentFile.changeType = "added";
+      syncCurrentFilePaths();
       continue;
     }
 
     // Deleted file mode
     if (line.startsWith("deleted file mode ")) {
       currentFile.changeType = "deleted";
+      syncCurrentFilePaths();
+      continue;
+    }
+
+    if (!currentHunk && line.startsWith("--- ")) {
+      currentPatchOldLabel = line.slice(4);
+      syncCurrentFilePaths();
+      continue;
+    }
+
+    if (!currentHunk && line.startsWith("+++ ")) {
+      currentPatchNewLabel = line.slice(4);
+      syncCurrentFilePaths();
+      continue;
+    }
+
+    if (line.startsWith("rename from ")) {
+      currentFile.changeType = "renamed";
+      currentRenameFrom = line.slice("rename from ".length);
+      syncCurrentFilePaths();
       continue;
     }
 
-    // Rename marker
-    if (line.startsWith("rename from ") || line.startsWith("rename to ")) {
+    if (line.startsWith("rename to ")) {
       currentFile.changeType = "renamed";
+      currentRenameTo = line.slice("rename to ".length);
+      syncCurrentFilePaths();
       continue;
     }
 

From c83ea5e5d3dd441c1f0feac7641aa1323f6c5b12 Mon Sep 17 00:00:00 2001
From: p0ny <p0uy@outlook.com>
Date: Fri, 20 Mar 2026 16:17:16 +0800
Subject: [PATCH 3/6] =?UTF-8?q?=F0=9F=A4=96=20fix:=20satisfy=20diffParser?=
 =?UTF-8?q?=20lint=20rules?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Keep the robust diff parser changes intact while addressing the remaining lint complaints by switching the parsed path label shape to an interface and using an optional chain for the null-path guard.
---
 src/common/utils/git/diffParser.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/common/utils/git/diffParser.ts b/src/common/utils/git/diffParser.ts
index 86fa975c79..5988dbf032 100644
--- a/src/common/utils/git/diffParser.ts
+++ b/src/common/utils/git/diffParser.ts
@@ -48,11 +48,11 @@ function parseHunkHeader(line: string): {
   };
 }
 
-type ParsedDiffPathLabel = {
+interface ParsedDiffPathLabel {
   raw: string;
   prefix: string | null;
   path: string | null;
-};
+}
 
 function parseDiffPathLabel(label: string | undefined): ParsedDiffPathLabel | null {
   if (label == null) {
@@ -95,7 +95,7 @@ function canonicalizeDiffPathLabel(
   pairedLabel: string | undefined
 ): string | undefined {
   const parsedLabel = parseDiffPathLabel(label);
-  if (!parsedLabel || parsedLabel.path == null) {
+  if (parsedLabel?.path == null) {
     return undefined;
   }
 

From 18dd83fbfe14e233bf3d20b017752b91697a03b6 Mon Sep 17 00:00:00 2001
From: p0ny <p0uy@outlook.com>
Date: Fri, 20 Mar 2026 16:45:21 +0800
Subject: [PATCH 4/6] =?UTF-8?q?=F0=9F=A4=96=20fix:=20harden=20diff=20path?=
 =?UTF-8?q?=20parsing?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/common/utils/git/diffParser.test.ts |  41 +++++
 src/common/utils/git/diffParser.ts      | 215 +++++++++++++++++++++---
 2 files changed, 232 insertions(+), 24 deletions(-)

diff --git a/src/common/utils/git/diffParser.test.ts b/src/common/utils/git/diffParser.test.ts
index 386f0385bc..b8274c5b2b 100644
--- a/src/common/utils/git/diffParser.test.ts
+++ b/src/common/utils/git/diffParser.test.ts
@@ -142,6 +142,47 @@ describe("git diff parser (real repository)", () => {
     expect(allHunks[0].content).toContain("+new line");
   });
 
+  it("should parse real diffs for paths with spaces", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+
+    const spacedFileName = "file with space.txt";
+    writeFileSync(join(testRepoPath, spacedFileName), "before\n");
+    execSync("git add . && git commit -m 'Add spaced file'", { cwd: testRepoPath });
+
+    writeFileSync(join(testRepoPath, spacedFileName), "after\n");
+
+    const diff = execSync("git diff HEAD", { cwd: testRepoPath, encoding: "utf-8" });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].filePath).toBe(spacedFileName);
+    expect(fileDiffs[0].oldPath).toBeUndefined();
+    expect(fileDiffs[0].hunks).toHaveLength(1);
+    expect(fileDiffs[0].hunks[0].filePath).toBe(spacedFileName);
+    expect(fileDiffs[0].hunks[0].content).toContain("+after");
+  });
+
+  it("should normalize quoted patch labels for escaped file names", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+
+    const escapedFileName = 'tab\tquote"file.txt';
+    writeFileSync(join(testRepoPath, escapedFileName), "before\n");
+    execSync("git add . && git commit -m 'Add escaped path file'", { cwd: testRepoPath });
+
+    rmSync(join(testRepoPath, escapedFileName));
+
+    const diff = execSync("git diff HEAD", { cwd: testRepoPath, encoding: "utf-8" });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].changeType).toBe("deleted");
+    expect(fileDiffs[0].filePath).toBe(escapedFileName);
+    expect(fileDiffs[0].oldPath).toBe(escapedFileName);
+    expect(fileDiffs[0].hunks).toHaveLength(1);
+    expect(fileDiffs[0].hunks[0].oldPath).toBe(escapedFileName);
+    expect(fileDiffs[0].hunks[0].content).toContain("-before");
+  });
+
   it("should preserve nested paths in --no-prefix diffs", () => {
     execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
     execSync("mkdir -p src/common", { cwd: testRepoPath });
diff --git a/src/common/utils/git/diffParser.ts b/src/common/utils/git/diffParser.ts
index 5988dbf032..0c91756449 100644
--- a/src/common/utils/git/diffParser.ts
+++ b/src/common/utils/git/diffParser.ts
@@ -54,32 +54,202 @@ interface ParsedDiffPathLabel {
   path: string | null;
 }
 
-function parseDiffPathLabel(label: string | undefined): ParsedDiffPathLabel | null {
+function decodeGitCString(value: string): string {
+  const bytes: number[] = [];
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+
+  for (let index = 0; index < value.length; index++) {
+    const char = value[index];
+    if (char !== "\\") {
+      bytes.push(...encoder.encode(char));
+      continue;
+    }
+
+    index += 1;
+    if (index >= value.length) {
+      bytes.push(0x5c);
+      break;
+    }
+
+    const escape = value[index];
+    if (/[0-7]/.test(escape)) {
+      let octal = escape;
+      while (index + 1 < value.length && octal.length < 3 && /[0-7]/.test(value[index + 1])) {
+        index += 1;
+        octal += value[index];
+      }
+      bytes.push(parseInt(octal, 8));
+      continue;
+    }
+
+    switch (escape) {
+      case "a":
+        bytes.push(0x07);
+        break;
+      case "b":
+        bytes.push(0x08);
+        break;
+      case "t":
+        bytes.push(0x09);
+        break;
+      case "n":
+        bytes.push(0x0a);
+        break;
+      case "v":
+        bytes.push(0x0b);
+        break;
+      case "f":
+        bytes.push(0x0c);
+        break;
+      case "r":
+        bytes.push(0x0d);
+        break;
+      case '"':
+        bytes.push(0x22);
+        break;
+      case "\\":
+        bytes.push(0x5c);
+        break;
+      default:
+        bytes.push(...encoder.encode(escape));
+        break;
+    }
+  }
+
+  return decoder.decode(new Uint8Array(bytes));
+}
+
+function parseQuotedDiffLabel(
+  value: string,
+  startIndex = 0
+): { rawLabel: string; label: string; nextIndex: number } | null {
+  if (value[startIndex] !== '"') {
+    return null;
+  }
+
+  let escaped = false;
+  for (let index = startIndex + 1; index < value.length; index++) {
+    const char = value[index];
+    if (!escaped && char === '"') {
+      return {
+        rawLabel: value.slice(startIndex, index + 1),
+        label: decodeGitCString(value.slice(startIndex + 1, index)),
+        nextIndex: index + 1,
+      };
+    }
+
+    escaped = !escaped && char === "\\";
+  }
+
+  return null;
+}
+
+function normalizeDiffPathLabel(label: string | undefined): string | undefined {
   if (label == null) {
+    return undefined;
+  }
+
+  const trimmedLabel = label.trimEnd();
+  if (trimmedLabel.length === 0) {
+    return undefined;
+  }
+
+  const quotedLabel = parseQuotedDiffLabel(trimmedLabel);
+  if (quotedLabel) {
+    return quotedLabel.label;
+  }
+
+  const tabIndex = trimmedLabel.indexOf("\t");
+  return tabIndex === -1 ? trimmedLabel : trimmedLabel.slice(0, tabIndex);
+}
+
+function parseDiffPathLabel(label: string | undefined): ParsedDiffPathLabel | null {
+  const normalizedLabel = normalizeDiffPathLabel(label);
+  if (normalizedLabel == null) {
     return null;
   }
 
-  if (label === "/dev/null") {
+  if (normalizedLabel === "/dev/null") {
     return {
-      raw: label,
+      raw: normalizedLabel,
       prefix: null,
       path: null,
     };
   }
 
-  const slashIndex = label.indexOf("/");
+  const slashIndex = normalizedLabel.indexOf("/");
   if (slashIndex === -1) {
     return {
-      raw: label,
+      raw: normalizedLabel,
       prefix: null,
-      path: label,
+      path: normalizedLabel,
     };
   }
 
   return {
-    raw: label,
-    prefix: label.slice(0, slashIndex),
-    path: label.slice(slashIndex + 1),
+    raw: normalizedLabel,
+    prefix: normalizedLabel.slice(0, slashIndex),
+    path: normalizedLabel.slice(slashIndex + 1),
+  };
+}
+
+function parseDiffGitHeaderLabels(line: string): {
+  oldLabel: string | undefined;
+  newLabel: string | undefined;
+} {
+  const labelSection = line.slice("diff --git ".length);
+  const quotedOldLabel = parseQuotedDiffLabel(labelSection);
+  if (quotedOldLabel) {
+    const separatorMatch = /\s+/.exec(labelSection.slice(quotedOldLabel.nextIndex));
+    if (separatorMatch) {
+      const quotedNewLabel = parseQuotedDiffLabel(
+        labelSection,
+        quotedOldLabel.nextIndex + separatorMatch.index + separatorMatch[0].length
+      );
+      if (quotedNewLabel) {
+        return {
+          oldLabel: quotedOldLabel.rawLabel,
+          newLabel: quotedNewLabel.rawLabel,
+        };
+      }
+    }
+  }
+
+  const simpleLabels = labelSection.split(" ");
+  if (simpleLabels.length === 2) {
+    return {
+      oldLabel: simpleLabels[0],
+      newLabel: simpleLabels[1],
+    };
+  }
+
+  // Git can emit unquoted `diff --git` headers for paths with spaces, so look for the split
+  // that preserves the paired path on both sides instead of tokenizing on every space.
+  for (let index = 0; index < labelSection.length; index++) {
+    if (labelSection[index] !== " ") {
+      continue;
+    }
+
+    const oldLabel = labelSection.slice(0, index);
+    const newLabel = labelSection.slice(index + 1);
+    const parsedOldLabel = parseDiffPathLabel(oldLabel);
+    const parsedNewLabel = parseDiffPathLabel(newLabel);
+    if (
+      parsedOldLabel?.path != null &&
+      parsedNewLabel?.path != null &&
+      parsedOldLabel.path === parsedNewLabel.path
+    ) {
+      return {
+        oldLabel,
+        newLabel,
+      };
+    }
+  }
+
+  return {
+    oldLabel: undefined,
+    newLabel: undefined,
   };
 }
 
@@ -210,21 +380,18 @@ export function parseDiff(diffOutput: string): FileDiff[] {
     // File header: git emits path labels here, but they are not guaranteed to be literal a/ and b/.
     if (line.startsWith("diff --git ")) {
       finishFile();
-      // Extract the trailing paths from "diff --git <label>/path <label>/path" without
-      // assuming specific labels. Review diffs can use other prefixes (for example c/ and w/).
-      const parts = line.split(" ");
-      if (parts.length >= 4) {
-        currentHeaderOldLabel = parts[2];
-        currentHeaderNewLabel = parts[3];
-        currentFile = {
-          filePath: "",
-          oldPath: undefined,
-          changeType: "modified",
-          isBinary: false,
-          hunks: [],
-        };
-        syncCurrentFilePaths();
-      }
+      // Extract the paired labels without assuming literal a/ and b/ prefixes or space-free paths.
+      const parsedHeaderLabels = parseDiffGitHeaderLabels(line);
+      currentHeaderOldLabel = parsedHeaderLabels.oldLabel;
+      currentHeaderNewLabel = parsedHeaderLabels.newLabel;
+      currentFile = {
+        filePath: "",
+        oldPath: undefined,
+        changeType: "modified",
+        isBinary: false,
+        hunks: [],
+      };
+      syncCurrentFilePaths();
       continue;
     }
 

From 4383f8531de2092de7031b06ed8fce8a78a78447 Mon Sep 17 00:00:00 2001
From: p0ny <p0uy@outlook.com>
Date: Fri, 20 Mar 2026 17:00:22 +0800
Subject: [PATCH 5/6] fix normalize quoted rename diff paths

---
 src/common/utils/git/diffParser.test.ts | 22 ++++++++++++++++++++++
 src/common/utils/git/diffParser.ts      |  4 ++--
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/common/utils/git/diffParser.test.ts b/src/common/utils/git/diffParser.test.ts
index b8274c5b2b..3ee9e525a6 100644
--- a/src/common/utils/git/diffParser.test.ts
+++ b/src/common/utils/git/diffParser.test.ts
@@ -417,6 +417,28 @@ describe("git diff parser (real repository)", () => {
     expect(allHunks.every((h) => h.id && h.id.length > 0)).toBe(true);
   });
 
+  it("should normalize quoted rename metadata paths", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+
+    const originalFileName = 'tab\tquote"name.txt';
+    const renamedFileName = 'tab\tquote"renamed.txt';
+    writeFileSync(join(testRepoPath, originalFileName), "before\n");
+    execSync("git add . && git commit -m 'Add quoted rename source file'", { cwd: testRepoPath });
+
+    execSync(`git mv '${originalFileName}' '${renamedFileName}'`, {
+      cwd: testRepoPath,
+    });
+
+    const diff = execSync("git diff --cached -M", { cwd: testRepoPath, encoding: "utf-8" });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].changeType).toBe("renamed");
+    expect(fileDiffs[0].filePath).toBe(renamedFileName);
+    expect(fileDiffs[0].oldPath).toBe(originalFileName);
+    expect(fileDiffs[0].hunks).toHaveLength(0);
+  });
+
   it("should handle pure file rename (no content changes)", () => {
     // Reset
     execSync("git reset --hard HEAD", { cwd: testRepoPath });
diff --git a/src/common/utils/git/diffParser.ts b/src/common/utils/git/diffParser.ts
index 0c91756449..b3dd35ef19 100644
--- a/src/common/utils/git/diffParser.ts
+++ b/src/common/utils/git/diffParser.ts
@@ -431,14 +431,14 @@ export function parseDiff(diffOutput: string): FileDiff[] {
 
     if (line.startsWith("rename from ")) {
       currentFile.changeType = "renamed";
-      currentRenameFrom = line.slice("rename from ".length);
+      currentRenameFrom = normalizeDiffPathLabel(line.slice("rename from ".length));
       syncCurrentFilePaths();
       continue;
     }
 
     if (line.startsWith("rename to ")) {
       currentFile.changeType = "renamed";
-      currentRenameTo = line.slice("rename to ".length);
+      currentRenameTo = normalizeDiffPathLabel(line.slice("rename to ".length));
       syncCurrentFilePaths();
       continue;
     }

From a67bf5f6817801b48ac47917e649b6537183781c Mon Sep 17 00:00:00 2001
From: p0ny <p0uy@outlook.com>
Date: Fri, 20 Mar 2026 17:14:30 +0800
Subject: [PATCH 6/6] =?UTF-8?q?=F0=9F=A4=96=20fix:=20preserve=20trailing?=
 =?UTF-8?q?=20spaces=20in=20diff=20labels?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/common/utils/git/diffParser.test.ts | 22 ++++++++++++++++++++++
 src/common/utils/git/diffParser.ts      | 14 ++++++--------
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/src/common/utils/git/diffParser.test.ts b/src/common/utils/git/diffParser.test.ts
index 3ee9e525a6..54c2f4e996 100644
--- a/src/common/utils/git/diffParser.test.ts
+++ b/src/common/utils/git/diffParser.test.ts
@@ -162,6 +162,28 @@ describe("git diff parser (real repository)", () => {
     expect(fileDiffs[0].hunks[0].content).toContain("+after");
   });
 
+  it("should preserve literal trailing spaces in diff path labels", () => {
+    execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
+
+    const trailingSpaceFileName = "trailing-space.txt ";
+    writeFileSync(join(testRepoPath, trailingSpaceFileName), "before\n");
+    execSync("git add . && git commit -m 'Add trailing space file'", { cwd: testRepoPath });
+
+    rmSync(join(testRepoPath, trailingSpaceFileName));
+
+    const diff = execSync("git diff HEAD", { cwd: testRepoPath, encoding: "utf-8" });
+    const fileDiffs = parseDiff(diff);
+
+    expect(fileDiffs).toHaveLength(1);
+    expect(fileDiffs[0].changeType).toBe("deleted");
+    expect(fileDiffs[0].filePath).toBe(trailingSpaceFileName);
+    expect(fileDiffs[0].oldPath).toBe(trailingSpaceFileName);
+    expect(fileDiffs[0].hunks).toHaveLength(1);
+    expect(fileDiffs[0].hunks[0].filePath).toBe(trailingSpaceFileName);
+    expect(fileDiffs[0].hunks[0].oldPath).toBe(trailingSpaceFileName);
+    expect(fileDiffs[0].hunks[0].content).toContain("-before");
+  });
+
   it("should normalize quoted patch labels for escaped file names", () => {
     execSync("git reset --hard HEAD && git clean -fd", { cwd: testRepoPath });
 
diff --git a/src/common/utils/git/diffParser.ts b/src/common/utils/git/diffParser.ts
index b3dd35ef19..e5a7ba96e6 100644
--- a/src/common/utils/git/diffParser.ts
+++ b/src/common/utils/git/diffParser.ts
@@ -150,18 +150,16 @@ function normalizeDiffPathLabel(label: string | undefined): string | undefined {
     return undefined;
   }
 
-  const trimmedLabel = label.trimEnd();
-  if (trimmedLabel.length === 0) {
-    return undefined;
-  }
-
-  const quotedLabel = parseQuotedDiffLabel(trimmedLabel);
+  const quotedLabel = parseQuotedDiffLabel(label);
   if (quotedLabel) {
     return quotedLabel.label;
   }
 
-  const tabIndex = trimmedLabel.indexOf("\t");
-  return tabIndex === -1 ? trimmedLabel : trimmedLabel.slice(0, tabIndex);
+  // Preserve literal trailing spaces in file names while still stripping the tab separator
+  // Git appends to unquoted patch labels before any optional timestamp metadata.
+  const tabIndex = label.indexOf("\t");
+  const normalizedLabel = tabIndex === -1 ? label : label.slice(0, tabIndex);
+  return normalizedLabel.length === 0 ? undefined : normalizedLabel;
 }
 
 function parseDiffPathLabel(label: string | undefined): ParsedDiffPathLabel | null {