use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::env;
use std::fs;
use std::path::{Path, PathBuf};
const SETTINGS_VERSION: u32 = 7;
pub const KNOWN_CHANNELS: &[(&str, &str)] = &[
("response", "Your conversational responses to the user"),
(
"code_comment",
"Code comments you write (//, /* */, #, etc.)",
),
(
"documentation",
"Documentation (markdown files, README, AGENTS.md, doc comments)",
),
("commit_message", "Git commit messages (subject + body)"),
];
pub const KNOWN_LANGS: &[(&str, &str)] = &[
("auto", "Auto (match user)"),
("en", "English"),
("ko", "Korean (한국어)"),
("ja", "Japanese (日本語)"),
("zh", "Chinese (中文)"),
("es", "Spanish"),
("fr", "French"),
("de", "German"),
];
#[allow(dead_code)]
const ENV_PREFIX: &str = "OXI_";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ThinkingLevel {
#[default]
Off,
Minimal,
Low,
Medium,
High,
XHigh,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum EditFormat {
#[default]
Hashline,
StrReplace,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CustomProvider {
pub name: String,
pub base_url: String,
pub api_key_env: String,
#[serde(default = "default_custom_provider_api")]
pub api: String,
}
fn default_custom_provider_api() -> String {
"openai-completions".to_string()
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Settings {
#[serde(default)]
pub version: u32,
#[serde(default = "default_thinking_level")]
pub thinking_level: ThinkingLevel,
#[serde(default = "default_theme")]
pub theme: String,
#[serde(default, skip_serializing)]
pub default_model: Option<String>,
#[serde(default, skip_serializing)]
pub default_provider: Option<String>,
#[serde(default)]
pub last_used_model: Option<String>,
#[serde(default)]
pub last_used_provider: Option<String>,
pub max_tokens: Option<u32>,
pub temperature: Option<f32>,
pub default_temperature: Option<f64>,
pub max_response_tokens: Option<usize>,
#[serde(default = "default_session_history_size")]
pub session_history_size: usize,
pub session_dir: Option<PathBuf>,
#[serde(default = "default_true")]
pub stream_responses: bool,
#[serde(default = "default_true")]
pub extensions_enabled: bool,
#[serde(default = "default_true")]
pub auto_compaction: bool,
#[serde(default)]
pub disabled_tools: Vec<String>,
#[serde(default = "default_tool_timeout")]
pub tool_timeout_seconds: u64,
#[serde(default)]
pub questionnaire_timeout_secs: u64,
#[serde(default)]
pub extensions: Vec<String>,
#[serde(default)]
pub skills: Vec<String>,
#[serde(default)]
pub prompts: Vec<String>,
#[serde(default)]
pub themes: Vec<String>,
#[serde(default)]
pub custom_providers: Vec<CustomProvider>,
#[serde(default)]
pub dynamic_models: HashMap<String, Vec<String>>,
#[serde(default = "default_false")]
pub enable_routing: bool,
#[serde(default)]
pub router_profile: Option<String>,
#[serde(default = "default_true")]
pub prefer_cost_efficient: bool,
#[serde(default)]
pub fallback_chain: Vec<String>,
#[serde(default = "default_true")]
pub enable_fallback: bool,
#[serde(default)]
pub disable_fallback: bool,
#[serde(default = "default_circuit_failure_threshold")]
pub circuit_breaker_failure_threshold: u32,
#[serde(default = "default_circuit_open_duration_secs")]
pub circuit_breaker_open_duration_secs: u64,
#[serde(default)]
pub keybindings: HashMap<String, Vec<String>>,
#[serde(default)]
pub output_languages: HashMap<String, String>,
#[serde(default = "default_false")]
pub language_policy_enabled: bool,
#[serde(default)]
pub edit_format: EditFormat,
#[serde(default = "default_false")]
pub memory_enabled: bool,
#[serde(default)]
pub memory_db_path: Option<PathBuf>,
#[serde(default = "default_false")]
pub ttsr_enabled: bool,
#[serde(default = "default_ttsr_mode")]
pub ttsr_interrupt_mode: String,
}
fn default_theme() -> String {
"default".to_string()
}
fn default_thinking_level() -> ThinkingLevel {
ThinkingLevel::Medium
}
fn default_session_history_size() -> usize {
100
}
fn default_true() -> bool {
true
}
fn default_false() -> bool {
false
}
fn default_ttsr_mode() -> String {
"prose_only".to_string()
}
fn default_circuit_failure_threshold() -> u32 {
5
}
fn default_circuit_open_duration_secs() -> u64 {
30
}
fn default_tool_timeout() -> u64 {
120
}
impl Default for Settings {
fn default() -> Self {
Self {
version: SETTINGS_VERSION,
thinking_level: ThinkingLevel::Medium,
theme: default_theme(),
last_used_model: None,
last_used_provider: None,
default_model: None,
default_provider: None,
max_tokens: None,
temperature: None,
default_temperature: None,
max_response_tokens: None,
session_history_size: default_session_history_size(),
session_dir: None,
stream_responses: true,
extensions_enabled: true,
auto_compaction: true,
disabled_tools: Vec::new(),
tool_timeout_seconds: default_tool_timeout(),
questionnaire_timeout_secs: 0,
extensions: Vec::new(),
skills: Vec::new(),
prompts: Vec::new(),
themes: Vec::new(),
custom_providers: Vec::new(),
dynamic_models: HashMap::new(),
enable_routing: false,
router_profile: None,
prefer_cost_efficient: true,
fallback_chain: Vec::new(),
enable_fallback: true,
disable_fallback: false,
circuit_breaker_failure_threshold: 5,
circuit_breaker_open_duration_secs: 30,
keybindings: HashMap::new(),
output_languages: HashMap::new(),
language_policy_enabled: false,
edit_format: EditFormat::default(),
memory_enabled: false,
memory_db_path: None,
ttsr_enabled: false,
ttsr_interrupt_mode: default_ttsr_mode(),
}
}
}
impl Settings {
pub fn settings_dir() -> Result<PathBuf> {
let base = dirs::home_dir().context("Cannot determine home directory")?;
Ok(base.join(".oxi"))
}
pub fn settings_toml_path() -> Result<PathBuf> {
Ok(Self::settings_dir()?.join("settings.toml"))
}
pub fn settings_json_path() -> Result<PathBuf> {
Ok(Self::settings_dir()?.join("settings.json"))
}
pub fn settings_path() -> Result<PathBuf> {
let json_path = Self::settings_json_path()?;
let toml_path = Self::settings_toml_path()?;
if json_path.exists() && toml_path.exists() {
tracing::debug!("Both settings.json and settings.toml exist, using settings.json");
return Ok(json_path);
}
if json_path.exists() {
return Ok(json_path);
}
if toml_path.exists() {
return Ok(toml_path);
}
Ok(json_path)
}
pub fn settings_path_with_preference(prefer_json: bool) -> Result<PathBuf> {
let json_path = Self::settings_json_path()?;
let toml_path = Self::settings_toml_path()?;
let (primary, secondary) = if prefer_json {
(&json_path, &toml_path)
} else {
(&toml_path, &json_path)
};
if primary.exists() {
return Ok(primary.clone());
}
if secondary.exists() {
return Ok(secondary.clone());
}
Ok(primary.clone())
}
pub fn detect_format(path: &Path) -> SettingsFormat {
match path.extension().and_then(|e| e.to_str()) {
Some("json") => SettingsFormat::Json,
Some("toml") => SettingsFormat::Toml,
_ => SettingsFormat::Json, }
}
pub fn find_project_settings(start_dir: &std::path::Path) -> Option<PathBuf> {
let mut dir = start_dir.to_path_buf();
loop {
let json_candidate = dir.join(".oxi").join("settings.json");
if json_candidate.exists() {
return Some(json_candidate);
}
let toml_candidate = dir.join(".oxi").join("settings.toml");
if toml_candidate.exists() {
return Some(toml_candidate);
}
if !dir.pop() {
return None;
}
}
}
pub fn effective_session_dir(&self) -> Result<PathBuf> {
if let Some(ref dir) = self.session_dir {
return Ok(dir.clone());
}
Ok(Self::settings_dir()?.join("sessions"))
}
pub fn load() -> Result<Self> {
Self::load_from_cwd()
}
pub fn load_from(dir: &std::path::Path) -> Result<Self> {
let mut settings = Settings::default();
if let Ok(global_path) = Self::settings_path()
&& global_path.exists()
{
settings = Self::layer_file(&settings, &global_path)?;
}
if let Some(project_path) = Self::find_project_settings(dir) {
settings = Self::layer_file(&settings, &project_path)?;
}
settings.apply_env();
settings = Self::migrate(settings)?;
settings.validate_output_languages();
Ok(settings)
}
fn validate_output_languages(&mut self) {
if self.output_languages.is_empty() {
return;
}
let known_langs: std::collections::HashSet<&str> =
KNOWN_LANGS.iter().map(|(k, _)| *k).collect();
for (channel, lang) in &self.output_languages {
if !known_langs.contains(lang.as_str()) {
tracing::warn!(
"Unknown output_languages language code '{}' for channel '{}'. \
Keeping as-is (the model will likely understand).",
lang,
channel
);
}
}
}
pub fn load_from_cwd() -> Result<Self> {
let cwd = env::current_dir().context("Cannot determine current directory")?;
Self::load_from(&cwd)
}
fn layer_file(base: &Settings, path: &std::path::Path) -> Result<Settings> {
let content = fs::read_to_string(path)
.with_context(|| format!("Failed to read settings from {}", path.display()))?;
let format = Self::detect_format(path);
let overlay: serde_json::Value = match format {
SettingsFormat::Toml => {
let toml_value: toml::Value = toml::from_str(&content).with_context(|| {
format!("Failed to parse TOML settings from {}", path.display())
})?;
toml_value_to_json(toml_value)
}
SettingsFormat::Json => serde_json::from_str(&content).with_context(|| {
format!("Failed to parse JSON settings from {}", path.display())
})?,
};
let base_json =
serde_json::to_value(base).context("Failed to serialize base settings for merge")?;
let merged = merge_json_values(base_json, overlay);
let result: Settings =
serde_json::from_value(merged).context("Failed to deserialize merged settings")?;
Ok(result)
}
#[allow(dead_code)]
pub fn apply_env(&mut self) {
}
#[allow(dead_code)]
pub fn from_env() -> Self {
Self::default()
}
pub fn save(&self) -> Result<()> {
let dir = Self::settings_dir()?;
let path = Self::settings_path()?;
if !dir.exists() {
fs::create_dir_all(&dir).with_context(|| {
format!("Failed to create settings directory {}", dir.display())
})?;
}
let format = Self::detect_format(&path);
let content = Self::serialize_for_format(self, format)?;
let tmp_path = path.with_extension("tmp");
fs::write(&tmp_path, &content)
.with_context(|| format!("Failed to write settings to {}", tmp_path.display()))?;
fs::rename(&tmp_path, &path)
.with_context(|| format!("Failed to rename settings to {}", path.display()))?;
Ok(())
}
pub fn save_to(&self, path: &Path) -> Result<()> {
if let Some(parent) = path.parent()
&& !parent.exists()
{
fs::create_dir_all(parent)
.with_context(|| format!("Failed to create directory {}", parent.display()))?;
}
let format = Self::detect_format(path);
let content = Self::serialize_for_format(self, format)?;
let tmp_path = path.with_extension("tmp");
fs::write(&tmp_path, &content)
.with_context(|| format!("Failed to write settings to {}", tmp_path.display()))?;
fs::rename(&tmp_path, path)
.with_context(|| format!("Failed to rename settings to {}", path.display()))?;
Ok(())
}
pub fn save_project(&self, project_dir: &std::path::Path) -> Result<()> {
let dir = project_dir.join(".oxi");
if !dir.exists() {
fs::create_dir_all(&dir).with_context(|| {
format!(
"Failed to create project settings directory {}",
dir.display()
)
})?;
}
let json_path = dir.join("settings.json");
let toml_path = dir.join("settings.toml");
let path = if json_path.exists() {
&json_path
} else if toml_path.exists() {
&toml_path
} else {
&json_path
};
let format = Self::detect_format(path);
let content = Self::serialize_for_format(self, format)?;
let tmp_path = path.with_extension("tmp");
fs::write(&tmp_path, &content)
.with_context(|| format!("Failed to write settings to {}", tmp_path.display()))?;
fs::rename(&tmp_path, path)
.with_context(|| format!("Failed to rename settings to {}", path.display()))?;
Ok(())
}
pub fn serialize_for_format(settings: &Settings, format: SettingsFormat) -> Result<String> {
match format {
SettingsFormat::Toml => {
toml::to_string_pretty(settings).context("Failed to serialize settings to TOML")
}
SettingsFormat::Json => serde_json::to_string_pretty(settings)
.context("Failed to serialize settings to JSON"),
}
}
pub fn parse_from_str(content: &str, format: SettingsFormat) -> Result<Settings> {
match format {
SettingsFormat::Toml => {
toml::from_str(content).context("Failed to parse TOML settings")
}
SettingsFormat::Json => {
serde_json::from_str(content).context("Failed to parse JSON settings")
}
}
}
pub fn merge_cli(
&mut self,
model: Option<String>,
provider: Option<String>,
enable_routing: Option<bool>,
prefer_cost_efficient: Option<bool>,
fallback_chain: Option<Vec<String>>,
disable_fallback: Option<bool>,
) {
if let Some(m) = model {
self.last_used_model = Some(m);
}
if let Some(p) = provider {
self.last_used_provider = Some(p);
}
if let Some(r) = enable_routing {
self.enable_routing = r;
}
if let Some(p) = prefer_cost_efficient {
self.prefer_cost_efficient = p;
}
if let Some(fc) = fallback_chain
&& !fc.is_empty()
{
self.fallback_chain = fc;
}
if let Some(df) = disable_fallback {
self.disable_fallback = df;
if df {
self.enable_fallback = false;
}
}
}
pub fn effective_model(&self, cli_model: Option<&str>) -> Option<String> {
cli_model.map(String::from).or_else(|| {
let model = self.last_used_model.as_ref()?;
if model.contains('/') {
Some(model.clone())
} else if let Some(ref provider) = self.last_used_provider {
Some(format!("{}/{}", provider, model))
} else {
Some(model.clone())
}
})
}
pub fn effective_provider(&self, cli_provider: Option<&str>) -> Option<String> {
cli_provider
.map(String::from)
.or_else(|| self.last_used_provider.clone())
}
pub fn effective_temperature(&self) -> Option<f64> {
self.default_temperature
.or(self.temperature.map(|t| t as f64))
}
pub fn effective_max_tokens(&self) -> Option<usize> {
self.max_response_tokens
.or(self.max_tokens.map(|t| t as usize))
}
pub fn router_profile(&self) -> Option<&str> {
self.router_profile.as_deref()
}
pub fn save_last_used(model_id: &str) {
if let Ok(mut settings) = Self::load() {
if let Some((provider, model)) = model_id.split_once('/') {
settings.last_used_provider = Some(provider.to_string());
settings.last_used_model = Some(model.to_string());
} else {
settings.last_used_model = Some(model_id.to_string());
}
let _ = settings.save();
}
}
pub fn save_theme(&mut self, name: &str) -> Result<()> {
self.theme = name.to_string();
self.save()
}
pub fn get_theme_name(&self) -> String {
if self.theme.is_empty() || self.theme == "default" {
"oxi_dark".to_string()
} else {
self.theme.clone()
}
}
fn migrate(settings: Settings) -> Result<Settings> {
let mut settings = settings;
match settings.version {
SETTINGS_VERSION => {
}
0 => {
if settings.tool_timeout_seconds == 0 {
settings.tool_timeout_seconds = default_tool_timeout();
}
settings.version = SETTINGS_VERSION;
tracing::info!("Migrated settings from version 0 to {}", SETTINGS_VERSION);
}
1 | 2 => {
settings.version = SETTINGS_VERSION;
tracing::info!(
"Migrated settings from version {} to {} (dynamic_models + output_languages + language_policy_enabled defaults applied)",
settings.version,
SETTINGS_VERSION
);
}
3 => {
if let Some(model) = settings.default_model.take() {
if let Some((provider, model_name)) = model.split_once('/') {
settings.last_used_provider = Some(provider.to_string());
settings.last_used_model = Some(model_name.to_string());
} else {
settings.last_used_model = Some(model);
}
}
settings.version = SETTINGS_VERSION;
tracing::info!(
"Migrated settings from version 3 to {} (default_model → last_used_model; output_languages + language_policy_enabled defaults)",
SETTINGS_VERSION
);
}
4 => {
settings.version = SETTINGS_VERSION;
tracing::info!(
"Migrated settings from version 4 to {} (added output_languages + language_policy_enabled, both defaulted to off)",
SETTINGS_VERSION
);
}
5 => {
settings.version = SETTINGS_VERSION;
tracing::info!(
"Migrated settings from version 5 to {} (added language_policy_enabled, defaulting to OFF — toggle ON in /settings to activate existing channels)",
SETTINGS_VERSION
);
}
6 => {
settings.version = SETTINGS_VERSION;
tracing::info!(
"Migrated settings from version 6 to {} (added edit_format, defaulting to str_replace)",
SETTINGS_VERSION
);
}
v if v > SETTINGS_VERSION => {
anyhow::bail!(
"Settings version {} is newer than supported version {}. \
Please update oxi.",
v,
SETTINGS_VERSION
);
}
v => {
tracing::warn!(
"Unknown settings version {}, attempting migration to {}",
v,
SETTINGS_VERSION
);
settings.version = SETTINGS_VERSION;
}
}
Ok(settings)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SettingsFormat {
#[default]
Json,
Toml,
}
impl SettingsFormat {
pub fn extension(&self) -> &'static str {
match self {
SettingsFormat::Json => "json",
SettingsFormat::Toml => "toml",
}
}
}
fn toml_value_to_json(toml: toml::Value) -> serde_json::Value {
match toml {
toml::Value::String(s) => serde_json::Value::String(s),
toml::Value::Integer(i) => serde_json::Value::Number(i.into()),
toml::Value::Float(f) => serde_json::Number::from_f64(f)
.map(serde_json::Value::Number)
.unwrap_or(serde_json::Value::Null),
toml::Value::Boolean(b) => serde_json::Value::Bool(b),
toml::Value::Datetime(dt) => serde_json::Value::String(dt.to_string()),
toml::Value::Array(arr) => {
serde_json::Value::Array(arr.into_iter().map(toml_value_to_json).collect())
}
toml::Value::Table(table) => {
let obj = table
.into_iter()
.map(|(k, v)| (k, toml_value_to_json(v)))
.collect();
serde_json::Value::Object(obj)
}
}
}
fn merge_json_values(base: serde_json::Value, override_: serde_json::Value) -> serde_json::Value {
match (base, override_) {
(serde_json::Value::Object(base_map), serde_json::Value::Object(override_map)) => {
let mut result = base_map;
for (key, override_value) in override_map {
let base_value = result.remove(&key);
let merged = match base_value {
Some(base_v) => merge_json_values(base_v, override_value),
None => override_value,
};
result.insert(key, merged);
}
serde_json::Value::Object(result)
}
(_, override_) => override_,
}
}
pub fn parse_thinking_level(s: &str) -> Option<ThinkingLevel> {
match s.to_lowercase().as_str() {
"off" | "none" => Some(ThinkingLevel::Off),
"minimal" => Some(ThinkingLevel::Minimal),
"low" => Some(ThinkingLevel::Low),
"medium" | "standard" => Some(ThinkingLevel::Medium),
"high" | "thorough" => Some(ThinkingLevel::High),
"xhigh" => Some(ThinkingLevel::XHigh),
_ => None,
}
}
#[allow(dead_code)]
fn parse_boolish(s: &str) -> Result<bool> {
match s.to_lowercase().as_str() {
"true" | "1" | "yes" | "on" => Ok(true),
"false" | "0" | "no" | "off" => Ok(false),
_ => anyhow::bail!("Cannot parse '{}' as boolean", s),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write as IoWrite;
use std::sync::Mutex;
#[allow(dead_code)] static ENV_LOCK: Mutex<()> = Mutex::new(());
struct EnvGuard {
saved: Vec<(String, Option<String>)>,
}
impl EnvGuard {
fn new(vars: &[&str]) -> Self {
let saved = vars
.iter()
.map(|&name| {
let old = env::var(name).ok();
unsafe { env::remove_var(name) };
(name.to_string(), old)
})
.collect();
Self { saved }
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
for (name, old) in self.saved.drain(..) {
match old {
Some(val) => unsafe { env::set_var(&name, val) },
None => unsafe { env::remove_var(&name) },
}
}
}
}
#[test]
fn test_default_settings() {
let settings = Settings::default();
assert_eq!(settings.version, SETTINGS_VERSION);
assert_eq!(settings.thinking_level, ThinkingLevel::Medium);
assert_eq!(settings.theme, "default");
assert!(settings.last_used_model.is_none());
assert!(settings.last_used_provider.is_none());
assert!(settings.extensions_enabled);
assert!(settings.auto_compaction);
assert_eq!(settings.tool_timeout_seconds, 120);
assert!(settings.stream_responses);
}
#[test]
fn test_merge_cli() {
let mut settings = Settings::default();
settings.last_used_model = Some("gpt-4o".to_string());
settings.merge_cli(Some("claude".to_string()), None, None, None, None, None);
assert_eq!(settings.last_used_model, Some("claude".to_string()));
settings.merge_cli(None, Some("google".to_string()), None, None, None, None);
assert_eq!(settings.last_used_provider, Some("google".to_string()));
settings.merge_cli(
None,
None,
Some(true),
Some(false),
Some(vec!["openai/gpt-4o".to_string()]),
Some(false),
);
assert!(settings.enable_routing);
assert!(!settings.prefer_cost_efficient);
assert_eq!(settings.fallback_chain, vec!["openai/gpt-4o"]);
assert!(!settings.disable_fallback);
let mut settings2 = Settings::default();
settings2.merge_cli(None, None, None, None, None, Some(true));
assert!(settings2.disable_fallback);
assert!(!settings2.enable_fallback);
}
#[test]
fn test_layer_file_overrides() {
let base = Settings::default();
let tmp = tempfile::NamedTempFile::with_suffix(".toml").unwrap();
let toml_content = r#"
last_used_model = "openai/gpt-4o"
theme = "dracula"
"#;
tmp.as_file().write_all(toml_content.as_bytes()).unwrap();
let merged = Settings::layer_file(&base, tmp.path()).unwrap();
assert_eq!(merged.last_used_model, Some("openai/gpt-4o".to_string()));
assert_eq!(merged.theme, "dracula");
assert_eq!(merged.thinking_level, ThinkingLevel::Medium);
assert!(merged.extensions_enabled);
}
#[test]
fn test_layer_file_preserves_unset() {
let mut base = Settings::default();
base.last_used_provider = Some("deepseek".to_string());
let tmp = tempfile::NamedTempFile::with_suffix(".toml").unwrap();
let toml_content = "theme = \"monokai\"\n";
tmp.as_file().write_all(toml_content.as_bytes()).unwrap();
let merged = Settings::layer_file(&base, tmp.path()).unwrap();
assert_eq!(merged.theme, "monokai");
assert_eq!(merged.last_used_provider, Some("deepseek".to_string()));
}
#[test]
fn test_load_from_dir_with_project_config() {
let _guard = EnvGuard::new(&[
"OXI_MODEL",
"OXI_PROVIDER",
"OXI_THEME",
"OXI_TOOL_TIMEOUT",
"OXI_TEMPERATURE",
"OXI_MAX_TOKENS",
"OXI_SESSION_DIR",
"OXI_STREAM",
"OXI_EXTENSIONS_ENABLED",
]);
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let settings_path = oxi_dir.join("settings.toml");
fs::write(
&settings_path,
"version = 3\ndefault_model = \"google/gemini-2.0-flash\"\n",
)
.unwrap();
let settings = Settings::load_from(tmp.path()).unwrap();
assert_eq!(
settings.last_used_model,
Some("gemini-2.0-flash".to_string())
);
assert_eq!(settings.last_used_provider, Some("google".to_string()));
}
#[test]
fn test_load_from_dir_no_config() {
let _guard = EnvGuard::new(&[
"OXI_MODEL",
"OXI_PROVIDER",
"OXI_THEME",
"OXI_TOOL_TIMEOUT",
"OXI_TEMPERATURE",
"OXI_MAX_TOKENS",
"OXI_SESSION_DIR",
"OXI_STREAM",
"OXI_EXTENSIONS_ENABLED",
]);
let tmp = tempfile::tempdir().unwrap();
let settings = Settings::load_from(tmp.path()).unwrap();
assert_eq!(settings.thinking_level, ThinkingLevel::Medium);
}
#[test]
fn test_from_env() {
let _guard = EnvGuard::new(&[
"OXI_MODEL",
"OXI_THEME",
"OXI_TOOL_TIMEOUT",
"OXI_PROVIDER",
"OXI_DEFAULT_MODEL",
]);
let settings = Settings::from_env();
assert_eq!(settings.last_used_model, None);
assert_eq!(settings.theme, "default");
assert_eq!(settings.tool_timeout_seconds, 120);
}
#[test]
fn test_apply_env_boolish() {
let _guard = EnvGuard::new(&["OXI_STREAM", "OXI_EXTENSIONS_ENABLED"]);
unsafe { env::set_var("OXI_STREAM", "false") };
unsafe { env::set_var("OXI_EXTENSIONS_ENABLED", "0") };
let mut settings = Settings::default();
settings.apply_env();
assert!(settings.stream_responses); assert!(settings.extensions_enabled); }
#[test]
fn test_apply_env_temperature() {
let _guard = EnvGuard::new(&["OXI_TEMPERATURE"]);
unsafe { env::set_var("OXI_TEMPERATURE", "0.7") };
let mut settings = Settings::default();
settings.apply_env();
assert_eq!(settings.default_temperature, None);
}
#[test]
fn test_env_does_not_override_when_unset() {
let _guard = EnvGuard::new(&["OXI_MODEL", "OXI_PROVIDER", "OXI_THEME", "OXI_TEMPERATURE"]);
let settings = Settings::from_env();
assert!(settings.last_used_model.is_none());
assert!(settings.last_used_provider.is_none());
}
#[test]
fn test_parse_thinking_level() {
assert_eq!(parse_thinking_level("off"), Some(ThinkingLevel::Off));
assert_eq!(parse_thinking_level("none"), Some(ThinkingLevel::Off));
assert_eq!(
parse_thinking_level("MINIMAL"),
Some(ThinkingLevel::Minimal)
);
assert_eq!(parse_thinking_level("Low"), Some(ThinkingLevel::Low));
assert_eq!(parse_thinking_level("medium"), Some(ThinkingLevel::Medium));
assert_eq!(parse_thinking_level("Medium"), Some(ThinkingLevel::Medium));
assert_eq!(
parse_thinking_level("Standard"),
Some(ThinkingLevel::Medium)
);
assert_eq!(parse_thinking_level("High"), Some(ThinkingLevel::High));
assert_eq!(parse_thinking_level("thorough"), Some(ThinkingLevel::High));
assert_eq!(parse_thinking_level("xhigh"), Some(ThinkingLevel::XHigh));
assert_eq!(parse_thinking_level("invalid"), None);
}
#[test]
fn test_parse_boolish() {
assert!(parse_boolish("true").unwrap());
assert!(parse_boolish("1").unwrap());
assert!(parse_boolish("yes").unwrap());
assert!(parse_boolish("ON").unwrap());
assert!(!parse_boolish("false").unwrap());
assert!(!parse_boolish("0").unwrap());
assert!(!parse_boolish("no").unwrap());
assert!(!parse_boolish("OFF").unwrap());
assert!(parse_boolish("maybe").is_err());
}
#[test]
fn test_effective_model_returns_last_used() {
let mut settings = Settings::default();
settings.last_used_model = Some("openai/gpt-4o".to_string());
assert_eq!(
settings.effective_model(None),
Some("openai/gpt-4o".to_string())
);
}
#[test]
fn test_effective_model_cli_overrides() {
let mut settings = Settings::default();
settings.last_used_model = Some("openai/gpt-4o".to_string());
assert_eq!(
settings.effective_model(Some("anthropic/claude-3")),
Some("anthropic/claude-3".to_string())
);
}
#[test]
fn test_effective_model_none_when_unset() {
let settings = Settings::default();
assert_eq!(settings.effective_model(None), None);
}
#[test]
fn test_effective_model_falls_back_to_last_used() {
let mut settings = Settings::default();
settings.last_used_model = Some("anthropic/claude-3".to_string());
assert_eq!(
settings.effective_model(None),
Some("anthropic/claude-3".to_string())
);
}
#[test]
fn test_effective_model_returns_none_when_nothing_set() {
let settings = Settings::default();
assert_eq!(settings.effective_model(None), None);
}
#[test]
fn test_effective_temperature_prefers_f64() {
let mut settings = Settings::default();
settings.temperature = Some(0.5);
settings.default_temperature = Some(0.7);
assert_eq!(settings.effective_temperature(), Some(0.7));
}
#[test]
fn test_effective_temperature_falls_back_to_f32() {
let mut settings = Settings::default();
settings.temperature = Some(0.5);
assert_eq!(settings.effective_temperature(), Some(0.5));
}
#[test]
fn test_effective_max_tokens_prefers_usize() {
let mut settings = Settings::default();
settings.max_tokens = Some(1024);
settings.max_response_tokens = Some(4096);
assert_eq!(settings.effective_max_tokens(), Some(4096));
}
#[test]
fn test_effective_max_tokens_falls_back_to_u32() {
let mut settings = Settings::default();
settings.max_tokens = Some(1024);
assert_eq!(settings.effective_max_tokens(), Some(1024));
}
#[test]
fn test_effective_session_dir_default() {
let _guard = EnvGuard::new(&["OXI_SESSION_DIR"]);
let settings = Settings::default();
let dir = settings.effective_session_dir().unwrap();
assert!(dir.ends_with("sessions"), "dir was: {:?}", dir);
}
#[test]
fn test_effective_session_dir_from_field() {
let _guard = EnvGuard::new(&["OXI_SESSION_DIR"]);
let mut settings = Settings::default();
settings.session_dir = Some(PathBuf::from("/tmp/oxi-sessions"));
assert_eq!(
settings.effective_session_dir().unwrap(),
PathBuf::from("/tmp/oxi-sessions")
);
}
#[test]
fn test_effective_session_dir_env_disabled() {
let _guard = EnvGuard::new(&["OXI_SESSION_DIR"]);
unsafe { env::set_var("OXI_SESSION_DIR", "/tmp/env-sessions") };
let settings = Settings::default();
let dir = settings.effective_session_dir().unwrap();
assert!(
dir.ends_with("sessions"),
"expected default sessions dir, got: {:?}",
dir
);
}
#[test]
fn test_migration_v0_to_v1() {
let mut settings = Settings::default();
settings.version = 0;
settings.tool_timeout_seconds = 0;
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
assert_eq!(migrated.tool_timeout_seconds, 120);
}
#[test]
fn test_migration_already_current() {
let settings = Settings::default();
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
}
#[test]
fn test_migration_v3_to_v4_splits_model() {
let mut settings = Settings::default();
settings.version = 3;
settings.default_model = Some("openai/gpt-4o".to_string());
settings.default_provider = None;
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
assert_eq!(migrated.last_used_model, Some("gpt-4o".to_string()));
assert_eq!(migrated.last_used_provider, Some("openai".to_string()));
}
#[test]
fn test_migration_v3_no_slash_keeps_model() {
let mut settings = Settings::default();
settings.version = 3;
settings.default_model = Some("bare-model-name".to_string());
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
assert_eq!(
migrated.last_used_model,
Some("bare-model-name".to_string())
);
}
#[test]
fn test_migration_future_version_fails() {
let mut settings = Settings::default();
settings.version = 9999;
assert!(Settings::migrate(settings).is_err());
}
#[test]
fn test_default_output_languages_is_empty() {
let settings = Settings::default();
assert!(
settings.output_languages.is_empty(),
"all channels should default to auto (empty map)"
);
}
#[test]
fn test_migration_v4_to_v5_preserves_existing_output_languages() {
let mut settings = Settings::default();
settings.version = 4;
settings
.output_languages
.insert("response".to_string(), "ko".to_string());
settings
.output_languages
.insert("commit_message".to_string(), "en".to_string());
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
assert_eq!(
migrated.output_languages.get("response"),
Some(&"ko".to_string())
);
assert_eq!(
migrated.output_languages.get("commit_message"),
Some(&"en".to_string())
);
}
#[test]
fn test_migration_v4_to_v5_creates_empty_if_missing() {
let mut settings = Settings::default();
settings.version = 4;
assert!(settings.output_languages.is_empty());
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
assert!(migrated.output_languages.is_empty());
}
#[test]
fn test_validate_keeps_user_defined_channel() {
let mut settings = Settings::default();
settings
.output_languages
.insert("pr_description".to_string(), "en".to_string()); settings
.output_languages
.insert("response".to_string(), "ko".to_string());
settings.validate_output_languages();
assert!(settings.output_languages.contains_key("pr_description"));
assert!(settings.output_languages.contains_key("response"));
assert_eq!(
settings.output_languages.get("pr_description"),
Some(&"en".to_string())
);
assert_eq!(
settings.output_languages.get("response"),
Some(&"ko".to_string())
);
}
#[test]
fn test_validate_keeps_unknown_lang_with_warning() {
let mut settings = Settings::default();
settings
.output_languages
.insert("response".to_string(), "klingon".to_string()); settings
.output_languages
.insert("commit_message".to_string(), "en".to_string());
settings.validate_output_languages();
assert_eq!(
settings.output_languages.get("response"),
Some(&"klingon".to_string())
);
assert_eq!(
settings.output_languages.get("commit_message"),
Some(&"en".to_string())
);
}
#[test]
fn test_known_channels_table_includes_core_four() {
let keys: Vec<&str> = KNOWN_CHANNELS.iter().map(|(k, _)| *k).collect();
assert!(keys.contains(&"response"));
assert!(keys.contains(&"code_comment"));
assert!(keys.contains(&"documentation"));
assert!(keys.contains(&"commit_message"));
}
#[test]
fn test_known_langs_table_includes_auto_and_english() {
let codes: Vec<&str> = KNOWN_LANGS.iter().map(|(k, _)| *k).collect();
assert!(codes.contains(&"auto"));
assert!(codes.contains(&"en"));
}
#[test]
fn test_default_language_policy_enabled_is_false() {
let settings = Settings::default();
assert!(
!settings.language_policy_enabled,
"language_policy_enabled must default to false (opt-in)"
);
}
#[test]
fn test_migration_v5_to_v6_defaults_master_toggle_to_off() {
let mut settings = Settings::default();
settings.version = 5;
settings
.output_languages
.insert("response".to_string(), "ko".to_string());
settings
.output_languages
.insert("commit_message".to_string(), "en".to_string());
let migrated = Settings::migrate(settings).unwrap();
assert_eq!(migrated.version, SETTINGS_VERSION);
assert!(
!migrated.language_policy_enabled,
"v5 → v6 migration must default language_policy_enabled to false"
);
assert_eq!(
migrated.output_languages.get("response"),
Some(&"ko".to_string())
);
assert_eq!(
migrated.output_languages.get("commit_message"),
Some(&"en".to_string())
);
}
#[test]
fn test_save_and_load_roundtrip_preserves_language_policy_enabled() {
let tmp = tempfile::tempdir().unwrap();
let settings_path = tmp.path().join("settings.toml");
let mut original = Settings::default();
original.language_policy_enabled = true;
original
.output_languages
.insert("response".to_string(), "ko".to_string());
let content = toml::to_string_pretty(&original).unwrap();
fs::write(&settings_path, &content).unwrap();
let loaded_content = fs::read_to_string(&settings_path).unwrap();
let loaded: Settings = toml::from_str(&loaded_content).unwrap();
assert!(loaded.language_policy_enabled);
assert_eq!(
loaded.output_languages.get("response"),
Some(&"ko".to_string())
);
}
#[test]
fn test_save_and_load_roundtrip_preserves_output_languages() {
let tmp = tempfile::tempdir().unwrap();
let settings_path = tmp.path().join("settings.toml");
let mut original = Settings::default();
original
.output_languages
.insert("response".to_string(), "ko".to_string());
original
.output_languages
.insert("commit_message".to_string(), "en".to_string());
let content = toml::to_string_pretty(&original).unwrap();
fs::write(&settings_path, &content).unwrap();
let loaded_content = fs::read_to_string(&settings_path).unwrap();
let loaded: Settings = toml::from_str(&loaded_content).unwrap();
assert_eq!(
loaded.output_languages.get("response"),
Some(&"ko".to_string())
);
assert_eq!(
loaded.output_languages.get("commit_message"),
Some(&"en".to_string())
);
}
#[test]
fn test_save_and_load_roundtrip() {
let tmp = tempfile::tempdir().unwrap();
let settings_path = tmp.path().join("settings.toml");
let mut original = Settings::default();
original.last_used_model = Some("gpt-4o".to_string());
original.last_used_provider = Some("openai".to_string());
original.theme = "dracula".to_string();
original.tool_timeout_seconds = 60;
let content = toml::to_string_pretty(&original).unwrap();
fs::write(&settings_path, &content).unwrap();
let loaded_content = fs::read_to_string(&settings_path).unwrap();
let loaded: Settings = toml::from_str(&loaded_content).unwrap();
assert_eq!(loaded.last_used_model, original.last_used_model);
assert_eq!(loaded.theme, original.theme);
assert_eq!(loaded.tool_timeout_seconds, original.tool_timeout_seconds);
}
#[test]
fn test_toml_roundtrip_preserves_new_fields() {
let mut settings = Settings::default();
settings.default_temperature = Some(0.8);
settings.max_response_tokens = Some(8192);
settings.auto_compaction = false;
settings.extensions_enabled = false;
settings.session_dir = Some(PathBuf::from("/custom/sessions"));
let toml_str = toml::to_string_pretty(&settings).unwrap();
let parsed: Settings = toml::from_str(&toml_str).unwrap();
assert_eq!(parsed.default_temperature, Some(0.8));
assert_eq!(parsed.max_response_tokens, Some(8192));
assert!(!parsed.auto_compaction);
assert!(!parsed.extensions_enabled);
assert_eq!(parsed.session_dir, Some(PathBuf::from("/custom/sessions")));
}
#[test]
fn test_json_roundtrip() {
let mut settings = Settings::default();
settings.last_used_model = Some("gpt-4o".to_string());
settings.last_used_provider = Some("openai".to_string());
settings.theme = "dracula".to_string();
settings.tool_timeout_seconds = 60;
settings.default_temperature = Some(0.8);
settings.max_response_tokens = Some(8192);
let json_str = serde_json::to_string_pretty(&settings).unwrap();
let parsed: Settings = serde_json::from_str(&json_str).unwrap();
assert_eq!(parsed.last_used_model, settings.last_used_model);
assert_eq!(parsed.theme, settings.theme);
assert_eq!(parsed.tool_timeout_seconds, settings.tool_timeout_seconds);
assert_eq!(parsed.default_temperature, settings.default_temperature);
assert_eq!(parsed.max_response_tokens, settings.max_response_tokens);
}
#[test]
fn test_json_serialize_for_format() {
let mut settings = Settings::default();
settings.last_used_model = Some("claude-3".to_string());
settings.last_used_provider = Some("anthropic".to_string());
settings.thinking_level = ThinkingLevel::Minimal;
let json_content = Settings::serialize_for_format(&settings, SettingsFormat::Json).unwrap();
let parsed: Settings = serde_json::from_str(&json_content).unwrap();
assert_eq!(parsed.last_used_model, Some("claude-3".to_string()));
assert_eq!(parsed.thinking_level, ThinkingLevel::Minimal);
}
#[test]
fn test_toml_serialize_for_format() {
let mut settings = Settings::default();
settings.last_used_model = Some("gemini-pro".to_string());
settings.last_used_provider = Some("google".to_string());
settings.thinking_level = ThinkingLevel::High;
let toml_content = Settings::serialize_for_format(&settings, SettingsFormat::Toml).unwrap();
let parsed: Settings = toml::from_str(&toml_content).unwrap();
assert_eq!(parsed.last_used_model, Some("gemini-pro".to_string()));
assert_eq!(parsed.thinking_level, ThinkingLevel::High);
}
#[test]
fn test_parse_from_str_json() {
let json_content = r#"{
"last_used_model": "gpt-4",
"last_used_provider": "openai",
"theme": "nord",
"tool_timeout_seconds": 90
}"#;
let settings = Settings::parse_from_str(json_content, SettingsFormat::Json).unwrap();
assert_eq!(settings.last_used_model, Some("gpt-4".to_string()));
assert_eq!(settings.last_used_provider, Some("openai".to_string()));
assert_eq!(settings.theme, "nord");
assert_eq!(settings.tool_timeout_seconds, 90);
assert_eq!(settings.thinking_level, ThinkingLevel::Medium);
assert!(settings.extensions_enabled);
}
#[test]
fn test_parse_from_str_toml() {
let toml_content = r#"
last_used_model = "claude-opus"
last_used_provider = "anthropic"
theme = "monokai"
tool_timeout_seconds = 45
"#;
let settings = Settings::parse_from_str(toml_content, SettingsFormat::Toml).unwrap();
assert_eq!(settings.last_used_model, Some("claude-opus".to_string()));
assert_eq!(settings.last_used_provider, Some("anthropic".to_string()));
assert_eq!(settings.theme, "monokai");
assert_eq!(settings.tool_timeout_seconds, 45);
assert_eq!(settings.thinking_level, ThinkingLevel::Medium);
}
#[test]
fn test_layer_file_json() {
let base = Settings::default();
let tmp = tempfile::NamedTempFile::with_suffix(".json").unwrap();
let json_content = r#"{
"last_used_model": "gpt-4o",
"last_used_provider": "openai",
"theme": "dracula",
"auto_compaction": false
}"#;
tmp.as_file().write_all(json_content.as_bytes()).unwrap();
let merged = Settings::layer_file(&base, tmp.path()).unwrap();
assert_eq!(merged.last_used_model, Some("gpt-4o".to_string()));
assert_eq!(merged.last_used_provider, Some("openai".to_string()));
assert_eq!(merged.theme, "dracula");
assert!(!merged.auto_compaction);
assert_eq!(merged.thinking_level, ThinkingLevel::Medium);
assert!(merged.extensions_enabled);
assert_eq!(merged.tool_timeout_seconds, 120);
}
#[test]
fn test_layer_file_json_preserves_unset() {
let mut base = Settings::default();
base.last_used_provider = Some("deepseek".to_string());
let tmp = tempfile::NamedTempFile::with_suffix(".json").unwrap();
let json_content = r#"{ "theme": "nord" }"#;
tmp.as_file().write_all(json_content.as_bytes()).unwrap();
let merged = Settings::layer_file(&base, tmp.path()).unwrap();
assert_eq!(merged.theme, "nord");
assert_eq!(merged.last_used_provider, Some("deepseek".to_string()));
}
#[test]
fn test_save_to_json() {
let tmp = tempfile::tempdir().unwrap();
let settings_path = tmp.path().join("settings.json");
let mut settings = Settings::default();
settings.last_used_model = Some("gpt-4o".to_string());
settings.last_used_provider = Some("openai".to_string());
settings.theme = "dracula".to_string();
settings.tool_timeout_seconds = 60;
settings.save_to(&settings_path).unwrap();
let content = fs::read_to_string(&settings_path).unwrap();
let parsed: Settings = serde_json::from_str(&content).unwrap();
assert_eq!(parsed.last_used_model, Some("gpt-4o".to_string()));
assert_eq!(parsed.theme, "dracula");
assert_eq!(parsed.tool_timeout_seconds, 60);
}
#[test]
fn test_save_to_toml() {
let tmp = tempfile::tempdir().unwrap();
let settings_path = tmp.path().join("settings.toml");
let mut settings = Settings::default();
settings.last_used_model = Some("gemini-pro".to_string());
settings.last_used_provider = Some("google".to_string());
settings.theme = "monokai".to_string();
settings.tool_timeout_seconds = 90;
settings.save_to(&settings_path).unwrap();
let content = fs::read_to_string(&settings_path).unwrap();
let parsed: Settings = toml::from_str(&content).unwrap();
assert_eq!(parsed.last_used_model, Some("gemini-pro".to_string()));
assert_eq!(parsed.theme, "monokai");
assert_eq!(parsed.tool_timeout_seconds, 90);
}
#[test]
fn test_load_from_dir_with_json_project_config() {
let _guard = EnvGuard::new(&[
"OXI_MODEL",
"OXI_PROVIDER",
"OXI_THEME",
"OXI_TOOL_TIMEOUT",
"OXI_TEMPERATURE",
"OXI_MAX_TOKENS",
"OXI_SESSION_DIR",
"OXI_STREAM",
"OXI_EXTENSIONS_ENABLED",
]);
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let settings_path = oxi_dir.join("settings.json");
let json_content = r#"{ "version": 3, "default_model": "google/gemini-2.0-flash" }"#;
fs::write(&settings_path, json_content).unwrap();
let settings = Settings::load_from(tmp.path()).unwrap();
assert_eq!(
settings.last_used_model,
Some("gemini-2.0-flash".to_string())
);
assert_eq!(settings.last_used_provider, Some("google".to_string()));
}
#[test]
fn test_find_project_settings_json_priority() {
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let json_path = oxi_dir.join("settings.json");
let toml_path = oxi_dir.join("settings.toml");
fs::write(&json_path, r#"{ "theme": "json-theme" }"#).unwrap();
fs::write(&toml_path, r#"theme = "toml-theme""#).unwrap();
let found = Settings::find_project_settings(tmp.path());
assert!(found.is_some());
assert_eq!(
found.unwrap().file_name().unwrap().to_str().unwrap(),
"settings.json"
);
}
#[test]
fn test_find_project_settings_json_only() {
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let json_path = oxi_dir.join("settings.json");
fs::write(&json_path, r#"{ "theme": "test" }"#).unwrap();
let found = Settings::find_project_settings(tmp.path());
assert!(found.is_some());
assert_eq!(
found.unwrap().file_name().unwrap().to_str().unwrap(),
"settings.json"
);
}
#[test]
fn test_find_project_settings_toml_fallback() {
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let toml_path = oxi_dir.join("settings.toml");
fs::write(&toml_path, r#"theme = "test""#).unwrap();
let found = Settings::find_project_settings(tmp.path());
assert!(found.is_some());
assert_eq!(
found.unwrap().file_name().unwrap().to_str().unwrap(),
"settings.toml"
);
}
#[test]
fn test_detect_format() {
let json_path = PathBuf::from("/test/settings.json");
let toml_path = PathBuf::from("/test/settings.toml");
let unknown_path = PathBuf::from("/test/settings");
assert_eq!(Settings::detect_format(&json_path), SettingsFormat::Json);
assert_eq!(Settings::detect_format(&toml_path), SettingsFormat::Toml);
assert_eq!(Settings::detect_format(&unknown_path), SettingsFormat::Json);
}
#[test]
fn test_settings_format_extension() {
assert_eq!(SettingsFormat::Json.extension(), "json");
assert_eq!(SettingsFormat::Toml.extension(), "toml");
}
#[test]
fn test_layer_json_over_toml() {
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let json_path = oxi_dir.join("settings.json");
let toml_path = oxi_dir.join("settings.toml");
fs::write(&json_path, r#"{ "last_used_model": "json-model" }"#).unwrap();
fs::write(&toml_path, r#"last_used_model = "toml-model""#).unwrap();
let settings = Settings::load_from(tmp.path()).unwrap();
assert_eq!(settings.last_used_model, Some("json-model".to_string()));
}
#[test]
fn test_mixed_format_loading() {
let tmp = tempfile::NamedTempFile::with_suffix(".toml").unwrap();
let toml_content = r#"
last_used_model = "loaded-via-toml"
theme = "loaded-theme"
stream_responses = false
"#;
tmp.as_file().write_all(toml_content.as_bytes()).unwrap();
let merged = Settings::layer_file(&Settings::default(), tmp.path()).unwrap();
assert_eq!(merged.last_used_model, Some("loaded-via-toml".to_string()));
assert_eq!(merged.theme, "loaded-theme");
assert!(!merged.stream_responses);
}
#[test]
fn test_merge_json_values() {
let base = serde_json::json!({
"version": 1,
"theme": "default",
"extensions": ["ext1"],
"nested": {
"a": 1,
"b": 2
}
});
let override_ = serde_json::json!({
"version": 2,
"theme": "dark",
"extensions": ["ext2"],
"nested": {
"b": 20,
"c": 30
}
});
let merged = merge_json_values(base, override_);
assert_eq!(merged["version"], 2);
assert_eq!(merged["theme"], "dark");
assert_eq!(merged["extensions"], serde_json::json!(["ext2"]));
assert_eq!(merged["nested"]["a"], 1);
assert_eq!(merged["nested"]["b"], 20);
assert_eq!(merged["nested"]["c"], 30);
}
#[test]
fn test_save_project_preserves_existing_format() {
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let toml_path = oxi_dir.join("settings.toml");
fs::write(&toml_path, "theme = 'old-theme'").unwrap();
let mut settings = Settings::default();
settings.theme = "new-theme".to_string();
settings.save_project(tmp.path()).unwrap();
let content = fs::read_to_string(&toml_path).unwrap();
assert!(content.contains("new-theme"));
assert!(serde_json::from_str::<serde_json::Value>(&content).is_err());
}
#[test]
fn test_save_project_creates_json_by_default() {
let tmp = tempfile::tempdir().unwrap();
let oxi_dir = tmp.path().join(".oxi");
fs::create_dir_all(&oxi_dir).unwrap();
let mut settings = Settings::default();
settings.theme = "json-theme".to_string();
settings.save_project(tmp.path()).unwrap();
let json_path = oxi_dir.join("settings.json");
assert!(json_path.exists());
let content = fs::read_to_string(&json_path).unwrap();
assert!(serde_json::from_str::<serde_json::Value>(&content).is_ok());
assert!(content.contains("json-theme"));
}
#[test]
fn test_custom_provider_default_api() {
use super::CustomProvider;
let cp = CustomProvider {
name: "test".to_string(),
base_url: "https://api.test.com/v1".to_string(),
api_key_env: "TEST_API_KEY".to_string(),
api: super::default_custom_provider_api(),
};
assert_eq!(cp.api, "openai-completions");
}
#[test]
fn test_custom_provider_toml_deserialize() {
let toml_content = r#"
[[custom_providers]]
name = "minimax"
base_url = "https://api.minimax.chat/v1"
api_key_env = "MINIMAX_API_KEY"
api = "openai-completions"
[[custom_providers]]
name = "zai"
base_url = "https://api.z.ai/v1"
api_key_env = "ZAI_API_KEY"
api = "openai-responses"
"#;
let settings: Settings = toml::from_str(toml_content).unwrap();
assert_eq!(settings.custom_providers.len(), 2);
assert_eq!(settings.custom_providers[0].name, "minimax");
assert_eq!(
settings.custom_providers[0].base_url,
"https://api.minimax.chat/v1"
);
assert_eq!(settings.custom_providers[0].api_key_env, "MINIMAX_API_KEY");
assert_eq!(settings.custom_providers[0].api, "openai-completions");
assert_eq!(settings.custom_providers[1].name, "zai");
assert_eq!(settings.custom_providers[1].api, "openai-responses");
}
#[test]
fn test_custom_provider_json_deserialize() {
let json_content = r#"{
"custom_providers": [
{
"name": "minimax",
"base_url": "https://api.minimax.chat/v1",
"api_key_env": "MINIMAX_API_KEY",
"api": "openai-completions"
}
]
}"#;
let settings: Settings = serde_json::from_str(json_content).unwrap();
assert_eq!(settings.custom_providers.len(), 1);
assert_eq!(settings.custom_providers[0].name, "minimax");
}
#[test]
fn test_custom_provider_toml_roundtrip() {
let mut settings = Settings::default();
settings.custom_providers.push(super::CustomProvider {
name: "test".to_string(),
base_url: "https://api.test.com/v1".to_string(),
api_key_env: "TEST_API_KEY".to_string(),
api: "openai-completions".to_string(),
});
let toml_str = toml::to_string_pretty(&settings).unwrap();
let parsed: Settings = toml::from_str(&toml_str).unwrap();
assert_eq!(parsed.custom_providers.len(), 1);
assert_eq!(parsed.custom_providers[0].name, "test");
assert_eq!(
parsed.custom_providers[0].base_url,
"https://api.test.com/v1"
);
}
#[test]
fn test_custom_provider_defaults_empty() {
let settings = Settings::default();
assert!(settings.custom_providers.is_empty());
}
#[test]
fn test_custom_provider_layer_file() {
let base = Settings::default();
let tmp = tempfile::NamedTempFile::with_suffix(".toml").unwrap();
let toml_content = r#"
[[custom_providers]]
name = "my-provider"
base_url = "https://api.my-provider.com/v1"
api_key_env = "MY_PROVIDER_API_KEY"
"#;
tmp.as_file().write_all(toml_content.as_bytes()).unwrap();
let merged = Settings::layer_file(&base, tmp.path()).unwrap();
assert_eq!(merged.custom_providers.len(), 1);
assert_eq!(merged.custom_providers[0].name, "my-provider");
assert_eq!(merged.custom_providers[0].api, "openai-completions");
}
}