feat(chat): Implement /compact help and simplify token warning system

- Add proper help text for '/compact help' command similar to '/context help'
- Replace multiple warning levels with a single warning at 500K characters
- Change token warning language to be more subtle about limits
- Add '--summary' flag to show the summary after compacting
- Refactor token calculation to focus on character count instead of percentages

Author: aseemxs

crates/q_cli/src/cli/chat/chat_state.rs

@@ -6,17 +6,14 @@ use fig_api_client::model::ChatMessage;
 pub enum TokenWarningLevel {
     /// No warning, conversation is within normal limits
     None,
-    /// Warning level - approaching limit (60% of max)
-    Warning,
-    /// Critical level - near limit (90% of max)
+    /// Critical level - at single warning threshold (500K characters)
     Critical,
 }
 
 /// Constants for token usage warnings
 pub const CHARS_PER_TOKEN: f64 = 3.5;
 pub const MAX_TOKENS: usize = 200000; // Reduced for testing (original: 200_000)
-pub const WARNING_THRESHOLD: f64 = 0.60; // 60% of max tokens
-pub const CRITICAL_THRESHOLD: f64 = 0.90; // 90% of max tokens
+pub const MAX_CHARS: usize = 500000; // Single character-based warning threshold
 
 /// Flag for the compact command - we will always clear but store the summary
 #[derive(Debug, Clone)]
@@ -32,20 +29,24 @@ pub struct SummarizationState {
     pub original_history: Option<VecDeque<ChatMessage>>,
     /// Optional custom prompt used for summarization
     pub custom_prompt: Option<String>,
+    /// Whether to show the summary after compacting
+    pub show_summary: bool,
 }
 
 impl SummarizationState {
     pub fn new() -> Self {
         Self {
             original_history: None,
             custom_prompt: None,
+            show_summary: false,
         }
     }
 
     pub fn with_prompt(prompt: Option<String>) -> Self {
         Self {
             original_history: None,
             custom_prompt: prompt,
+            show_summary: false,
         }
     }
 }

crates/q_cli/src/cli/chat/command.rs

@@ -18,8 +18,7 @@ pub enum Command {
     Profile { subcommand: ProfileSubcommand },
     Context { subcommand: ContextSubcommand },
     PromptEditor { initial_text: Option<String> },
-    Compact { prompt: Option<String> },
-    Summary,
+    Compact { prompt: Option<String>, show_summary: bool, help: bool },
     Tools { subcommand: Option<ToolsSubcommand> },
 }
 
@@ -223,18 +222,45 @@ impl Command {
             return Ok(match parts[0].to_lowercase().as_str() {
                 "clear" => Self::Clear,
                 "help" => Self::Help,
-                "summary" => Self::Summary,
                 "compact" => {
-                    if parts.len() > 1 {
-                        // If there are additional arguments, join them as the prompt
-                        Self::Compact {
-                            prompt: Some(parts[1..].join(" ")),
-                        }
+                    let mut prompt = None;
+                    let mut show_summary = false;
+                    let mut help = false;
+                    
+                    // Check if "help" is the first subcommand
+                    if parts.len() > 1 && parts[1].to_lowercase() == "help" {
+                        help = true;
                     } else {
-                        // No additional arguments, use default prompt
-                        Self::Compact { 
-                            prompt: None,
+                        let mut remaining_parts = Vec::new();
+                        
+                        // Parse the parts to handle both prompt and flags
+                        for part in &parts[1..] {
+                            if *part == "--summary" {
+                                show_summary = true;
+                            } else {
+                                remaining_parts.push(*part);
+                            }
+                        }
+                        
+                        // Check if the last word is "--summary" (which would have been captured as part of the prompt)
+                        if !remaining_parts.is_empty() {
+                            let last_idx = remaining_parts.len() - 1;
+                            if remaining_parts[last_idx] == "--summary" {
+                                remaining_parts.pop();
+                                show_summary = true;
+                            }
                         }
+                        
+                        // If we have remaining parts after parsing flags, join them as the prompt
+                        if !remaining_parts.is_empty() {
+                            prompt = Some(remaining_parts.join(" "));
+                        }
+                    }
+                    
+                    Self::Compact { 
+                        prompt,
+                        show_summary,
+                        help,
                     }
                 },
                 "acceptall" => {
@@ -533,7 +559,21 @@ mod tests {
                 }
             };
         }
+        macro_rules! compact {
+            ($prompt:expr, $show_summary:expr) => {
+                Command::Compact {
+                    prompt: $prompt,
+                    show_summary: $show_summary,
+                    help: false,
+                }
+            };
+        }
         let tests = &[
+            ("/compact", compact!(None, false)),
+            ("/compact --summary", compact!(None, true)),
+            ("/compact custom prompt", compact!(Some("custom prompt".to_string()), false)),
+            ("/compact --summary custom prompt", compact!(Some("custom prompt".to_string()), true)),
+            ("/compact custom prompt --summary", compact!(Some("custom prompt".to_string()), true)),
             ("/profile list", profile!(ProfileSubcommand::List)),
             (
                 "/profile create new_profile",

crates/q_cli/src/cli/chat/conversation_state.rs

@@ -32,7 +32,7 @@ use tracing::{
     warn,
 };
 
-use super::chat_state::{CHARS_PER_TOKEN, CRITICAL_THRESHOLD, MAX_TOKENS, TokenWarningLevel, WARNING_THRESHOLD};
+use super::chat_state::{CHARS_PER_TOKEN, MAX_CHARS, MAX_TOKENS, TokenWarningLevel};
 use super::context::ContextManager;
 use super::tools::{
     QueuedTool,
@@ -502,7 +502,7 @@ impl ConversationState {
         self.context_message_length
     }
 
-    /// Calculate the approximate token usage based on character count
+    /// Calculate the character count and token usage
     pub fn calculate_token_usage(&self) -> (usize, f64) {
         // Calculate total character count in all messages
         let mut total_chars = 0;
@@ -549,21 +549,19 @@ impl ConversationState {
             total_chars += summary.len();
         }
 
-        // Calculate estimated tokens
+        // Calculate estimated tokens based on character count
         let estimated_tokens = (total_chars as f64 / CHARS_PER_TOKEN).ceil() as usize;
         let usage_percentage = estimated_tokens as f64 / MAX_TOKENS as f64;
 
-        (estimated_tokens, usage_percentage)
+        (total_chars, usage_percentage)
     }
 
     /// Get the current token warning level
     pub fn get_token_warning_level(&self) -> TokenWarningLevel {
-        let (_, usage_percentage) = self.calculate_token_usage();
+        let (total_chars, _) = self.calculate_token_usage();
 
-        if usage_percentage >= CRITICAL_THRESHOLD {
+        if total_chars >= MAX_CHARS {
             TokenWarningLevel::Critical
-        } else if usage_percentage >= WARNING_THRESHOLD {
-            TokenWarningLevel::Warning
         } else {
             TokenWarningLevel::None
         }