mi6_core/context/

github.rs

//! GitHub context extraction from Bash tool events.
//!
//! This module parses Bash commands and their output to extract GitHub issue/PR
//! references and worktree information. This provides more accurate context than
//! branch name parsing alone, capturing:
//!
//! - Explicit `gh issue/pr` commands
//! - GitHub URLs in command output (e.g., from `gh pr create`)
//! - `Fixes #N` references in PR bodies
//! - Git worktree operations
//!
//! # Usage
//!
//! ```rust,ignore
//! use mi6_core::github::{extract_context, SessionContextUpdate};
//! use std::path::Path;
//!
//! let cwd = Path::new("/home/user/project");
//! let update = extract_context(
//!     "gh issue view 52 --repo paradigmxyz/mi6",
//!     None,
//!     cwd,
//! );
//!
//! assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
//! assert_eq!(update.github_issue, Some(52));
//! ```

use std::path::Path;
use std::sync::LazyLock;

use regex::Regex;

/// Context update derived from a Bash tool event.
///
/// Each field is `Some` only if the parsing found a new value.
/// Use with COALESCE semantics to update session fields.
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct SessionContextUpdate {
    /// Repository in `owner/repo` format
    pub github_repo: Option<String>,
    /// GitHub issue number
    pub github_issue: Option<i32>,
    /// GitHub PR number
    pub github_pr: Option<i32>,
    /// Absolute path to git worktree
    pub worktree_path: Option<String>,
    /// Branch name in the worktree
    pub worktree_branch: Option<String>,
}

impl SessionContextUpdate {
    /// Returns true if this update has any values
    pub fn has_values(&self) -> bool {
        self.github_repo.is_some()
            || self.github_issue.is_some()
            || self.github_pr.is_some()
            || self.worktree_path.is_some()
            || self.worktree_branch.is_some()
    }

    /// Merge another update into this one (other values take precedence)
    pub fn merge(&mut self, other: SessionContextUpdate) {
        if other.github_repo.is_some() {
            self.github_repo = other.github_repo;
        }
        if other.github_issue.is_some() {
            self.github_issue = other.github_issue;
        }
        if other.github_pr.is_some() {
            self.github_pr = other.github_pr;
        }
        if other.worktree_path.is_some() {
            self.worktree_path = other.worktree_path;
        }
        if other.worktree_branch.is_some() {
            self.worktree_branch = other.worktree_branch;
        }
    }
}

