1use std::ffi::OsString;
4use std::path::{Path, PathBuf};
5
6use serde::{Deserialize, Serialize};
7
8#[cfg(feature = "codex-acp")]
9use crate::{DEFAULT_CODEX_ACP_MODEL, DEFAULT_CODEX_ACP_REASONING_EFFORT, DEFAULT_SYSTEM_PROMPT};
10use crate::{RubricEffort, SequenceOptions};
11
12#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
14pub struct RubricOptions {
15 pub model: Option<String>,
17 pub effort: Option<RubricEffort>,
19 pub system_prompt: Option<String>,
21}
22
23#[derive(Clone, Debug, PartialEq, Eq)]
32pub struct RubricRunConfig {
33 pub codex_acp_binary: PathBuf,
35 pub acp_args: Vec<String>,
40 pub url: Option<String>,
44 pub api_model: Option<String>,
46 pub extra_env: Vec<(OsString, OsString)>,
48 pub cwd: Option<PathBuf>,
50}
51
52impl Default for RubricRunConfig {
53 fn default() -> Self {
54 Self {
55 #[cfg(feature = "codex-acp")]
56 codex_acp_binary: PathBuf::from("codex-acp"),
57 #[cfg(not(feature = "codex-acp"))]
58 codex_acp_binary: PathBuf::from("opencode"),
59 acp_args: Vec::new(),
60 url: None,
61 api_model: None,
62 extra_env: Vec::new(),
63 cwd: None,
64 }
65 }
66}
67
68impl RubricRunConfig {
69 #[must_use]
79 pub fn from_config_toml(path: Option<&Path>) -> Self {
80 let toml = match load_config_toml(path) {
81 Ok(c) => c,
82 Err(_) => return RubricRunConfig::default(),
83 };
84 let mode = toml.mode.unwrap_or_default();
85 let default_backend = match mode {
86 ConfigMode::Direct => "codex-acp",
87 ConfigMode::Pipeline => "opencode",
88 };
89 let codex_acp_binary: PathBuf = toml
90 .rubric
91 .backend
92 .unwrap_or_else(|| default_backend.to_string())
93 .into();
94 let acp_args = toml
95 .rubric
96 .args
97 .unwrap_or_else(|| default_acp_args(&codex_acp_binary));
98 RubricRunConfig {
99 codex_acp_binary,
100 acp_args,
101 url: toml.rubric.url,
102 api_model: toml.rubric.model.clone(),
103 ..Default::default()
104 }
105 }
106}
107
108impl SequenceOptions {
109 #[must_use]
115 pub fn from_config_toml(path: Option<&Path>) -> Self {
116 let config = load_config_toml(path).ok();
117 let defaults = Self::default();
118 let sequence = config.as_ref().map(|value| &value.sequence);
119 Self {
120 max_frames: sequence
121 .and_then(|value| value.max_frames)
122 .unwrap_or(defaults.max_frames),
123 require_transition: sequence
124 .and_then(|value| value.require_transition)
125 .unwrap_or(defaults.require_transition),
126 }
127 }
128}
129
130pub(crate) fn default_acp_args(binary: &Path) -> Vec<String> {
133 if binary.file_name().is_some_and(|name| name == "opencode") {
134 vec!["acp".to_string()]
135 } else {
136 Vec::new()
137 }
138}
139
140#[cfg(feature = "codex-acp")]
142#[must_use]
143pub fn default_options() -> RubricOptions {
144 RubricOptions {
145 model: Some(DEFAULT_CODEX_ACP_MODEL.to_string()),
146 effort: Some(DEFAULT_CODEX_ACP_REASONING_EFFORT.into()),
147 system_prompt: Some(DEFAULT_SYSTEM_PROMPT.to_string()),
148 }
149}
150
151#[cfg(feature = "codex-acp")]
153#[must_use]
154pub fn default_codex_acp_binary() -> PathBuf {
155 PathBuf::from("codex-acp")
156}
157
158#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, PartialEq, Eq, clap::ValueEnum)]
160#[serde(rename_all = "kebab-case")]
161pub enum ConfigMode {
162 #[default]
164 Direct,
165 Pipeline,
167}
168
169#[derive(Debug, Deserialize, Serialize, Default)]
171#[serde(default)]
172pub struct TomlConfig {
173 pub mode: Option<ConfigMode>,
175 pub vision: TomlVision,
177 pub rubric: TomlRubric,
179 pub sequence: TomlSequence,
181}
182
183#[derive(Debug, Deserialize, Serialize, Default)]
185#[serde(default)]
186pub struct TomlSequence {
187 pub max_frames: Option<usize>,
189 pub require_transition: Option<bool>,
191}
192
193#[derive(Debug, Deserialize, Serialize, Default)]
195#[serde(default)]
196pub struct TomlVision {
197 pub url: Option<String>,
199 pub model: Option<String>,
201 pub api_key: Option<String>,
203 pub prompt: Option<String>,
205}
206
207#[derive(Debug, Deserialize, Serialize, Default)]
209#[serde(default)]
210pub struct TomlRubric {
211 pub backend: Option<String>,
213 pub args: Option<Vec<String>>,
215 pub url: Option<String>,
219 pub model: Option<String>,
221 pub effort: Option<String>,
223 pub system_prompt: Option<String>,
225}
226
227#[cfg(feature = "codex-acp")]
232#[must_use]
233pub fn direct_codex_gpt_config(model: Option<&str>, effort: Option<&str>) -> TomlConfig {
234 TomlConfig {
235 mode: Some(ConfigMode::Direct),
236 vision: TomlVision::default(),
237 sequence: TomlSequence::default(),
238 rubric: TomlRubric {
239 backend: Some("codex-acp".to_string()),
240 args: None,
241 url: None,
242 model: Some(model.unwrap_or(DEFAULT_CODEX_ACP_MODEL).to_string()),
243 effort: Some(
244 effort
245 .unwrap_or(DEFAULT_CODEX_ACP_REASONING_EFFORT)
246 .to_string(),
247 ),
248 system_prompt: None,
249 },
250 }
251}
252
253pub fn load_config_toml(path: Option<&Path>) -> Result<TomlConfig, std::io::Error> {
259 let path = match path {
260 Some(p) => p.to_path_buf(),
261 None => config_candidates()
262 .into_iter()
263 .find(|candidate| candidate.is_file())
264 .unwrap_or_else(|| PathBuf::from("/etc/visual-rubric/config.toml")),
265 };
266 let content = match std::fs::read_to_string(&path) {
267 Ok(c) => c,
268 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
269 return Ok(TomlConfig::default());
270 }
271 Err(e) => return Err(e),
272 };
273 toml::from_str(&content).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
274}
275
276fn config_candidates() -> Vec<PathBuf> {
277 let mut candidates = Vec::new();
278 if let Some(base) = config_dir() {
279 candidates.push(base.join("visual-rubric/config.toml"));
280 }
281 candidates.push(PathBuf::from("/etc/visual-rubric/config.toml"));
282 candidates
283}
284
285fn config_dir() -> Option<PathBuf> {
286 #[cfg(windows)]
287 {
288 std::env::var_os("APPDATA").map(PathBuf::from)
289 }
290 #[cfg(target_os = "macos")]
291 {
292 std::env::var_os("HOME").map(|h| PathBuf::from(h).join("Library/Application Support"))
293 }
294 #[cfg(not(any(windows, target_os = "macos")))]
295 {
296 std::env::var("XDG_CONFIG_HOME")
297 .ok()
298 .map(PathBuf::from)
299 .or_else(|| {
300 std::env::var("HOME")
301 .ok()
302 .map(|h| PathBuf::from(h).join(".config"))
303 })
304 }
305}