magi-code 0.63.0

Repository-aware CLI coding agent for terminal work
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

use std::{
    ffi::{OsStr, OsString},
    sync::{Mutex, MutexGuard, OnceLock},
};

static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();

pub(crate) struct EnvGuard {
    _guard: MutexGuard<'static, ()>,
}

impl EnvGuard {
    pub(crate) fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(&self, key: K, value: V) {
        // SAFETY: EnvGuard holds the global test environment mutex while mutating process env.
        unsafe { std::env::set_var(key, value) };
    }

    pub(crate) fn remove_var<K: AsRef<OsStr>>(&self, key: K) {
        // SAFETY: EnvGuard holds the global test environment mutex while mutating process env.
        unsafe { std::env::remove_var(key) };
    }

    pub(crate) fn save(&self, name: &'static str) -> SavedEnvVar<'_> {
        SavedEnvVar {
            name,
            value: std::env::var_os(name),
            guard: self,
        }
    }
}

pub(crate) fn env_lock() -> EnvGuard {
    EnvGuard {
        _guard: ENV_LOCK.get_or_init(|| Mutex::new(())).lock().unwrap(),
    }
}

pub(crate) struct SavedEnvVar<'a> {
    name: &'static str,
    value: Option<OsString>,
    guard: &'a EnvGuard,
}

impl Drop for SavedEnvVar<'_> {
    fn drop(&mut self) {
        match self.value.as_ref() {
            Some(value) => self.guard.set_var(self.name, value),
            None => self.guard.remove_var(self.name),
        }
    }
}

static CURRENT_DIR_LOCK: OnceLock<Mutex<()>> = OnceLock::new();

pub(crate) struct CurrentDirGuard {
    original: std::path::PathBuf,
    _guard: MutexGuard<'static, ()>,
    restored: bool,
}

impl CurrentDirGuard {
    pub(crate) fn capture() -> Self {
        let guard = CURRENT_DIR_LOCK
            .get_or_init(|| Mutex::new(()))
            .lock()
            .unwrap();
        Self {
            original: std::env::current_dir().unwrap(),
            _guard: guard,
            restored: false,
        }
    }

    pub(crate) fn set_current_dir(&self, path: impl AsRef<std::path::Path>) -> std::io::Result<()> {
        std::env::set_current_dir(path)
    }

    pub(crate) fn restore(&mut self) -> std::io::Result<()> {
        let result = std::env::set_current_dir(&self.original);
        if result.is_ok() {
            self.restored = true;
        }
        result
    }
}

impl Drop for CurrentDirGuard {
    fn drop(&mut self) {
        if !self.restored {
            let _ = std::env::set_current_dir(&self.original);
        }
    }
}