cydonia 0.1.8

Desktop workspace for the ACP agents you run, keeping what they produce as files on your disk
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

//! Personal session choices, scoped to a project and agent, outside the repository.

use super::settings::{self, Agent};
use anyhow::Result;
use cacp::schema::{
    SessionConfigKind, SessionConfigOption, SessionConfigOptionValue, SessionConfigSelectOptions,
    SessionModeState,
};
use serde::{Deserialize, Serialize};
use std::{
    collections::BTreeMap,
    path::{Path, PathBuf},
};

#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default)]
pub struct Choices {
    pub mode: Option<String>,
    pub config: BTreeMap<String, SessionConfigOptionValue>,
}

impl Choices {
    pub fn capture(modes: Option<&SessionModeState>, config: &[SessionConfigOption]) -> Self {
        Self {
            mode: modes.map(|modes| modes.current_mode_id.to_string()),
            config: config
                .iter()
                .map(|option| (option.id.to_string(), current(option)))
                .collect(),
        }
    }
}

pub fn current(option: &SessionConfigOption) -> SessionConfigOptionValue {
    match &option.kind {
        SessionConfigKind::Select(select) => SessionConfigOptionValue::ValueId {
            value: select.current_value.clone(),
        },
        SessionConfigKind::Boolean(flag) => SessionConfigOptionValue::Boolean {
            value: flag.current_value,
        },
    }
}

pub fn supports(option: &SessionConfigOption, value: &SessionConfigOptionValue) -> bool {
    match (&option.kind, value) {
        (SessionConfigKind::Boolean(_), SessionConfigOptionValue::Boolean { .. }) => true,
        (SessionConfigKind::Select(select), SessionConfigOptionValue::ValueId { value }) => {
            match &select.options {
                SessionConfigSelectOptions::Ungrouped(options) => {
                    options.iter().any(|option| &option.value == value)
                }
                SessionConfigSelectOptions::Grouped(groups) => groups
                    .iter()
                    .any(|group| group.options.iter().any(|option| &option.value == value)),
            }
        }
        _ => false,
    }
}

#[derive(Default, Serialize, Deserialize)]
#[serde(default)]
struct AgentChoices {
    defaults: Choices,
    sessions: BTreeMap<String, Choices>,
}

type Stored = BTreeMap<PathBuf, BTreeMap<String, AgentChoices>>;

fn path() -> Result<PathBuf> {
    Ok(settings::dir()?.join("session-preferences.json"))
}

fn agent_key(agent: &Agent) -> String {
    agent
        .id
        .as_ref()
        .map_or_else(|| format!("name:{}", agent.name), |id| format!("id:{id}"))
}

fn read(path: &Path) -> Result<Stored> {
    match std::fs::read(path) {
        Ok(bytes) => Ok(serde_json::from_slice(&bytes)?),
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(Stored::default()),
        Err(error) => Err(error.into()),
    }
}

pub fn load(cwd: &Path, agent: &Agent, session: Option<&str>) -> Choices {
    let stored = path().and_then(|path| read(&path)).unwrap_or_default();
    let Some(agent) = stored
        .get(cwd)
        .and_then(|project| project.get(&agent_key(agent)))
    else {
        return Choices::default();
    };
    session
        .and_then(|session| agent.sessions.get(session))
        .unwrap_or(&agent.defaults)
        .clone()
}

fn edit(cwd: &Path, agent: &Agent, change: impl FnOnce(&mut AgentChoices)) -> Result<()> {
    let path = path()?;
    let mut stored = read(&path)?;
    let before = serde_json::to_vec(&stored)?;
    change(
        stored
            .entry(cwd.to_path_buf())
            .or_default()
            .entry(agent_key(agent))
            .or_default(),
    );
    let after = serde_json::to_vec(&stored)?;
    if before == after {
        return Ok(());
    }
    std::fs::create_dir_all(path.parent().expect("settings directory"))?;
    let temporary = path.with_extension("json.tmp");
    std::fs::write(&temporary, after)?;
    std::fs::rename(temporary, path)?;
    Ok(())
}

pub fn remember_mode(cwd: &Path, agent: &Agent, mode: &str) -> Result<()> {
    edit(cwd, agent, |agent| agent.defaults.mode = Some(mode.into()))
}

pub fn remember_config(
    cwd: &Path,
    agent: &Agent,
    id: &str,
    value: SessionConfigOptionValue,
) -> Result<()> {
    edit(cwd, agent, |agent| {
        agent.defaults.config.insert(id.into(), value);
    })
}

pub fn remember_session(cwd: &Path, agent: &Agent, id: &str, choices: &Choices) -> Result<()> {
    edit(cwd, agent, |agent| {
        agent.sessions.insert(id.into(), choices.clone());
    })
}