use serde::Serialize; use std::path::{Path, PathBuf}; use std::process::Command; #[derive(Serialize)] #[serde(rename_all = "camelCase")] pub struct GitState { pub is_git_repo: bool, pub current_branch: Option, pub dirty_file_count: u32, pub incoming_commit_count: u32, pub worktrees: Vec, pub is_worktree: bool, pub main_worktree_path: Option, pub local_branches: Vec, } #[derive(Serialize)] #[serde(rename_all = "camelCase")] pub struct WorktreeInfo { pub path: String, pub branch: Option, pub is_main: bool, } #[derive(Serialize)] #[serde(rename_all = "camelCase")] pub struct CreatedWorktree { pub path: String, pub branch: String, } #[tauri::command] pub fn get_git_state(path: String) -> Result { let repo_path = PathBuf::from(&path); if !repo_path.exists() { return Err(format!("Path does not exist: {}", path)); } if !is_git_repo(&repo_path)? { return Ok(GitState { is_git_repo: false, current_branch: None, dirty_file_count: 0, incoming_commit_count: 0, worktrees: Vec::new(), is_worktree: false, main_worktree_path: None, local_branches: Vec::new(), }); } let current_root = trim_to_option(run_git_success( &repo_path, &["rev-parse", "--show-toplevel"], )?) .ok_or("Could not determine repository root")?; let current_branch = trim_to_option(run_git_success(&repo_path, &["branch", "--show-current"])?); let dirty_file_count = count_lines(&run_git_success(&repo_path, &["status", "--porcelain"])?); let git_common_dir = trim_to_option(run_git_success( &repo_path, &["rev-parse", "--git-common-dir"], )?); let main_worktree_path = git_common_dir .as_deref() .and_then(|git_common_dir| resolve_main_worktree_path(git_common_dir, ¤t_root)) .as_deref() .map(normalize_path_string); let worktrees_output = run_git_success(&repo_path, &["worktree", "list", "--porcelain"])?; let worktrees = parse_worktrees(&worktrees_output, main_worktree_path.as_deref()); let is_worktree = main_worktree_path .as_deref() .map(|main_path| normalize_path_string(¤t_root) != main_path) .unwrap_or(false); let incoming_commit_count = count_incoming_commits(&repo_path).unwrap_or(0); let local_branches = list_local_branches(&repo_path).unwrap_or_default(); Ok(GitState { is_git_repo: true, current_branch, dirty_file_count, incoming_commit_count, worktrees, is_worktree, main_worktree_path, local_branches, }) } #[tauri::command] pub fn git_switch_branch(path: String, branch: String) -> Result<(), String> { let repo_path = resolve_repo_path(&path)?; run_git_success(&repo_path, &["switch", &branch])?; Ok(()) } #[tauri::command] pub fn git_stash(path: String) -> Result<(), String> { let repo_path = resolve_repo_path(&path)?; run_git_success(&repo_path, &["stash"])?; Ok(()) } #[tauri::command] pub fn git_init(path: String) -> Result<(), String> { let repo_path = resolve_repo_path(&path)?; run_git_success(&repo_path, &["init"])?; Ok(()) } #[tauri::command] pub fn git_fetch(path: String) -> Result<(), String> { let repo_path = resolve_repo_path(&path)?; run_git_success(&repo_path, &["fetch", "--prune"])?; Ok(()) } #[tauri::command] pub fn git_pull(path: String) -> Result<(), String> { let repo_path = resolve_repo_path(&path)?; run_git_success(&repo_path, &["pull", "--ff-only"])?; Ok(()) } #[tauri::command] pub fn git_create_branch(path: String, name: String, base_branch: String) -> Result<(), String> { let repo_path = resolve_repo_path(&path)?; let branch_name = require_nonempty(&name, "Branch name")?; let base_branch = require_nonempty(&base_branch, "Base branch")?; run_git_success( &repo_path, &["switch", "-c", branch_name.as_str(), base_branch.as_str()], )?; Ok(()) } #[tauri::command] pub fn git_create_worktree( path: String, name: String, branch: String, create_branch: bool, base_branch: Option, ) -> Result { let repo_path = resolve_repo_path(&path)?; let worktree_name = validate_worktree_name(&name)?; let branch_name = require_nonempty(&branch, "Branch name")?; let (_, main_worktree_path) = git_repo_context(&repo_path)?; let target_path = derive_worktree_path( main_worktree_path.as_deref().unwrap_or(path.as_str()), &worktree_name, )?; if let Some(parent) = target_path.parent() { std::fs::create_dir_all(parent) .map_err(|error| format!("Failed to create worktree directory: {}", error))?; } let target_path_string = target_path.to_string_lossy().to_string(); if create_branch { let base_branch = require_nonempty(base_branch.as_deref().unwrap_or_default(), "Base branch")?; run_git_success( &repo_path, &[ "worktree", "add", "-b", branch_name.as_str(), target_path_string.as_str(), base_branch.as_str(), ], )?; } else { run_git_success( &repo_path, &[ "worktree", "add", target_path_string.as_str(), branch_name.as_str(), ], )?; } Ok(CreatedWorktree { path: normalize_path_string(&target_path_string), branch: branch_name, }) } pub(crate) fn is_git_repo(path: &Path) -> Result { let output = Command::new("git") .arg("rev-parse") .arg("--is-inside-work-tree") .current_dir(path) .output() .map_err(|error| format!("Failed to run git: {}", error))?; Ok(output.status.success() && String::from_utf8_lossy(&output.stdout).trim() == "true") } pub(crate) fn resolve_repo_path(path: &str) -> Result { let repo_path = PathBuf::from(path); if !repo_path.exists() { return Err(format!("Path does not exist: {}", path)); } Ok(repo_path) } pub(crate) fn run_git_success(path: &Path, args: &[&str]) -> Result { let output = Command::new("git") .args(args) .current_dir(path) .output() .map_err(|error| format!("Failed to run git: {}", error))?; if !output.status.success() { let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string(); let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string(); let message = if !stderr.is_empty() { stderr } else { stdout }; let rendered_args = args.join(" "); return Err(format!("git {} failed: {}", rendered_args, message)); } Ok(String::from_utf8_lossy(&output.stdout).into_owned()) } pub(crate) fn trim_to_option(value: String) -> Option { let trimmed = value.trim(); if trimmed.is_empty() { None } else { Some(trimmed.to_string()) } } fn require_nonempty(value: &str, label: &str) -> Result { let trimmed = value.trim(); if trimmed.is_empty() { Err(format!("{} cannot be empty", label)) } else { Ok(trimmed.to_string()) } } fn count_lines(value: &str) -> u32 { value .lines() .filter(|line| !line.trim().is_empty()) .count() .try_into() .unwrap_or(u32::MAX) } fn count_incoming_commits(path: &Path) -> Result { let has_upstream = Command::new("git") .args([ "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}", ]) .current_dir(path) .output() .map_err(|error| format!("Failed to run git: {}", error))?; if !has_upstream.status.success() { return Ok(0); } let output = run_git_success(path, &["rev-list", "--count", "HEAD..@{upstream}"])?; let count = output .trim() .parse::() .map_err(|error| format!("Failed to parse incoming commit count: {}", error))?; Ok(count) } fn resolve_main_worktree_path(git_common_dir: &str, current_root: &str) -> Option { let path = PathBuf::from(git_common_dir); let absolute = if path.is_absolute() { path } else { PathBuf::from(current_root).join(path) }; if absolute.file_name().is_some_and(|name| name == ".git") { absolute .parent() .map(|parent| parent.to_string_lossy().into_owned()) } else { None } } fn git_repo_context(path: &Path) -> Result<(String, Option), String> { let current_root = trim_to_option(run_git_success(path, &["rev-parse", "--show-toplevel"])?) .ok_or("Could not determine repository root")?; let git_common_dir = trim_to_option(run_git_success(path, &["rev-parse", "--git-common-dir"])?); let main_worktree_path = git_common_dir .as_deref() .and_then(|git_common_dir| resolve_main_worktree_path(git_common_dir, ¤t_root)) .as_deref() .map(normalize_path_string); Ok((current_root, main_worktree_path)) } fn validate_worktree_name(value: &str) -> Result { let worktree_name = require_nonempty(value, "Worktree name")?; if worktree_name == "." || worktree_name == ".." { return Err("Worktree name must be a real folder name".to_string()); } if worktree_name.contains('/') || worktree_name.contains('\\') { return Err("Worktree name cannot contain path separators".to_string()); } Ok(worktree_name) } fn derive_worktree_path(main_worktree_path: &str, worktree_name: &str) -> Result { let main_root = PathBuf::from(main_worktree_path); let repo_name = main_root .file_name() .ok_or("Could not determine repository name")? .to_string_lossy() .to_string(); let repo_parent = main_root .parent() .ok_or("Could not determine repository parent")?; let target_path = repo_parent .join(format!("{}-worktrees", repo_name)) .join(worktree_name); if target_path.exists() { return Err(format!( "Worktree path already exists: {}", target_path.to_string_lossy() )); } Ok(target_path) } fn parse_worktrees(output: &str, main_worktree_path: Option<&str>) -> Vec { let mut worktrees = Vec::new(); let mut current_path: Option = None; let mut current_branch: Option = None; for line in output.lines() { if let Some(path) = line.strip_prefix("worktree ") { if let Some(path) = current_path.take() { worktrees.push(build_worktree( path, current_branch.take(), main_worktree_path, )); } current_path = Some(path.to_string()); current_branch = None; continue; } if let Some(branch) = line.strip_prefix("branch ") { current_branch = Some(branch_name(branch)); } } if let Some(path) = current_path { worktrees.push(build_worktree(path, current_branch, main_worktree_path)); } worktrees } fn build_worktree( path: String, branch: Option, main_worktree_path: Option<&str>, ) -> WorktreeInfo { let normalized_path = normalize_path_string(&path); let is_main = main_worktree_path .map(|main_path| normalized_path == main_path) .unwrap_or(false); WorktreeInfo { path: normalized_path, branch, is_main, } } fn branch_name(branch_ref: &str) -> String { branch_ref .strip_prefix("refs/heads/") .unwrap_or(branch_ref) .to_string() } fn normalize_path_string(path: &str) -> String { path.replace('\\', "/").trim_end_matches('/').to_string() } fn list_local_branches(path: &Path) -> Result, String> { let output = run_git_success( path, &[ "for-each-ref", "--sort=-committerdate", "--format=%(refname:short)", "refs/heads", ], )?; Ok(output .lines() .map(|line| line.trim().to_string()) .filter(|line| !line.is_empty()) .collect()) }