mi6_core/context/

git.rs

//! Git branch tracking utilities for mi6.
//!
//! This module provides functionality to:
//! - Capture the current git branch from a working directory
//! - Parse branch names to extract PR/issue numbers
//! - Detect git branch-changing commands in shell commands

use std::path::Path;
use std::process::Command;

/// Result of parsing a git branch name for PR/issue numbers.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct GitBranchInfo {
    /// The branch name
    pub branch: String,
    /// PR number if detected in branch name
    pub pr_number: Option<i32>,
    /// Issue number if detected in branch name
    pub issue_number: Option<i32>,
}

/// Get the current git branch for a directory.
///
/// This runs `git rev-parse --abbrev-ref HEAD` in the specified directory.
/// Returns `None` if:
/// - The directory is not a git repository
/// - git is not installed
/// - The command fails for any reason
///
/// This function is designed to be fast (~20ms) and never block.
pub fn get_current_branch(cwd: &Path) -> Option<String> {
    let output = Command::new("git")
        .args(["rev-parse", "--abbrev-ref", "HEAD"])
        .current_dir(cwd)
        .output()
        .ok()?;

    if !output.status.success() {
        return None;
    }

    let branch = String::from_utf8_lossy(&output.stdout).trim().to_string();

    // "HEAD" means detached HEAD state, which isn't useful
    if branch.is_empty() || branch == "HEAD" {
        return None;
    }

    Some(branch)
}

/// Parse a branch name to extract PR and issue numbers.
///
/// Recognizes common branch naming patterns:
/// - `feature/issue-123` -> issue_number: 123
/// - `fix/GH-456` -> issue_number: 456
/// - `pr/789` -> pr_number: 789
/// - `fix-123-some-description` -> issue_number: 123
/// - `issue-42` -> issue_number: 42
/// - `123-feature` -> issue_number: 123
/// - `feature/pr-100` -> pr_number: 100
pub fn parse_branch_info(branch: &str) -> GitBranchInfo {
    let mut info = GitBranchInfo {
        branch: branch.to_string(),
        pr_number: None,
        issue_number: None,
    };

    // Normalize branch name for parsing (lowercase, get last component after /)
    let branch_lower = branch.to_lowercase();
    let last_component = branch_lower.rsplit('/').next().unwrap_or(&branch_lower);

    // Try to find PR number patterns
    // pr-123, pr123, pr/123
    if let Some(num) = extract_prefixed_number(last_component, "pr-")
        .or_else(|| extract_prefixed_number(last_component, "pr"))
    {
        info.pr_number = Some(num);
        return info;
    }

    // Try to find issue number patterns (in order of specificity)
    // issue-123, issue123
    if let Some(num) = extract_prefixed_number(last_component, "issue-")
        .or_else(|| extract_prefixed_number(last_component, "issue"))
    {
        info.issue_number = Some(num);
        return info;
    }

    // gh-123, GH-123
    if let Some(num) = extract_prefixed_number(last_component, "gh-") {
        info.issue_number = Some(num);
        return info;
    }

    // fix-123, fix/123
    if let Some(num) = extract_prefixed_number(last_component, "fix-")
        .or_else(|| extract_prefixed_number(last_component, "fix/"))
    {
        info.issue_number = Some(num);
        return info;
    }

    // Number at the start: 123-feature
    if let Some(num) = extract_leading_number(last_component) {
        info.issue_number = Some(num);
        return info;
    }

    // Number at the end after dash: feature-123
    if let Some(num) = extract_trailing_number(last_component) {
        info.issue_number = Some(num);
        return info;
    }

    info
}

/// Get git branch info for a directory.
///
/// Combines `get_current_branch` and `parse_branch_info` into a single call.
pub fn get_branch_info(cwd: &Path) -> Option<GitBranchInfo> {
    get_current_branch(cwd).map(|branch| parse_branch_info(&branch))
}

/// Check if a shell command might change the git branch.
///
/// Returns `true` for commands like:
/// - `git checkout <branch>`
/// - `git switch <branch>`
/// - `git worktree add <path>`
/// - `git merge <branch>` (in case of fast-forward)
/// - `git rebase <branch>`
///
/// This is a heuristic and may have false positives/negatives.
pub fn is_branch_changing_command(command: &str) -> bool {
    let cmd_lower = command.to_lowercase();

    // Split on common command separators to handle chained commands
    let parts: Vec<&str> = cmd_lower.split(['&', '|', ';']).collect();

    for part in parts {
        let trimmed = part.trim();

        // Must start with "git"
        if !trimmed.starts_with("git ") && !trimmed.starts_with("git\t") {
            continue;
        }

        // Check for branch-changing subcommands
        let git_args = trimmed.strip_prefix("git").unwrap_or("").trim();

        // git checkout (not -b which creates a branch without switching context significantly)
        // but git checkout -b still changes branch, so include it
        if git_args.starts_with("checkout ") || git_args.starts_with("checkout\t") {
            return true;
        }

        // git switch
        if git_args.starts_with("switch ") || git_args.starts_with("switch\t") {
            return true;
        }

        // git worktree add (changes branch in new worktree context)
        if git_args.starts_with("worktree ")
            && (git_args.contains("add ") || git_args.contains("add\t"))
        {
            return true;
        }

        // git merge (can change branch via fast-forward)
        if git_args.starts_with("merge ") || git_args.starts_with("merge\t") {
            return true;
        }

        // git rebase (can change branch)
        if git_args.starts_with("rebase ") || git_args.starts_with("rebase\t") {
            return true;
        }

        // git pull (can change branch via merge/rebase)
        if git_args.starts_with("pull ") || git_args.starts_with("pull\t") || git_args == "pull" {
            return true;
        }
    }

    false
}

