actually commit things

The MCP server will now actually commit work. Just trying to see how to
actually run GitButler stuff via this Rust binary. Currently it will
just choose the first stack it sees and blindly commit everything with
the unmodified prompt and summary.

Author: schacon

.github/copilot-instructions.md

@@ -1,67 +1 @@
-## General information
-
-This is a monorepo with multiple projects.
-The main applications are found in the `apps` directory.
-They are:
-
-- `desktop` containing the Tauri application's frontend code
-- `web` containing the web application's frontend code
-
-The backend of the Tauri application is found in the `crates` directory.
-It contains different rust packages, all used for the Tauri application.
-
-The `packages` directory contains different self-contained npm packages.
-These are shared between the `desktop` and `web` applications.
-The packages are:
-
-- `ui` containing the shared UI components
-- `shared` containing the shared types and utils
-- `mcp` containing the Model Context Protocol packages
-- `no-relative-imports` containing the no-relative-imports ESLINT package
-
-## Version control
-
-- Use GitButler tools
-- The MCP tools require the absolute path to the repository
-- Don't use any other git commands
-
-### Absorb
-
-When told to 'absorb' follow these steps:
-
-1. If there were any instructions given, take them into account.
-2. List the file changes
-3. Get the hunk dependencies
-4. For all files that depend on a **single** commit, amend the file onto that commit. Every time a file is amended, list the hunk dependencies again.
-5. If there are no dependencies, list the stacks. Based on the stack branch names and descriptions, determine the best branch to commit the changes to.
-6. List the commits in the branch determined in the previous step, and then determine the best commit to amend the changes to based on the description. Update the description if needed.
-
-### Figure out the commits
-
-When told to 'figure out the commits' follow these steps:
-
-1. List the file changes
-2. List the stacks
-3. Figure out, based on the changes and whether there are any applied stacks/branches:
-4. Create a plan for the commits. For that, take a look at the `Create a commit plan` section below.
-5. Always execute the plan, and commit the changes as previously determined unless otherwise directed.
-
-### Creating a commit plan
-
-Follow this instructions when creating a commit plan:
-
-1. Group the file changes into logical groups
-   - Take a look at their diffs and determine if they are related.
-   - Groups are good, but prefer to have smaller commits than larger ones.
-   - Granularity is good.
-2. Determine if any branches should be created
-   - If there are any stacks with branches, take a look at the branch names and descriptions and match them with the file changes.
-   - Create multiple branches if needed. You can tell if multiple branches are needed if the file changes span multiple projects in the monorepo.
-3. Determine the commits
-   - For each group of file changes, determine the commit message. Be descriptive and explain what the changes are.
-   - If branches need to be created, use a descriptive name for the branch.
-   - Determine the order of the commits. If there are any dependencies between the commits, make sure to commit them in the correct order.
-   - Define which commits should go into which branches.
-   - If there were any other instructions given, take them into account.
-
-In the end, the plan should contain a list of the branches to be created (if any) and the commits to be made
+After every session that adds, deletes or modifies code, call the gitbutler update_branch MCP call to update the current branch and then inform the user what happened based on the output of that call.

Cargo.lock

@@ -6,6 +6,10 @@ description = "Model Context Protocol server for GitButler"
 authors = ["GitButler <gitbutler@gitbutler.com>"]
 publish = false
 
