use std::ffi::OsString;
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use crate::RubricEffort;
#[cfg(feature = "codex-acp")]
use crate::{
DEFAULT_CODEX_ACP_MODEL, DEFAULT_CODEX_ACP_REASONING_EFFORT, DEFAULT_SYSTEM_PROMPT,
build_codex_acp_args,
};
#[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"),
#[cfg(feature = "codex-acp")]
acp_args: build_codex_acp_args(
DEFAULT_CODEX_ACP_MODEL,
DEFAULT_CODEX_ACP_REASONING_EFFORT,
),
#[cfg(not(feature = "codex-acp"))]
acp_args: vec!["acp".to_string()],
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()
}
}
}
fn direct_codex_acp_args(rubric: &TomlRubric) -> Vec<String> {
#[cfg(feature = "codex-acp")]
{
build_codex_acp_args(
rubric.model.as_deref().unwrap_or(DEFAULT_CODEX_ACP_MODEL),
rubric
.effort
.as_deref()
.unwrap_or(DEFAULT_CODEX_ACP_REASONING_EFFORT),
)
}
#[cfg(not(feature = "codex-acp"))]
{
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,
}
#[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(),
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(target_os = "linux")]
{
std::env::var("XDG_CONFIG_HOME")
.ok()
.map(PathBuf::from)
.or_else(|| {
std::env::var("HOME")
.ok()
.map(|h| PathBuf::from(h).join(".config"))
})
}
#[cfg(not(target_os = "linux"))]
{
dirs::config_dir()
}
}