chore: clean up codebase (#19)

Reviewed-on: #19

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

@@ -0,0 +1,223 @@
+use gpui::prelude::*;
+use gpui::{AnyElement, App, SharedString, Window, div, px};
+use gpui_component::clipboard::Clipboard;
+use gpui_component::{ActiveTheme, StyledExt, WindowExt, h_flex, v_flex};
+use nostr::prelude::PublicKey;
+use signed_core::Announcement;
+use signed_state::ProfileStore;
+use signed_ui::{UserAvatar, middle_truncate};
+
+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();
+        dialog
+            .w(px(500.))
+            .h(px(600.))
+            .keyboard(true)
+            .close_button(true)
+            .title("About")
+            .child(announcement_rows(&announcement, cx))
+    });
+}
+
+fn announcement_rows(announcement: &Announcement, cx: &App) -> AnyElement {
+    let mut rows: Vec<AnyElement> = Vec::new();
+
+    rows.push(row(
+        "Name",
+        text(
+            announcement
+                .name
+                .as_deref()
+                .map(SharedString::from)
+                .unwrap_or_else(|| SharedString::from("-")),
+        ),
+        cx,
+    ));
+
+    rows.push(row(
+        "Description",
+        text(
+            announcement
+                .description
+                .as_deref()
+                .map(SharedString::from)
+                .unwrap_or_else(|| SharedString::from("-")),
+        ),
+        cx,
+    ));
+
+    if !announcement.web.is_empty() {
+        rows.push(row(
+            "Web",
+            list(
+                "about-web",
+                announcement.web.iter().map(|url| url.to_string()),
+                cx,
+            ),
+            cx,
+        ));
+    }
+
+    if let Some(euc) = &announcement.euc {
+        rows.push(row(
+            "Earliest Commit",
+            copy_value("about-euc", euc.clone(), cx),
+            cx,
+        ));
+    }
+
+    if let Some(upstream) = &announcement.upstream {
+        rows.push(row("Upstream", text(upstream.display()), cx));
+    }
+
+    if !announcement.hashtags.is_empty() {
+        rows.push(row(
+            "Hashtags",
+            text(SharedString::from(announcement.hashtags.join(", "))),
+            cx,
+        ));
+    }
+
+    if !announcement.clone.is_empty() {
+        rows.push(row(
+            "Clone URLs",
+            list(
+                "about-clone",
+                announcement.clone.iter().map(|url| url.to_string()),
+                cx,
+            ),
+            cx,
+        ));
+    }
+
+    if !announcement.relays.is_empty() {
+        rows.push(row(
+            "Grasp Relays",
+            list(
+                "about-relays",
+                announcement.relays.iter().map(|url| url.to_string()),
+                cx,
+            ),
+            cx,
+        ));
+    }
+
+    if !announcement.maintainers.is_empty() {
+        rows.push(row(
+            "Maintainers",
+            maintainers(&announcement.maintainers, cx),
+            cx,
+        ));
+    }
+
+    v_flex().gap_3().w_full().children(rows).into_any_element()
+}
+
+fn row(label: &'static str, value: AnyElement, cx: &App) -> AnyElement {
+    v_flex()
+        .gap_1()
+        .min_w_0()
+        .child(
+            div()
+                .text_xs()
+                .font_semibold()
+                .text_color(cx.theme().muted_foreground)
+                .child(label),
+        )
+        .child(value)
+        .into_any_element()
+}
+
+fn text<T>(value: T) -> AnyElement
+where
+    T: Into<SharedString>,
+{
+    let value = value.into();
+
+    div()
+        .text_sm()
+        .w_full()
+        .min_w_0()
+        .child(value)
+        .into_any_element()
+}
+
+fn copy_value(id: &'static str, value: String, cx: &App) -> AnyElement {
+    h_flex()
+        .gap_2()
+        .items_center()
+        .min_w_0()
+        .child(
+            div()
+                .font_family(cx.theme().mono_font_family.clone())
+                .text_xs()
+                .min_w_0()
+                .child(SharedString::from(value.clone())),
+        )
+        .child(Clipboard::new(id).tooltip("Copy").value(value))
+        .into_any_element()
+}
+
+fn maintainers(maintainers: &[PublicKey], cx: &App) -> AnyElement {
+    let profile_store = ProfileStore::global(cx);
+    v_flex()
+        .gap_2()
+        .min_w_0()
+        .children(maintainers.iter().map(|pubkey| {
+            let profile = profile_store.read(cx).get(pubkey);
+            let name = profile.name();
+            let picture = profile.picture();
+
+            h_flex()
+                .gap_2()
+                .items_center()
+                .min_w_0()
+                .child(UserAvatar::new(name.clone()).picture(picture))
+                .child(
+                    div()
+                        .flex_1()
+                        .min_w_0()
+                        .overflow_hidden()
+                        .whitespace_nowrap()
+                        .text_ellipsis()
+                        .text_sm()
+                        .child(name),
+                )
+        }))
+        .into_any_element()
+}
+
+fn list(id: &'static str, items: impl IntoIterator<Item = String>, cx: &App) -> AnyElement {
+    v_flex()
+        .gap_2()
+        .min_w_0()
+        .children(items.into_iter().enumerate().map(|(ix, item)| {
+            h_flex()
+                .id(ix)
+                .h_8()
+                .px_2()
+                .gap_2()
+                .min_w_0()
+                .bg(cx.theme().secondary)
+                .hover(|this| this.bg(cx.theme().secondary_hover))
+                .rounded(cx.theme().radius)
+                .text_color(cx.theme().secondary_foreground)
+                .child(
+                    div()
+                        .flex_1()
+                        .min_w_0()
+                        .whitespace_nowrap()
+                        .text_ellipsis()
+                        .text_sm()
+                        .child(SharedString::from(middle_truncate(&item, 28, 16))),
+                )
+                .child(
+                    Clipboard::new(format!("{id}-{ix}"))
+                        .tooltip("Copy")
+                        .value(item),
+                )
+                .into_any_element()
+        }))
+        .into_any_element()
+}

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

