a3s 0.10.0

a3s — A3S coding agent CLI; `a3s code` launches the interactive TUI
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

use super::*;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum AgentIslandPreferenceCommand {
    Status,
    Enable,
    Disable,
}

pub(super) fn parse_agent_island_preference_command(
    value: &str,
) -> Result<AgentIslandPreferenceCommand, &'static str> {
    match value.trim().to_ascii_lowercase().as_str() {
        "" | "status" => Ok(AgentIslandPreferenceCommand::Status),
        "on" => Ok(AgentIslandPreferenceCommand::Enable),
        "off" => Ok(AgentIslandPreferenceCommand::Disable),
        _ => Err("usage: /island [on|off|status]"),
    }
}

impl AgentIslandSupervisor {
    pub(super) fn set_enabled(&mut self, enabled: bool) {
        if self.enabled == enabled {
            return;
        }
        self.enabled = enabled;
        self.consecutive_failures = 0;
        self.request = None;
        if enabled {
            self.lifecycle = AgentIslandLifecycle::AwaitingSnapshot;
            return;
        }

        let lifecycle = std::mem::replace(&mut self.lifecycle, AgentIslandLifecycle::Stopped);
        if let AgentIslandLifecycle::Running(mut monitor) = lifecycle {
            monitor.stop();
        }
    }
}

impl AgentPresenceRuntime {
    fn apply_island_preference(&mut self, enabled: bool) {
        if self.island.enabled == enabled {
            return;
        }
        self.island.set_enabled(enabled);
    }
}

impl App {
    pub(in crate::tui) fn sync_agent_island_preference(&mut self) {
        let enabled = self.agent_presence.publisher.island_preference_enabled();
        self.agent_presence.apply_island_preference(enabled);
    }

    pub(in crate::tui) fn submit_agent_island_command(&mut self, value: &str) -> Option<Cmd<Msg>> {
        self.textarea.clear();
        let command = match parse_agent_island_preference_command(value) {
            Ok(command) => command,
            Err(usage) => {
                self.push_line(&Style::new().fg(TN_YELLOW).render(&format!("  {usage}")));
                return None;
            }
        };

        if command == AgentIslandPreferenceCommand::Status {
            let enabled = self.agent_presence.publisher.island_preference_enabled();
            let message = if !enabled {
                "  Agent Island is off · /island on enables it".to_string()
            } else if let Some(reason) = AgentIslandEnvironment::current().skip_reason() {
                format!("  Agent Island preference is on · launch unavailable: {reason}")
            } else {
                "  Agent Island is on".to_string()
            };
            self.push_line(&Style::new().fg(TN_GRAY).render(&message));
            return None;
        }

        let enabled = command == AgentIslandPreferenceCommand::Enable;
        if let Err(error) = self
            .agent_presence
            .publisher
            .persist_island_enabled(enabled)
        {
            self.push_line(&Style::new().fg(TN_RED).render(&format!(
                "  could not save Agent Island preference: {error}"
            )));
            return None;
        }

        self.agent_presence.apply_island_preference(enabled);
        let message = if enabled {
            if let Some(reason) = AgentIslandEnvironment::current().skip_reason() {
                format!("  Agent Island preference is on · launch unavailable: {reason}")
            } else {
                "  Agent Island is on".to_string()
            }
        } else {
            "  Agent Island is off · /island on enables it".to_string()
        };
        self.push_line(&Style::new().fg(TN_GRAY).render(&message));
        None
    }
}