git_workflow/git/
query.rs

1//! Read-only git operations
2
3use std::path::PathBuf;
4use std::process::Command;
5
6use crate::error::{GwError, Result};
7
8/// Execute a git command and return stdout as string
9fn git_output(args: &[&str]) -> Result<String> {
10    let output = Command::new("git")
11        .args(args)
12        .output()
13        .map_err(|e| GwError::GitCommandFailed(format!("Failed to execute git: {e}")))?;
14
15    if output.status.success() {
16        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
17    } else {
18        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
19        Err(GwError::GitCommandFailed(stderr))
20    }
21}
22
23/// Execute a git command and check if it succeeded (ignoring output)
24fn git_check(args: &[&str]) -> bool {
25    Command::new("git")
26        .args(args)
27        .output()
28        .map(|o| o.status.success())
29        .unwrap_or(false)
30}
31
32/// Check if we're in a git repository
33pub fn is_git_repo() -> bool {
34    git_check(&["rev-parse", "--git-dir"])
35}
36
37/// Get the current branch name
38pub fn current_branch() -> Result<String> {
39    git_output(&["rev-parse", "--abbrev-ref", "HEAD"])
40}
41
42/// Get the worktree root (the top-level working directory of the current worktree)
43pub fn worktree_root() -> Result<PathBuf> {
44    git_output(&["rev-parse", "--show-toplevel"]).map(PathBuf::from)
45}
46
47/// Get the git directory (.git or .git/worktrees/xxx)
48pub fn git_dir() -> Result<PathBuf> {
49    git_output(&["rev-parse", "--git-dir"]).map(PathBuf::from)
50}
51
52/// Get the common git directory (always .git of main repo)
53pub fn git_common_dir() -> Result<PathBuf> {
54    git_output(&["rev-parse", "--git-common-dir"]).map(PathBuf::from)
55}
56
57/// Check if we're in a worktree (not the main repo)
58pub fn is_worktree() -> Result<bool> {
59    let git_dir = git_dir()?;
60    let common_dir = git_common_dir()?;
61    Ok(git_dir != common_dir)
62}
63
64/// Check if a branch exists locally
65pub fn branch_exists(branch: &str) -> bool {
66    git_check(&[
67        "show-ref",
68        "--verify",
69        "--quiet",
70        &format!("refs/heads/{branch}"),
71    ])
72}
73
74/// Check if a branch exists on remote origin.
75///
76/// Returns `Ok(true)` / `Ok(false)` only when the answer is definitive:
77/// `git ls-remote --exit-code` exits 0 when the ref exists and 2 when it
78/// provably does not. Any other exit (no `origin`, network/auth failure) is
79/// returned as an `Err` so callers can distinguish "not there" from "couldn't
80/// check" — the latter must never be treated as safe-to-delete.
81pub fn remote_branch_exists(branch: &str) -> Result<bool> {
82    let output = Command::new("git")
83        .args(["ls-remote", "--exit-code", "--heads", "origin", branch])
84        .output()
85        .map_err(|e| GwError::GitCommandFailed(format!("Failed to execute git: {e}")))?;
86
87    match output.status.code() {
88        Some(0) => Ok(true),
89        Some(2) => Ok(false),
90        _ => {
91            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
92            Err(GwError::GitCommandFailed(format!(
93                "Could not query remote branch '{branch}': {stderr}"
94            )))
95        }
96    }
97}
98
99/// Get the current HEAD commit hash
100pub fn head_commit() -> Result<String> {
101    git_output(&["rev-parse", "HEAD"])
102}
103
104/// Get the short commit hash
105pub fn short_commit() -> Result<String> {
106    git_output(&["rev-parse", "--short", "HEAD"])
107}
108
109/// Get the commit message of HEAD
110pub fn head_commit_message() -> Result<String> {
111    git_output(&["log", "-1", "--format=%s"])
112}
113
114/// Check if working directory has unstaged changes
115pub fn has_unstaged_changes() -> bool {
116    !git_check(&["diff", "--quiet"])
117}
118
119/// Check if working directory has staged changes
120pub fn has_staged_changes() -> bool {
121    !git_check(&["diff", "--cached", "--quiet"])
122}
123
124/// Check if working directory has any uncommitted changes (staged or unstaged)
125pub fn has_uncommitted_changes() -> bool {
126    has_unstaged_changes() || has_staged_changes()
127}
128
129/// Check if working directory has untracked files
130pub fn has_untracked_files() -> bool {
131    git_output(&["ls-files", "--others", "--exclude-standard"])
132        .map(|s| !s.is_empty())
133        .unwrap_or(false)
134}
135
136/// Get the upstream tracking branch for a local branch, if any
137pub fn get_upstream(branch: &str) -> Option<String> {
138    git_output(&[
139        "rev-parse",
140        "--abbrev-ref",
141        &format!("{branch}@{{upstream}}"),
142    ])
143    .ok()
144    .filter(|s| !s.is_empty())
145}
146
147/// Check if a branch has a remote tracking branch
148pub fn has_remote_tracking(branch: &str) -> bool {
149    get_upstream(branch).is_some()
150}
151
152/// Count commits between two refs (exclusive..inclusive)
153pub fn commit_count(from: &str, to: &str) -> Result<usize> {
154    let output = git_output(&["rev-list", "--count", &format!("{from}..{to}")])?;
155    output
156        .parse()
157        .map_err(|_| GwError::GitCommandFailed("Failed to parse commit count".to_string()))
158}
159
160/// Get number of unpushed commits on a branch (compared to its upstream)
161pub fn unpushed_commit_count(branch: &str) -> Result<usize> {
162    let upstream = get_upstream(branch)
163        .ok_or_else(|| GwError::Other(format!("Branch '{branch}' has no upstream")))?;
164    commit_count(&upstream, branch)
165}
166
167/// Get number of commits behind upstream
168pub fn behind_upstream_count(branch: &str) -> Result<usize> {
169    let upstream = get_upstream(branch)
170        .ok_or_else(|| GwError::Other(format!("Branch '{branch}' has no upstream")))?;
171    commit_count(branch, &upstream)
172}
173
174/// Count stashes
175pub fn stash_count() -> usize {
176    git_output(&["stash", "list"])
177        .map(|s| if s.is_empty() { 0 } else { s.lines().count() })
178        .unwrap_or(0)
179}
180
181/// Get the message of the latest stash (stash@{0})
182pub fn get_latest_stash_message() -> Option<String> {
183    git_output(&["stash", "list", "-1", "--format=%gs"])
184        .ok()
185        .filter(|s| !s.is_empty())
186}
187
188/// Check if HEAD has a parent commit (i.e., we can undo)
189pub fn has_commits_to_undo() -> bool {
190    git_check(&["rev-parse", "HEAD~1"])
191}
192
193/// Get the current working directory name
194pub fn current_dir_name() -> Result<String> {
195    std::env::current_dir()
196        .map_err(GwError::Io)?
197        .file_name()
198        .and_then(|s| s.to_str())
199        .map(String::from)
200        .ok_or_else(|| GwError::Other("Could not determine current directory name".to_string()))
201}
202
203/// Get the default remote branch (origin/main or origin/master)
204pub fn get_default_remote_branch() -> Result<String> {
205    // An unreachable remote is treated as "not found" here; default_branch_name()
206    // falls back to local branches when this returns an error.
207    if remote_branch_exists("main").unwrap_or(false) {
208        Ok("origin/main".to_string())
209    } else if remote_branch_exists("master").unwrap_or(false) {
210        Ok("origin/master".to_string())
211    } else {
212        Err(GwError::Other(
213            "Neither origin/main nor origin/master exists".to_string(),
214        ))
215    }
216}
217
218/// Get the default branch name (e.g. "main" or "master"), without the remote prefix.
219///
220/// Prefers the remote's default branch; falls back to a local `main`/`master`
221/// for repositories without a configured `origin`. This is the single source of
222/// truth for "the trunk branch", replacing scattered hardcoded "main" literals.
223pub fn default_branch_name() -> Result<String> {
224    if let Ok(remote) = get_default_remote_branch() {
225        return Ok(remote
226            .strip_prefix("origin/")
227            .unwrap_or(&remote)
228            .to_string());
229    }
230    if branch_exists("main") {
231        return Ok("main".to_string());
232    }
233    if branch_exists("master") {
234        return Ok("master".to_string());
235    }
236    Err(GwError::Other(
237        "Could not determine the default branch (no origin/main, origin/master, or local main/master)"
238            .to_string(),
239    ))
240}
241
242/// Check if HEAD is detached
243pub fn is_detached_head() -> bool {
244    current_branch().map(|b| b == "HEAD").unwrap_or(false)
245}
246
247/// Get the top-level working directory of the repository
248pub fn repo_root() -> Result<PathBuf> {
249    git_output(&["rev-parse", "--show-toplevel"]).map(PathBuf::from)
250}
git_workflow/git/query.rs

git_workflow/git/
query.rs
