Updates: New features

Author: jruokola

Cargo.lock

@@ -84,8 +84,11 @@ impl AnthropicProvider {
                 Err(e) => {
                     last_error = Some(e);
                     if attempt < self.config.max_retries {
-                        tracing::warn!("Anthropic request failed (attempt {}/{}), retrying...",
-                            attempt + 1, self.config.max_retries + 1);
+                        tracing::warn!(
+                            "Anthropic request failed (attempt {}/{}), retrying...",
+                            attempt + 1,
+                            self.config.max_retries + 1
+                        );
                     }
                 }
             }
@@ -143,11 +146,7 @@ impl AnthropicProvider {
                 .await
                 .unwrap_or_else(|_| "Unknown error".to_string());
 
-            return Err(anyhow!(
-                "Anthropic API error ({}): {}",
-                status,
-                error_text
-            ));
+            return Err(anyhow!("Anthropic API error ({}): {}", status, error_text));
         }
 
         response

crates/codegraph-ai/src/anthropic_provider.rs

@@ -1,5 +1,5 @@
-pub mod llm_provider;
 pub mod llm_factory;
+pub mod llm_provider;
 pub mod ml;
 pub mod optimization;
 pub mod qwen_simple;
@@ -9,12 +9,12 @@ pub mod semantic;
 // Cloud LLM providers
 #[cfg(feature = "anthropic")]
 pub mod anthropic_provider;
-#[cfg(feature = "openai-llm")]
-pub mod openai_llm_provider;
 #[cfg(feature = "openai-compatible")]
 pub mod openai_compatible_provider;
+#[cfg(feature = "openai-llm")]
+pub mod openai_llm_provider;
 
-pub use llm_provider::*;
 pub use llm_factory::LLMProviderFactory;
+pub use llm_provider::*;
 pub use qwen_simple::{QwenClient, QwenConfig, QwenResult};
 pub use semantic::search::*;

crates/codegraph-ai/src/lib.rs

@@ -37,9 +37,21 @@ impl LLMProviderFactory {
             _ => Err(anyhow!(
                 "Unsupported LLM provider: {}. Available providers: ollama, lmstudio{}{}{}",
                 provider_name,
-                if cfg!(feature = "anthropic") { ", anthropic" } else { "" },
-                if cfg!(feature = "openai-llm") { ", openai" } else { "" },
-                if cfg!(feature = "openai-compatible") { ", openai-compatible" } else { "" }
+                if cfg!(feature = "anthropic") {
+                    ", anthropic"
+                } else {
+                    ""
+                },
+                if cfg!(feature = "openai-llm") {
+                    ", openai"
+                } else {
+                    ""
+                },
+                if cfg!(feature = "openai-compatible") {
+                    ", openai-compatible"
+                } else {
+                    ""
+                }
             )),
         }
     }
