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

/// Agent ID and message conversion utilities
///
/// This module handles conversion between different agent representations
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::RwLock;

use crate::coordination::AgentMessage as CCSwarmMessage;
use crate::identity::AgentRole;

/// Agent ID type alias
pub type AgentId = String;

/// Unified agent information across systems
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnifiedAgentInfo {
    /// CCSwarm agent ID
    pub ccswarm_id: String,
    /// Agent role in ccswarm
    pub role: AgentRole,
    /// Active status
    pub active: bool,
    /// Capabilities
    pub capabilities: Vec<String>,
    /// Additional metadata
    pub metadata: serde_json::Value,
}

/// Registry for agent mappings
pub struct AgentMappingRegistry {
    /// Mappings between different agent ID formats
    mappings: RwLock<HashMap<String, UnifiedAgentInfo>>,
}

impl AgentMappingRegistry {
    /// Create a new registry
    pub fn new() -> Self {
        Self {
            mappings: RwLock::new(HashMap::new()),
        }
    }

    /// Register an agent mapping
    pub async fn register(&self, info: UnifiedAgentInfo) -> Result<()> {
        let mut mappings = self
            .mappings
            .write()
            .map_err(|e| anyhow::anyhow!("Failed to acquire write lock: {}", e))?;
        mappings.insert(info.ccswarm_id.clone(), info);
        Ok(())
    }

    /// Get unified agent info
    pub fn get_agent_info(&self, agent_id: &str) -> Option<UnifiedAgentInfo> {
        let mappings = self
            .mappings
            .read()
            .map_err(|e| {
                log::error!("Failed to acquire read lock: {}", e);
                e
            })
            .ok()?;
        mappings.get(agent_id).cloned()
    }

    /// Convert CCSwarm agent ID to unified format
    pub fn to_unified(&self, ccswarm_id: &str) -> String {
        // For now, just return the same ID
        ccswarm_id.to_string()
    }

    /// Convert from unified format to CCSwarm ID
    pub fn from_unified(&self, unified_id: &str) -> String {
        // For now, just return the same ID
        unified_id.to_string()
    }
}

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

/// Convert message types (placeholder)
pub async fn convert_to_ai_session(
    _msg: CCSwarmMessage,
    _registry: &AgentMappingRegistry,
) -> Result<serde_json::Value> {
    Ok(serde_json::json!({}))
}

/// Convert message types back (placeholder)
pub async fn convert_from_ai_session(
    _msg: serde_json::Value,
    _registry: &AgentMappingRegistry,
) -> Result<CCSwarmMessage> {
    Ok(CCSwarmMessage::StatusUpdate {
        agent_id: "system".to_string(),
        status: crate::agent::AgentStatus::Available,
        metrics: serde_json::json!({}),
    })
}