grok-cli-acp 0.1.2

package/src/display/mod.rs

@@ -0,0 +1,62 @@
+//! Display module for Grok CLI
+//!
+//! Handles ASCII art, banners, tips, and other visual elements
+
+pub mod ascii_art;
+pub mod banner;
+pub mod components;
+pub mod interactive;
+pub mod terminal;
+pub mod tips;
+
+pub use ascii_art::print_grok_logo;
+pub use banner::{
+    clear_current_line, print_directory_recommendation, print_welcome_banner,
+    BannerConfig,
+};
+
+use colored::*;
+use std::io::{self, Write};
+use terminal_size::{terminal_size, Height, Width};
+
+/// Get terminal dimensions
+pub fn get_terminal_size() -> (u16, u16) {
+    if let Some((Width(w), Height(h))) = terminal_size() {
+        (w, h)
+    } else {
+        (80, 24) // Default fallback
+    }
+}
+
+/// Clear the terminal screen
+pub fn clear_screen() {
+    print!("\x1B[2J\x1B[1;1H");
+    io::stdout().flush().unwrap_or(());
+}
+
+/// Print a separator line
+pub fn print_separator(width: u16, color: Option<Color>) {
+    let line = "─".repeat(width as usize);
+    if let Some(c) = color {
+        println!("{}", line.color(c));
+    } else {
+        println!("{}", line.dimmed());
+    }
+}
+
+/// Print centered text
+pub fn print_centered(text: &str, width: u16, color: Option<Color>) {
+    let text_len = text.len();
+    let padding = if width as usize > text_len {
+        (width as usize - text_len) / 2
+    } else {
+        0
+    };
+
+    let centered = format!("{}{}", " ".repeat(padding), text);
+    if let Some(c) = color {
+        println!("{}", centered.color(c));
+    } else {
+        println!("{}", centered);
+    }
+}

package/src/display/terminal.rs

@@ -0,0 +1,42 @@
+use anyhow::Result;
+use crossterm::{
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::backend::CrosstermBackend;
+use ratatui::Terminal;
+use std::io::{self, Stdout};
+
+pub type Tui = Terminal<CrosstermBackend<Stdout>>;
+
+pub fn init_tui() -> Result<Tui> {
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen)?;
+    let backend = CrosstermBackend::new(stdout);
+    let terminal = Terminal::new(backend)?;
+    Ok(terminal)
+}
+
+pub fn restore_tui() -> Result<()> {
+    disable_raw_mode()?;
+    execute!(io::stdout(), LeaveAlternateScreen)?;
+    Ok(())
+}
+
+/// A lighter version of init_tui that doesn't enter alternate screen
+/// Useful for the chat interface where we want to keep history visible
+pub fn init_inline_tui() -> Result<Tui> {
+    enable_raw_mode()?;
+    let stdout = io::stdout();
+    // We don't enter alternate screen here
+    let backend = CrosstermBackend::new(stdout);
+    let terminal = Terminal::new(backend)?;
+    Ok(terminal)
+}
+
+pub fn restore_inline_tui() -> Result<()> {
+    disable_raw_mode()?;
+    // We don't leave alternate screen here
+    Ok(())
+}

package/src/display/tips.rs

