Absorb uncommitted hunks into target commits

Author: krlvi

Cargo.lock

@@ -41,6 +41,7 @@ but-graph.workspace = true
 but-workspace.workspace = true
 but-settings.workspace = true
 but-hunk-assignment.workspace = true
+but-hunk-dependency.workspace = true
 but-claude.workspace = true
 but-cursor.workspace = true
 but-tools.workspace = true

crates/but/Cargo.toml

@@ -1,4 +1,11 @@
+use std::collections::BTreeMap;
+
+use bstr::{BString, ByteSlice};
+use but_api::{diff, hex_hash::HexHash, virtual_branches};
+use but_hunk_assignment::HunkAssignment;
+use but_hunk_dependency::ui::HunkDependencies;
 use but_settings::AppSettings;
+use but_workspace::DiffSpec;
 use gitbutler_command_context::CommandContext;
 use gitbutler_project::Project;
 
@@ -26,23 +33,302 @@ pub(crate) fn handle(project: &Project, _json: bool, source: Option<&str>) -> an
                 matches!(s, CliId::UncommittedFile { .. }) || matches!(s, CliId::Branch { .. })
             })
         });
+
+    // Get all worktree changes, assignments, and dependencies
+    let worktree_changes = diff::changes_in_worktree(project.id)?;
+    let assignments = worktree_changes.assignments;
+    let dependencies = worktree_changes.dependencies;
+
     if let Some(source) = source {
         match source {
-            CliId::UncommittedFile {
-                path: _,
-                assignment: _,
-            } => {
+            CliId::UncommittedFile { path, assignment } => {
                 // Absorb this particular file
+                absorb_file(project, ctx, &path, assignment, &assignments, &dependencies)?;
             }
-            CliId::Branch { name: _ } => {
+            CliId::Branch { name } => {
                 // Absorb everything that is assigned to this lane
+                absorb_branch(project, ctx, &name, &assignments, &dependencies)?;
             }
             _ => {
-                // Invalid source - error out
+                anyhow::bail!("Invalid source: expected an uncommitted file or branch");
             }
         }
     } else {
-        // Try to absorb everhting uncommitted
+        // Try to absorb everything uncommitted
+        absorb_all(project, ctx, &assignments, &dependencies)?;
+    }
+    Ok(())
+}
+
+/// Absorb a single file into the appropriate commit
+fn absorb_file(
+    project: &Project,
+    _ctx: &mut CommandContext,
+    path: &str,
+    _assignment: Option<but_workspace::StackId>,
+    assignments: &[HunkAssignment],
+    dependencies: &Option<HunkDependencies>,
+) -> anyhow::Result<()> {
+    // Filter assignments to just this file
+    let file_assignments: Vec<_> = assignments
+        .iter()
+        .filter(|a| a.path == path)
+        .cloned()
+        .collect();
+
+    if file_assignments.is_empty() {
+        anyhow::bail!("No uncommitted changes found for file: {}", path);
+    }
+
+    // Group changes by their target commit
+    let changes_by_commit =
+        group_changes_by_target_commit(project.id, &file_assignments, dependencies)?;
+
+    // Apply each group to its target commit
+    for ((stack_id, commit_id), file_hunks) in changes_by_commit {
+        let diff_specs = convert_assignments_to_diff_specs(&file_hunks)?;
+        amend_commit(project, stack_id, commit_id, diff_specs)?;
+    }
+
+    Ok(())
+}
+
+/// Absorb all files assigned to a specific branch/stack
+fn absorb_branch(
+    project: &Project,
+    _ctx: &mut CommandContext,
+    branch_name: &str,
+    assignments: &[HunkAssignment],
+    dependencies: &Option<HunkDependencies>,
+) -> anyhow::Result<()> {
+    // Get the stack ID for this branch
+    let stacks = but_api::workspace::stacks(project.id, None)?;
+
+    // Find the stack that contains this branch
+    let stack = stacks
+        .iter()
+        .find(|s| {
+            s.heads
+                .iter()
+                .any(|h| h.name.to_str().map(|n| n == branch_name).unwrap_or(false))
+        })
+        .ok_or_else(|| anyhow::anyhow!("Branch not found: {}", branch_name))?;
+
+    let stack_id = stack.id.ok_or_else(|| anyhow::anyhow!("Stack has no ID"))?;
+
+    // Filter assignments to just this stack
+    let stack_assignments: Vec<_> = assignments
+        .iter()
+        .filter(|a| a.stack_id == Some(stack_id))
+        .cloned()
+        .collect();
+
+    if stack_assignments.is_empty() {
+        anyhow::bail!("No uncommitted changes assigned to branch: {}", branch_name);
     }
+
+    // Group changes by their target commit
+    let changes_by_commit =
+        group_changes_by_target_commit(project.id, &stack_assignments, dependencies)?;
+
+    // Apply each group to its target commit
+    for ((target_stack_id, commit_id), hunks) in changes_by_commit {
+        let diff_specs = convert_assignments_to_diff_specs(&hunks)?;
+        amend_commit(project, target_stack_id, commit_id, diff_specs)?;
+    }
+
+    Ok(())
+}
+
+/// Absorb all uncommitted changes
+fn absorb_all(
+    project: &Project,
+    _ctx: &mut CommandContext,
+    assignments: &[HunkAssignment],
+    dependencies: &Option<HunkDependencies>,
+) -> anyhow::Result<()> {
+    if assignments.is_empty() {
+        println!("No uncommitted changes to absorb");
+        return Ok(());
+    }
+
+    // Group all changes by their target commit
+    let changes_by_commit = group_changes_by_target_commit(project.id, assignments, dependencies)?;
+
+    // Apply each group to its target commit
+    for ((stack_id, commit_id), hunks) in changes_by_commit {
+        let diff_specs = convert_assignments_to_diff_specs(&hunks)?;
+        amend_commit(project, stack_id, commit_id, diff_specs)?;
+    }
+
+    Ok(())
+}
+
+/// Group changes by their target commit based on dependencies and assignments
+fn group_changes_by_target_commit(
+    project_id: gitbutler_project::ProjectId,
+    assignments: &[HunkAssignment],
+    dependencies: &Option<HunkDependencies>,
+) -> anyhow::Result<BTreeMap<(but_workspace::StackId, gix::ObjectId), Vec<HunkAssignment>>> {
+    let mut changes_by_commit: BTreeMap<
+        (but_workspace::StackId, gix::ObjectId),
+        Vec<HunkAssignment>,
+    > = BTreeMap::new();
+
+    // Process each assignment
+    for assignment in assignments {
+        // Determine the target commit for this assignment
+        let (stack_id, commit_id) = determine_target_commit(project_id, assignment, dependencies)?;
+
+        changes_by_commit
+            .entry((stack_id, commit_id))
+            .or_default()
+            .push(assignment.clone());
+    }
+
+    Ok(changes_by_commit)
+}
+
+/// Determine the target commit for an assignment based on dependencies and assignments
+fn determine_target_commit(
+    project_id: gitbutler_project::ProjectId,
+    assignment: &HunkAssignment,
+    dependencies: &Option<HunkDependencies>,
+) -> anyhow::Result<(but_workspace::StackId, gix::ObjectId)> {
+    // Priority 1: Check if there's a dependency lock for this hunk
+    if let Some(deps) = dependencies
+        && let Some(_hunk_id) = assignment.id
+    {
+        // Find the dependency for this hunk
+        for (path, _hunk, locks) in &deps.diffs {
+            // Match by path and hunk content
+            if path == &assignment.path {
+                // If there's a lock (dependency), use the topmost commit
+                if let Some(lock) = locks.first() {
+                    return Ok((lock.stack_id, lock.commit_id));
+                }
+            }
+        }
+    }
+
+    // Priority 2: Use the assignment's stack ID if available
+    if let Some(stack_id) = assignment.stack_id {
+        // We need to find the topmost commit in this stack
+        let stack_details = but_api::workspace::stack_details(project_id, Some(stack_id))?;
+
+        // Find the topmost commit in the first branch
+        if let Some(branch) = stack_details.branch_details.first()
+            && let Some(commit) = branch.commits.first()
+        {
+            return Ok((stack_id, commit.id));
+        }
+
+        // If there are no commits in the stack, create a blank commit first
+        virtual_branches::insert_blank_commit(project_id, stack_id, None, -1)?;
+
+        // Now fetch the stack details again to get the newly created commit
+        let stack_details = but_api::workspace::stack_details(project_id, Some(stack_id))?;
+        if let Some(branch) = stack_details.branch_details.first()
+            && let Some(commit) = branch.commits.first()
+        {
+            return Ok((stack_id, commit.id));
+        }
+
+        anyhow::bail!("Failed to create blank commit in stack: {:?}", stack_id);
+    }
+
+    // Priority 3: If no assignment, find the topmost commit of the leftmost lane
+    let stacks = but_api::workspace::stacks(project_id, None)?;
+    if let Some(stack) = stacks.first()
+        && let Some(stack_id) = stack.id
+    {
+        let stack_details = but_api::workspace::stack_details(project_id, Some(stack_id))?;
+
+        if let Some(branch) = stack_details.branch_details.first()
+            && let Some(commit) = branch.commits.first()
+        {
+            return Ok((stack_id, commit.id));
+        }
+
+        // If the first stack has no commits, create a blank commit first
+        virtual_branches::insert_blank_commit(project_id, stack_id, None, -1)?;
+
+        // Now fetch the stack details again to get the newly created commit
+        let stack_details = but_api::workspace::stack_details(project_id, Some(stack_id))?;
+        if let Some(branch) = stack_details.branch_details.first()
+            && let Some(commit) = branch.commits.first()
+        {
+            return Ok((stack_id, commit.id));
+        }
+
+        anyhow::bail!("Failed to create blank commit in leftmost stack");
+    }
+
+    anyhow::bail!(
+        "Unable to determine target commit for unassigned change: {}",
+        assignment.path
+    );
+}
+
+/// Convert HunkAssignments to DiffSpecs
+fn convert_assignments_to_diff_specs(
+    assignments: &[HunkAssignment],
+) -> anyhow::Result<Vec<DiffSpec>> {
+    let mut specs_by_path: BTreeMap<BString, Vec<HunkAssignment>> = BTreeMap::new();
+
+    // Group assignments by file path
+    for assignment in assignments {
+        specs_by_path
+            .entry(assignment.path_bytes.clone())
+            .or_default()
+            .push(assignment.clone());
+    }
+
+    // Convert to DiffSpecs
+    let mut diff_specs = Vec::new();
+    for (path, hunks) in specs_by_path {
+        let mut hunk_headers = Vec::new();
+        for hunk in hunks {
+            if let Some(header) = hunk.hunk_header {
+                hunk_headers.push(header);
+            }
+        }
+
+        diff_specs.push(DiffSpec {
+            previous_path: None, // TODO: Handle renames
+            path: path.clone(),
+            hunk_headers,
+        });
+    }
+
+    Ok(diff_specs)
+}
+
+/// Amend a commit with the given changes
+fn amend_commit(
+    project: &Project,
+    stack_id: but_workspace::StackId,
+    commit_id: gix::ObjectId,
+    diff_specs: Vec<DiffSpec>,
+) -> anyhow::Result<()> {
+    // Convert commit_id to HexHash
+    let hex_hash = HexHash::from(commit_id);
+
+    let outcome = but_api::workspace::amend_commit_from_worktree_changes(
+        project.id, stack_id, hex_hash, diff_specs,
+    )?;
+
+    if !outcome.paths_to_rejected_changes.is_empty() {
+        eprintln!(
+            "Warning: Failed to absorb {} file(s)",
+            outcome.paths_to_rejected_changes.len()
+        );
+    }
+
+    println!(
+        "Absorbed changes into commit {}",
+        &commit_id.to_hex().to_string()[..7]
+    );
+
     Ok(())
 }