hippox 0.5.0

🦛A reliable AI agent and skills orchestration runtime engine.
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
141
142
143
144
145
146
147
148
149
150

//! Registry generation for skills and instances

use serde_json::{Value, json};
use crate::get_config;

const STARTUP_BANNER: &str = r#"
██╗  ██╗██╗██████╗ ██████╗  ██████╗ ██╗  ██╗
██║  ██║██║██╔══██╗██╔══██╗██╔═══██╗╚██╗██╔╝
███████║██║██████╔╝██████╔╝██║   ██║ ╚███╔╝ 
██╔══██║██║██╔═══╝ ██╔═══╝ ██║   ██║ ██╔██╗ 
██║  ██║██║██║     ██║     ╚██████╔╝██╔╝ ██╗
╚═╝  ╚═╝╚═╝╚═╝     ╚═╝      ╚═════╝ ╚═╝  ╚═╝
"#;

/// Generate skills registry (atomic skills metadata)
pub fn generate_skills_registry() -> String {
    let skills = crate::executors::registry::list_skills();
    let registry: Vec<serde_json::Value> = skills
        .iter()
        .filter_map(|name| {
            crate::executors::registry::get_skill(name).map(|skill| {
                serde_json::json!({
                    "name": name,
                    "description": skill.description(),
                    "category": skill.category(),
                    "parameters": skill.parameters(),
                    "example_call": skill.example_call(),
                    "example_output": skill.example_output(),
                })
            })
        })
        .collect();
    serde_json::to_string_pretty(&registry).unwrap_or_else(|_| "[]".to_string())
}

/// Generate instances registry (configured database/service instances)
pub fn generate_instances_registry() -> String {
    let config = get_config();
    let mut instances = serde_json::Map::new();
    
    // PostgreSQL instances
    let pg_instances: Vec<serde_json::Value> = config
        .postgresql_instances
        .values()
        .map(|inst| {
            json!({
                "id": inst.id,
                "name": inst.name,
                "description": inst.description,
                "type": "postgresql"
            })
        })
        .collect();
    if !pg_instances.is_empty() {
        instances.insert("postgresql".to_string(), json!(pg_instances));
    }
    
    // MySQL instances
    let mysql_instances: Vec<serde_json::Value> = config
        .mysql_instances
        .values()
        .map(|inst| {
            json!({
                "id": inst.id,
                "name": inst.name,
                "description": inst.description,
                "type": "mysql"
            })
        })
        .collect();
    if !mysql_instances.is_empty() {
        instances.insert("mysql".to_string(), json!(mysql_instances));
    }
    
    // Redis instances
    let redis_instances: Vec<serde_json::Value> = config
        .redis_instances
        .values()
        .map(|inst| {
            json!({
                "id": inst.id,
                "name": inst.name,
                "description": inst.description,
                "type": "redis"
            })
        })
        .collect();
    if !redis_instances.is_empty() {
        instances.insert("redis".to_string(), json!(redis_instances));
    }
    
    // SQLite instances
    let sqlite_instances: Vec<serde_json::Value> = config
        .sqlite_instances
        .values()
        .map(|inst| {
            json!({
                "id": inst.id,
                "name": inst.name,
                "description": inst.description,
                "type": "sqlite"
            })
        })
        .collect();
    if !sqlite_instances.is_empty() {
        instances.insert("sqlite".to_string(), json!(sqlite_instances));
    }
    
    // Docker instances
    let docker_instances: Vec<serde_json::Value> = config
        .docker_instances
        .values()
        .map(|inst| {
            json!({
                "id": inst.id,
                "name": inst.name,
                "description": inst.description,
                "type": "docker"
            })
        })
        .collect();
    if !docker_instances.is_empty() {
        instances.insert("docker".to_string(), json!(docker_instances));
    }
    
    // Kubernetes instances
    let k8s_instances: Vec<serde_json::Value> = config
        .k8s_instances
        .values()
        .map(|inst| {
            json!({
                "id": inst.id,
                "name": inst.name,
                "description": inst.description,
                "type": "kubernetes",
                "namespace": inst.namespace
            })
        })
        .collect();
    if !k8s_instances.is_empty() {
        instances.insert("kubernetes".to_string(), json!(k8s_instances));
    }
    
    serde_json::to_string_pretty(&instances).unwrap_or_else(|_| "{}".to_string())
}

/// Get the startup banner
pub fn get_startup_banner() -> &'static str {
    STARTUP_BANNER
}