add debug option to recommend

Author: zhangfengcdt

examples/financial_advisor/src/advisor/interactive.rs

@@ -102,7 +102,7 @@ impl<'a> InteractiveSession<'a> {
         println!("{}", "Available commands:".yellow());
         println!(
             "  {} - Get recommendation for a stock symbol",
-            "recommend <SYMBOL> [notes]".cyan()
+            "recommend <SYMBOL> [--debug] [notes]".cyan()
         );
         println!("  {} - Show client profile", "profile".cyan());
         println!(
@@ -149,17 +149,32 @@ impl<'a> InteractiveSession<'a> {
 
             "recommend" | "r" => {
                 if parts.len() < 2 {
-                    println!("{} Usage: recommend <SYMBOL> [notes]", "❓".yellow());
+                    println!(
+                        "{} Usage: recommend <SYMBOL> [--debug] [notes]",
+                        "❓".yellow()
+                    );
                     return Ok(true);
                 }
 
                 let symbol = parts[1].to_uppercase();
-                let notes = if parts.len() > 2 {
-                    Some(parts[2..].join(" "))
+
+                // Check for debug flag and extract notes
+                let mut debug_mode = false;
+                let mut remaining_parts = &parts[2..];
+
+                if !remaining_parts.is_empty() && remaining_parts[0] == "--debug" {
+                    debug_mode = true;
+                    remaining_parts = &remaining_parts[1..];
+                }
+
+                let notes = if !remaining_parts.is_empty() {
+                    Some(remaining_parts.join(" "))
                 } else {
                     None
                 };
-                self.handle_recommendation(&symbol, client, notes).await?;
+
+                self.handle_recommendation_with_debug(&symbol, client, notes, debug_mode)
+                    .await?;
             }
 
             "profile" | "p" => {
@@ -282,7 +297,6 @@ impl<'a> InteractiveSession<'a> {
                 println!("Result: '{actual}'");
             }
 
-
             "exit" | "quit" | "q" => {
                 return Ok(false);
             }
@@ -307,7 +321,7 @@ impl<'a> InteractiveSession<'a> {
         println!("{}", "Available commands:".yellow());
         println!(
             "  {} - Get recommendation for a stock symbol",
-            "recommend <SYMBOL> [notes]".cyan()
+            "recommend <SYMBOL> [--debug] [notes]".cyan()
         );
         println!("  {} - Show client profile", "profile".cyan());
         println!(
@@ -370,14 +384,30 @@ impl<'a> InteractiveSession<'a> {
         symbol: &str,
         client: &ClientProfile,
         notes: Option<String>,
+    ) -> Result<()> {
+        self.handle_recommendation_with_debug(symbol, client, notes, false)
+            .await
+    }
+
+    async fn handle_recommendation_with_debug(
+        &mut self,
+        symbol: &str,
+        client: &ClientProfile,
+        notes: Option<String>,
+        debug_mode: bool,
     ) -> Result<()> {
         println!(
-            "{} Generating recommendation for {}...",
+            "{} Generating recommendation for {}{}...",
             "🔍".yellow(),
-            symbol
+            symbol,
+            if debug_mode { " (debug mode)" } else { "" }
         );
 
-        match self.advisor.get_recommendation(symbol, client, notes).await {
+        match self
+            .advisor
+            .get_recommendation_with_debug(symbol, client, notes, debug_mode)
+            .await
+        {
             Ok(recommendation) => {
                 println!();
                 println!("{}", "📊 Recommendation Generated".green().bold());
@@ -393,21 +423,29 @@ impl<'a> InteractiveSession<'a> {
                     "Confidence".cyan(),
                     recommendation.confidence * 100.0
                 );
-                
+
                 // Show analysis mode prominently
                 let mode_display = match recommendation.analysis_mode {
-                    crate::advisor::AnalysisMode::AIPowered => "🤖 AI-Powered Analysis".bright_green(),
-                    crate::advisor::AnalysisMode::RuleBased => "📊 Rule-Based Analysis".bright_yellow(),
+                    crate::advisor::AnalysisMode::AIPowered => {
+                        "🤖 AI-Powered Analysis".bright_green()
+                    }
+                    crate::advisor::AnalysisMode::RuleBased => {
+                        "📊 Rule-Based Analysis".bright_yellow()
+                    }
                 };
                 println!("{}: {}", "Mode".cyan(), mode_display);
-                
+
                 // Show data source information
                 let data_source_display = match recommendation.data_source {
-                    crate::advisor::DataSource::RealStockData => "📈 Real Market Data".bright_blue(),
-                    crate::advisor::DataSource::SimulatedData => "🎲 Simulated Data".bright_magenta(),
+                    crate::advisor::DataSource::RealStockData => {
+                        "📈 Real Market Data".bright_blue()
+                    }
+                    crate::advisor::DataSource::SimulatedData => {
+                        "🎲 Simulated Data".bright_magenta()
+                    }
                 };
                 println!("{}: {}", "Data Source".cyan(), data_source_display);
-                
+
                 println!("{}: {}", "Client".cyan(), recommendation.client_id);
                 println!();
                 println!("{}", "Reasoning:".yellow());
@@ -585,21 +623,21 @@ impl<'a> InteractiveSession<'a> {
                 rec.recommendation_type.as_str().bold()
             );
             println!("  {}: {:.1}%", "Confidence".cyan(), rec.confidence * 100.0);
-            
+
             // Show analysis mode with clear indicator
             let mode_display = match rec.analysis_mode {
                 crate::advisor::AnalysisMode::AIPowered => "🤖 AI-Powered".bright_green(),
                 crate::advisor::AnalysisMode::RuleBased => "📊 Rule-Based".bright_yellow(),
             };
             println!("  {}: {}", "Analysis Mode".cyan(), mode_display);
-            
+
             // Show data source
             let data_source_display = match rec.data_source {
                 crate::advisor::DataSource::RealStockData => "📈 Real Data".bright_blue(),
                 crate::advisor::DataSource::SimulatedData => "🎲 Simulated".bright_magenta(),
             };
             println!("  {}: {}", "Data Source".cyan(), data_source_display);
-            
+
             println!("  {}: {}", "Client ID".cyan(), rec.client_id);
             println!(
                 "  {}: {}",
@@ -872,7 +910,7 @@ impl<'a> InteractiveSession<'a> {
         // Display branches in a tree structure
         println!("{}", "Repository Branches:".yellow());
         println!();
-        
+
         // Sort branches to ensure main/master comes first
         let mut sorted_branches = branches.clone();
         sorted_branches.sort_by(|a, b| {
@@ -890,32 +928,42 @@ impl<'a> InteractiveSession<'a> {
             let is_last = i == sorted_branches.len() - 1;
             let connector = if is_last { "└──" } else { "├──" };
             let vertical_line = if is_last { "    " } else { "│   " };
-            
+
             // Determine branch color and symbol
-            let (branch_display, symbol) = if branch == &current_branch {
+            let (branch_display, symbol) = if branch == current_branch {
                 (branch.green().bold(), "●") // Current branch
             } else if branch == "main" || branch == "master" {
                 (branch.blue().bold(), "◆") // Main branch
             } else {
                 (branch.normal(), "○") // Other branches
             };
-            
+
             // Display branch with appropriate formatting
-            println!("{} {} {} {}", 
-                connector.dimmed(), 
+            println!(
+                "{} {} {} {}",
+                connector.dimmed(),
                 symbol,
                 branch_display,
-                if branch == &current_branch { "(current)".dimmed() } else { "".normal() }
+                if branch == current_branch {
+                    "(current)".dimmed()
+                } else {
+                    "".normal()
+                }
             );
-            
+
             // Show some recent commits for the current branch
-            if branch == &current_branch {
+            if branch == current_branch {
                 if let Ok(history) = self.advisor.get_memory_history(Some(3)).await {
                     for (j, commit) in history.iter().enumerate() {
                         let is_last_commit = j == history.len() - 1 || j == 2;
-                        let commit_connector = if is_last_commit { "└──" } else { "├──" };
-                        
-                        println!("{}   {} {} {}",
+                        let commit_connector = if is_last_commit {
+                            "└──"
+                        } else {
+                            "├──"
+                        };
+
+                        println!(
+                            "{}   {} {} {}",
                             vertical_line.dimmed(),
                             commit_connector.dimmed(),
                             commit.hash[..8].yellow(),
@@ -932,9 +980,18 @@ impl<'a> InteractiveSession<'a> {
         println!("  {} Main branch", "◆".blue());
         println!("  {} Other branches", "○".normal());
         println!();
-        println!("{} All branches share the same versioned memory system", "💾".cyan());
-        println!("{} Switch branches with: switch <branch-name>", "🔀".yellow());
-        println!("{} Create new branch with: branch <branch-name>", "🌿".green());
+        println!(
+            "{} All branches share the same versioned memory system",
+            "💾".cyan()
+        );
+        println!(
+            "{} Switch branches with: switch <branch-name>",
+            "🔀".yellow()
+        );
+        println!(
+            "{} Create new branch with: branch <branch-name>",
+            "🌿".green()
+        );
 
         Ok(())
     }
@@ -1036,5 +1093,4 @@ impl<'a> InteractiveSession<'a> {
             );
         }
     }
-
 }

examples/financial_advisor/src/advisor/mod.rs

@@ -2,6 +2,7 @@
 
 use anyhow::Result;
 use chrono::{DateTime, Utc};
+use colored::Colorize;
 // OpenAI integration for AI-powered recommendations
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
@@ -125,6 +126,17 @@ impl FinancialAdvisor {
         symbol: &str,
         client_profile: &ClientProfile,
         notes: Option<String>,
+    ) -> Result<Recommendation> {
+        self.get_recommendation_with_debug(symbol, client_profile, notes, false)
+            .await
+    }
+
+    pub async fn get_recommendation_with_debug(
+        &mut self,
+        symbol: &str,
+        client_profile: &ClientProfile,
+        notes: Option<String>,
+        debug_mode: bool,
     ) -> Result<Recommendation> {
         if self.verbose {
             println!("🔍 Fetching market data for {symbol}...");
@@ -145,7 +157,7 @@ impl FinancialAdvisor {
             .recommendation_engine
             .generate(symbol, client_profile, &market_data, &self.memory_store)
             .await?;
-        
+
         // Set the data source
         recommendation.data_source = stock_data.data_source;
 
@@ -155,12 +167,13 @@ impl FinancialAdvisor {
         }
 
         let (ai_reasoning, analysis_mode) = self
-            .generate_ai_reasoning(
+            .generate_ai_reasoning_with_debug(
                 symbol,
                 &recommendation.recommendation_type,
                 &serde_json::from_str::<serde_json::Value>(&market_data.content)
                     .unwrap_or(serde_json::json!({})),
                 client_profile,
+                debug_mode,
             )
             .await?;
 
@@ -458,6 +471,24 @@ impl FinancialAdvisor {
         recommendation_type: &RecommendationType,
         market_data: &serde_json::Value,
         client: &ClientProfile,
+    ) -> Result<(String, AnalysisMode)> {
+        self.generate_ai_reasoning_with_debug(
+            symbol,
+            recommendation_type,
+            market_data,
+            client,
+            false,
+        )
+        .await
+    }
+
+    async fn generate_ai_reasoning_with_debug(
+        &self,
+        symbol: &str,
+        recommendation_type: &RecommendationType,
+        market_data: &serde_json::Value,
+        client: &ClientProfile,
+        debug_mode: bool,
     ) -> Result<(String, AnalysisMode)> {
         // Build context from market data
         let price = market_data["price"].as_f64().unwrap_or(0.0);
@@ -501,6 +532,16 @@ impl FinancialAdvisor {
             recommendation_type = recommendation_type
         );
 
+        // Print prompt if debug mode is enabled
+        if debug_mode {
+            println!();
+            println!("{}", "🔍 OpenAI Prompt Debug".bright_cyan().bold());
+            println!("{}", "━".repeat(60).dimmed());
+            println!("{prompt}");
+            println!("{}", "━".repeat(60).dimmed());
+            println!();
+        }
+
         // Make OpenAI API call
         let openai_request = serde_json::json!({
             "model": "gpt-3.5-turbo",

examples/financial_advisor/src/advisor/recommendations.rs

@@ -4,7 +4,9 @@ use anyhow::Result;
 use chrono::Utc;
 use uuid::Uuid;
 
-use super::{AnalysisMode, ClientProfile, DataSource, Recommendation, RecommendationType, RiskTolerance};
+use super::{
+    AnalysisMode, ClientProfile, DataSource, Recommendation, RecommendationType, RiskTolerance,
+};
 use crate::memory::{MemoryStore, ValidatedMemory};
 use crate::validation::ValidationResult;