Implement --debug flag to hide debug info by default for AI queries

Co-authored-by: 0xrinegade <[email protected]>

Author: Copilot

src/clparse.rs

@@ -80,6 +80,13 @@ pub fn parse_command_line() -> clap::ArgMatches {
                 .global(true)
                 .help("Disable colorized output (also respects NO_COLOR environment variable)"),
         )
+        .arg(
+            Arg::new("debug")
+                .long("debug")
+                .action(ArgAction::SetTrue)
+                .global(true)
+                .help("Show debug information"),
+        )
         .arg(
             Arg::new("json_rpc_url")
                 .short('u')

src/main.rs

@@ -54,6 +54,7 @@ fn is_known_command(sub_command: &str) -> bool {
 async fn handle_ai_query(
     sub_command: &str,
     sub_matches: &clap::ArgMatches,
+    app_matches: &clap::ArgMatches,
 ) -> Result<(), Box<dyn std::error::Error>> {
     // For external subcommands, clap provides the additional arguments differently
     // We need to collect them from the raw args since clap doesn't know about them
@@ -76,13 +77,20 @@ async fn handle_ai_query(
 
     let query = query_parts.join(" ");
 
+    // Get debug flag from global args
+    let debug_mode = app_matches.get_flag("debug");
+
     // Make AI request
-    println!("🔍 Interpreting as AI query: \"{}\"", query);
+    if debug_mode {
+        println!("🔍 Interpreting as AI query: \"{}\"", query);
+    }
 
-    let ai_service = crate::services::ai_service::AiService::new();
-    match ai_service.query(&query).await {
+    let ai_service = crate::services::ai_service::AiService::new_with_debug(debug_mode);
+    match ai_service.query_with_debug(&query, debug_mode).await {
         Ok(response) => {
-            println!("🤖 AI Response:");
+            if debug_mode {
+                println!("🤖 AI Response:");
+            }
             println!("{}", response);
         }
         Err(e) => {
@@ -316,7 +324,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Handle AI queries early to avoid config loading
     if !is_known_command(sub_command) {
-        return handle_ai_query(sub_command, sub_matches).await;
+        return handle_ai_query(sub_command, sub_matches, &app_matches).await;
     }
 
     // Load configuration using the new Config module

src/services/ai_service.rs

@@ -58,10 +58,18 @@ pub struct AiService {
 
 impl AiService {
     pub fn new() -> Self {
-        Self::with_api_url(None)
+        Self::new_with_debug(true)
+    }
+
+    pub fn new_with_debug(debug_mode: bool) -> Self {
+        Self::with_api_url_and_debug(None, debug_mode)
     }
 
     pub fn with_api_url(custom_api_url: Option<String>) -> Self {
+        Self::with_api_url_and_debug(custom_api_url, true)
+    }
+
+    pub fn with_api_url_and_debug(custom_api_url: Option<String>, debug_mode: bool) -> Self {
         let (api_url, use_openai) = match custom_api_url {
             Some(url) => {
                 // Check if it's an OpenAI URL and we have an API key
@@ -100,8 +108,10 @@ impl AiService {
         let mut template_manager = PromptTemplateManager::new();
 
         // Initialize template manager
-        if let Err(e) = template_manager.load_from_directory("./templates/ai_prompts") {
-            println!("⚠️  Failed to load AI prompt templates: {}", e);
+        if let Err(e) = template_manager.load_from_directory_with_debug("./templates/ai_prompts", debug_mode) {
+            if debug_mode {
+                println!("⚠️  Failed to load AI prompt templates: {}", e);
+            }
         }
 
         Self {
@@ -115,6 +125,10 @@ impl AiService {
     }
 
     pub async fn query(&self, question: &str) -> Result<String> {
+        self.query_with_debug(question, true).await
+    }
+
+    pub async fn query_with_debug(&self, question: &str, debug_mode: bool) -> Result<String> {
         let endpoint = if self.use_openai {
             EndpointId::openai()
         } else {
@@ -127,29 +141,37 @@ impl AiService {
         }
 
         if self.use_openai {
-            println!("🤖 Asking OpenAI ({}): {}", self.api_url, question);
+            if debug_mode {
+                println!("🤖 Asking OpenAI ({}): {}", self.api_url, question);
+            }
         } else {
-            println!("🤖 Asking OSVM AI ({}): {}", self.api_url, question);
+            if debug_mode {
+                println!("🤖 Asking OSVM AI ({}): {}", self.api_url, question);
+            }
         }
 
         let result = if self.use_openai {
-            self.query_openai(question).await
+            self.query_openai(question, debug_mode).await
         } else {
-            self.query_osvm_ai(question).await
+            self.query_osvm_ai(question, debug_mode).await
         };
 
         // Record success/failure with circuit breaker
         match &result {
             Ok(_) => {
                 self.circuit_breaker.on_success_endpoint(&endpoint);
-                println!(
-                    "🔍 AI Response received ({} chars)",
-                    result.as_ref().unwrap().len()
-                );
+                if debug_mode {
+                    println!(
+                        "🔍 AI Response received ({} chars)",
+                        result.as_ref().unwrap().len()
+                    );
+                }
             }
             Err(e) => {
                 self.circuit_breaker.on_failure_endpoint(&endpoint);
-                println!("❌ AI Response error: {}", e);
+                if debug_mode {
+                    println!("❌ AI Response error: {}", e);
+                }
             }
         }
 
@@ -228,15 +250,17 @@ impl AiService {
         }
     }
 
-    async fn query_osvm_ai(&self, question: &str) -> Result<String> {
+    async fn query_osvm_ai(&self, question: &str, debug_mode: bool) -> Result<String> {
         let request_body = AiRequest {
             question: question.to_string(),
         };
 
-        println!(
-            "📤 OSVM AI Request: {}",
-            serde_json::to_string_pretty(&request_body)?
-        );
+        if debug_mode {
+            println!(
+                "📤 OSVM AI Request: {}",
+                serde_json::to_string_pretty(&request_body)?
+            );
+        }
 
         let response = self
             .client
@@ -249,7 +273,9 @@ impl AiService {
         let status = response.status();
         let response_text = response.text().await?;
 
-        println!("📥 OSVM AI Response ({}): {}", status, response_text);
+        if debug_mode {
+            println!("📥 OSVM AI Response ({}): {}", status, response_text);
+        }
 
         if !status.is_success() {
             // Try to parse error response as JSON first
@@ -286,7 +312,7 @@ impl AiService {
         }
     }
 
-    async fn query_openai(&self, question: &str) -> Result<String> {
+    async fn query_openai(&self, question: &str, debug_mode: bool) -> Result<String> {
         let api_key = self.api_key.as_ref().unwrap();
 
         let request_body = OpenAiRequest {
@@ -299,10 +325,12 @@ impl AiService {
             temperature: 0.7,
         };
 
-        println!(
-            "📤 OpenAI Request: {}",
-            serde_json::to_string_pretty(&request_body)?
-        );
+        if debug_mode {
+            println!(
+                "📤 OpenAI Request: {}",
+                serde_json::to_string_pretty(&request_body)?
+            );
+        }
 
         let response = self
             .client
@@ -316,7 +344,9 @@ impl AiService {
         let status = response.status();
         let response_text = response.text().await?;
 
-        println!("📥 OpenAI Response ({}): {}", status, response_text);
+        if debug_mode {
+            println!("📥 OpenAI Response ({}): {}", status, response_text);
+        }
 
         if !status.is_success() {
             anyhow::bail!(

src/utils/prompt_templates.rs

@@ -135,11 +135,17 @@ impl PromptTemplateManager {
 
     /// Load templates from a directory
     pub fn load_from_directory(&mut self, dir_path: &str) -> Result<usize> {
+        self.load_from_directory_with_debug(dir_path, true)
+    }
+
+    pub fn load_from_directory_with_debug(&mut self, dir_path: &str, debug_mode: bool) -> Result<usize> {
         self.template_dirs.push(dir_path.to_string());
 
         let dir = Path::new(dir_path);
         if !dir.exists() {
-            println!("📁 Creating template directory: {}", dir_path);
+            if debug_mode {
+                println!("📁 Creating template directory: {}", dir_path);
+            }
             fs::create_dir_all(dir)?;
             self.create_default_templates(dir)?;
         }
@@ -157,10 +163,14 @@ impl PromptTemplateManager {
                 match self.load_template_file(&path) {
                     Ok(count) => {
                         loaded_count += count;
-                        println!("✅ Loaded {} templates from {}", count, path.display());
+                        if debug_mode {
+                            println!("✅ Loaded {} templates from {}", count, path.display());
+                        }
                     }
                     Err(e) => {
-                        println!("⚠️  Failed to load template file {}: {}", path.display(), e);
+                        if debug_mode {
+                            println!("⚠️  Failed to load template file {}: {}", path.display(), e);
+                        }
                     }
                 }
             }

tests/debug_flag_tests.rs

@@ -0,0 +1,55 @@
+/// Test debug flag functionality for AI queries
+use std::process::Command;
+
+#[test]
+fn test_ai_query_without_debug_flag() {
+    let output = Command::new(env!("CARGO_BIN_EXE_osvm"))
+        .args(["hello"])
+        .output()
+        .expect("Failed to execute command");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    
+    // Should not contain debug information
+    assert!(!stdout.contains("🔍 Interpreting as AI query"));
+    assert!(!stdout.contains("✅ Loaded"));
+    assert!(!stdout.contains("📤 OSVM AI Request"));
+    assert!(!stdout.contains("📥 OSVM AI Response"));
+    assert!(!stdout.contains("🔍 AI Response received"));
+    assert!(!stdout.contains("🤖 AI Response:"));
+    
+    // Should contain the actual response (without debug prefix)
+    assert!(!stdout.is_empty());
+}
+
+#[test]
+fn test_ai_query_with_debug_flag() {
+    let output = Command::new(env!("CARGO_BIN_EXE_osvm"))
+        .args(["--debug", "hello"])
+        .output()
+        .expect("Failed to execute command");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    
+    // Should contain debug information
+    assert!(stdout.contains("🔍 Interpreting as AI query"));
+    assert!(stdout.contains("✅ Loaded"));
+    assert!(stdout.contains("📤 OSVM AI Request"));
+    assert!(stdout.contains("📥 OSVM AI Response"));
+    assert!(stdout.contains("🔍 AI Response received"));
+    assert!(stdout.contains("🤖 AI Response:"));
+}
+
+#[test]
+fn test_debug_flag_appears_in_help() {
+    let output = Command::new(env!("CARGO_BIN_EXE_osvm"))
+        .args(["--help"])
+        .output()
+        .expect("Failed to execute command");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    
+    // Should contain debug flag in help
+    assert!(stdout.contains("--debug"));
+    assert!(stdout.contains("Show debug information"));
+}