Merge pull request #11232 from Byron/next2

Single-branch support for `but branch apply`

Author: Byron

Cargo.lock

@@ -51,8 +51,13 @@ pub fn git_at_dir(dir: impl AsRef<Path>) -> std::process::Command {
 /// Run the given `script` in bash, with the `cwd` set to the `repo` worktree.
 /// Panic if the script fails.
 pub fn invoke_bash(script: &str, repo: &gix::Repository) {
+    invoke_bash_at_dir(script, repo.workdir().unwrap_or(repo.git_dir()))
+}
+/// Run the given `script` in bash, with the `cwd` set to `dir`.
+/// Panic if the script fails.
+pub fn invoke_bash_at_dir(script: &str, dir: &Path) {
     let mut cmd = std::process::Command::new("bash");
-    cmd.current_dir(repo.workdir().unwrap_or(repo.git_dir()));
+    cmd.current_dir(dir);
     isolate_env_std_cmd(&mut cmd);
     cmd.stdin(std::process::Stdio::piped())
         .stdout(std::process::Stdio::piped())

crates/but-testsupport/src/lib.rs

@@ -80,6 +80,7 @@ cli-prompts = "0.1.0"
 
 [dev-dependencies]
 but-core = { workspace = true, features = ["testing"] }
+serde_json = { workspace = true, features = ["preserve_order"] }
 but-testsupport = { workspace = true, features = ["snapbox"] }
 snapbox = { workspace = true, features = ["term-svg", "regex"] }
 shell-words = "1.1.0"

crates/but/Cargo.toml

@@ -1,7 +1,7 @@
+use crate::forge::review;
+use crate::{base, branch, forge};
 use std::path::PathBuf;
 
-use crate::forge;
-
 #[derive(Debug, clap::Parser)]
 #[clap(name = "but", about = "A GitButler CLI tool", version = option_env!("GIX_VERSION"))]
 pub struct Args {
@@ -11,6 +11,11 @@ pub struct Args {
     /// Run as if gitbutler-cli was started in PATH instead of the current working directory.
     #[clap(short = 'C', long, default_value = ".", value_name = "PATH")]
     pub current_dir: PathBuf,
+    /// Explicitly control how output should be formatted.
+    ///
+    /// If unset and from a terminal, it defaults to human output, when redirected it's for shells.
+    #[clap(long, short = 'f', env = "BUT_OUTPUT_FORMAT", conflicts_with = "json")]
+    pub format: Option<OutputFormat>,
     /// Whether to use JSON output format.
     #[clap(long, short = 'j', global = true)]
     pub json: bool,
@@ -84,9 +89,9 @@ For examples see `but rub --help`."
         repo: bool,
     },
     /// Commands for managing the base.
-    Base(crate::base::Platform),
+    Base(base::Platform),
     /// Commands for managing branches.
-    Branch(crate::branch::Platform),
+    Branch(branch::Platform),
     /// Commands for managing worktrees.
     #[clap(hide = true)]
     Worktree(crate::worktree::Platform),
@@ -198,35 +203,82 @@ For examples see `but rub --help`."
     },
 }
 
+impl Subcommands {
+    pub fn to_metrics_command(&self) -> CommandName {
+        use CommandName::*;
+        match self {
+            Subcommands::Log => Log,
+            Subcommands::Status { .. } => Status,
+            Subcommands::Stf { .. } => Stf,
+            Subcommands::Rub { .. } => Rub,
+            Subcommands::Base(base::Platform { cmd }) => match cmd {
+                base::Subcommands::Update => BaseUpdate,
+                base::Subcommands::Check => BaseCheck,
+            },
+            Subcommands::Branch(branch::Platform { cmd }) => match cmd {
+                None | Some(branch::Subcommands::List { .. }) => BranchList,
+                Some(branch::Subcommands::New { .. }) => BranchNew,
+                Some(branch::Subcommands::Delete { .. }) => BranchDelete,
+                Some(branch::Subcommands::Unapply { .. }) => BranchUnapply,
+                Some(branch::Subcommands::Apply { .. }) => BranchApply,
+            },
+            Subcommands::Worktree(crate::worktree::Platform { cmd: _ }) => Worktree,
+            Subcommands::Mark { .. } => Mark,
+            Subcommands::Unmark => Unmark,
+            Subcommands::Gui => Gui,
+            Subcommands::Commit { .. } => Commit,
+            Subcommands::Push(_) => Push,
+            Subcommands::New { .. } => New,
+            Subcommands::Describe { .. } => Describe,
+            Subcommands::Oplog { .. } => Oplog,
+            Subcommands::Restore { .. } => Restore,
+            Subcommands::Undo => Undo,
+            Subcommands::Snapshot { .. } => Snapshot,
+            Subcommands::Claude(claude::Platform { cmd }) => match cmd {
+                claude::Subcommands::PreTool => ClaudePreTool,
+                claude::Subcommands::PostTool => ClaudePostTool,
+                claude::Subcommands::Stop => ClaudeStop,
+                claude::Subcommands::Last { .. }
+                | claude::Subcommands::PermissionPromptMcp { .. } => Unknown,
+            },
+            Subcommands::Cursor(cursor::Platform { cmd }) => match cmd {
+                cursor::Subcommands::AfterEdit => CursorAfterEdit,
+                cursor::Subcommands::Stop { .. } => CursorStop,
+            },
+            Subcommands::Forge(forge::integration::Platform { cmd }) => match cmd {
+                forge::integration::Subcommands::Auth => ForgeAuth,
+                forge::integration::Subcommands::Forget { .. } => ForgeForget,
+                forge::integration::Subcommands::ListUsers => ForgeListUsers,
+            },
+            Subcommands::Review(review::Platform { cmd }) => match cmd {
+                review::Subcommands::Publish { .. } => PublishReview,
+                review::Subcommands::Template { .. } => ReviewTemplate,
+            },
+            Subcommands::Completions { .. } => Completions,
+            Subcommands::Absorb { .. } => Absorb,
+            Subcommands::Metrics { .. }
+            | Subcommands::Actions(_)
+            | Subcommands::Mcp { .. }
+            | Subcommands::Init { .. } => Unknown,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, clap::ValueEnum, Default)]
 pub enum CommandName {
-    #[clap(alias = "log")]
     Log,
-    #[clap(alias = "absorb")]
     Absorb,
-    #[clap(alias = "st")]
     Status,
-    #[clap(alias = "stf", hide = true)]
     Stf,
-    #[clap(alias = "rub")]
     Rub,
-    #[clap(alias = "commit")]
     Commit,
-    #[clap(alias = "push")]
     Push,
-    #[clap(alias = "new")]
     New,
-    #[clap(alias = "describe")]
     Describe,
-    #[clap(alias = "oplog")]
     Oplog,
-    #[clap(alias = "restore")]
     Restore,
-    #[clap(alias = "undo")]
     Undo,
-    #[clap(alias = "snapshot")]
     Snapshot,
-    #[clap(alias = "gui")]
     Gui,
     BaseCheck,
     BaseUpdate,
@@ -235,40 +287,10 @@ pub enum CommandName {
     BranchList,
     BranchUnapply,
     BranchApply,
-    #[clap(
-        alias = "claude-pre-tool",
-        alias = "claudepretool",
-        alias = "claudePreTool",
-        alias = "ClaudePreTool"
-    )]
     ClaudePreTool,
-    #[clap(
-        alias = "claude-post-tool",
-        alias = "claudeposttool",
-        alias = "claudePostTool",
-        alias = "ClaudePostTool"
-    )]
     ClaudePostTool,
