Merge pull request #106 from openSVM/copilot/fix-105

Hide debug info under --debug flag for AI queries (v0.7.0)

Author: 0xrinegade

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "osvm"
-version = "0.6.4"
+version = "0.7.0"
 edition = "2021"
 license = "MIT"
 description = "OpenSVM CLI tool for managing SVM nodes and deployments"

Cargo.toml

@@ -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/clparse.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/main.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/services/ai_service.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);
+                        }
                     }
                 }
             }

src/utils/prompt_templates.rs

@@ -0,0 +1,25 @@
+id: deeplogic_economic_exploit
+name: DeepLogic Economic Exploit Analysis
+description: Analyzes code for potential economic exploitation vulnerabilities
+category: deeplogic
+analysis_vector: economic_exploit
+template: "You are an expert Solana security auditor specializing in economic vulnerability analysis.\n\nAnalyze the following code for potential economic exploitation vulnerabilities:\n\nFILE: {filename}\nCODE:\n```rust\n{code}\n```\n\nVULNERABILITY CONTEXT:\n{vulnerability_description}\n\nPlease provide a comprehensive analysis including:\n\n1. **Economic Risk Assessment**: How could this code be exploited for financial gain?\n2. **Attack Scenarios**: Describe specific step-by-step attack vectors\n3. **Impact Analysis**: Quantify potential financial losses or gains for attackers\n4. **Fix Recommendations**: Provide specific code changes to prevent exploitation\n\nFocus on:\n- Flash loan attacks\n- Arbitrage vulnerabilities  \n- Price manipulation\n- Liquidity extraction\n- MEV (Maximal Extractable Value) opportunities\n- Economic state inconsistencies\n\nProvide your analysis in JSON format:\n{{\n  \"risk_level\": \"Critical|High|Medium|Low\",\n  \"confidence_score\": 0.0-1.0,\n  \"attack_scenarios\": [\"scenario1\", \"scenario2\"],\n  \"economic_impact\": \"description\",\n  \"recommended_fixes\": [\"fix1\", \"fix2\"]\n}}"
+variables:
+- name: filename
+  description: Path to the source file being analyzed
+  required: true
+  default_value: null
+  variable_type: filename
+- name: code
+  description: The source code to analyze
+  required: true
+  default_value: null
+  variable_type: code
+- name: vulnerability_description
+  description: Description of the identified vulnerability
+  required: true
+  default_value: null
+  variable_type: string
+version: 1.0.0
+enabled: true
+metadata: {}

templates/ai_prompts/deeplogic_economic_exploit.yaml

@@ -0,0 +1,65 @@
+id: fix_suggestion_general
+name: General Fix Suggestion Generator
+description: Generates specific code fixes for identified vulnerabilities
+category: fix_suggestion
+analysis_vector: general
+template: |-
+  You are an expert Rust and Solana developer tasked with fixing security vulnerabilities.
+
+  PROBLEMATIC CODE:
+  ```rust
+  {problematic_code}
+  ```
+
+  ISSUE DESCRIPTION:
+  {issue_description}
+
+  VULNERABILITY TYPE: {vulnerability_type}
+
+  Please provide:
+
+  1. **Root Cause Analysis**: Why is this code vulnerable?
+  2. **Specific Fix**: Provide the exact corrected code
+  3. **Explanation**: Explain why your fix resolves the issue
+  4. **Additional Considerations**: Any other security improvements
+
+  Requirements:
+  - Maintain existing functionality
+  - Follow Solana/Anchor best practices
+  - Include proper error handling
+  - Add necessary imports if required
+
+  Provide your response in this format:
+
+  ## Root Cause
+  [explanation]
+
+  ## Fixed Code
+  ```rust
+  [corrected code]
+  ```
+
+  ## Explanation
+  [why this fix works]
+
+  ## Additional Considerations
+  [other improvements or warnings]
+variables:
+- name: problematic_code
+  description: The code that contains the vulnerability
+  required: true
+  default_value: null
+  variable_type: code
+- name: issue_description
+  description: Description of the security issue
+  required: true
+  default_value: null
+  variable_type: string
+- name: vulnerability_type
+  description: Type/category of the vulnerability
+  required: false
+  default_value: General Security Issue
+  variable_type: string
+version: 1.0.0
+enabled: true
+metadata: {}