feat: add internal ZCLAW kernel crates to git tracking

crates/zclaw-kernel/src/config.rs

@@ -0,0 +1,121 @@
+//! Kernel configuration
+
+use std::sync::Arc;
+use serde::{Deserialize, Serialize};
+use secrecy::SecretString;
+use zclaw_types::{Result, ZclawError};
+use zclaw_runtime::{LlmDriver, AnthropicDriver, OpenAiDriver, GeminiDriver, LocalDriver};
+
+/// Kernel configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct KernelConfig {
+    /// Database URL (SQLite)
+    #[serde(default = "default_database_url")]
+    pub database_url: String,
+
+    /// Default LLM provider
+    #[serde(default = "default_provider")]
+    pub default_provider: String,
+
+    /// Default model
+    #[serde(default = "default_model")]
+    pub default_model: String,
+
+    /// API keys (loaded from environment)
+    #[serde(skip)]
+    pub anthropic_api_key: Option<String>,
+    #[serde(skip)]
+    pub openai_api_key: Option<String>,
+    #[serde(skip)]
+    pub gemini_api_key: Option<String>,
+
+    /// Local LLM base URL
+    #[serde(default)]
+    pub local_base_url: Option<String>,
+
+    /// Maximum tokens per response
+    #[serde(default = "default_max_tokens")]
+    pub max_tokens: u32,
+
+    /// Default temperature
+    #[serde(default = "default_temperature")]
+    pub temperature: f32,
+}
+
+fn default_database_url() -> String {
+    let home = dirs::home_dir().unwrap_or_else(|| std::path::PathBuf::from("."));
+    let dir = home.join(".zclaw");
+    format!("sqlite:{}/data.db?mode=rwc", dir.display())
+}
+
+fn default_provider() -> String {
+    "anthropic".to_string()
+}
+
+fn default_model() -> String {
+    "claude-sonnet-4-20250514".to_string()
+}
+
+fn default_max_tokens() -> u32 {
+    4096
+}
+
+fn default_temperature() -> f32 {
+    0.7
+}
+
+impl Default for KernelConfig {
+    fn default() -> Self {
+        Self {
+            database_url: default_database_url(),
+            default_provider: default_provider(),
+            default_model: default_model(),
+            anthropic_api_key: std::env::var("ANTHROPIC_API_KEY").ok(),
+            openai_api_key: std::env::var("OPENAI_API_KEY").ok(),
+            gemini_api_key: std::env::var("GEMINI_API_KEY").ok(),
+            local_base_url: None,
+            max_tokens: default_max_tokens(),
+            temperature: default_temperature(),
+        }
+    }
+}
+
+impl KernelConfig {
+    /// Load configuration from file
+    pub async fn load() -> Result<Self> {
+        // TODO: Load from ~/.zclaw/config.toml
+        Ok(Self::default())
+    }
+
+    /// Create the default LLM driver
+    pub fn create_driver(&self) -> Result<Arc<dyn LlmDriver>> {
+        let driver: Arc<dyn LlmDriver> = match self.default_provider.as_str() {
+            "anthropic" => {
+                let key = self.anthropic_api_key.clone()
+                    .ok_or_else(|| ZclawError::ConfigError("ANTHROPIC_API_KEY not set".into()))?;
+                Arc::new(AnthropicDriver::new(SecretString::new(key)))
+            }
+            "openai" => {
+                let key = self.openai_api_key.clone()
+                    .ok_or_else(|| ZclawError::ConfigError("OPENAI_API_KEY not set".into()))?;
+                Arc::new(OpenAiDriver::new(SecretString::new(key)))
+            }
+            "gemini" => {
+                let key = self.gemini_api_key.clone()
+                    .ok_or_else(|| ZclawError::ConfigError("GEMINI_API_KEY not set".into()))?;
+                Arc::new(GeminiDriver::new(SecretString::new(key)))
+            }
+            "local" | "ollama" => {
+                let base_url = self.local_base_url.clone()
+                    .unwrap_or_else(|| "http://localhost:11434/v1".to_string());
+                Arc::new(LocalDriver::new(base_url))
+            }
+            _ => {
+                return Err(ZclawError::ConfigError(
+                    format!("Unknown provider: {}", self.default_provider)
+                ));
+            }
+        };
+        Ok(driver)
+    }
+}