+[[bin]]
+name = "gitbutler-mcp"
+path = "src/main.rs"
+
 [dependencies]
 tokio = { version = "1", features = [
   "macros",
@@ -27,6 +31,17 @@ tracing-subscriber = { version = "0.3", features = [
   "std",
   "fmt",
 ] }
+gitbutler-oplog.workspace = true
+gitbutler-project.workspace = true
+gitbutler-reference.workspace = true
+gitbutler-branch-actions.workspace = true
+gitbutler-command-context.workspace = true
+gitbutler-branch.workspace = true
+gitbutler-diff.workspace = true
+but-settings.workspace = true
+gitbutler-stack.workspace = true
+gitbutler-oxidize.workspace = true
+gix = { workspace = true, features = ["max-performance", "tracing"] }
 
 [dev-dependencies]
 temp-dir = "0.1"

crates/gitbutler-mcp/Cargo.toml

@@ -1,47 +1,23 @@
-# GitButler MCP
+# Butler MCP
 
-A Model Context Protocol server implementation for GitButler that provides AI assistants with branch management capabilities.
+This crate implments a single binary Rust MCP server that can be pointed to by an Agent to do some basic branch management work with the GitButler tooling.
 
-## Overview
+It implements a single tool called 'update_branch' that will look at uncommitted changes in the working directory and either commit them or amend an existing commit. 
 
-`gitbutler-mcp` is a Rust crate that implements a Model Context Protocol (MCP) server for GitButler. It enables AI assistants to perform branch-related operations in GitButler repositories through standardized MCP interactions.
+If there is no existing branch, it will create a new one.
 
-## Features
+If AI capabilities are enabled, it will also use the AI to generate a commit message for the changes based on the prompt.
 
-- **Branch Management**: Update branches with summaries and prompts
-- **MCP Compliance**: Fully implements the Model Context Protocol specification
-- **Tooling Integration**: Provides tools that can be used by AI assistants
+## The Idea
 
-## Usage
+The concept is not to give an Agent an endpoint to every API that we have, which mainly results in being able to use the agent as a slow command line. The idea is to have a few very powerful tools that can be used to do a lot of work automatically. 
 
-The MCP server can be integrated with AI assistants that support the Model Context Protocol. It exposes tools that allow these assistants to:
+Most of the work should be done in GitButler for more specific tasks, but updating a branch with new work generated via agentic work can be simple and powerful.
 
-- Update branches with contextual information
-- Process prompts and convert them into branch-specific actions
+## TODO
 
-## Tool Reference
-
-### `update_branch`
-
-Updates a GitButler branch with a given prompt and summary.
-
-**Parameters:**
-- `working_directory`: Path to the Git repository
-- `full_prompt`: Complete prompt that was used for the branch update
-- `summary`: Short description of the changes
-
-## Development
-
-To run the MCP server:
-
-```bash
-cargo run -p gitbutler-mcp
-```
-
-## Integration
-
-This MCP server can be integrated with any AI assistant that supports the Model Context Protocol (MCP) specification.
-
-## License
-
-Same as the GitButler project.
+- [ ] create a new branch if there is no existing one
+- [ ] determine the actual branch name to use of everything existing
+- [ ] determine if a new virtual branch should be created
+- [ ] determine if work should be committed or amended
+- [ ] use the AI to generate a commit message

crates/gitbutler-mcp/README.md

@@ -6,6 +6,9 @@ use serde_json::json;
 use std::path::PathBuf;
 use tracing;
 
+use crate::common::commit::commit;
+use crate::common::prepare::project_from_path;
+
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct UpdateBranchRequest {
     pub working_directory: String,
@@ -47,6 +50,12 @@ impl Butler {
             ));
         }
 
+        let project = project_from_path(project_path).unwrap();
+        dbg!(&project);
+
+        let _commit = commit(project, full_prompt.clone(), summary.clone());
+        dbg!(&_commit);
+
         // In a real implementation, we would use GitButler's branch management APIs
         // But for now, we'll simulate a successful branch update
         tracing::info!(
@@ -63,6 +72,25 @@ impl Butler {
     }
 }
 
+// simple test with my working directory
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_update_branch() {
+        let butler = Butler::new();
+        let request = UpdateBranchRequest {
+            working_directory: "/Users/schacon/projects/gitbutler".to_string(),
+            full_prompt: "Update branch with new changes".to_string(),
+            summary: "Updated branch with new changes".to_string(),
+        };
+
+        let result = butler.update_branch(request);
+        dbg!(result);
+    }
+}
+
 const_string!(UpdateBranch = "updateBranch");
 
 #[tool(tool_box)]

crates/gitbutler-mcp/src/common/butler.rs

@@ -0,0 +1,76 @@
+use anyhow::{bail, Result};
+use but_settings::AppSettings;
+use gitbutler_branch::{BranchCreateRequest, BranchIdentity, BranchUpdateRequest};
+use gitbutler_branch_actions::{get_branch_listing_details, list_branches, BranchManagerExt};
+use gitbutler_command_context::CommandContext;
+use gitbutler_project::Project;
+use gitbutler_reference::{LocalRefname, Refname};
+use gitbutler_stack::{Stack, VirtualBranchesHandle};
+
+pub fn commit(project: Project, full_prompt: String, summary: String) -> Result<()> {
+    let ctx = CommandContext::open(&project, AppSettings::default())?;
+    let list_result = gitbutler_branch_actions::list_virtual_branches(&ctx)?;
+
+    // just get the first stack for now
+    let stack = VirtualBranchesHandle::new(project.gb_dir())
+        .list_stacks_in_workspace()?
+        .into_iter()
+        .next()
+        .ok_or(anyhow::anyhow!("No stacks found in the project directory"))?;
+
+    dbg!(&stack);
+
+    if !list_result.skipped_files.is_empty() {
+        eprintln!(
+            "{} files could not be processed (binary or large size)",
+            list_result.skipped_files.len()
+        )
+    }
+
+    dbg!(&list_result);
+
+    let target_branch = list_result
+        .branches
+        .iter()
+        .next()
+        .expect("A populated branch exists for a branch we can list");
+    if target_branch.ownership.claims.is_empty() {
+        bail!(
+            "Branch has no change to commit{hint}",
+            hint = {
+                let candidate_names = list_result
+                    .branches
+                    .iter()
+                    .filter_map(|b| (!b.ownership.claims.is_empty()).then_some(b.name.as_str()))
+                    .collect::<Vec<_>>();
+                let mut candidates = candidate_names.join(", ");
+                if !candidate_names.is_empty() {
+                    candidates = format!(
+                        ". {candidates} {have} changes.",
+                        have = if candidate_names.len() == 1 {
+                            "has"
+                        } else {
+                            "have"
+                        }
+                    )
+                };
+                candidates
+            }
+        )
+    }
+
+    let message = full_prompt + "\n\n" + &summary;
+    dbg!(&message);
+
+    let _oid = gitbutler_branch_actions::create_commit(
+        &ctx,
+        stack.id,
+        &message,
+        Some(&target_branch.ownership),
+    )?;
+
+    dbg!("Commit created successfully");
+    dbg!(_oid);
+
+    Ok(())
+}

crates/gitbutler-mcp/src/common/commit.rs

@@ -1 +1,3 @@
 pub mod butler;
+pub mod commit;
+pub mod prepare;

crates/gitbutler-mcp/src/common/mod.rs

@@ -0,0 +1,8 @@
+use std::path::PathBuf;
+
+use anyhow::{bail, Context};
+use gitbutler_project::Project;
+
+pub fn project_from_path(path: PathBuf) -> anyhow::Result<Project> {
+    Project::from_path(&path)
+}