feat(rebase): add --exec option to run commands after each patch

Add support for `stg rebase --exec <cmd>` which executes a shell command
after each patch is successfully applied during the rebase operation.
This is modeled after `git rebase --exec`.

Key changes:
- Add `exec_cmd()` method to StupidContext for running shell commands
- Add `push_patches_with_exec()` method to StackTransaction for pushing
  patches with exec commands between each push
- Add `print_exec()` method to TransactionUserInterface for output
- Add `--exec` / `-x` argument to the rebase command

The exec command is run via the user's shell ($SHELL or "sh" as fallback).
Multiple --exec options can be specified to run multiple commands in
sequence after each patch. If any command fails, the rebase halts.

Note: When an exec command fails, the entire transaction is rolled back
(no patches remain applied). This differs from git rebase --exec which
leaves you at the failing point. The rollback behavior is safer and
consistent with how stgit transactions work.

Implements: #469

Author: notactuallytreyanastasio

src/cmd/rebase.rs

@@ -88,6 +88,25 @@ fn make() -> clap::Command {
                 .action(clap::ArgAction::SetTrue),
         )
         .arg(argset::push_conflicts_arg())
+        .arg(
+            Arg::new("exec")
+                .long("exec")
+                .short('x')
+                .help("Execute command after each patch is applied")
+                .long_help(
+                    "Execute the given shell command after each patch is successfully \
+                     applied during the rebase operation. If the command fails (exits with \
+                     non-zero status), the rebase will halt.\n\
+                     \n\
+                     This option may be specified multiple times to run multiple commands \
+                     in sequence after each patch.\n\
+                     \n\
+                     This is similar to `git rebase --exec`.",
+                )
+                .action(clap::ArgAction::Append)
+                .value_name("cmd")
+                .conflicts_with_all(["nopush", "interactive"]),
+        )
 }
 
 fn run(matches: &ArgMatches) -> Result<()> {
@@ -237,13 +256,24 @@ fn run(matches: &ArgMatches) -> Result<()> {
     } else if !matches.get_flag("nopush") {
         stack.check_head_top_mismatch()?;
         let check_merged = matches.get_flag("merged");
+        let exec_cmds: Vec<String> = matches
+            .get_many::<String>("exec")
+            .map(|vals| vals.cloned().collect())
+            .unwrap_or_default();
+
         stack
             .setup_transaction()
             .use_index_and_worktree(true)
             .allow_push_conflicts(allow_push_conflicts)
             .committer_date_is_author_date(committer_date_is_author_date)
             .with_output_stream(get_color_stdout(matches))
-            .transact(|trans| trans.push_patches(&applied, check_merged))
+            .transact(|trans| {
+                if exec_cmds.is_empty() {
+                    trans.push_patches(&applied, check_merged)
+                } else {
+                    trans.push_patches_with_exec(&applied, check_merged, &exec_cmds)
+                }
+            })
             .execute("rebase (reapply)")?;
     }
 

src/stack/transaction/mod.rs

@@ -998,6 +998,59 @@ impl<'repo> StackTransaction<'repo> {
         })
     }
 
