Support 'rub uncommit' for files in commits

Add plumbing to allow uncommitting files from commits via the `rub` 
subcommand so the UI's "uncommit" action (alt-click) can call into the 
CLI.

Author: schacon

crates/but/src/id/mod.rs

@@ -87,6 +87,10 @@ impl CliId {
                 .into_iter()
                 .filter(|id| id.matches_prefix(s))
                 .for_each(|id| everything.push(id));
+            crate::status::all_committed_files(ctx)?
+                .into_iter()
+                .filter(|id| id.matches_prefix(s))
+                .for_each(|id| everything.push(id));
             crate::status::all_branches(ctx)?
                 .into_iter()
                 .filter(|id| id.matches_prefix(s))
@@ -117,6 +121,10 @@ impl CliId {
             .into_iter()
             .filter(|id| id.matches(s))
             .for_each(|id| everything.push(id));
+        crate::status::all_committed_files(ctx)?
+            .into_iter()
+            .filter(|id| id.matches(s))
+            .for_each(|id| everything.push(id));
         crate::status::all_branches(ctx)?
             .into_iter()
             .filter(|id| id.matches(s))

crates/but/src/main.rs

@@ -182,25 +182,28 @@ where
 fn print_grouped_help() {
     use clap::CommandFactory;
     use std::collections::HashSet;
-    
+
     let cmd = Args::command();
     let subcommands: Vec<_> = cmd.get_subcommands().collect();
-    
+
     // Define command groupings and their order (excluding MISC)
     let groups = [
         ("INSPECTION", vec!["log", "status"]),
-        ("STACK OPERATIONS", vec!["commit", "new", "describe", "branch"]),
+        (
+            "STACK OPERATIONS",
+            vec!["commit", "rub", "new", "describe", "branch"],
+        ),
         ("OPERATION HISTORY", vec!["oplog", "undo", "restore"]),
     ];
-    
+
     println!("A GitButler CLI tool");
     println!();
     println!("Usage: but [OPTIONS] <COMMAND>");
     println!();
-    
+
     // Keep track of which commands we've already printed
     let mut printed_commands = HashSet::new();
-    
+
     // Print grouped commands
     for (group_name, command_names) in &groups {
         println!("{}:", group_name);
@@ -213,13 +216,13 @@ fn print_grouped_help() {
         }
         println!();
     }
-    
+
     // Collect any remaining commands not in the explicit groups
     let misc_commands: Vec<_> = subcommands
         .iter()
         .filter(|subcmd| !printed_commands.contains(subcmd.get_name()) && !subcmd.is_hide_set())
         .collect();
-    
+
     // Print MISC section if there are any ungrouped commands
     if !misc_commands.is_empty() {
         println!("MISC:");
@@ -229,7 +232,7 @@ fn print_grouped_help() {
         }
         println!();
     }
-    
+
     println!("Options:");
     println!(
         "  -C, --current-dir <PATH>  Run as if gitbutler-cli was started in PATH instead of the current working directory [default: .]"

crates/but/src/rub/mod.rs

@@ -10,6 +10,7 @@ mod assign;
 mod move_commit;
 mod squash;
 mod undo;
+mod uncommit;
 
 use crate::id::CliId;
 
@@ -46,9 +47,8 @@ pub(crate) fn handle(
         (CliId::CommittedFile { .. }, CliId::CommittedFile { .. }) => {
             bail!(makes_no_sense_error(&source, &target))
         }
-        (CliId::CommittedFile { .. }, CliId::Unassigned) => {
-            // Extract file from commit to unassigned area - for now, not implemented
-            bail!("Extracting files from commits is not yet supported. Use git commands to extract file changes.")
+        (CliId::CommittedFile { path, commit_oid }, CliId::Unassigned) => {
+            uncommit::file_from_commit(ctx, path, commit_oid)
         }
         (CliId::CommittedFile { .. }, CliId::Branch { .. }) => {
             // Extract file from commit to branch - for now, not implemented  

crates/but/src/rub/uncommit.rs

@@ -0,0 +1,29 @@
+use anyhow::Result;
+use gitbutler_command_context::CommandContext;
+use colored::Colorize;
+
+pub(crate) fn file_from_commit(
+    _ctx: &CommandContext, 
+    file_path: &str, 
+    commit_oid: &gix::ObjectId
+) -> Result<()> {
+    // For now, we'll show a message about what would happen
+    // The actual implementation would need to:
+    // 1. Extract the file changes from the commit
+    // 2. Apply them to the working directory as uncommitted changes
+    // 3. Remove the file changes from the commit (creating a new commit)
+    
+    let commit_short = &commit_oid.to_string()[..7];
+    println!(
+        "Uncommitting {} from commit {}",
+        file_path.white(),
+        commit_short.blue()
+    );
+    
+    // TODO: Implement the actual uncommit logic
+    // This would involve complex Git operations similar to what the GitButler UI does
+    anyhow::bail!(
+        "Uncommitting files from commits is not yet fully implemented. \
+         Use the GitButler UI or git commands to extract file changes from commits."
+    )
+}

crates/but/src/status/mod.rs

@@ -103,6 +103,48 @@ pub(crate) fn all_branches(ctx: &CommandContext) -> anyhow::Result<Vec<CliId>> {
     Ok(branches)
 }
 
+pub(crate) fn all_committed_files(ctx: &mut CommandContext) -> anyhow::Result<Vec<CliId>> {
+    let mut committed_files = Vec::new();
+    
+    // Get stacks with detailed information
+    let stack_entries = crate::log::stacks(ctx)?;
+    let stacks: Vec<(
+        Option<but_workspace::StackId>,
+        but_workspace::ui::StackDetails,
+    )> = stack_entries
+        .iter()
+        .filter_map(|s| {
+            s.id.map(|id| (s.id, crate::log::stack_details(ctx, id)))
+                .and_then(|(stack_id, result)| result.ok().map(|details| (stack_id, details)))
+        })
+        .collect();
+
+    // Iterate through all commits in all branches to get committed files
+    for (_stack_id, stack) in &stacks {
+        for branch in &stack.branch_details {
+            // Process upstream commits
+            for commit in &branch.upstream_commits {
+                if let Ok(commit_files) = get_commit_files(ctx, commit.id) {
+                    for (file_path, _status) in commit_files {
+                        committed_files.push(CliId::committed_file(&file_path, commit.id));
+                    }
+                }
+            }
+            
+            // Process local commits  
+            for commit in &branch.commits {
+                if let Ok(commit_files) = get_commit_files(ctx, commit.id) {
+                    for (file_path, _status) in commit_files {
+                        committed_files.push(CliId::committed_file(&file_path, commit.id));
+                    }
+                }
+            }
+        }
+    }
+    
+    Ok(committed_files)
+}
+
 fn get_commit_files(ctx: &CommandContext, commit_id: gix::ObjectId) -> anyhow::Result<Vec<(String, String)>> {
     let repo = ctx.repo();
     let git2_oid = gix_to_git2_oid(commit_id);