Merge pull request #9430 from gitbutlerapp/enhance-branch-name-generation

enhance-branch-name-generation

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],
+    existing_branch_names: &[String],
 ) -> anyhow::Result<String> {
     let system_message =
         "You are a version control assistant that helps with Git branch naming.".to_string();
@@ -105,31 +106,72 @@ pub async fn branch_name(
         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.
+        
+        Here are the existing branch names:
+        {}
+
         Here are the commit messages:
 
         {}",
+        existing_branch_names.join(",\n"),
         commit_messages.join("\n==================\n")
     );
 
+    let schema = schema_for!(GenerateBranchNameOutput);
+    let schema_json = serde_json::to_value(schema)?;
+    let response_format = ResponseFormat::JsonSchema {
+        json_schema: ResponseFormatJsonSchema {
+            description: None,
+            name: "branch_name".into(),
+            schema: Some(schema_json),
+            strict: Some(false),
+        },
+    };
+
     let request = CreateChatCompletionRequestArgs::default()
         .model("gpt-4o")
         .messages([
             ChatCompletionRequestSystemMessage::from(system_message).into(),
             ChatCompletionRequestUserMessage::from(user_message).into(),
         ])
+        .response_format(response_format)
         .build()?;
 
     let response = client.chat().create(request).await?;
-    let response_string = response
+    let choice = response
         .choices
         .first()
-        .unwrap()
+        .ok_or_else(|| anyhow::anyhow!("No choices returned from OpenAI response"))?;
+
+    let response_string = choice
         .message
         .content
         .as_ref()
-        .unwrap();
+        .ok_or_else(|| anyhow::anyhow!("No content in OpenAI response message"))?;
+
+    let structured_output: GenerateBranchNameOutput = serde_json::from_str(response_string)
+        .map_err(|e| anyhow::anyhow!("Failed to parse response: {}", e))?;
 
-    Ok(response_string.trim().to_string())
+    Ok(structured_output.branch_name)
+}
+
+#[derive(serde::Serialize, serde::Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct GenerateBranchNameOutput {
+    #[schemars(description = "
+    <description>
+        The generated branch name based on the commit messages.
+    </description>
+
+    <important_notes>
+        The branch name should be concise, descriptive, and follow the naming conventions.
+        It should not contain spaces or special characters other than hyphens.
+        Return the branch name only, no backticks or quotes.
+        It should be noticeably different from existing branch names.
+    </important_notes>
+    ")]
+    pub branch_name: String,
 }
 
 const DEFAULT_COMMIT_MESSAGE_INSTRUCTIONS: &str = r#"The message should be a short summary line, followed by two newlines, then a short paragraph explaining WHY the change was needed based off the prompt.

crates/but-action/src/rename_branch.rs

@@ -5,17 +5,30 @@ use gix::bstr::BString;
 
 use crate::workflow::{self, Workflow};
 
+pub struct RenameBranchParams {
+    pub commit_id: gix::ObjectId,
+    pub commit_message: BString,
+    pub stack_id: StackId,
+    pub current_branch_name: String,
+    pub existing_branch_names: Vec<String>,
+}
+
 pub async fn rename_branch(
     ctx: &mut CommandContext,
     client: &Client<OpenAIConfig>,
-    commit_id: gix::ObjectId,
-    commit_message: BString,
-    stack_id: StackId,
-    current_branch_name: String,
+    parameters: RenameBranchParams,
     trigger_id: uuid::Uuid,
 ) -> anyhow::Result<()> {
+    let RenameBranchParams {
+        commit_id,
+        commit_message,
+        stack_id,
+        current_branch_name,
+        existing_branch_names,
+    } = parameters;
     let commit_messages = vec![commit_message.to_string()];
-    let branch_name = crate::generate::branch_name(client, &commit_messages).await?;
+    let branch_name =
+        crate::generate::branch_name(client, &commit_messages, &existing_branch_names).await?;
     let normalized_branch_name = gitbutler_reference::normalize_branch_name(&branch_name)?;
 
     let update = gitbutler_branch_actions::stack::update_branch_name(

crates/but-tools/src/workspace.rs

@@ -1177,6 +1177,8 @@ impl Tool for SquashCommits {
         <important_notes>
             This tool allows you to squash a sequence of commits in a stack into a single commit with a new message.
             Use this tool to clean up commit history before merging or sharing.
+            Always squash the commits down, meanding newer commits into their parents.
+            Remember that the commits listed in the project status are in reverse order, so the first commit in the list is the newest one.
         </important_notes>
         ".to_string()
     }

crates/but/src/command/claude.rs

@@ -2,6 +2,7 @@ use std::io::{self, Read};
 use std::str::FromStr;
 
 use anyhow::anyhow;
+use but_action::rename_branch::RenameBranchParams;
 use but_action::{ActionHandler, OpenAiProvider, Source, reword::CommitEvent};
 use but_db::ClaudeCodeSession;
 use but_hunk_assignment::HunkAssignmentRequest;
@@ -111,6 +112,10 @@ pub(crate) async fn handle_stop() -> anyhow::Result<ClaudeHookOutput> {
     )?;
 
     let stacks = crate::log::stacks(defer.ctx)?;
+    let existing_branch_names = stacks
+        .iter()
+        .flat_map(|s| s.heads.iter().map(|h| h.name.clone().to_string()))
+        .collect::<Vec<_>>();
 
     // 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
@@ -140,17 +145,16 @@ pub(crate) async fn handle_stop() -> anyhow::Result<ClaudeHookOutput> {
 
             match elegibility {
                 RenameEligibility::Eligible(commit) => {
-                    but_action::rename_branch::rename_branch(
-                        defer.ctx,
-                        &openai_client,
-                        commit.id,
-                        commit.message,
-                        branch.stack_id,
-                        branch.branch_name.clone(),
-                        id,
-                    )
-                    .await
-                    .ok();
+                    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)
+                        .await
+                        .ok();
                 }
                 RenameEligibility::NotEligible => {
                     // Do nothing, branch is not eligible for renaming