greentic 0.1.0

The fastest, most secure and extendable agentic platform
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
106
107
108
109
110
111
112
113
114
115

use async_trait::async_trait;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use tracing::{error, info};
use std::{collections::HashMap, env, path::PathBuf};

#[async_trait::async_trait]
#[typetag::serde] 
pub trait ConfigManagerType: Send + Sync  {
    async fn keys(&self) -> Vec<String>;
    async fn get(&self, key: &str) -> Option<String>;
    async fn set(&mut self, key: &str, value: &str) -> Result<(), String>;
    fn clone_box(&self) -> Box<dyn ConfigManagerType>;
    fn debug_box(&self) -> String;
}

#[derive(Serialize, Deserialize )]
pub struct ConfigManager(pub Box<dyn ConfigManagerType>);

impl ConfigManager {
    pub fn into_inner(self) -> Box<dyn ConfigManagerType> {
        self.0
    }
}

impl Clone for ConfigManager {
    fn clone(&self) -> Self {
        ConfigManager(self.0.clone_box())
    }
}

impl std::fmt::Debug for ConfigManager {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.0.debug_box())
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct EnvConfigManager;

impl EnvConfigManager {
    pub fn new(env_file: PathBuf) -> Box<Self> {
        if env_file.exists() {
            dotenvy::from_path(env_file.clone()).ok();
            info!("Loaded .env from {}", env_file.display());
        } else {
            error!("could not load .env from {}",env_file.display())
        }

        Box::new(Self)
    }
}

#[typetag::serde]
#[async_trait]
impl ConfigManagerType for EnvConfigManager {

    async fn keys(&self) -> Vec<String> {
        env::vars().map(|(k, _)| k).collect()
    }
    async fn get(&self, key: &str) -> Option<String> {
        env::var(key).ok()
    }

    async fn set(&mut self, key: &str, value: &str) -> Result<(), String> {
        unsafe { env::set_var(key, value); };
        Ok(())
    }

    fn clone_box(&self) -> Box<dyn ConfigManagerType> {
        Box::new(self.clone())
    }

    fn debug_box(&self) -> String {
        "EnvConfigManager".to_string()
    }
}



#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct MapConfigManager {
    // simple HashMap → serde will derive Serialize + Deserialize for us
    map: HashMap<String, String>,
}

impl MapConfigManager {
    pub fn new() -> Box<Self> {
        Box::new(Self{map:HashMap::new()})
    }
}

#[typetag::serde]
#[async_trait]
impl ConfigManagerType for MapConfigManager {
    async fn keys(&self) -> Vec<String> {
        self.map.keys().cloned().collect()
    }

    async fn get(&self, key: &str) -> Option<String> {
        self.map.get(key).cloned()
    }

    async fn set(&mut self, key: &str, value: &str) -> Result<(), String> {
        self.map.insert(key.to_string(), value.to_string());
        Ok(())
    }

    fn clone_box(&self) -> Box<dyn ConfigManagerType> {
        Box::new(self.clone())
    }
    fn debug_box(&self) -> String {
        format!("MapConfigManager({} entries)", self.map.len())
    }
}