// Lazy-compiled regex patterns.
// These patterns are static literals that are verified at compile time,
// so expect() is safe here.

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static GH_ISSUE_PR_RE: LazyLock<Regex> = LazyLock::new(|| {
    // gh issue/pr {view,checks,diff,merge,close,edit,reopen,comment} N [--repo R]
    Regex::new(
        r"gh\s+(issue|pr)\s+(view|checks|diff|merge|close|edit|reopen|comment)\s+(\d+)(?:.*--repo\s+([^\s]+))?"
    ).expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static GITHUB_URL_RE: LazyLock<Regex> = LazyLock::new(|| {
    // https://github.com/owner/repo/issues/N or /pull/N
    Regex::new(r"https://github\.com/([^/]+/[^/]+)/(issues|pull)/(\d+)").expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static CLOSES_RE: LazyLock<Regex> = LazyLock::new(|| {
    // Closes/Fixes/Resolves #N (case-insensitive)
    Regex::new(r"(?i)\b(closes?|fixes?|resolves?)\s*#(\d+)").expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static GH_PR_CREATE_BODY_RE: LazyLock<Regex> = LazyLock::new(|| {
    // gh pr create ... --body "..." or --body '...'
    // Capture the body content for scanning
    Regex::new(r#"gh\s+pr\s+create\s+.*--body\s+(?:"([^"]*)"|'([^']*)')"#).expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static GIT_WORKTREE_ADD_RE: LazyLock<Regex> = LazyLock::new(|| {
    // git worktree add [-f] <path> [-b <branch>] [<commit>]
    Regex::new(r"git\s+worktree\s+add\s+(?:-f\s+)?([^\s]+)(?:.*-b\s+([^\s]+))?")
        .expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static GIT_C_PATH_RE: LazyLock<Regex> = LazyLock::new(|| {
    // git -C <path> ...
    Regex::new(r"git\s+-C\s+([^\s]+)").expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static CD_PATH_RE: LazyLock<Regex> = LazyLock::new(|| {
    // cd <path> with optional quotes
    Regex::new(r#"cd\s+(?:"([^"]+)"|'([^']+)'|([^\s;&|]+))"#).expect("invalid regex")
});

#[expect(
    clippy::expect_used,
    reason = "static regex pattern verified at compile time"
)]
static GH_CREATE_RE: LazyLock<Regex> = LazyLock::new(|| {
    // gh issue create or gh pr create - commands that output URLs we want to capture
    Regex::new(r"gh\s+(issue|pr)\s+create").expect("invalid regex")
});

/// Parse a Bash command for gh issue/pr references.
///
/// Handles commands like:
/// - `gh issue view 52`
/// - `gh pr checks 86 --repo paradigmxyz/mi6`
/// - `gh issue close 42`
pub fn parse_gh_command(command: &str) -> SessionContextUpdate {
    let mut update = SessionContextUpdate::default();

    // Split command on && || ; to handle chained commands
    for part in split_chained_commands(command) {
        if let Some(caps) = GH_ISSUE_PR_RE.captures(part) {
            let cmd_type = caps.get(1).map(|m| m.as_str());
            let number_str = caps.get(3).map(|m| m.as_str());
            let repo = caps.get(4).map(|m| m.as_str().to_string());

            if let Some(num) = number_str.and_then(|s| s.parse::<i32>().ok()) {
                match cmd_type {
                    Some("issue") => update.github_issue = Some(num),
                    Some("pr") => update.github_pr = Some(num),
                    _ => {}
                }
            }

            if let Some(r) = repo {
                update.github_repo = Some(r);
            }
        }

        // Also check for gh pr create --body "... Fixes #N ..."
        if let Some(caps) = GH_PR_CREATE_BODY_RE.captures(part) {
            let body = caps.get(1).or_else(|| caps.get(2)).map(|m| m.as_str());
            if let Some(body_text) = body {
                let issues = parse_closes_references(body_text);
                if let Some(&first_issue) = issues.first() {
                    update.github_issue = Some(first_issue);
                }
            }
        }
    }

    update
}

/// Parse tool output for GitHub URLs.
///
/// Extracts repo, issue, and PR from URLs like:
/// - `https://github.com/paradigmxyz/mi6/issues/236`
/// - `https://github.com/paradigmxyz/mi6/pull/237`
pub fn parse_github_urls(output: &str) -> SessionContextUpdate {
    let mut update = SessionContextUpdate::default();

    for caps in GITHUB_URL_RE.captures_iter(output) {
        let repo = caps.get(1).map(|m| m.as_str().to_string());
        let url_type = caps.get(2).map(|m| m.as_str());
        let number_str = caps.get(3).map(|m| m.as_str());

        if let Some(num) = number_str.and_then(|s| s.parse::<i32>().ok()) {
            match url_type {
                Some("issues") => update.github_issue = Some(num),
                Some("pull") => update.github_pr = Some(num),
                _ => {}
            }
        }

        if let Some(r) = repo {
            update.github_repo = Some(r);
        }
    }

    update
}

/// Parse PR body text for "Closes #N" references.
///
/// Returns a list of issue numbers found.
pub fn parse_closes_references(body: &str) -> Vec<i32> {
    CLOSES_RE
        .captures_iter(body)
        .filter_map(|caps| caps.get(2).and_then(|m| m.as_str().parse::<i32>().ok()))
        .collect()
}

/// Parse git worktree add command.
///
/// Extracts path and optional branch from commands like:
/// - `git worktree add ../foo-issue-42`
/// - `git worktree add ../foo -b fix/issue-42`
/// - `git worktree add -f /path/to/worktree`
pub fn parse_worktree_add(command: &str, cwd: &Path) -> Option<(String, Option<String>)> {
    for part in split_chained_commands(command) {
        if let Some(caps) = GIT_WORKTREE_ADD_RE.captures(part) {
            let path_str = caps.get(1)?.as_str();
            let branch = caps.get(2).map(|m| m.as_str().to_string());

            // Resolve path relative to cwd
            let resolved = resolve_path(path_str, cwd);
            return Some((resolved, branch));
        }
    }
    None
}

/// Parse `git -C <path>` from a command.
///
/// Returns the path argument if found.
pub fn parse_git_c_path(command: &str, cwd: &Path) -> Option<String> {
    for part in split_chained_commands(command) {
        if let Some(caps) = GIT_C_PATH_RE.captures(part) {
            let path_str = caps.get(1)?.as_str();
            return Some(resolve_path(path_str, cwd));
        }
    }
    None
}

/// Parse cd command for directory changes.
///
/// Handles quoted and unquoted paths:
/// - `cd /path/to/dir`
/// - `cd "/path with spaces/dir"`
/// - `cd '/path/dir'`
pub fn parse_cd_path(command: &str, cwd: &Path) -> Option<String> {
    for part in split_chained_commands(command) {
        if let Some(caps) = CD_PATH_RE.captures(part) {
            // Match groups: 1=double-quoted, 2=single-quoted, 3=unquoted
            let path_str = caps
                .get(1)
                .or_else(|| caps.get(2))
                .or_else(|| caps.get(3))?
                .as_str();
            return Some(resolve_path(path_str, cwd));
        }
    }
    None
}

/// Check if the command is one that creates GitHub resources and outputs URLs.
///
/// Only these commands should have their output parsed for GitHub URLs:
/// - `gh issue create` - outputs the created issue URL
/// - `gh pr create` - outputs the created PR URL
///
/// Other commands (like `gh run view`, `cat`, etc.) may have GitHub URLs in their
/// output, but these are incidental and shouldn't be treated as session context.
fn should_parse_output_urls(command: &str) -> bool {
    for part in split_chained_commands(command) {
        if GH_CREATE_RE.is_match(part) {
            return true;
        }
    }
    false
}

/// Extract all context from a Bash tool event.
///
/// Combines command parsing and output parsing to extract:
/// - GitHub repo, issue, and PR references
/// - Worktree path and branch
///
/// # Arguments
/// * `command` - The Bash command (from event payload)
/// * `output` - The tool output (from event tool_output), if any
/// * `cwd` - Current working directory for resolving relative paths
pub fn extract_context(command: &str, output: Option<&str>, cwd: &Path) -> SessionContextUpdate {
    let mut update = SessionContextUpdate::default();

    // Parse command for gh commands
    update.merge(parse_gh_command(command));

    // Parse output for GitHub URLs, but only for creation commands.
    // This prevents incidental URLs (e.g., in CI logs, code comments) from
    // being treated as session context.
    if let Some(out) = output
        && should_parse_output_urls(command)
    {
        update.merge(parse_github_urls(out));
    }

    // Parse worktree operations
    if let Some((path, branch)) = parse_worktree_add(command, cwd) {
        update.worktree_path = Some(path);
        update.worktree_branch = branch;
    }

    // Parse git -C path (updates worktree_path)
    if let Some(path) = parse_git_c_path(command, cwd) {
        update.worktree_path = Some(path);
    }

    // Parse cd commands
    if let Some(path) = parse_cd_path(command, cwd) {
        update.worktree_path = Some(path);
    }

    update
}

/// Split command on && || ; to handle chained commands.
fn split_chained_commands(command: &str) -> Vec<&str> {
    // Split on && || ; but not inside quotes
    // For simplicity, we do a basic split that handles most cases
    let mut parts = Vec::new();
    let mut current = command;

    // Simple split that works for most shell commands
    while !current.is_empty() {
        // Find the next delimiter
        let delim_pos = current
            .find("&&")
            .map(|p| (p, 2))
            .or_else(|| current.find("||").map(|p| (p, 2)))
            .or_else(|| current.find(';').map(|p| (p, 1)));

        if let Some((pos, len)) = delim_pos {
            let part = current[..pos].trim();
            if !part.is_empty() {
                parts.push(part);
            }
            current = &current[pos + len..];
        } else {
            let part = current.trim();
            if !part.is_empty() {
                parts.push(part);
            }
            break;
        }
    }

    parts
}

/// Resolve a path relative to cwd, handling ~ expansion.
fn resolve_path(path: &str, cwd: &Path) -> String {
    let path = if path.starts_with('~') {
        // Expand ~ to home directory
        if let Ok(home) = std::env::var("HOME") {
            path.replacen('~', &home, 1)
        } else {
            path.to_string()
        }
    } else {
        path.to_string()
    };

    let path = Path::new(&path);
    if path.is_absolute() {
        path.to_string_lossy().into_owned()
    } else {
        cwd.join(path).to_string_lossy().into_owned()
    }
}

#[cfg(test)]
#[expect(clippy::unwrap_used, reason = "test code uses unwrap for clarity")]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn test_parse_gh_issue_view() {
        let update = parse_gh_command("gh issue view 52");
        assert_eq!(update.github_issue, Some(52));
        assert_eq!(update.github_pr, None);
        assert_eq!(update.github_repo, None);
    }

    #[test]
    fn test_parse_gh_issue_with_repo() {
        let update = parse_gh_command("gh issue view 52 --repo paradigmxyz/mi6");
        assert_eq!(update.github_issue, Some(52));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }

    #[test]
    fn test_parse_gh_pr_checks() {
        let update = parse_gh_command("gh pr checks 86");
        assert_eq!(update.github_pr, Some(86));
        assert_eq!(update.github_issue, None);
    }

    #[test]
    fn test_parse_gh_pr_with_repo() {
        let update = parse_gh_command("gh pr view 64 --repo paradigmxyz/mi6");
        assert_eq!(update.github_pr, Some(64));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }

    #[test]
    fn test_parse_github_url_issue() {
        let update = parse_github_urls("Created https://github.com/paradigmxyz/mi6/issues/236");
        assert_eq!(update.github_issue, Some(236));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }

    #[test]
    fn test_parse_github_url_pr() {
        let update = parse_github_urls("Created https://github.com/paradigmxyz/mi6/pull/237");
        assert_eq!(update.github_pr, Some(237));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }

    #[test]
    fn test_parse_closes_references() {
        let issues = parse_closes_references("This PR fixes #52 and closes #53");
        assert_eq!(issues, vec![52, 53]);
    }

    #[test]
    fn test_parse_closes_references_case_insensitive() {
        let issues = parse_closes_references("FIXES #42\nResolves #43\ncloses #44");
        assert_eq!(issues, vec![42, 43, 44]);
    }

    #[test]
    fn test_parse_gh_pr_create_with_fixes() {
        let update = parse_gh_command(r#"gh pr create --title "Fix bug" --body "Fixes #52""#);
        assert_eq!(update.github_issue, Some(52));
    }

    #[test]
    fn test_parse_worktree_add_simple() {
        let cwd = PathBuf::from("/test/repos/mi6");
        let result = parse_worktree_add("git worktree add ../mi6-issue-42", &cwd);
        assert!(result.is_some());
        let (path, branch) = result.unwrap();
        assert_eq!(path, "/test/repos/mi6/../mi6-issue-42");
        assert_eq!(branch, None);
    }

    #[test]
    fn test_parse_worktree_add_with_branch() {
        let cwd = PathBuf::from("/test/repos/mi6");
        let result = parse_worktree_add(
            "git worktree add ../mi6-fix -b fix/issue-42 origin/main",
            &cwd,
        );
        assert!(result.is_some());
        let (path, branch) = result.unwrap();
        assert_eq!(path, "/test/repos/mi6/../mi6-fix");
        assert_eq!(branch, Some("fix/issue-42".to_string()));
    }

    #[test]
    fn test_parse_git_c_path() {
        let cwd = PathBuf::from("/test/repos");
        let cmd = "git -C /test/worktree status";
        let result = parse_git_c_path(cmd, &cwd);
        assert_eq!(result, Some("/test/worktree".to_string()));
    }

    #[test]
    fn test_parse_cd_path_unquoted() {
        let cwd = PathBuf::from("/test");
        let cmd = "cd /test/path/to/dir";
        let result = parse_cd_path(cmd, &cwd);
        assert_eq!(result, Some("/test/path/to/dir".to_string()));
    }

    #[test]
    fn test_parse_cd_path_quoted() {
        let cwd = PathBuf::from("/test");
        let cmd = r#"cd "/test/path with spaces/dir""#;
        let result = parse_cd_path(cmd, &cwd);
        assert_eq!(result, Some("/test/path with spaces/dir".to_string()));
    }

    #[test]
    fn test_parse_cd_path_relative() {
        let cwd = PathBuf::from("/test/repos");
        let result = parse_cd_path("cd mi6-issue-42", &cwd);
        assert_eq!(result, Some("/test/repos/mi6-issue-42".to_string()));
    }

    #[test]
    fn test_chained_commands() {
        let update =
            parse_gh_command("cargo build && gh pr create --title 'Fix' --body 'Fixes #52'");
        assert_eq!(update.github_issue, Some(52));
    }

    #[test]
    fn test_chained_commands_semicolon() {
        let update = parse_gh_command("echo hello; gh issue view 42");
        assert_eq!(update.github_issue, Some(42));
    }

    #[test]
    fn test_extract_context_combined() {
        let cwd = PathBuf::from("/test/repos/mi6");
        let update = extract_context(
            "gh pr view 86 --repo paradigmxyz/mi6",
            Some("Some output here"),
            &cwd,
        );
        assert_eq!(update.github_pr, Some(86));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }

    #[test]
    fn test_extract_context_from_output() {
        let cwd = PathBuf::from("/test/repos/mi6");
        let update = extract_context(
            "gh pr create --title 'Fix' --body 'Some fix'",
            Some("Created https://github.com/paradigmxyz/mi6/pull/237"),
            &cwd,
        );
        assert_eq!(update.github_pr, Some(237));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }

    #[test]
    fn test_session_context_update_has_values() {
        let empty = SessionContextUpdate::default();
        assert!(!empty.has_values());

        let with_issue = SessionContextUpdate {
            github_issue: Some(42),
            ..Default::default()
        };
        assert!(with_issue.has_values());
    }

    #[test]
    fn test_session_context_update_merge() {
        let mut base = SessionContextUpdate {
            github_repo: Some("foo/bar".to_string()),
            github_issue: Some(1),
            ..Default::default()
        };

        let other = SessionContextUpdate {
            github_issue: Some(2),
            github_pr: Some(42),
            ..Default::default()
        };

        base.merge(other);

        assert_eq!(base.github_repo, Some("foo/bar".to_string())); // kept
        assert_eq!(base.github_issue, Some(2)); // overwritten
        assert_eq!(base.github_pr, Some(42)); // added
    }

    #[test]
    fn test_should_parse_output_urls() {
        // Creation commands should have output parsed
        assert!(should_parse_output_urls("gh pr create --title 'Fix'"));
        assert!(should_parse_output_urls("gh issue create --title 'Bug'"));
        assert!(should_parse_output_urls(
            "cargo build && gh pr create --title 'Fix'"
        ));

        // Non-creation commands should NOT have output parsed
        assert!(!should_parse_output_urls("gh run view 12345"));
        assert!(!should_parse_output_urls("gh pr view 42"));
        assert!(!should_parse_output_urls("gh issue view 42"));
        assert!(!should_parse_output_urls("cat README.md"));
        assert!(!should_parse_output_urls(
            "gh run download 12345 --name logs"
        ));
    }

    #[test]
    fn test_extract_context_ignores_urls_in_non_creation_output() {
        // This test reproduces a bug where GitHub URLs in CI logs were incorrectly
        // extracted as session context. The URL below appeared in a comment within
        // the dtolnay/rust-toolchain action's shell script.
        let cwd = PathBuf::from("/test/repos/mi6");
        let ci_log_output = r#"
            # GitHub does not enforce `required: true` inputs itself. https://github.com/actions/runner/issues/1070
            echo "toolchain=$toolchain" >> $GITHUB_OUTPUT
        "#;

        let update = extract_context("gh run view 12345 --log", Some(ci_log_output), &cwd);

        // Should NOT extract the incidental URL from CI logs
        assert_eq!(update.github_issue, None);
        assert_eq!(update.github_repo, None);
        assert_eq!(update.github_pr, None);
    }

    #[test]
    fn test_extract_context_issue_create_output() {
        let cwd = PathBuf::from("/test/repos/mi6");
        let update = extract_context(
            "gh issue create --title 'Bug report'",
            Some("https://github.com/paradigmxyz/mi6/issues/42"),
            &cwd,
        );
        assert_eq!(update.github_issue, Some(42));
        assert_eq!(update.github_repo, Some("paradigmxyz/mi6".to_string()));
    }
}