feat(git): implement missing backend commands for git-graph SDK

Add 7 missing Rust backend commands invoked by src/sdk/git-graph.ts:

- git_checkout: checkout a branch, tag, or commit (branch.rs)
- git_create_branch: create a new branch with optional start point (branch.rs)
- git_delete_branch: delete a local branch with optional force flag (branch.rs)
- git_reset: reset HEAD to a commit with soft/mixed/hard mode (branch.rs)
- git_revert: revert a commit with conflict handling (branch.rs)
- git_cherry_pick: cherry-pick a single commit with conflict handling (cherry_pick.rs)
- git_rebase: simple non-interactive rebase onto a target (rebase.rs)

Also adds:
- git_get_commit_graph registration (existed in graph.rs but was unregistered)
- git_get_commit_details command and supporting types (CommitDetails,
  CommitPerson, CommitDetailRef, CommitDiffStat, CommitDetailFile)
- first_parent field to GraphOptions struct

Fixes frontend SDK (git-graph.ts) to use correct existing command names
(git_branches instead of git_get_branches, git_list_tags instead of
git_get_tags) and camelCase parameter naming for Tauri v2 auto-conversion.

Fixes CommitComparison struct serialization by adding
serde(rename_all = "camelCase") so files_changed serializes as filesChanged
matching frontend expectations in both git-graph.ts and tauri-api.ts.

Author: echobt

src-tauri/src/app/git_commands.rs

