Surface the git graph context menu in the git panel's history tab (#60713)

This PR refactors the Git Graph’s commit context menu into its own file
so it can be reused by both the Git Graph and the Git panel’s History
tab.

<img width="511" height="566" alt="SCR-20260709-qlxt"
src="https://github.com/user-attachments/assets/8f18f22b-21d7-46a0-8ce2-183cf4af86c9"
/>

Also, includes a "Show in Git Graph" option only shown in the history
tab's context menu:


https://github.com/user-attachments/assets/2e30648b-2802-4caa-a99e-2d135e2dc539

Release Notes:

- Surfaced the git graph context menu in the git panel's history tab.

Author: JosephTLyons

crates/git_ui/src/commit_context_menu.rs

@@ -0,0 +1,243 @@
+use crate::commit_view::CommitView;
+use git::Oid;
+use gpui::{Action, ClipboardItem, Entity, FocusHandle, SharedString, WeakEntity, Window, actions};
+use project::{GIT_COMMAND_TASK_TAG, git_store::Repository};
+
+use task::{TaskContext, TaskVariables, VariableName};
+use ui::{Color, ContextMenu, ContextMenuEntry, IconName, IconPosition, prelude::*};
+use workspace::Workspace;
+
+actions!(
+    git_graph,
+    [
+        /// Copies the SHA of the selected commit to the clipboard.
+        CopyCommitSha,
+        /// Copies a tag from the selected commit to the clipboard.
+        CopyCommitTag,
+        /// Opens the commit view for the selected commit.
+        OpenCommitView,
+    ]
+);
+
+const COMMIT_TAG_LIST_WIDTH_IN_REMS: Rems = rems(10.);
+const CUSTOM_GIT_COMMANDS_DOCS_SLUG: &str = "tasks#custom-git-commands";
+
+pub(crate) struct CommitContextMenuData {
+    pub(crate) sha: Oid,
+    pub(crate) tag_names: Vec<SharedString>,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CommitContextMenuSource {
+    GitGraph,
+    GitPanel,
+}
+
+pub(crate) fn commit_context_menu(
+    commit: CommitContextMenuData,
+    source: CommitContextMenuSource,
+    ref_name: Option<SharedString>,
+    focus_handle: FocusHandle,
+    repository: Option<WeakEntity<Repository>>,
+    workspace: WeakEntity<Workspace>,
+    window: &mut Window,
+    cx: &mut App,
+) -> Entity<ContextMenu> {
+    let sha = commit.sha;
+    let sha_short = sha.display_short();
+    let git_tasks = git_context_menu_tasks(
+        git_task_context(&repository, sha, ref_name.as_deref(), cx),
+        &workspace,
+        cx,
+    );
+    let header = match &ref_name {
+        Some(ref_name) => format!("Ref {ref_name}"),
+        None => format!("Commit {sha_short}"),
+    };
+
+    ContextMenu::build(window, cx, move |context_menu, _, _| {
+        context_menu
+            .context(focus_handle)
+            .header(header)
+            .entry("View Commit", Some(OpenCommitView.boxed_clone()), {
+                let repository = repository.clone();
+                let workspace = workspace.clone();
+                move |window, cx| {
+                    let Some(repository) = repository.clone() else {
+                        return;
+                    };
+                    CommitView::open(
+                        sha.to_string(),
+                        repository,
+                        workspace.clone(),
+                        None,
+                        None,
+                        window,
+                        cx,
+                    );
+                }
+            })
+            .entry(
+                "Copy SHA",
+                Some(CopyCommitSha.boxed_clone()),
+                move |_window, cx| {
+                    cx.write_to_clipboard(ClipboardItem::new_string(sha.to_string()));
+                },
+            )
+            .when_some(ref_name.clone(), |menu, ref_name| {
+                menu.entry("Copy Ref Name", None, move |_window, cx| {
+                    cx.write_to_clipboard(ClipboardItem::new_string(ref_name.to_string()));
+                })
+            })
+            .when(ref_name.is_none(), |menu| {
+                menu.map(|menu| {
+                    let tag_names = commit.tag_names.clone();
+                    let copy_tag_label = "Copy Tag";
+
+                    match tag_names.as_slice() {
+                        [] => menu.item(
+                            ContextMenuEntry::new(copy_tag_label)
+                                .action(CopyCommitTag.boxed_clone())
+                                .disabled(true),
+                        ),
+                        [tag_name] => {
+                            let tag_name = tag_name.clone();
+                            let label = format!("{copy_tag_label}: {tag_name}");
+                            menu.entry(
+                                label,
+                                Some(CopyCommitTag.boxed_clone()),
+                                move |_window, cx| {
+                                    cx.write_to_clipboard(ClipboardItem::new_string(
+                                        tag_name.to_string(),
+                                    ));
+                                },
+                            )
+                        }
+                        _ => menu.submenu(copy_tag_label, move |menu, _window, _cx| {
+                            let mut menu = menu.fixed_width(COMMIT_TAG_LIST_WIDTH_IN_REMS.into());
+
+                            for tag_name in tag_names.clone() {
+                                let tag_name_to_copy = tag_name.clone();
+                                menu = menu.entry(tag_name, None, move |_window, cx| {
+                                    cx.write_to_clipboard(ClipboardItem::new_string(
+                                        tag_name_to_copy.to_string(),
+                                    ));
+                                });
+                            }
+                            menu
+                        }),
+                    }
+                })
+            })
+            .when(source == CommitContextMenuSource::GitPanel, |menu| {
+                menu.entry("Show in Git Graph", None, move |window, cx| {
+                    window.dispatch_action(
+                        Box::new(crate::git_graph::OpenAtCommit {
+                            sha: sha.to_string(),
+                        }),
+                        cx,
+                    );
+                })
+            })
+            .map(|mut menu| {
+                menu = menu.separator().header("Custom Commands");
+
+                if git_tasks.is_empty() {
+                    return menu.item(
+                        ContextMenuEntry::new("Learn More")
+                            .icon(IconName::ArrowUpRight)
+                            .icon_color(Color::Muted)
+                            .icon_position(IconPosition::End)
+                            .handler(|_window, cx| {
+                                let docs_url =
+                                    release_channel::docs_url(CUSTOM_GIT_COMMANDS_DOCS_SLUG, cx);
+                                cx.open_url(&docs_url);
+                            }),
+                    );
+                }
+
+                for (task_source_kind, resolved_task) in git_tasks {
+                    let label = resolved_task.display_label().to_string();
+                    let workspace = workspace.clone();
+                    menu = menu.entry(label, None, move |window, cx| {
+                        workspace
+                            .update(cx, |workspace, cx| {
+                                workspace.schedule_resolved_task(
+                                    task_source_kind.clone(),
+                                    resolved_task.clone(),
+                                    false,
+                                    window,
+                                    cx,
+                                );
+                            })
+                            .ok();
+                    });
+                }
+
+                menu
+            })
+    })
+}
+
+fn git_task_context(
+    repository: &Option<WeakEntity<Repository>>,
+    commit_sha: git::Oid,
+    ref_name: Option<&str>,
+    cx: &App,
+) -> Option<TaskContext> {
+    let repository_path = repository
+        .as_ref()?
+        .upgrade()?
+        .read(cx)
+        .work_directory_abs_path
+        .to_path_buf();
+    let repository_name = repository_path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .map(ToString::to_string);
+    let mut task_variables = TaskVariables::from_iter([
+        (VariableName::GitSha, commit_sha.to_string()),
+        (VariableName::GitShaShort, commit_sha.display_short()),
+        (
+            VariableName::GitRepositoryPath,
+            repository_path.to_string_lossy().into_owned(),
+        ),
+    ]);
+
+    if let Some(repository_name) = repository_name {
+        task_variables.insert(VariableName::GitRepositoryName, repository_name);
+    }
+    if let Some(ref_name) = ref_name {
+        task_variables.insert(VariableName::GitRef, ref_name.to_string());
+    }
+
+    Some(TaskContext {
+        cwd: Some(repository_path),
+        task_variables,
+        ..TaskContext::default()
+    })
+}
+
+fn git_context_menu_tasks(
+    task_context: Option<TaskContext>,
+    workspace: &WeakEntity<Workspace>,
+    cx: &App,
+) -> Vec<(project::TaskSourceKind, task::ResolvedTask)> {
+    let Some(task_context) = task_context else {
+        return Vec::new();
+    };
+    let Some(workspace) = workspace.upgrade() else {
+        return Vec::new();
+    };
+    let project = workspace.read(cx).project().clone();
+    let task_inventory = project.read_with(cx, |project, cx| {
+        project.task_store().read(cx).task_inventory().cloned()
+    });
+    let Some(task_inventory) = task_inventory else {
+        return Vec::new();
+    };
+
+    task_inventory
+        .read(cx)
+        .resolve_global_tasks_with_tag(GIT_COMMAND_TASK_TAG, &task_context)
+}