add merge pr to interactive mode

Author: ozankasikci

CHANGELOG.md

@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file. This format
 ## [0.5.3] - 2025-09-28
 
 ### Added
-- Improve interactive ui/ux.
+- Improve interactive UI/UX with a merge PR action and configurable cleanup prompts.
 
 ## [0.5.1] - 2025-09-27
 

README.md

@@ -21,6 +21,8 @@
 
 - Open a terminal UI for browsing worktrees, focusing actions, and inspecting details without memorizing subcommands.
 - Launch it with the `interactive` command: `rsworktree interactive` (shortcut: `rsworktree i`).
+- Available actions include opening worktrees, removing them, creating PRs, and merging PRs without leaving the TUI.
+- The merge flow lets you decide whether to keep the local branch, delete the remote branch, and clean up the worktree before exiting.
 - ![Interactive mode screenshot](tapes/gifs/interactive-mode.gif)
 
 ## CLI commands

src/commands/interactive/command.rs

@@ -15,7 +15,7 @@ use ratatui::{
 
 use super::{
     Action, EventSource, Focus, Selection, StatusMessage, WorktreeEntry,
-    dialog::{CreateDialog, CreateDialogFocus, Dialog},
+    dialog::{CreateDialog, CreateDialogFocus, Dialog, MergeDialog, MergeDialogFocus},
     view::{DetailData, DialogView, Snapshot},
 };
 
@@ -152,6 +152,14 @@ where
                     }
                     return Ok(LoopControl::Continue);
                 }
+                Dialog::Merge(_) => {
+                    if let Event::Key(key) = event {
+                        if key.kind == KeyEventKind::Press {
+                            return self.handle_merge_dialog_key(key);
+                        }
+                    }
+                    return Ok(LoopControl::Continue);
+                }
             }
         }
 
@@ -286,6 +294,13 @@ where
                         }
                         self.status = Some(StatusMessage::info("No worktree selected."));
                     }
+                    Action::MergePrGithub => {
+                        if let Some(index) = self.selected {
+                            self.dialog = Some(Dialog::Merge(MergeDialog::new(index)));
+                        } else {
+                            self.status = Some(StatusMessage::info("No worktree selected."));
+                        }
+                    }
                 }
             }
             Focus::GlobalActions => match self.global_action_selected {
@@ -474,6 +489,89 @@ where
         Ok(())
     }
 
+    fn handle_merge_dialog_key(&mut self, key: KeyEvent) -> Result<LoopControl> {
+        let dialog_option = self.dialog.take();
+        let Some(Dialog::Merge(mut dialog)) = dialog_option else {
+            self.dialog = dialog_option;
+            return Ok(LoopControl::Continue);
+        };
+
+        let mut reinstate = true;
+        let mut outcome = LoopControl::Continue;
+
+        match key.code {
+            KeyCode::Esc => {
+                reinstate = false;
+                self.status = Some(StatusMessage::info("Merge cancelled."));
+            }
+            KeyCode::Tab => dialog.focus_next(),
+            KeyCode::BackTab => dialog.focus_prev(),
+            KeyCode::Up | KeyCode::Char('k') => match dialog.focus {
+                MergeDialogFocus::Options => dialog.move_option(-1),
+                MergeDialogFocus::Buttons => dialog.focus = MergeDialogFocus::Options,
+            },
+            KeyCode::Down | KeyCode::Char('j') => match dialog.focus {
+                MergeDialogFocus::Options => dialog.move_option(1),
+                MergeDialogFocus::Buttons => {}
+            },
+            KeyCode::Left => {
+                if dialog.focus == MergeDialogFocus::Buttons {
+                    dialog.move_button(-1);
+                }
+            }
+            KeyCode::Right => {
+                if dialog.focus == MergeDialogFocus::Buttons {
+                    dialog.move_button(1);
+                }
+            }
+            KeyCode::Char(' ') => {
+                if dialog.focus == MergeDialogFocus::Options {
+                    dialog.toggle_selected_option();
+                }
+            }
+            KeyCode::Enter => match dialog.focus {
+                MergeDialogFocus::Options => dialog.toggle_selected_option(),
+                MergeDialogFocus::Buttons => {
+                    if dialog.buttons_selected == 0 {
+                        reinstate = false;
+                        self.status = Some(StatusMessage::info("Merge cancelled."));
+                    } else {
+                        match self.build_merge_selection(&dialog) {
+                            Some(selection) => {
+                                reinstate = false;
+                                outcome = LoopControl::Exit(Some(selection));
+                            }
+                            None => {
+                                reinstate = false;
+                                self.status = Some(StatusMessage::error(
+                                    "Selected worktree no longer exists.",
+                                ));
+                            }
+                        }
+                    }
+                }
+            },
+            _ => {}
+        }
+
+        if reinstate {
+            self.dialog = Some(Dialog::Merge(dialog));
+        }
+
+        Ok(outcome)
+    }
+
+    fn build_merge_selection(&self, dialog: &MergeDialog) -> Option<Selection> {
+        self.worktrees
+            .get(dialog.index)
+            .map(|entry| Selection::MergePrGithub {
+                name: entry.name.clone(),
+                remove_local_branch: dialog.remove_local_branch(),
+                remove_remote_branch: dialog.remove_remote_branch(),
+                remove_worktree: dialog.remove_worktree(),
+            })
+    }
+
     fn submit_create<G>(
         &mut self,
         dialog: &mut CreateDialog,
@@ -680,6 +778,14 @@ where
             }
             Some(Dialog::Info { message }) => Some(DialogView::Info { message }),
             Some(Dialog::Create(dialog)) => Some(DialogView::Create(dialog.into())),
