chore: clean up codebase (#19)

Reviewed-on: #19

crates/workspace/Cargo.toml

@@ -18,7 +18,6 @@ utils = { path = "../utils" }
 gpui.workspace = true
 gpui-component.workspace = true
 gpui-base.workspace = true
-gpui-fps.workspace = true
 gix.workspace = true
 nostr.workspace = true
 

crates/workspace/src/views/commit_diff/mod.rs

@@ -13,34 +13,25 @@ use gpui_component::resizable::{resizable_panel, v_resizable};
 use gpui_component::scroll::{ScrollableElement, Scrollbar};
 use gpui_component::spinner::Spinner;
 use gpui_component::tag::Tag;
-use gpui_component::tree::{TreeEntry, TreeState, tree};
+use gpui_component::tree::{TreeEntry, TreeItem, TreeState, tree};
 use gpui_component::{
     ActiveTheme, Sizable, StyledExt, VirtualListScrollHandle, h_flex, v_flex, v_virtual_list,
 };
-use signed_git::{CommitDiff, DiffStatus, FileCommit, FileDiff};
+use signed_git::{CommitDiff, DiffHunk, DiffLine, DiffLineKind, DiffStatus, FileCommit, FileDiff};
 use signed_ui::{placeholder, tree_row};
 use utils::relative_time_secs;
 
-use super::helpers::{
-    DIFF_ROW_HEIGHT, DiffRow, build_tree_items, diff_rows, find_item, render_diff_row, tree_items,
-};
+use crate::views::tree::{build_tree_items, tree_items};
 
-/// Width of the changed-files column.
 const TREE_WIDTH: f32 = 260.;
 
-/// Tree and per-file diff body, shared by the commit diff and compare views.
 pub struct DiffPane {
-    /// Loaded diff, `None` until [`Self::set_diff`] is called.
     diff: Option<CommitDiff>,
-    /// Changed-files explorer state.
     tree_state: Entity<TreeState>,
-    /// Path of the file whose diff is shown in the detail column.
     selected_file: Option<SharedString>,
     /// Rows of the selected file's diff, hunk headers and lines.
     rows: Vec<DiffRow>,
-    /// Per-row heights of [`Self::rows`].
     item_sizes: Rc<Vec<Size<Pixels>>>,
-    /// Virtual list state of the diff rows.
     scroll_handle: VirtualListScrollHandle,
 }
 
@@ -56,12 +47,10 @@ impl DiffPane {
         }
     }
 
-    /// The loaded diff, for stats and badges in the host's header.
     pub fn diff(&self) -> Option<&CommitDiff> {
         self.diff.as_ref()
     }
 
-    /// Replace the diff and rebuild the tree and the selected file's rows.
     pub fn set_diff(&mut self, diff: CommitDiff, cx: &mut Context<Self>) {
         let mut paths: Vec<PathBuf> = diff
             .files
@@ -86,9 +75,6 @@ impl DiffPane {
         }
     }
 
-    /// Forget the diff, e.g. when the compared branches changed.
-    ///
-    /// Clears the tree, the selection and the diff rows.
     pub fn clear(&mut self, cx: &mut Context<Self>) {
         self.diff = None;
         self.selected_file = None;
@@ -99,14 +85,12 @@ impl DiffPane {
         });
     }
 
-    /// Show the diff of the file at `path`, selected in the tree.
     fn select_file(&mut self, path: &str, cx: &mut Context<Self>) {
         self.selected_file = Some(path.into());
         self.set_diff_rows(path);
         cx.notify();
     }
 
