Add selectable repo diff scopes

- Split repo diffs into working tree, unstaged, staged, and branch scopes
- Persist the selected scope and reuse it in the diff panel and chat header

Author: Emanuele-web04

apps/server/src/git/Layers/GitCore.test.ts

@@ -1578,6 +1578,40 @@ it.layer(TestLayer)("git integration", (it) => {
       }),
     );
 
+    it.effect("reads branch, staged, and unstaged patches as separate scopes", () =>
+      Effect.gen(function* () {
+        const tmp = yield* makeTmpDir();
+        yield* initRepoWithCommit(tmp);
+        const core = yield* GitCore;
+
+        yield* core.createBranch({ cwd: tmp, branch: "feature/diff-scopes" });
+        yield* core.checkoutBranch({ cwd: tmp, branch: "feature/diff-scopes" });
+        yield* writeTextFile(path.join(tmp, "branch.txt"), "branch change\n");
+        yield* git(tmp, ["add", "branch.txt"]);
+        yield* git(tmp, ["commit", "-m", "branch change"]);
+
+        yield* writeTextFile(path.join(tmp, "staged.txt"), "staged change\n");
+        yield* git(tmp, ["add", "staged.txt"]);
+        yield* writeTextFile(path.join(tmp, "README.md"), "# test\nunstaged change\n");
+        yield* writeTextFile(path.join(tmp, "untracked.txt"), "untracked change\n");
+
+        const branchPatch = (yield* core.readBranchPatch(tmp)).patch;
+        expect(branchPatch).toContain("diff --git a/branch.txt b/branch.txt");
+        expect(branchPatch).not.toContain("staged.txt");
+        expect(branchPatch).not.toContain("untracked.txt");
+
+        const stagedPatch = (yield* core.readStagedPatch(tmp)).patch;
+        expect(stagedPatch).toContain("diff --git a/staged.txt b/staged.txt");
+        expect(stagedPatch).not.toContain("README.md");
+        expect(stagedPatch).not.toContain("untracked.txt");
+
+        const unstagedPatch = (yield* core.readUnstagedPatch(tmp)).patch;
+        expect(unstagedPatch).toContain("diff --git a/README.md b/README.md");
+        expect(unstagedPatch).toContain("diff --git a/untracked.txt b/untracked.txt");
+        expect(unstagedPatch).not.toContain("staged.txt");
+      }),
+    );
+
     it.effect("computes ahead count against base branch when no upstream is configured", () =>
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();

apps/server/src/git/Layers/GitCore.ts

@@ -1453,6 +1453,72 @@ export const makeGitCore = (options?: { executeOverride?: GitCoreShape["execute"
         })),
       );
 
