zesdex/src/model/app_config.rs

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppConfig {
    pub providers: HashMap<String, ProviderConfig>,
    pub model_roles: HashMap<String, ModelRole>,
    pub default_provider: String,
    pub default_model: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderConfig {
    pub api_base: String,
    pub api_key_env: Option<String>,
    pub default_model: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelRole {
    pub provider: String,
    pub model: String,
    pub max_tokens: Option<u32>,
    pub temperature: Option<f32>,
}

impl Default for AppConfig {
    fn default() -> Self {
        let mut providers = HashMap::new();
        providers.insert("zen".to_string(), ProviderConfig {
            api_base: "https://opencode.ai/zen/v1".to_string(),
            api_key_env: Some("API_KEY".to_string()),
            default_model: Some("deepseek-v4-flash-free".to_string()),
        });
        let mut model_roles = HashMap::new();
        model_roles.insert("default".to_string(), ModelRole {
            provider: "zen".to_string(),
            model: "deepseek-v4-flash-free".to_string(),
            max_tokens: Some(8192),
            temperature: Some(0.7),
        });
        AppConfig {
            providers,
            model_roles,
            default_provider: "zen".to_string(),
            default_model: "deepseek-v4-flash-free".to_string(),
        }
    }
}

impl AppConfig {
    pub fn load() -> Self {
        let store = super::store::Store::new();
        let path = store.base_dir.join("app_config.json");
        std::fs::read_to_string(path)
            .ok()
            .and_then(|s| serde_json::from_str(&s).ok())
            .unwrap_or_default()
    }
}