ccswarm 0.9.2

AI Agent Workflow DevOps toolchain complementing Claude Code Agent Teams
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

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

use super::types::ExecutionSessionId;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionContext {
    pub session_id: ExecutionSessionId,
    messages: Vec<Message>,
    total_messages_added: usize,
    active_tokens: usize,
    metadata: HashMap<String, serde_json::Value>,
}

impl SessionContext {
    pub fn new(session_id: ExecutionSessionId) -> Self {
        Self {
            session_id,
            messages: Vec::new(),
            total_messages_added: 0,
            active_tokens: 0,
            metadata: HashMap::new(),
        }
    }

    pub fn add_message_raw(&mut self, role: MessageRole, content: String) {
        let token_count = estimate_tokens(&content);
        self.messages.push(Message {
            role,
            content,
            timestamp: Utc::now(),
            token_count,
        });
        self.total_messages_added += 1;
        self.active_tokens = self.active_tokens.saturating_add(token_count);
        self.compact_if_needed();
    }

    pub async fn compress_context(&mut self) {
        self.compact_if_needed();
    }

    pub fn get_recent_messages(&self, n: usize) -> Vec<&Message> {
        let count = self.messages.len();
        if n >= count {
            self.messages.iter().collect()
        } else {
            self.messages.iter().skip(count - n).collect()
        }
    }

    pub fn get_compression_stats(&self) -> CompressionStats {
        CompressionStats {
            total_messages_added: self.total_messages_added,
            active_messages: self.messages.len(),
            compressed_messages: self
                .total_messages_added
                .saturating_sub(self.messages.len()),
            active_tokens: self.active_tokens,
            tokens_saved: 0,
            compressed_bytes: 0,
            compression_ratio: 0.0,
        }
    }

    fn compact_if_needed(&mut self) {
        const KEEP_RECENT: usize = 40;
        if self.messages.len() <= KEEP_RECENT {
            return;
        }
        let remove_count = self.messages.len() - KEEP_RECENT;
        let removed_tokens: usize = self
            .messages
            .drain(..remove_count)
            .map(|message| message.token_count)
            .sum();
        self.active_tokens = self.active_tokens.saturating_sub(removed_tokens);
    }
}

fn estimate_tokens(content: &str) -> usize {
    if content.is_empty() {
        return 1;
    }
    let word_count = content.split_whitespace().count();
    let char_count = content.chars().count();
    let special_chars = content
        .chars()
        .filter(|c| !c.is_alphanumeric() && !c.is_whitespace())
        .count();
    ((word_count as f64 * 1.3) as usize + special_chars + 2)
        .max(char_count / 4)
        .max(1)
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    pub role: MessageRole,
    pub content: String,
    pub timestamp: DateTime<Utc>,
    pub token_count: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum MessageRole {
    System,
    User,
    Assistant,
    Tool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionStats {
    pub total_messages_added: usize,
    pub active_messages: usize,
    pub compressed_messages: usize,
    pub active_tokens: usize,
    pub tokens_saved: usize,
    pub compressed_bytes: usize,
    pub compression_ratio: f64,
}