git: Add diff_base setting for showing changes since the default branch (zed-industries#61501)

# Objective

Let git indicators — the editor gutter, file colors, and `git::Diff` —
show all changes on the current branch relative to its merge base with
the default branch, instead of only uncommitted changes.

Supersedes zed-industries#60398; thanks to @samuelcolvin for the original
implementation and motivation.

Closes FR-135

## Solution

- New `git.diff_base` setting (`"head"` | `"default_branch"`), applied
live and toggleable per session from the editor controls menu ("Diff
Against Default Branch").
- Statuses come from a real merge-base-to-worktree tree diff (`git diff
--merge-base`), so local edits that revert branch changes correctly show
as unchanged.
- `GitStore` shares one `DiffBufferList` per repository with the Branch
Diff view; `repo_snapshots` and `project_path_git_status` keep returning
index/worktree truth, while display surfaces use separate `display_*`
APIs.
- `BufferDiff` now records what its base is (`DiffBaseKind`); hunks
whose base isn't HEAD are read-only in the gutter — stage/restore
buttons and keybindings are inert, so committed work can't be silently
rewritten.
- `git::Diff` follows the setting; new `git::DiffHead` always opens the
HEAD diff; `git::BranchDiff` is renamed `git::DiffBranch` (deprecated
alias kept).

Tradeoffs / known limitations:

- Hunk-level staging is unavailable while in `default_branch` mode
(whole-file staging via the git panel still works). Staging just the
uncommitted sub-ranges of a branch hunk is a follow-up.
- Remote hosts running an older server ignore the new
`GetTreeDiff.includes_worktree` proto field and degrade to
committed-changes-only branch diffs.
- Repositories with no resolvable default branch fall back to
HEAD-relative behavior; a failed first resolution retries on the next
branch-list change.

## Testing

- Real-git-repo tests for the merge-base-to-worktree diff's edge cases:
files recreated after index deletion, committed deletions recreated on
disk, and symlinks.
- GPUI tests for status semantics (a branch change reverted on disk
shows clean), `git::Diff` routing, live setting changes, and read-only
hunk enforcement (restore/stage leave buffer and index untouched).

## Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content adheres to Zed's UI standards
([UX/UI](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
and
[icon](https://github.com/zed-industries/zed/blob/main/crates/icons/README.md)
guidelines)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

---

Release Notes:

- Git: Added a `git.diff_base` setting (`"head"` or `"default_branch"`)
that makes the editor gutter, file colors, and diff view show all
changes on the current branch since its merge base with the default
branch, instead of only uncommitted changes.

---------

Co-authored-by: Ben Kunkle <ben@zed.dev>

Author: mikayla-maki

assets/settings/default.json

@@ -1712,6 +1712,8 @@
     // 2. Show unstaged hunks hollow and staged hunks filled:
     //    "hunk_style": "unstaged_hollow"
     "hunk_style": "staged_hollow",
+    // Whether git features diff against HEAD ("head") or the default branch ("default_branch").
+    "diff_base": "head",
     // Should the name or path be displayed first in the git view.
     // "path_style": "file_name_first" or "file_path_first"
     "path_style": "file_name_first",

crates/acp_thread/src/diff.rs

@@ -89,7 +89,13 @@ impl Diff {
         let language = buffer.read(cx).language().cloned();
         let language_registry = buffer.read(cx).language_registry();
         let buffer_diff = cx.new(|cx| {
-            BufferDiff::new_unchanged(&buffer_text_snapshot, language, language_registry, cx)
+            BufferDiff::new_unchanged(
+                &buffer_text_snapshot,
+                language,
+                language_registry,
+                buffer_diff::DiffBaseKind::Custom,
+                cx,
+            )
         });
 
         let multibuffer = cx.new(|cx| {
@@ -389,7 +395,15 @@ async fn build_buffer_diff(
     let buffer = cx.update(|cx| buffer.read(cx).snapshot());
     let base_text = base_text_exists.then(|| old_text);
 
-    let diff = cx.new(|cx| BufferDiff::new(&buffer, language, language_registry, cx));
+    let diff = cx.new(|cx| {
+        BufferDiff::new(
+            &buffer,
+            language,
+            language_registry,
+            buffer_diff::DiffBaseKind::Custom,
+            cx,
+        )
+    });
     diff.update(cx, |diff, cx| {
         diff.set_base_text(base_text, buffer.text, cx)
     })

crates/action_log/src/action_log.rs

@@ -159,8 +159,15 @@ impl ActionLog {
                 let text_snapshot = buffer.read(cx).text_snapshot();
                 let language = buffer.read(cx).language().cloned();
                 let language_registry = buffer.read(cx).language_registry();
-                let diff =
-                    cx.new(|cx| BufferDiff::new(&text_snapshot, language, language_registry, cx));
+                let diff = cx.new(|cx| {
+                    BufferDiff::new(
+                        &text_snapshot,
+                        language,
+                        language_registry,
+                        buffer_diff::DiffBaseKind::Custom,
+                        cx,
+                    )
+                });
                 let (diff_update_tx, diff_update_rx) = mpsc::unbounded();
                 let diff_base;
                 let unreviewed_edits;

crates/buffer_diff/src/buffer_diff.rs

@@ -25,6 +25,23 @@ pub struct BufferDiff {
     diff_snapshot: Option<BufferDiffSnapshot>,
     secondary_diff: Option<Entity<BufferDiff>>,
     buffer_snapshot: text::BufferSnapshot,
+    base_kind: DiffBaseKind,
+}
+
+/// Where this diff's base text came from. Only diffs whose base is HEAD
+/// support staging and restoring hunks; a diff against any other base (e.g.
+/// the merge base with another branch) would rewrite committed work.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DiffBaseKind {
+    /// The buffer's committed (HEAD) content.
+    Head,
+    /// The buffer's index (staged) content.
+    Index,
+    /// An arbitrary blob, such as the merge base with another branch.
+    Oid,
+    /// Arbitrary caller-provided text, such as an agent's original text,
+    /// the clipboard, or another file.
+    Custom,
 }
 
 #[derive(Clone)]
@@ -1553,6 +1570,7 @@ impl BufferDiff {
         buffer: &text::BufferSnapshot,
         language: Option<Arc<Language>>,
         language_registry: Option<Arc<LanguageRegistry>>,
+        base_kind: DiffBaseKind,
         cx: &mut App,
     ) -> Self {
         let base_text = cx.new(|cx| {
@@ -1571,12 +1589,14 @@ impl BufferDiff {
             diff_snapshot: None,
             buffer_snapshot: buffer.clone(),
             secondary_diff: None,
+            base_kind,
         }
     }
 
     pub fn new_with_base_text_buffer(
         buffer: &text::BufferSnapshot,
         base_text_buffer: Entity<language::Buffer>,
+        base_kind: DiffBaseKind,
         _cx: &mut App,
     ) -> Self {
         BufferDiff {
@@ -1585,13 +1605,15 @@ impl BufferDiff {
             diff_snapshot: None,
             buffer_snapshot: buffer.clone(),
             secondary_diff: None,
+            base_kind,
         }
     }
 
     pub fn new_unchanged(
         buffer: &text::BufferSnapshot,
         language: Option<Arc<Language>>,
         language_registry: Option<Arc<LanguageRegistry>>,
+        base_kind: DiffBaseKind,
         cx: &mut Context<Self>,
     ) -> Self {
         let base_text = buffer.text();
@@ -1622,6 +1644,7 @@ impl BufferDiff {
             diff_snapshot: Some(diff_snapshot),
             buffer_snapshot: buffer.clone(),
             secondary_diff: None,
+            base_kind,
         }
     }
 
@@ -1631,7 +1654,7 @@ impl BufferDiff {
         buffer: &text::BufferSnapshot,
         cx: &mut Context<Self>,
     ) -> Self {
-        let mut this = BufferDiff::new(buffer, None, None, cx);
+        let mut this = BufferDiff::new(buffer, None, None, DiffBaseKind::Head, cx);
         let mut base_text = base_text.to_owned();
         text::LineEnding::normalize(&mut base_text);
         let base_text_buffer = cx.new(|cx| {
@@ -1655,6 +1678,16 @@ impl BufferDiff {
         self.secondary_diff = Some(diff);
     }
 
+    pub fn base_kind(&self) -> DiffBaseKind {
+        self.base_kind
+    }
+
+    /// Whether hunks in this diff can be staged or restored: true only when
+    /// the diff's base is HEAD.
+    pub fn is_stageable(&self) -> bool {
+        self.base_kind == DiffBaseKind::Head
+    }
+
     pub fn secondary_diff(&self) -> Option<Entity<BufferDiff>> {
         self.secondary_diff.clone()
     }
@@ -2449,7 +2482,8 @@ mod tests {
             ],
         );
 
-        diff = cx.update(|cx| BufferDiff::new(&buffer, None, None, cx).snapshot(cx));
+        diff = cx
+            .update(|cx| BufferDiff::new(&buffer, None, None, DiffBaseKind::Head, cx).snapshot(cx));
         assert_hunks::<&str, _>(
             diff.hunks_intersecting_range(
                 Anchor::min_max_range_for_buffer(buffer.remote_id()),
@@ -3154,7 +3188,8 @@ mod tests {
 
         let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text_1);
 
-        let empty_diff = cx.update(|cx| BufferDiff::new(&buffer, None, None, cx).snapshot(cx));
+        let empty_diff = cx
+            .update(|cx| BufferDiff::new(&buffer, None, None, DiffBaseKind::Head, cx).snapshot(cx));
         let diff_1 = BufferDiffSnapshot::new_sync(&buffer, base_text.clone(), cx);
         let DiffChanged {
             changed_range,
@@ -4312,7 +4347,8 @@ mod tests {
         );
         let buffer_snapshot = buffer.snapshot();
 
-        let diff = cx.new(|cx| BufferDiff::new(&buffer_snapshot, None, None, cx));
+        let diff =
+            cx.new(|cx| BufferDiff::new(&buffer_snapshot, None, None, DiffBaseKind::Head, cx));
         diff.update(cx, |diff, cx| {
             diff.set_base_text(Some(Arc::from(base_text_crlf)), buffer_snapshot.clone(), cx)
         })

crates/edit_prediction_ui/src/rate_prediction_modal.rs

@@ -605,6 +605,7 @@ impl RatePredictionsModal {
                         &predicted_buffer_snapshot.text,
                         predicted_buffer_snapshot.language().cloned(),
                         predicted_buffer.read(cx).language_registry(),
+                        buffer_diff::DiffBaseKind::Custom,
                         cx,
                     )
                 });
@@ -711,6 +712,7 @@ impl RatePredictionsModal {
                     &expected_buffer_snapshot.text,
                     expected_buffer_snapshot.language().cloned(),
                     expected_buffer.read(cx).language_registry(),
+                    buffer_diff::DiffBaseKind::Custom,
                     cx,
                 )
             });

crates/editor/src/editor.rs

@@ -113,9 +113,7 @@ pub use git::{
     set_blame_renderer,
 };
 pub(crate) use git::{DiffHunkKey, StoredReviewComment};
-use git::{
-    DiffReviewDragState, DiffReviewOverlay, InlineBlamePopover, update_uncommitted_diff_for_buffer,
-};
+use git::{DiffReviewDragState, DiffReviewOverlay, InlineBlamePopover};
 pub(crate) use git::{DisplayDiffHunk, PhantomDiffReviewIndicator};
 pub use hover_popover::hover_markdown_style;
 pub use inlays::Inlay;
@@ -2170,20 +2168,41 @@ impl Editor {
             ));
             let git_store = project.read(cx).git_store().clone();
             let project = project.clone();
-            project_subscriptions.push(cx.subscribe(&git_store, move |this, _, event, cx| {
-                if let GitStoreEvent::RepositoryAdded = event {
-                    this.load_diff_task = Some(
-                        update_uncommitted_diff_for_buffer(
-                            cx.entity(),
-                            &project,
-                            this.buffer.read(cx).all_buffers(),
-                            this.buffer.clone(),
-                            cx,
-                        )
-                        .shared(),
-                    );
-                }
-            }));
+            project_subscriptions.push(cx.subscribe(
+                &git_store,
+                move |this, git_store, event, cx| {
+                    let buffers = match event {
+                        GitStoreEvent::RepositoryAdded | GitStoreEvent::DiffBaseChanged(None) => {
+                            this.buffer.read(cx).all_buffers()
+                        }
+                        GitStoreEvent::DiffBaseChanged(Some(repo_id)) => this
+                            .buffer
+                            .read(cx)
+                            .all_buffers()
+                            .into_iter()
+                            .filter(|buffer| {
+                                git_store
+                                    .read(cx)
+                                    .repository_and_path_for_buffer_id(
+                                        buffer.read(cx).remote_id(),
+                                        cx,
+                                    )
+                                    .is_some_and(|(repo, _)| repo.read(cx).id == *repo_id)
+                            })
+                            .collect(),
+                        _ => return,
+                    };
+                    if buffers.is_empty() {
+                        return;
+                    }
+                    let task = this.update_uncommitted_diff_for_buffer(&project, buffers, cx);
+                    if matches!(event, GitStoreEvent::DiffBaseChanged(Some(_))) {
+                        task.detach();
+                    } else {
+                        this.load_diff_task = Some(task.shared());
+                    }
+                },
+            ));
         }
 
         let buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
@@ -2222,18 +2241,7 @@ impl Editor {
         };
 
         let mut code_action_providers = Vec::new();
-        let mut load_uncommitted_diff = None;
         if let Some(project) = project.clone() {
-            load_uncommitted_diff = Some(
-                update_uncommitted_diff_for_buffer(
-                    cx.entity(),
-                    &project,
-                    multi_buffer.read(cx).all_buffers(),
-                    multi_buffer.clone(),
-                    cx,
-                )
-                .shared(),
-            );
             code_action_providers.push(Rc::new(project) as Rc<_>);
         }
 
@@ -2447,7 +2455,7 @@ impl Editor {
             serialize_selections: Task::ready(()),
             serialize_folds: Task::ready(()),
             text_style_refinement: None,
-            load_diff_task: load_uncommitted_diff,
+            load_diff_task: None,
             diff_hunk_delegate: None,
             minimap: None,
             change_list: ChangeList::new(),
@@ -2474,6 +2482,18 @@ impl Editor {
             colorize_brackets_task: Task::ready(()),
         };
 
+        if let Some(project) = editor.project.clone() {
+            editor.load_diff_task = Some(
+                editor
+                    .update_uncommitted_diff_for_buffer(
+                        &project,
+                        multi_buffer.read(cx).all_buffers(),
+                        cx,
+                    )
+                    .shared(),
+            );
+        }
+
         if is_minimap {
             return editor;
         }
@@ -9631,16 +9651,10 @@ impl Editor {
                 self.refresh_document_highlights(cx);
                 let buffer_id = buffer.read(cx).remote_id();
                 if self.buffer.read(cx).diff_for(buffer_id).is_none()
-                    && let Some(project) = &self.project
+                    && let Some(project) = self.project.clone()
                 {
-                    update_uncommitted_diff_for_buffer(
-                        cx.entity(),
-                        project,
-                        [buffer.clone()],
-                        self.buffer.clone(),
-                        cx,
-                    )
-                    .detach();
+                    self.update_uncommitted_diff_for_buffer(&project, [buffer.clone()], cx)
+                        .detach();
                 }
                 self.register_visible_buffers(cx);
                 self.update_lsp_data(Some(buffer_id), window, cx);