use std::ffi::OsString;
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
#[cfg(feature = "codex-acp")]
use crate::{DEFAULT_CODEX_ACP_MODEL, DEFAULT_CODEX_ACP_REASONING_EFFORT, DEFAULT_SYSTEM_PROMPT};
use crate::{RubricEffort, SequenceOptions};
#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
pub struct RubricOptions {
pub model: Option<String>,
pub effort: Option<RubricEffort>,
pub system_prompt: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RubricRunConfig {
pub codex_acp_binary: PathBuf,
pub acp_args: Vec<String>,
pub url: Option<String>,
pub api_model: Option<String>,
pub extra_env: Vec<(OsString, OsString)>,
pub cwd: Option<PathBuf>,
}
impl Default for RubricRunConfig {
fn default() -> Self {
Self {
#[cfg(feature = "codex-acp")]
codex_acp_binary: PathBuf::from("codex-acp"),
#[cfg(not(feature = "codex-acp"))]
codex_acp_binary: PathBuf::from("opencode"),
acp_args: Vec::new(),
url: None,
api_model: None,
extra_env: Vec::new(),
cwd: None,
}
}
}
impl RubricRunConfig {
#[must_use]
pub fn from_config_toml(path: Option<&Path>) -> Self {
let toml = match load_config_toml(path) {
Ok(c) => c,
Err(_) => return RubricRunConfig::default(),
};
let mode = toml.mode.unwrap_or_default();
let default_backend = match mode {
ConfigMode::Direct => "codex-acp",
ConfigMode::Pipeline => "opencode",
};
let acp_args = match toml.rubric.args {
Some(args) => args,
None if mode == ConfigMode::Direct => direct_codex_acp_args(&toml.rubric),
None => vec!["acp".to_string()],
};
RubricRunConfig {
codex_acp_binary: toml
.rubric
.backend
.unwrap_or_else(|| default_backend.to_string())
.into(),
acp_args,
url: toml.rubric.url,
api_model: toml.rubric.model.clone(),
..Default::default()
}
}
}
impl SequenceOptions {
#[must_use]
pub fn from_config_toml(path: Option<&Path>) -> Self {
let config = load_config_toml(path).ok();
let defaults = Self::default();
let sequence = config.as_ref().map(|value| &value.sequence);
Self {
max_frames: sequence
.and_then(|value| value.max_frames)
.unwrap_or(defaults.max_frames),
require_transition: sequence
.and_then(|value| value.require_transition)
.unwrap_or(defaults.require_transition),
}
}
}
fn direct_codex_acp_args(rubric: &TomlRubric) -> Vec<String> {
let _ = rubric;
Vec::new()
}
#[cfg(feature = "codex-acp")]
#[must_use]
pub fn default_options() -> RubricOptions {
RubricOptions {
model: Some(DEFAULT_CODEX_ACP_MODEL.to_string()),
effort: Some(DEFAULT_CODEX_ACP_REASONING_EFFORT.into()),
system_prompt: Some(DEFAULT_SYSTEM_PROMPT.to_string()),
}
}
#[cfg(feature = "codex-acp")]
#[must_use]
pub fn default_codex_acp_binary() -> PathBuf {
PathBuf::from("codex-acp")
}
#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, PartialEq, Eq, clap::ValueEnum)]
#[serde(rename_all = "kebab-case")]
pub enum ConfigMode {
#[default]
Direct,
Pipeline,
}
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(default)]
pub struct TomlConfig {
pub mode: Option<ConfigMode>,
pub vision: TomlVision,
pub rubric: TomlRubric,
pub sequence: TomlSequence,
}
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(default)]
pub struct TomlSequence {
pub max_frames: Option<usize>,
pub require_transition: Option<bool>,
}
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(default)]
pub struct TomlVision {
pub url: Option<String>,
pub model: Option<String>,
pub api_key: Option<String>,
pub prompt: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(default)]
pub struct TomlRubric {
pub backend: Option<String>,
pub args: Option<Vec<String>>,
pub url: Option<String>,
pub model: Option<String>,
pub effort: Option<String>,
pub system_prompt: Option<String>,
}
#[cfg(feature = "codex-acp")]
#[must_use]
pub fn direct_codex_gpt_config(model: Option<&str>, effort: Option<&str>) -> TomlConfig {
TomlConfig {
mode: Some(ConfigMode::Direct),
vision: TomlVision::default(),
sequence: TomlSequence::default(),
rubric: TomlRubric {
backend: Some("codex-acp".to_string()),
args: None,
url: None,
model: Some(model.unwrap_or(DEFAULT_CODEX_ACP_MODEL).to_string()),
effort: Some(
effort
.unwrap_or(DEFAULT_CODEX_ACP_REASONING_EFFORT)
.to_string(),
),
system_prompt: None,
},
}
}
pub fn load_config_toml(path: Option<&Path>) -> Result<TomlConfig, std::io::Error> {
let path = match path {
Some(p) => p.to_path_buf(),
None => config_candidates()
.into_iter()
.find(|candidate| candidate.is_file())
.unwrap_or_else(|| PathBuf::from("/etc/visual-rubric/config.toml")),
};
let content = match std::fs::read_to_string(&path) {
Ok(c) => c,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Ok(TomlConfig::default());
}
Err(e) => return Err(e),
};
toml::from_str(&content).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
}
fn config_candidates() -> Vec<PathBuf> {
let mut candidates = Vec::new();
if let Some(base) = config_dir() {
candidates.push(base.join("visual-rubric/config.toml"));
}
candidates.push(PathBuf::from("/etc/visual-rubric/config.toml"));
candidates
}
fn config_dir() -> Option<PathBuf> {
#[cfg(windows)]
{
std::env::var_os("APPDATA").map(PathBuf::from)
}
#[cfg(target_os = "macos")]
{
std::env::var_os("HOME").map(|h| PathBuf::from(h).join("Library/Application Support"))
}
#[cfg(not(any(windows, target_os = "macos")))]
{
std::env::var("XDG_CONFIG_HOME")
.ok()
.map(PathBuf::from)
.or_else(|| {
std::env::var("HOME")
.ok()
.map(|h| PathBuf::from(h).join(".config"))
})
}
}