+    /// Push unapplied patches, running exec commands after each successful push.
+    ///
+    /// This is similar to `push_patches`, but after each patch is pushed successfully,
+    /// all provided exec commands are run in sequence. If any exec command fails, the
+    /// entire transaction is rolled back (no patches remain applied).
+    ///
+    /// This supports the `stg rebase --exec` functionality. Note that this differs from
+    /// `git rebase --exec` which leaves you at the failing point; stgit's behavior is
+    /// safer and consistent with how stgit transactions work.
+    pub(crate) fn push_patches_with_exec<P>(
+        &mut self,
+        patchnames: &[P],
+        check_merged: bool,
+        exec_cmds: &[String],
+    ) -> Result<()>
+    where
+        P: AsRef<PatchName>,
+    {
+        let stupid = self.stack.repo.stupid();
+        stupid.with_temp_index(|stupid_temp| {
+            let mut temp_index_tree_id: Option<gix::ObjectId> = None;
+
+            let merged = if check_merged {
+                Some(self.check_merged(patchnames, stupid_temp, &mut temp_index_tree_id)?)
+            } else {
+                None
+            };
+
+            for (i, patchname) in patchnames.iter().enumerate() {
+                let patchname = patchname.as_ref();
+                let is_last = i + 1 == patchnames.len() && exec_cmds.is_empty();
+                let already_merged = merged
+                    .as_ref()
+                    .is_some_and(|merged| merged.contains(&patchname));
+                self.push_patch(
+                    patchname,
+                    already_merged,
+                    is_last,
+                    stupid_temp,
+                    &mut temp_index_tree_id,
+                )?;
+
+                // Run exec commands after each successful push
+                for exec_cmd in exec_cmds {
+                    self.ui.print_exec(exec_cmd)?;
+                    stupid.exec_cmd(exec_cmd)?;
+                }
+            }
+
+            Ok(())
+        })
+    }
+
     fn push_patch(
         &mut self,
         patchname: &PatchName,

src/stack/transaction/ui.rs

@@ -243,6 +243,16 @@ impl TransactionUserInterface {
         Ok(())
     }
 
+    pub(super) fn print_exec(&self, cmd: &str) -> Result<()> {
+        let mut output = self.output.borrow_mut();
+        let mut color_spec = termcolor::ColorSpec::new();
+        output.set_color(color_spec.set_fg(Some(termcolor::Color::Yellow)))?;
+        write!(output, "Executing: ")?;
+        output.reset()?;
+        writeln!(output, "{cmd}")?;
+        Ok(())
+    }
+
     pub(super) fn print_updated(&self, patchname: &PatchName, applied: &[PatchName]) -> Result<()> {
         let mut output = self.output.borrow_mut();
         let (is_applied, is_top) = if let Some(pos) = applied.iter().position(|pn| pn == patchname)

src/stupid/context.rs

@@ -1317,6 +1317,35 @@ impl StupidContext<'_, '_> {
         }
     }
 
+    /// Run user-provided exec command in a shell.
+    ///
+    /// This executes the command using the user's shell (from $SHELL env var, or
+    /// "sh" as fallback), similar to how `git rebase --exec` works.
+    pub(crate) fn exec_cmd(&self, cmd: &str) -> Result<()> {
+        let shell = std::env::var("SHELL").unwrap_or_else(|_| "sh".to_string());
+        let mut command = Command::new(&shell);
+        if let Some(work_dir) = self.work_dir {
+            command.current_dir(work_dir);
+        }
+        self.setup_git_env(&mut command);
+        let status = command
+            .arg("-c")
+            .arg(cmd)
+            .stdin(Stdio::inherit())
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit())
+            .status()
+            .with_context(|| format!("could not execute `{cmd}`"))?;
+
+        if status.success() {
+            Ok(())
+        } else if let Some(code) = status.code() {
+            Err(anyhow!("`{cmd}` exited with code {code}"))
+        } else {
+            Err(anyhow!("`{cmd}` failed"))
+        }
+    }
+
     /// Run user-provided rebase command.
     pub(crate) fn user_rebase(&self, user_cmd_str: &str, target: gix::ObjectId) -> Result<()> {
         let mut args = user_cmd_str.split(|c: char| c.is_ascii_whitespace());

t/t2206-rebase-exec.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+
+test_description='Test stg rebase --exec'
+
+. ./test-lib.sh
+
+test_expect_success 'Setup stack with multiple patches' '
+    echo base >file &&
+    stg add file &&
+    git commit -m base &&
+    echo update >file2 &&
+    stg add file2 &&
+    git commit -m "add file2" &&
+    stg branch --create test-exec master~1 &&
+    stg new p1 -m "patch 1" &&
+    echo p1 >>file &&
+    stg refresh &&
+    stg new p2 -m "patch 2" &&
+    echo p2 >>file &&
+    stg refresh &&
+    stg new p3 -m "patch 3" &&
+    echo p3 >>file &&
+    stg refresh
+'
+
+test_expect_success 'Rebase with --exec runs command after each patch' '
+    rm -f exec.log &&
+    stg rebase --exec "echo EXEC >>exec.log" master &&
+    test $(stg series --applied -c) = 3 &&
+    test $(wc -l <exec.log) = 3
+'
+
+test_expect_success 'Rebase with multiple --exec options' '
+    rm -f exec.log exec2.log &&
+    stg rebase --exec "echo EXEC1 >>exec.log" --exec "echo EXEC2 >>exec2.log" master~1 &&
+    test $(stg series --applied -c) = 3 &&
+    test $(wc -l <exec.log) = 3 &&
+    test $(wc -l <exec2.log) = 3
+'
+
+test_expect_success 'Rebase with --exec halts on command failure and rolls back' '
+    rm -f exec.log out &&
+    test_must_fail stg rebase --exec "echo EXEC >>exec.log && false" master >out 2>&1 &&
+    grep -q "exited with code" out &&
+    test_line_count = 1 exec.log &&
+    test "$(stg series --applied -c)" = "0"
+'
+
+test_expect_success 'Rebase --exec conflicts with --nopush' '
+    test_must_fail stg rebase --exec "true" --nopush master 2>err &&
+    grep -q "cannot be used with" err
+'
+
+test_expect_success 'Rebase --exec conflicts with --interactive' '
+    test_must_fail stg rebase --exec "true" --interactive master 2>err &&
+    grep -q "cannot be used with" err
+'
+
+test_expect_success 'Rebase --exec can run complex shell commands' '
+    rm -f exec.log &&
+    stg push -a &&
+    stg rebase --exec "pwd && ls -la >>exec.log" master~1 &&
+    test $(stg series --applied -c) = 3 &&
+    test -f exec.log
+'
+
+test_done