ccswarm 0.4.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

/// Parser for Claude Code subagent definition files
///
/// This module handles parsing of the YAML frontmatter and markdown content
/// from .claude/agents/*.md files
use super::{SubagentDefinition, SubagentError, SubagentResult};
use std::fs;
use std::path::Path;

/// Parser for subagent definition files
pub struct SubagentParser;

impl SubagentParser {
    /// Parse a subagent definition file
    pub fn parse_file(path: &Path) -> SubagentResult<(SubagentDefinition, String)> {
        let content = fs::read_to_string(path)?;
        Self::parse_content(&content)
    }

    /// Parse subagent definition from string content
    pub fn parse_content(content: &str) -> SubagentResult<(SubagentDefinition, String)> {
        // Split the content into frontmatter and body
        let parts: Vec<&str> = content.splitn(3, "---").collect();

        if parts.len() < 3 {
            return Err(SubagentError::Parse(
                "Invalid subagent file format: missing frontmatter".to_string(),
            ));
        }

        // Parse the YAML frontmatter
        let frontmatter = parts[1].trim();
        let body = parts[2].trim();

        let mut definition: SubagentDefinition = serde_yaml::from_str(frontmatter)
            .map_err(|e| SubagentError::Parse(format!("Failed to parse YAML: {}", e)))?;

        // Validate the definition
        Self::validate_definition(&mut definition)?;

        Ok((definition, body.to_string()))
    }

    /// Parse all subagent definitions in a directory
    pub fn parse_directory(dir: &Path) -> SubagentResult<Vec<(SubagentDefinition, String)>> {
        if !dir.exists() {
            return Ok(Vec::new());
        }

        let mut agents = Vec::new();

        for entry in fs::read_dir(dir)? {
            let entry = entry?;
            let path = entry.path();

            if path.extension().and_then(|s| s.to_str()) == Some("md") {
                match Self::parse_file(&path) {
                    Ok(agent) => agents.push(agent),
                    Err(e) => {
                        crate::utils::common::logging::log_parse_warning(
                            &path.display().to_string(),
                            &e,
                        );
                    }
                }
            }
        }

        Ok(agents)
    }

    pub fn validate_definition(definition: &mut SubagentDefinition) -> SubagentResult<()> {
        // Validate that the definition has required fields
        if definition.name.is_empty() {
            return Err(SubagentError::Validation(
                "Subagent name cannot be empty".to_string(),
            ));
        }

        if definition.description.is_empty() {
            return Err(SubagentError::Validation(
                "Subagent description cannot be empty".to_string(),
            ));
        }

        // Validate tools
        if definition.tools.standard.is_empty()
            && definition.tools.semantic.is_empty()
            && definition.tools.memory.is_empty()
            && definition.tools.custom.is_empty()
        {
            return Err(SubagentError::Validation(
                "Subagent must have at least one tool".to_string(),
            ));
        }

        // Validate capabilities
        if definition.capabilities.is_empty() {
            return Err(SubagentError::Validation(
                "Subagent must have at least one capability".to_string(),
            ));
        }

        Ok(())
    }
}