forjar 1.4.2

Rust-native Infrastructure as Code — bare-metal first, BLAKE3 state, provenance tracing
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

//! Tests: FJ-1437 agent registry.

#![allow(unused_imports)]
use super::agent_registry::*;
use std::path::Path;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_load_empty_registry() {
        let dir = tempfile::tempdir().unwrap();
        let reg = load_agent_registry(dir.path()).unwrap();
        assert!(reg.recipes.is_empty());
    }

    #[test]
    fn test_save_and_load() {
        let dir = tempfile::tempdir().unwrap();
        let mut reg = AgentRegistry::default();
        reg.recipes.push(AgentRecipe {
            name: "code-helper".to_string(),
            description: "Code assistant agent".to_string(),
            category: AgentCategory::CodeAssistant,
            version: "1.0.0".to_string(),
            model: "claude-sonnet".to_string(),
            gpu_required: false,
            mcp_servers: vec!["filesystem".to_string()],
            health_check: Some("curl localhost:8080/health".to_string()),
            tags: vec!["code".to_string()],
        });
        save_agent_registry(dir.path(), &reg).unwrap();
        let loaded = load_agent_registry(dir.path()).unwrap();
        assert_eq!(loaded.recipes.len(), 1);
        assert_eq!(loaded.recipes[0].name, "code-helper");
    }

    #[test]
    fn test_search_agents() {
        let reg = AgentRegistry {
            recipes: vec![
                AgentRecipe {
                    name: "code-helper".to_string(),
                    description: "Code assistant".to_string(),
                    category: AgentCategory::CodeAssistant,
                    version: "1.0.0".to_string(),
                    model: "claude".to_string(),
                    gpu_required: false,
                    mcp_servers: vec![],
                    health_check: None,
                    tags: vec!["coding".to_string()],
                },
                AgentRecipe {
                    name: "data-bot".to_string(),
                    description: "Data analyst".to_string(),
                    category: AgentCategory::DataAnalyst,
                    version: "1.0.0".to_string(),
                    model: "claude".to_string(),
                    gpu_required: true,
                    mcp_servers: vec![],
                    health_check: None,
                    tags: vec!["data".to_string()],
                },
            ],
        };
        assert_eq!(search_agents(&reg, "code").len(), 1);
        assert_eq!(search_agents(&reg, "data").len(), 1);
        assert_eq!(search_agents(&reg, "coding").len(), 1);
    }

    #[test]
    fn test_cmd_agent_registry() {
        let dir = tempfile::tempdir().unwrap();
        let result = cmd_agent_registry(dir.path(), None, true);
        assert!(result.is_ok());
    }

    #[test]
    fn test_agent_category_display() {
        assert_eq!(format!("{}", AgentCategory::CodeAssistant), "code-assistant");
        assert_eq!(format!("{}", AgentCategory::SecurityAuditor), "security-auditor");
    }

    #[test]
    fn test_agent_recipe_serde() {
        let recipe = AgentRecipe {
            name: "test".to_string(),
            description: "test".to_string(),
            category: AgentCategory::Custom,
            version: "1.0.0".to_string(),
            model: "test".to_string(),
            gpu_required: false,
            mcp_servers: vec![],
            health_check: None,
            tags: vec![],
        };
        let json = serde_json::to_string(&recipe).unwrap();
        let round: AgentRecipe = serde_json::from_str(&json).unwrap();
        assert_eq!(round.name, "test");
    }
}