ccswarm 0.4.1

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
127
128

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Agent personality traits
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Personality {
    pub traits: Vec<String>,
    pub style: String,
    pub approach: String,
    pub skills: HashMap<String, Skill>,
    pub working_style: String,
}

impl Personality {
    pub fn new(style: String) -> Self {
        Self {
            traits: Vec::new(),
            style,
            approach: String::from("collaborative"),
            skills: HashMap::new(),
            working_style: String::from("balanced"),
        }
    }

    pub fn add_trait(&mut self, trait_name: String) {
        self.traits.push(trait_name);
    }

    pub fn set_approach(&mut self, approach: String) {
        self.approach = approach;
    }

    pub fn describe_personality(&self) -> String {
        format!(
            "Style: {}, Approach: {}, Traits: {:?}, Skills: {:?}",
            self.style,
            self.approach,
            self.traits,
            self.skills.keys().collect::<Vec<_>>()
        )
    }

    pub fn composability_score(&self) -> f32 {
        // Calculate composability based on collaborative traits
        let collaborative_traits = ["cooperative", "flexible", "team-oriented"];
        let score = self
            .traits
            .iter()
            .filter(|t| collaborative_traits.contains(&t.as_str()))
            .count() as f32;
        (score / collaborative_traits.len() as f32).min(1.0)
    }
}

impl Default for Personality {
    fn default() -> Self {
        Self::new(String::from("neutral"))
    }
}

/// Agent personality configuration
pub type AgentPersonality = Personality;

/// Personality traits
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PersonalityTraits {
    Analytical,
    Creative,
    Methodical,
    Collaborative,
    Innovative,
}

/// Skill level
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Skill {
    pub name: String,
    pub level: SkillLevel,
    pub experience: f32,
    pub experience_points: u32,
    pub relevance_score: f32,
    pub language: String,
    pub framework: String,
}

impl Skill {
    pub fn new(name: String, level: SkillLevel) -> Self {
        Self {
            name: name.clone(),
            level,
            experience: 0.0,
            experience_points: 0,
            relevance_score: 0.5,
            language: String::new(),
            framework: String::new(),
        }
    }

    pub fn add_experience(&mut self, exp: f32) {
        self.experience += exp;
    }
}

/// Skill level
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SkillLevel {
    Beginner,
    Intermediate,
    Advanced,
    Expert,
}

/// Task approach
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskApproach {
    Sequential,
    Parallel,
    Hybrid,
}

/// Working style
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum WorkingStyle {
    Independent,
    TeamPlayer,
    Leader,
    Support,
}