git-workflow 0.4.1

Git guardrails for AI coding agents - safe git workflows with clear state feedback
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! GitHub data types

/// PR state from GitHub
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PrState {
    /// PR is open
    Open,
    /// PR was merged
    Merged {
        /// How the PR was merged
        method: MergeMethod,
        /// The merge commit SHA (for regular merge) or squash commit SHA
        merge_commit: Option<String>,
    },
    /// PR was closed without merging
    Closed,
}

impl PrState {
    /// Check if the PR is merged
    pub fn is_merged(&self) -> bool {
        matches!(self, PrState::Merged { .. })
    }

    /// Check if the PR is open
    pub fn is_open(&self) -> bool {
        matches!(self, PrState::Open)
    }

    /// Check if the PR is closed (without merging)
    pub fn is_closed(&self) -> bool {
        matches!(self, PrState::Closed)
    }
}

/// How a PR was merged
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MergeMethod {
    /// Regular merge commit
    Merge,
    /// Squash and merge
    Squash,
    /// Rebase and merge
    Rebase,
}

impl std::fmt::Display for MergeMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MergeMethod::Merge => write!(f, "merge"),
            MergeMethod::Squash => write!(f, "squash"),
            MergeMethod::Rebase => write!(f, "rebase"),
        }
    }
}

/// Information about a PR associated with a branch
#[derive(Debug, Clone)]
pub struct PrInfo {
    /// PR number
    pub number: u64,
    /// PR title
    pub title: String,
    /// PR URL
    pub url: String,
    /// PR state
    pub state: PrState,
    /// Base branch (e.g., "main")
    pub base_branch: String,
}

impl PrInfo {
    /// Create a new PrInfo for testing
    pub fn new(number: u64, title: &str, url: &str, state: PrState, base_branch: &str) -> Self {
        Self {
            number,
            title: title.to_string(),
            url: url.to_string(),
            state,
            base_branch: base_branch.to_string(),
        }
    }
}

/// Raw PR data from JSON (before merge method detection)
#[derive(Debug, Clone)]
pub struct RawPrData {
    pub number: u64,
    pub title: String,
    pub url: String,
    pub state: String,
    pub base_branch: String,
    pub merge_commit: Option<String>,
}