@@ -136,10 +148,7 @@ impl LLMProviderFactory {
         let openai_config = OpenAIConfig {
             api_key,
             base_url: "https://api.openai.com/v1".to_string(),
-            model: config
-                .model
-                .clone()
-                .unwrap_or_else(|| "gpt-4o".to_string()),
+            model: config.model.clone().unwrap_or_else(|| "gpt-4o".to_string()),
             context_window: config.context_window,
             timeout_secs: config.timeout_secs,
             max_retries: 3,
@@ -152,14 +161,9 @@ impl LLMProviderFactory {
     /// Create an OpenAI-compatible provider
     #[cfg(feature = "openai-compatible")]
     fn create_openai_compatible_provider(config: &LLMConfig) -> Result<Arc<dyn LLMProvider>> {
-        let base_url = config
-            .openai_compatible_url
-            .clone()
-            .ok_or_else(|| {
-                anyhow!(
-                    "OpenAI-compatible base URL not found. Set 'openai_compatible_url' in config"
-                )
-            })?;
+        let base_url = config.openai_compatible_url.clone().ok_or_else(|| {
+            anyhow!("OpenAI-compatible base URL not found. Set 'openai_compatible_url' in config")
+        })?;
 
         let compat_config = OpenAICompatibleConfig {
             base_url,

crates/codegraph-ai/src/llm_factory.rs

@@ -123,7 +123,8 @@ pub trait LLMProvider: Send + Sync {
             role: MessageRole::User,
             content: prompt.to_string(),
         }];
-        self.generate_chat(&messages, &GenerationConfig::default()).await
+        self.generate_chat(&messages, &GenerationConfig::default())
+            .await
     }
 
     /// Generate a completion with custom configuration

crates/codegraph-ai/src/llm_provider.rs

@@ -190,16 +190,14 @@ impl OpenAICompatibleProvider {
 
         // Add API key if provided
         if let Some(api_key) = &self.config.api_key {
-            request_builder = request_builder.header("Authorization", format!("Bearer {}", api_key));
+            request_builder =
+                request_builder.header("Authorization", format!("Bearer {}", api_key));
         }
 
-        let response = request_builder
-            .send()
-            .await
-            .context(format!(
-                "Failed to send request to {} Responses API at {}",
-                self.config.provider_name, self.config.base_url
-            ))?;
+        let response = request_builder.send().await.context(format!(
+            "Failed to send request to {} Responses API at {}",
+            self.config.provider_name, self.config.base_url
+        ))?;
 
         let status = response.status();
 
@@ -257,16 +255,14 @@ impl OpenAICompatibleProvider {
 
         // Add API key if provided
         if let Some(api_key) = &self.config.api_key {
-            request_builder = request_builder.header("Authorization", format!("Bearer {}", api_key));
+            request_builder =
+                request_builder.header("Authorization", format!("Bearer {}", api_key));
         }
 
-        let response = request_builder
-            .send()
-            .await
-            .context(format!(
-                "Failed to send request to {} Chat Completions API at {}",
-                self.config.provider_name, self.config.base_url
-            ))?;
+        let response = request_builder.send().await.context(format!(
+            "Failed to send request to {} Chat Completions API at {}",
+            self.config.provider_name, self.config.base_url
+        ))?;
 
         let status = response.status();
 
@@ -284,16 +280,16 @@ impl OpenAICompatibleProvider {
             ));
         }
 
-        let chat_response: ChatCompletionsResponse = response
-            .json()
-            .await
-            .context(format!(
-                "Failed to parse {} Chat Completions API response",
-                self.config.provider_name
-            ))?;
+        let chat_response: ChatCompletionsResponse = response.json().await.context(format!(
+            "Failed to parse {} Chat Completions API response",
+            self.config.provider_name
+        ))?;
 
         // Convert Chat Completions response to Responses API format
-        let choice = chat_response.choices.first().ok_or_else(|| anyhow!("No choices in response"))?;
+        let choice = chat_response
+            .choices
+            .first()
+            .ok_or_else(|| anyhow!("No choices in response"))?;
 
         Ok(ResponseAPIResponse {
             id: chat_response.id,
@@ -352,7 +348,7 @@ impl LLMProvider for OpenAICompatibleProvider {
         ProviderCharacteristics {
             max_tokens: self.config.context_window,
             avg_latency_ms: 1500, // Local models are typically slower
-            rpm_limit: None,       // No rate limits for local providers
+            rpm_limit: None,      // No rate limits for local providers
             tpm_limit: None,
             supports_streaming: true,
             supports_functions: false, // Most local providers don't support function calling

crates/codegraph-ai/src/openai_compatible_provider.rs

@@ -230,18 +230,21 @@ impl LLMProvider for OpenAIProvider {
 
     fn characteristics(&self) -> ProviderCharacteristics {
         // Characteristics vary by model
-        let (max_tokens, rpm_limit, tpm_limit, supports_functions) = match self.config.model.as_str() {
-            // Reasoning models
-            m if m.contains("o1") => (200_000, Some(50), Some(30_000), false),
-            m if m.contains("o3") || m.contains("o4") => (200_000, Some(50), Some(30_000), false),
-            m if m.starts_with("gpt-5") => (200_000, Some(50), Some(30_000), false),
-            // Standard models
-            "gpt-4o" => (128_000, Some(500), Some(30_000), true),
-            "gpt-4o-mini" => (128_000, Some(500), Some(200_000), true),
-            "gpt-4-turbo" => (128_000, Some(500), Some(30_000), true),
-            "gpt-4" => (8_192, Some(500), Some(10_000), true),
-            _ => (self.config.context_window, Some(500), Some(30_000), true),
-        };
+        let (max_tokens, rpm_limit, tpm_limit, supports_functions) =
+            match self.config.model.as_str() {
+                // Reasoning models
+                m if m.contains("o1") => (200_000, Some(50), Some(30_000), false),
+                m if m.contains("o3") || m.contains("o4") => {
+                    (200_000, Some(50), Some(30_000), false)
+                }
+                m if m.starts_with("gpt-5") => (200_000, Some(50), Some(30_000), false),
+                // Standard models
+                "gpt-4o" => (128_000, Some(500), Some(30_000), true),
+                "gpt-4o-mini" => (128_000, Some(500), Some(200_000), true),
+                "gpt-4-turbo" => (128_000, Some(500), Some(30_000), true),
+                "gpt-4" => (8_192, Some(500), Some(10_000), true),
+                _ => (self.config.context_window, Some(500), Some(30_000), true),
+            };
 
         ProviderCharacteristics {
             max_tokens,
@@ -394,7 +397,11 @@ mod tests {
                 ..Default::default()
             };
             let provider = OpenAIProvider::new(config).unwrap();
-            assert!(provider.is_reasoning_model(), "Model {} should be detected as reasoning model", model);
+            assert!(
+                provider.is_reasoning_model(),
+                "Model {} should be detected as reasoning model",
+                model
+            );
         }
     }
 
@@ -408,7 +415,11 @@ mod tests {
                 ..Default::default()
             };
             let provider = OpenAIProvider::new(config).unwrap();
-            assert!(!provider.is_reasoning_model(), "Model {} should NOT be detected as reasoning model", model);
+            assert!(
+                !provider.is_reasoning_model(),
+                "Model {} should NOT be detected as reasoning model",
+                model
+            );
         }
     }
 }

crates/codegraph-ai/src/openai_llm_provider.rs

@@ -269,12 +269,7 @@ async fn run_setup_wizard() -> Result<SetupConfig> {
                     .allow_empty(true)
                     .interact_text()?;
 
-                let models = vec![
-                    "gpt-4o",
-                    "gpt-4o-mini",
-                    "gpt-4-turbo",
-                    "gpt-4",
-                ];
+                let models = vec!["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4"];
 
                 let model_selection = Select::with_theme(&theme)
                     .with_prompt("Select OpenAI model")
@@ -345,18 +340,15 @@ fn save_config(config: &SetupConfig) -> Result<()> {
         .join(".codegraph");
 
     // Create config directory if it doesn't exist
-    fs::create_dir_all(&config_dir)
-        .context("Failed to create config directory")?;
+    fs::create_dir_all(&config_dir).context("Failed to create config directory")?;
 
     let config_path = config_dir.join("config.toml");
 
     // Serialize config to TOML
-    let toml_content = toml::to_string_pretty(config)
-        .context("Failed to serialize config")?;
+    let toml_content = toml::to_string_pretty(config).context("Failed to serialize config")?;
 
     // Write to file
-    fs::write(&config_path, toml_content)
-        .context("Failed to write config file")?;
+    fs::write(&config_path, toml_content).context("Failed to write config file")?;
 
     println!("\n📝 Configuration preview:");
     println!("─────────────────────────────────────────────────");

crates/codegraph-api/src/bin/codegraph-setup.rs

@@ -265,8 +265,7 @@ async fn main() -> Result<()> {
     let cli = Cli::parse();
 
     // Initialize configuration
-    let config = ConfigManager::new(None)
-        .context("Failed to load configuration")?;
+    let config = ConfigManager::new(None).context("Failed to load configuration")?;
 
     // Initialize app state (for now, we'll create a temporary one)
     // In production, this would connect to the actual storage
@@ -321,8 +320,7 @@ async fn execute_transaction_command(
         }
 
         TransactionCommands::Commit { transaction_id } => {
-            let tx_id = Uuid::parse_str(transaction_id)
-                .context("Invalid transaction ID format")?;
+            let tx_id = Uuid::parse_str(transaction_id).context("Invalid transaction ID format")?;
 
             state
                 .transactional_graph
@@ -341,8 +339,7 @@ async fn execute_transaction_command(
         }
 
         TransactionCommands::Rollback { transaction_id } => {
-            let tx_id = Uuid::parse_str(transaction_id)
-                .context("Invalid transaction ID format")?;
+            let tx_id = Uuid::parse_str(transaction_id).context("Invalid transaction ID format")?;
 
             state
                 .transactional_graph
@@ -668,11 +665,7 @@ fn print_pretty(value: &serde_json::Value) -> Result<()> {
                         println!("{}: {}", key_colored, n.to_string().yellow());
                     }
                     serde_json::Value::Bool(b) => {
-                        let val_colored = if *b {
-                            "true".green()
-                        } else {
-                            "false".red()
-                        };
+                        let val_colored = if *b { "true".green() } else { "false".red() };
                         println!("{}: {}", key_colored, val_colored);
                     }
                     _ => {

crates/codegraph-cli/src/main.rs

@@ -10,7 +10,7 @@ use tracing::{debug, info, warn};
 use crate::embedding_config::{EmbeddingModelConfig, EmbeddingPreset};
 use crate::performance_config::{PerformanceMode, PerformanceModeConfig, PerformanceProfile};
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Default)]
 pub struct AdvancedConfig {
     #[serde(default)]
     pub embedding: EmbeddingModelConfig,
@@ -28,18 +28,6 @@ pub struct AdvancedConfig {
     pub templates: ConfigTemplates,
 }
 
-impl Default for AdvancedConfig {
-    fn default() -> Self {
-        Self {
-            embedding: EmbeddingModelConfig::default(),
-            performance: PerformanceModeConfig::default(),
-            runtime: RuntimeConfig::default(),
-            monitoring: MonitoringConfig::default(),
-            templates: ConfigTemplates::default(),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct RuntimeConfig {
     #[serde(default = "RuntimeConfig::default_allow_runtime_switching")]