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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

//! Output formatting utilities for CLI

use serde::Serialize;
use serde_json::Value;

/// Enum to hold different formatter types
pub enum OutputFormatter {
    Json(JsonFormatter),
    Human(HumanFormatter),
}

impl OutputFormatter {
    /// Format a success message
    pub fn format_success(&self, message: &str, data: Option<Value>) -> String {
        match self {
            OutputFormatter::Json(f) => f.format_success(message, data),
            OutputFormatter::Human(f) => f.format_success(message, data),
        }
    }

    /// Format an error message
    #[allow(dead_code)]
    pub fn format_error(&self, error: &str) -> String {
        match self {
            OutputFormatter::Json(f) => f.format_error(error),
            OutputFormatter::Human(f) => f.format_error(error),
        }
    }

    /// Format a list of items
    #[allow(dead_code)]
    pub fn format_list<T: Serialize>(&self, items: &[T], title: &str) -> String {
        match self {
            OutputFormatter::Json(f) => f.format_list(items, title),
            OutputFormatter::Human(f) => f.format_list(items, title),
        }
    }

    /// Format a status report
    #[allow(dead_code)]
    pub fn format_status<T: Serialize>(&self, status: &T, title: &str) -> String {
        match self {
            OutputFormatter::Json(f) => f.format_status(status, title),
            OutputFormatter::Human(f) => f.format_status(status, title),
        }
    }
}

/// JSON output formatter
pub struct JsonFormatter;

impl JsonFormatter {
    pub fn format_success(&self, message: &str, data: Option<Value>) -> String {
        let mut result = serde_json::json!({
            "status": "success",
            "message": message
        });

        if let Some(data) = data {
            result["data"] = data;
        }

        serde_json::to_string_pretty(&result).unwrap_or_else(|_| message.to_string())
    }

    #[allow(dead_code)]
    pub fn format_error(&self, error: &str) -> String {
        let result = serde_json::json!({
            "status": "error",
            "error": error
        });

        serde_json::to_string_pretty(&result).unwrap_or_else(|_| error.to_string())
    }

    #[allow(dead_code)]
    pub fn format_list<T: Serialize>(&self, items: &[T], title: &str) -> String {
        let result = serde_json::json!({
            "title": title,
            "count": items.len(),
            "items": items
        });

        serde_json::to_string_pretty(&result)
            .unwrap_or_else(|_| format!("{}: {} items", title, items.len()))
    }

    #[allow(dead_code)]
    pub fn format_status<T: Serialize>(&self, status: &T, title: &str) -> String {
        let result = serde_json::json!({
            "title": title,
            "status": status
        });

        serde_json::to_string_pretty(&result).unwrap_or_else(|_| title.to_string())
    }
}

/// Human-readable output formatter
pub struct HumanFormatter;

impl HumanFormatter {
    pub fn format_success(&self, message: &str, data: Option<Value>) -> String {
        if let Some(data) = data {
            format!(
                "✅ {}\n\n{}",
                message,
                serde_json::to_string_pretty(&data).unwrap_or_default()
            )
        } else {
            format!("✅ {}", message)
        }
    }

    #[allow(dead_code)]
    pub fn format_error(&self, error: &str) -> String {
        format!("❌ Error: {}", error)
    }

    #[allow(dead_code)]
    pub fn format_list<T: Serialize>(&self, items: &[T], title: &str) -> String {
        let mut output = format!("📋 {} ({} items):\n", title, items.len());

        for (i, item) in items.iter().enumerate() {
            if let Ok(json) = serde_json::to_value(item) {
                output.push_str(&format!("  {}. {}\n", i + 1, format_item(&json)));
            }
        }

        output
    }

    #[allow(dead_code)]
    pub fn format_status<T: Serialize>(&self, status: &T, title: &str) -> String {
        format!(
            "📊 {}:\n{}",
            title,
            serde_json::to_string_pretty(status).unwrap_or_default()
        )
    }
}

/// Format a JSON value as a human-readable string
#[allow(dead_code)]
fn format_item(value: &Value) -> String {
    match value {
        Value::String(s) => s.clone(),
        Value::Object(obj) => {
            if let Some(name) = obj.get("name").and_then(|v| v.as_str()) {
                if let Some(status) = obj.get("status").and_then(|v| v.as_str()) {
                    format!("{} ({})", name, status)
                } else {
                    name.to_string()
                }
            } else if let Some(id) = obj.get("id").and_then(|v| v.as_str()) {
                id.to_string()
            } else {
                serde_json::to_string(value).unwrap_or_default()
            }
        }
        _ => value.to_string(),
    }
}

/// Create a formatter based on output format preference
pub fn create_formatter(json: bool) -> OutputFormatter {
    if json {
        OutputFormatter::Json(JsonFormatter)
    } else {
        OutputFormatter::Human(HumanFormatter)
    }
}