-    #[clap(
-        alias = "claude-stop",
-        alias = "claudestop",
-        alias = "claudeStop",
-        alias = "ClaudeStop"
-    )]
     ClaudeStop,
-    #[clap(
-        alias = "cursor-after-edit",
-        alias = "cursorafteredit",
-        alias = "cursorAfterEdit",
-        alias = "CursorAfterEdit"
-    )]
     CursorAfterEdit,
-    #[clap(
-        alias = "cursor-stop",
-        alias = "cursorstop",
-        alias = "cursorStop",
-        alias = "CursorStop"
-    )]
     CursorStop,
     Worktree,
     Mark,
@@ -283,6 +305,18 @@ pub enum CommandName {
     Unknown,
 }
 
+/// How to format the output.
+#[derive(Debug, Clone, Copy, clap::ValueEnum, Default)]
+pub enum OutputFormat {
+    /// Produce verbose output for human consumption.
+    #[default]
+    Human,
+    /// The output is optimised for variable assignment in shells.
+    Shell,
+    /// Output detailed information as JSON for tool consumption.
+    Json,
+}
+
 pub mod actions {
     #[derive(Debug, clap::Parser)]
     pub struct Platform {

crates/but/src/args.rs

@@ -1,6 +1,9 @@
+use crate::utils::{Output, OutputFormat};
 use anyhow::bail;
 use bstr::ByteSlice;
 use gitbutler_reference::RemoteRefname;
+use gix::reference::Category;
+use std::io::Write;
 use std::{ops::Deref, str::FromStr};
 
 /// Apply a branch to the workspace, and return the full ref name to it.
@@ -9,7 +12,7 @@ use std::{ops::Deref, str::FromStr};
 pub fn apply(
     ctx: &but_ctx::Context,
     branch_name: &str,
-    json: bool,
+    out: &mut Output,
 ) -> anyhow::Result<but_api::json::Reference> {
     let legacy_project = &ctx.legacy_project;
     let ctx = ctx.legacy_ctx()?;
@@ -32,9 +35,6 @@ pub fn apply(
             remote_ref_name,
             None,
         )?;
-        if !json {
-            println!("Applied branch '{branch_name}' to workspace");
-        }
         reference
     } else if let Some((remote_ref, reference)) = find_remote_reference(&repo, branch_name)? {
         let remote = remote_ref.remote();
@@ -48,14 +48,30 @@ pub fn apply(
             Some(remote_ref.clone()),
             None,
         )?;
-        if !json {
-            println!("Applied remote branch '{branch_name}' to workspace");
-        }
         reference
     } else {
         bail!("Could not find branch '{branch_name}' in local repository");
     };
 
+    match out.format {
+        OutputFormat::Human => {
+            let short_name = reference.name().shorten();
+            let is_remote_reference = reference
+                .name()
+                .category()
+                .is_some_and(|c| c == Category::RemoteBranch);
+            if is_remote_reference {
+                writeln!(out, "Applied remote branch '{short_name}' to workspace")
+            } else {
+                writeln!(out, "Applied branch '{short_name}' to workspace")
+            }
+            .ok();
+        }
+        OutputFormat::Shell => {
+            writeln!(out, "{reference_name}", reference_name = reference.name())?;
+        }
+    }
+
     Ok(reference.inner.into())
 }
 

crates/but/src/branch/apply.rs

@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use crate::we_need_proper_json_output_here;
+use crate::utils::we_need_proper_json_output_here;
 use colored::Colorize;
 use gitbutler_branch_actions::BranchListingFilter;
 use gitbutler_project::Project;

crates/but/src/branch/list.rs

@@ -1,6 +1,6 @@
-use crate::{LegacyProject, into_json_value, we_need_proper_json_output_here};
+use crate::LegacyProject;
+use crate::utils::{Output, OutputFormat, into_json_value, we_need_proper_json_output_here};
 use anyhow::bail;
-use atty::Stream;
 use but_core::ref_metadata::StackId;
 use but_settings::AppSettings;
 use but_workspace::legacy::ui::StackEntry;
@@ -70,9 +70,8 @@ pub enum Subcommands {
 pub async fn handle(
     cmd: Option<Subcommands>,
     ctx: &but_ctx::Context,
-    json: bool,
+    out: &mut Output,
 ) -> anyhow::Result<serde_json::Value> {
-    let mut stdout = io::stdout();
     let legacy_project = &ctx.legacy_project;
     match cmd {
         None => {
@@ -147,18 +146,19 @@ pub async fn handle(
                 },
             )?;
 
-            if json {
-                let response = json::BranchNewOutput {
-                    branch: branch_name,
-                    anchor: anchor_for_json,
-                };
-                writeln!(stdout, "{}", serde_json::to_string_pretty(&response)?)?;
-            } else if atty::is(Stream::Stdout) {
-                writeln!(stdout, "Created branch {branch_name}").ok();
-            } else {
-                writeln!(stdout, "{branch_name}").ok();
+            let json = json::BranchNewOutput {
+                branch: branch_name.clone(),
+                anchor: anchor_for_json,
+            };
+            match out.format {
+                OutputFormat::Human => {
+                    writeln!(out, "Created branch {branch_name}").ok();
+                }
+                OutputFormat::Shell => {
+                    writeln!(out, "{branch_name}").ok();
+                }
             }
-            Ok(we_need_proper_json_output_here())
+            Ok(into_json_value(json))
         }
         Some(Subcommands::Delete { branch_name, force }) => {
             let stacks = but_api::workspace::stacks(
@@ -178,11 +178,11 @@ pub async fn handle(
                 }
             }
 
-            writeln!(stdout, "Branch '{}' not found in any stack", branch_name).ok();
+            writeln!(out, "Branch '{}' not found in any stack", branch_name).ok();
             Ok(we_need_proper_json_output_here())
         }
         Some(Subcommands::Apply { branch_name }) => {
-            apply::apply(ctx, &branch_name, json).map(into_json_value)
+            apply::apply(ctx, &branch_name, out).map(into_json_value)
         }
         Some(Subcommands::Unapply { branch_name, force }) => {
             let stacks = but_api::workspace::stacks(
@@ -202,7 +202,7 @@ pub async fn handle(
                 }
             }
 
-            writeln!(stdout, "Branch '{}' not found in any stack", branch_name).ok();
+            writeln!(out, "Branch '{}' not found in any stack", branch_name).ok();
             Ok(we_need_proper_json_output_here())
         }
     }