darwincode 1.9.95

The open source terminal AI coding agent
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
111
112
113
114
115
116
117

use serde::{Deserialize, Serialize};
use std::fmt;

#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum TodoStatus {
    Pending,
    InProgress,
    Completed,
    Cancelled,
}

impl TodoStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Pending => "pending",
            Self::InProgress => "in_progress",
            Self::Completed => "completed",
            Self::Cancelled => "cancelled",
        }
    }
}

impl fmt::Display for TodoStatus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum TodoPriority {
    High,
    Medium,
    Low,
}

impl TodoPriority {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::High => "high",
            Self::Medium => "medium",
            Self::Low => "low",
        }
    }
}

impl fmt::Display for TodoPriority {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct TodoItem {
    pub content: String,
    pub status: TodoStatus,
    pub priority: TodoPriority,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::api::ChatMessage;
    use crate::config::StoredConfig;

    #[test]
    fn test_todo_lifecycle_validation() {
        use crate::app::App;

        // Create app with default config
        let mut app = App::new(Some(StoredConfig::default()));
        app.chat.session_id = "test_mock_todo_validation".to_owned();

        // Case 1: Initial list (one pending, one in_progress)
        app.chat.history.push(ChatMessage {
            role: "model".to_owned(),
            parts: vec![serde_json::json!({
                "functionCall": {
                    "name": "todo",
                    "args": {
                        "todos": [
                            { "content": "Task 1", "status": "pending", "priority": "high" },
                            { "content": "Task 2", "status": "in_progress", "priority": "medium" }
                        ]
                    }
                }
            })],
        });

        app.complete_function_execution("todo".to_string(), serde_json::json!({ "success": true }));
        assert_eq!(app.chat.todos.len(), 2);
        assert_eq!(app.chat.todos[0].content, "Task 1");
        assert_eq!(app.chat.todos[0].status, TodoStatus::Pending);
        assert_eq!(app.chat.todos[1].content, "Task 2");
        assert_eq!(app.chat.todos[1].status, TodoStatus::InProgress);

        // Case 2: Transition pending -> completed directly (validation is relaxed, should succeed)
        app.chat.history.push(ChatMessage {
            role: "model".to_owned(),
            parts: vec![serde_json::json!({
                "functionCall": {
                    "name": "todo",
                    "args": {
                        "todos": [
                            { "content": "Task 1", "status": "completed", "priority": "high" },
                            { "content": "Task 2", "status": "in_progress", "priority": "medium" }
                        ]
                    }
                }
            })],
        });

        app.complete_function_execution("todo".to_string(), serde_json::json!({ "success": true }));
        assert_eq!(app.chat.todos[0].status, TodoStatus::Completed);
    }
}