/// Extract a number that follows a prefix.
/// e.g., extract_prefixed_number("issue-123-fix", "issue-") -> Some(123)
fn extract_prefixed_number(s: &str, prefix: &str) -> Option<i32> {
    let after_prefix = s.strip_prefix(prefix)?;
    extract_leading_number(after_prefix)
}

/// Extract a number at the start of a string.
/// e.g., extract_leading_number("123-feature") -> Some(123)
fn extract_leading_number(s: &str) -> Option<i32> {
    let num_str: String = s.chars().take_while(|c| c.is_ascii_digit()).collect();
    if num_str.is_empty() {
        return None;
    }
    num_str.parse().ok()
}

/// Extract a number at the end of a string (after the last dash).
/// e.g., extract_trailing_number("feature-123") -> Some(123)
fn extract_trailing_number(s: &str) -> Option<i32> {
    let last_part = s.rsplit('-').next()?;
    // Only if the entire last part is a number
    if last_part.chars().all(|c| c.is_ascii_digit()) && !last_part.is_empty() {
        return last_part.parse().ok();
    }
    None
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_branch_info_issue_patterns() {
        // issue-N pattern
        let info = parse_branch_info("feature/issue-123");
        assert_eq!(info.issue_number, Some(123));
        assert_eq!(info.pr_number, None);

        // gh-N pattern
        let info = parse_branch_info("fix/GH-456");
        assert_eq!(info.issue_number, Some(456));

        // fix-N pattern
        let info = parse_branch_info("fix-789-description");
        assert_eq!(info.issue_number, Some(789));

        // Leading number
        let info = parse_branch_info("123-add-feature");
        assert_eq!(info.issue_number, Some(123));

        // Trailing number
        let info = parse_branch_info("feature-add-something-42");
        assert_eq!(info.issue_number, Some(42));
    }

    #[test]
    fn test_parse_branch_info_pr_patterns() {
        // pr-N pattern
        let info = parse_branch_info("pr-100");
        assert_eq!(info.pr_number, Some(100));
        assert_eq!(info.issue_number, None);

        // With prefix
        let info = parse_branch_info("feature/pr-200");
        assert_eq!(info.pr_number, Some(200));
    }

    #[test]
    fn test_parse_branch_info_no_number() {
        let info = parse_branch_info("main");
        assert_eq!(info.pr_number, None);
        assert_eq!(info.issue_number, None);

        let info = parse_branch_info("feature/add-new-thing");
        assert_eq!(info.pr_number, None);
        assert_eq!(info.issue_number, None);
    }

    #[test]
    fn test_is_branch_changing_command() {
        // Should detect
        assert!(is_branch_changing_command("git checkout main"));
        assert!(is_branch_changing_command("git checkout -b feature"));
        assert!(is_branch_changing_command("git switch develop"));
        assert!(is_branch_changing_command("git worktree add ../wt main"));
        assert!(is_branch_changing_command("git merge feature"));
        assert!(is_branch_changing_command("git rebase main"));
        assert!(is_branch_changing_command("git pull"));
        assert!(is_branch_changing_command("git pull origin main"));

        // Chained commands
        assert!(is_branch_changing_command("echo foo && git checkout main"));
        assert!(is_branch_changing_command("git status; git checkout main"));

        // Should not detect
        assert!(!is_branch_changing_command("git status"));
        assert!(!is_branch_changing_command("git add ."));
        assert!(!is_branch_changing_command("git commit -m 'test'"));
        assert!(!is_branch_changing_command("git push"));
        assert!(!is_branch_changing_command("git log"));
        assert!(!is_branch_changing_command("git diff"));
        assert!(!is_branch_changing_command("git branch -a"));
        assert!(!is_branch_changing_command("echo checkout"));
        assert!(!is_branch_changing_command("cargo test"));
    }

    #[test]
    fn test_get_current_branch_in_git_repo() {
        // This test assumes we're running in a git repo
        let Ok(cwd) = std::env::current_dir() else {
            return; // Skip test if cwd is unavailable
        };
        let branch = get_current_branch(&cwd);

        // Should return Some branch name in a git repo
        // (may be None if running outside a git repo)
        if let Some(ref b) = branch {
            assert!(!b.is_empty());
            assert_ne!(b, "HEAD");
        }
    }

    #[test]
    fn test_get_current_branch_not_git_repo() {
        // Use a path that definitely doesn't exist to ensure it's not a git repo
        let branch = get_current_branch(Path::new("/nonexistent/path/that/should/not/exist"));
        assert!(branch.is_none());
    }
}