+    const readUntrackedPatches = (cwd: string, operationPrefix: string) =>
+      runGitStdout(
+        `${operationPrefix}.untrackedFiles`,
+        cwd,
+        ["ls-files", "--others", "--exclude-standard", "-z"],
+        true,
+      ).pipe(
+        Effect.map((stdout) => stdout.split("\0").filter((entry) => entry.length > 0)),
+        Effect.flatMap((untrackedFiles) =>
+          Effect.forEach(
+            untrackedFiles,
+            (filePath) =>
+              // Git diff omits untracked files, so synthesize a normal patch for each one.
+              executeGit(
+                `${operationPrefix}.untrackedPatch`,
+                cwd,
+                [
+                  "diff",
+                  "--no-index",
+                  "--patch",
+                  "--no-color",
+                  "--src-prefix=a/",
+                  "--dst-prefix=b/",
+                  "--",
+                  "/dev/null",
+                  filePath,
+                ],
+                {
+                  allowNonZeroExit: true,
+                  timeoutMs: WORKING_TREE_DIFF_TIMEOUT_MS,
+                },
+              ).pipe(Effect.map((result) => result.stdout)),
+            { concurrency: MAX_UNTRACKED_DIFF_CONCURRENCY },
+          ),
+        ),
+      );
+
+    const readUnstagedPatch: GitCoreShape["readUnstagedPatch"] = (cwd) =>
+      Effect.gen(function* () {
+        const trackedPatch = yield* executeGit(
+          "GitCore.readUnstagedPatch.trackedPatch",
+          cwd,
+          ["diff", "--patch", "--no-color", "--no-ext-diff"],
+          {
+            allowNonZeroExit: true,
+            timeoutMs: WORKING_TREE_DIFF_TIMEOUT_MS,
+          },
+        ).pipe(Effect.map((result) => result.stdout));
+        const untrackedPatches = yield* readUntrackedPatches(cwd, "GitCore.readUnstagedPatch");
+
+        return {
+          patch: joinPatchSegments([trackedPatch, ...untrackedPatches]),
+        };
+      });
+
+    const readStagedPatch: GitCoreShape["readStagedPatch"] = (cwd) =>
+      executeGit(
+        "GitCore.readStagedPatch",
+        cwd,
+        ["diff", "--cached", "--patch", "--no-color", "--no-ext-diff"],
+        {
+          allowNonZeroExit: true,
+          timeoutMs: WORKING_TREE_DIFF_TIMEOUT_MS,
+        },
+      ).pipe(Effect.map((result) => ({ patch: result.stdout })));
+
     const readWorkingTreePatch: GitCoreShape["readWorkingTreePatch"] = (cwd) =>
       Effect.gen(function* () {
         const headExists = yield* executeGit(
@@ -1474,43 +1540,49 @@ export const makeGitCore = (options?: { executeOverride?: GitCoreShape["execute"
           },
         ).pipe(Effect.map((result) => result.stdout));
 
-        const untrackedFiles = yield* runGitStdout(
-          "GitCore.readWorkingTreePatch.untrackedFiles",
-          cwd,
-          ["ls-files", "--others", "--exclude-standard", "-z"],
-          true,
-        ).pipe(Effect.map((stdout) => stdout.split("\0").filter((entry) => entry.length > 0)));
-
-        const untrackedPatches = yield* Effect.forEach(
-          untrackedFiles,
-          (filePath) =>
-            executeGit(
-              "GitCore.readWorkingTreePatch.untrackedPatch",
-              cwd,
-              [
-                "diff",
-                "--no-index",
-                "--patch",
-                "--no-color",
-                "--src-prefix=a/",
-                "--dst-prefix=b/",
-                "--",
-                "/dev/null",
-                filePath,
-              ],
-              {
-                allowNonZeroExit: true,
-                timeoutMs: WORKING_TREE_DIFF_TIMEOUT_MS,
-              },
-            ).pipe(Effect.map((result) => result.stdout)),
-          { concurrency: MAX_UNTRACKED_DIFF_CONCURRENCY },
-        );
+        const untrackedPatches = yield* readUntrackedPatches(cwd, "GitCore.readWorkingTreePatch");
 
         return {
           patch: joinPatchSegments([trackedPatch, ...untrackedPatches]),
         };
       });
 
+    const readBranchPatch: GitCoreShape["readBranchPatch"] = (cwd) =>
+      Effect.gen(function* () {
+        const details = yield* statusDetails(cwd);
+        const baseBranch =
+          details.upstreamRef ??
+          (details.branch
+            ? yield* resolveBaseBranchForNoUpstream(cwd, details.branch).pipe(
+                Effect.catch(() => Effect.succeed(null)),
+              )
+            : null);
+        if (!baseBranch) {
+          return yield* createGitCommandError(
+            "GitCore.readBranchPatch.base",
+            cwd,
+            ["diff", "--patch", "--minimal", "<base>...HEAD"],
+            "Cannot resolve a base branch for the current branch diff.",
+          );
+        }
+
+        const result = yield* execute({
+          operation: "GitCore.readBranchPatch.diffPatch",
+          cwd,
+          args: [
+            "diff",
+            "--patch",
+            "--minimal",
+            "--no-color",
+            "--no-ext-diff",
+            `${baseBranch}...HEAD`,
+          ],
+          maxOutputBytes: 10_000_000,
+        });
+
+        return { patch: result.stdout };
+      });
+
     const prepareCommitContext: GitCoreShape["prepareCommitContext"] = (cwd, filePaths) =>
       Effect.gen(function* () {
         if (filePaths && filePaths.length > 0) {
@@ -2465,6 +2537,9 @@ export const makeGitCore = (options?: { executeOverride?: GitCoreShape["execute"
       status,
       statusDetails,
       readWorkingTreePatch,
+      readUnstagedPatch,
+      readStagedPatch,
+      readBranchPatch,
       prepareCommitContext,
       commit,
       pushCurrentBranch,

apps/server/src/git/Layers/GitManager.ts

@@ -1483,7 +1483,17 @@ export const makeGitManager = Effect.gen(function* () {
 
   const readWorkingTreeDiff: GitManagerShape["readWorkingTreeDiff"] = Effect.fnUntraced(
     function* (input) {
-      return yield* gitCore.readWorkingTreePatch(input.cwd);
+      switch (input.scope) {
+        case "branch":
+          return yield* gitCore.readBranchPatch(input.cwd);
+        case "staged":
+          return yield* gitCore.readStagedPatch(input.cwd);
+        case "unstaged":
+          return yield* gitCore.readUnstagedPatch(input.cwd);
+        case "workingTree":
+        default:
+          return yield* gitCore.readWorkingTreePatch(input.cwd);
+      }
     },
   );
 

apps/server/src/git/Services/GitCore.ts

@@ -170,6 +170,25 @@ export interface GitCoreShape {
     cwd: string,
   ) => Effect.Effect<GitWorkingTreePatch, GitCommandError>;
 
+  /**
+   * Read only unstaged tracked changes plus untracked files.
+   */
+  readonly readUnstagedPatch: (
+    cwd: string,
+  ) => Effect.Effect<GitWorkingTreePatch, GitCommandError>;
+
+  /**
+   * Read only staged changes.
+   */
+  readonly readStagedPatch: (
+    cwd: string,
+  ) => Effect.Effect<GitWorkingTreePatch, GitCommandError>;
+
+  /**
+   * Read committed branch changes against the upstream/base branch.
+   */
+  readonly readBranchPatch: (cwd: string) => Effect.Effect<GitWorkingTreePatch, GitCommandError>;
+
   /**
    * Build staged change context for commit generation.
    */