feat: enhance Ruixen's state management with emoji reactions and query analysis

Author: gitcoder89431

.idea/agentic.iml

@@ -67,6 +67,43 @@ pub enum AgentMessage {
     CloudSynthesisComplete(Result<AtomicNote, CloudError>),
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RuixenState {
+    Resting,     // 😴💤🌙 - Waiting for input, peaceful state
+    Curious,     // 🤨🧠💭 - Analyzing user query, thinking
+    Working,     // 😤💦📝 - Processing complex query, working hard
+    Searching,   // 🔍☁️⚡ - Cloud processing, searching for answers
+    Celebrating, // 💎🚀🎯 - Successful synthesis, celebration
+    Confused,    // 😅🤦‍♂️📝 - Error state, but learning from it
+}
+
+impl RuixenState {
+    pub fn emoji_expression(&self) -> &'static str {
+        match self {
+            RuixenState::Resting => "😴 💤 🌙",
+            RuixenState::Curious => "🤨 🧠 💭",
+            RuixenState::Working => "😤 💦 📝",
+            RuixenState::Searching => "🔍 ☁️ ⚡",
+            RuixenState::Celebrating => "💎 🚀 🎯",
+            RuixenState::Confused => "😅 🤦‍♂️ 📝",
+        }
+    }
+
+    pub fn from_agent_status(status: AgentStatus) -> Self {
+        match status {
+            AgentStatus::Ready => RuixenState::Resting,
+            AgentStatus::Orchestrating => RuixenState::Curious,
+            AgentStatus::Searching => RuixenState::Searching,
+            AgentStatus::Complete => RuixenState::Celebrating,
+            AgentStatus::LocalEndpointError | AgentStatus::CloudEndpointError => {
+                RuixenState::Confused
+            }
+            AgentStatus::ValidatingLocal | AgentStatus::ValidatingCloud => RuixenState::Working,
+            _ => RuixenState::Resting,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum SettingsSelection {
     #[default]
@@ -129,6 +166,8 @@ pub struct App {
     cloud_tokens_used: u32, // Token count for current cloud request
     show_autocomplete: bool,
     autocomplete_index: usize,
+    ruixen_reaction_state: Option<RuixenState>, // Temporary reaction state
+    reaction_timer: Option<std::time::Instant>, // When reaction started,
 }
 
 impl App {
@@ -162,6 +201,76 @@ impl App {
             cloud_tokens_used: 0,
             show_autocomplete: false,
             autocomplete_index: 0,
+            ruixen_reaction_state: None,
+            reaction_timer: None,
+        }
+    }
+
+    fn get_current_ruixen_emoji(&self) -> &'static str {
+        // Check if we have a temporary reaction that should expire
+        if let (Some(reaction), Some(timer)) = (&self.ruixen_reaction_state, &self.reaction_timer) {
+            if timer.elapsed() <= std::time::Duration::from_millis(2000) {
+                // 2 second reactions
+                return reaction.emoji_expression();
+            }
+        }
+
+        // Default to agent status-based emoji
+        RuixenState::from_agent_status(self.agent_status).emoji_expression()
+    }
+
+    fn set_ruixen_reaction(&mut self, reaction: RuixenState) {
+        self.ruixen_reaction_state = Some(reaction);
+        self.reaction_timer = Some(std::time::Instant::now());
+    }
+
+    fn cleanup_expired_reactions(&mut self) {
+        if let (Some(_), Some(timer)) = (&self.ruixen_reaction_state, &self.reaction_timer) {
+            if timer.elapsed() > std::time::Duration::from_millis(2000) {
+                self.ruixen_reaction_state = None;
+                self.reaction_timer = None;
+            }
+        }
+    }
+
+    fn analyze_query_complexity(&self, query: &str) -> RuixenState {
+        let word_count = query.split_whitespace().count();
+        let has_questions = query.contains('?');
+        let has_complex_words = query.split_whitespace().any(|word| word.len() > 10);
+        let is_philosophical = query.to_lowercase().contains("why")
+            || query.to_lowercase().contains("how")
+            || query.to_lowercase().contains("what if");
+
+        // Determine Ruixen's initial reaction based on query complexity
+        if word_count < 5 && !has_questions {
+            RuixenState::Curious // 🤨🧠💭 - Simple query, just curious
+        } else if (word_count > 15) || has_complex_words || is_philosophical {
+            RuixenState::Working // 😤💦📝 - Complex query, need to work hard
+        } else {
+            RuixenState::Curious // 🤨🧠💭 - Standard query, thinking
+        }
+    }
+
+    fn analyze_synthesis_quality(&self, response: &AtomicNote) -> RuixenState {
+        let body_length = response.body_text.len();
+        let has_insights = response.body_text.to_lowercase().contains("insight")
+            || response.body_text.to_lowercase().contains("reveals")
+            || response.body_text.to_lowercase().contains("understanding");
+        let has_technical_terms = response
+            .body_text
+            .split_whitespace()
+            .any(|word| word.len() > 12 || word.contains("ology") || word.contains("tion"));
+        let tag_count = response.header_tags.len();
+
+        // Determine Ruixen's reaction to the synthesis quality
+        if body_length > 800 && has_insights && tag_count > 3 {
+            RuixenState::Celebrating // 💎🚀🎯 - Excellent synthesis, celebration!
+        } else if body_length > 400 && (has_insights || has_technical_terms) {
+            RuixenState::Celebrating // 💎🚀🎯 - Good synthesis, satisfied
+        } else if body_length < 200 {
+            RuixenState::Confused // 😅🤦‍♂️📝 - Short response, maybe didn't work well
+        } else {
+            RuixenState::Curious // 🤨🧠💭 - Decent response, still thinking
         }
     }
 
@@ -173,7 +282,7 @@ impl App {
         };
 
         let block = Block::default()
-            .title(" Synthesize Knowledge ")
+            .title(format!(" {} ", self.get_current_ruixen_emoji()))
             .borders(Borders::ALL)
             .style(self.theme.ratatui_style(Element::Active));
 
@@ -299,6 +408,9 @@ impl App {
 
     pub async fn run(&mut self, terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
         while !self.should_quit {
+            // Clean up expired reactions
+            self.cleanup_expired_reactions();
+
             self.draw(terminal)?;
 
             // Handle validation messages from background tasks
@@ -496,7 +608,7 @@ impl App {
                 );
 
                 let block = Block::default()
-                    .title(" Synthesis Complete ")
+                    .title(format!(" {} ", self.get_current_ruixen_emoji()))
                     .borders(Borders::ALL)
                     .style(self.theme.ratatui_style(Element::Active));
 
@@ -519,6 +631,7 @@ impl App {
                         commands: &self.get_filtered_slash_commands(),
                         selected_index: self.autocomplete_index,
                     },
+                    self.get_current_ruixen_emoji(),
                 );
             }
         })?;
@@ -638,6 +751,10 @@ impl App {
                 self.agent_status = AgentStatus::Ready;
             }
             AgentMessage::CloudSynthesisComplete(Ok(response)) => {
+                // Analyze the synthesis quality and show reaction
+                let reaction = self.analyze_synthesis_quality(&response);
+                self.set_ruixen_reaction(reaction);
+
                 self.cloud_response = Some(response);
                 self.mode = AppMode::Complete;
                 self.agent_status = AgentStatus::Complete;
@@ -1079,6 +1196,10 @@ impl App {
             // Store the original user query for metadata
             self.original_user_query = message.clone();
 
+            // Analyze query complexity and show brief reaction
+            let reaction = self.analyze_query_complexity(&message);
+            self.set_ruixen_reaction(reaction);
+
             // Estimate tokens for local request (rough: chars/4 + prompt overhead)
             self.local_tokens_used = (message.len() / 4) as u32 + 500; // ~500 tokens for prompt template
             self.cloud_tokens_used = 0; // Reset cloud tokens for new session

.idea/workspace.xml

@@ -71,10 +71,11 @@ pub fn render_chat(
     chat_input: &str,
     agent_status: AgentStatus,
     autocomplete: AutocompleteParams,
+    ruixen_emoji: &str,
 ) {
     let chat_block = Block::new()
         .borders(Borders::ALL)
-        .title(" 🤨 🔍 💡 ")
+        .title(format!(" {} ", ruixen_emoji))
         .style(theme.ratatui_style(Element::Text));
 
     let inner_area = chat_block.inner(area);