@@ -33,6 +33,9 @@ macro_rules! git_commands {
             $crate::git::log::git_compare_commits,
             $crate::git::log::git_commit_graph,
             $crate::git::log::git_log_graph,
+            // Git graph commands
+            $crate::git::graph::git_get_commit_graph,
+            $crate::git::log::git_get_commit_details,
             // Git stash commands
             $crate::git::stash::git_stashes,
             $crate::git::stash::git_stash_list,
@@ -58,12 +61,14 @@ macro_rules! git_commands {
             $crate::git::bisect::git_bisect_reset,
             // Git cherry-pick commands
             $crate::git::cherry_pick::git_commit_files,
+            $crate::git::cherry_pick::git_cherry_pick,
             $crate::git::cherry_pick::git_cherry_pick_status,
             $crate::git::cherry_pick::git_cherry_pick_start,
             $crate::git::cherry_pick::git_cherry_pick_continue,
             $crate::git::cherry_pick::git_cherry_pick_skip,
             $crate::git::cherry_pick::git_cherry_pick_abort,
             // Git rebase commands
+            $crate::git::rebase::git_rebase,
             $crate::git::rebase::git_rebase_commits,
             $crate::git::rebase::git_rebase_status,
             $crate::git::rebase::git_rebase_start,
@@ -137,6 +142,11 @@ macro_rules! git_commands {
             $crate::git::branch::git_branch_rename,
             $crate::git::branch::git_reset_soft,
             $crate::git::branch::git_clean,
+            $crate::git::branch::git_checkout,
+            $crate::git::branch::git_create_branch,
+            $crate::git::branch::git_delete_branch,
+            $crate::git::branch::git_reset,
+            $crate::git::branch::git_revert,
             // Git repository watcher
             $crate::git::watcher::git_watch_repository,
             // Git line staging

src-tauri/src/git/branch.rs

@@ -174,6 +174,150 @@ pub async fn git_clean(path: String, files: Option<Vec<String>>) -> Result<(), S
     .map_err(|e| format!("Task join error: {}", e))?
 }
 
+/// Checkout a branch, tag, or commit
+#[tauri::command]
+pub async fn git_checkout(path: Option<String>, r#ref: String) -> Result<(), String> {
+    let path = path.unwrap_or_else(|| ".".to_string());
+    tokio::task::spawn_blocking(move || {
+        let repo_root = get_repo_root(&path)?;
+        let repo_root_path = Path::new(&repo_root);
+
+        let output = git_command_with_timeout(&["checkout", &r#ref], repo_root_path)?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(format!("Failed to checkout '{}': {}", r#ref, stderr));
+        }
+
+        info!("[Git] Checked out '{}'", r#ref);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+}
+
+/// Create a new branch
+#[tauri::command]
+pub async fn git_create_branch(
+    path: Option<String>,
+    name: String,
+    start_point: Option<String>,
+) -> Result<(), String> {
+    let path = path.unwrap_or_else(|| ".".to_string());
+    tokio::task::spawn_blocking(move || {
+        let repo_root = get_repo_root(&path)?;
+        let repo_root_path = Path::new(&repo_root);
+
+        let mut args = vec!["branch".to_string(), name.clone()];
+        if let Some(ref s) = start_point {
+            args.push(s.clone());
+        }
+        let args_refs: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+
+        let output = git_command_with_timeout(&args_refs, repo_root_path)?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(format!("Failed to create branch '{}': {}", name, stderr));
+        }
+
+        info!("[Git] Created branch '{}'", name);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+}
+
+/// Delete a local branch
+#[tauri::command]
+pub async fn git_delete_branch(
+    path: Option<String>,
+    name: String,
+    force: Option<bool>,
+) -> Result<(), String> {
+    let path = path.unwrap_or_else(|| ".".to_string());
+    tokio::task::spawn_blocking(move || {
+        let repo_root = get_repo_root(&path)?;
+        let repo_root_path = Path::new(&repo_root);
+
+        let flag = if force.unwrap_or(false) { "-D" } else { "-d" };
+        let output = git_command_with_timeout(&["branch", flag, &name], repo_root_path)?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(format!("Failed to delete branch '{}': {}", name, stderr));
+        }
+
+        info!("[Git] Deleted branch '{}'", name);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+}
+
+/// Reset current HEAD to a specific commit
+#[tauri::command]
+pub async fn git_reset(
+    path: Option<String>,
+    hash: String,
+    mode: Option<String>,
+) -> Result<(), String> {
+    let path = path.unwrap_or_else(|| ".".to_string());
+    tokio::task::spawn_blocking(move || {
+        let repo_root = get_repo_root(&path)?;
+        let repo_root_path = Path::new(&repo_root);
+
+        let mode_str = mode.unwrap_or_else(|| "mixed".to_string());
+        let mode_flag = match mode_str.as_str() {
+            "soft" => "--soft",
+            "mixed" => "--mixed",
+            "hard" => "--hard",
+            other => return Err(format!("Invalid reset mode: {}", other)),
+        };
+
+        let output = git_command_with_timeout(&["reset", mode_flag, &hash], repo_root_path)?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(format!("Failed to reset to '{}': {}", hash, stderr));
+        }
+
+        info!("[Git] Reset ({}) to {}", mode_str, hash);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+}
+
+/// Revert a commit
+#[tauri::command]
+pub async fn git_revert(path: Option<String>, hash: String) -> Result<(), String> {
+    let path = path.unwrap_or_else(|| ".".to_string());
+    tokio::task::spawn_blocking(move || {
+        let repo_root = get_repo_root(&path)?;
+        let repo_root_path = Path::new(&repo_root);
+
+        let output = git_command_with_timeout(&["revert", "--no-edit", &hash], repo_root_path)?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            if stderr.contains("CONFLICT") || stderr.contains("conflict") {
+                info!(
+                    "[Git] Revert of {} has conflicts, waiting for resolution",
+                    hash
+                );
+                return Ok(());
+            }
+            return Err(format!("Failed to revert '{}': {}", hash, stderr));
+        }
+
+        info!("[Git] Reverted commit {}", hash);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+}
+
 #[cfg(test)]
 #[allow(clippy::unwrap_used, clippy::expect_used)]
 mod tests {

src-tauri/src/git/cherry_pick.rs

@@ -156,6 +156,31 @@ pub async fn git_cherry_pick_status(path: String) -> Result<CherryPickStatus, St
     .map_err(|e| format!("Task join error: {}", e))?
 }
 
+/// Cherry-pick a single commit (simple wrapper for git-graph SDK)
+#[tauri::command]
+pub async fn git_cherry_pick(path: Option<String>, hash: String) -> Result<(), String> {
+    let path = path.unwrap_or_else(|| ".".to_string());
+    tokio::task::spawn_blocking(move || {
+        info!("Cherry-picking commit {}", hash);
+
+        let output = git_command_with_timeout(&["cherry-pick", &hash], Path::new(&path))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            if stderr.contains("CONFLICT") || stderr.contains("conflict") {
+                info!("Cherry-pick has conflicts, waiting for resolution");
+                return Ok(());
+            }
+            return Err(format!("Cherry-pick failed: {}", stderr));
+        }
+
+        info!("Cherry-pick of {} completed successfully", hash);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+}
+
 /// Start a cherry-pick operation for one or more commits
 #[tauri::command]
 pub async fn git_cherry_pick_start(path: String, commits: Vec<String>) -> Result<(), String> {