@@ -0,0 +1,316 @@
+//! Tips display module for Grok CLI
+//!
+//! Handles display of helpful tips and getting started information
+
+use colored::*;
+use rand::prelude::IndexedMutRandom;
+use rand::seq::SliceRandom;
+
+/// Collection of helpful tips for users
+pub static GETTING_STARTED_TIPS: &[&str] = &[
+    "Ask questions, edit files, or run commands.",
+    "Be specific for the best results.",
+    "/help for more information.",
+    "Use 'grok code explain <file>' to understand code.",
+    "Use 'grok code review <file>' for code improvements.",
+    "Use 'grok chat --interactive' for ongoing conversations.",
+    "Set GROK_API_KEY environment variable to avoid typing --api-key.",
+    "Use 'grok config show' to view your current configuration.",
+    "Create a config.toml file to customize default settings.",
+];
+
+/// Advanced usage tips
+pub static ADVANCED_TIPS: &[&str] = &[
+    "Use system prompts with 'grok chat --system \"You are a...\"' for specialized assistance.",
+    "Adjust temperature with --temperature for more creative or focused responses.",
+    "Use 'grok acp server' to integrate with Zed editor.",
+    "Pipe input to Grok CLI: 'cat file.py | grok chat \"Explain this code\"'.",
+    "Use 'grok health --all' to diagnose connectivity issues.",
+    "Set custom models with --model flag (e.g., grok-3, grok-2-latest).",
+    "Use 'grok code generate' to create new code from descriptions.",
+];
+
+/// Productivity tips
+pub static PRODUCTIVITY_TIPS: &[&str] = &[
+    "Create shell aliases: alias gc='grok chat' for faster access.",
+    "Use tab completion in your shell for Grok CLI commands.",
+    "Combine with other CLI tools: 'git diff | grok chat \"Review these changes\"'.",
+    "Set up your preferred editor integration for seamless workflow.",
+    "Use 'grok config set' to save frequently used settings.",
+];
+
+/// Troubleshooting tips
+pub static TROUBLESHOOTING_TIPS: &[&str] = &[
+    "Having connection issues? Check 'grok health --api' for diagnostics.",
+    "API key not working? Verify it's set correctly with 'grok config show'.",
+    "Slow responses? Try reducing --max-tokens or adjusting --timeout.",
+    "Use --verbose flag to see detailed debug information.",
+    "Check your internet connection - Starlink users may experience drops.",
+];
+
+/// Configuration for tip display
+#[derive(Debug, Clone)]
+pub struct TipConfig {
+    pub show_tips: bool,
+    pub randomize: bool,
+    pub max_tips: usize,
+    pub width: Option<u16>,
+}
+
+impl Default for TipConfig {
+    fn default() -> Self {
+        Self {
+            show_tips: true,
+            randomize: true,
+            max_tips: 3,
+            width: None,
+        }
+    }
+}
+
+/// Print getting started tips
+pub fn print_getting_started_tips(config: &TipConfig) {
+    if !config.show_tips {
+        return;
+    }
+
+    println!("{}", "Tips for getting started:".bright_cyan());
+
+    let tips = if config.randomize {
+        get_random_tips(GETTING_STARTED_TIPS, config.max_tips)
+    } else {
+        GETTING_STARTED_TIPS
+            .iter()
+            .take(config.max_tips)
+            .cloned()
+            .collect()
+    };
+
+    for (i, tip) in tips.iter().enumerate() {
+        println!("{}. {}", (i + 1).to_string().bright_white(), tip);
+    }
+    println!();
+}
+
+/// Print advanced tips for experienced users
+pub fn print_advanced_tips(config: &TipConfig) {
+    if !config.show_tips {
+        return;
+    }
+
+    println!("{}", "Advanced tips:".bright_magenta());
+
+    let tips = if config.randomize {
+        get_random_tips(ADVANCED_TIPS, config.max_tips)
+    } else {
+        ADVANCED_TIPS
+            .iter()
+            .take(config.max_tips)
+            .cloned()
+            .collect()
+    };
+
+    for tip in tips {
+        println!("• {}", tip);
+    }
+    println!();
+}
+
+/// Print productivity tips
+pub fn print_productivity_tips(config: &TipConfig) {
+    if !config.show_tips {
+        return;
+    }
+
+    println!("{}", "Productivity tips:".bright_green());
+
+    let tips = if config.randomize {
+        get_random_tips(PRODUCTIVITY_TIPS, config.max_tips)
+    } else {
+        PRODUCTIVITY_TIPS
+            .iter()
+            .take(config.max_tips)
+            .cloned()
+            .collect()
+    };
+
+    for tip in tips {
+        println!("💡 {}", tip);
+    }
+    println!();
+}
+
+/// Print troubleshooting tips
+pub fn print_troubleshooting_tips(config: &TipConfig) {
+    if !config.show_tips {
+        return;
+    }
+
+    println!("{}", "Troubleshooting tips:".bright_yellow());
+
+    let tips = if config.randomize {
+        get_random_tips(TROUBLESHOOTING_TIPS, config.max_tips)
+    } else {
+        TROUBLESHOOTING_TIPS
+            .iter()
+            .take(config.max_tips)
+            .cloned()
+            .collect()
+    };
+
+    for tip in tips {
+        println!("🔧 {}", tip);
+    }
+    println!();
+}
+
+/// Get random tips from a collection
+fn get_random_tips<'a>(tips: &'a [&'a str], count: usize) -> Vec<&'a str> {
+    let mut rng = rand::rng();
+    let mut selected_tips: Vec<&str> = tips.to_vec();
+    selected_tips.shuffle(&mut rng);
+    selected_tips.into_iter().take(count).collect()
+}
+
+/// Print a tip of the day
+pub fn print_tip_of_the_day() {
+    let mut all_tips: Vec<&str> = GETTING_STARTED_TIPS
+        .iter()
+        .chain(ADVANCED_TIPS.iter())
+        .chain(PRODUCTIVITY_TIPS.iter())
+        .chain(TROUBLESHOOTING_TIPS.iter())
+        .cloned()
+        .collect();
+
+    if let Some(tip) = all_tips.choose_mut(&mut rand::rng()) {
+        println!("{} {}", "💡 Tip of the day:".bright_yellow(), tip);
+        println!();
+    }
+}
+
+/// Print contextual tips based on current operation
+pub fn print_contextual_tips(context: &str, config: &TipConfig) {
+    if !config.show_tips {
+        return;
+    }
+
+    match context {
+        "first-run" => print_getting_started_tips(config),
+        "error" => print_troubleshooting_tips(config),
+        "config" => print_config_tips(config),
+        "code" => print_code_tips(config),
+        "chat" => print_chat_tips(config),
+        _ => print_getting_started_tips(config),
+    }
+}
+
+/// Print configuration-specific tips
+fn print_config_tips(config: &TipConfig) {
+    println!("{}", "Configuration tips:".bright_blue());
+    let tips = vec![
+        "Use 'grok config init' to create a default configuration file",
+        "Set your preferred model with 'grok config set default_model grok-3'",
+        "Configure API settings with 'grok config set api_key <your-key>'",
+        "Use 'grok config validate' to check your configuration",
+    ];
+
+    let display_tips = if config.randomize {
+        get_random_tips(&tips, config.max_tips)
+    } else {
+        tips.iter().take(config.max_tips).copied().collect()
+    };
+
+    for tip in display_tips {
+        println!("⚙️ {}", tip);
+    }
+    println!();
+}
+
+/// Print code-specific tips
+fn print_code_tips(config: &TipConfig) {
+    println!("{}", "Code assistance tips:".bright_purple());
+    let tips = vec![
+        "Use 'grok code explain' to understand complex code",
+        "Get code reviews with 'grok code review --focus security'",
+        "Generate code with 'grok code generate --language rust'",
+        "Fix issues with 'grok code fix <file> \"description of problem\"'",
+    ];
+
+    let display_tips = if config.randomize {
+        get_random_tips(&tips, config.max_tips)
+    } else {
+        tips.iter().take(config.max_tips).copied().collect()
+    };
+
+    for tip in display_tips {
+        println!("💻 {}", tip);
+    }
+    println!();
+}
+
+/// Print chat-specific tips
+fn print_chat_tips(config: &TipConfig) {
+    println!("{}", "Chat tips:".bright_cyan());
+    let tips = vec![
+        "Use --interactive for ongoing conversations",
+        "Set system prompts with --system for specialized help",
+        "Adjust creativity with --temperature (0.1 = focused, 1.5 = creative)",
+        "Use --max-tokens to control response length",
+    ];
+
+    let display_tips = if config.randomize {
+        get_random_tips(&tips, config.max_tips)
+    } else {
+        tips.iter().take(config.max_tips).copied().collect()
+    };
+
+    for tip in display_tips {
+        println!("💬 {}", tip);
+    }
+    println!();
+}
+
+/// Print a formatted help section
+pub fn print_help_section(title: &str, items: &[(&str, &str)]) {
+    println!("{}", title.bright_cyan().bold());
+    println!();
+
+    for (command, description) in items {
+        println!("  {:<25} {}", command.bright_white(), description);
+    }
+    println!();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_random_tips() {
+        let tips = ["tip1", "tip2", "tip3", "tip4", "tip5"];
+        let random_tips = get_random_tips(&tips, 3);
+        assert_eq!(random_tips.len(), 3);
+
+        // All returned tips should be from the original set
+        for tip in random_tips {
+            assert!(tips.contains(&tip));
+        }
+    }
+
+    #[test]
+    fn test_tip_config_default() {
+        let config = TipConfig::default();
+        assert!(config.show_tips);
+        assert!(config.randomize);
+        assert_eq!(config.max_tips, 3);
+        assert!(config.width.is_none());
+    }
+
+    #[test]
+    fn test_tips_not_empty() {
+        assert!(!GETTING_STARTED_TIPS.is_empty());
+        assert!(!ADVANCED_TIPS.is_empty());
+        assert!(!PRODUCTIVITY_TIPS.is_empty());
+        assert!(!TROUBLESHOOTING_TIPS.is_empty());
+    }
+}

package/src/grok_client_ext.rs

@@ -0,0 +1,177 @@
+//! Grok Client Extensions
+//!
+//! This module provides compatibility extensions for the grok_api::GrokClient
+//! to maintain API compatibility with the previous local implementation.
+
+use anyhow::Result;
+use grok_api::{ChatMessage, ChatResponse as GrokApiChatResponse, Message};
+use serde_json::Value;
+
+use crate::config::RateLimitConfig;
+
+/// Extended Grok client that wraps grok_api::GrokClient with additional methods
+#[derive(Clone, Debug)]
+pub struct GrokClient {
+    inner: grok_api::GrokClient,
+    rate_limit_config: Option<RateLimitConfig>,
+}
+
+impl GrokClient {
+    /// Create a new GrokClient with default settings
+    pub fn new(api_key: &str) -> Result<Self> {
+        let inner = grok_api::GrokClient::new(api_key)?;
+        Ok(Self {
+            inner,
+            rate_limit_config: None,
+        })
+    }
+
+    /// Create a new GrokClient with custom timeout and retry settings
+    pub fn with_settings(api_key: &str, timeout_secs: u64, max_retries: u32) -> Result<Self> {
+        let inner = grok_api::GrokClient::builder()
+            .api_key(api_key)
+            .timeout_secs(timeout_secs)
+            .max_retries(max_retries)
+            .build()?;
+
+        Ok(Self {
+            inner,
+            rate_limit_config: None,
+        })
+    }
+
+    /// Set rate limit configuration (for compatibility - currently a no-op)
+    pub fn with_rate_limits(mut self, config: RateLimitConfig) -> Self {
+        self.rate_limit_config = Some(config);
+        self
+    }
+
+    /// Send a single chat completion request to Grok
+    pub async fn chat_completion(
+        &self,
+        message: &str,
+        system_prompt: Option<&str>,
+        temperature: f32,
+        max_tokens: u32,
+        model: &str,
+    ) -> Result<String> {
+        let mut messages = Vec::new();
+
+        // Add system message if provided
+        if let Some(system) = system_prompt {
+            messages.push(ChatMessage::system(system));
+        }
+
+        // Add user message
+        messages.push(ChatMessage::user(message));
+
+        let response = self
+            .inner
+            .chat_with_history(&messages)
+            .temperature(temperature)
+            .max_tokens(max_tokens)
+            .model(model)
+            .send()
+            .await?;
+
+        Ok(response.content().unwrap_or("").to_string())
+    }
+
+    /// Send chat completion with conversation history and optional tools
+    pub async fn chat_completion_with_history(
+        &self,
+        messages: &[Value],
+        temperature: f32,
+        max_tokens: u32,
+        model: &str,
+        tools: Option<Vec<Value>>,
+    ) -> Result<Message> {
+        // Convert JSON messages to ChatMessage format
+        let chat_messages: Vec<ChatMessage> = messages
+            .iter()
+            .filter_map(|msg| {
+                let role = msg.get("role")?.as_str()?;
+                let content = msg.get("content")?.as_str()?;
+
+                Some(match role {
+                    "system" => ChatMessage::system(content),
+                    "user" => ChatMessage::user(content),
+                    "assistant" => ChatMessage::assistant(content),
+                    _ => return None,
+                })
+            })
+            .collect();
+
+        let mut request = self
+            .inner
+            .chat_with_history(&chat_messages)
+            .temperature(temperature)
+            .max_tokens(max_tokens)
+            .model(model);
+
+        // Add tools if provided
+        if let Some(tool_defs) = tools {
+            // Convert tools to the format expected by grok_api
+            // Note: This is a simplified conversion - you may need to adjust
+            // based on the exact tool format expected by grok_api
+            request = request.tools(tool_defs);
+        }
+
+        let response = request.send().await?;
+
+        // Convert the response to the Message format
+        convert_response_to_message(response)
+    }
+
+    /// Test the connection to the Grok API
+    pub async fn test_connection(&self) -> Result<()> {
+        self.inner.test_connection().await.map_err(|e| e.into())
+    }
+
+    /// List available models
+    pub async fn list_models(&self) -> Result<Vec<String>> {
+        self.inner.list_models().await.map_err(|e| e.into())
+    }
+
+    /// Get the underlying grok_api client
+    pub fn inner(&self) -> &grok_api::GrokClient {
+        &self.inner
+    }
+}
+
+/// Convert ChatResponse to Message format for compatibility
+fn convert_response_to_message(response: GrokApiChatResponse) -> Result<Message> {
+    // Get the message from the first choice
+    if let Some(message) = response.message() {
+        Ok(message.clone())
+    } else {
+        Ok(Message {
+            role: "assistant".to_string(),
+            content: response.content().map(|s| s.to_string()),
+            tool_calls: None,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_grok_client_creation() {
+        let client = GrokClient::with_settings("test-key", 30, 3);
+        assert!(client.is_ok());
+
+        let empty_key_client = GrokClient::with_settings("", 30, 3);
+        assert!(empty_key_client.is_err());
+    }
+
+    #[test]
+    fn test_with_rate_limits() {
+        let client = GrokClient::new("test-key").unwrap();
+        let rate_config = RateLimitConfig::default();
+        let client_with_limits = client.with_rate_limits(rate_config);
+
+        assert!(client_with_limits.rate_limit_config.is_some());
+    }
+}