//! T3 Code's git actions in the thread details panel: one quick action
//! that fits how the branch stands (Commit, Commit & push, Commit, push &
//! PR, Push, Push & create PR, Pull, Create PR), a menu with Commit, Push
//! and Create PR, the commit dialog, and the confirmation before pushing
//! to the default branch. Commit messages and pull requests are written by
//! the text generation model when left empty.
use std::path::{Path, PathBuf};
use std::time::Instant;
use gpui_kit::component::{
Icon, IconName, WindowExt as _, checkbox::Checkbox, h_flex,
input::EditorState,
menu::{DropdownMenu as _, PopupMenuItem},
notification::Notification,
tooltip::Tooltip,
v_flex,
};
use gpui_kit::prelude::FluentBuilder as _;
use gpui_kit::*;
use super::Workspace;
use crate::git::{self, GitStatus, StatusFile};
use crate::ui::icons::Lucide;
use crate::ui::metal::{self, MetalButton, MetalStyled as _};
/// What a git action does.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GitAction {
Commit,
CommitPush,
CommitPushPr,
Push,
PushPr,
CreatePr,
Pull,
}
impl GitAction {
fn label(self) -> &'static str {
match self {
GitAction::Commit => "Commit",
GitAction::CommitPush => "Commit & push",
GitAction::CommitPushPr => "Commit, push & PR",
GitAction::Push => "Push",
GitAction::PushPr => "Push & create PR",
GitAction::CreatePr => "Create PR",
GitAction::Pull => "Pull",
}
}
fn icon(self) -> Icon {
match self {
GitAction::Commit => Icon::new(Lucide::GitCommitHorizontal),
GitAction::Push | GitAction::CommitPush => Icon::new(Lucide::CloudUpload),
GitAction::Pull => Icon::new(Lucide::CloudDownload),
GitAction::CommitPushPr | GitAction::PushPr | GitAction::CreatePr => Icon::new(Lucide::GitPullRequest),
}
}
fn commits(self) -> bool {
matches!(self, GitAction::Commit | GitAction::CommitPush | GitAction::CommitPushPr)
}
fn pushes(self) -> bool {
matches!(self, GitAction::CommitPush | GitAction::CommitPushPr | GitAction::Push | GitAction::PushPr)
}
fn opens_pr(self) -> bool {
matches!(self, GitAction::CommitPushPr | GitAction::PushPr | GitAction::CreatePr)
}
}
/// The quick action: something to run, or a label with why there's
/// nothing to run.
#[derive(Clone, Debug, PartialEq)]
pub enum Quick {
Run(GitAction),
Hint { label: &'static str, hint: &'static str },
}
/// T3 Code's choice of quick action for how the branch stands.
pub fn quick_action(status: &GitStatus, pr_open: bool) -> Quick {
let hint = |label, hint| Quick::Hint { label, hint };
if status.detached() {
return hint("Commit", "Create and checkout a ref before pushing or opening a PR.");
}
let pr_or_default = pr_open || status.on_default();
if status.has_changes() {
return Quick::Run(match () {
_ if status.upstream.is_none() && !status.has_origin => GitAction::Commit,
_ if pr_or_default => GitAction::CommitPush,
_ => GitAction::CommitPushPr,
});
}
if status.upstream.is_none() {
if !status.has_origin {
return hint("Push", "Add an \"origin\" remote before pushing.");
}
if status.ahead_of_default == 0 && pr_open {
return hint("Commit", "Branch is up to date. No action needed.");
}
if status.ahead_of_default == 0 {
return hint("Push", "No local commits to push.");
}
return Quick::Run(if pr_or_default { GitAction::Push } else { GitAction::PushPr });
}
if status.ahead > 0 && status.behind > 0 {
return hint("Sync ref", "Branch has diverged from upstream. Rebase/merge first.");
}
if status.behind > 0 {
return Quick::Run(GitAction::Pull);
}
if status.ahead > 0 {
return Quick::Run(if pr_or_default { GitAction::Push } else { GitAction::PushPr });
}
if pr_open {
return hint("Commit", "Branch is up to date. No action needed.");
}
if status.ahead_of_default > 0 && !status.on_default() {
return Quick::Run(GitAction::CreatePr);
}
hint("Commit", "Branch is up to date. No action needed.")
}
/// Why a menu action can't run now, as T3 Code says it.
fn disabled_reason(action: GitAction, status: &GitStatus, pr_open: bool) -> Option<&'static str> {
match action {
GitAction::Commit if !status.has_changes() => Some("Worktree is clean. Make changes before committing."),
GitAction::Push if status.detached() => Some("Detached HEAD: check out a branch before pushing."),
GitAction::Push if status.has_changes() => Some("Commit or stash local changes before pushing."),
GitAction::Push if status.behind > 0 => Some("Branch is behind upstream. Pull/rebase before pushing."),
GitAction::Push if !status.has_origin => Some("Add an \"origin\" remote before pushing."),
GitAction::Push if status.upstream.is_some() && status.ahead == 0 || status.upstream.is_none() && status.ahead_of_default == 0 => {
Some("No local commits to push.")
}
GitAction::CreatePr if status.detached() => Some("Detached HEAD: check out a branch before creating a PR."),
GitAction::CreatePr if status.has_changes() => Some("Commit local changes before creating a PR."),
GitAction::CreatePr if !status.has_origin => Some("Add an \"origin\" remote before creating a PR."),
GitAction::CreatePr if status.ahead_of_default == 0 => Some("No local commits to include in a PR."),
GitAction::CreatePr if status.behind > 0 => Some("Branch is behind upstream. Pull/rebase before creating a PR."),
GitAction::CreatePr if pr_open => Some("A pull request is already open."),
_ => None,
}
}
/// What a finished action reports.
struct Outcome {
title: String,
url: Option<String>,
}
/// Runs an action in `path`: commits (with `message`, or a generated one,
/// on a new feature branch when asked), pushes and opens a pull request.
/// Blocks; run it in the background.
fn run(
path: &Path,
action: GitAction,
files: Option<Vec<String>>,
message: String,
feature_branch: bool,
) -> Result<Outcome, String> {
let mut title = String::new();
if action == GitAction::Pull {
let status = git::status(path).unwrap_or_default();
let before = git::git(path, &["rev-parse", "HEAD"]).unwrap_or_default();
git::git(path, &["pull", "--ff-only"])?;
let after = git::git(path, &["rev-parse", "HEAD"]).unwrap_or_default();
let branch = status.branch.unwrap_or_default();
return Ok(Outcome {
title: if before == after {
"Already up to date".into()
} else {
format!("Pulled: updated {branch} from {}", status.upstream.unwrap_or_default())
},
url: None,
});
}
if action.commits() {
if feature_branch {
let fragment = crate::worktree::sanitize_fragment(message.lines().next().unwrap_or("update"));
let mut branch = format!("feature/{fragment}");
for n in 2.. {
if git::git(path, &["rev-parse", "--verify", "-q", &format!("refs/heads/{branch}")]).is_err() {
break;
}
branch = format!("feature/{fragment}-{n}");
}
git::git(path, &["switch", "-c", &branch])?;
}
match &files {
Some(files) => {
let mut args = vec!["add", "-A", "--"];
args.extend(files.iter().map(String::as_str));
git::git(path, &args)?;
}
None => {
git::git(path, &["add", "-A"])?;
}
}
let message = if message.trim().is_empty() {
let (summary, patch) = git::staged(path);
let branch = git::status(path).and_then(|status| status.branch);
crate::textgen::commit_message(branch.as_deref(), &summary, &patch).unwrap_or_else(|| "Update files".into())
} else {
message
};
git::git(path, &["commit", "-q", "-m", &message])?;
let sha = git::git(path, &["rev-parse", "--short", "HEAD"])?.trim().to_string();
title = format!("Committed {sha}");
}
if action.pushes() || action.opens_pr() {
let status = git::status(path).unwrap_or_default();
let branch = status.branch.clone().ok_or("Detached HEAD: check out a branch before pushing.")?;
if action.pushes() || status.upstream.is_none() {
if status.upstream.is_none() {
git::git(path, &["push", "-q", "-u", "origin", &branch])?;
} else {
git::git(path, &["push", "-q"])?;
}
let sha = git::git(path, &["rev-parse", "--short", "HEAD"])?.trim().to_string();
title = format!("Pushed {sha} to {branch}");
}
if action.opens_pr() {
let gh = crate::ui::workspace::find_program(&["gh"]).ok_or("Install the GitHub CLI (gh) to create pull requests.")?;
let base = status.default_branch.clone().unwrap_or_else(|| "main".into());
let base_ref = format!("origin/{base}");
let commits = git::git(path, &["log", "--oneline", &format!("{base_ref}..HEAD")]).unwrap_or_default();
let stat = git::git(path, &["diff", "--stat", &format!("{base_ref}...HEAD")]).unwrap_or_default();
let patch = git::git(path, &["diff", &format!("{base_ref}...HEAD")]).unwrap_or_default();
let mut command = std::process::Command::new(gh);
command.current_dir(path).args(["pr", "create", "--base", &base, "--head", &branch]);
match crate::textgen::pull_request_content(&base, &branch, &commits, &stat, &patch) {
Some((pr_title, body)) => command.args(["--title", &pr_title, "--body", &body]),
None => command.arg("--fill"),
};
let output = command.stdin(std::process::Stdio::null()).output().map_err(|err| err.to_string())?;
if !output.status.success() {
return Err(String::from_utf8_lossy(&output.stderr).trim().to_string());
}
let url = String::from_utf8_lossy(&output.stdout).lines().rev().find(|line| line.starts_with("http")).map(str::to_string);
let number = url.as_deref().and_then(|url| url.rsplit('/').next()).unwrap_or_default().to_string();
return Ok(Outcome { title: format!("Created PR #{number}"), url });
}
}
Ok(Outcome { title: if title.is_empty() { "Done".into() } else { title }, url: None })
}
impl Workspace {
/// The folder the git actions work in: the open thread's worktree, or
/// its project's checkout. `None` for a thread on another device.
fn git_path(&self, cx: &App) -> Option<PathBuf> {
let project = self.active_project()?;
if project.environment.is_some() {
return None;
}
Some(self.active_worktree(cx).unwrap_or_else(|| project.path.clone()))
}
/// Starts an action, after asking first when it would push to the
/// default branch.
pub(super) fn git_action(&mut self, action: GitAction, window: &mut Window, cx: &mut Context<Self>) {
let Some((_, status)) = self.git_status.clone() else { return };
if action == GitAction::Commit {
self.open_commit_dialog(status, window, cx);
return;
}
if (action.pushes() || action.opens_pr()) && status.on_default() {
self.confirm_default_branch(action, &status, None, window, cx);
return;
}
self.start_git_action(action, None, String::new(), false, window, cx);
}
fn start_git_action(
&mut self,
action: GitAction,
files: Option<Vec<String>>,
message: String,
feature_branch: bool,
window: &mut Window,
cx: &mut Context<Self>,
) {
let Some(path) = self.git_path(cx) else { return };
let status = match action {
GitAction::Pull => "Pulling latest changes...",
_ if action.commits() && message.trim().is_empty() => "Generating commit message...",
_ if action.commits() => "Committing...",
_ if action.pushes() => "Pushing...",
_ => "Creating pull request...",
};
self.git_running = Some((status, Instant::now()));
cx.notify();
let task = cx.background_executor().spawn({
let path = path.clone();
async move { run(&path, action, files, message, feature_branch) }
});
cx.spawn_in(window, async move |this, cx| {
let result = task.await;
let _ = this.update_in(cx, |this, window, cx| {
this.git_running = None;
match result {
Ok(outcome) => {
let mut notification = Notification::success(outcome.title.clone());
if let Some(url) = outcome.url {
notification = notification.content(move |_, _, _| {
let url = url.clone();
MetalButton::new("view-pr")
.compact()
.label("View PR")
.on_click(move |_, _, _| crate::ui::workspace::open_url(&url))
.into_any_element()
});
}
window.push_notification(notification, cx);
}
Err(err) => window.push_notification(Notification::error(err).title("Action failed"), cx),
}
this.poll_git(cx);
cx.notify();
});
})
.detach();
}
/// T3 Code's question before pushing to the default branch: go on, or
/// check out a feature branch and run the same action there.
fn confirm_default_branch(
&mut self,
action: GitAction,
status: &GitStatus,
commit: Option<(Option<Vec<String>>, String)>,
window: &mut Window,
cx: &mut Context<Self>,
) {
let branch = status.branch.clone().unwrap_or_default();
let with_commit = action.commits() || commit.is_some();
let (title, description, continue_label): (&str, String, String) = match (action.opens_pr(), with_commit) {
(false, true) => (
"Commit & push to default ref?",
"This action will commit and push changes".into(),
format!("Commit & push to {branch}"),
),
(false, false) => ("Push to default ref?", "This action will push local commits".into(), format!("Push to {branch}")),
(true, true) => (
"Commit, push & create PR from default ref?",
"This action will commit, push, and create a PR".into(),
"Commit, push & create PR".into(),
),
(true, false) => (
"Push & create PR from default ref?",
"This action will push local commits and create a PR".into(),
"Push & create PR".into(),
),
};
let description =
format!("{description} on \"{branch}\". You can continue on this ref or create a feature ref and run the same action there.");
let workspace = cx.entity().downgrade();
let (files, message) = commit.unwrap_or((None, String::new()));
window.open_dialog(cx, move |dialog, _, cx| {
let p = metal::palette(cx);
let (stay, feature) = (workspace.clone(), workspace.clone());
let (stay_files, feature_files) = (files.clone(), files.clone());
let (stay_message, feature_message) = (message.clone(), message.clone());
dialog
.w(px(576.))
.title(title)
.child(div().text_size(px(13.)).text_color(p.ink2).child(description.clone()))
.footer(
h_flex()
.w_full()
.justify_end()
.gap(px(8.))
.child(MetalButton::new("default-abort").compact().label("Abort").on_click(|_, window, cx| window.close_dialog(cx)))
.child(MetalButton::new("default-continue").compact().label(continue_label.clone()).on_click(
move |_, window, cx| {
window.close_dialog(cx);
let (files, message) = (stay_files.clone(), stay_message.clone());
let _ = stay.update(cx, |this, cx| this.start_git_action(action, files, message, false, window, cx));
},
))
.child(
MetalButton::new("default-feature")
.primary()
.compact()
.label("Check out feature branch & continue")
.on_click(move |_, window, cx| {
window.close_dialog(cx);
let (files, message) = (feature_files.clone(), feature_message.clone());
let _ = feature.update(cx, |this, cx| this.start_git_action(action, files, message, true, window, cx));
}),
),
)
});
}
/// T3 Code's commit dialog: the branch, the files (pick which with
/// Edit), and an optional message.
fn open_commit_dialog(&mut self, status: GitStatus, window: &mut Window, cx: &mut Context<Self>) {
let workspace = cx.entity().downgrade();
let dialog = cx.new(|cx| CommitDialog::new(status, workspace, window, cx));
window.open_dialog(cx, move |modal, _, _| {
let dialog = dialog.clone();
modal.w(px(560.)).title("Commit changes").child(dialog)
});
}
/// The git actions' row in the thread details panel: the quick action
/// and the menu beside it, or what's running and for how long.
pub(super) fn render_git_actions(&self, cx: &mut Context<Self>) -> AnyElement {
let p = metal::palette(cx);
let Some((_, status)) = self.git_status.clone() else {
return super::Workspace::panel_row(Lucide::GitCommitHorizontal, "Commit", p).text_color(p.ink3).into_any_element();
};
let pr_open = self.active.as_ref().and_then(|session| session.read(cx).pull_request.clone()).is_some_and(|pr| pr.is_open());
if let Some((label, started)) = self.git_running {
return h_flex()
.h(px(32.))
.px(px(10.))
.gap(px(10.))
.text_size(px(13.))
.text_color(p.ink2)
.child(metal::led("git-running", metal::Led::Live, true, p))
.child(div().flex_1().min_w_0().truncate().child(label))
.child(div().text_size(px(12.)).text_color(p.ink3).child(elapsed(started)))
.into_any_element();
}
let quick = quick_action(&status, pr_open);
let (icon, label, hint, action) = match &quick {
Quick::Run(action) => (action.icon(), action.label(), None, Some(*action)),
Quick::Hint { label, hint } => {
let icon = match *label {
"Commit" => Icon::new(Lucide::GitCommitHorizontal),
"Push" => Icon::new(Lucide::CloudUpload),
_ => Icon::new(IconName::Info),
};
(icon, *label, Some(*hint), None)
}
};
let workspace = cx.entity().downgrade();
let menu_status = status.clone();
h_flex()
.w_full()
.rounded(px(10.))
.hover(|style| style.bg(p.row_hover))
.child(
h_flex()
.id("git-quick-action")
.flex_1()
.min_w_0()
.h(px(32.))
.px(px(10.))
.gap(px(10.))
.text_size(px(13.))
.font_weight(FontWeight::MEDIUM)
.text_color(if action.is_some() { p.ink.opacity(0.8) } else { p.ink3 })
.cursor_pointer()
.child(icon.size(px(16.)).text_color(p.ink3))
.child(div().truncate().child(label))
.when_some(hint, |this, hint| {
this.tooltip(move |window, cx| Tooltip::new(hint).build(window, cx))
.on_click(move |_, window, cx| window.push_notification(Notification::info(hint).title(label), cx))
})
.when_some(action, |this, action| {
this.on_click(cx.listener(move |this, _, window, cx| this.git_action(action, window, cx)))
}),
)
.child(div().w(px(1.)).h(px(16.)).bg(p.rule))
.child(
MetalButton::new("git-action-options")
.ghost()
.mini()
.w(px(32.))
.h(px(32.))
.icon(IconName::ChevronDown)
.tooltip("Git action options")
.dropdown_menu_with_anchor(Anchor::TopRight, move |mut menu, _, _| {
for action in [GitAction::Commit, GitAction::Push, GitAction::CreatePr] {
if action != GitAction::Commit && !menu_status.has_origin {
continue;
}
if action == GitAction::CreatePr && pr_open {
continue;
}
let reason = disabled_reason(action, &menu_status, pr_open);
let workspace = workspace.clone();
menu = menu.item(
PopupMenuItem::new(action.label())
.icon(action.icon())
.disabled(reason.is_some())
.on_click(move |_, window, cx| {
let _ = workspace.update(cx, |this, cx| this.git_action(action, window, cx));
}),
);
}
if menu_status.detached() {
menu = menu.separator().label("Detached HEAD: create and check out a branch to enable push and pull request actions.");
} else if menu_status.behind > 0 {
menu = menu.separator().label("Behind upstream. Pull/rebase first.");
}
menu
}),
)
.into_any_element()
}
}
fn elapsed(started: Instant) -> String {
let secs = started.elapsed().as_secs();
if secs < 60 { format!("{secs}s") } else { format!("{}m {}s", secs / 60, secs % 60) }
}
/// The commit dialog's state.
struct CommitDialog {
status: GitStatus,
selected: Vec<bool>,
editing: bool,
message: Entity<EditorState>,
workspace: WeakEntity<Workspace>,
}
impl CommitDialog {
fn new(status: GitStatus, workspace: WeakEntity<Workspace>, window: &mut Window, cx: &mut Context<Self>) -> Self {
let message = cx.new(|cx| {
crate::ui::markdown_input::composer_state(EditorState::new(window, cx), false).placeholder("Leave empty to auto-generate")
});
let selected = vec![true; status.files.len()];
Self { status, selected, editing: false, message, workspace }
}
fn picked(&self) -> Vec<&StatusFile> {
self.status.files.iter().zip(&self.selected).filter(|(_, on)| **on).map(|(file, _)| file).collect()
}
fn commit(&mut self, feature_branch: bool, window: &mut Window, cx: &mut Context<Self>) {
let all = self.selected.iter().all(|on| *on);
let files = (!all).then(|| self.picked().into_iter().map(|file| file.path.clone()).collect::<Vec<_>>());
let message = self.message.read(cx).value().to_string();
window.close_dialog(cx);
let _ = self.workspace.update(cx, |this, cx| {
this.start_git_action(GitAction::Commit, files, message, feature_branch, window, cx)
});
}
}
impl Render for CommitDialog {
fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let p = metal::palette(cx);
let picked = self.picked();
let (added, removed) = picked.iter().fold((0, 0), |(a, r), file| (a + file.added.unwrap_or(0), r + file.removed.unwrap_or(0)));
let count = picked.len();
let total = self.status.files.len();
let on_default = self.status.on_default();
let all = self.selected.iter().all(|on| *on);
v_flex()
.gap(px(12.))
.child(
div()
.text_size(px(13.))
.text_color(p.ink2)
.child("Review and confirm your commit. Leave the message blank to auto-generate one."),
)
.child(
v_flex()
.p(px(12.))
.gap(px(8.))
.rounded(px(14.))
.well(p)
.text_size(px(13.))
.child(
h_flex()
.gap(px(8.))
.child(div().w(px(48.)).text_color(p.ink3).child("Branch"))
.child(div().flex_1().truncate().text_color(p.ink).child(self.status.branch.clone().unwrap_or_else(|| "(detached HEAD)".into())))
.when(on_default, |this| this.child(div().text_size(px(12.)).text_color(p.amber_ink).child("Default branch"))),
)
.child(
h_flex()
.gap(px(8.))
.child(div().w(px(48.)).text_color(p.ink3).child("Files"))
.child(div().flex_1().text_color(p.ink2).when(count < total, |this| this.child(format!("({count} of {total})"))))
.when(self.editing, |this| {
this.child(
Checkbox::new("commit-all")
.checked(all)
.on_click(cx.listener(move |this, _, _, cx| {
let on = !all;
this.selected.iter_mut().for_each(|selected| *selected = on);
cx.notify();
})),
)
})
.child(
MetalButton::new("commit-edit-files")
.ghost()
.mini()
.label(if self.editing { "Done" } else { "Edit" })
.on_click(cx.listener(|this, _, _, cx| {
this.editing = !this.editing;
cx.notify();
})),
),
)
.child(
v_flex()
.id("commit-files")
.max_h(px(176.))
.overflow_y_scroll()
.font_family(metal::MONO)
.text_size(px(12.))
.when(total == 0, |this| this.child(div().text_color(p.ink3).child("none")))
.children(self.status.files.iter().enumerate().map(|(ix, file)| {
let on = self.selected[ix];
h_flex()
.gap(px(8.))
.py(px(2.))
.when(self.editing, |this| {
this.child(Checkbox::new(("commit-file", ix)).checked(on).on_click(cx.listener(move |this, _, _, cx| {
this.selected[ix] = !this.selected[ix];
cx.notify();
})))
})
.child(div().flex_1().min_w_0().truncate().text_color(if on { p.ink } else { p.ink3 }).child(file.path.clone()))
.child(if on {
h_flex()
.gap(px(4.))
.child(div().text_color(metal::diff_ink(p).added).child(format!("+{}", file.added.unwrap_or(0))))
.child(div().text_color(metal::diff_ink(p).removed).child(format!("-{}", file.removed.unwrap_or(0))))
.into_any_element()
} else {
div().text_color(p.ink3).child("Excluded").into_any_element()
})
})),
)
.child(
h_flex()
.justify_end()
.gap(px(4.))
.font_family(metal::MONO)
.text_size(px(12.))
.child(div().text_color(metal::diff_ink(p).added).child(format!("+{added}")))
.child(div().text_color(p.ink3).child("/"))
.child(div().text_color(metal::diff_ink(p).removed).child(format!("-{removed}"))),
),
)
.child(
v_flex()
.gap(px(6.))
.child(div().text_size(px(12.)).font_weight(FontWeight::MEDIUM).text_color(p.ink2).child("Commit message (optional)"))
.child(
div()
.px(px(10.))
.py(px(6.))
.rounded(px(10.))
.well(p)
.text_size(px(13.))
.child(crate::ui::markdown_input::MarkdownInput::new(&self.message).rows(3, 8)),
),
)
.child(
h_flex()
.justify_end()
.gap(px(8.))
.child(MetalButton::new("commit-cancel").compact().label("Cancel").on_click(|_, window, cx| window.close_dialog(cx)))
.child(
MetalButton::new("commit-new-branch")
.compact()
.label("Commit on new branch")
.disabled(count == 0)
.on_click(cx.listener(|this, _, window, cx| this.commit(true, window, cx))),
)
.child(
MetalButton::new("commit-confirm")
.primary()
.compact()
.label("Commit")
.disabled(count == 0)
.on_click(cx.listener(|this, _, window, cx| this.commit(false, window, cx))),
),
)
}
}