ccswarm 0.5.0

AI-powered multi-agent orchestration system with proactive intelligence, security monitoring, and session management
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Task Converter Module
//!
//! Provides conversion between orchestrator Task types and subagent SpawnTask types.
//! This enables seamless integration between the proactive master's decision system
//! and the parallel executor's task execution system.

use crate::agent::{Priority, Task, TaskType};
use crate::subagent::SpawnTask;

/// Conversion from Task reference to SpawnTask
///
/// This enables the ProactiveMaster to convert its internal Task representation
/// to the SpawnTask format required by the ParallelExecutor.
impl From<&Task> for SpawnTask {
    fn from(task: &Task) -> Self {
        let priority = match task.priority {
            Priority::Critical => 100,
            Priority::High => 75,
            Priority::Medium => 50,
            Priority::Low => 25,
        };

        let mut spawn_task = SpawnTask::new(&task.description)
            .with_id(&task.id)
            .with_priority(priority);

        // Add task metadata as context
        spawn_task = spawn_task.with_context(
            "task_type",
            serde_json::json!(format!("{:?}", task.task_type)),
        );
        spawn_task = spawn_task.with_context(
            "priority",
            serde_json::json!(format!("{:?}", task.priority)),
        );

        if let Some(details) = &task.details {
            spawn_task = spawn_task.with_context("details", serde_json::json!(details));
        }

        if let Some(parent_id) = &task.parent_task_id {
            spawn_task = spawn_task.with_context("parent_task_id", serde_json::json!(parent_id));
        }

        spawn_task
    }
}

/// Conversion from owned Task to SpawnTask
impl From<Task> for SpawnTask {
    fn from(task: Task) -> Self {
        SpawnTask::from(&task)
    }
}

/// Convert priority to integer value for SpawnTask
pub fn priority_to_int(priority: &Priority) -> i32 {
    match priority {
        Priority::Critical => 100,
        Priority::High => 75,
        Priority::Medium => 50,
        Priority::Low => 25,
    }
}

/// Convert task type to string for context
pub fn task_type_to_string(task_type: &TaskType) -> &'static str {
    match task_type {
        TaskType::Development => "development",
        TaskType::Testing => "testing",
        TaskType::Documentation => "documentation",
        TaskType::Infrastructure => "infrastructure",
        TaskType::Coordination => "coordination",
        TaskType::Review => "review",
        TaskType::Bugfix | TaskType::Bug => "bugfix",
        TaskType::Feature => "feature",
        TaskType::Remediation => "remediation",
        TaskType::Assistance => "assistance",
        TaskType::Research => "research",
    }
}

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

    #[test]
    fn test_task_to_spawn_task_conversion() {
        let task = Task::new(
            "test-task-1".to_string(),
            "Implement feature X".to_string(),
            Priority::High,
            TaskType::Development,
        )
        .with_details("Additional details here".to_string());

        let spawn_task: SpawnTask = (&task).into();

        assert_eq!(spawn_task.id, "test-task-1");
        assert_eq!(spawn_task.prompt, "Implement feature X");
        assert_eq!(spawn_task.priority, 75); // High priority = 75
        assert!(spawn_task.context.contains_key("task_type"));
        assert!(spawn_task.context.contains_key("details"));
    }

    #[test]
    fn test_priority_conversion() {
        assert_eq!(priority_to_int(&Priority::Critical), 100);
        assert_eq!(priority_to_int(&Priority::High), 75);
        assert_eq!(priority_to_int(&Priority::Medium), 50);
        assert_eq!(priority_to_int(&Priority::Low), 25);
    }

    #[test]
    fn test_owned_task_conversion() {
        let task = Task::new(
            "owned-task".to_string(),
            "Test owned conversion".to_string(),
            Priority::Medium,
            TaskType::Testing,
        );

        let spawn_task: SpawnTask = task.into();
        assert_eq!(spawn_task.priority, 50);
    }
}