feat: add --cleanup-backups flag for backup branch cleanup

Add `git chain rebase --cleanup-backups` to automatically delete
backup branches (backup-<chain>/<branch>) after a successful rebase.
Works with rebase, rebase --continue, and rebase --skip.

Adds cleanup_backups parameter to rebase(), rebase_continue(), and
rebase_skip() signatures, and the cleanup_backup_branches() helper
that finds and deletes matching backup branches.

Author: dashed

src/cli.rs

@@ -183,6 +183,13 @@ where
                     "skip_rebase",
                 ])
                 .takes_value(false),
+        )
+        .arg(
+            Arg::with_name("cleanup_backups")
+                .long("cleanup-backups")
+                .help("Delete backup branches after successful rebase")
+                .conflicts_with_all(&["abort_rebase", "status_rebase"])
+                .takes_value(false),
         );
 
     let push_subcommand = SubCommand::with_name("push")

src/commands.rs

@@ -258,12 +258,14 @@ pub fn run(arg_matches: ArgMatches) -> Result<(), Error> {
             };
         }
         ("rebase", Some(sub_matches)) => {
+            let cleanup_backups = sub_matches.is_present("cleanup_backups");
+
             if sub_matches.is_present("status_rebase") {
                 git_chain.rebase_status()?;
             } else if sub_matches.is_present("continue_rebase") {
-                git_chain.rebase_continue()?;
+                git_chain.rebase_continue(cleanup_backups)?;
             } else if sub_matches.is_present("skip_rebase") {
-                git_chain.rebase_skip()?;
+                git_chain.rebase_skip(cleanup_backups)?;
             } else if sub_matches.is_present("abort_rebase") {
                 git_chain.rebase_abort()?;
             } else {
@@ -291,6 +293,7 @@ pub fn run(arg_matches: ArgMatches) -> Result<(), Error> {
                         step_rebase,
                         ignore_root,
                         squashed_merge_handling,
+                        cleanup_backups,
                     )?;
                 } else {
                     eprintln!("Unable to rebase chain.");

src/git_chain/operations.rs

@@ -20,6 +20,7 @@ impl GitChain {
         step_rebase: bool,
         ignore_root: bool,
         squashed_merge_handling: SquashedRebaseHandling,
+        cleanup_backups: bool,
     ) -> Result<(), Error> {
         // Check for existing chain rebase state (not for step mode)
         if !step_rebase && state_exists(&self.repo) {
@@ -333,6 +334,9 @@ impl GitChain {
             }
             let state = read_state(&self.repo)?;
             self.print_rebase_summary(&state, num_of_rebase_operations);
+            if cleanup_backups {
+                self.cleanup_backup_branches(chain_name, &state.branches);
+            }
             let _ = delete_state(&self.repo);
         }
 
@@ -399,7 +403,7 @@ impl GitChain {
         Ok(())
     }
 
-    pub fn rebase_continue(&self) -> Result<(), Error> {
+    pub fn rebase_continue(&self, cleanup_backups: bool) -> Result<(), Error> {
         // 1. Verify state file exists
         if !state_exists(&self.repo) {
             return Err(Error::from_str(
@@ -688,6 +692,10 @@ impl GitChain {
 
         // Print summary and clean up
         self.print_rebase_summary(&state, num_of_rebase_operations);
+        let chain_name = state.chain_name.clone();
+        if cleanup_backups {
+            self.cleanup_backup_branches(&chain_name, &state.branches);
+        }
         let _ = delete_state(&self.repo);
 
         // Return to original branch
@@ -728,7 +736,7 @@ impl GitChain {
         Ok(())
     }
 
-    pub fn rebase_skip(&self) -> Result<(), Error> {
+    pub fn rebase_skip(&self, cleanup_backups: bool) -> Result<(), Error> {
         // 1. Verify state file exists
         if !state_exists(&self.repo) {
             return Err(Error::from_str(
@@ -993,6 +1001,10 @@ impl GitChain {
 
         // Print summary and clean up
         self.print_rebase_summary(&state, num_of_rebase_operations);
+        let chain_name = state.chain_name.clone();
+        if cleanup_backups {
+            self.cleanup_backup_branches(&chain_name, &state.branches);
+        }
         let _ = delete_state(&self.repo);
 
         // Return to original branch
@@ -1110,6 +1122,53 @@ impl GitChain {
         }
     }
 
+    /// Delete backup branches for a chain after successful rebase.
+    fn cleanup_backup_branches(&self, chain_name: &str, branches: &[BranchState]) {
+        let mut cleaned = 0;
+
+        for branch in branches {
+            let backup_name = format!("backup-{}/{}", chain_name, branch.name);
+            // Check if backup branch exists
+            if self.git_local_branch_exists(&backup_name).unwrap_or(false) {
+                let output = Command::new("git")
+                    .arg("branch")
+                    .arg("-D")
+                    .arg(&backup_name)
+                    .output();
+
+                match output {
+                    Ok(result) if result.status.success() => {
+                        if cleaned == 0 {
+                            println!();
+                            println!("🧹 Cleaning up backup branches...");
+                        }
+                        println!("  Deleted {}", backup_name.bold());
+                        cleaned += 1;
+                    }
+                    Ok(result) => {
+                        let stderr = String::from_utf8_lossy(&result.stderr);
+                        eprintln!(
+                            "  ⚠️  Failed to delete {}: {}",
+                            backup_name.bold(),
+                            stderr.trim()
+                        );
+                    }
+                    Err(e) => {
+                        eprintln!("  ⚠️  Failed to delete {}: {}", backup_name.bold(), e);
+                    }
+                }
+            }
+        }
+
+        if cleaned > 0 {
+            println!(
+                "  Cleaned up {} backup branch{}.",
+                cleaned,
+                if cleaned == 1 { "" } else { "es" }
+            );
+        }
+    }
+
     pub fn rebase_abort(&self) -> Result<(), Error> {
         // 1. Verify state file exists
         if !state_exists(&self.repo) {