but discard commit/file

Add the ability to discard a commit or file completely

Usage: 

```
but uncommit <commit-id> -d
but uncommit <committed-file-id> -d

```

Update the skills file

Author: estib-vega

crates/but/skill/references/reference.md

@@ -334,6 +334,8 @@ Uncommit changes back to unstaged area.
 ```bash
 but uncommit <commit-id>      # Uncommit entire commit
 but uncommit <file-id>        # Uncommit specific file from its commit
+but uncommit <commit-id> -d   # Discard committed changes instead of moving to unassigned
+but uncommit <file-id> --discard  # Discard committed file changes completely
 but uncommit <commit-id> --status-after  # Uncommit then show workspace status
 ```
 

crates/but/src/args/mod.rs

@@ -862,12 +862,17 @@ pub enum Subcommands {
 
     /// Uncommit changes from a commit or file-in-commit to the unstaged area.
     ///
+    /// Use `--discard` to remove the selected committed changes entirely instead.
+    ///
     /// Wrapper for `but rub <source> zz`.
     #[cfg(feature = "legacy")]
     #[clap(verbatim_doc_comment)]
     Uncommit {
         /// Commit ID or file-in-commit ID to uncommit
         source: String,
+        /// Discard the selected committed changes instead of moving them to unassigned
+        #[clap(long, short = 'd')]
+        discard: bool,
     },
 
     /// Amend a file change into a specific commit and rebases any dependent commits.

crates/but/src/command/commit/file.rs

@@ -1,5 +1,6 @@
 use anyhow::{Context as _, Result};
 use bstr::BStr;
+use bstr::ByteSlice;
 use but_core::{DiffSpec, diff::tree_changes};
 use but_ctx::Context;
 use gitbutler_branch_actions::update_workspace_commit;
@@ -13,18 +14,7 @@ pub fn commited_file_to_another_commit(
     target_id: gix::ObjectId,
     out: &mut OutputChannel,
 ) -> Result<()> {
-    let relevant_changes = {
-        let repo = ctx.repo.get()?;
-        let source_commit = repo.find_commit(source_id)?;
-        let source_commit_parent_id = source_commit.parent_ids().next().context("First parent")?;
-
-        let tree_changes = tree_changes(&repo, Some(source_commit_parent_id.detach()), source_id)?;
-        tree_changes
-            .into_iter()
-            .filter(|tc| tc.path == path)
-            .map(Into::into)
-            .collect::<Vec<DiffSpec>>()
-    };
+    let relevant_changes = changes_for_path_in_commit(ctx, path, source_id)?;
 
     but_api::commit::move_changes::commit_move_changes_between_only(
         ctx,
@@ -53,20 +43,7 @@ pub fn uncommit_file(
 ) -> Result<()> {
     // Convert target_branch to StackId if provided (for hunk assignment after uncommit)
     let assign_to = find_stack_id_for_branch(ctx, target_branch)?;
-
-    let relevant_changes = {
-        let repo = ctx.repo.get()?;
-
-        let source_commit = repo.find_commit(source_id)?;
-        let source_commit_parent_id = source_commit.parent_ids().next().context("First parent")?;
-
-        let tree_changes = tree_changes(&repo, Some(source_commit_parent_id.detach()), source_id)?;
-        tree_changes
-            .into_iter()
-            .filter(|tc| tc.path == path)
-            .map(Into::into)
-            .collect::<Vec<DiffSpec>>()
-    };
+    let relevant_changes = changes_for_path_in_commit(ctx, path, source_id)?;
 
     but_api::commit::uncommit::commit_uncommit_changes_only(
         ctx,
@@ -86,6 +63,66 @@ pub fn uncommit_file(
     Ok(())
 }
 
+pub fn uncommit_file_and_discard(
+    ctx: &mut Context,
+    path: &BStr,
+    source_id: gix::ObjectId,
+    out: &mut OutputChannel,
+    emit_output: bool,
+) -> Result<()> {
+    let relevant_changes = changes_for_path_in_commit(ctx, path, source_id)?;
+
+    let context_lines = ctx.settings.context_lines;
+    but_api::commit::uncommit::commit_uncommit_changes(
+        ctx,
+        source_id,
+        relevant_changes.clone(),
+        None,
+    )?;
+
+    let repo = ctx.repo.get()?;
+    let dropped = but_workspace::discard_workspace_changes(&repo, relevant_changes, context_lines)?;
+
+    update_workspace_commit(ctx, false)?;
+
+    if emit_output {
+        if let Some(out) = out.for_human() {
+            if !dropped.is_empty() {
+                writeln!(
+                    out,
+                    "Warning: Some changes could not be discarded (possibly already discarded or modified):"
+                )?;
+                for spec in &dropped {
+                    writeln!(out, "  {}", spec.path.as_bstr())?;
+                }
+            }
+            writeln!(out, "Discarded committed changes")?;
+        } else if let Some(out) = out.for_json() {
+            out.write_value(serde_json::json!({"ok": true}))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn changes_for_path_in_commit(
+    ctx: &Context,
+    path: &BStr,
+    source_id: gix::ObjectId,
+) -> Result<Vec<DiffSpec>> {
+    let repo = ctx.repo.get()?;
+
+    let source_commit = repo.find_commit(source_id)?;
+    let source_commit_parent_id = source_commit.parent_ids().next().context("First parent")?;
+
+    let tree_changes = tree_changes(&repo, Some(source_commit_parent_id.detach()), source_id)?;
+    Ok(tree_changes
+        .into_iter()
+        .filter(|tc| tc.path == path)
+        .map(Into::into)
+        .collect())
+}
+
 /// Determine which stack contains the target branch, if any.
 fn find_stack_id_for_branch(
     ctx: &Context,

crates/but/src/command/legacy/rub/mod.rs

@@ -18,7 +18,7 @@ use crate::{
     CliId, IdMap,
     command::commit::r#move::move_commit_to_branch,
     id::parser::{parse_sources_with_disambiguation, prompt_for_disambiguation},
-    utils::OutputChannel,
+    utils::{OutputChannel, shorten_object_id},
 };
 
 /// A description of a set of hunks.
@@ -850,6 +850,7 @@ pub(crate) fn handle_uncommit(
     ctx: &mut Context,
     out: &mut OutputChannel,
     source_str: &str,
+    discard: bool,
 ) -> anyhow::Result<()> {
     let id_map = IdMap::legacy_new_from_context(ctx, None)?;
     let sources = parse_sources_with_disambiguation(ctx, &id_map, source_str, out)?;
@@ -870,6 +871,47 @@ pub(crate) fn handle_uncommit(
         }
     }
 
+    if discard {
+        let json_mode = out.for_json().is_some();
+
+        for source in sources {
+            match source {
+                CliId::Commit { commit_id, .. } => {
+                    but_api::commit::discard_commit::commit_discard(ctx, commit_id)?;
+
+                    if !json_mode && let Some(out) = out.for_human() {
+                        let repo = ctx.repo.get()?;
+                        writeln!(
+                            out,
+                            "Discarded {}",
+                            shorten_object_id(&repo, commit_id).blue()
+                        )?;
+                    }
+                }
+                CliId::CommittedFile {
+                    path, commit_id, ..
+                } => {
+                    crate::command::commit::file::uncommit_file_and_discard(
+                        ctx,
+                        path.as_ref(),
+                        commit_id,
+                        out,
+                        !json_mode,
+                    )?;
+                }
+                _ => {
+                    unreachable!("uncommit sources were validated before execution");
+                }
+            }
+        }
+
+        if json_mode && let Some(out) = out.for_json() {
+            out.write_value(serde_json::json!({"ok": true}))?;
+        }
+
+        return Ok(());
+    }
+
     // Call the main rub handler with "zz" as target
     handle(ctx, out, source_str, "zz")
 }

crates/but/src/lib.rs

@@ -1260,7 +1260,7 @@ async fn match_subcommand(
                 .show_root_cause_error_then_exit_without_destructors(output)
         }
         #[cfg(feature = "legacy")]
-        Subcommands::Uncommit { source } => {
+        Subcommands::Uncommit { source, discard } => {
             let status_after = args.status_after;
             let mut ctx = setup::init_ctx(
                 &args,
@@ -1271,7 +1271,7 @@ async fn match_subcommand(
                 out,
             )?;
             out.begin_status_after(status_after);
-            let result = command::legacy::rub::handle_uncommit(&mut ctx, out, &source)
+            let result = command::legacy::rub::handle_uncommit(&mut ctx, out, &source, discard)
                 .context("Failed to uncommit.")
                 .emit_metrics(metrics_ctx);
             maybe_run_status_after(status_after, &result, &mut ctx, out).await;