+            Some(Dialog::Merge(dialog)) => {
+                self.worktrees
+                    .get(dialog.index)
+                    .map(|entry| DialogView::Merge {
+                        name: entry.name.clone(),
+                        dialog: dialog.into(),
+                    })
+            }
             None => None,
         };
 

src/commands/interactive/dialog.rs

@@ -189,9 +189,119 @@ impl CreateDialogView {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum MergeDialogFocus {
+    Options,
+    Buttons,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct MergeDialog {
+    pub(crate) index: usize,
+    pub(crate) focus: MergeDialogFocus,
+    pub(crate) options_selected: usize,
+    pub(crate) buttons_selected: usize,
+    pub(crate) remove_local_branch: bool,
+    pub(crate) remove_remote_branch: bool,
+    pub(crate) remove_worktree: bool,
+}
+
+impl MergeDialog {
+    const OPTION_COUNT: usize = 3;
+    const BUTTON_COUNT: usize = 2;
+
+    pub(crate) fn new(index: usize) -> Self {
+        Self {
+            index,
+            focus: MergeDialogFocus::Options,
+            options_selected: 0,
+            buttons_selected: 1,
+            remove_local_branch: true,
+            remove_remote_branch: false,
+            remove_worktree: false,
+        }
+    }
+
+    pub(crate) fn focus_next(&mut self) {
+        self.focus = match self.focus {
+            MergeDialogFocus::Options => MergeDialogFocus::Buttons,
+            MergeDialogFocus::Buttons => MergeDialogFocus::Options,
+        };
+    }
+
+    pub(crate) fn focus_prev(&mut self) {
+        self.focus_next();
+    }
+
+    pub(crate) fn move_option(&mut self, delta: isize) {
+        let len = Self::OPTION_COUNT as isize;
+        let current = self.options_selected as isize;
+        let next = (current + delta).rem_euclid(len);
+        self.options_selected = next as usize;
+    }
+
+    pub(crate) fn move_button(&mut self, delta: isize) {
+        let len = Self::BUTTON_COUNT as isize;
+        let current = self.buttons_selected as isize;
+        let next = (current + delta).rem_euclid(len);
+        self.buttons_selected = next as usize;
+    }
+
+    pub(crate) fn toggle_selected_option(&mut self) {
+        match self.options_selected {
+            0 => self.remove_local_branch = !self.remove_local_branch,
+            1 => self.remove_remote_branch = !self.remove_remote_branch,
+            2 => self.remove_worktree = !self.remove_worktree,
+            _ => {}
+        }
+    }
+
+    pub(crate) fn remove_local_branch(&self) -> bool {
+        self.remove_local_branch
+    }
+
+    pub(crate) fn remove_remote_branch(&self) -> bool {
+        self.remove_remote_branch
+    }
+
+    pub(crate) fn remove_worktree(&self) -> bool {
+        self.remove_worktree
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct MergeDialogView {
+    pub(crate) focus: MergeDialogFocus,
+    pub(crate) options_selected: usize,
+    pub(crate) buttons_selected: usize,
+    pub(crate) remove_local_branch: bool,
+    pub(crate) remove_remote_branch: bool,
+    pub(crate) remove_worktree: bool,
+}
+
+impl From<&MergeDialog> for MergeDialogView {
+    fn from(dialog: &MergeDialog) -> Self {
+        Self {
+            focus: dialog.focus,
+            options_selected: dialog.options_selected,
+            buttons_selected: dialog.buttons_selected,
+            remove_local_branch: dialog.remove_local_branch,
+            remove_remote_branch: dialog.remove_remote_branch,
+            remove_worktree: dialog.remove_worktree,
+        }
+    }
+}
+
+impl From<MergeDialog> for MergeDialogView {
+    fn from(dialog: MergeDialog) -> Self {
+        Self::from(&dialog)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) enum Dialog {
     ConfirmRemove { index: usize },
     Info { message: String },
     Create(CreateDialog),
+    Merge(MergeDialog),
 }

src/commands/interactive/mod.rs

@@ -42,6 +42,12 @@ pub(crate) const GLOBAL_ACTIONS: [&str; 2] = ["Create worktree", "Cd to root dir
 pub(crate) enum Selection {
     Worktree(String),
     PrGithub(String),
+    MergePrGithub {
+        name: String,
+        remove_local_branch: bool,
+        remove_remote_branch: bool,
+        remove_worktree: bool,
+    },
     RepoRoot,
 }
 
@@ -50,21 +56,31 @@ pub(crate) enum Action {
     Open,
     Remove,
     PrGithub,
+    MergePrGithub,
 }
 
 impl Action {
-    pub(crate) const ALL: [Action; 3] = [Action::Open, Action::Remove, Action::PrGithub];
+    pub(crate) const ALL: [Action; 4] = [
+        Action::Open,
+        Action::Remove,
+        Action::PrGithub,
+        Action::MergePrGithub,
+    ];
 
     pub(crate) fn label(self) -> &'static str {
         match self {
             Action::Open => "Open",
             Action::Remove => "Remove",
             Action::PrGithub => "PR (GitHub)",
+            Action::MergePrGithub => "Merge PR (GitHub)",
         }
     }
 
     pub(crate) fn requires_selection(self) -> bool {
-        matches!(self, Action::Open | Action::Remove | Action::PrGithub)
+        matches!(
+            self,
+            Action::Open | Action::Remove | Action::PrGithub | Action::MergePrGithub
+        )
     }
 
     pub(crate) fn from_index(index: usize) -> Self {

src/commands/interactive/runtime.rs

@@ -14,6 +14,7 @@ use crate::{
         cd::{CdCommand, shell_command},
         create::{CreateCommand, CreateOutcome},
         list::{find_worktrees, format_worktree},
+        merge_pr_github::MergePrGithubCommand,
         pr_github::{PrGithubCommand, PrGithubOptions},
         rm::RemoveCommand,
     },
@@ -115,6 +116,26 @@ pub fn run(repo: &Repo) -> Result<()> {
                 let mut command = PrGithubCommand::new(options);
                 command.execute(repo)?;
             }
+            Selection::MergePrGithub {
+                name,
+                remove_local_branch,
+                remove_remote_branch,
+                remove_worktree,
+            } => {
+                let mut command = MergePrGithubCommand::new(name.clone());
+                if !remove_local_branch {
+                    command.disable_remove_local();
+                }
+                if remove_remote_branch {
+                    command.enable_remove_remote();
+                }
+                command.execute(repo)?;
+
+                if remove_worktree {
+                    let remove_command = RemoveCommand::new(name, false);
+                    remove_command.execute(repo)?;
+                }
+            }
         }
     }