feat(reword): return new commit ID and message on commit

Modify the commit function to return an Option containing the new
commit ID and its message, enabling downstream processes to access
the updated commit information. Update the reword workflow to handle
this new return type and propagate the commit data.

Enhance branch rename logic to use the reworded commit ID and message
from the commit step, ensuring branch renaming uses the latest commit
details. This improves consistency and correctness in commit message
generation and branch renaming workflows.

Author: estib-vega

crates/but-action/src/generate.rs

@@ -96,6 +96,7 @@ pub struct StructuredOutput {
 pub async fn branch_name(
     client: &Client<OpenAIConfig>,
     commit_messages: &[String],
+    diffs: &[String],
     existing_branch_names: &[String],
 ) -> anyhow::Result<String> {
     let system_message =
@@ -104,18 +105,27 @@ pub async fn branch_name(
         "Generate a concise and descriptive branch name based on the provided commit messages.
         Keep the branch name short, ideally under 50 characters. Only user lowercase letters, numbers, and hyphens.
         Don't use other special characters or spaces.
-        The branche name should reflect the main content of the commit messages.
-
-        Try to make the branch name unique and noticeably different from existing branch names.
+        <important_notes>
+            The branch name should reflect the main content of the commit messages and, if available, change diffs.
+            Try to make the branch name unique and noticeably different from existing branch names.
+            Do not use any of the existing branch names.
+        </important_notes>
         
-        Here are the existing branch names:
+        <exisiting_branch_names>
         {}
+        </existing_branch_names>
 
-        Here are the commit messages:
-
-        {}",
+        <commit_messages>
+        {}
+        </commit_messages>
+        
+        <diffs>
+        {}
+        </diffs>
+        ",
         existing_branch_names.join(",\n"),
-        commit_messages.join("\n==================\n")
+        commit_messages.join("\n==================\n"),
+        diffs.join("\n==================\n")
     );
 
     let schema = schema_for!(GenerateBranchNameOutput);

crates/but-action/src/rename_branch.rs

@@ -1,13 +1,14 @@
+use std::vec;
+
 use async_openai::{Client, config::OpenAIConfig};
 use but_workspace::StackId;
 use gitbutler_command_context::CommandContext;
-use gix::bstr::BString;
 
 use crate::workflow::{self, Workflow};
 
 pub struct RenameBranchParams {
     pub commit_id: gix::ObjectId,
-    pub commit_message: BString,
+    pub commit_message: String,
     pub stack_id: StackId,
     pub current_branch_name: String,
     pub existing_branch_names: Vec<String>,
@@ -26,9 +27,16 @@ pub async fn rename_branch(
         current_branch_name,
         existing_branch_names,
     } = parameters;
-    let commit_messages = vec![commit_message.to_string()];
+
+    let repo = &ctx.gix_repo_for_merging_non_persisting()?;
+    let changes = but_core::diff::ui::commit_changes_by_worktree_dir(repo, commit_id)?;
+    let diff = changes.try_as_unidiff_string(repo, ctx.app_settings().context_lines)?;
+    let diffs = vec![diff];
+
+    let commit_messages = vec![commit_message];
     let branch_name =
-        crate::generate::branch_name(client, &commit_messages, &existing_branch_names).await?;
+        crate::generate::branch_name(client, &commit_messages, &diffs, &existing_branch_names)
+            .await?;
     let normalized_branch_name = gitbutler_reference::normalize_branch_name(&branch_name)?;
 
     let update = gitbutler_branch_actions::stack::update_branch_name(
@@ -52,8 +60,8 @@ pub async fn rename_branch(
         }),
         workflow::Trigger::Snapshot(trigger_id),
         status,
-        vec![commit_id],
-        vec![commit_id],
+        vec![],
+        vec![],
         None,
     )
     .persist(ctx)

crates/but-action/src/reword.rs

@@ -20,7 +20,10 @@ pub struct CommitEvent {
     pub trigger: Uuid,
 }
 
-pub async fn commit(client: &Client<OpenAIConfig>, event: CommitEvent) -> anyhow::Result<()> {
+pub async fn commit(
+    client: &Client<OpenAIConfig>,
+    event: CommitEvent,
+) -> anyhow::Result<Option<(gix::ObjectId, String)>> {
     let ctx = &mut CommandContext::open(&event.project, event.app_settings)?;
     let repo = &ctx.gix_repo_for_merging_non_persisting()?;
     let changes = but_core::diff::ui::commit_changes_by_worktree_dir(repo, event.commit_id)?;
@@ -49,10 +52,8 @@ pub async fn commit(client: &Client<OpenAIConfig>, event: CommitEvent) -> anyhow
         Err(e) => workflow::Status::Failed(e.to_string()),
     };
 
-    let output_commits = match &result {
-        Ok(new_commit_id) => vec![new_commit_id.to_gix()],
-        Err(_) => vec![],
-    };
+    let new_commit_id = result.map(|id| id.to_gix()).ok();
+    let output_commits = new_commit_id.map(|id| vec![id]).unwrap_or_default();
 
     Workflow::new(
         workflow::Kind::Reword(Some(workflow::RewordOutcome {
@@ -73,7 +74,7 @@ pub async fn commit(client: &Client<OpenAIConfig>, event: CommitEvent) -> anyhow
     .persist(ctx)
     .ok();
 
-    Ok(())
+    Ok(new_commit_id.map(|id| (id, message)))
 }
 
 fn stacks(ctx: &CommandContext) -> anyhow::Result<Vec<StackEntry>> {

crates/but/src/command/claude.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::io::{self, Read};
 use std::str::FromStr;
 
@@ -7,7 +8,6 @@ use but_action::{ActionHandler, OpenAiProvider, Source, reword::CommitEvent};
 use but_db::ClaudeCodeSession;
 use but_hunk_assignment::HunkAssignmentRequest;
 use but_settings::AppSettings;
-use but_workspace::ui::Commit;
 use but_workspace::{HunkHeader, StackId};
 use gitbutler_branch::BranchCreateRequest;
 use gitbutler_command_context::CommandContext;
@@ -120,10 +120,13 @@ pub(crate) async fn handle_stop() -> anyhow::Result<ClaudeHookOutput> {
     // Trigger commit message generation for newly created commits
     // TODO: Maybe this can be done in the main app process i.e. the GitButler GUI, if avaialbe
     // Alternatively, and probably better - we could spawn a new process to do this
+
     if let Some(openai_client) =
         OpenAiProvider::with(None).and_then(|provider| provider.client().ok())
     {
         for branch in &outcome.updated_branches {
+            let mut commit_message_mapping = HashMap::new();
+
             let elegibility = is_branch_eligible_for_rename(&defer, &stacks, branch)?;
 
             for commit in &branch.new_commits {
@@ -137,24 +140,39 @@ pub(crate) async fn handle_stop() -> anyhow::Result<ClaudeHookOutput> {
                         app_settings: defer.ctx.app_settings().clone(),
                         trigger: id,
                     };
-                    but_action::reword::commit(&openai_client, commit_event)
+                    let reword_result = but_action::reword::commit(&openai_client, commit_event)
                         .await
-                        .ok();
+                        .ok()
+                        .unwrap_or_default();
+
+                    // Update the commit mapping with the new commit ID
+                    if let Some(reword_result) = reword_result {
+                        commit_message_mapping.insert(commit_id, reword_result);
+                    }
                 }
             }
 
             match elegibility {
-                RenameEligibility::Eligible(commit) => {
-                    let params = RenameBranchParams {
-                        commit_id: commit.id,
-                        commit_message: commit.message,
-                        stack_id: branch.stack_id,
-                        current_branch_name: branch.branch_name.clone(),
-                        existing_branch_names: existing_branch_names.clone(),
-                    };
-                    but_action::rename_branch::rename_branch(defer.ctx, &openai_client, params, id)
+                RenameEligibility::Eligible { commit_id } => {
+                    let reword_result = commit_message_mapping.get(&commit_id).cloned();
+
+                    if let Some((commit_id, commit_message)) = reword_result {
+                        let params = RenameBranchParams {
+                            commit_id,
+                            commit_message,
+                            stack_id: branch.stack_id,
+                            current_branch_name: branch.branch_name.clone(),
+                            existing_branch_names: existing_branch_names.clone(),
+                        };
+                        but_action::rename_branch::rename_branch(
+                            defer.ctx,
+                            &openai_client,
+                            params,
+                            id,
+                        )
                         .await
                         .ok();
+                    }
                 }
                 RenameEligibility::NotEligible => {
                     // Do nothing, branch is not eligible for renaming
@@ -172,7 +190,7 @@ pub(crate) async fn handle_stop() -> anyhow::Result<ClaudeHookOutput> {
 }
 
 enum RenameEligibility {
-    Eligible(Box<Commit>),
+    Eligible { commit_id: gix::ObjectId },
     NotEligible,
 }
 
@@ -231,9 +249,9 @@ fn is_branch_eligible_for_rename(
             but_workspace::ui::PushStatus::CompletelyUnpushed
         )
     {
-        Ok(RenameEligibility::Eligible(Box::new(
-            branch_details.commits[0].clone(),
-        )))
+        Ok(RenameEligibility::Eligible {
+            commit_id: branch_head.tip,
+        })
     } else {
         Ok(RenameEligibility::NotEligible)
     }