mars-agents 0.7.0

Agent package manager for .agents/ directories
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

//! Shared probe cache refresh semantics for pi / opencode / cursor caches.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ProbeRefreshMode {
    /// Stale usable cache → return stale and spawn detached `__refresh-probe`.
    #[default]
    Background,
    /// Stale or miss → run probe in-process; never spawn background refresh.
    Synchronous,
    /// No probe subprocess; use disk only (stale if present, else unavailable).
    Skip,
}

impl ProbeRefreshMode {
    pub fn should_spawn_background_on_stale(self, mars_offline: bool) -> bool {
        !mars_offline && self == Self::Background
    }

    pub fn should_sync_probe_on_stale(self, mars_offline: bool) -> bool {
        !mars_offline && self == Self::Synchronous
    }

    pub fn blocks_cold_probe(self, mars_offline: bool) -> bool {
        mars_offline || self == Self::Skip
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProbeCacheBranch<T> {
    Hit(T),
    Stale(T),
    Unavailable,
    SynchronousProbe,
}

pub fn resolve_probe_cache_branch<Entry, Result, CachedResult, IsFresh, TriggerBackground>(
    cached: Option<Entry>,
    mars_offline: bool,
    probe_refresh: ProbeRefreshMode,
    cached_result: CachedResult,
    is_fresh: IsFresh,
    trigger_background: TriggerBackground,
) -> ProbeCacheBranch<Result>
where
    Result: Clone,
    CachedResult: Fn(&Entry) -> Option<&Result>,
    IsFresh: Fn(&Entry) -> bool,
    TriggerBackground: FnOnce(),
{
    if let Some(entry) = cached
        && let Some(result) = cached_result(&entry)
    {
        if is_fresh(&entry) {
            return ProbeCacheBranch::Hit(result.clone());
        }
        if probe_refresh.should_sync_probe_on_stale(mars_offline) {
            return ProbeCacheBranch::SynchronousProbe;
        }
        let result = result.clone();
        if probe_refresh.should_spawn_background_on_stale(mars_offline) {
            trigger_background();
        }
        return ProbeCacheBranch::Stale(result);
    }

    if probe_refresh.blocks_cold_probe(mars_offline) {
        ProbeCacheBranch::Unavailable
    } else {
        ProbeCacheBranch::SynchronousProbe
    }
}