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 acp_args = match toml.rubric.args {
90 Some(args) => args,
91 None if mode == ConfigMode::Direct => direct_codex_acp_args(&toml.rubric),
92 None => vec!["acp".to_string()],
93 };
94 RubricRunConfig {
95 codex_acp_binary: toml
96 .rubric
97 .backend
98 .unwrap_or_else(|| default_backend.to_string())
99 .into(),
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
130fn direct_codex_acp_args(rubric: &TomlRubric) -> Vec<String> {
131 let _ = rubric;
132 Vec::new()
133}
134
135#[cfg(feature = "codex-acp")]
137#[must_use]
138pub fn default_options() -> RubricOptions {
139 RubricOptions {
140 model: Some(DEFAULT_CODEX_ACP_MODEL.to_string()),
141 effort: Some(DEFAULT_CODEX_ACP_REASONING_EFFORT.into()),
142 system_prompt: Some(DEFAULT_SYSTEM_PROMPT.to_string()),
143 }
144}
145
146#[cfg(feature = "codex-acp")]
148#[must_use]
149pub fn default_codex_acp_binary() -> PathBuf {
150 PathBuf::from("codex-acp")
151}
152
153#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, PartialEq, Eq, clap::ValueEnum)]
155#[serde(rename_all = "kebab-case")]
156pub enum ConfigMode {
157 #[default]
159 Direct,
160 Pipeline,
162}
163
164#[derive(Debug, Deserialize, Serialize, Default)]
166#[serde(default)]
167pub struct TomlConfig {
168 pub mode: Option<ConfigMode>,
170 pub vision: TomlVision,
172 pub rubric: TomlRubric,
174 pub sequence: TomlSequence,
176}
177
178#[derive(Debug, Deserialize, Serialize, Default)]
180#[serde(default)]
181pub struct TomlSequence {
182 pub max_frames: Option<usize>,
184 pub require_transition: Option<bool>,
186}
187
188#[derive(Debug, Deserialize, Serialize, Default)]
190#[serde(default)]
191pub struct TomlVision {
192 pub url: Option<String>,
194 pub model: Option<String>,
196 pub api_key: Option<String>,
198 pub prompt: Option<String>,
200}
201
202#[derive(Debug, Deserialize, Serialize, Default)]
204#[serde(default)]
205pub struct TomlRubric {
206 pub backend: Option<String>,
208 pub args: Option<Vec<String>>,
210 pub url: Option<String>,
214 pub model: Option<String>,
216 pub effort: Option<String>,
218 pub system_prompt: Option<String>,
220}
221
222#[cfg(feature = "codex-acp")]
227#[must_use]
228pub fn direct_codex_gpt_config(model: Option<&str>, effort: Option<&str>) -> TomlConfig {
229 TomlConfig {
230 mode: Some(ConfigMode::Direct),
231 vision: TomlVision::default(),
232 sequence: TomlSequence::default(),
233 rubric: TomlRubric {
234 backend: Some("codex-acp".to_string()),
235 args: None,
236 url: None,
237 model: Some(model.unwrap_or(DEFAULT_CODEX_ACP_MODEL).to_string()),
238 effort: Some(
239 effort
240 .unwrap_or(DEFAULT_CODEX_ACP_REASONING_EFFORT)
241 .to_string(),
242 ),
243 system_prompt: None,
244 },
245 }
246}
247
248pub fn load_config_toml(path: Option<&Path>) -> Result<TomlConfig, std::io::Error> {
254 let path = match path {
255 Some(p) => p.to_path_buf(),
256 None => config_candidates()
257 .into_iter()
258 .find(|candidate| candidate.is_file())
259 .unwrap_or_else(|| PathBuf::from("/etc/visual-rubric/config.toml")),
260 };
261 let content = match std::fs::read_to_string(&path) {
262 Ok(c) => c,
263 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
264 return Ok(TomlConfig::default());
265 }
266 Err(e) => return Err(e),
267 };
268 toml::from_str(&content).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
269}
270
271fn config_candidates() -> Vec<PathBuf> {
272 let mut candidates = Vec::new();
273 if let Some(base) = config_dir() {
274 candidates.push(base.join("visual-rubric/config.toml"));
275 }
276 candidates.push(PathBuf::from("/etc/visual-rubric/config.toml"));
277 candidates
278}
279
280fn config_dir() -> Option<PathBuf> {
281 #[cfg(windows)]
282 {
283 std::env::var_os("APPDATA").map(PathBuf::from)
284 }
285 #[cfg(target_os = "macos")]
286 {
287 std::env::var_os("HOME").map(|h| PathBuf::from(h).join("Library/Application Support"))
288 }
289 #[cfg(not(any(windows, target_os = "macos")))]
290 {
291 std::env::var("XDG_CONFIG_HOME")
292 .ok()
293 .map(PathBuf::from)
294 .or_else(|| {
295 std::env::var("HOME")
296 .ok()
297 .map(|h| PathBuf::from(h).join(".config"))
298 })
299 }
300}