carryctx 0.0.1

Persistent project context for coding agents
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::error::CarryCtxError;

/// Progress item type
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ProgressType {
    Todo,
    Blocker,
    Risk,
    Note,
}

impl ProgressType {
    pub fn name(self) -> &'static str {
        match self {
            Self::Todo => "todo",
            Self::Blocker => "blocker",
            Self::Risk => "risk",
            Self::Note => "note",
        }
    }
}

impl TryFrom<&str> for ProgressType {
    type Error = CarryCtxError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        match s {
            "todo" => Ok(Self::Todo),
            "blocker" | "block" => Ok(Self::Blocker),
            "risk" => Ok(Self::Risk),
            "note" => Ok(Self::Note),
            _ => Err(CarryCtxError::invalid_arguments(format!(
                "Unknown progress type: {}",
                s
            ))),
        }
    }
}

/// Progress item lifecycle status
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ProgressStatus {
    Open,
    Completed,
    Removed,
}

/// Progress transition action
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProgressAction {
    Complete,
    Reopen,
    Remove,
}

/// Result of evaluating a progress transition
pub fn evaluate_progress_transition(
    current: ProgressStatus,
    action: ProgressAction,
) -> Result<ProgressStatus, CarryCtxError> {
    match (current, action) {
        (ProgressStatus::Open, ProgressAction::Complete) => Ok(ProgressStatus::Completed),
        (ProgressStatus::Open, ProgressAction::Remove) => Ok(ProgressStatus::Removed),
        (ProgressStatus::Completed, ProgressAction::Reopen) => Ok(ProgressStatus::Open),
        (ProgressStatus::Completed, ProgressAction::Remove) => Ok(ProgressStatus::Removed),
        _ => Err(CarryCtxError::invalid_task_transition(
            &format!("{:?}", current),
            &format!("{:?}", action),
        )),
    }
}

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

    #[test]
    fn test_progress_complete() {
        let result = evaluate_progress_transition(ProgressStatus::Open, ProgressAction::Complete);
        assert_eq!(result.unwrap(), ProgressStatus::Completed);
    }

    #[test]
    fn test_progress_reopen() {
        let result =
            evaluate_progress_transition(ProgressStatus::Completed, ProgressAction::Reopen);
        assert_eq!(result.unwrap(), ProgressStatus::Open);
    }

    #[test]
    fn test_progress_remove_from_any_state() {
        assert!(evaluate_progress_transition(ProgressStatus::Open, ProgressAction::Remove).is_ok());
        assert!(
            evaluate_progress_transition(ProgressStatus::Completed, ProgressAction::Remove).is_ok()
        );
    }

    #[test]
    fn test_removed_cannot_transition() {
        assert!(
            evaluate_progress_transition(ProgressStatus::Removed, ProgressAction::Complete)
                .is_err()
        );
        assert!(
            evaluate_progress_transition(ProgressStatus::Removed, ProgressAction::Reopen).is_err()
        );
    }
}