@@ -0,0 +1,201 @@
+use std::path::PathBuf;
+
+use assets::CustomIconName;
+use gpui::prelude::*;
+use gpui::{App, Entity, WeakEntity, Window, px};
+use gpui_base::h_flex;
+use gpui_base::input::TextareaState;
+use gpui_component::button::{Button, ButtonVariants};
+use gpui_component::dialog::{DialogDescription, DialogFooter, DialogHeader, DialogTitle};
+use gpui_component::form::{field, v_form};
+use gpui_component::input::{Input, InputState, Textarea};
+use gpui_component::{ActiveTheme, Disableable, WindowExt};
+use settings::SettingsStore;
+use signed_state::Backend;
+
+use super::RepoDetailView;
+use crate::views::dialog_state::{DialogProgress, error_row};
+use crate::views::sidebar::grasp_servers::{
+    GraspServersState, grasp_servers_field, load_user_grasp_servers,
+};
+
+pub type InitRepoState = DialogProgress;
+
+pub fn open(
+    local_path: PathBuf,
+    view: WeakEntity<RepoDetailView>,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    let default_name = local_path
+        .file_name()
+        .map(|name| name.to_string_lossy().into_owned())
+        .unwrap_or_default();
+
+    let grasp_settings = SettingsStore::global(cx)
+        .read(cx)
+        .settings()
+        .grasp_servers
+        .clone();
+
+    let state = cx.new(|_| InitRepoState::default());
+    let grasp_state = cx.new(|_| GraspServersState::new_default(&grasp_settings));
+
+    let relay_input = cx.new(|cx| InputState::new(window, cx).placeholder("relay.example.com"));
+    let name_input = cx.new(|cx| InputState::new(window, cx).default_value(default_name));
+    let desc_input = cx.new(|cx| {
+        TextareaState::new(window, cx)
+            .auto_grow(3, 5)
+            .placeholder("Short description")
+    });
+
+    load_user_grasp_servers(grasp_state.clone(), window, cx);
+
+    window.open_dialog(cx, move |dialog, _window, _cx| {
+        const DESC: &str = "Publish this local repository to Nostr.";
+
+        let name_input = name_input.clone();
+        let desc_input = desc_input.clone();
+        let relay_input = relay_input.clone();
+        let state = state.clone();
+        let grasp_state = grasp_state.clone();
+        let local_path = local_path.clone();
+        let view = view.clone();
+
+        dialog
+            .width(px(520.))
+            .margin_top(px(50.))
+            .content(move |content, _window, cx| {
+                let busy = state.read(cx).busy;
+                let error = state.read(cx).error.clone();
+
+                content
+                    .child(
+                        DialogHeader::new()
+                            .child(DialogTitle::new().child("Initialize repository"))
+                            .child(DialogDescription::new().child(DESC)),
+                    )
+                    .child(
+                        v_form()
+                            .child(
+                                field()
+                                    .label("Repository name")
+                                    .description("Max 100 characters")
+                                    .required(true)
+                                    .child(Input::new(&name_input).readonly(true)),
+                            )
+                            .child(
+                                field()
+                                    .label("Description")
+                                    .child(Textarea::new(&desc_input)),
+                            )
+                            .child(
+                                field()
+                                    .label("Folder")
+                                    .description("The local repository being published")
+                                    .child(
+                                        h_flex()
+                                            .h_8()
+                                            .w_full()
+                                            .px_2()
+                                            .bg(cx.theme().muted)
+                                            .text_sm()
+                                            .text_color(cx.theme().muted_foreground)
+                                            .rounded(cx.theme().radius)
+                                            .child(local_path.display().to_string()),
+                                    ),
+                            )
+                            .child(grasp_servers_field(&grasp_state, &relay_input, cx)),
+                    )
+                    .children(error_row(&error, cx))
+                    .child(
+                        DialogFooter::new().justify_end().child(
+                            Button::new("init")
+                                .primary()
+                                .label("Initialize")
+                                .icon(CustomIconName::Init)
+                                .tooltip("Publish to Nostr")
+                                .loading(busy)
+                                .disabled(busy)
+                                .on_click({
+                                    let name_input = name_input.clone();
+                                    let desc_input = desc_input.clone();
+                                    let state = state.clone();
+                                    let grasp_state = grasp_state.clone();
+                                    let local_path = local_path.clone();
+                                    let view = view.clone();
+
+                                    move |_ev, window, cx| {
+                                        init_repository(
+                                            local_path.clone(),
+                                            (name_input.clone(), desc_input.clone()),
+                                            state.clone(),
+                                            grasp_state.clone(),
+                                            view.clone(),
+                                            window,
+                                            cx,
+                                        );
+                                    }
+                                }),
+                        ),
+                    )
+            })
+    });
+}
+
+fn init_repository(
+    local_path: PathBuf,
+    inputs: (Entity<InputState>, Entity<TextareaState>),
+    state: Entity<InitRepoState>,
+    grasp_state: Entity<GraspServersState>,
+    view: WeakEntity<RepoDetailView>,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    let (name_input, desc_input) = inputs;
+    let name = name_input.read(cx).value().trim().to_owned();
+    let description = desc_input.read(cx).value().trim().to_owned();
+    let servers = grasp_state.read(cx).grasp_servers.clone();
+
+    if name.is_empty() {
+        state.update(cx, |state, _| state.fail("Repository name is required"));
+        return;
+    }
+
+    if servers.is_empty() {
+        state.update(cx, |state, _| state.fail("Add at least one grasp server"));
+        return;
+    }
+
+    state.update(cx, |state, _| state.begin());
+
+    let backend = Backend::global(cx);
+    let task = backend.update(cx, |backend, cx| {
+        backend.publish_local_repo(local_path.clone(), &name, &description, servers, cx)
+    });
+
+    let handle = window.window_handle();
+    let state = state.clone();
+    let view = view.clone();
+
+    cx.spawn(async move |cx| match task.await {
+        Ok(announcement) => {
+            cx.update_window(handle, |_, window, cx| {
+                window.close_dialog(cx);
+                if let Some(view) = view.upgrade() {
+                    view.update(cx, |this, cx| {
+                        this.apply_announcement(announcement, cx);
+                    });
+                }
+            })
+            .ok();
+        }
+        Err(e) => {
+            cx.update_window(handle, |_, _window, cx| {
+                state.update(cx, |state, _| state.fail(e.to_string()));
+            })
+            .ok();
+        }
+    })
+    .detach();
+}

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
+}