chabeau 0.7.3

A full-screen terminal chat interface that connects to various AI APIs for real-time conversations
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
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

use crate::core::config::data::Config;
use std::fs;
use std::path::PathBuf;
use std::sync::{LazyLock, Mutex};
use std::time::SystemTime;

#[derive(Default)]
pub(crate) struct ConfigCacheState {
    config: Option<Config>,
    modified: Option<SystemTime>,
}

pub(crate) struct ConfigOrchestrator {
    path: PathBuf,
    state: Mutex<ConfigCacheState>,
}

pub(crate) static CONFIG_ORCHESTRATOR: LazyLock<ConfigOrchestrator> =
    LazyLock::new(|| ConfigOrchestrator::new(Config::get_config_path()));

#[cfg(test)]
pub(crate) static TEST_ORCHESTRATOR: LazyLock<Mutex<Option<ConfigOrchestrator>>> =
    LazyLock::new(|| Mutex::new(None));

impl ConfigOrchestrator {
    pub(crate) fn new(path: PathBuf) -> Self {
        Self {
            path,
            state: Mutex::new(ConfigCacheState::default()),
        }
    }

    pub(crate) fn load_with_cache(&self) -> Result<Config, Box<dyn std::error::Error>> {
        let mut state = self.state.lock().unwrap();
        let disk_modified = Self::modified_time(&self.path);
        if state.config.is_none() || state.modified != disk_modified {
            let config = Config::load_from_path(&self.path)?;
            state.modified = disk_modified;
            state.config = Some(config);
        }
        Ok(state.config.clone().unwrap_or_default())
    }

    pub(crate) fn persist(&self, config: Config) -> Result<(), Box<dyn std::error::Error>> {
        self.write_config(&config)?;
        let mut state = self.state.lock().unwrap();
        state.modified = Self::modified_time(&self.path);
        state.config = Some(config);
        Ok(())
    }

    pub(crate) fn mutate<F, T>(&self, mutator: F) -> Result<T, Box<dyn std::error::Error>>
    where
        F: FnOnce(&mut Config) -> Result<T, Box<dyn std::error::Error>>,
    {
        let snapshot = {
            let mut state = self.state.lock().unwrap();
            let disk_modified = Self::modified_time(&self.path);
            if state.config.is_none() || state.modified != disk_modified {
                let config = Config::load_from_path(&self.path)?;
                state.modified = disk_modified;
                state.config = Some(config);
            }
            state.config.clone().unwrap_or_default()
        };

        let mut working = snapshot;
        let result = mutator(&mut working)?;
        self.persist(working)?;
        Ok(result)
    }

    fn write_config(&self, config: &Config) -> Result<(), Box<dyn std::error::Error>> {
        config.save_to_path(&self.path)
    }

    fn modified_time(path: &PathBuf) -> Option<SystemTime> {
        fs::metadata(path).ok()?.modified().ok()
    }
}

impl Config {
    pub fn load() -> Result<Config, Box<dyn std::error::Error>> {
        #[cfg(test)]
        {
            if let Some(orchestrator) = TEST_ORCHESTRATOR.lock().unwrap().as_ref() {
                return orchestrator.load_with_cache();
            }
        }
        CONFIG_ORCHESTRATOR.load_with_cache()
    }

    #[cfg(test)]
    pub fn load_test_safe() -> Result<Config, Box<dyn std::error::Error>> {
        Ok(Config::default())
    }

    #[cfg(not(test))]
    pub fn load_test_safe() -> Result<Config, Box<dyn std::error::Error>> {
        Self::load()
    }

    pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
        #[cfg(test)]
        {
            if let Some(orchestrator) = TEST_ORCHESTRATOR.lock().unwrap().as_ref() {
                return orchestrator.persist(self.clone());
            }
        }
        CONFIG_ORCHESTRATOR.persist(self.clone())
    }

    #[cfg(not(test))]
    pub fn mutate<F, T>(mutator: F) -> Result<T, Box<dyn std::error::Error>>
    where
        F: FnOnce(&mut Config) -> Result<T, Box<dyn std::error::Error>>,
    {
        CONFIG_ORCHESTRATOR.mutate(mutator)
    }

    #[cfg(test)]
    pub fn mutate<F, T>(mutator: F) -> Result<T, Box<dyn std::error::Error>>
    where
        F: FnOnce(&mut Config) -> Result<T, Box<dyn std::error::Error>>,
    {
        if let Some(orchestrator) = TEST_ORCHESTRATOR.lock().unwrap().as_ref() {
            orchestrator.mutate(mutator)
        } else {
            let mut config = Config::default();
            let result = mutator(&mut config)?;
            Ok(result)
        }
    }

    #[cfg(test)]
    pub(crate) fn set_test_config_path(path: PathBuf) {
        let mut guard = TEST_ORCHESTRATOR.lock().unwrap();
        *guard = Some(ConfigOrchestrator::new(path));
    }

    #[cfg(test)]
    pub(crate) fn clear_test_config_override() {
        let mut guard = TEST_ORCHESTRATOR.lock().unwrap();
        guard.take();
    }
}