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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Configuration for Claude Code ACP integration

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

/// Configuration for Claude Code ACP connection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClaudeACPConfig {
    /// WebSocket URL for Claude Code (default: ws://localhost:9100)
    pub url: String,

    /// Auto-connect on startup
    pub auto_connect: bool,

    /// Connection timeout in seconds
    pub timeout: u64,

    /// Maximum retry attempts
    pub max_retries: u32,

    /// Retry delay in seconds
    pub retry_delay: u64,

    /// Prefer Claude Code for task execution
    pub prefer_claude: bool,

    /// Enable debug logging
    pub debug: bool,
}

impl Default for ClaudeACPConfig {
    fn default() -> Self {
        Self {
            url: "ws://localhost:9100".to_string(),
            auto_connect: true,
            timeout: 30,
            max_retries: 3,
            retry_delay: 2,
            prefer_claude: true,
            debug: false,
        }
    }
}

impl ClaudeACPConfig {
    /// Create configuration from environment variables
    pub fn from_env() -> Self {
        let mut config = Self::default();

        if let Ok(url) = env::var("CCSWARM_CLAUDE_ACP_URL") {
            config.url = url;
        }

        if let Ok(auto) = env::var("CCSWARM_CLAUDE_ACP_AUTO_CONNECT") {
            config.auto_connect = auto.parse().unwrap_or(true);
        }

        if let Ok(timeout) = env::var("CCSWARM_CLAUDE_ACP_TIMEOUT") {
            if let Ok(t) = timeout.parse() {
                config.timeout = t;
            }
        }

        if let Ok(retries) = env::var("CCSWARM_CLAUDE_ACP_MAX_RETRIES") {
            if let Ok(r) = retries.parse() {
                config.max_retries = r;
            }
        }

        if let Ok(prefer) = env::var("CCSWARM_CLAUDE_ACP_PREFER_CLAUDE") {
            config.prefer_claude = prefer.parse().unwrap_or(true);
        }

        if let Ok(debug) = env::var("CCSWARM_CLAUDE_ACP_DEBUG") {
            config.debug = debug.parse().unwrap_or(false);
        }

        config
    }

    /// Load configuration from file
    pub fn from_file(path: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let content = std::fs::read_to_string(path)?;
        let config: Self = serde_yaml::from_str(&content)?;
        Ok(config)
    }

    /// Create a builder for the configuration
    pub fn builder() -> ConfigBuilder {
        ConfigBuilder::new()
    }
}

/// Builder for ClaudeACPConfig
pub struct ConfigBuilder {
    config: ClaudeACPConfig,
}

impl Default for ConfigBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl ConfigBuilder {
    pub fn new() -> Self {
        Self {
            config: ClaudeACPConfig::default(),
        }
    }

    pub fn url(mut self, url: impl Into<String>) -> Self {
        self.config.url = url.into();
        self
    }

    pub fn auto_connect(mut self, auto: bool) -> Self {
        self.config.auto_connect = auto;
        self
    }

    pub fn timeout(mut self, timeout: u64) -> Self {
        self.config.timeout = timeout;
        self
    }

    pub fn max_retries(mut self, retries: u32) -> Self {
        self.config.max_retries = retries;
        self
    }

    pub fn prefer_claude(mut self, prefer: bool) -> Self {
        self.config.prefer_claude = prefer;
        self
    }

    pub fn build(self) -> ClaudeACPConfig {
        self.config
    }
}