ccswarm 0.4.2

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

use crate::error::Result;
/// Type-state pattern for Agent lifecycle management
///
/// This module implements compile-time state machine validation
/// using Rust's type system, ensuring agents can only perform
/// valid state transitions.
use std::marker::PhantomData;

/// Agent states as zero-sized types (zero runtime cost)
pub struct Idle;
pub struct Working;
pub struct Reviewing;
pub struct Completed;

/// Agent with compile-time state tracking
pub struct Agent<State> {
    id: String,
    name: String,
    _state: PhantomData<State>,
}

/// Methods available only in Idle state
impl Agent<Idle> {
    pub fn new(id: String, name: String) -> Self {
        Agent {
            id,
            name,
            _state: PhantomData,
        }
    }

    /// Transition from Idle to Working
    pub fn start_work(self, _task: Task) -> Result<Agent<Working>> {
        tracing::info!("Agent {} starting work on task", self.id);

        Ok(Agent {
            id: self.id,
            name: self.name,
            _state: PhantomData,
        })
    }
}

/// Methods available only in Working state
impl Agent<Working> {
    /// Submit work for review
    pub fn submit_for_review(self) -> Agent<Reviewing> {
        tracing::info!("Agent {} submitting work for review", self.id);

        Agent {
            id: self.id,
            name: self.name,
            _state: PhantomData,
        }
    }

    /// Return to idle if work is cancelled
    pub fn cancel(self) -> Agent<Idle> {
        tracing::warn!("Agent {} work cancelled", self.id);

        Agent {
            id: self.id,
            name: self.name,
            _state: PhantomData,
        }
    }
}

/// Methods available only in Reviewing state
impl Agent<Reviewing> {
    /// Review passed, mark as completed
    pub fn approve(self) -> Agent<Completed> {
        tracing::info!("Agent {} work approved", self.id);

        Agent {
            id: self.id,
            name: self.name,
            _state: PhantomData,
        }
    }

    /// Review failed, return to working
    pub fn request_changes(self) -> Agent<Working> {
        tracing::info!("Agent {} needs to address review comments", self.id);

        Agent {
            id: self.id,
            name: self.name,
            _state: PhantomData,
        }
    }
}

/// Methods available only in Completed state
impl Agent<Completed> {
    /// Reset agent to idle for next task
    pub fn reset(self) -> Agent<Idle> {
        tracing::info!("Agent {} resetting to idle", self.id);

        Agent {
            id: self.id,
            name: self.name,
            _state: PhantomData,
        }
    }
}

/// Common methods available in all states
impl<State> Agent<State> {
    pub fn id(&self) -> &str {
        &self.id
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}

// Import the actual Task from the module
use super::Task;