-    /// Rebuild the virtual list state for `path` and scroll back to the top.
     fn set_diff_rows(&mut self, path: &str) {
         let Some(diff) = self.diff.as_ref() else {
             return;
@@ -119,7 +103,6 @@ impl DiffPane {
         self.scroll_handle.scroll_to_item(0, ScrollStrategy::Top);
     }
 
-    /// One row of the changed-files tree, icon and name, indented by depth.
     fn render_tree_item(
         ix: usize,
         entry: &TreeEntry,
@@ -136,7 +119,6 @@ impl DiffPane {
         })
     }
 
-    /// Left column showing the changed-files tree.
     fn render_tree_column(&self, cx: &mut Context<Self>) -> AnyElement {
         let tree_state = self.tree_state.clone();
         let view = cx.entity().downgrade();
@@ -166,7 +148,6 @@ impl DiffPane {
             .into_any_element()
     }
 
-    /// Right column, header of the selected file plus its diff.
     fn render_detail_column(&self, cx: &mut Context<Self>) -> AnyElement {
         let Some(diff) = self.diff.as_ref() else {
             return placeholder("No changes", cx);
@@ -184,7 +165,6 @@ impl DiffPane {
         self.render_file_diff(file, cx.entity(), cx)
     }
 
-    /// The diff of one file, with a header showing status and stats.
     fn render_file_diff(&self, file: &FileDiff, view: Entity<Self>, cx: &App) -> AnyElement {
         let status_label = match file.status {
             DiffStatus::Added => "A",
@@ -311,19 +291,14 @@ impl Render for DiffPane {
     }
 }
 
-/// Detail panel showing the diff of one commit.
 pub struct CommitDiffView {
     focus_handle: FocusHandle,
-    /// Local clone the commit lives in.
     worktree: PathBuf,
-    /// Display name of the repository the commit belongs to.
     repo_name: SharedString,
-    /// The commit being shown in the header and tab title.
     commit: FileCommit,
     /// The diff is being computed on a background task.
     loading: bool,
     error: Option<SharedString>,
-    /// Changed-files explorer and per-file diff, also used by the new PR panel's compare view.
     pane: Entity<DiffPane>,
 }
 
@@ -359,7 +334,6 @@ impl CommitDiffView {
         }
     }
 
-    /// Load the commit diff and the full commit metadata.
     fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         self.loading = true;
         self.error = None;
@@ -407,7 +381,6 @@ impl CommitDiffView {
         task.detach();
     }
 
-    /// Header with the commit id, summary, author/time and overall change stats.
     fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
         let commit = &self.commit;
         let (files, insertions, deletions) = self.pane.read(cx).diff().map_or((0, 0, 0), |diff| {
@@ -535,3 +508,180 @@ impl Render for CommitDiffView {
             .child(resizable_panel().child(body))
     }
 }
+
+const GUTTER_WIDTH: f32 = 44.;
+const DIFF_ROW_HEIGHT: f32 = 20.;
+
+#[derive(Clone, Copy)]
+enum DiffRow {
+    Hunk {
+        old_start: u32,
+        old_lines: u32,
+        new_start: u32,
+        new_lines: u32,
+    },
+    Line {
+        hunk: usize,
+        line: usize,
+    },
+}
+
+fn diff_rows(file: &FileDiff) -> Vec<DiffRow> {
+    let mut rows = Vec::new();
+    for (hunk_ix, hunk) in file.hunks.iter().enumerate() {
+        rows.push(DiffRow::Hunk {
+            old_start: hunk.old_start,
+            old_lines: hunk.old_lines,
+            new_start: hunk.new_start,
+            new_lines: hunk.new_lines,
+        });
+        rows.extend((0..hunk.lines.len()).map(|line| DiffRow::Line {
+            hunk: hunk_ix,
+            line,
+        }));
+    }
+    rows
+}
+
+fn render_diff_row(hunks: &[DiffHunk], row: DiffRow, cx: &App) -> AnyElement {
+    match row {
+        DiffRow::Hunk {
+            old_start,
+            old_lines,
+            new_start,
+            new_lines,
+        } => div()
+            .px_2()
+            .w_full()
+            .h(px(DIFF_ROW_HEIGHT))
+            .font_family(cx.theme().mono_font_family.clone())
+            .text_xs()
+            .bg(cx.theme().muted)
+            .border_y(px(1.))
+            .border_color(cx.theme().border)
+            .text_color(cx.theme().muted_foreground)
+            .child(SharedString::from(format!(
+                "@@ -{},{} +{},{} @@",
+                old_start, old_lines, new_start, new_lines
+            )))
+            .into_any_element(),
+        DiffRow::Line { hunk, line } => render_diff_line(&hunks[hunk].lines[line], cx),
+    }
+}
+
+fn render_diff_line(line: &DiffLine, cx: &App) -> AnyElement {
+    let bg = match line.kind {
+        DiffLineKind::Addition => Some(cx.theme().success.opacity(0.2)),
+        DiffLineKind::Deletion => Some(cx.theme().danger.opacity(0.2)),
+        DiffLineKind::Context => None,
+    };
+    let gutter = cx.theme().muted_foreground;
+
+    // Fixed height and nowrap, the virtual list assumes every row has the same height.
+    // Long lines are clipped instead of wrapped.
+    h_flex()
+        .w_full()
+        .h(px(DIFF_ROW_HEIGHT))
+        .items_center()
+        .font_family(cx.theme().mono_font_family.clone())
+        .text_xs()
+        .when_some(bg, |this, bg| this.bg(bg))
+        .child(
+            div()
+                .w(px(GUTTER_WIDTH))
+                .flex_none()
+                .pr_2()
+                .text_right()
+                .text_color(gutter)
+                .child(line.old.map(|n| n.to_string()).unwrap_or_default()),
+        )
+        .child(
+            div()
+                .w(px(GUTTER_WIDTH))
+                .flex_none()
+                .pr_2()
+                .text_right()
+                .text_color(gutter)
+                .child(line.new.map(|n| n.to_string()).unwrap_or_default()),
+        )
+        .child(
+            div()
+                .flex_1()
+                .min_w_0()
+                .overflow_hidden()
+                .whitespace_nowrap()
+                .text_color(cx.theme().foreground)
+                .child(line.text.clone()),
+        )
+        .into_any_element()
+}
+
+fn find_item<'a>(items: &'a [TreeItem], id: Option<&str>) -> Option<&'a TreeItem> {
+    let id = id?;
+    items.iter().find_map(|item| {
+        if item.id.as_ref() == id {
+            Some(item)
+        } else {
+            find_item(&item.children, Some(id))
+        }
+    })
+}
+
+pub(crate) const COMMIT_ROW_HEIGHT: f32 = 56.;
+
+pub(crate) fn commit_row(
+    ix: usize,
+    commit: &FileCommit,
+    on_click: impl Fn(&mut Window, &mut App) + 'static,
+    cx: &App,
+) -> AnyElement {
+    h_flex()
+        .id(ix)
+        .px_4()
+        .h(px(COMMIT_ROW_HEIGHT))
+        .w_full()
+        .gap_3()
+        .items_center()
+        .border_b(px(1.))
+        .border_color(cx.theme().border)
+        .hover(|this| this.bg(cx.theme().list_hover))
+        .child(
+            v_flex()
+                .flex_1()
+                .min_w_0()
+                .gap_0p5()
+                .justify_center()
+                .child(
+                    h_flex()
+                        .gap_2()
+                        .items_center()
+                        .overflow_hidden()
+                        .child(
+                            div()
+                                .font_family(cx.theme().mono_font_family.clone())
+                                .text_xs()
+                                .text_color(cx.theme().muted_foreground)
+                                .child(commit.id.clone()),
+                        )
+                        .child(
+                            div()
+                                .flex_1()
+                                .min_w_0()
+                                .text_sm()
+                                .text_ellipsis()
+                                .whitespace_nowrap()
+                                .child(commit.summary.clone()),
+                        ),
+                )
+                .child(
+                    h_flex()
+                        .gap_2()
+                        .text_xs()
+                        .text_color(cx.theme().muted_foreground)
+                        .child(commit.author.clone())
+                        .child(relative_time_secs(commit.time)),
+                ),
+        )
+        .on_click(move |_event, window, cx| on_click(window, cx))
+        .into_any_element()
+}

crates/workspace/src/views/dialog_state.rs

@@ -2,8 +2,7 @@ use gpui::prelude::*;
 use gpui::{AnyElement, App, SharedString, div};
 use gpui_component::ActiveTheme;
 
-/// Progress of an async dialog action: a busy flag disabling the form,
-/// and an error line shown under it.
+/// Progress of an async dialog action: a busy flag that disables the form and an error shown below it.
 #[derive(Debug, Default)]
 pub struct DialogProgress {
     pub busy: bool,
@@ -11,13 +10,13 @@ pub struct DialogProgress {
 }
 
 impl DialogProgress {
-    /// An action started, disable the form and clear the previous error.
+    /// Marks an action as started, disabling the form and clearing the previous error.
     pub fn begin(&mut self) {
         self.busy = true;
         self.error = None;
     }
 
-    /// An action failed, re-enable the form and surface `message`.
+    /// Marks an action as failed, enabling the form and showing `message`.
     pub fn fail(&mut self, message: impl Into<SharedString>) {
         self.busy = false;
         self.error = Some(message.into());

crates/workspace/src/views/discussion.rs

@@ -0,0 +1,217 @@
+use assets::CustomIconName;
+use gpui::prelude::*;
+use gpui::{AnyElement, App, Entity, SharedString, div, px};
+use gpui_component::button::{Button, ButtonVariants};
+use gpui_component::input::{Textarea, TextareaState};
+use gpui_component::tag::Tag;
+use gpui_component::{ActiveTheme, Icon, Sizable, StyledExt, h_flex, v_flex};
+use nostr::prelude::{Event, EventId, PublicKey};
+use signed_state::{ProfileStore, RepoStore};
+use signed_ui::UserAvatar;
+use utils::relative_time;
+
+pub(crate) fn issue_roots(store: &RepoStore) -> &[Event] {
+    &store.issues
+}
+
+pub(crate) fn pr_roots(store: &RepoStore) -> &[Event] {
+    &store.pull_requests
+}
+
+fn sidebar_title(text: &str, cx: &App) -> AnyElement {
+    div()
+        .text_xs()
+        .font_semibold()
+        .text_color(cx.theme().muted_foreground)
+        .child(text.to_string())
+        .into_any_element()
+}
+
+pub(crate) fn sidebar_section(
+    store: &Entity<RepoStore>,
+    id: EventId,
+    roots: fn(&RepoStore) -> &[Event],
+    top_gap: bool,
+    cx: &App,
+) -> AnyElement {
+    let store = store.read(cx);
+    let Some(root) = roots(store).iter().find(|event| event.id == id) else {
+        // The caller bails out when the root is missing.
+        return div().into_any_element();
+    };
+    let profile_store = ProfileStore::global(cx);
+
+    // Participants, the root author plus everyone who commented.
+    let mut participants: Vec<PublicKey> = vec![root.pubkey];
+    participants.extend(store.comments_of(&root.id).map(|comment| comment.pubkey));
+    participants.sort_by_key(PublicKey::to_hex);
+    participants.dedup();
+
+    // Labels are NIP-34 `t` hashtag tags on the event.
+    let labels: Vec<String> = root.tags.hashtags().map(|tag| tag.to_string()).collect();
+
+    v_flex()
+        .w(px(240.))
+        .h_full()
+        .flex_none()
+        .px_4()
+        .gap_4()
+        .border_l(px(1.))
+        .border_color(cx.theme().sidebar_border)
+        .child(
+            v_flex()
+                .when(top_gap, |this| this.mt_4())
+                .gap_2()
+                .child(sidebar_title("Participants", cx))
+                .children(participants.iter().map(|pubkey| {
+                    let profile = profile_store.read(cx).get(pubkey);
+                    let name = profile.name();
+                    let picture = profile.picture();
+
+                    h_flex()
+                        .gap_1()
+                        .items_center()
+                        .child(UserAvatar::new(name.clone()).picture(picture))
+                        .child(div().text_sm().truncate().text_ellipsis().child(name))
+                        .into_any_element()
+                })),
+        )
+        .child(
+            v_flex()
+                .gap_2()
+                .child(sidebar_title("Labels", cx))
+                .map(|this| {
+                    if labels.is_empty() {
+                        this.child(
+                            div()
+                                .text_sm()
+                                .text_color(cx.theme().muted_foreground)
+                                .child("None yet."),
+                        )
+                    } else {
+                        this.child(h_flex().gap_1().children({
+                            let mut items = vec![];
+
+                            for label in labels.iter() {
+                                items.push(
+                                    Tag::secondary()
+                                        .outline()
+                                        .xsmall()
+                                        .child(SharedString::from(label)),
+                                );
+                            }
+
+                            items
+                        }))
+                    }
+                }),
+        )
+        .into_any_element()
+}
+
+pub(crate) fn comments_section(store: &Entity<RepoStore>, root: EventId, cx: &App) -> AnyElement {
+    let store = store.read(cx);
+    let comments: Vec<&Event> = store.comments_of(&root).collect();
+    let title = SharedString::from(format!("Discussions {}", comments.len()));
+
+    v_flex()
+        .gap_4()
+        .child(div().text_xs().font_semibold().child(title))
+        .children(comments.iter().map(|comment| {
+            let profile = ProfileStore::global(cx).read(cx).get(&comment.pubkey);
+            let author = profile.name();
+            let picture = profile.picture();
+            let age = relative_time(comment.created_at);
+            let content = SharedString::from(comment.content.as_str());
+
+            v_flex()
+                .gap_1()
+                .p_3()
+                .border_1()
+                .border_color(cx.theme().border)
+                .rounded(cx.theme().radius)
+                .child(
+                    h_flex()
+                        .gap_2()
+                        .text_sm()
+                        .child(
+                            h_flex()
+                                .gap_1()
+                                .child(UserAvatar::new(author.clone()).picture(picture))
+                                .child(author),
+                        )
+                        .child(
+                            div()
+                                .text_color(cx.theme().muted_foreground)
+                                .child("commented"),
+                        )
+                        .child(
+                            div()
+                                .text_color(cx.theme().muted_foreground)
+                                .child(SharedString::from(age)),
+                        ),
+                )
+                .child(div().text_sm().child(content))
+        }))
+        .into_any_element()
+}
+
+/// `roots` selects the root's list within the store, issues or pull requests.
+pub(crate) fn comment_form(
+    store: &Entity<RepoStore>,
+    root: EventId,
+    roots: fn(&RepoStore) -> &[Event],
+    comment_input: &Entity<TextareaState>,
+    button_id: &'static str,
+    cx: &App,
+) -> AnyElement {
+    let comment_input = comment_input.clone();
+    let store = store.clone();
+
+    v_flex()
+        .gap_2()
+        .child(
+            Textarea::new(&comment_input)
+                .h_24()
+                .text_color(cx.theme().muted_foreground)
+                .bg(cx.theme().muted),
+        )
+        .child(
+            h_flex()
+                .justify_between()
+                .child(
+                    h_flex()
+                        .gap_1()
+                        .text_xs()
+                        .text_color(cx.theme().muted_foreground)
+                        .child(Icon::new(CustomIconName::Markdown).small())
+                        .child("Markdown is supported"),
+                )
+                .child(
+                    Button::new(button_id)
+                        .primary()
+                        .label("Comment")
+                        .tooltip("Post comment")
+                        .on_click(move |_event, window, cx| {
+                            let content = comment_input.read(cx).value().trim().to_string();
+                            if content.is_empty() {
+                                return;
+                            }
+                            let Some(root) = roots(store.read(cx))
+                                .iter()
+                                .find(|event| event.id == root)
+                                .cloned()
+                            else {
+                                return;
+                            };
+                            store.update(cx, |store, cx| {
+                                store.comment(&root, content, cx);
+                            });
+                            comment_input.update(cx, |input, cx| {
+                                input.set_value("", window, cx);
+                            });
+                        }),
+                ),
+        )
+        .into_any_element()
+}

crates/workspace/src/views/inbox.rs

@@ -21,20 +21,13 @@ use utils::relative_time;
 
 use super::{RepoItem, open_repo_item};
 
-/// Delay between a refresh request and the actual re-query.
 const REFRESH_DEBOUNCE: Duration = Duration::from_millis(300);
-
-/// Extra list rows measured above and below the visible area.
 const LIST_OVERDRAW: Pixels = px(400.);
-
-/// Maximum number of sub-activity lines shown under a thread row.
 const MAX_SUB_ACTIVITIES: usize = 5;
 
-/// A repository's slice of the inbox: the threads that belong to it.
 struct InboxSection {
-    /// Repository the section groups, `None` for items without one.
+    /// `None` for items without a repository.
     address: Option<RepoAddr>,
-    /// Number of threads with an unread event.
     unread: usize,
     /// Indices into the threads, newest activity first.
     entries: Vec<usize>,
@@ -54,15 +47,11 @@ pub struct InboxView {
     dock_area: WeakEntity<DockArea>,
     /// One row per thread, merging notifications and own activity, newest first.
     threads: Arc<Vec<InboxItem>>,
-    /// The threads grouped by repository, newest first.
     sections: Arc<Vec<InboxSection>>,
-    /// The flattened repository headers and rows of the list.
     rows: Arc<Vec<InboxRow>>,
-    /// Number of non-archived threads with an unread event.
     unread_count: usize,
     /// Copy of the global read state the current lists were derived with.
     state: InboxReadState,
-    /// Set once the global state has been read for the current user.
     state_loaded: bool,
     refresh: RefreshGate,
     list: ListState,
@@ -118,7 +107,6 @@ impl InboxView {
         }
     }
 
-    /// Mark every known notification read.
     pub fn mark_all_read(&mut self, cx: &mut Context<Self>) {
         let Some(me) = Backend::global(cx).read(cx).current_user() else {
             return;
@@ -136,7 +124,6 @@ impl InboxView {
         inbox.update(cx, |inbox, cx| inbox.mark_all_read(&all, me, cx));
     }
 
-    /// Re-derive from the global state when it is loaded or changes.
     pub fn sync_state(&mut self, cx: &mut Context<Self>) {
         let backend = Backend::global(cx);
         let inbox = backend.read(cx).inbox();
@@ -170,7 +157,6 @@ impl InboxView {
         }
     }
 
-    /// Handle a backend event that can change the derived sections.
     fn handle_backend_event(&mut self, event: &BackendEvent, cx: &mut Context<Self>) {
         match event {
             BackendEvent::NostrUpdate(updates) => {
@@ -192,7 +178,6 @@ impl InboxView {
         }
     }
 
-    /// One-shot initial load, no debounce.
     fn refresh_initial(&mut self, cx: &mut Context<Self>) {
         debug_assert!(!self.refresh.debouncing());
         if self.refresh.running() {
@@ -202,7 +187,6 @@ impl InboxView {
         self.run_refresh(cx);
     }
 
-    /// Re-query the local database.
     fn refresh(&mut self, cx: &mut Context<Self>) {
         if !self.state_loaded {
             return;
@@ -218,7 +202,6 @@ impl InboxView {
         }));
     }
 
-    /// One query and apply cycle, the debounced entry point.
     fn run_refresh(&mut self, cx: &mut Context<Self>) {
         self.refresh.begin();
 
@@ -264,7 +247,6 @@ impl InboxView {
         }));
     }
 
-    /// Recompute the unread and archived flags from the current state.
     fn regroup(&mut self, cx: &mut Context<Self>) {
         let mut items = (*self.threads).clone();
 
@@ -277,7 +259,6 @@ impl InboxView {
         self.rebuild(cx);
     }
 
-    /// Regroup the current threads by repository and flatten them into rows.
     fn rebuild(&mut self, cx: &mut Context<Self>) {
         let backend = Backend::global(cx);
         let repo_list = RepoListStore::global(cx);
@@ -308,7 +289,6 @@ impl InboxView {
         self.rows = Arc::new(rows);
     }
 
-    /// Group the threads into one section per repository.
     fn group_sections(&self) -> Vec<InboxSection> {
         let mut by_repo: HashMap<Option<RepoAddr>, InboxSection> = HashMap::new();
 
@@ -349,7 +329,6 @@ impl InboxView {
         sections
     }
 
-    /// Flatten the sections into the list of repository headers and their rows.
     fn flatten_rows(&self, sections: &[InboxSection]) -> Vec<InboxRow> {
         let mut rows = Vec::new();
 
@@ -369,7 +348,6 @@ impl InboxView {
         rows
     }
 
-    /// Forget everything derived for the current user.
     fn clear(&mut self) {
         self.threads = Arc::new(Vec::new());
         self.sections = Arc::new(Vec::new());
@@ -393,16 +371,6 @@ impl InboxView {
             return;
         };
 
-        let Some(announcement) = RepoListStore::global(cx)
-            .read(cx)
-            .announcements
-            .iter()
-            .find(|announcement| announcement.addr() == address)
-            .cloned()
-        else {
-            return;
-        };
-
         let item = match kind {
             Some(Kind::GitIssue) => RepoItem::Issue(root),
             Some(Kind::GitPullRequest) => RepoItem::PullRequest(root),
@@ -410,7 +378,7 @@ impl InboxView {
             _ => return,
         };
 
-        open_repo_item(&self.dock_area, &announcement, item, window, cx);
+        open_repo_item(&self.dock_area, &address, None, item, window, cx);
     }
 
     fn render_entry(&self, ix: usize, cx: &Context<Self>) -> AnyElement {
@@ -455,7 +423,6 @@ impl InboxView {
     }
 }
 
-/// Display name of the repository at `addr`, from the announcement store.
 fn repo_name(addr: Option<&RepoAddr>, cx: &App) -> Option<SharedString> {
     let repo_list = RepoListStore::global(cx);
     let addr = addr?;
@@ -467,7 +434,6 @@ fn repo_name(addr: Option<&RepoAddr>, cx: &App) -> Option<SharedString> {
         .map(|announcement| announcement.name().map(SharedString::from))
 }
 
-/// Header of a repository section.
 fn repo_header(section: &InboxSection, cx: &App) -> AnyElement {
     let name =
         repo_name(section.address.as_ref(), cx).unwrap_or_else(|| SharedString::from("Untitled"));
@@ -491,7 +457,6 @@ fn repo_header(section: &InboxSection, cx: &App) -> AnyElement {
         .into_any_element()
 }
 
-/// Placeholder under a repository header that has nothing to show.
 fn empty_section_row(cx: &App) -> AnyElement {
     h_flex()
         .h_12()
@@ -610,7 +575,6 @@ fn sub_activity(event: &Event, me: Option<PublicKey>, cx: &App) -> AnyElement {
         .into_any_element()
 }
 
-/// Phrase describing an activity event, read as `[name] [phrase]`.
 fn activity_phrase(kind: Kind) -> &'static str {
     if kind == COVER_NOTE_KIND {
         return "added a note";
@@ -630,7 +594,6 @@ fn activity_phrase(kind: Kind) -> &'static str {
     }
 }
 
-/// Centered muted icon and message filling its container.
 fn empty_state(icon: impl IconNamed, message: &str, cx: &App) -> AnyElement {
     v_flex()
         .w_full()

crates/workspace/src/views/issues/detail.rs

@@ -1,8 +1,8 @@
 use dock::{BasePanel, Panel, PanelEvent};
 use gpui::prelude::*;
 use gpui::{
-    App, Context, Entity, EventEmitter, FocusHandle, Focusable, Render, SharedString, Window, div,
-    relative,
+    App, Context, Entity, EventEmitter, FocusHandle, Focusable, Render, SharedString, Subscription,
+    Window, div, relative,
 };
 use gpui_component::input::TextareaState;
 use gpui_component::scroll::ScrollableElement;
@@ -13,16 +13,14 @@ use signed_state::{ProfileStore, RepoStore};
 use signed_ui::{UserAvatar, placeholder, status_badge};
 use utils::relative_time;
 
-use super::helpers::{comment_form, comments_section, issue_roots, sidebar_section};
+use crate::views::discussion::{comment_form, comments_section, issue_roots, sidebar_section};
 
-/// Detail panel of a single issue.
 pub struct IssueDetailView {
-    /// Repo store holding the issues and their statuses.
+    focus_handle: FocusHandle,
     store: Entity<RepoStore>,
     issue_id: EventId,
-    /// Input state of the comment textarea.
     comment_input: Entity<TextareaState>,
-    focus_handle: FocusHandle,
+    _subscription: Subscription,
 }
 
 impl IssueDetailView {
@@ -35,11 +33,14 @@ impl IssueDetailView {
         let comment_input =
             cx.new(|cx| TextareaState::new(window, cx).placeholder("Leave a comment..."));
 
+        let subscription = cx.observe(&store, |_this, _store, cx| cx.notify());
+
         Self {
             focus_handle: cx.focus_handle(),
             store,
             issue_id,
             comment_input,
+            _subscription: subscription,
         }
     }
 }
@@ -81,7 +82,12 @@ impl Render for IssueDetailView {
         let store = self.store.read(cx);
 
         let Some(issue) = store.issues.iter().find(|issue| issue.id == self.issue_id) else {
-            return placeholder("Issue not found", cx);
+            // The store has not applied its first pass yet, the issue may still arrive.
+            return if store.loaded {
+                placeholder("Issue not found", cx)
+            } else {
+                placeholder("Loading issue...", cx)
+            };
         };
 
         let (title, author, picture, status, age, issue_id, content) = {

crates/workspace/src/views/issues/mod.rs

@@ -4,8 +4,8 @@ use assets::CustomIconName;
 use dock::{BasePanel, DockArea, Panel, PanelEvent, add_center_panel, panel_handle};
 use gpui::prelude::*;
 use gpui::{
-    AnyElement, App, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render,
-    SharedString, Size, WeakEntity, Window, div, px, size,
+    AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels,
+    Render, SharedString, Size, Subscription, WeakEntity, Window, div, px, size,
 };
 use gpui_component::button::{Button, ButtonVariants};
 use gpui_component::dialog::{DialogDescription, DialogFooter, DialogHeader, DialogTitle};
@@ -21,24 +21,20 @@ use signed_state::{ProfileStore, RepoStore};
 use signed_ui::{SegmentButton, UserAvatar, placeholder, status_badge};
 use utils::relative_time;
 
-use super::issue_detail::IssueDetailView;
+pub(super) mod detail;
+
+use self::detail::IssueDetailView;
 
-/// Height of one issue row in the virtual list.
 const ISSUE_ROW_HEIGHT: f32 = 73.;
 
-/// Status filter of the issues list, chosen via the header's filter buttons.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum IssueFilter {
-    /// Every issue, regardless of status.
     All,
-    /// Issues whose resolved status is [`RepoStatus::Open`].
     Open,
-    /// Issues whose resolved status is [`RepoStatus::Closed`].
     Closed,
 }
 
 impl IssueFilter {
-    /// Whether an issue with `status` is included by this filter.
     fn matches(self, status: RepoStatus) -> bool {
         match self {
             Self::All => true,
@@ -50,37 +46,37 @@ impl IssueFilter {
 
 pub struct IssuesView {
     focus_handle: FocusHandle,
-    /// Dock area the issue detail panel is opened in.
     dock_area: WeakEntity<DockArea>,
-    /// Repo store holding the issues and their statuses.
     store: Entity<RepoStore>,
-    /// Display name of the repository, for the panel title.
     repo_name: SharedString,
-    /// Filter selected in the header filter buttons.
     filter: IssueFilter,
-    /// Per-row heights of the virtual list.
     item_sizes: Rc<Vec<Size<Pixels>>>,
-    /// The filtered issue count [`Self::item_sizes`] was built for.
-    issue_len: usize,
-    /// Indices into the store's `issues` matching [`Self::filter`].
     visible_issues: Vec<usize>,
-    /// Header counts `(total, open, closed)`, rebuilt with [`Self::visible_issues`].
     counts: (usize, usize, usize),
-    /// Store version and filter the cached rows/counts were built from.
-    cache_key: Option<(u64, IssueFilter)>,
-    /// Virtual list state of the issues list.
+    // A filter change notifies even when the visible rows are unchanged,
+    // e.g. switching between two empty filters.
+    synced_filter: IssueFilter,
     scroll_handle: VirtualListScrollHandle,
+    _subscription: Subscription,
 }
 
 impl IssuesView {
     pub fn new(
         dock_area: WeakEntity<DockArea>,
         store: Entity<RepoStore>,
-        _window: &mut Window,
+        window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
         let repo_name = store.read(cx).name();
 
+        let subscription = cx.observe(&store, |this, _store, cx| {
+            this.rebuild(cx);
+        });
+
+        cx.defer_in(window, |this, _window, cx| {
+            this.rebuild(cx);
+        });
+
         Self {
             focus_handle: cx.focus_handle(),
             dock_area,
@@ -88,14 +84,60 @@ impl IssuesView {
             repo_name,
             filter: IssueFilter::Open,
             item_sizes: Rc::new(Vec::new()),
-            issue_len: 0,
             visible_issues: Vec::new(),
             counts: (0, 0, 0),
-            cache_key: None,
+            synced_filter: IssueFilter::Open,
             scroll_handle: VirtualListScrollHandle::new(),
+            _subscription: subscription,
         }
     }
 
+    fn rebuild(&mut self, cx: &mut Context<Self>) {
+        let filter = self.filter;
+
+        let (visible_issues, counts) = {
+            let store = self.store.read(cx);
+            let mut counts = (0usize, 0usize, 0usize);
+
+            let visible_issues: Vec<usize> = store
+                .issues
+                .iter()
+                .enumerate()
+                .filter_map(|(ix, issue)| {
+                    let status = store.status_of(issue);
+                    counts.0 += 1;
+                    match status {
+                        RepoStatus::Open => counts.1 += 1,
+                        RepoStatus::Closed => counts.2 += 1,
+                        RepoStatus::Draft | RepoStatus::Applied => {}
+                    }
+                    filter.matches(status).then_some(ix)
+                })
+                .collect();
+
+            (visible_issues, counts)
+        };
+
+        let filter_changed = self.synced_filter != filter;
+        let visible_issues_changed = self.visible_issues != visible_issues;
+        let counts_changed = self.counts != counts;
+
+        if !filter_changed && !visible_issues_changed && !counts_changed {
+            return;
+        }
+
+        self.item_sizes = Rc::new(vec![
+            size(px(0.), px(ISSUE_ROW_HEIGHT));
+            visible_issues.len()
+        ]);
+
+        self.synced_filter = filter;
+        self.visible_issues = visible_issues;
+        self.counts = counts;
+
+        cx.notify();
+    }
+
     /// Open the detail panel of `issue_id` in the dock area.
     fn open_issue_detail(
         &mut self,
@@ -176,7 +218,6 @@ impl IssuesView {
     }
 
     fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
-        // Counts of the last list rebuild.
         let (total, open, closed) = self.counts;
 
         h_flex()
@@ -197,7 +238,7 @@ impl IssuesView {
                             .selected(self.filter == IssueFilter::All)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = IssueFilter::All;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     )
                     .child(
@@ -207,7 +248,7 @@ impl IssuesView {
                             .selected(self.filter == IssueFilter::Open)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = IssueFilter::Open;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     )
                     .child(
@@ -217,7 +258,7 @@ impl IssuesView {
                             .selected(self.filter == IssueFilter::Closed)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = IssueFilter::Closed;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     ),
             )
@@ -234,7 +275,6 @@ impl IssuesView {
     }
 }
 
-/// Open the new issue dialog, a title and a content input.
 pub(super) fn open_new_issue_dialog(store: Entity<RepoStore>, window: &mut Window, cx: &mut App) {
     let subject = cx.new(|cx| InputState::new(window, cx).placeholder("Issue title"));
     let content = cx.new(|cx| TextareaState::new(window, cx).placeholder("Describe the issue..."));
@@ -322,41 +362,7 @@ impl Focusable for IssuesView {
 impl Render for IssuesView {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let filter = self.filter;
-
-        // Rows and counts are rebuilt only when the store refreshed or filter changed.
-        let version = self.store.read(cx).version();
-
-        if self.cache_key != Some((version, filter)) {
-            let store = self.store.read(cx);
-            let mut counts = (0usize, 0usize, 0usize);
-            self.visible_issues = store
-                .issues
-                .iter()
-                .enumerate()
-                .filter_map(|(ix, issue)| {
-                    let status = store.status_of(issue);
-                    counts.0 += 1;
-                    match status {
-                        RepoStatus::Open => counts.1 += 1,
-                        RepoStatus::Closed => counts.2 += 1,
-                        RepoStatus::Draft | RepoStatus::Applied => {}
-                    }
-                    filter.matches(status).then_some(ix)
-                })
-                .collect();
-            self.counts = counts;
-            self.cache_key = Some((version, filter));
-        }
-
         let count = self.visible_issues.len();
-
-        // The virtual list's item count comes from `item_sizes`.
-        // Rebuild it whenever the filtered issue count changes.
-        if count != self.issue_len {
-            self.issue_len = count;
-            self.item_sizes = Rc::new(vec![size(px(0.), px(ISSUE_ROW_HEIGHT)); count]);
-        }
-
         let sizes = self.item_sizes.clone();
         let scroll_handle = self.scroll_handle.clone();
 

crates/workspace/src/views/mod.rs

@@ -1,11 +1,17 @@
+mod commit_diff;
 mod dialog_state;
+pub(crate) mod discussion;
 mod inbox;
-mod repo_detail;
+mod issues;
+mod pull_requests;
+mod repo;
 mod repo_list;
+mod send_patch;
 pub(crate) mod sidebar;
+pub(crate) mod tree;
 
 pub use inbox::InboxView;
-pub use repo_detail::RepoDetailView;
-pub(crate) use repo_detail::{RepoItem, open_repo_item, open_repo_panel};
+pub use repo::RepoDetailView;
+pub(crate) use repo::{RepoItem, open_repo_item, open_repo_panel};
 pub use repo_list::RepoListView;
 pub use sidebar::SidebarPanel;

crates/workspace/src/views/pull_requests/detail.rs

@@ -6,7 +6,7 @@ use dock::{BasePanel, DockArea, DockPlacement, Panel, PanelEvent, panel_handle};
 use gpui::prelude::*;
 use gpui::{
     AnyElement, App, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render,
-    SharedString, Size, WeakEntity, Window, div, px, relative, size,
+    SharedString, Size, Subscription, WeakEntity, Window, div, px, relative, size,
 };
 use gpui_component::button::{Button, ButtonVariants};
 use gpui_component::clipboard::Clipboard;
@@ -20,9 +20,9 @@ use gpui_component::{
     ActiveTheme, Sizable, StyledExt, VirtualListScrollHandle, WindowExt, h_flex, v_flex,
     v_virtual_list,
 };
-use nostr::prelude::{Event, EventId, Kind};
+use nostr::prelude::{Event, EventId, Kind, Url};
 use signed_core::{
-    activity_subject, branch_name_of, clone_urls_of, current_commit_of, latest_update,
+    RepoAddr, activity_subject, branch_name_of, clone_urls_of, current_commit_of, latest_update,
     merge_base_of, pull_request_patch,
 };
 use signed_git::{FileCommit, patch_commits, patch_diffs};
@@ -30,45 +30,57 @@ use signed_state::{Backend, GitStore, ProfileStore, RepoStore};
 use signed_ui::{CountBadge, UserAvatar, placeholder, status_badge};
 use utils::{relative_time, relative_time_secs};
 
-use super::diff::{CommitDiffView, DiffPane};
-use super::helpers::{comment_form, comments_section, pr_roots, sidebar_section};
+use crate::views::commit_diff::{CommitDiffView, DiffPane};
+use crate::views::discussion::{comment_form, comments_section, pr_roots, sidebar_section};
 
-/// Height of one commit row in the commits tab's virtual list.
 const ROW_HEIGHT: f32 = 37.;
 
+/// Shown once the store's first pass is applied and the root PR is still absent.
+const NOT_FOUND: &str = "Pull request not found";
+
+/// A store refresh re-binds the panel, and reloads only when these change.
+#[derive(Clone, PartialEq, Eq)]
+struct PrBinding {
+    description: String,
+    patch: String,
+    tip: Option<String>,
+    base: Option<String>,
+    clone_urls: Vec<Url>,
+    addr: RepoAddr,
+    has_patch_link: bool,
+}
+
 /// Detail panel of a single pull request.
 pub struct PullRequestDetailView {
     focus_handle: FocusHandle,
-    /// Dock area where new panels, e.g. commit diffs, are added.
     dock_area: WeakEntity<DockArea>,
-    /// Repo store holding the PR, its status and comments.
     store: Entity<RepoStore>,
-    /// Event id of the root PR event, kind 1618.
-    /// Updates are revisions.
+    /// Event id of the root PR event, kind 1618. Updates are revisions.
     pr_id: EventId,
-    /// Input state of the comment textarea.
     comment_input: Entity<TextareaState>,
-    /// Display name of the repository, for panels opened from here.
     repo_name: SharedString,
     /// Local clone the PR's git changes come from.
     worktree: Option<PathBuf>,
-    /// Root PR's content, shown as plain text.
     description: SharedString,
-    /// Tip commit of the PR, the latest update's `c` tag or the root's.
+    /// Tip commit of the PR, from the latest update's `c` tag or the root.
     current_commit: Option<SharedString>,
     /// Commits of the patch series, in patch order, oldest first.
     commits: Vec<FileCommit>,
     /// The patch is being parsed on a background task.
     loading: bool,
     error: Option<SharedString>,
-    /// Active header tab, 0 = Discussion, 1 = Files, 2 = Commits.
+    /// Root PR inputs the in-flight diff load was started for.
+    bound: Option<PrBinding>,
+    /// Generation of the in-flight diff load. Stale results are discarded.
+    load_generation: u64,
+    /// 0 = Discussion, 1 = Files, 2 = Commits.
     active_tab: usize,
-    /// Changed-files explorer and per-file diff, like the commit and compare views.
     pane: Entity<DiffPane>,
-    /// Per-row heights of the commits tab's virtual list, built when the patch series loads.
     commit_item_sizes: Rc<Vec<Size<Pixels>>>,
-    /// Virtual list state of the commits tab.
     commit_scroll_handle: VirtualListScrollHandle,
+    /// The dock caches item panels, so without this observer a panel opened
+    /// before the store loaded would stay on its placeholder.
+    _subscription: Subscription,
 }
 
 impl PullRequestDetailView {
@@ -85,9 +97,11 @@ impl PullRequestDetailView {
         let comment_input =
             cx.new(|cx| TextareaState::new(window, cx).placeholder("Leave a comment..."));
 
+        let subscription = cx.observe(&store, |this, _store, cx| this.sync(cx));
+
         // Defer loading until the window is ready, like the commit diff view.
-        cx.defer_in(window, |this, window, cx| {
-            this.load(window, cx);
+        cx.defer_in(window, |this, _window, cx| {
+            this.sync(cx);
         });
 
         Self {
@@ -103,156 +117,217 @@ impl PullRequestDetailView {
             commits: Vec::new(),
             loading: true,
             error: None,
+            bound: None,
+            load_generation: 0,
             active_tab: 0,
             pane,
             commit_item_sizes: Rc::new(Vec::new()),
             commit_scroll_handle: VirtualListScrollHandle::new(),
+            _subscription: subscription,
         }
     }
 
-    /// Snapshot the PR events from the store.
-    fn load(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    /// Snapshot the root PR from the store and reload the diff when it changed.
+    ///
+    /// Re-runs on construction and on every store refresh. Item panels are
+    /// cached by the dock, so this is the only way a panel opened before the
+    /// store's first pass learns about its PR.
+    fn sync(&mut self, cx: &mut Context<Self>) {
+        let loaded = self.store.read(cx).loaded;
+
+        let binding = {
+            let store = self.store.read(cx);
+
+            store.addr().and_then(|addr| {
+                store
+                    .pull_requests
+                    .iter()
+                    .find(|pr| pr.id == self.pr_id && pr.kind == Kind::GitPullRequest)
+                    .map(|root| {
+                        let update = latest_update(store.pull_requests.iter(), root);
+
+                        let tip = update
+                            .and_then(current_commit_of)
+                            .or_else(|| current_commit_of(root));
+
+                        let base = update
+                            .and_then(merge_base_of)
+                            .or_else(|| merge_base_of(root));
+
+                        let clone_urls = clone_urls_of(root)
+                            .or_else(|| store.announcement.as_ref().map(|a| a.clone.clone()))
+                            .unwrap_or_default();
+
+                        PrBinding {
+                            description: root.content.clone(),
+                            patch: pull_request_patch(root, store.patches.iter()),
+                            tip,
+                            base,
+                            clone_urls,
+                            addr: addr.clone(),
+                            has_patch_link: root.tags.event_ids().next().is_some(),
+                        }
+                    })
+            })
+        };
+
+        let Some(binding) = binding else {
+            self.sync_missing(loaded, cx);
+            return;
+        };
+
+        if self.bound.as_ref() == Some(&binding) {
+            return;
+        }
+
+        self.bound = Some(binding.clone());
+        self.load_diff(binding, cx);
+    }
+
+    /// The store does not hold the root PR yet, or at all.
+    ///
+    /// Loading until the first pass is applied, not found afterwards.
+    fn sync_missing(&mut self, loaded: bool, cx: &mut Context<Self>) {
+        self.bound = None;
+
+        if !loaded {
+            if !self.loading || self.error.is_some() {
+                self.loading = true;
+                self.error = None;
+                cx.notify();
+            }
+            return;
+        }
+
+        if self.error.as_deref() != Some(NOT_FOUND) {
+            self.loading = false;
+            self.error = Some(NOT_FOUND.into());
+            cx.notify();
+        }
+    }
+
+    /// Load the bound PR's changed files and commits.
+    ///
+    /// Nostr-backed pull requests parse the patch series, git-backed ones fetch
+    /// the clone and diff the `merge-base..tip` range.
+    fn load_diff(&mut self, binding: PrBinding, cx: &mut Context<Self>) {
         self.loading = true;
         self.error = None;
+        self.description = binding.description.clone().into();
+        self.current_commit = binding.tip.clone().map(SharedString::from);
         cx.notify();
 
         let cache = GitStore::global(cx).cache().clone();
 
-        let (description, patch, current_commit, merge_base, clone_urls, addr, has_patch_link) = {
-            let store = self.store.read(cx);
+        self.load_generation = self.load_generation.wrapping_add(1);
+        let generation = self.load_generation;
 
-            let Some(root) = store
-                .pull_requests
-                .iter()
-                .find(|pr| pr.id == self.pr_id && pr.kind == Kind::GitPullRequest)
-            else {
-                self.loading = false;
-                self.error = Some("Pull request not found".into());
-                cx.notify();
-                return;
+        let PrBinding {
+            patch,
+            tip,
+            base,
+            clone_urls,
+            addr,
+            has_patch_link,
+            ..
+        } = binding;
+
+        let task: gpui::Task<Result<(), anyhow::Error>> = cx.spawn(async move |this, cx| {
+            let nostr_diff = cx
+                .background_spawn({
+                    let patch = patch.clone();
+                    async move { patch_diffs(&patch) }
+                })
+                .await;
+
+            let nostr_commits = cx
+                .background_spawn({
+                    let patch = patch.clone();
+                    async move { patch_commits(&patch) }
+                })
+                .await;
+
+            // PRs without patch events, e.g. published by ngit, carry their changes in git.
+            // Fetch the clone and diff the `merge-base..tip` range.
+            let use_nostr = match &nostr_diff {
+                Ok(diff) => has_patch_link || !diff.files.is_empty(),
+                Err(_) => true,
             };
 
-            let update = latest_update(store.pull_requests.iter(), root);
+            let git = if use_nostr {
+                None
+            } else {
+                let cache = cache.clone();
+                let addr = addr.clone();
+                let clone_urls = clone_urls.clone();
+                let base = base.clone();
+                let tip = tip.clone();
 
-            let tip = update
-                .and_then(current_commit_of)
-                .or_else(|| current_commit_of(root));
+                Some(
+                    cx.background_spawn(async move {
+                        let repo = cache.ensure_clone(&addr, &clone_urls)?;
 
-            let base = update
-                .and_then(merge_base_of)
-                .or_else(|| merge_base_of(root));
+                        let workdir = repo
+                            .workdir()
+                            .ok_or_else(|| anyhow::anyhow!("repository has no worktree"))?
+                            .to_path_buf();
 
-            let clone_urls = clone_urls_of(root)
-                .or_else(|| store.announcement.as_ref().map(|a| a.clone.clone()));
+                        let tip =
+                            tip.ok_or_else(|| anyhow::anyhow!("pull request has no tip commit"))?;
 
-            (
-                root.content.clone(),
-                pull_request_patch(root, store.patches.iter()),
-                tip,
-                base,
-                clone_urls.unwrap_or_default(),
-                store.addr().clone(),
-                root.tags.event_ids().next().is_some(),
-            )
-        };
+                        let base = match base {
+                            Some(base) => base,
+                            // No `merge-base` tag. Use the merge base of the tip and the default branch.
+                            None => {
+                                let head = repo
+                                    .head_id()
+                                    .map_err(|_| anyhow::anyhow!("repository has no HEAD"))?;
+                                let tip_id = repo.rev_parse_single(tip.as_bytes())?;
+                                repo.merge_base(tip_id, head)?.to_string()
+                            }
+                        };
 
-        self.description = description.into();
+                        let diff = signed_git::worktree_commit_range_diff(&workdir, &base, &tip)?;
+                        let commits =
+                            signed_git::worktree_commit_range_commits(&workdir, &base, &tip)?;
 
-        let task: gpui::Task<Result<(), anyhow::Error>> =
-            cx.spawn_in(window, async move |this, cx| {
-                let nostr_diff = cx
-                    .background_spawn({
-                        let patch = patch.clone();
-                        async move { patch_diffs(&patch) }
+                        Ok::<_, anyhow::Error>((diff, commits, workdir))
                     })
-                    .await;
+                    .await,
+                )
+            };
 
-                let nostr_commits = cx
-                    .background_spawn({
-                        let patch = patch.clone();
-                        async move { patch_commits(&patch) }
-                    })
-                    .await;
+            let (diff, commits, worktree) = match git {
+                Some(Ok((diff, commits, worktree))) => (Ok(diff), commits, Some(worktree)),
+                Some(Err(error)) => (Err(error), Vec::new(), None),
+                None => (nostr_diff, nostr_commits, None),
+            };
 
-                // PRs without patch events, e.g. published by ngit, carry their changes in git.
-                // Fetch the clone and diff the `merge-base..tip` range.
-                let use_nostr = match &nostr_diff {
-                    Ok(diff) => has_patch_link || !diff.files.is_empty(),
-                    Err(_) => true,
-                };
+            this.update(cx, |this, cx| {
+                // A newer binding superseded this load.
+                if this.load_generation != generation {
+                    return;
+                }
 
-                let git = if use_nostr {
-                    None
-                } else {
-                    let cache = cache.clone();
-                    let addr = addr.clone();
-                    let clone_urls = clone_urls.clone();
-                    let base = merge_base.clone();
-                    let tip = current_commit.clone();
+                this.loading = false;
+                this.worktree = worktree;
+                this.commit_item_sizes = Rc::new(vec![size(px(0.), px(ROW_HEIGHT)); commits.len()]);
+                this.commits = commits;
 
-                    Some(
-                        cx.background_spawn(async move {
-                            let repo = cache.ensure_clone(&addr, &clone_urls)?;
-
-                            let workdir = repo
-                                .workdir()
-                                .ok_or_else(|| anyhow::anyhow!("repository has no worktree"))?
-                                .to_path_buf();
-
-                            let tip = tip
-                                .ok_or_else(|| anyhow::anyhow!("pull request has no tip commit"))?;
-
-                            let base = match base {
-                                Some(base) => base,
-                                // No `merge-base` tag. Use the merge base of the tip and the default branch.
-                                None => {
-                                    let head = repo
-                                        .head_id()
-                                        .map_err(|_| anyhow::anyhow!("repository has no HEAD"))?;
-                                    let tip_id = repo.rev_parse_single(tip.as_bytes())?;
-                                    repo.merge_base(tip_id, head)?.to_string()
-                                }
-                            };
-
-                            let diff =
-                                signed_git::worktree_commit_range_diff(&workdir, &base, &tip)?;
-                            let commits =
-                                signed_git::worktree_commit_range_commits(&workdir, &base, &tip)?;
-
-                            Ok::<_, anyhow::Error>((diff, commits, workdir))
-                        })
-                        .await,
-                    )
-                };
-
-                let (diff, commits, worktree) = match git {
-                    Some(Ok((diff, commits, worktree))) => (Ok(diff), commits, Some(worktree)),
-                    Some(Err(error)) => (Err(error), Vec::new(), None),
-                    None => (nostr_diff, nostr_commits, None),
-                };
-
-                this.update_in(cx, |this, _window, cx| {
-                    this.loading = false;
-                    this.worktree = worktree;
-                    this.current_commit = current_commit.map(SharedString::from);
-                    this.commit_item_sizes =
-                        Rc::new(vec![size(px(0.), px(ROW_HEIGHT)); commits.len()]);
-                    this.commits = commits;
-
-                    match diff {
-                        Ok(diff) => {
-                            this.pane.update(cx, |pane, cx| pane.set_diff(diff, cx));
-                        }
-                        Err(error) => {
-                            this.error = Some(error.to_string().into());
-                        }
+                match diff {
+                    Ok(diff) => {
+                        this.pane.update(cx, |pane, cx| pane.set_diff(diff, cx));
                     }
+                    Err(error) => {
+                        this.error = Some(error.to_string().into());
+                    }
+                }
 
-                    cx.notify();
-                })?;
+                cx.notify();
+            })?;
 
-                Ok(())
-            });
+            Ok(())
+        });
 
         task.detach();
     }
@@ -435,9 +510,6 @@ impl PullRequestDetailView {
             .into_any_element()
     }
 
-    /// Full-height Commits tab.
-    ///
-    /// Every commit of the patch series, or a status message while loading or empty.
     fn render_commits_tab(&self, cx: &mut Context<Self>) -> AnyElement {
         if self.loading {
             return v_flex()
@@ -485,9 +557,6 @@ impl PullRequestDetailView {
             .into_any_element()
     }
 
-    /// One row of the commits tab, id, summary, author and time.
-    ///
-    /// Clicking a row opens the commit's diff in the bottom dock.
     fn render_commit_row(
         &self,
         ix: usize,
@@ -540,7 +609,6 @@ impl PullRequestDetailView {
             .into_any_element()
     }
 
-    /// Always-visible header with a status badge and title, like the issue panel.
     fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
         let current_commit = self.current_commit.clone();
         let (title, status, branch, author) = {
@@ -642,7 +710,6 @@ impl PullRequestDetailView {
     }
 }
 
-/// Open the update pull request dialog.
 fn open_update_pull_request_dialog(
     store: Entity<RepoStore>,
     root: Event,
@@ -703,7 +770,6 @@ fn open_update_pull_request_dialog(
     });
 }
 
-/// The `c` tag of a PR event, the commit the proposal points at.
 /// One-line commit metadata for the commits list.
 ///
 /// Author and relative time, whichever is available.
@@ -761,26 +827,3 @@ impl Render for PullRequestDetailView {
             })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const COMMIT_HEX: &str = "1111111111111111111111111111111111111111";
-
-    #[test]
-    fn commit_meta_combines_author_and_time() {
-        let commit = |author: &str, time: i64| FileCommit {
-            id: COMMIT_HEX.into(),
-            summary: "summary".into(),
-            description: None,
-            author: author.into(),
-            time,
-        };
-
-        assert_eq!(commit_meta(&commit("Alice", 0)), "Alice");
-        assert_eq!(commit_meta(&commit("", 0)), "");
-        assert!(!commit_meta(&commit("", 1_000_000)).is_empty());
-        assert!(!commit_meta(&commit("Alice", 1_000_000)).is_empty());
-    }
-}

crates/workspace/src/views/pull_requests/mod.rs

@@ -4,8 +4,8 @@ use assets::CustomIconName;
 use dock::{BasePanel, DockArea, Panel, PanelEvent, add_center_panel, panel_handle};
 use gpui::prelude::*;
 use gpui::{
-    AnyElement, App, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render,
-    SharedString, Size, WeakEntity, Window, div, px, size,
+    AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels,
+    Render, SharedString, Size, Subscription, WeakEntity, Window, div, px, size,
 };
 use gpui_base::Button as BaseButton;
 use gpui_component::alert::Alert;
@@ -19,31 +19,26 @@ use signed_state::{ProfileStore, RepoStore};
 use signed_ui::{DropdownButton, SegmentButton, UserAvatar, placeholder, status_badge};
 use utils::relative_time;
 
-use super::RepoAction;
-use super::new_pull_request::open_new_pull_panel;
-use super::pull_request_detail::PullRequestDetailView;
+pub(super) mod detail;
+pub(super) mod new;
+
+use self::detail::PullRequestDetailView;
+use self::new::open_new_pull_panel;
 use super::send_patch::open_send_patch_panel;
+use crate::views::repo::RepoAction;
 
-/// Height of one pull request row in the virtual list.
 const ROW_HEIGHT: f32 = 73.;
 
-/// Status filter of the pull request list, chosen via the header's filter buttons.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum PullRequestFilter {
-    /// Every pull request, regardless of status.
     All,
-    /// Pull requests whose resolved status is [`RepoStatus::Open`].
     Open,
-    /// Pull requests whose resolved status is [`RepoStatus::Closed`].
     Closed,
-    /// Pull requests whose resolved status is [`RepoStatus::Draft`].
     Draft,
-    /// Pull requests whose resolved status is [`RepoStatus::Applied`].
     Merged,
 }
 
 impl PullRequestFilter {
-    /// Whether a pull request with `status` is included by this filter.
     fn matches(self, status: RepoStatus) -> bool {
         match self {
             Self::All => true,
@@ -57,37 +52,39 @@ impl PullRequestFilter {
 
 pub struct PullRequestsView {
     focus_handle: FocusHandle,
-    /// Dock area the detail panels are added to.
     dock_area: WeakEntity<DockArea>,
-    /// Repo store holding the pull requests and their statuses.
     store: Entity<RepoStore>,
-    /// Display name of the repository, for the panel title.
     repo_name: SharedString,
-    /// Filter selected in the header filter buttons.
     filter: PullRequestFilter,
-    /// Per-row heights of the virtual list.
     item_sizes: Rc<Vec<Size<Pixels>>>,
-    /// The filtered pull request count [`Self::item_sizes`] was built for.
-    pr_len: usize,
     /// Indices into the store's `pull_requests` matching [`Self::filter`].
     visible_prs: Vec<usize>,
     /// Header counts `(total, open, closed, draft, merged)`.
     counts: (usize, usize, usize, usize, usize),
-    /// Store version and filter the cached rows/counts were built from.
-    cache_key: Option<(u64, PullRequestFilter)>,
-    /// Virtual list state of the pull requests list.
+    // A filter change notifies even when the visible rows are unchanged,
+    // e.g. switching between two empty filters.
+    synced_filter: PullRequestFilter,
     scroll_handle: VirtualListScrollHandle,
+    _subscription: Subscription,
 }
 
 impl PullRequestsView {
     pub fn new(
         dock_area: WeakEntity<DockArea>,
         store: Entity<RepoStore>,
-        _window: &mut Window,
+        window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
         let repo_name = store.read(cx).name();
 
+        let subscription = cx.observe(&store, |this, _store, cx| {
+            this.rebuild(cx);
+        });
+
+        cx.defer_in(window, |this, _window, cx| {
+            this.rebuild(cx);
+        });
+
         Self {
             focus_handle: cx.focus_handle(),
             dock_area,
@@ -95,15 +92,61 @@ impl PullRequestsView {
             repo_name,
             filter: PullRequestFilter::Open,
             item_sizes: Rc::new(Vec::new()),
-            pr_len: 0,
             visible_prs: Vec::new(),
             counts: (0, 0, 0, 0, 0),
-            cache_key: None,
+            synced_filter: PullRequestFilter::Open,
             scroll_handle: VirtualListScrollHandle::new(),
+            _subscription: subscription,
         }
     }
 
-    /// Open the detail panel of `pr_id` in the dock area.
+    fn rebuild(&mut self, cx: &mut Context<Self>) {
+        let filter = self.filter;
+
+        let (visible_prs, counts) = {
+            let store = self.store.read(cx);
+            let mut counts = (0usize, 0usize, 0usize, 0usize, 0usize);
+
+            let visible_prs: Vec<usize> = store
+                .pull_requests
+                .iter()
+                .enumerate()
+                .filter_map(|(ix, pr)| {
+                    if pr.kind != Kind::GitPullRequest {
+                        return None;
+                    }
+
+                    let status = store.status_of(pr);
+                    counts.0 += 1;
+
+                    match status {
+                        RepoStatus::Open => counts.1 += 1,
+                        RepoStatus::Closed => counts.2 += 1,
+                        RepoStatus::Draft => counts.3 += 1,
+                        RepoStatus::Applied => counts.4 += 1,
+                    }
+
+                    filter.matches(status).then_some(ix)
+                })
+                .collect();
+
+            (visible_prs, counts)
+        };
+
+        let filter_changed = self.synced_filter != filter;
+
+        if !filter_changed && self.visible_prs == visible_prs && self.counts == counts {
+            return;
+        }
+
+        self.synced_filter = filter;
+        self.item_sizes = Rc::new(vec![size(px(0.), px(ROW_HEIGHT)); visible_prs.len()]);
+        self.visible_prs = visible_prs;
+        self.counts = counts;
+
+        cx.notify();
+    }
+
     fn open_pull_request_detail(
         &mut self,
         pr_id: EventId,
@@ -129,9 +172,6 @@ impl PullRequestsView {
         });
     }
 
-    /// Render one row of the pull request list.
-    ///
-    /// `ix` is the row index, `pr_ix` the index in the store's `pull_requests`.
     fn render_row(&self, ix: usize, pr_ix: usize, cx: &mut Context<Self>) -> AnyElement {
         let pr = &self.store.read(cx).pull_requests[pr_ix];
         let pr_id = pr.id;
@@ -196,7 +236,6 @@ impl PullRequestsView {
     }
 
     fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
-        // Counts of the last list rebuild.
         let (total, open, closed, draft, merged) = self.counts;
 
         h_flex()
@@ -217,7 +256,7 @@ impl PullRequestsView {
                             .selected(self.filter == PullRequestFilter::All)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = PullRequestFilter::All;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     )
                     .child(
@@ -227,7 +266,7 @@ impl PullRequestsView {
                             .selected(self.filter == PullRequestFilter::Open)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = PullRequestFilter::Open;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     )
                     .child(
@@ -237,7 +276,7 @@ impl PullRequestsView {
                             .selected(self.filter == PullRequestFilter::Closed)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = PullRequestFilter::Closed;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     )
                     .child(
@@ -247,7 +286,7 @@ impl PullRequestsView {
                             .selected(self.filter == PullRequestFilter::Draft)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = PullRequestFilter::Draft;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     )
                     .child(
@@ -257,7 +296,7 @@ impl PullRequestsView {
                             .selected(self.filter == PullRequestFilter::Merged)
                             .on_click(cx.listener(|this, _event, _window, cx| {
                                 this.filter = PullRequestFilter::Merged;
-                                cx.notify();
+                                this.rebuild(cx);
                             })),
                     ),
             )
@@ -330,55 +369,11 @@ impl Focusable for PullRequestsView {
 impl Render for PullRequestsView {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let filter = self.filter;
-
-        // Rows and counts are rebuilt only when the store refreshed or filter changed.
-        let version = self.store.read(cx).version();
-
-        if self.cache_key != Some((version, filter)) {
-            let store = self.store.read(cx);
-            let mut counts = (0usize, 0usize, 0usize, 0usize, 0usize);
-            self.visible_prs = store
-                .pull_requests
-                .iter()
-                .enumerate()
-                .filter_map(|(ix, pr)| {
-                    if pr.kind != Kind::GitPullRequest {
-                        return None;
-                    }
-
-                    let status = store.status_of(pr);
-                    counts.0 += 1;
-
-                    match status {
-                        RepoStatus::Open => counts.1 += 1,
-                        RepoStatus::Closed => counts.2 += 1,
-                        RepoStatus::Draft => counts.3 += 1,
-                        RepoStatus::Applied => counts.4 += 1,
-                    }
-
-                    filter.matches(status).then_some(ix)
-                })
-                .collect();
-
-            self.counts = counts;
-            self.cache_key = Some((version, filter));
-        }
-
         let count = self.visible_prs.len();
-
-        // The virtual list's item count comes from `item_sizes`.
-        // Rebuild it whenever the filtered pull request count changes.
-        if count != self.pr_len {
-            self.pr_len = count;
-            self.item_sizes = Rc::new(vec![size(px(0.), px(ROW_HEIGHT)); count]);
-        }
-
         let sizes = self.item_sizes.clone();
         let scroll_handle = self.scroll_handle.clone();
         let view = cx.entity().clone();
 
-        // Non-fatal warnings and errors of the last action, like creating or updating a PR.
-        // Shown as dismissible banners above the list.
         let (last_error, last_warning) = {
             let store = self.store.read(cx);
             (store.last_error.clone(), store.last_warning.clone())

crates/workspace/src/views/pull_requests/new.rs

@@ -27,26 +27,19 @@ use signed_git::{
     worktree_commit_range_commits, worktree_commit_range_diff,
 };
 use signed_state::{Backend, CheckoutsStore, GitStore, RepoListStore, RepoStore};
-use signed_ui::{CountBadge, placeholder};
+use signed_ui::{CountBadge, placeholder, ref_selector_trigger};
 
-use super::commits::{COMMIT_ROW_HEIGHT, commit_row};
-use super::diff::{CommitDiffView, DiffPane};
-use super::helpers::ref_selector_trigger;
+use crate::views::commit_diff::{COMMIT_ROW_HEIGHT, CommitDiffView, DiffPane, commit_row};
 
-/// The new pull request panel of a repository.
 pub struct NewPullRequestView {
     focus_handle: FocusHandle,
-    /// Dock area the panel lives in, commit diffs are opened there.
     dock_area: WeakEntity<DockArea>,
-    /// Store of the target repository, source of the announced HEAD default.
     store: Entity<RepoStore>,
-    /// Display name of the repository, for the panel title.
     repo_name: SharedString,
     /// The user's local checkout.
     repo_path: Option<PathBuf>,
-    /// Branches of the checkout, backing both selectors in checkout mode.
+    /// Backs both selectors in checkout mode.
     branches: Vec<SharedString>,
-    /// Fork-backed compare state.
     fork: Option<ForkCompare>,
     /// Selected base branch, the PR target, stored as a short name.
     base: SharedString,
@@ -54,33 +47,27 @@ pub struct NewPullRequestView {
     compare: SharedString,
     base_select: Entity<ComboboxState<SearchableVec<SharedString>>>,
     compare_select: Entity<ComboboxState<SearchableVec<SharedString>>>,
-    /// Title input, required.
     subject: Entity<InputState>,
-    /// Description input, optional.
     description: Entity<TextareaState>,
     /// Merge base of the selected branches, `None` until the compare loads.
     merge_base: Option<String>,
     /// Commits in `merge_base..compare`, newest first.
     commits: Option<Vec<signed_git::FileCommit>>,
-    /// The compare is being computed.
     loading: bool,
-    /// Error of the last compare or submit attempt.
     error: Option<SharedString>,
     /// A submit, patch generation and publish, is in flight.
     submitting: bool,
     /// Bumped on every branch switch, stale compare results are discarded.
     compare_generation: u64,
-    /// Active tab, 0 = Files and 1 = Commits.
+    /// 0 = Files, 1 = Commits.
     active_tab: usize,
     /// The compare diff, the Files tab body.
     pane: Entity<DiffPane>,
-    /// Virtual list state of the Commits tab.
     scroll_handle: VirtualListScrollHandle,
     item_sizes: Rc<Vec<Size<Pixels>>>,
     _subscriptions: Vec<Subscription>,
 }
 
-/// A fork-backed compare.
 struct ForkCompare {
     /// Fork announcement the compare branch is imported from.
     announcement: Announcement,
@@ -91,20 +78,15 @@ struct ForkCompare {
 }
 
 impl ForkCompare {
-    /// The full ref of the base branch `name` in the mirror.
     fn base_ref(name: &str) -> String {
         format!("refs/remotes/origin/{name}")
     }
 
-    /// The full ref of the compare branch `name` in the mirror.
     fn compare_ref(&self, name: &str) -> String {
         format!("refs/fork/{}/{}", self.namespace, name)
     }
 }
 
-/// The display name of an announcement.
-///
-/// Its human-readable name, falling back to the repository id.
 fn fork_display_name(announcement: &Announcement) -> SharedString {
     announcement
         .name
@@ -113,7 +95,6 @@ fn fork_display_name(announcement: &Announcement) -> SharedString {
         .unwrap_or_else(|| SharedString::from(announcement.id.clone()))
 }
 
-/// A short label of a fork's owner for the source picker, a hex prefix.
 fn shorten_owner(owner: &PublicKey) -> String {
     let hex = owner.to_hex();
     hex.chars().take(10).collect()
@@ -132,9 +113,6 @@ fn truncate_label(label: &str) -> SharedString {
     SharedString::from(label)
 }
 
-/// The compare-source menu entry of one local checkout folder.
-///
-/// Applies the folder directly, no picker.
 fn checkout_source_item(
     view: WeakEntity<NewPullRequestView>,
     path: PathBuf,
@@ -163,7 +141,6 @@ fn checkout_source_item(
     })
 }
 
-/// The compare-source menu entry prompting for an arbitrary folder.
 fn choose_folder_source_item(view: WeakEntity<NewPullRequestView>) -> PopupMenuItem {
     PopupMenuItem::element(move |_window, cx| {
         source_row(
@@ -180,9 +157,6 @@ fn choose_folder_source_item(view: WeakEntity<NewPullRequestView>) -> PopupMenuI
     })
 }
 
-/// The compare-source menu entry of one announced fork.
-///
-/// Imports its branches into the target's mirror and switches the panel to fork mode.
 fn fork_source_item(
     view: WeakEntity<NewPullRequestView>,
     announcement: Announcement,
@@ -208,7 +182,6 @@ fn fork_source_item(
     })
 }
 
-/// One row of the compare-source menu, icon, title and a muted subtitle.
 fn source_row<T>(icon: impl Into<Icon>, title: T, subtitle: T, cx: &App) -> AnyElement
 where
     T: Into<SharedString>,
@@ -306,7 +279,24 @@ impl NewPullRequestView {
             ),
         ];
 
-        let mut view = Self {
+        cx.defer_in(window, |this, window, cx| {
+            let Some(addr) = this.store.read(cx).addr().cloned() else {
+                return;
+            };
+
+            let Some(path) = CheckoutsStore::global(cx)
+                .read(cx)
+                .associations_of(&addr)
+                .into_iter()
+                .next()
+            else {
+                return;
+            };
+
+            this.apply_folder_path(path, window, cx);
+        });
+
+        Self {
             focus_handle: cx.focus_handle(),
             dock_area,
             store,
@@ -331,23 +321,9 @@ impl NewPullRequestView {
             scroll_handle: VirtualListScrollHandle::new(),
             item_sizes: Rc::new(Vec::new()),
             _subscriptions: subscriptions,
-        };
-
-        // Prefill with the store's freshest associated checkout, no folder dialog.
-        let addr = view.store.read(cx).addr().clone();
-        if let Some(path) = CheckoutsStore::global(cx)
-            .read(cx)
-            .associations_of(&addr)
-            .into_iter()
-            .next()
-        {
-            view.apply_folder_path(path, window, cx);
         }
-
-        view
     }
 
-    /// Whether a compare source, a checkout or a fork, is applied.
     fn has_source(&self) -> bool {
         self.repo_path.is_some() || self.fork.is_some()
     }
@@ -384,7 +360,6 @@ impl NewPullRequestView {
         }
     }
 
-    /// Prompt for a local checkout.
     fn choose_checkout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let prompt = cx.prompt_for_paths(PathPromptOptions {
             files: false,
@@ -415,9 +390,7 @@ impl NewPullRequestView {
         task.detach();
     }
 
-    /// Apply `path` as the local checkout, no picker.
-    ///
-    /// Branches and current branch are read off the UI thread, then applied.
+    /// Branches and the current branch are read off the UI thread, then applied.
     fn apply_folder_path(&mut self, path: PathBuf, window: &mut Window, cx: &mut Context<Self>) {
         let path = path.to_string_lossy().to_string();
 
@@ -446,7 +419,6 @@ impl NewPullRequestView {
         task.detach();
     }
 
-    /// Apply a picked checkout, filling the selectors and loading the compare.
     fn apply_checkout(
         &mut self,
         path: String,
@@ -497,11 +469,12 @@ impl NewPullRequestView {
 
         // Remember this folder as a checkout of the target repository.
         // The next panel pre-fills it.
-        let addr = self.store.read(cx).addr().clone();
-        let checkout_store = CheckoutsStore::global(cx);
-        checkout_store.update(cx, |store, cx| {
-            store.record(PathBuf::from(&path), addr, cx);
-        });
+        if let Some(addr) = self.store.read(cx).addr().cloned() {
+            let checkout_store = CheckoutsStore::global(cx);
+            checkout_store.update(cx, |store, cx| {
+                store.record(PathBuf::from(&path), addr, cx);
+            });
+        }
 
         let branches = self.branches.clone();
         let base = SharedString::from(base.clone());
@@ -523,20 +496,21 @@ impl NewPullRequestView {
         self.reload_compare(window, cx);
     }
 
-    /// The base repository of the panel, its address and announced EUC.
-    ///
-    /// Used to find fork candidates.
-    fn base_repo(&self, cx: &App) -> (RepoAddr, Option<String>) {
+    /// Used to find fork candidates. `None` while the repository is not announced.
+    fn base_repo(&self, cx: &App) -> Option<(RepoAddr, Option<String>)> {
         let store = self.store.read(cx);
+        let addr = store.addr()?.clone();
         let euc = store.announcement.as_ref().and_then(|a| a.euc.clone());
-        (store.addr().clone(), euc)
+        Some((addr, euc))
     }
 
     /// Announced forks of the target repository a compare can use, own first.
     ///
     /// Re-read whenever the picker opens.
     fn fork_candidates(&self, cx: &App) -> Vec<Announcement> {
-        let (base, euc) = self.base_repo(cx);
+        let Some((base, euc)) = self.base_repo(cx) else {
+            return Vec::new();
+        };
         let user = Backend::global(cx).read(cx).current_user();
         let announcements = RepoListStore::global(cx).read(cx).announcements.clone();
         fork_candidates(&announcements, &base, euc.as_deref(), user)
@@ -545,7 +519,6 @@ impl NewPullRequestView {
             .collect()
     }
 
-    /// Compare against an announced fork.
     fn choose_fork(
         &mut self,
         announcement: Announcement,
@@ -557,7 +530,9 @@ impl NewPullRequestView {
             .as_ref()
             .is_some_and(|fork| fork.announcement.addr() == announcement.addr());
 
-        let (base, _euc) = self.base_repo(cx);
+        let Some((base, _euc)) = self.base_repo(cx) else {
+            return;
+        };
         let cache = GitStore::global(cx).cache().clone();
         let mirror_path = cache.repo_path(&base);
         let namespace = fork_namespace(&announcement);
@@ -598,9 +573,6 @@ impl NewPullRequestView {
                         let clone_urls = clone_urls.clone();
                         let mirror_path = mirror_path.clone();
                         async move {
-                            // The fork and base must share history for a merge-base to exist.
-                            // The target's mirror is the object store both sides land in.
-                            // `ensure_clone` fetches `origin` when the mirror already exists.
                             cache.ensure_clone(&base, &base_clone_urls)?;
 
                             // Prune stale imports of any fork.
@@ -669,7 +641,6 @@ impl NewPullRequestView {
         task.detach();
     }
 
-    /// Apply an imported fork, filling the selectors and loading the compare.
     #[allow(clippy::too_many_arguments)]
     fn apply_fork(
         &mut self,
@@ -774,7 +745,6 @@ impl NewPullRequestView {
         self.reload_compare(window, cx);
     }
 
-    /// Recompute `merge_base..compare` of the selected branches on a background task.
     fn reload_compare(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let Some(repo_path) = self.work_path() else {
             return;
@@ -868,7 +838,6 @@ impl NewPullRequestView {
         task.detach();
     }
 
-    /// Publish the pull request.
     fn submit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if self.submitting || self.loading {
             return;
@@ -950,7 +919,6 @@ impl NewPullRequestView {
         task.detach();
     }
 
-    /// Open the diff of `commit_id`, from the Commits tab, in a new panel.
     fn open_commit_diff(&mut self, commit_id: &str, window: &mut Window, cx: &mut Context<Self>) {
         let Some(repo_path) = self.work_path() else {
             return;
@@ -1108,7 +1076,6 @@ impl NewPullRequestView {
             .into_any_element()
     }
 
-    /// The source picker's trigger, a truncated label of the applied source.
     fn source_trigger(&self) -> SharedString {
         match &self.fork {
             Some(fork) => truncate_label(&fork_display_name(&fork.announcement)),
@@ -1119,14 +1086,17 @@ impl NewPullRequestView {
         }
     }
 
-    /// Build the compare-source menu.
     fn source_menu(
         &self,
         cx: &Context<Self>,
     ) -> impl Fn(PopupMenu, &mut Window, &mut Context<PopupMenu>) -> PopupMenu + 'static {
         let view = cx.entity().downgrade();
-        let addr = self.store.read(cx).addr().clone();
-        let associated = CheckoutsStore::global(cx).read(cx).associations_of(&addr);
+        let associated = self
+            .store
+            .read(cx)
+            .addr()
+            .map(|addr| CheckoutsStore::global(cx).read(cx).associations_of(addr))
+            .unwrap_or_default();
 
         let active_path = (self.fork.is_none())
             .then(|| self.repo_path.clone())
@@ -1172,7 +1142,6 @@ impl NewPullRequestView {
         }
     }
 
-    /// The title and description inputs.
     fn render_inputs(&self, _cx: &mut Context<Self>) -> AnyElement {
         v_flex()
             .px_4()
@@ -1183,7 +1152,6 @@ impl NewPullRequestView {
             .into_any_element()
     }
 
-    /// The Files/Commits tab bar, mirroring the repository panel's.
     fn render_tabs(&self, cx: &mut Context<Self>) -> AnyElement {
         let files = self.pane.read(cx).diff().map_or(0, |diff| diff.files.len());
         let commits = self.commits.as_ref().map_or(0, |commits| commits.len());
@@ -1255,7 +1223,6 @@ impl NewPullRequestView {
             .into_any_element()
     }
 
-    /// The active tab's body.
     fn render_content(&self, cx: &mut Context<Self>) -> AnyElement {
         if self.loading {
             return v_flex()
@@ -1341,8 +1308,7 @@ impl NewPullRequestView {
     }
 }
 
-/// Open the new pull request panel in the center dock.
-pub(super) fn open_new_pull_panel(
+pub(crate) fn open_new_pull_panel(
     dock_area: WeakEntity<DockArea>,
     store: Entity<RepoStore>,
     window: &mut Window,

crates/workspace/src/views/repo/about.rs

@@ -7,7 +7,6 @@ use signed_core::Announcement;
 use signed_state::ProfileStore;
 use signed_ui::{UserAvatar, middle_truncate};
 
-/// Open the About dialog showing every field of the announcement event.
 pub(super) fn open_about_dialog(announcement: Announcement, window: &mut Window, cx: &mut App) {
     window.open_dialog(cx, move |dialog, _window, cx| {
         let announcement = announcement.clone();
@@ -21,7 +20,6 @@ pub(super) fn open_about_dialog(announcement: Announcement, window: &mut Window,
     });
 }
 
-/// The announcement's fields as labeled rows.
 fn announcement_rows(announcement: &Announcement, cx: &App) -> AnyElement {
     let mut rows: Vec<AnyElement> = Vec::new();
 
@@ -116,7 +114,6 @@ fn announcement_rows(announcement: &Announcement, cx: &App) -> AnyElement {
     v_flex().gap_3().w_full().children(rows).into_any_element()
 }
 
-/// One info row with a small muted label above the value.
 fn row(label: &'static str, value: AnyElement, cx: &App) -> AnyElement {
     v_flex()
         .gap_1()
@@ -132,7 +129,6 @@ fn row(label: &'static str, value: AnyElement, cx: &App) -> AnyElement {
         .into_any_element()
 }
 
-/// Plain text value, wrapping within the dialog.
 fn text<T>(value: T) -> AnyElement
 where
     T: Into<SharedString>,
@@ -147,7 +143,6 @@ where
         .into_any_element()
 }
 
-/// A mono-spaced value with a copy button, for hex identifiers.
 fn copy_value(id: &'static str, value: String, cx: &App) -> AnyElement {
     h_flex()
         .gap_2()
@@ -164,10 +159,6 @@ fn copy_value(id: &'static str, value: String, cx: &App) -> AnyElement {
         .into_any_element()
 }
 
-/// One row per maintainer with avatar and display name.
-/// The display name falls back to a shortened npub.
-///
-/// A copy button copies the full pubkey.
 fn maintainers(maintainers: &[PublicKey], cx: &App) -> AnyElement {
     let profile_store = ProfileStore::global(cx);
     v_flex()
@@ -197,9 +188,6 @@ fn maintainers(maintainers: &[PublicKey], cx: &App) -> AnyElement {
         .into_any_element()
 }
 
-/// One row per item of a multi-value tag.
-///
-/// The value is truncated to a single line, with a copy button for the full value.
 fn list(id: &'static str, items: impl IntoIterator<Item = String>, cx: &App) -> AnyElement {
     v_flex()
         .gap_2()

crates/workspace/src/views/repo/actions.rs

@@ -0,0 +1,78 @@
+use std::sync::Arc;
+
+use dock::{DockArea, add_center_panel, panel_handle};
+use gpui::prelude::*;
+use gpui::{App, Entity, WeakEntity, Window};
+use gpui_base::dock::PanelView;
+use nostr::prelude::EventId;
+use signed_core::{Announcement, RepoAddr};
+use signed_state::RepoStore;
+
+use super::RepoDetailView;
+use crate::views::issues::detail::IssueDetailView;
+use crate::views::pull_requests::detail::PullRequestDetailView;
+
+/// Open repository as a panel in the dock's center.
+pub(crate) fn open_repo_panel(
+    dock_area: &WeakEntity<DockArea>,
+    addr: &RepoAddr,
+    hint: Option<&Announcement>,
+    window: &mut Window,
+    cx: &mut App,
+) -> Entity<RepoDetailView> {
+    let detail = cx
+        .new(|cx| RepoDetailView::new(dock_area.clone(), addr.clone(), hint.cloned(), window, cx));
+
+    if let Some(dock_area) = dock_area.upgrade() {
+        dock_area.update(cx, |dock_area, cx| {
+            add_center_panel(dock_area, panel_handle(detail.clone()), window, cx);
+        });
+    }
+
+    detail
+}
+
+/// The nostr store of `addr`'s repository, without opening a repository panel.
+fn repo_store(addr: &RepoAddr, hint: Option<&Announcement>, cx: &mut App) -> Entity<RepoStore> {
+    cx.new(|cx| RepoStore::new(addr.clone(), hint.cloned(), cx))
+}
+
+/// An item of a repository to open from outside its detail panel.
+pub(crate) enum RepoItem {
+    Issue(EventId),
+    PullRequest(EventId),
+    Patch,
+}
+
+/// The repository store is built here.
+pub(crate) fn open_repo_item(
+    dock_area: &WeakEntity<DockArea>,
+    addr: &RepoAddr,
+    hint: Option<&Announcement>,
+    item: RepoItem,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    let panel: Arc<dyn PanelView> =
+        match item {
+            RepoItem::Issue(issue_id) => {
+                let store = repo_store(addr, hint, cx);
+                panel_handle(cx.new(|cx| IssueDetailView::new(store, issue_id, window, cx)))
+            }
+            RepoItem::PullRequest(pr_id) => {
+                let store = repo_store(addr, hint, cx);
+                panel_handle(cx.new(|cx| {
+                    PullRequestDetailView::new(dock_area.clone(), store, pr_id, window, cx)
+                }))
+            }
+            RepoItem::Patch => return,
+        };
+
+    let Some(dock_area) = dock_area.upgrade() else {
+        return;
+    };
+
+    dock_area.update(cx, |dock_area, cx| {
+        add_center_panel(dock_area, panel, window, cx);
+    });
+}

crates/workspace/src/views/repo/banners.rs

@@ -0,0 +1,46 @@
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+use signed_state::CheckoutStatus;
+
+#[derive(Default)]
+pub(super) struct Banners {
+    dismissed: HashSet<(PathBuf, String)>,
+    ready_requested: bool,
+    /// Re-requested only when the announced HEAD or the base default changes.
+    ready_head: Option<String>,
+    ready_statuses: Vec<CheckoutStatus>,
+    push_statuses: Vec<CheckoutStatus>,
+}
+
+impl Banners {
+    pub(super) fn dismissal(&self, status: &CheckoutStatus) -> bool {
+        self.dismissed
+            .contains(&(status.path.clone(), status.branch.clone()))
+    }
+
+    pub(super) fn dismiss(&mut self, status: &CheckoutStatus) {
+        self.dismissed
+            .insert((status.path.clone(), status.branch.clone()));
+    }
+
+    pub(super) fn ready_requested_at(&self) -> (bool, &Option<String>) {
+        (self.ready_requested, &self.ready_head)
+    }
+
+    pub(super) fn mark_ready_requested(&mut self, head: Option<String>) {
+        self.ready_requested = true;
+        self.ready_head = head;
+    }
+
+    pub(super) fn set_statuses(
+        &mut self,
+        ready: Vec<CheckoutStatus>,
+        push: Vec<CheckoutStatus>,
+    ) -> bool {
+        let changed = ready != self.ready_statuses || push != self.push_statuses;
+        self.ready_statuses = ready;
+        self.push_statuses = push;
+        changed
+    }
+}

crates/workspace/src/views/repo/files.rs

@@ -0,0 +1,737 @@
+use std::collections::{HashMap, HashSet, VecDeque};
+use std::path::{Component, Path, PathBuf};
+
+use anyhow::Error;
+use gpui::prelude::*;
+use gpui::{AnyElement, Context, Entity, Render, SharedString, Task, WeakEntity, Window, div, px};
+use gpui_component::button::{Button, ButtonVariants};
+use gpui_component::input::{Editor, EditorState};
+use gpui_component::list::ListItem;
+use gpui_component::spinner::Spinner;
+use gpui_component::text::{TextView, TextViewState};
+use gpui_component::tree::{TreeEntry, TreeState, tree};
+use gpui_component::{ActiveTheme, Sizable, StyledExt, h_flex, v_flex};
+use signed_git::{FileCommit, WorktreeSnapshot};
+use signed_ui::{placeholder, tree_row};
+
+use crate::views::tree::{TreeItemSeed, tree_items};
+
+const TREE_WIDTH: f32 = 240.;
+const MAX_PREVIEW_BYTES: usize = 1024 * 1024;
+const MAX_PREVIEWED_FILES: usize = 32;
+const MAX_PREVIEW_CACHE_BYTES: usize = 8 * 1024 * 1024;
+
+enum FileContent {
+    Text(String),
+    Binary,
+    TooLarge,
+    Failed(String),
+}
+
+struct MarkdownView {
+    /// `None` means the repository README.
+    path: Option<SharedString>,
+    state: Entity<TextViewState>,
+    /// Hash of the source, so the same document is not re-parsed on a refresh.
+    source_hash: u64,
+}
+
+struct CodeView {
+    /// Source path, relative to the worktree root.
+    path: SharedString,
+    state: Entity<EditorState>,
+    /// Hash of the source, so the same document is not re-parsed on a refresh.
+    source_hash: u64,
+}
+
+pub(super) struct RepoFilesView {
+    tree_state: Entity<TreeState>,
+    worktree: Option<PathBuf>,
+    worktree_paths: Vec<String>,
+    md: Option<MarkdownView>,
+    code: Option<CodeView>,
+    readme_name: Option<SharedString>,
+    selected_file: Option<SharedString>,
+    files: HashMap<String, FileContent>,
+    file_order: VecDeque<String>,
+    preview_bytes: usize,
+    loading_files: HashSet<String>,
+    commits: HashMap<String, FileCommit>,
+    pending_commits: Vec<String>,
+    loading_commits: bool,
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+impl RepoFilesView {
+    pub(super) fn new(cx: &mut Context<Self>) -> Self {
+        Self {
+            tree_state: cx.new(|cx| TreeState::new(cx)),
+            worktree: None,
+            worktree_paths: Vec::new(),
+            md: None,
+            code: None,
+            readme_name: None,
+            selected_file: None,
+            files: HashMap::new(),
+            file_order: VecDeque::new(),
+            preview_bytes: 0,
+            loading_files: HashSet::new(),
+            commits: HashMap::new(),
+            pending_commits: Vec::new(),
+            loading_commits: false,
+            tasks: Vec::new(),
+        }
+    }
+
+    pub(super) fn set_worktree(&mut self, path: PathBuf) {
+        self.worktree = Some(path);
+    }
+
+    pub(super) fn apply_entries(
+        &mut self,
+        tree: Vec<TreeItemSeed>,
+        paths: Vec<String>,
+        cx: &mut Context<Self>,
+    ) {
+        self.worktree_paths = paths;
+        self.tree_state.update(cx, |state, cx| {
+            state.set_items(tree_items(tree, false), cx);
+        });
+    }
+
+    /// Point the README pane at `path`/`bytes`, or clear it when absent.
+    ///
+    /// Returns whether the pane changed.
+    pub(super) fn set_readme(
+        &mut self,
+        path: Option<PathBuf>,
+        bytes: Option<Vec<u8>>,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        let Some((path, bytes)) = path.zip(bytes) else {
+            let changed = self.readme_name.is_some() || self.md.is_some();
+            self.readme_name = None;
+            self.md = None;
+            return changed;
+        };
+
+        let name: SharedString = path.to_string_lossy().into();
+        let mut changed = self.readme_name.as_ref() != Some(&name);
+        self.readme_name = Some(name);
+        self.load_commit(&path.to_string_lossy(), cx);
+
+        if let Ok(text) = String::from_utf8(bytes) {
+            changed |= self.set_markdown(None, &text, cx);
+        }
+
+        changed
+    }
+
+    /// Drop every cached preview and the README, e.g. on a branch switch.
+    pub(super) fn clear_previews(&mut self) {
+        self.selected_file = None;
+        self.files.clear();
+        self.file_order.clear();
+        self.preview_bytes = 0;
+        self.loading_files.clear();
+        self.commits.clear();
+        self.pending_commits.clear();
+        self.loading_commits = false;
+        self.md = None;
+        self.code = None;
+        self.readme_name = None;
+    }
+
+    /// Refresh after the mirror caught up with the remote.
+    ///
+    /// Unlike a branch switch this keeps the selection and previews: it rebuilds
+    /// the tree, drops previews of files the refresh removed and re-renders the
+    /// README when it is on screen.
+    ///
+    /// Returns whether the tree, a preview or the README changed.
+    pub(super) fn catch_up(
+        &mut self,
+        snapshot: &WorktreeSnapshot,
+        tree: Vec<TreeItemSeed>,
+        paths: Vec<String>,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        let mut changed = false;
+
+        if paths != self.worktree_paths {
+            self.apply_entries(tree, paths, cx);
+            changed = true;
+        }
+
+        let present: HashSet<String> = snapshot
+            .entries
+            .iter()
+            .map(|path| path.to_string_lossy().into_owned())
+            .collect();
+
+        let mut previewed: Vec<String> = Vec::new();
+
+        previewed.extend(self.files.keys().cloned());
+        previewed.extend(self.selected_file.clone().map(|path| path.to_string()));
+
+        if let Some(path) = self.md.as_ref().and_then(|md| md.path.clone()) {
+            previewed.push(path.to_string());
+        }
+
+        if let Some(path) = self.code.as_ref().map(|code| code.path.clone()) {
+            previewed.push(path.to_string());
+        }
+
+        previewed.sort();
+        previewed.dedup();
+
+        for path in previewed {
+            if !present.contains(&path) {
+                self.drop_preview_of(&path);
+                changed = true;
+            }
+        }
+
+        if self.selected_file.is_none() {
+            changed |= self.set_readme(snapshot.readme_path.clone(), snapshot.readme.clone(), cx);
+        }
+
+        changed
+    }
+
+    fn pane_title(&self) -> SharedString {
+        self.selected_file
+            .clone()
+            .or_else(|| self.readme_name.clone())
+            .unwrap_or_else(|| "Overview".into())
+    }
+
+    fn render_tree_item(
+        ix: usize,
+        entry: &TreeEntry,
+        selected: bool,
+        view: &WeakEntity<Self>,
+    ) -> ListItem {
+        let view = view.clone();
+        let id = entry.item().id.clone();
+
+        tree_row(ix, entry, selected, move |window, cx| {
+            if let Some(view) = view.upgrade() {
+                view.update(cx, |this, cx| this.open_file(&id, window, cx));
+            }
+        })
+    }
+
+    fn render_tree_column(
+        tree_state: Entity<TreeState>,
+        view: WeakEntity<Self>,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        v_flex()
+            .h_full()
+            .w(px(TREE_WIDTH))
+            .p_2()
+            .flex_none()
+            .border_r_1()
+            .border_color(cx.theme().border)
+            .child(div().flex_1().min_h_0().child(tree(
+                &tree_state,
+                move |ix, entry, selected, _window, _cx| {
+                    Self::render_tree_item(ix, entry, selected, &view)
+                },
+            )))
+    }
+
+    fn render_content_column(
+        &self,
+        pane_title: SharedString,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let body: AnyElement = if let Some(path) = self.selected_file.clone() {
+            match self.files.get(path.as_ref()) {
+                Some(FileContent::Text(_)) => {
+                    if is_markdown_path(path.as_ref()) {
+                        self.markdown_element(Some(path.as_ref()), cx)
+                    } else {
+                        self.code_element(path.as_ref(), cx)
+                    }
+                }
+                Some(FileContent::Binary) => placeholder("Binary file - preview not supported", cx),
+                Some(FileContent::TooLarge) => placeholder("File is too large to preview", cx),
+                Some(FileContent::Failed(message)) => placeholder(message, cx),
+                None => preview_spinner(),
+            }
+        } else if self.readme_name.is_some() {
+            self.markdown_element(None, cx)
+        } else {
+            placeholder("No README found", cx)
+        };
+
+        // Latest commit for the current pane, the selected file or the README.
+        let commit = match &self.selected_file {
+            Some(path) => self.commits.get(path.as_ref()),
+            None => self
+                .readme_name
+                .as_ref()
+                .and_then(|name| self.commits.get(name.as_ref())),
+        };
+
+        v_flex()
+            .flex_1()
+            .min_w_0()
+            .h_full()
+            .child(
+                h_flex()
+                    .px_3()
+                    .h_9()
+                    .gap_2()
+                    .bg(cx.theme().muted)
+                    .border_b(px(1.))
+                    .border_color(cx.theme().border)
+                    .text_color(cx.theme().muted_foreground)
+                    .child(
+                        div()
+                            .text_xs()
+                            .font_semibold()
+                            .text_ellipsis()
+                            .whitespace_nowrap()
+                            .child(pane_title),
+                    )
+                    .when_some(commit, |this, commit| {
+                        this.child(
+                            h_flex()
+                                .flex_1()
+                                .gap_1()
+                                .child(
+                                    Button::new("commit")
+                                        .xsmall()
+                                        .text()
+                                        .label(commit.id.clone()),
+                                )
+                                .child(
+                                    div()
+                                        .max_w(px(250.))
+                                        .text_xs()
+                                        .text_ellipsis()
+                                        .whitespace_nowrap()
+                                        .child(commit.summary.clone()),
+                                ),
+                        )
+                    }),
+            )
+            .child(div().id("repo-content").flex_1().min_h_0().child(body))
+    }
+
+    fn set_markdown(
+        &mut self,
+        path: Option<SharedString>,
+        text: &str,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        let hash = source_hash(text);
+
+        if let Some(md) = &self.md
+            && md.path == path
+            && md.source_hash == hash
+        {
+            return false;
+        }
+
+        let state = cx.new(|cx| TextViewState::markdown("", cx));
+        state.update(cx, |state, cx| state.push_str(text, cx));
+
+        self.md = Some(MarkdownView {
+            path,
+            state,
+            source_hash: hash,
+        });
+
+        true
+    }
+
+    fn markdown_element(&self, path: Option<&str>, _cx: &mut Context<Self>) -> AnyElement {
+        let Some(md) = &self.md else {
+            return preview_spinner();
+        };
+
+        let ready = match path {
+            Some(path) => md.path.as_deref() == Some(path),
+            None => md.path.is_none(),
+        };
+
+        if !ready {
+            return preview_spinner();
+        }
+
+        TextView::new(&md.state)
+            .selectable(true)
+            .scrollable(true)
+            .p_4()
+            .text_sm()
+            .into_any_element()
+    }
+
+    fn set_code(
+        &mut self,
+        path: SharedString,
+        text: &str,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let hash = source_hash(text);
+
+        if let Some(code) = &self.code
+            && code.path == path
+            && code.source_hash == hash
+        {
+            return;
+        }
+
+        let language = code_language(path.as_ref()).unwrap_or("text");
+        let state = cx.new(|cx| {
+            EditorState::new(window, cx)
+                .language(language)
+                .default_value(text)
+                .line_number(true)
+                .folding(true)
+        });
+
+        self.code = Some(CodeView {
+            path,
+            state,
+            source_hash: hash,
+        });
+    }
+
+    fn code_element(&self, path: &str, _cx: &mut Context<Self>) -> AnyElement {
+        let Some(code) = &self.code else {
+            return preview_spinner();
+        };
+        if code.path.as_ref() != path {
+            return preview_spinner();
+        }
+
+        Editor::new(&code.state)
+            .readonly(true)
+            .bordered(false)
+            .rounded_none()
+            .h_full()
+            .text_sm()
+            .into_any_element()
+    }
+
+    fn open_file(&mut self, path: &str, window: &mut Window, cx: &mut Context<Self>) {
+        self.selected_file = Some(path.into());
+
+        if self.files.contains_key(path) {
+            if let Some(FileContent::Text(text)) = self.files.get(path) {
+                let text = text.clone();
+                if is_markdown_path(path) {
+                    if self.md.as_ref().map(|md| md.path.as_deref()) != Some(Some(path)) {
+                        self.set_markdown(Some(path.into()), &text, cx);
+                    }
+                } else if self.code.as_ref().map(|code| code.path.as_str()) != Some(path) {
+                    self.set_code(path.into(), &text, window, cx);
+                }
+            }
+            cx.notify();
+            return;
+        }
+        if self.loading_files.contains(path) {
+            cx.notify();
+            return;
+        }
+
+        let rel = Path::new(path);
+        let unsafe_path = rel.is_absolute()
+            || rel.components().any(|c| {
+                matches!(
+                    c,
+                    Component::ParentDir | Component::RootDir | Component::Prefix(_)
+                )
+            });
+
+        let Some(worktree) = self.worktree.clone() else {
+            return;
+        };
+
+        if unsafe_path {
+            return;
+        }
+
+        self.loading_files.insert(path.to_string());
+        let path = path.to_string();
+
+        self.load_commit(&path, cx);
+
+        let task: Task<Result<(), Error>> = cx.spawn_in(window, async move |this, cx| {
+            let path_for_read = path.clone();
+            let content = cx
+                .background_spawn(async move {
+                    let full = worktree.join(&path_for_read);
+
+                    let metadata = match std::fs::metadata(&full) {
+                        Ok(metadata) => metadata,
+                        Err(error) => return Err(anyhow::anyhow!("{}", error)),
+                    };
+
+                    if metadata.len() > MAX_PREVIEW_BYTES as u64 {
+                        return Ok(FileContent::TooLarge);
+                    }
+
+                    let bytes = match std::fs::read(&full) {
+                        Ok(bytes) => bytes,
+                        Err(error) => return Err(anyhow::anyhow!("{}", error)),
+                    };
+
+                    match String::from_utf8(bytes) {
+                        Ok(text) => Ok(FileContent::Text(text)),
+                        Err(_) => Ok(FileContent::Binary),
+                    }
+                })
+                .await;
+
+            this.update_in(cx, |this, window, cx| {
+                this.loading_files.remove(&path);
+
+                match content {
+                    Ok(kind) => {
+                        if let FileContent::Text(text) = &kind {
+                            if is_markdown_path(&path) {
+                                let same = this.md.as_ref().map(|md| md.path.as_deref())
+                                    == Some(Some(path.as_str()));
+                                if !same {
+                                    this.set_markdown(Some(path.clone().into()), text, cx);
+                                }
+                            } else {
+                                let same = this.code.as_ref().map(|code| code.path.as_str())
+                                    == Some(path.as_str());
+                                if !same {
+                                    this.set_code(path.clone().into(), text, window, cx);
+                                }
+                            }
+                            this.preview_bytes += text.len();
+                        }
+                        this.files.insert(path.clone(), kind);
+                        this.file_order.push_back(path);
+                        this.evict_previews();
+                    }
+                    Err(error) => {
+                        this.files
+                            .insert(path, FileContent::Failed(error.to_string()));
+                    }
+                }
+                cx.notify();
+            })?;
+
+            Ok(())
+        });
+
+        self.tasks.push(task);
+    }
+
+    fn drop_preview_of(&mut self, path: &str) {
+        if let Some(FileContent::Text(text)) = self.files.remove(path) {
+            self.preview_bytes -= text.len();
+        }
+
+        self.commits.remove(path);
+
+        if self.selected_file.as_deref() == Some(path) {
+            self.selected_file = None;
+        }
+
+        if self.md.as_ref().and_then(|md| md.path.as_deref()) == Some(path) {
+            self.md = None;
+        }
+
+        if self.code.as_ref().map(|code| code.path.as_ref()) == Some(path) {
+            self.code = None;
+        }
+    }
+
+    fn evict_previews(&mut self) {
+        while (self.files.len() > MAX_PREVIEWED_FILES
+            || self.preview_bytes > MAX_PREVIEW_CACHE_BYTES)
+            && self.file_order.len() > 1
+        {
+            let path = self.file_order.pop_front().expect("non-empty");
+
+            if Some(path.as_str()) == self.selected_file.as_deref() {
+                self.file_order.push_back(path);
+                continue;
+            }
+
+            if let Some(FileContent::Text(text)) = self.files.remove(&path) {
+                self.preview_bytes -= text.len();
+            }
+
+            if self.md.as_ref().map(|md| md.path.as_deref()) == Some(Some(path.as_str())) {
+                self.md = None;
+            }
+
+            if self
+                .code
+                .as_ref()
+                .is_some_and(|code| code.path.as_ref() == path.as_str())
+            {
+                self.code = None;
+            }
+
+            self.commits.remove(&path);
+        }
+    }
+
+    fn load_commit(&mut self, path: &str, cx: &mut Context<Self>) {
+        if self.commits.contains_key(path) || self.pending_commits.iter().any(|p| p == path) {
+            return;
+        }
+
+        self.pending_commits.push(path.to_string());
+
+        if !self.loading_commits {
+            self.load_commits(cx);
+        }
+    }
+
+    fn load_commits(&mut self, cx: &mut Context<Self>) {
+        if self.pending_commits.is_empty() || self.loading_commits {
+            return;
+        }
+
+        let Some(worktree) = self.worktree.clone() else {
+            self.pending_commits.clear();
+            return;
+        };
+
+        self.loading_commits = true;
+
+        let paths = std::mem::take(&mut self.pending_commits);
+
+        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+            let rels: Vec<PathBuf> = paths.iter().map(PathBuf::from).collect();
+            let result = cx
+                .background_spawn(
+                    async move { signed_git::worktree_last_commits(&worktree, &rels) },
+                )
+                .await;
+
+            this.update(cx, |this, cx| {
+                this.loading_commits = false;
+
+                if let Ok(found) = result {
+                    for (path, commit) in found {
+                        this.commits
+                            .insert(path.to_string_lossy().into_owned(), commit);
+                    }
+                }
+
+                if !this.pending_commits.is_empty() {
+                    this.load_commits(cx);
+                }
+
+                cx.notify();
+            })?;
+
+            Ok(())
+        });
+
+        self.tasks.push(task);
+    }
+}
+
+impl Render for RepoFilesView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let tree_state = self.tree_state.clone();
+        let view = cx.entity().downgrade();
+        let pane_title = self.pane_title();
+
+        h_flex()
+            .flex_1()
+            .w_full()
+            .overflow_hidden()
+            .child(Self::render_tree_column(tree_state, view, cx))
+            .child(self.render_content_column(pane_title, cx))
+    }
+}
+
+fn source_hash(text: &str) -> u64 {
+    use std::hash::{Hash, Hasher};
+
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    text.hash(&mut hasher);
+    hasher.finish()
+}
+
+fn preview_spinner() -> AnyElement {
+    v_flex()
+        .size_full()
+        .items_center()
+        .justify_center()
+        .child(Spinner::new().small())
+        .into_any_element()
+}
+
+/// The markdown fence language for a file path, or `None` for plain text.
+fn code_language(path: &str) -> Option<&'static str> {
+    let name = Path::new(path)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or_default();
+
+    // Some common files are recognized by name rather than extension.
+    match name {
+        "Makefile" | "makefile" => return Some("make"),
+        "CMakeLists.txt" => return Some("cmake"),
+        _ => {}
+    }
+
+    let ext = Path::new(path).extension()?.to_str()?.to_ascii_lowercase();
+    Some(match ext.as_str() {
+        "rs" => "rust",
+        "toml" => "toml",
+        "json" | "jsonc" => "json",
+        "py" => "python",
+        "js" | "mjs" | "cjs" => "javascript",
+        "ts" | "mts" | "cts" => "typescript",
+        "tsx" | "jsx" => "tsx",
+        "go" => "go",
+        "c" | "h" => "c",
+        "cc" | "cpp" | "cxx" | "hh" | "hpp" | "hxx" => "cpp",
+        "cs" => "csharp",
+        "java" => "java",
+        "kt" | "kts" | "ktm" => "kotlin",
+        "swift" => "swift",
+        "php" | "phtml" => "php",
+        "rb" => "ruby",
+        "sh" | "bash" | "zsh" => "bash",
+        "yml" | "yaml" => "yaml",
+        "css" | "scss" | "sass" => "css",
+        "html" | "htm" => "html",
+        "lua" => "lua",
+        "sql" => "sql",
+        "proto" | "protobuf" => "proto",
+        "cmake" => "cmake",
+        "zig" => "zig",
+        "ex" | "exs" => "elixir",
+        "graphql" | "gql" => "graphql",
+        "diff" | "patch" => "diff",
+        "svelte" => "svelte",
+        "astro" => "astro",
+        "scala" => "scala",
+        _ => return None,
+    })
+}
+
+/// Whether a file path has a markdown extension.
+fn is_markdown_path(path: &str) -> bool {
+    Path::new(path)
+        .extension()
+        .and_then(|ext| ext.to_str())
+        .is_some_and(|ext| {
+            matches!(
+                ext.to_ascii_lowercase().as_str(),
+                "md" | "markdown" | "mdown" | "mkdn"
+            )
+        })
+}

crates/workspace/src/views/repo/history.rs

@@ -0,0 +1,201 @@
+use std::path::PathBuf;
+use std::rc::Rc;
+
+use anyhow::Error;
+use dock::{DockArea, add_center_panel, panel_handle};
+use gpui::prelude::*;
+use gpui::{Context, Entity, Pixels, Render, Size, Task, WeakEntity, Window, div, px, size};
+use gpui_component::scroll::Scrollbar;
+use gpui_component::spinner::Spinner;
+use gpui_component::{ActiveTheme, Sizable, VirtualListScrollHandle, v_flex, v_virtual_list};
+use signed_git::CommitList;
+use signed_state::RepoStore;
+use signed_ui::placeholder;
+
+use super::repo_display_name;
+use crate::views::commit_diff::{COMMIT_ROW_HEIGHT, CommitDiffView, commit_row};
+
+pub(super) struct RepoHistoryView {
+    store: Entity<RepoStore>,
+    dock_area: WeakEntity<DockArea>,
+    worktree: Option<PathBuf>,
+    all_commits: Option<CommitList>,
+    loading_all_commits: bool,
+    scroll_handle: VirtualListScrollHandle,
+    item_sizes: Rc<Vec<Size<Pixels>>>,
+    tasks: Vec<Task<Result<(), Error>>>,
+}
+
+impl RepoHistoryView {
+    pub(super) fn new(store: Entity<RepoStore>, dock_area: WeakEntity<DockArea>) -> Self {
+        Self {
+            store,
+            dock_area,
+            worktree: None,
+            all_commits: None,
+            loading_all_commits: false,
+            scroll_handle: VirtualListScrollHandle::new(),
+            item_sizes: Rc::new(Vec::new()),
+            tasks: Vec::new(),
+        }
+    }
+
+    pub(super) fn set_worktree(&mut self, path: Option<PathBuf>) {
+        self.worktree = path;
+    }
+
+    /// Number of commits reachable from HEAD, for the Commits tab badge.
+    pub(super) fn commit_count(&self) -> Option<usize> {
+        self.all_commits.as_ref().map(|list| list.total)
+    }
+
+    /// Drop the current list and walk HEAD again.
+    pub(super) fn reload(&mut self, cx: &mut Context<Self>) {
+        self.all_commits = None;
+        self.loading_all_commits = false;
+        self.load(cx);
+    }
+
+    fn load(&mut self, cx: &mut Context<Self>) {
+        if self.loading_all_commits || self.all_commits.is_some() {
+            return;
+        }
+
+        let Some(worktree) = self.worktree.clone() else {
+            return;
+        };
+
+        self.loading_all_commits = true;
+
+        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+            let result = cx
+                .background_spawn(async move { signed_git::worktree_all_commits(&worktree) })
+                .await;
+
+            this.update(cx, |this, cx| {
+                if let Ok(list) = result {
+                    let count = list.commits.len();
+                    this.item_sizes = Rc::new(vec![size(px(0.), px(COMMIT_ROW_HEIGHT)); count]);
+                    this.all_commits = Some(list);
+                }
+
+                this.loading_all_commits = false;
+                cx.notify();
+            })?;
+
+            Ok(())
+        });
+
+        self.tasks.push(task);
+    }
+
+    pub(super) fn open_commit_diff(
+        &mut self,
+        commit_id: &str,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(worktree) = self.worktree.clone() else {
+            return;
+        };
+
+        let Some(dock_area) = self.dock_area.upgrade() else {
+            return;
+        };
+
+        // Same display name as the repo detail panel's title.
+        let repo_name = repo_display_name(self.store.read(cx));
+
+        let panel =
+            cx.new(|cx| CommitDiffView::new(worktree, repo_name, commit_id.into(), window, cx));
+
+        dock_area.update(cx, |dock_area, cx| {
+            add_center_panel(dock_area, panel_handle(panel), window, cx);
+        });
+    }
+}
+
+impl Render for RepoHistoryView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let Some(list) = self.all_commits.as_ref() else {
+            return if self.loading_all_commits {
+                v_flex()
+                    .size_full()
+                    .items_center()
+                    .justify_center()
+                    .child(Spinner::new().small())
+                    .into_any_element()
+            } else {
+                placeholder("Failed to load commits", cx)
+            };
+        };
+
+        if list.commits.is_empty() {
+            return placeholder("No commits found", cx);
+        }
+
+        let view = cx.entity().clone();
+        let sizes = self.item_sizes.clone();
+        let scroll_handle = self.scroll_handle.clone();
+        let shown = list.commits.len();
+        let total = list.total;
+
+        v_flex()
+            .relative()
+            .flex_1()
+            .w_full()
+            .min_h_0()
+            .child(
+                v_virtual_list(view, "commits", sizes, move |this, range, _window, cx| {
+                    let view = cx.entity().downgrade();
+                    let commits = this
+                        .all_commits
+                        .as_ref()
+                        .map(|list| list.commits.as_slice())
+                        .unwrap_or(&[]);
+
+                    range
+                        .map(|ix| {
+                            let id = commits[ix].id.clone();
+                            let view = view.clone();
+
+                            commit_row(
+                                ix,
+                                &commits[ix],
+                                move |window, cx| {
+                                    if let Some(view) = view.upgrade() {
+                                        view.update(cx, |this, cx| {
+                                            this.open_commit_diff(&id, window, cx)
+                                        });
+                                    }
+                                },
+                                cx,
+                            )
+                        })
+                        .collect()
+                })
+                .track_scroll(&scroll_handle)
+                .size_full(),
+            )
+            .when(shown < total, |this| {
+                this.child(
+                    div()
+                        .py_2()
+                        .w_full()
+                        .text_xs()
+                        .text_color(cx.theme().muted_foreground)
+                        .child(format!("Showing {shown} of {total} commits")),
+                )
+            })
+            .child(
+                div()
+                    .absolute()
+                    .top_0()
+                    .left_0()
+                    .right_0()
+                    .bottom_0()
+                    .child(Scrollbar::vertical(&self.scroll_handle)),
+            )
+            .into_any_element()
+    }
+}

crates/workspace/src/views/repo/init_dialog.rs

@@ -19,10 +19,8 @@ use crate::views::sidebar::grasp_servers::{
     GraspServersState, grasp_servers_field, load_user_grasp_servers,
 };
 
-/// Shared state for the Init dialog, so async results can be rendered.
 pub type InitRepoState = DialogProgress;
 
-/// Open the Init dialog for the local repository at `local_path`.
 pub fn open(
     local_path: PathBuf,
     view: WeakEntity<RepoDetailView>,
@@ -51,7 +49,6 @@ pub fn open(
             .placeholder("Short description")
     });
 
-    // Load the user's grasp servers.
     load_user_grasp_servers(grasp_state.clone(), window, cx);
 
     window.open_dialog(cx, move |dialog, _window, _cx| {
@@ -146,9 +143,6 @@ pub fn open(
     });
 }
 
-/// Run the init flow.
-///
-/// Closes the dialog and switches the repository into NIP-34 mode on success.
 fn init_repository(
     local_path: PathBuf,
     inputs: (Entity<InputState>, Entity<TextareaState>),

crates/workspace/src/views/repo/refs.rs

@@ -0,0 +1,115 @@
+use gpui::prelude::*;
+use gpui::{App, Entity, SharedString, Window};
+use gpui_component::combobox::ComboboxState;
+use gpui_component::searchable_list::SearchableVec;
+
+pub(super) struct RefSwitcher {
+    pub(super) branch_select: Entity<ComboboxState<SearchableVec<SharedString>>>,
+    pub(super) tag_select: Entity<ComboboxState<SearchableVec<SharedString>>>,
+    ref_branches: Vec<SharedString>,
+    ref_tags: Vec<SharedString>,
+    pub(super) switching_ref: bool,
+}
+
+impl RefSwitcher {
+    pub(super) fn new(window: &mut Window, cx: &mut App) -> Self {
+        let branch_select = cx.new(|cx| {
+            ComboboxState::new(
+                SearchableVec::new(Vec::<SharedString>::new()),
+                Vec::new(),
+                window,
+                cx,
+            )
+            .searchable(true)
+        });
+        let tag_select = cx.new(|cx| {
+            ComboboxState::new(
+                SearchableVec::new(Vec::<SharedString>::new()),
+                Vec::new(),
+                window,
+                cx,
+            )
+            .searchable(true)
+        });
+
+        Self {
+            branch_select,
+            tag_select,
+            ref_branches: Vec::new(),
+            ref_tags: Vec::new(),
+            switching_ref: false,
+        }
+    }
+
+    pub(super) fn set_branches(
+        &mut self,
+        branches: Vec<SharedString>,
+        selected: Option<SharedString>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> bool {
+        sync_selector(
+            &self.branch_select,
+            &mut self.ref_branches,
+            branches,
+            selected,
+            window,
+            cx,
+        )
+    }
+
+    pub(super) fn set_tags(
+        &mut self,
+        tags: Vec<SharedString>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> bool {
+        sync_selector(&self.tag_select, &mut self.ref_tags, tags, None, window, cx)
+    }
+
+    pub(super) fn restore_selection(
+        &self,
+        select: &Entity<ComboboxState<SearchableVec<SharedString>>>,
+        previous: &Option<SharedString>,
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        select.update(cx, |state, cx| match previous {
+            Some(value) => state.set_selected_values(std::slice::from_ref(value), window, cx),
+            None => state.clear_selection(cx),
+        });
+    }
+}
+
+fn sync_selector(
+    select: &Entity<ComboboxState<SearchableVec<SharedString>>>,
+    cached: &mut Vec<SharedString>,
+    items: Vec<SharedString>,
+    selected: Option<SharedString>,
+    window: &mut Window,
+    cx: &mut App,
+) -> bool {
+    let items_changed = *cached != items;
+
+    let selection_changed = selected
+        .as_ref()
+        .is_some_and(|value| select.read(cx).selected_value().as_ref() != Some(value));
+
+    if !items_changed && !selection_changed {
+        return false;
+    }
+
+    select.update(cx, |state, cx| {
+        if items_changed {
+            state.set_items(SearchableVec::from(items.clone()), window, cx);
+        }
+        if let Some(value) = selected
+            && (items_changed || selection_changed)
+        {
+            state.set_selected_values(std::slice::from_ref(&value), window, cx);
+        }
+    });
+    *cached = items;
+
+    true
+}

crates/workspace/src/views/repo_detail/browser.rs

@@ -1,288 +0,0 @@
-use gpui::prelude::*;
-use gpui::{AnyElement, Context, Entity, SharedString, WeakEntity, Window, div, px};
-use gpui_component::button::{Button, ButtonVariants};
-use gpui_component::input::{Editor, EditorState};
-use gpui_component::list::ListItem;
-use gpui_component::spinner::Spinner;
-use gpui_component::text::{TextView, TextViewState};
-use gpui_component::tree::{TreeEntry, TreeState, tree};
-use gpui_component::{ActiveTheme, Sizable, StyledExt, h_flex, v_flex};
-use signed_ui::{placeholder, tree_row};
-
-use super::RepoDetailView;
-use super::helpers::{code_language, is_markdown_path};
-
-/// Width of the file explorer column.
-const TREE_WIDTH: f32 = 240.;
-/// Files larger than this are not previewed.
-pub(super) const MAX_PREVIEW_BYTES: usize = 1024 * 1024;
-/// Preview cache caps, a file count and a text byte count.
-///
-/// The oldest previews are evicted beyond the caps.
-pub(super) const MAX_PREVIEWED_FILES: usize = 32;
-pub(super) const MAX_PREVIEW_CACHE_BYTES: usize = 8 * 1024 * 1024;
-
-/// Preview state of a browsed file.
-pub(super) enum FileContent {
-    /// Decodable text content.
-    Text(String),
-    /// Not valid UTF-8.
-    Binary,
-    /// Bigger than [`MAX_PREVIEW_BYTES`].
-    TooLarge,
-    /// Reading failed.
-    Failed(String),
-}
-
-/// A markdown document loaded into a persistent [`TextViewState`].
-pub(super) struct MarkdownView {
-    /// Source path, `None` means the repository README.
-    pub(super) path: Option<SharedString>,
-    pub(super) state: Entity<TextViewState>,
-}
-
-/// A code file loaded into a persistent [`InputState`].
-pub(super) struct CodeView {
-    /// Source path, relative to the worktree root.
-    pub(super) path: SharedString,
-    pub(super) state: Entity<EditorState>,
-}
-
-/// Spinner shown while a document is being loaded/parsed.
-fn preview_spinner() -> AnyElement {
-    v_flex()
-        .size_full()
-        .items_center()
-        .justify_center()
-        .child(Spinner::new().small())
-        .into_any_element()
-}
-
-impl RepoDetailView {
-    /// One row of the file tree with icon and name, indented by depth.
-    fn render_tree_item(
-        ix: usize,
-        entry: &TreeEntry,
-        selected: bool,
-        view: &WeakEntity<Self>,
-    ) -> ListItem {
-        let view = view.clone();
-        let id = entry.item().id.clone();
-
-        tree_row(ix, entry, selected, move |window, cx| {
-            if let Some(view) = view.upgrade() {
-                view.update(cx, |this, cx| this.open_file(&id, window, cx));
-            }
-        })
-    }
-
-    /// Left column showing the file tree.
-    pub(super) fn render_tree_column(
-        tree_state: Entity<TreeState>,
-        view: WeakEntity<Self>,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        v_flex()
-            .h_full()
-            .w(px(TREE_WIDTH))
-            .p_2()
-            .flex_none()
-            .border_r_1()
-            .border_color(cx.theme().border)
-            .child(div().flex_1().min_h_0().child(tree(
-                &tree_state,
-                move |ix, entry, selected, _window, _cx| {
-                    Self::render_tree_item(ix, entry, selected, &view)
-                },
-            )))
-    }
-
-    /// Right column, README, selected file preview or status text.
-    pub(super) fn render_content_column(
-        &self,
-        pane_title: SharedString,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        let loading = self.loading;
-        let error = self.error.clone();
-        let selected_file = self.selected_file.clone();
-
-        let body: AnyElement = if loading {
-            v_flex()
-                .size_full()
-                .items_center()
-                .justify_center()
-                .gap_2()
-                .child(Spinner::new().small())
-                .child(
-                    div()
-                        .text_sm()
-                        .text_color(cx.theme().muted_foreground)
-                        .child("Cloning repository..."),
-                )
-                .into_any_element()
-        } else if let Some(error) = error {
-            v_flex()
-                .size_full()
-                .items_center()
-                .justify_center()
-                .p_4()
-                .child(
-                    div()
-                        .text_sm()
-                        .text_color(cx.theme().muted_foreground)
-                        .child(error),
-                )
-                .into_any_element()
-        } else if let Some(path) = selected_file {
-            match self.files.get(path.as_ref()) {
-                Some(FileContent::Text(_)) => {
-                    if is_markdown_path(path.as_ref()) {
-                        self.markdown_element(Some(path.as_ref()), cx)
-                    } else {
-                        self.code_element(path.as_ref(), cx)
-                    }
-                }
-                Some(FileContent::Binary) => placeholder("Binary file - preview not supported", cx),
-                Some(FileContent::TooLarge) => placeholder("File is too large to preview", cx),
-                Some(FileContent::Failed(message)) => placeholder(message, cx),
-                None => preview_spinner(),
-            }
-        } else if self.readme_name.is_some() {
-            self.markdown_element(None, cx)
-        } else {
-            placeholder("No README found", cx)
-        };
-
-        // Latest commit for the current pane, the selected file or the README.
-        // Computed after the body above, which needs `&mut self`.
-        let commit = match &self.selected_file {
-            Some(path) => self.commits.get(path.as_ref()),
-            None => self
-                .readme_name
-                .as_ref()
-                .and_then(|name| self.commits.get(name.as_ref())),
-        };
-
-        v_flex()
-            .flex_1()
-            .min_w_0()
-            .h_full()
-            .child(
-                h_flex()
-                    .px_3()
-                    .h_9()
-                    .gap_2()
-                    .bg(cx.theme().muted)
-                    .border_b(px(1.))
-                    .border_color(cx.theme().border)
-                    .text_color(cx.theme().muted_foreground)
-                    .child(
-                        div()
-                            .text_xs()
-                            .font_semibold()
-                            .text_ellipsis()
-                            .whitespace_nowrap()
-                            .child(pane_title),
-                    )
-                    .when_some(commit, |this, commit| {
-                        this.child(
-                            h_flex()
-                                .flex_1()
-                                .gap_1()
-                                .child(
-                                    Button::new("commit")
-                                        .xsmall()
-                                        .text()
-                                        .label(commit.id.clone()),
-                                )
-                                .child(
-                                    div()
-                                        .max_w(px(250.))
-                                        .text_xs()
-                                        .text_ellipsis()
-                                        .whitespace_nowrap()
-                                        .child(commit.summary.clone()),
-                                ),
-                        )
-                    }),
-            )
-            .child(div().id("repo-content").flex_1().min_h_0().child(body))
-    }
-
-    /// Load `text` into the persistent markdown TextView state.
-    pub(super) fn set_markdown(
-        &mut self,
-        path: Option<SharedString>,
-        text: &str,
-        cx: &mut Context<Self>,
-    ) {
-        let state = cx.new(|cx| TextViewState::markdown("", cx));
-        state.update(cx, |state, cx| state.push_str(text, cx));
-        self.md = Some(MarkdownView { path, state });
-    }
-
-    /// The persistent markdown TextView for `path`, where `None` is the README.
-    ///
-    /// Shows a spinner while the document is being loaded or parsed.
-    fn markdown_element(&self, path: Option<&str>, _cx: &mut Context<Self>) -> AnyElement {
-        let Some(md) = &self.md else {
-            return preview_spinner();
-        };
-
-        let ready = match path {
-            Some(path) => md.path.as_deref() == Some(path),
-            None => md.path.is_none(),
-        };
-
-        if !ready {
-            return preview_spinner();
-        }
-
-        TextView::new(&md.state)
-            .selectable(true)
-            .scrollable(true)
-            .p_4()
-            .text_sm()
-            .into_any_element()
-    }
-
-    /// Load `text` into the persistent code editor state for `path`.
-    ///
-    /// Code editor mode makes the Input render it read-only and highlighted.
-    pub(super) fn set_code(
-        &mut self,
-        path: SharedString,
-        text: &str,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let language = code_language(path.as_ref()).unwrap_or("text");
-        let state = cx.new(|cx| {
-            EditorState::new(window, cx)
-                .language(language)
-                .default_value(text)
-                .line_number(true)
-                .folding(true)
-        });
-        self.code = Some(CodeView { path, state });
-    }
-
-    /// The persistent code editor for `path`, or a spinner while the file loads or parses.
-    fn code_element(&self, path: &str, _cx: &mut Context<Self>) -> AnyElement {
-        let Some(code) = &self.code else {
-            return preview_spinner();
-        };
-        if code.path.as_ref() != path {
-            return preview_spinner();
-        }
-
-        Editor::new(&code.state)
-            .readonly(true)
-            .bordered(false)
-            .rounded_none()
-            .h_full()
-            .text_sm()
-            .into_any_element()
-    }
-}

crates/workspace/src/views/repo_detail/commits.rs

@@ -1,160 +0,0 @@
-use gpui::prelude::*;
-use gpui::{AnyElement, App, Context, Window, div, px};
-use gpui_component::scroll::Scrollbar;
-use gpui_component::spinner::Spinner;
-use gpui_component::{ActiveTheme, Sizable, h_flex, v_flex, v_virtual_list};
-use signed_git::FileCommit;
-use signed_ui::placeholder;
-use utils::relative_time_secs;
-
-use super::RepoDetailView;
-
-/// Height of one commit row in the virtual list.
-pub(super) const COMMIT_ROW_HEIGHT: f32 = 56.;
-
-pub(super) fn commit_row(
-    ix: usize,
-    commit: &FileCommit,
-    on_click: impl Fn(&mut Window, &mut App) + 'static,
-    cx: &App,
-) -> AnyElement {
-    h_flex()
-        .id(ix)
-        .px_4()
-        .h(px(COMMIT_ROW_HEIGHT))
-        .w_full()
-        .gap_3()
-        .items_center()
-        .border_b(px(1.))
-        .border_color(cx.theme().border)
-        .hover(|this| this.bg(cx.theme().list_hover))
-        .child(
-            v_flex()
-                .flex_1()
-                .min_w_0()
-                .gap_0p5()
-                .justify_center()
-                .child(
-                    h_flex()
-                        .gap_2()
-                        .items_center()
-                        .overflow_hidden()
-                        .child(
-                            div()
-                                .font_family(cx.theme().mono_font_family.clone())
-                                .text_xs()
-                                .text_color(cx.theme().muted_foreground)
-                                .child(commit.id.clone()),
-                        )
-                        .child(
-                            div()
-                                .flex_1()
-                                .min_w_0()
-                                .text_sm()
-                                .text_ellipsis()
-                                .whitespace_nowrap()
-                                .child(commit.summary.clone()),
-                        ),
-                )
-                .child(
-                    h_flex()
-                        .gap_2()
-                        .text_xs()
-                        .text_color(cx.theme().muted_foreground)
-                        .child(commit.author.clone())
-                        .child(relative_time_secs(commit.time)),
-                ),
-        )
-        .on_click(move |_event, window, cx| on_click(window, cx))
-        .into_any_element()
-}
-
-impl RepoDetailView {
-    pub(super) fn render_commits_tab(&self, cx: &mut Context<Self>) -> AnyElement {
-        let Some(list) = self.all_commits.as_ref() else {
-            return if self.loading_all_commits {
-                v_flex()
-                    .size_full()
-                    .items_center()
-                    .justify_center()
-                    .child(Spinner::new().small())
-                    .into_any_element()
-            } else {
-                placeholder("Failed to load commits", cx)
-            };
-        };
-
-        if list.commits.is_empty() {
-            return placeholder("No commits found", cx);
-        }
-
-        // Copy only the values the element tree needs.
-        // The list is borrowed by the renderer below instead of cloned per frame.
-        // A full history can be tens of thousands of commits.
-        let view = cx.entity().clone();
-        let sizes = self.item_sizes.clone();
-        let scroll_handle = self.scroll_handle.clone();
-        let shown = list.commits.len();
-        let total = list.total;
-
-        v_flex()
-            .relative()
-            .flex_1()
-            .w_full()
-            .min_h_0()
-            .child(
-                v_virtual_list(view, "commits", sizes, move |this, range, _window, cx| {
-                    let view = cx.entity().downgrade();
-                    let commits = this
-                        .all_commits
-                        .as_ref()
-                        .map(|list| list.commits.as_slice())
-                        .unwrap_or(&[]);
-
-                    range
-                        .map(|ix| {
-                            let id = commits[ix].id.clone();
-                            let view = view.clone();
-
-                            commit_row(
-                                ix,
-                                &commits[ix],
-                                move |window, cx| {
-                                    if let Some(view) = view.upgrade() {
-                                        view.update(cx, |this, cx| {
-                                            this.open_commit_diff(&id, window, cx)
-                                        });
-                                    }
-                                },
-                                cx,
-                            )
-                        })
-                        .collect()
-                })
-                .track_scroll(&scroll_handle)
-                .size_full(),
-            )
-            .when(shown < total, |this| {
-                // The history is capped.
-                // Tell the user the list is truncated.
-                this.child(
-                    div()
-                        .py_2()
-                        .w_full()
-                        .text_xs()
-                        .text_color(cx.theme().muted_foreground)
-                        .child(format!("Showing {shown} of {total} commits")),
-                )
-            })
-            .child(
-                div()
-                    .absolute()
-                    .top_0()
-                    .left_0()
-                    .right_0()
-                    .bottom_0()
-                    .child(Scrollbar::vertical(&self.scroll_handle)),
-            )
-            .into_any_element()
-    }
-}

crates/workspace/src/views/repo_detail/helpers.rs

@@ -1,714 +0,0 @@
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-
-use assets::CustomIconName;
-use gpui::prelude::*;
-use gpui::{AnyElement, App, Entity, SharedString, div, px};
-use gpui_component::button::{Button, ButtonVariants};
-use gpui_component::combobox::{Caret, ComboboxTriggerContext};
-use gpui_component::input::{Textarea, TextareaState};
-use gpui_component::menu::PopupMenu;
-use gpui_component::searchable_list::SearchableVec;
-use gpui_component::tag::Tag;
-use gpui_component::tree::TreeItem;
-use gpui_component::{ActiveTheme, Icon, Sizable, StyledExt, h_flex, v_flex};
-use nostr::nips::nip19::{Nip19Coordinate, ToBech32};
-use nostr::prelude::{Event, EventId, PublicKey};
-use signed_core::Announcement;
-use signed_git::{DiffHunk, DiffLine, DiffLineKind, FileDiff};
-use signed_state::{ProfileStore, RepoStore};
-use signed_ui::{UserAvatar, menu_copy_row, middle_truncate};
-use utils::relative_time;
-
-pub(super) struct TreeItemSeed {
-    /// Path of the node, relative to the worktree root.
-    id: String,
-    /// File or directory name.
-    label: String,
-    children: Vec<TreeItemSeed>,
-}
-
-pub(super) fn tree_items(seeds: Vec<TreeItemSeed>, expand_folders: bool) -> Vec<TreeItem> {
-    fn convert(seed: TreeItemSeed, expand_folders: bool) -> TreeItem {
-        let mut item = TreeItem::new(seed.id, seed.label);
-        if expand_folders && !seed.children.is_empty() {
-            item = item.expanded(true);
-        }
-        item.children = seed
-            .children
-            .into_iter()
-            .map(|seed| convert(seed, expand_folders))
-            .collect();
-        item
-    }
-
-    seeds
-        .into_iter()
-        .map(|seed| convert(seed, expand_folders))
-        .collect()
-}
-
-/// Build nested tree items from a flat entry list sorted dirs-first.
-pub(super) fn build_tree_items(entries: &[PathBuf]) -> Vec<TreeItemSeed> {
-    // Node indices by full path, so parents resolve in constant time while inserting.
-    let mut index: HashMap<String, usize> = HashMap::new();
-    let mut nodes: Vec<(String, String, Vec<usize>)> = Vec::new();
-    let mut roots: Vec<usize> = Vec::new();
-
-    for entry in entries {
-        let mut parent: Option<usize> = None;
-        let mut path = String::new();
-        for part in entry.components() {
-            let label = part.as_os_str().to_string_lossy().into_owned();
-            path = if path.is_empty() {
-                label.clone()
-            } else {
-                format!("{path}/{label}")
-            };
-            let ix = *index.entry(path.clone()).or_insert_with(|| {
-                let ix = nodes.len();
-                nodes.push((path.clone(), label.clone(), Vec::new()));
-                match parent {
-                    Some(parent) => nodes[parent].2.push(ix),
-                    None => roots.push(ix),
-                }
-                ix
-            });
-            parent = Some(ix);
-        }
-    }
-
-    fn assemble(ix: usize, nodes: &[(String, String, Vec<usize>)]) -> TreeItemSeed {
-        let (id, label, children) = &nodes[ix];
-        TreeItemSeed {
-            id: id.clone(),
-            label: label.clone(),
-            children: children
-                .iter()
-                .map(|child| assemble(*child, nodes))
-                .collect(),
-        }
-    }
-
-    roots.iter().map(|root| assemble(*root, &nodes)).collect()
-}
-
-/// The markdown fence language for a file path, or `None` for plain text.
-pub(super) fn code_language(path: &str) -> Option<&'static str> {
-    let name = Path::new(path)
-        .file_name()
-        .and_then(|name| name.to_str())
-        .unwrap_or_default();
-
-    // Some common files are recognized by name rather than extension.
-    match name {
-        "Makefile" | "makefile" => return Some("make"),
-        "CMakeLists.txt" => return Some("cmake"),
-        _ => {}
-    }
-
-    let ext = Path::new(path).extension()?.to_str()?.to_ascii_lowercase();
-    Some(match ext.as_str() {
-        "rs" => "rust",
-        "toml" => "toml",
-        "json" | "jsonc" => "json",
-        "py" => "python",
-        "js" | "mjs" | "cjs" => "javascript",
-        "ts" | "mts" | "cts" => "typescript",
-        "tsx" | "jsx" => "tsx",
-        "go" => "go",
-        "c" | "h" => "c",
-        "cc" | "cpp" | "cxx" | "hh" | "hpp" | "hxx" => "cpp",
-        "cs" => "csharp",
-        "java" => "java",
-        "kt" | "kts" | "ktm" => "kotlin",
-        "swift" => "swift",
-        "php" | "phtml" => "php",
-        "rb" => "ruby",
-        "sh" | "bash" | "zsh" => "bash",
-        "yml" | "yaml" => "yaml",
-        "css" | "scss" | "sass" => "css",
-        "html" | "htm" => "html",
-        "lua" => "lua",
-        "sql" => "sql",
-        "proto" | "protobuf" => "proto",
-        "cmake" => "cmake",
-        "zig" => "zig",
-        "ex" | "exs" => "elixir",
-        "graphql" | "gql" => "graphql",
-        "diff" | "patch" => "diff",
-        "svelte" => "svelte",
-        "astro" => "astro",
-        "scala" => "scala",
-        _ => return None,
-    })
-}
-
-/// Whether a file path has a markdown extension.
-pub(super) fn is_markdown_path(path: &str) -> bool {
-    Path::new(path)
-        .extension()
-        .and_then(|ext| ext.to_str())
-        .is_some_and(|ext| {
-            matches!(
-                ext.to_ascii_lowercase().as_str(),
-                "md" | "markdown" | "mdown" | "mkdn"
-            )
-        })
-}
-
-pub(super) struct ShareTargets {
-    /// NIP-19 `naddr1...` of the announcement, with its announced relays.
-    pub(super) naddr: String,
-    /// Hex ID of the announcement event itself.
-    pub(super) event_id: String,
-    /// NIP-34 coordinate `30617:<pubkey>:<repo-id>`.
-    pub(super) coordinate: String,
-    /// `https://gitworkshop.dev/<naddr>`
-    pub(super) gitworkshop: String,
-    /// `https://ditto.pub/<naddr>`
-    pub(super) ditto: String,
-}
-
-impl ShareTargets {
-    pub(super) fn from_announcement(announcement: &Announcement) -> Self {
-        let addr = announcement.addr();
-        let coordinate = addr.to_string();
-        let naddr = Nip19Coordinate::new(addr, announcement.relays.iter().cloned())
-            .to_bech32()
-            .expect("a complete coordinate always encodes to naddr");
-
-        Self {
-            naddr: naddr.clone(),
-            event_id: announcement.event_id.to_bech32().unwrap(),
-            coordinate,
-            gitworkshop: format!("https://gitworkshop.dev/{naddr}"),
-            ditto: format!("https://ditto.pub/{naddr}"),
-        }
-    }
-
-    /// The share dropdown menu, one row per target.
-    ///
-    /// Each shows a compact label, the copy button and row click copy the full value.
-    pub(super) fn menu(&self, menu: PopupMenu) -> PopupMenu {
-        menu.min_w(px(340.))
-            .item(menu_copy_row(
-                "copy-gitworkshop",
-                "GitWorkshop",
-                truncate_naddr_link(&self.gitworkshop, 4),
-                self.gitworkshop.clone(),
-            ))
-            .item(menu_copy_row(
-                "copy-ditto",
-                "Ditto",
-                truncate_naddr_link(&self.ditto, 4),
-                self.ditto.clone(),
-            ))
-            .item(menu_copy_row(
-                "copy-event-id",
-                "Event ID",
-                middle_truncate(&self.event_id, 10, 10),
-                self.event_id.clone(),
-            ))
-            .item(menu_copy_row(
-                "copy-coordinate",
-                "Coordinate",
-                middle_truncate(&self.coordinate, 10, 10),
-                self.coordinate.clone(),
-            ))
-    }
-}
-
-/// Shorten an naddr link to `<url>/naddr1...[last tail chars]`.
-fn truncate_naddr_link(url: &str, tail: usize) -> String {
-    let Some(end) = url.find("naddr1").map(|i| i + "naddr1".len()) else {
-        return url.to_string();
-    };
-    if url.len() - end <= tail + 3 {
-        return url.to_string();
-    }
-    format!("{}...{}", &url[..end], &url[url.len() - tail..])
-}
-
-/// Width of one line-number gutter in a diff row.
-pub(super) const GUTTER_WIDTH: f32 = 44.;
-/// Height of one row in a virtual diff list.
-pub(super) const DIFF_ROW_HEIGHT: f32 = 20.;
-
-/// One row of a virtual diff list, a hunk header or a line of a hunk.
-///
-/// Shared by the commit diff and pull request diff viewers.
-#[derive(Clone, Copy)]
-pub(super) enum DiffRow {
-    Hunk {
-        old_start: u32,
-        old_lines: u32,
-        new_start: u32,
-        new_lines: u32,
-    },
-    /// Line `line` of hunk `hunk` of the selected file's diff.
-    Line { hunk: usize, line: usize },
-}
-
-/// The rows of `file`'s diff, one header row per hunk then its lines.
-pub(super) fn diff_rows(file: &FileDiff) -> Vec<DiffRow> {
-    let mut rows = Vec::new();
-    for (hunk_ix, hunk) in file.hunks.iter().enumerate() {
-        rows.push(DiffRow::Hunk {
-            old_start: hunk.old_start,
-            old_lines: hunk.old_lines,
-            new_start: hunk.new_start,
-            new_lines: hunk.new_lines,
-        });
-        rows.extend((0..hunk.lines.len()).map(|line| DiffRow::Line {
-            hunk: hunk_ix,
-            line,
-        }));
-    }
-    rows
-}
-
-/// One row of the virtual diff list, a hunk header or a single line.
-pub(super) fn render_diff_row(hunks: &[DiffHunk], row: DiffRow, cx: &App) -> AnyElement {
-    match row {
-        DiffRow::Hunk {
-            old_start,
-            old_lines,
-            new_start,
-            new_lines,
-        } => div()
-            .px_2()
-            .w_full()
-            .h(px(DIFF_ROW_HEIGHT))
-            .font_family(cx.theme().mono_font_family.clone())
-            .text_xs()
-            .bg(cx.theme().muted)
-            .border_y(px(1.))
-            .border_color(cx.theme().border)
-            .text_color(cx.theme().muted_foreground)
-            .child(SharedString::from(format!(
-                "@@ -{},{} +{},{} @@",
-                old_start, old_lines, new_start, new_lines
-            )))
-            .into_any_element(),
-        DiffRow::Line { hunk, line } => render_diff_line(&hunks[hunk].lines[line], cx),
-    }
-}
-
-/// One diff line, old and new line numbers in the gutters.
-///
-/// The content is tinted by kind, addition, deletion or context.
-pub(super) fn render_diff_line(line: &DiffLine, cx: &App) -> AnyElement {
-    let bg = match line.kind {
-        DiffLineKind::Addition => Some(cx.theme().success.opacity(0.2)),
-        DiffLineKind::Deletion => Some(cx.theme().danger.opacity(0.2)),
-        DiffLineKind::Context => None,
-    };
-    let gutter = cx.theme().muted_foreground;
-
-    // Fixed height and nowrap, the virtual list assumes every row has the same height.
-    // Long lines are clipped instead of wrapped.
-    h_flex()
-        .w_full()
-        .h(px(DIFF_ROW_HEIGHT))
-        .items_center()
-        .font_family(cx.theme().mono_font_family.clone())
-        .text_xs()
-        .when_some(bg, |this, bg| this.bg(bg))
-        .child(
-            div()
-                .w(px(GUTTER_WIDTH))
-                .flex_none()
-                .pr_2()
-                .text_right()
-                .text_color(gutter)
-                .child(line.old.map(|n| n.to_string()).unwrap_or_default()),
-        )
-        .child(
-            div()
-                .w(px(GUTTER_WIDTH))
-                .flex_none()
-                .pr_2()
-                .text_right()
-                .text_color(gutter)
-                .child(line.new.map(|n| n.to_string()).unwrap_or_default()),
-        )
-        .child(
-            div()
-                .flex_1()
-                .min_w_0()
-                .overflow_hidden()
-                .whitespace_nowrap()
-                .text_color(cx.theme().foreground)
-                .child(line.text.clone()),
-        )
-        .into_any_element()
-}
-
-/// Find a tree item by id, searching into nested children.
-pub(super) fn find_item<'a>(items: &'a [TreeItem], id: Option<&str>) -> Option<&'a TreeItem> {
-    let id = id?;
-    items.iter().find_map(|item| {
-        if item.id.as_ref() == id {
-            Some(item)
-        } else {
-            find_item(&item.children, Some(id))
-        }
-    })
-}
-
-/// The root issue events of a repo store, for the shared detail sections.
-pub(super) fn issue_roots(store: &RepoStore) -> &[Event] {
-    &store.issues
-}
-
-/// The root pull request events of a repo store, for the shared detail sections.
-pub(super) fn pr_roots(store: &RepoStore) -> &[Event] {
-    &store.pull_requests
-}
-
-/// The trigger body of the branch/tag selectors.
-///
-/// The kind icon, the selection or placeholder, and the caret.
-/// `Combobox` replaces its default trigger entirely,
-/// the only way to show an icon inside it.
-pub(super) fn ref_selector_trigger(
-    ctx: &ComboboxTriggerContext<SearchableVec<SharedString>>,
-    icon: CustomIconName,
-    cx: &App,
-) -> AnyElement {
-    let muted = cx.theme().muted_foreground;
-
-    h_flex()
-        .w_full()
-        .min_w_0()
-        .gap_1()
-        .items_center()
-        .child(Icon::new(icon).small().flex_shrink_0())
-        .child(
-            div()
-                .flex_1()
-                .min_w_0()
-                .overflow_hidden()
-                .text_ellipsis()
-                .whitespace_nowrap()
-                .when(ctx.selection().is_empty(), |this| this.text_color(muted))
-                .child(
-                    ctx.selection()
-                        .first()
-                        .map(|(_, item)| item.clone())
-                        .or_else(|| ctx.placeholder().cloned())
-                        .unwrap_or_default(),
-                ),
-        )
-        .child(Caret::new(ctx.size()).text_color(muted))
-        .into_any_element()
-}
-
-/// Section heading of a detail sidebar, shared by the issue and PR panels.
-pub(super) fn sidebar_title(text: &str, cx: &App) -> AnyElement {
-    div()
-        .text_xs()
-        .font_semibold()
-        .text_color(cx.theme().muted_foreground)
-        .child(text.to_string())
-        .into_any_element()
-}
-
-/// Right sidebar with participants and labels of a root event, issue or PR.
-pub(super) fn sidebar_section(
-    store: &Entity<RepoStore>,
-    id: EventId,
-    roots: fn(&RepoStore) -> &[Event],
-    top_gap: bool,
-    cx: &App,
-) -> AnyElement {
-    let store = store.read(cx);
-    let Some(root) = roots(store).iter().find(|event| event.id == id) else {
-        // The caller bails out when the root is missing.
-        return div().into_any_element();
-    };
-    let profile_store = ProfileStore::global(cx);
-
-    // Participants, the root author plus everyone who commented.
-    let mut participants: Vec<PublicKey> = vec![root.pubkey];
-    participants.extend(store.comments_of(&root.id).map(|comment| comment.pubkey));
-    participants.sort_by_key(PublicKey::to_hex);
-    participants.dedup();
-
-    // Labels are NIP-34 `t` hashtag tags on the event.
-    let labels: Vec<String> = root.tags.hashtags().map(|tag| tag.to_string()).collect();
-
-    v_flex()
-        .w(px(240.))
-        .h_full()
-        .flex_none()
-        .px_4()
-        .gap_4()
-        .border_l(px(1.))
-        .border_color(cx.theme().sidebar_border)
-        .child(
-            v_flex()
-                .when(top_gap, |this| this.mt_4())
-                .gap_2()
-                .child(sidebar_title("Participants", cx))
-                .children(participants.iter().map(|pubkey| {
-                    let profile = profile_store.read(cx).get(pubkey);
-                    let name = profile.name();
-                    let picture = profile.picture();
-
-                    h_flex()
-                        .gap_1()
-                        .items_center()
-                        .child(UserAvatar::new(name.clone()).picture(picture))
-                        .child(div().text_sm().truncate().text_ellipsis().child(name))
-                        .into_any_element()
-                })),
-        )
-        .child(
-            v_flex()
-                .gap_2()
-                .child(sidebar_title("Labels", cx))
-                .map(|this| {
-                    if labels.is_empty() {
-                        this.child(
-                            div()
-                                .text_sm()
-                                .text_color(cx.theme().muted_foreground)
-                                .child("None yet."),
-                        )
-                    } else {
-                        this.child(h_flex().gap_1().children({
-                            let mut items = vec![];
-
-                            for label in labels.iter() {
-                                items.push(
-                                    Tag::secondary()
-                                        .outline()
-                                        .xsmall()
-                                        .child(SharedString::from(label)),
-                                );
-                            }
-
-                            items
-                        }))
-                    }
-                }),
-        )
-        .into_any_element()
-}
-
-/// The comments on a root event, issue or PR, one card per comment.
-pub(super) fn comments_section(store: &Entity<RepoStore>, root: EventId, cx: &App) -> AnyElement {
-    let store = store.read(cx);
-    let comments: Vec<&Event> = store.comments_of(&root).collect();
-    let title = SharedString::from(format!("Discussions {}", comments.len()));
-
-    v_flex()
-        .gap_4()
-        .child(div().text_xs().font_semibold().child(title))
-        .children(comments.iter().map(|comment| {
-            let profile = ProfileStore::global(cx).read(cx).get(&comment.pubkey);
-            let author = profile.name();
-            let picture = profile.picture();
-            let age = relative_time(comment.created_at);
-            let content = SharedString::from(comment.content.as_str());
-
-            v_flex()
-                .gap_1()
-                .p_3()
-                .border_1()
-                .border_color(cx.theme().border)
-                .rounded(cx.theme().radius)
-                .child(
-                    h_flex()
-                        .gap_2()
-                        .text_sm()
-                        .child(
-                            h_flex()
-                                .gap_1()
-                                .child(UserAvatar::new(author.clone()).picture(picture))
-                                .child(author),
-                        )
-                        .child(
-                            div()
-                                .text_color(cx.theme().muted_foreground)
-                                .child("commented"),
-                        )
-                        .child(
-                            div()
-                                .text_color(cx.theme().muted_foreground)
-                                .child(SharedString::from(age)),
-                        ),
-                )
-                .child(div().text_sm().child(content))
-        }))
-        .into_any_element()
-}
-
-/// The comment form posting to an issue or PR root event.
-///
-/// `roots` selects the root's list within the store, issues or pull requests.
-pub(super) fn comment_form(
-    store: &Entity<RepoStore>,
-    root: EventId,
-    roots: fn(&RepoStore) -> &[Event],
-    comment_input: &Entity<TextareaState>,
-    button_id: &'static str,
-    cx: &App,
-) -> AnyElement {
-    let comment_input = comment_input.clone();
-    let store = store.clone();
-
-    v_flex()
-        .gap_2()
-        .child(
-            Textarea::new(&comment_input)
-                .h_24()
-                .text_color(cx.theme().muted_foreground)
-                .bg(cx.theme().muted),
-        )
-        .child(
-            h_flex()
-                .justify_between()
-                .child(
-                    h_flex()
-                        .gap_1()
-                        .text_xs()
-                        .text_color(cx.theme().muted_foreground)
-                        .child(Icon::new(CustomIconName::Markdown).small())
-                        .child("Markdown is supported"),
-                )
-                .child(
-                    Button::new(button_id)
-                        .primary()
-                        .label("Comment")
-                        .tooltip("Post comment")
-                        .on_click(move |_event, window, cx| {
-                            let content = comment_input.read(cx).value().trim().to_string();
-                            if content.is_empty() {
-                                return;
-                            }
-                            let Some(root) = roots(store.read(cx))
-                                .iter()
-                                .find(|event| event.id == root)
-                                .cloned()
-                            else {
-                                return;
-                            };
-                            store.update(cx, |store, cx| {
-                                store.comment(&root, content, cx);
-                            });
-                            comment_input.update(cx, |input, cx| {
-                                input.set_value("", window, cx);
-                            });
-                        }),
-                ),
-        )
-        .into_any_element()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn builds_nested_tree_from_flat_entries() {
-        let entries = vec![
-            PathBuf::from("src"),
-            PathBuf::from("src/lib.rs"),
-            PathBuf::from("README.md"),
-            PathBuf::from("docs/guide.md"),
-        ];
-
-        let items = build_tree_items(&entries);
-
-        // Input order is preserved, dirs-first as produced by worktree_entries.
-        assert_eq!(items.len(), 3);
-        assert_eq!(items[0].label, "src");
-        assert_eq!(items[0].id, "src");
-        assert_eq!(items[0].children.len(), 1);
-        assert_eq!(items[0].children[0].label, "lib.rs");
-        assert_eq!(items[0].children[0].id, "src/lib.rs");
-
-        assert_eq!(items[1].label, "README.md");
-        assert_eq!(items[1].id, "README.md");
-
-        assert_eq!(items[2].label, "docs");
-        assert_eq!(items[2].children[0].label, "guide.md");
-        assert_eq!(items[2].children[0].id, "docs/guide.md");
-    }
-
-    #[test]
-    fn tree_builder_handles_deep_nesting() {
-        let entries = vec![
-            PathBuf::from("a"),
-            PathBuf::from("a/b"),
-            PathBuf::from("a/b/c.txt"),
-        ];
-
-        let items = build_tree_items(&entries);
-        assert_eq!(items.len(), 1);
-        assert_eq!(items[0].children[0].id, "a/b");
-        assert_eq!(items[0].children[0].children[0].id, "a/b/c.txt");
-    }
-
-    #[test]
-    fn tree_builder_merges_shared_prefixes() {
-        // File children of a directory arrive after other directories' entries.
-        // The worktree list is dirs-first globally.
-        // The shared prefix must still resolve to one node.
-        let entries = vec![
-            PathBuf::from("a/x.txt"),
-            PathBuf::from("b/y.txt"),
-            PathBuf::from("a/z.txt"),
-        ];
-
-        let items = build_tree_items(&entries);
-        assert_eq!(items.len(), 2);
-        assert_eq!(items[0].label, "a");
-        assert_eq!(items[0].children.len(), 2);
-        assert_eq!(items[1].label, "b");
-    }
-
-    #[test]
-    fn tree_seeds_convert_to_tree_items() {
-        let entries = vec![
-            PathBuf::from("src"),
-            PathBuf::from("src/main.rs"),
-            PathBuf::from("README.md"),
-        ];
-
-        let items: Vec<TreeItem> = tree_items(build_tree_items(&entries), false);
-        assert_eq!(items.len(), 2);
-        assert_eq!(items[0].label, "src");
-        assert_eq!(items[0].children.len(), 1);
-        assert_eq!(items[0].children[0].label, "main.rs");
-    }
-
-    #[test]
-    fn code_language_maps_extensions_and_names() {
-        assert_eq!(code_language("src/main.rs"), Some("rust"));
-        assert_eq!(code_language("Cargo.toml"), Some("toml"));
-        assert_eq!(code_language("app.js"), Some("javascript"));
-        assert_eq!(code_language("index.tsx"), Some("tsx"));
-        assert_eq!(code_language("Makefile"), Some("make"));
-        assert_eq!(code_language("CMakeLists.txt"), Some("cmake"));
-        assert_eq!(code_language("data.csv"), None);
-        assert_eq!(code_language("LICENSE"), None);
-        assert_eq!(code_language("README.md"), None);
-    }
-
-    #[test]
-    fn naddr_link_keeps_url_and_tail() {
-        assert_eq!(
-            truncate_naddr_link("https://gitworkshop.dev/naddr1qqqxyzabc1234", 4),
-            "https://gitworkshop.dev/naddr1...1234"
-        );
-        // Without the naddr1 prefix, unchanged.
-        assert_eq!(
-            truncate_naddr_link("https://example.com/x", 4),
-            "https://example.com/x"
-        );
-    }
-}

crates/workspace/src/views/repo_list.rs

@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use std::rc::Rc;
 
 use assets::CustomIconName;
@@ -5,7 +6,7 @@ use dock::{BasePanel, DockArea, Panel, PanelEvent};
 use gpui::prelude::*;
 use gpui::{
     AnyElement, App, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render,
-    SharedString, Size, Subscription, WeakEntity, Window, div, px, size,
+    SharedString, Size, Subscription, WeakEntity, Window, div, px, relative, size,
 };
 use gpui_component::input::{Input, InputEvent, InputState};
 use gpui_component::scroll::Scrollbar;
@@ -23,21 +24,32 @@ use super::open_repo_panel;
 const COLUMNS: usize = 2;
 const CARD_HEIGHT: f32 = 40. + 64. + 48. + 2. + 6.;
 
-/// How many of the newest repositories the `Recent` sort shows.
 const RECENT_COUNT: usize = 10;
 
-/// Sort of the explore list, chosen via the header's filter buttons.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 enum RepoFilter {
-    /// Every repository in the store's default order, newest first.
     All,
     #[default]
-    /// Repositories ranked by total issues + pull requests + commits.
     Popular,
-    /// The [`RECENT_COUNT`] newest repositories.
     Recent,
 }
 
+impl AsRef<str> for RepoFilter {
+    fn as_ref(&self) -> &str {
+        match self {
+            RepoFilter::All => "all",
+            RepoFilter::Popular => "popular",
+            RepoFilter::Recent => "recent",
+        }
+    }
+}
+
+impl Display for RepoFilter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_ref())
+    }
+}
+
 impl RepoFilter {
     /// Indices into the store's `announcements` this filter includes, in display order.
     ///
@@ -49,6 +61,7 @@ impl RepoFilter {
         // Narrow by the search query first.
         // Recent then limits the matches and Popular ranks them.
         let query = query.trim().to_lowercase();
+
         if !query.is_empty() {
             indices.retain(|&ix| {
                 let announcement = &announcements[ix];
@@ -82,23 +95,18 @@ impl RepoFilter {
     }
 }
 
-/// Browse all announced repositories.
 pub struct RepoListView {
     store: Entity<RepoListStore>,
     dock_area: WeakEntity<DockArea>,
     focus_handle: FocusHandle,
     scroll_handle: VirtualListScrollHandle,
-    /// Sort selected in the header filter buttons.
     filter: RepoFilter,
-    /// Per-row heights of the virtual list.
     item_sizes: Rc<Vec<Size<Pixels>>>,
     /// Number of rows [`Self::item_sizes`] was built for, the filtered repo count.
     repo_len: usize,
     /// Indices matching [`Self::filter`] into the store's `announcements`.
     visible: Vec<usize>,
-    /// Search box filtering repositories by name.
     search: Entity<InputState>,
-    /// Rebuilds the visible slice as the search text changes.
     _search_subscription: Subscription,
     _subscription: Subscription,
 }
@@ -111,7 +119,6 @@ impl RepoListView {
     ) -> Self {
         let store = RepoListStore::global(cx);
 
-        // Live search over repository names
         let search = cx.new(|cx| InputState::new(window, cx).placeholder("Search..."));
         let search_subscription = cx.subscribe(&search, |this, _search, event, cx| {
             if matches!(event, InputEvent::Change) {
@@ -125,7 +132,11 @@ impl RepoListView {
             this.rebuild_rows(cx);
         });
 
-        let mut this = Self {
+        cx.defer_in(window, |this, _window, cx| {
+            this.rebuild_rows(cx);
+        });
+
+        Self {
             store,
             dock_area,
             focus_handle: cx.focus_handle(),
@@ -137,27 +148,19 @@ impl RepoListView {
             search,
             _search_subscription: search_subscription,
             _subscription: subscription,
-        };
-
-        // Seed the rows right away.
-        // The store may already hold announcements from before the panel opened.
-        // The first render must not depend on a later store update.
-        this.rebuild_rows(cx);
-
-        this
+        }
     }
 
-    /// Rebuild [`Self::visible`] and [`Self::item_sizes`] from the store.
-    ///
-    /// Uses the store contents, [`Self::filter`] and the search query.
     fn rebuild_rows(&mut self, cx: &mut Context<Self>) {
         let filter = self.filter;
         let query = self.search.read(cx).value();
         let store = self.store.read(cx);
+
         self.visible = filter.visible(store, &query);
 
         // Each virtual list row holds `COLUMNS` repo cards.
         let rows = self.visible.len().div_ceil(COLUMNS);
+
         if self.repo_len != rows {
             self.repo_len = rows;
             self.item_sizes = Rc::new(vec![size(px(0.), px(CARD_HEIGHT)); rows]);
@@ -172,7 +175,13 @@ impl RepoListView {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        open_repo_panel(&self.dock_area, announcement, window, &mut *cx);
+        open_repo_panel(
+            &self.dock_area,
+            &announcement.addr(),
+            Some(announcement),
+            window,
+            cx,
+        );
     }
 
     fn render_card(
@@ -308,6 +317,22 @@ impl RepoListView {
             .into_any_element()
     }
 
+    fn render_filter<T>(&self, filter: RepoFilter, label: T, cx: &mut Context<Self>) -> AnyElement
+    where
+        T: Into<SharedString>,
+    {
+        let active = self.filter == filter;
+
+        SegmentButton::new(filter.to_string(), label)
+            .icon(Icon::new(filter.icon_name()))
+            .selected(active)
+            .on_click(cx.listener(move |this, _event, _window, cx| {
+                this.filter = filter;
+                this.rebuild_rows(cx);
+            }))
+            .into_any_element()
+    }
+
     fn render_header(&self, count: usize, cx: &mut Context<Self>) -> AnyElement {
         h_flex()
             .px_4()
@@ -315,18 +340,24 @@ impl RepoListView {
             .w_full()
             .gap_3()
             .child(
-                h_flex()
-                    .gap_1()
-                    .text_xs()
-                    .child(div().font_semibold().child("Repositories"))
+                v_flex()
+                    .gap_0p5()
                     .child(
                         div()
-                            .w_10()
                             .min_w_0()
                             .truncate()
                             .text_ellipsis()
+                            .font_semibold()
+                            .text_xs()
+                            .line_height(relative(1.2))
+                            .child("Repositories"),
+                    )
+                    .child(
+                        div()
+                            .text_size(px(10.))
                             .text_color(cx.theme().muted_foreground)
-                            .child(SharedString::from(format!("({count})"))),
+                            .line_height(relative(1.2))
+                            .child(SharedString::from(format!("Total: {count}"))),
                     ),
             )
             .child(
@@ -342,31 +373,12 @@ impl RepoListView {
             .child(
                 h_flex()
                     .gap_1()
-                    .child(self.filter_button(RepoFilter::All, "All", cx))
-                    .child(self.filter_button(RepoFilter::Popular, "Popular", cx))
-                    .child(self.filter_button(RepoFilter::Recent, "Recent", cx)),
+                    .child(self.render_filter(RepoFilter::All, "All", cx))
+                    .child(self.render_filter(RepoFilter::Popular, "Popular", cx))
+                    .child(self.render_filter(RepoFilter::Recent, "Recent", cx)),
             )
             .into_any_element()
     }
-
-    /// One segmented header filter button, like the issues list's status filter buttons.
-    fn filter_button(
-        &self,
-        filter: RepoFilter,
-        label: &'static str,
-        cx: &mut Context<Self>,
-    ) -> AnyElement {
-        let active = self.filter == filter;
-
-        SegmentButton::new(label, label)
-            .icon(Icon::new(filter.icon_name()))
-            .selected(active)
-            .on_click(cx.listener(move |this, _event, _window, cx| {
-                this.filter = filter;
-                this.rebuild_rows(cx);
-            }))
-            .into_any_element()
-    }
 }
 
 impl BasePanel for RepoListView {

crates/workspace/src/views/send_patch.rs

@@ -13,19 +13,12 @@ use signed_state::RepoStore;
 
 pub struct SendPatchView {
     focus_handle: FocusHandle,
-    /// Dock area the panel lives in.
     dock_area: WeakEntity<DockArea>,
-    /// Store of the target repository.
     store: Entity<RepoStore>,
-    /// Display name of the repository, for the panel title.
     repo_name: SharedString,
-    /// Title input, required.
     subject: Entity<InputState>,
-    /// Description input, optional.
     description: Entity<TextareaState>,
-    /// The pasted `git format-patch` output, required.
     patch: Entity<TextareaState>,
-    /// A submit is in flight.
     submitting: bool,
     /// Error of the last submit attempt, it keeps the panel open.
     error: Option<SharedString>,
@@ -61,7 +54,6 @@ impl SendPatchView {
         }
     }
 
-    /// Publish the pull request from the pasted patch.
     fn submit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if self.submitting {
             return;

crates/workspace/src/views/sidebar/create_repo_dialog.rs

@@ -17,10 +17,9 @@ use super::super::open_repo_panel;
 use super::grasp_servers::{GraspServersState, grasp_servers_field, load_user_grasp_servers};
 use crate::views::dialog_state::{DialogProgress, error_row};
 
-/// Shared state for the Create Repository dialog, so async results can be rendered.
+/// Progress of the create-repository flow, so async results can be rendered.
 pub type CreateRepoState = DialogProgress;
 
-/// Open the Create Repository dialog.
 pub fn open(dock_area: WeakEntity<DockArea>, window: &mut Window, cx: &mut App) {
     let settings = SettingsStore::global(cx);
     let default_folder = settings
@@ -151,7 +150,6 @@ pub fn open(dock_area: WeakEntity<DockArea>, window: &mut Window, cx: &mut App)
     });
 }
 
-/// Pick the repository's storage folder with the platform's native folder picker.
 fn choose_folder(folder_input: &Entity<InputState>, window: &mut Window, cx: &mut App) {
     let handle = window.window_handle();
     let folder_input = folder_input.clone();
@@ -186,8 +184,6 @@ fn choose_folder(folder_input: &Entity<InputState>, window: &mut Window, cx: &mu
     .detach();
 }
 
-/// Run the create-repository flow.
-///
 /// Opens the new working copy and the repository panel on success.
 #[allow(clippy::too_many_arguments)]
 fn create_repository(
@@ -250,12 +246,17 @@ fn create_repository(
     .detach();
 }
 
-/// Open the newly created repository in the dock's center.
 fn open_repo(
     dock_area: WeakEntity<DockArea>,
     announcement: Announcement,
     window: &mut Window,
     cx: &mut App,
 ) {
-    open_repo_panel(&dock_area, &announcement, window, cx);
+    open_repo_panel(
+        &dock_area,
+        &announcement.addr(),
+        Some(&announcement),
+        window,
+        cx,
+    );
 }

crates/workspace/src/views/sidebar/grasp_servers.rs

@@ -11,17 +11,16 @@ use signed_state::Backend;
 /// State of the grasp-server section of a publish dialog, so async results can be rendered.
 #[derive(Default)]
 pub struct GraspServersState {
-    /// The user's grasp list of kind `10317` is being loaded.
+    /// Set while the user's kind `10317` grasp list loads.
     pub loading_servers: bool,
     pub grasp_servers: Vec<RelayUrl>,
-    /// Whether the grasp server section is shown. Defaults to shown.
     pub servers_enabled: bool,
-    /// Error of the last grasp-server edit, an invalid relay URL for example.
+    /// Error from the last grasp-server edit, such as an invalid relay URL.
     pub error: Option<SharedString>,
 }
 
 impl GraspServersState {
-    /// Defaults used until the user's grasp list loads, which replaces them when non-empty.
+    /// Defaults used until the user's grasp list loads and replaces them.
     ///
     /// Persisted settings supply the defaults, an empty list falls back to the built-ins.
     pub fn new_default(settings: &GraspServersSettings) -> Self {
@@ -137,7 +136,6 @@ pub fn grasp_servers_field(
         }))
 }
 
-/// One grasp server row, the host in a tag plus a remove button.
 fn render_server_row(
     ix: usize,
     relay: &RelayUrl,
@@ -176,7 +174,7 @@ fn render_server_row(
         )
 }
 
-/// The bare host of a grasp server, defaults are entered without a scheme.
+/// Shows only the host, since grasp servers are entered without a scheme.
 fn display_server(relay: &RelayUrl) -> SharedString {
     relay
         .domain()
@@ -184,7 +182,7 @@ fn display_server(relay: &RelayUrl) -> SharedString {
         .unwrap_or_else(|| SharedString::from(relay.to_string()))
 }
 
-/// Parse the relay input, accepting a bare host, and append it to the list.
+/// Accepts a bare host as well as a full URL.
 fn add_relay(
     state: &Entity<GraspServersState>,
     input: &Entity<InputState>,
@@ -220,9 +218,9 @@ fn add_relay(
     }
 }
 
-/// Load the user's grasp list of kind `10317` from the local database.
+/// Loads the user's kind `10317` grasp list from the local database.
 ///
-/// It replaces the defaults when it lists any servers.
+/// Replaces the defaults when the list is non-empty.
 pub fn load_user_grasp_servers(
     state: Entity<GraspServersState>,
     window: &mut Window,

crates/workspace/src/views/sidebar/import_dialog.rs

@@ -1,7 +1,6 @@
 use gpui::{App, Window, px};
 use gpui_component::WindowExt;
 
-/// Open the Import Identity dialog.
 pub fn open(window: &mut Window, cx: &mut App) {
     window.open_dialog(cx, move |dialog, _window, _cx| {
         dialog.title("Import identity").width(px(400.))

crates/workspace/src/views/sidebar/mod.rs

@@ -39,15 +39,13 @@ pub struct SidebarPanel {
     dock_area: WeakEntity<DockArea>,
     inbox: Option<WeakEntity<InboxView>>,
     explore: Option<WeakEntity<RepoListView>>,
-    /// Artwork for the sign-in screen.
     banner: SharedString,
     /// The signed-in user's announced repositories, newest first.
     announcements: Arc<Vec<Announcement>>,
     /// Local repositories found by the scan that are not announced yet.
     local_repos: Arc<Vec<PathBuf>>,
-    /// A local scan is currently running.
     scanning: bool,
-    /// Unpushed local commits per announced repository, the row badge counts.
+    /// Unpushed commit counts per announced repository, shown as row badges.
     unpushed: HashMap<RepoAddr, usize>,
     _subscriptions: Vec<Subscription>,
 }
@@ -80,21 +78,19 @@ impl SidebarPanel {
             }
         }));
 
-        // The merged list re-derives when announcements or the local scan change.
         subscriptions.push(cx.observe(&repos, |this, _repos, cx| {
             if this.refresh(cx) {
                 cx.notify();
             }
         }));
 
-        // The local scan re-derives when announcements or the local scan change.
         subscriptions.push(cx.observe(&local, |this, _local, cx| {
             if this.refresh(cx) {
                 cx.notify();
             }
         }));
 
-        // Push statuses are recomputed in the background; only the badge counts change.
+        // Push statuses are recomputed in the background, so only the badge counts change.
         subscriptions.push(cx.observe(&checkouts, |this, _checkouts, cx| {
             if this.refresh_unpushed(cx) {
                 cx.notify();
@@ -125,8 +121,7 @@ impl SidebarPanel {
             .map(|user| repo_list.read(cx).announcements_of(user))
             .unwrap_or_default();
 
-        // A scanned repository is dropped from the local list
-        // once the user announces it, so it is not listed twice.
+        // Drop a scanned repository once the user announces it, so it is not listed twice.
         let local = LocalReposStore::global(cx);
         let scanning = local.read(cx).scanning;
 
@@ -162,14 +157,13 @@ impl SidebarPanel {
         announcements_changed || local_changed || scanning_changed
     }
 
-    /// Recompute the badge counts from the global checkouts store's ready-to-push statuses
     fn refresh_unpushed(&mut self, cx: &mut Context<Self>) -> bool {
-        let checkouts = CheckoutsStore::global(cx).read(cx);
+        let checkouts = CheckoutsStore::global(cx);
         let mut unpushed = HashMap::with_capacity(self.announcements.len());
 
         for announcement in self.announcements.iter() {
             let addr = announcement.addr();
-            let count = checkouts.unpushed(&addr);
+            let count = checkouts.read(cx).unpushed(&addr);
             if count > 0 {
                 unpushed.insert(addr, count);
             }
@@ -183,7 +177,6 @@ impl SidebarPanel {
         true
     }
 
-    /// Keep the `ready to push` statuses of the announced repositories current.
     fn request_push_watches(&self, cx: &mut Context<Self>) {
         let checkouts = CheckoutsStore::global(cx);
         checkouts.update(cx, |checkouts, cx| {
@@ -193,7 +186,6 @@ impl SidebarPanel {
         });
     }
 
-    /// Open the inbox home panel in the dock area's center.
     pub fn open_inbox(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if self.inbox.as_ref().and_then(WeakEntity::upgrade).is_some() {
             return;
@@ -202,12 +194,13 @@ impl SidebarPanel {
         let panel = cx.new(|cx| InboxView::new(self.dock_area.clone(), cx));
         self.inbox = Some(panel.downgrade());
 
-        let _ = self.dock_area.update(cx, |dock_area, cx| {
-            add_center_panel(dock_area, panel_handle(panel), window, cx);
-        });
+        self.dock_area
+            .update(cx, |dock_area, cx| {
+                add_center_panel(dock_area, panel_handle(panel), window, cx);
+            })
+            .ok();
     }
 
-    /// Open the Explore repository list panel in the dock area's center.
     pub fn open_explore(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if self
             .explore
@@ -221,12 +214,13 @@ impl SidebarPanel {
         let panel = cx.new(|cx| RepoListView::new(self.dock_area.clone(), window, cx));
         self.explore = Some(panel.downgrade());
 
-        let _ = self.dock_area.update(cx, |dock_area, cx| {
-            add_center_panel(dock_area, panel_handle(panel), window, cx);
-        });
+        self.dock_area
+            .update(cx, |dock_area, cx| {
+                add_center_panel(dock_area, panel_handle(panel), window, cx);
+            })
+            .ok();
     }
 
-    /// Show the Onboarding dialog.
     fn open_onboarding(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let name_input = cx.new(|cx| InputState::new(window, cx).placeholder("Enter desired name"));
         let pass_input = cx.new(|cx| {
@@ -244,23 +238,25 @@ impl SidebarPanel {
         onboarding_dialog::open(name_input, pass_input, repass_input, state, window, cx);
     }
 
-    /// Show the Create Repository dialog.
     fn open_create_repo(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         create_repo_dialog::open(self.dock_area.clone(), window, cx);
     }
 
-    /// Open a repository's detail view in the dock's center.
     fn open_repo(
         &mut self,
         announcement: &Announcement,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        open_repo_panel(&self.dock_area, announcement, window, &mut *cx);
+        open_repo_panel(
+            &self.dock_area,
+            &announcement.addr(),
+            Some(announcement),
+            window,
+            &mut *cx,
+        );
     }
 
-    /// Open a local repository's detail view in the dock's center.
-    ///
     /// The detail view offers to publish it to NIP-34.
     fn open_local_repo(&mut self, path: PathBuf, window: &mut Window, cx: &mut Context<Self>) {
         let detail =
@@ -324,7 +320,7 @@ impl SidebarPanel {
                     ),
             )
             .map(|this| {
-                // Merged list, the user's NIP-34 repositories and local repositories discovered.
+                // The merged list: NIP-34 repositories first, then discovered local repositories.
                 let total = announcements.len() + local_repos.len();
 
                 if total == 0 {
@@ -364,7 +360,7 @@ impl SidebarPanel {
             })
     }
 
-    /// One row of the merged sidebar list, a NIP-34 or a local repository.
+    /// Renders row `ix` of the merged list: an announced repository or a local one.
     fn render_repo_at(
         &self,
         announcements: &[Announcement],
@@ -393,7 +389,6 @@ impl SidebarPanel {
         let avatar = PixelAvatar::new(format!("{}:{}", announcement.owner, announcement.id));
         let announcement = announcement.clone();
 
-        // Badge with the unpushed commit count of the repository's local checkouts.
         let unpushed = self
             .unpushed
             .get(&announcement.addr())
@@ -423,9 +418,7 @@ impl SidebarPanel {
         )
     }
 
-    /// One local repository row.
-    ///
-    /// The directory name and a warning suffix, the repo is not yet set up for NIP-34.
+    /// A local repository that is not yet set up for NIP-34, marked with a warning.
     fn render_local_row(&self, path: &Path, cx: &mut Context<Self>) -> impl IntoElement {
         let name = path
             .file_name()
@@ -445,12 +438,11 @@ impl SidebarPanel {
             }))
     }
 
-    /// Show the Import Identity dialog.
     fn open_import(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         import_dialog::open(window, cx);
     }
 
-    /// Render the user avatar and name in the sidebar, inside the titlebar drag area.
+    /// The user avatar and name, wired into the titlebar drag area.
     fn render_user(
         &self,
         profile: &Profile,
@@ -480,7 +472,7 @@ impl SidebarPanel {
         )
     }
 
-    /// Sign-in placeholder shown while logged out.
+    /// Shown while no identity is signed in.
     fn render_sign_in(&self, window: &mut Window, cx: &mut Context<Self>) -> Div {
         v_flex()
             .size_full()
@@ -599,9 +591,9 @@ impl Render for SidebarPanel {
         }
 
         v_flex()
+            .image_cache(gpui::retain_all("sidebar"))
             .size_full()
             .justify_between()
-            .image_cache(gpui::retain_all("sidebar"))
             .bg(cx.theme().sidebar)
             .text_color(cx.theme().sidebar_foreground)
             .child(

crates/workspace/src/views/sidebar/onboarding_dialog.rs

@@ -9,10 +9,9 @@ use signed_state::Backend;
 
 use crate::views::dialog_state::{DialogProgress, error_row};
 
-/// Shared state for the Onboarding dialog, so async results can be rendered.
+/// Progress of the onboarding flow, so async results can be rendered.
 pub type OnboardingState = DialogProgress;
 
-/// Open the Onboarding dialog for creating a new identity.
 pub fn open(
     name_input: Entity<InputState>,
     pass_input: Entity<InputState>,

crates/workspace/src/views/sidebar/passphrase_dialog.rs

@@ -10,16 +10,14 @@ use signed_state::Backend;
 
 use crate::views::dialog_state::{DialogProgress, error_row};
 
-/// Shared state for the passphrase dialog, so async results can be rendered.
+/// State of the passphrase dialog, so async results can be rendered.
 #[derive(Default)]
 pub struct PassphraseState {
-    /// Progress of the unlock flow.
     pub progress: DialogProgress,
     /// Keeps the Enter-to-submit subscription alive while the dialog is open.
     _enter_subscription: Option<Subscription>,
 }
 
-/// Open the dialog asking for the passphrase that protects the stored identity.
 pub fn open(window: &mut Window, cx: &mut App) {
     let pass_input = cx.new(|cx| {
         InputState::new(window, cx)
@@ -30,7 +28,7 @@ pub fn open(window: &mut Window, cx: &mut App) {
     let handle = window.window_handle();
     let state = cx.new(|_| PassphraseState::default());
 
-    // Enter in the passphrase field submits, same as the Unlock button.
+    // Enter in the passphrase field submits, like the Unlock button.
     let enter_pass_input = pass_input.clone();
     let enter_state = state.clone();
     let enter_subscription = cx.subscribe(&pass_input, move |_input, event, cx| {
@@ -95,7 +93,6 @@ pub fn open(window: &mut Window, cx: &mut App) {
     });
 }
 
-/// Submit the passphrase to the backend.
 fn unlock(
     pass_input: &Entity<InputState>,
     state: &Entity<PassphraseState>,

crates/workspace/src/views/sidebar/settings_dialog.rs

@@ -22,7 +22,7 @@ use nostr::prelude::RelayUrl;
 use settings::{AppearanceMode, Settings, SettingsStore};
 use signed_ui::{SelectOption, setting_block, setting_row};
 
-/// The index of `value` in `options`, for seeding a [`SelectState`].
+/// Looks up the option index used to seed a [`SelectState`].
 fn selected_index(options: &[SelectOption], value: &str) -> Option<IndexPath> {
     options
         .iter()
@@ -30,7 +30,7 @@ fn selected_index(options: &[SelectOption], value: &str) -> Option<IndexPath> {
         .map(|row| IndexPath::default().row(row))
 }
 
-/// The light and dark themes registered in the theme registry.
+/// Registered themes split into light and dark options, light first.
 fn theme_options(cx: &App) -> (Vec<SelectOption>, Vec<SelectOption>) {
     let registry = ThemeRegistry::global(cx);
     let mut light = Vec::new();
@@ -48,7 +48,7 @@ fn theme_options(cx: &App) -> (Vec<SelectOption>, Vec<SelectOption>) {
     (light, dark)
 }
 
-/// Stateful controls of the settings dialog, created once when it opens.
+/// Created once when the dialog opens, so control state survives re-renders.
 struct SettingsControls {
     appearance: Entity<SelectState<Vec<SelectOption>>>,
     light_theme: Entity<SelectState<Vec<SelectOption>>>,
@@ -58,9 +58,9 @@ struct SettingsControls {
     radius: Entity<InputState>,
     radius_lg: Entity<InputState>,
     grasp_server_input: Entity<InputState>,
-    /// The effective default create-repository folder, shown in the disabled input.
+    /// The effective create-repository folder, shown in a disabled input.
     default_folder: Entity<InputState>,
-    /// Keeps the control subscriptions alive for the dialog's lifetime.
+    /// Keeps the control subscriptions alive while the dialog is open.
     _subscriptions: Vec<Subscription>,
 }
 
@@ -264,7 +264,6 @@ impl SettingsControls {
     }
 }
 
-/// Open the Settings dialog.
 pub fn open(window: &mut Window, cx: &mut App) {
     let controls = Rc::new(SettingsControls::new(window, cx));
 
@@ -278,8 +277,6 @@ pub fn open(window: &mut Window, cx: &mut App) {
     });
 }
 
-/// The settings content, one section per related setting.
-/// Sections are divided by horizontal separator lines.
 fn settings_view(controls: &SettingsControls, cx: &mut App) -> impl IntoElement {
     let store = SettingsStore::global(cx);
     let settings = store.read(cx).settings().clone();
@@ -297,7 +294,6 @@ fn settings_view(controls: &SettingsControls, cx: &mut App) -> impl IntoElement
         .child(repositories_section(&settings, controls, cx))
 }
 
-/// How the app picks its appearance.
 fn appearance_section(controls: &SettingsControls, cx: &App) -> impl IntoElement {
     v_flex().w_full().gap_3().child(setting_row(
         cx,
@@ -307,7 +303,6 @@ fn appearance_section(controls: &SettingsControls, cx: &App) -> impl IntoElement
     ))
 }
 
-/// Theme configuration, the registry theme names plus tweaks the app customizes at startup.
 fn theme_section(settings: &Settings, controls: &SettingsControls, cx: &App) -> impl IntoElement {
     v_flex()
         .gap_3()
@@ -378,7 +373,7 @@ fn theme_section(settings: &Settings, controls: &SettingsControls, cx: &App) ->
         ))
 }
 
-/// Default grasp servers offered until the user publishes a kind `10317` grasp list.
+/// Default grasp servers, used until the user's kind `10317` grasp list loads.
 fn grasp_servers_section(
     settings: &Settings,
     controls: &SettingsControls,
@@ -394,7 +389,6 @@ fn grasp_servers_section(
     ))
 }
 
-/// The editable list of default grasp servers plus an add-relay input.
 /// Styled like the grasp-server section of the publish dialogs.
 fn grasp_server_editor(
     servers: &[String],
@@ -459,7 +453,7 @@ fn grasp_server_editor(
         )
 }
 
-/// The bare host of a grasp server, defaults are entered without a scheme.
+/// Shows only the host, since grasp servers are entered without a scheme.
 /// Matches how the publish dialogs display servers.
 fn display_server(server: &str) -> SharedString {
     RelayUrl::parse(server)
@@ -469,7 +463,6 @@ fn display_server(server: &str) -> SharedString {
         .unwrap_or_else(|| SharedString::from(server.to_owned()))
 }
 
-/// Local repository scanning and the create-repository dialog default folder.
 fn repositories_section(
     settings: &Settings,
     controls: &SettingsControls,
@@ -494,7 +487,6 @@ fn repositories_section(
         ))
 }
 
-/// The editable list of scan directories plus an add-directory button.
 /// Styled like the grasp-server list.
 fn scan_paths_editor(scan_paths: &[PathBuf], cx: &App) -> impl IntoElement {
     v_flex()
@@ -547,7 +539,6 @@ fn scan_paths_editor(scan_paths: &[PathBuf], cx: &App) -> impl IntoElement {
         )
 }
 
-/// The default-folder selector, a disabled input plus a picker button.
 /// Matches the create-repository dialog.
 fn folder_selector(controls: &SettingsControls) -> impl IntoElement {
     let default_folder = controls.default_folder.clone();
@@ -571,8 +562,7 @@ fn folder_selector(controls: &SettingsControls) -> impl IntoElement {
         )
 }
 
-/// Parse the server input and append it to the default grasp servers.
-/// A bare host is accepted.
+/// Accepts a bare host as well as a full URL.
 fn add_server(input: &Entity<InputState>, window: &mut Window, cx: &mut App) {
     let value = input.read(cx).value().trim().to_owned();
     if value.is_empty() {
@@ -604,7 +594,6 @@ fn add_server(input: &Entity<InputState>, window: &mut Window, cx: &mut App) {
     input.update(cx, |input, cx| input.set_value("", window, cx));
 }
 
-/// Prompt for directories to add to the local-repository scan.
 fn add_scan_path(cx: &mut App) {
     let prompt = cx.prompt_for_paths(PathPromptOptions {
         files: false,
@@ -641,8 +630,7 @@ fn add_scan_path(cx: &mut App) {
     .detach();
 }
 
-/// Prompt for the Create Repository dialog's default folder.
-/// Remember it in the settings and show it in the disabled input.
+/// Persists the choice and reflects it in the disabled input.
 fn choose_default_folder(default_folder: &Entity<InputState>, window: &mut Window, cx: &mut App) {
     let handle = window.window_handle();
     let default_folder = default_folder.clone();
@@ -676,9 +664,7 @@ fn choose_default_folder(default_folder: &Entity<InputState>, window: &mut Windo
     .detach();
 }
 
-/// Wire a number input to the settings.
-/// Step actions clamp and persist the value.
-/// Typed changes parse, clamp and persist.
+/// Step actions clamp and persist the value; typed changes parse, clamp and persist.
 fn wire_number_input(
     state: &Entity<InputState>,
     subscriptions: &mut Vec<Subscription>,
@@ -751,7 +737,6 @@ fn wire_number_input(
     }));
 }
 
-/// Apply the persisted appearance to the live theme.
 fn apply_appearance(appearance: AppearanceMode, cx: &mut App) {
     match appearance {
         AppearanceMode::System => Theme::sync_system_appearance(None, cx),
@@ -760,7 +745,6 @@ fn apply_appearance(appearance: AppearanceMode, cx: &mut App) {
     }
 }
 
-/// Re-apply the persisted theme configuration to the live theme.
 fn apply_theme(cx: &mut App) {
     let store = SettingsStore::global(cx);
     let settings = store.read(cx).settings().theme.clone();

crates/workspace/src/views/tree.rs

@@ -0,0 +1,153 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use gpui_component::tree::TreeItem;
+
+pub(crate) struct TreeItemSeed {
+    /// Path of the node, relative to the worktree root.
+    pub(crate) id: String,
+    pub(crate) label: String,
+    pub(crate) children: Vec<TreeItemSeed>,
+}
+
+pub(crate) fn tree_items(seeds: Vec<TreeItemSeed>, expand_folders: bool) -> Vec<TreeItem> {
+    fn convert(seed: TreeItemSeed, expand_folders: bool) -> TreeItem {
+        let mut item = TreeItem::new(seed.id, seed.label);
+        if expand_folders && !seed.children.is_empty() {
+            item = item.expanded(true);
+        }
+        item.children = seed
+            .children
+            .into_iter()
+            .map(|seed| convert(seed, expand_folders))
+            .collect();
+        item
+    }
+
+    seeds
+        .into_iter()
+        .map(|seed| convert(seed, expand_folders))
+        .collect()
+}
+
+/// Build nested tree items from a flat entry list sorted dirs-first.
+pub(crate) fn build_tree_items(entries: &[PathBuf]) -> Vec<TreeItemSeed> {
+    // Node indices by full path, so parents resolve in constant time while inserting.
+    let mut index: HashMap<String, usize> = HashMap::new();
+    let mut nodes: Vec<(String, String, Vec<usize>)> = Vec::new();
+    let mut roots: Vec<usize> = Vec::new();
+
+    for entry in entries {
+        let mut parent: Option<usize> = None;
+        let mut path = String::new();
+        for part in entry.components() {
+            let label = part.as_os_str().to_string_lossy().into_owned();
+            path = if path.is_empty() {
+                label.clone()
+            } else {
+                format!("{path}/{label}")
+            };
+            let ix = *index.entry(path.clone()).or_insert_with(|| {
+                let ix = nodes.len();
+                nodes.push((path.clone(), label.clone(), Vec::new()));
+                match parent {
+                    Some(parent) => nodes[parent].2.push(ix),
+                    None => roots.push(ix),
+                }
+                ix
+            });
+            parent = Some(ix);
+        }
+    }
+
+    fn assemble(ix: usize, nodes: &[(String, String, Vec<usize>)]) -> TreeItemSeed {
+        let (id, label, children) = &nodes[ix];
+        TreeItemSeed {
+            id: id.clone(),
+            label: label.clone(),
+            children: children
+                .iter()
+                .map(|child| assemble(*child, nodes))
+                .collect(),
+        }
+    }
+
+    roots.iter().map(|root| assemble(*root, &nodes)).collect()
+}
+
+/// Sorted relative paths of a worktree snapshot.
+///
+/// Compared against the `worktree_paths` of a repository panel to skip
+/// rebuilding the explorer when a refresh left the worktree unchanged.
+pub(crate) fn sorted_worktree_paths(entries: &[PathBuf]) -> Vec<String> {
+    let mut paths: Vec<String> = entries
+        .iter()
+        .map(|path| path.to_string_lossy().into_owned())
+        .collect();
+    paths.sort();
+    paths
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builds_nested_tree_from_flat_entries() {
+        let entries = vec![
+            PathBuf::from("src"),
+            PathBuf::from("src/lib.rs"),
+            PathBuf::from("README.md"),
+            PathBuf::from("docs/guide.md"),
+        ];
+
+        let items = build_tree_items(&entries);
+
+        // Input order is preserved, dirs-first as produced by worktree_entries.
+        assert_eq!(items.len(), 3);
+        assert_eq!(items[0].label, "src");
+        assert_eq!(items[0].id, "src");
+        assert_eq!(items[0].children.len(), 1);
+        assert_eq!(items[0].children[0].label, "lib.rs");
+        assert_eq!(items[0].children[0].id, "src/lib.rs");
+
+        assert_eq!(items[1].label, "README.md");
+        assert_eq!(items[1].id, "README.md");
+
+        assert_eq!(items[2].label, "docs");
+        assert_eq!(items[2].children[0].label, "guide.md");
+        assert_eq!(items[2].children[0].id, "docs/guide.md");
+    }
+
+    #[test]
+    fn tree_builder_handles_deep_nesting() {
+        let entries = vec![
+            PathBuf::from("a"),
+            PathBuf::from("a/b"),
+            PathBuf::from("a/b/c.txt"),
+        ];
+
+        let items = build_tree_items(&entries);
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].children[0].id, "a/b");
+        assert_eq!(items[0].children[0].children[0].id, "a/b/c.txt");
+    }
+
+    #[test]
+    fn tree_builder_merges_shared_prefixes() {
+        // File children of a directory arrive after other directories' entries.
+        // The worktree list is dirs-first globally.
+        // The shared prefix must still resolve to one node.
+        let entries = vec![
+            PathBuf::from("a/x.txt"),
+            PathBuf::from("b/y.txt"),
+            PathBuf::from("a/z.txt"),
+        ];
+
+        let items = build_tree_items(&entries);
+        assert_eq!(items.len(), 2);
+        assert_eq!(items[0].label, "a");
+        assert_eq!(items[0].children.len(), 2);
+        assert_eq!(items[1].label, "b");
+    }
+}

crates/workspace/src/workspace.rs

@@ -1,28 +1,22 @@
 use dock::{DockArea, DockEvent, DockLayout, DockPlacement, SignedDockSkin, panel_handle};
 use gpui::prelude::*;
-use gpui::{Context, Entity, KeyBinding, Render, Subscription, Window, actions, div, px};
+use gpui::{Context, Entity, Render, Subscription, Window, div, px};
 use gpui_component::{Root, StyledExt, Theme};
-use gpui_fps::{FpsMonitor, FpsOverlay};
+use settings::{AppearanceMode, SettingsStore};
 use signed_state::{Backend, BackendEvent};
 
 use crate::views::SidebarPanel;
 use crate::views::sidebar::passphrase_dialog;
 
-actions!(workspace, [ToggleMonitor]);
-
 pub struct Workspace {
     dock: Entity<DockArea>,
-    fps: Entity<FpsMonitor>,
-    /// Debug HUD, toggled with `cmd-shift-f`.
-    show_fps: bool,
     _subscriptions: Vec<Subscription>,
-    _passphrase_subscription: Subscription,
 }
 
 impl Workspace {
     pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let fps = cx.new(|cx| FpsMonitor::new(window, cx).continuous(false));
-        cx.bind_keys([KeyBinding::new("cmd-shift-f", ToggleMonitor, None)]);
+        let backend = Backend::global(cx);
+        let settings = SettingsStore::global(cx);
 
         let dock = cx.new(|cx| {
             let skin = SignedDockSkin::new(cx);
@@ -33,20 +27,15 @@ impl Workspace {
         let sidebar = cx.new(|cx| SidebarPanel::new(weak_dock.clone(), cx));
         let weak_sidebar = sidebar.downgrade();
 
-        dock.update(cx, |dock_area, cx| {
-            dock_area.set_dock(
-                DockPlacement::Left,
-                DockLayout::tabs().panel_view(panel_handle(sidebar), cx),
-                window,
-                cx,
-            );
-            dock_area.set_dock_size(DockPlacement::Left, px(240.), window, cx);
-        });
-
         let mut subscriptions = vec![];
 
+        if settings.read(cx).settings().appearance == AppearanceMode::System {
+            subscriptions.push(cx.observe_window_appearance(window, |_this, window, cx| {
+                Theme::sync_system_appearance(Some(window), cx);
+            }));
+        }
+
         // A bottom or right dock whose last panel was dragged away is removed entirely.
-        let dock_for_pruning = dock.clone();
         subscriptions.push(cx.subscribe_in(
             &dock,
             window,
@@ -54,9 +43,9 @@ impl Workspace {
                 if !matches!(event, DockEvent::LayoutChanged) {
                     return;
                 }
-                let dock = dock_for_pruning.clone();
+                let weak = weak_dock.clone();
                 cx.spawn_in(window, async move |_, window| {
-                    dock.update_in(window, |area, window, cx| {
+                    weak.update_in(window, |area, window, cx| {
                         for placement in [DockPlacement::Bottom, DockPlacement::Right] {
                             if area.is_empty(placement, cx) {
                                 area.remove_dock(placement, window, cx);
@@ -69,28 +58,34 @@ impl Workspace {
             },
         ));
 
-        subscriptions.push(cx.observe_window_appearance(window, |_this, window, cx| {
-            Theme::sync_system_appearance(Some(window), cx);
-        }));
-
-        let backend = Backend::global(cx);
-
         // Ask for the passphrase when the stored identity is NIP-49 encrypted.
-        let passphrase_subscription =
-            window.subscribe(&backend, cx, |_backend, event, window, cx| {
+        subscriptions.push(cx.subscribe_in(
+            &backend,
+            window,
+            |_this, _state, event, window, cx| {
                 if matches!(event, BackendEvent::PassphraseRequired) {
                     passphrase_dialog::open(window, cx);
                 }
+            },
+        ));
+
+        cx.defer_in(window, move |this, window, cx| {
+            // The event may have fired before this window existed.
+            // Fall back to the backend state in that case.
+            if backend.read(cx).passphrase_required() {
+                passphrase_dialog::open(window, cx);
+            }
+
+            this.dock.update(cx, |dock_area, cx| {
+                dock_area.set_dock(
+                    DockPlacement::Left,
+                    DockLayout::tabs().panel_view(panel_handle(sidebar), cx),
+                    window,
+                    cx,
+                );
+                dock_area.set_dock_size(DockPlacement::Left, px(240.), window, cx);
             });
 
-        // The event may have fired before this window existed.
-        // Fall back to the backend state in that case.
-        if backend.read(cx).passphrase_required() {
-            passphrase_dialog::open(window, cx);
-        }
-
-        // Open the explore panel after the sidebar has been initialized.
-        cx.defer_in(window, move |_, window, cx| {
             weak_sidebar
                 .update(cx, |this, cx| {
                     this.open_explore(window, cx);
@@ -100,10 +95,7 @@ impl Workspace {
 
         Self {
             dock,
-            show_fps: cfg!(debug_assertions),
-            fps,
             _subscriptions: subscriptions,
-            _passphrase_subscription: passphrase_subscription,
         }
     }
 }
@@ -115,21 +107,11 @@ impl Render for Workspace {
 
         div()
             .id("workspace")
-            .on_action(
-                cx.listener(|this: &mut Self, _ev: &ToggleMonitor, _window, cx| {
-                    this.show_fps = !this.show_fps;
-                    cx.notify();
-                }),
-            )
             .v_flex()
             .size_full()
             .relative()
             .child(self.dock.clone())
-            // Notifications
             .children(notification_layer)
-            // Modals
             .children(dialog_layer)
-            // On top of everything, so it stays readable while debugging.
-            .when(self.show_fps, |this| this.child(FpsOverlay::new(&self.fps)))
     }
 }