hippox 0.5.8

🦛A reliable, autonomous LLM runtime and skill orchestration engine, Capable of processing natural language and automatically executing OS-native atomic skills, fundamentally enabling the LLM to truly take over the computer.
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

//! Core configuration structure and global state

use once_cell::sync::Lazy;
use std::collections::HashMap;
use std::sync::RwLock;

/// Global static configuration instance
pub(crate) static HIPPOX_CORE_CONFIG: Lazy<RwLock<HippoxConfig>> =
    Lazy::new(|| RwLock::new(HippoxConfig::default()));

#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
pub struct IdentityInformation {
    // Name, Default: Hippox
    pub name: Option<String>,
    // Sex
    pub sex: Option<String>,
    // age
    pub age: Option<String>,
    // Species
    pub species: Option<String>,
    // Role/Profession (e.g., "assistant", "teacher", "life coach")
    pub role: Option<String>,
    // Personality traits (e.g., "friendly", "humorous", "professional")
    pub personality: Option<String>,
    // Tone style (e.g., "casual", "formal", "poetic")
    pub tone_style: Option<String>,
    // Knowledge scope (e.g., "general", "medical", "programming")
    pub knowledge_scope: Option<String>,
    // Catchphrase / habitual expression (e.g., "Haha", "I see")
    pub catchphrase: Option<String>,
    // Taboos / prohibited topics (e.g., "no politics", "no medical advice")
    pub taboos: Option<String>,
}

impl Default for IdentityInformation {
    fn default() -> Self {
        Self {
            name: Some("Hippox".to_string()),
            sex: None,
            age: None,
            species: None,
            role: None,
            personality: None,
            tone_style: None,
            knowledge_scope: None,
            catchphrase: None,
            taboos: None,
        }
    }
}

/// Hippox global configuration
#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
pub struct HippoxConfig {
    // Application settings
    pub lang: String,
    // Identity information
    pub identity_information: IdentityInformation,
}

impl Default for HippoxConfig {
    fn default() -> Self {
        Self {
            lang: "en".to_string(),
            identity_information: IdentityInformation::default(),
        }
    }
}

impl HippoxConfig {
    /// Get identity information reference
    pub fn get_identity(&self) -> &IdentityInformation {
        &self.identity_information
    }

    /// Get mutable identity information reference
    pub fn get_identity_mut(&mut self) -> &mut IdentityInformation {
        &mut self.identity_information
    }

    /// Update identity information
    pub fn update_identity<F>(&mut self, f: F) -> &mut Self
    where
        F: FnOnce(&mut IdentityInformation),
    {
        f(&mut self.identity_information);
        self
    }

    /// Load from TOML configuration file
    pub fn load_from_toml_file(path: &str) -> anyhow::Result<Self> {
        let content = std::fs::read_to_string(path)?;
        let config: HippoxConfig = toml::from_str(&content)?;
        Ok(config)
    }

    /// Load from JSON configuration file
    pub fn load_from_json_file(path: &str) -> anyhow::Result<Self> {
        let content = std::fs::read_to_string(path)?;
        let config: HippoxConfig = serde_json::from_str(&content)?;
        Ok(config)
    }
}

/// Get a clone of the global configuration
pub fn get_config() -> HippoxConfig {
    HIPPOX_CORE_CONFIG.read().unwrap().clone()
}

/// Update config with a closure
pub fn update_config<F>(f: F) -> anyhow::Result<()>
where
    F: FnOnce(&mut HippoxConfig),
{
    let mut global = HIPPOX_CORE_CONFIG.write().unwrap();
    f(&mut global);
    Ok(())
}

/// Get current language setting
pub fn get_lang() -> String {
    HIPPOX_CORE_CONFIG.read().unwrap().lang.clone()
}

/// Set language
pub fn set_lang(lang: String) -> anyhow::Result<()> {
    let mut config = HIPPOX_CORE_CONFIG.write().unwrap();
    config.lang = lang;
    Ok(())
}

/// Get the global Hippox core configuration (alias for get_config for backward compatibility)
pub fn get_hippox_core_config() -> HippoxConfig {
    HIPPOX_CORE_CONFIG.read().unwrap().clone()
}