Method branch

core/src/tools/builtin/git.rs:237–280

Branch operations: list or create.

(&self, args: &serde_json::Value, git: &dyn WorkspaceGit)

    /// Branch operations: list or create.
    async fn branch(&self, args: &serde_json::Value, git: &dyn WorkspaceGit) -> Result<ToolOutput> {
        let name = args.get("name").and_then(|v| v.as_str());

        if let Some(branch_name) = name {
            let base = args.get("base").and_then(|v| v.as_str()).unwrap_or("HEAD");

            match git
                .create_branch(WorkspaceGitCreateBranchRequest {
                    name: branch_name.to_string(),
                    base: base.to_string(),
                })
                .await
            {
                Ok(_) => Ok(ToolOutput::success(format!(
                    "Created branch: {} (based on {})",
                    branch_name, base
                ))
                .with_metadata(serde_json::json!({ "branch": branch_name, "base": base }))),
                Err(e) => Ok(ToolOutput::error(format!("Failed to create branch: {e}"))),
            }
        } else {
            match git.list_branches().await {
                Ok(branches) => {
                    if branches.is_empty() {
                        return Ok(ToolOutput::success("No branches found."));
                    }

                    let entries: Vec<String> = branches
                        .iter()
                        .map(|branch| {
                            let prefix = if branch.is_current { "* " } else { "  " };
                            format!("{}{}", prefix, branch.name)
                        })
                        .collect();

                    Ok(
                        ToolOutput::success(format!("Branches:\n{}", entries.join("\n")))
                            .with_metadata(serde_json::json!({ "count": branches.len() })),
                    )
                }
                Err(e) => Ok(ToolOutput::error(format!("Failed to list branches: {e}"))),
            }
        }
    }

    /// Checkout a branch or commit.
    async fn checkout(