stax 0.96.6

Fast stacked Git branches and PRs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::application::{NoopOperationReporter, RepositorySession};
use crate::config::Config;
use crate::git::GitRepo;
use anyhow::{Context, Result};
use colored::Colorize;
use dialoguer::{Confirm, Input, theme::ColorfulTheme};
use std::io::IsTerminal;
use std::process::Command;

/// Rename the current branch and optionally edit the commit message
pub fn run(
    new_name: Option<String>,
    edit_message: bool,
    push_remote: bool,
    literal: bool,
) -> Result<()> {
    let is_interactive = std::io::stdin().is_terminal();
    let repo = GitRepo::open()?;
    let old_name = repo.current_branch()?;
    let trunk = repo.trunk_branch()?;
    let config = Config::load()?;
    let workdir = repo.workdir()?;

    if old_name == trunk {
        anyhow::bail!("Cannot rename the trunk branch '{}'", trunk);
    }

    // Get new name
    let new_name = match new_name {
        Some(name) => {
            if literal {
                name // Use as-is without prefix
            } else {
                config.format_branch_name(&name)
            }
        }
        None => {
            if !is_interactive {
                anyhow::bail!("New branch name required in non-interactive mode");
            }
            let input: String = Input::with_theme(&ColorfulTheme::default())
                .with_prompt("New branch name")
                .interact_text()?;
            config.format_branch_name(&input)
        }
    };

    if new_name == old_name {
        println!("Branch name unchanged.");
        return Ok(());
    }

    RepositorySession::open(workdir)?.rename_branch(
        &old_name,
        &new_name,
        &mut NoopOperationReporter,
    )?;

    println!(
        "✓ Renamed branch '{}' → '{}'",
        old_name.bright_black(),
        new_name.green()
    );

    // Handle remote branch
    let remote_name = config.remote_name();
    let remote_branches =
        crate::remote::get_remote_branches(workdir, remote_name).unwrap_or_default();

    if remote_branches.contains(&old_name) {
        let should_push = if push_remote {
            true // --push flag was passed
        } else if is_interactive {
            Confirm::with_theme(&ColorfulTheme::default())
                .with_prompt(format!(
                    "Push '{}' and delete old remote '{}'?",
                    new_name, old_name
                ))
                .default(true)
                .interact()?
        } else {
            false
        };

        if should_push {
            // Push new branch
            print!("  Pushing {}... ", new_name.cyan());
            std::io::Write::flush(&mut std::io::stdout()).ok();
            let push_status = Command::new("git")
                .args(["push", "-u", remote_name, &new_name])
                .current_dir(workdir)
                .stdout(std::process::Stdio::null())
                .stderr(std::process::Stdio::null())
                .status();

            if push_status.map(|s| s.success()).unwrap_or(false) {
                println!("{}", "✓".green());
            } else {
                println!("{}", "failed".red());
            }

            // Delete old remote branch
            print!("  Deleting remote {}... ", old_name.bright_black());
            std::io::Write::flush(&mut std::io::stdout()).ok();
            let delete_status = Command::new("git")
                .args(["push", remote_name, "--delete", &old_name])
                .current_dir(workdir)
                .stdout(std::process::Stdio::null())
                .stderr(std::process::Stdio::null())
                .status();

            if delete_status.map(|s| s.success()).unwrap_or(false) {
                println!("{}", "✓".green());
            } else {
                println!("{}", "failed".red());
            }
        }
    }

    // Optionally edit commit message
    let should_edit = if edit_message {
        true
    } else if is_interactive {
        Confirm::with_theme(&ColorfulTheme::default())
            .with_prompt("Edit the commit message?")
            .default(false)
            .interact()?
    } else {
        false
    };

    if should_edit {
        let status = Command::new("git")
            .args(["commit", "--amend"])
            .current_dir(workdir)
            .status()
            .context("Failed to amend commit")?;

        if status.success() {
            println!("✓ Commit message updated");
        }
    }

    println!();
    println!(
        "Branch renamed: {} → {}",
        old_name.bright_black(),
        new_name.green().bold()
    );

    Ok(())
}