BUTCLI: adds the ability to mark stack for auto assignments

Author: krlvi

Cargo.lock

@@ -292,7 +292,7 @@ pub fn list_rules(ctx: &mut CommandContext) -> anyhow::Result<Vec<WorkspaceRule>
     Ok(rules)
 }
 
-fn process_rules(ctx: &mut CommandContext) -> anyhow::Result<()> {
+pub fn process_rules(ctx: &mut CommandContext) -> anyhow::Result<()> {
     let wt_changes = but_core::diff::worktree_changes(&ctx.gix_repo()?)?;
 
     let dependencies = hunk_dependencies_for_workspace_changes_by_worktree_dir(

crates/but-rules/src/lib.rs

@@ -30,6 +30,7 @@ anyhow.workspace = true
 rmcp.workspace = true
 command-group = { version = "5.0.1", features = ["with-tokio"] }
 sysinfo = "0.36.0"
+regex = "1.11.1"
 gitbutler-project.workspace = true
 gix.workspace = true
 but-core.workspace = true
@@ -42,6 +43,7 @@ but-hunk-assignment.workspace = true
 but-hunk-dependency.workspace = true
 but-claude.workspace = true
 but-tools.workspace = true
+but-rules.workspace = true
 gitbutler-command-context.workspace = true
 gitbutler-serde.workspace = true
 gitbutler-stack.workspace = true

crates/but/Cargo.toml

@@ -42,6 +42,11 @@ For examples see `but rub --help`."
         /// The target entity to combine with the source
         target: String,
     },
+    /// Creates a rule for auto-assigning or auto-comitting
+    Mark {
+        /// The target entity that will be marked
+        target: String,
+    },
     /// Starts up the MCP server.
     Mcp {
         /// Starts the internal MCP server which has more granular tools.

crates/but/src/args.rs

@@ -14,6 +14,7 @@ use crate::id::CliId;
 pub(crate) fn commit_graph(repo_path: &Path, _json: bool) -> anyhow::Result<()> {
     let project = Project::from_path(repo_path).expect("Failed to create project from path");
     let ctx = &mut CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    but_rules::process_rules(ctx).ok(); // TODO: this is doing double work (dependencies can be reused)
     let stacks = stacks(ctx)?
         .iter()
         .filter_map(|s| s.id.map(|id| stack_details(ctx, id)))

crates/but/src/log/mod.rs

@@ -9,6 +9,7 @@ use but_claude::hooks::OutputAsJson;
 mod command;
 mod id;
 mod log;
+mod mark;
 mod mcp;
 mod mcp_internal;
 mod metrics;
@@ -98,6 +99,15 @@ async fn main() -> Result<()> {
             metrics_if_configured(app_settings, CommandName::Rub, props(start, &result)).ok();
             Ok(())
         }
+        Subcommands::Mark { target } => {
+            let result = mark::handle(&args.current_dir, args.json, target)
+                .context("Can't mark this. Taaaa-na-na-na. Can't mark this.");
+            if let Err(e) = &result {
+                eprintln!("{} {}", e, e.root_cause());
+            }
+            metrics_if_configured(app_settings, CommandName::Rub, props(start, &result)).ok();
+            Ok(())
+        }
     }
 }
 

crates/but/src/main.rs

@@ -0,0 +1,47 @@
+use std::path::Path;
+
+use crate::rub::branch_name_to_stack_id;
+use anyhow::bail;
+use but_rules::Operation;
+use but_settings::AppSettings;
+use gitbutler_command_context::CommandContext;
+use gitbutler_project::Project;
+pub(crate) fn handle(repo_path: &Path, _json: bool, target_str: &str) -> anyhow::Result<()> {
+    let project = Project::from_path(repo_path).expect("Failed to create project from path");
+    let ctx = &mut CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let target_result = crate::id::CliId::from_str(ctx, target_str)?;
+    if target_result.len() != 1 {
+        return Err(anyhow::anyhow!(
+            "Target {} is ambiguous: {:?}",
+            target_str,
+            target_result
+        ));
+    }
+    match target_result[0].clone() {
+        crate::id::CliId::Branch { name } => mark_branch(ctx, name),
+        crate::id::CliId::Commit { oid } => mark_commit(oid),
+        _ => bail!("Nope"),
+    }
+}
+
+fn mark_commit(_oid: gix::ObjectId) -> anyhow::Result<()> {
+    bail!("Not implemented yet");
+}
+
+fn mark_branch(ctx: &mut CommandContext, branch_name: String) -> anyhow::Result<()> {
+    let stack_id =
+        branch_name_to_stack_id(ctx, Some(&branch_name))?.expect("Cant find stack for this branch");
+    let action = but_rules::Action::Explicit(Operation::Assign {
+        target: but_rules::StackTarget::StackId(stack_id.to_string()),
+    });
+    let req = but_rules::CreateRuleRequest {
+        trigger: but_rules::Trigger::FileSytemChange,
+        filters: vec![but_rules::Filter::PathMatchesRegex(regex::Regex::new(
+            ".*",
+        )?)],
+        action,
+    };
+    but_rules::create_rule(ctx, req)?;
+    println!("Changes will be assigned to → {}", branch_name);
+    Ok(())
+}

crates/but/src/mark/mod.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use anyhow::bail;
+pub(crate) use assign::branch_name_to_stack_id;
 use but_settings::AppSettings;
 use colored::Colorize;
 use gitbutler_command_context::CommandContext;

crates/but/src/rub/mod.rs

@@ -15,6 +15,7 @@ use crate::id::CliId;
 pub(crate) fn worktree(repo_path: &Path, _json: bool) -> anyhow::Result<()> {
     let project = Project::from_path(repo_path).expect("Failed to create project from path");
     let ctx = &mut CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    but_rules::process_rules(ctx).ok(); // TODO: this is doing double work (dependencies can be reused)
 
     let stack_id_to_branch = crate::log::stacks(ctx)?
         .iter()