grok-cli-acp 0.1.2

package/src/lib.rs

@@ -0,0 +1,174 @@
+//! Grok CLI Library
+//!
+//! This library provides the core functionality for the Grok CLI,
+//! including API integration, configuration management, and display utilities.
+
+use clap::Subcommand;
+
+pub mod acp;
+pub mod cli;
+pub mod config;
+pub mod display;
+pub mod grok_client_ext;
+pub mod hooks;
+pub mod mcp;
+pub mod utils;
+
+// Re-export grok_api types for use throughout the crate
+pub use grok_api::{
+    ChatResponse, Message, ToolCall, FunctionCall, Choice, Usage,
+    Error as GrokApiError,
+};
+
+// Re-export the extended GrokClient
+pub use grok_client_ext::GrokClient;
+
+#[derive(Subcommand, Clone, Debug)]
+pub enum CodeAction {
+    /// Explain code functionality
+    Explain {
+        /// File path or code snippet
+        input: String,
+        /// Input is a file path (default: auto-detect)
+        #[arg(short, long)]
+        file: bool,
+    },
+    /// Review code for improvements
+    Review {
+        /// File path or code snippet
+        input: String,
+        /// Input is a file path (default: auto-detect)
+        #[arg(short, long)]
+        file: bool,
+        /// Focus on specific aspects (security, performance, style, etc.)
+        #[arg(long)]
+        focus: Option<String>,
+    },
+    /// Generate code from description
+    Generate {
+        /// Description of what to generate
+        description: Vec<String>,
+        /// Programming language
+        #[arg(short, long)]
+        language: Option<String>,
+        /// Output file path
+        #[arg(short, long)]
+        output: Option<String>,
+    },
+    /// Fix code issues
+    Fix {
+        /// File path containing code to fix
+        file: String,
+        /// Description of the issue to fix
+        issue: Vec<String>,
+    },
+}
+
+#[derive(Subcommand, Clone, Debug)]
+pub enum AcpAction {
+    /// Start ACP server for Zed integration
+    Server {
+        /// Port to bind to (default: auto-assign)
+        #[arg(short, long)]
+        port: Option<u16>,
+        /// Host to bind to
+        #[arg(short = 'H', long, default_value = "127.0.0.1")]
+        host: String,
+    },
+    /// Start ACP in stdio mode (default for Zed)
+    Stdio {
+        /// Model to use (overrides default)
+        #[arg(long)]
+        model: Option<String>,
+    },
+    /// Test ACP connection
+    Test {
+        /// ACP server address
+        #[arg(short, long)]
+        address: String,
+    },
+    /// Show ACP capabilities
+    Capabilities,
+}
+
+#[derive(Subcommand, Clone, Debug)]
+pub enum ConfigAction {
+    /// Show current configuration
+    Show,
+    /// Set configuration value
+    Set {
+        /// Configuration key
+        key: String,
+        /// Configuration value
+        value: String,
+    },
+    /// Get configuration value
+    Get {
+        /// Configuration key
+        key: String,
+    },
+    /// Initialize configuration with defaults
+    Init {
+        /// Force overwrite existing config
+        #[arg(long)]
+        force: bool,
+    },
+    /// Validate configuration
+    Validate,
+}
+
+#[derive(Subcommand, Clone, Debug)]
+pub enum SettingsAction {
+    /// Show interactive settings browser
+    Show,
+    /// Edit settings interactively
+    Edit,
+    /// Reset settings to defaults
+    Reset {
+        /// Category to reset (optional, resets all if not specified)
+        #[arg(short, long)]
+        category: Option<String>,
+    },
+    /// Export settings to file
+    Export {
+        /// Export file path
+        #[arg(short, long)]
+        path: Option<String>,
+    },
+    /// Import settings from file
+    Import {
+        /// Import file path
+        #[arg(short, long)]
+        path: String,
+    },
+}
+
+#[derive(Subcommand, Clone, Debug)]
+pub enum HistoryAction {
+    /// List all chat sessions
+    List,
+    /// View a specific chat session
+    View {
+        /// Session ID to view
+        session_id: String,
+    },
+    /// Search through chat sessions
+    Search {
+        /// Search query
+        query: String,
+    },
+    /// Clear chat history
+    Clear {
+        /// Confirm deletion
+        #[arg(long)]
+        confirm: bool,
+    },
+}
+
+// Re-export commonly used types and functions
+pub use config::{Config, ConfigSource, RateLimitConfig};
+pub use display::{
+    ascii_art::{get_logo_for_width, print_grok_logo},
+    banner::{BannerConfig, BannerType, print_banner, print_welcome_banner},
+    get_terminal_size,
+};

package/src/main.rs

@@ -0,0 +1,65 @@
+use anyhow::Result;
+use std::path::PathBuf;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+// Import directly from the library crate to avoid duplicate compilation
+use grok_cli::cli;
+use grok_cli::utils::chat_logger;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Load environment variables from .env file
+    dotenvy::dotenv().ok();
+
+    // Initialize tracing
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "grok_cli=info".into()),
+        )
+        .with(tracing_subscriber::fmt::layer())
+        .init();
+
+    // Initialize chat logger
+    let chat_logger_enabled = std::env::var("GROK_CHAT_LOGGING_ENABLED")
+        .unwrap_or_else(|_| "true".to_string())
+        .parse::<bool>()
+        .unwrap_or(true);
+
+    let chat_log_dir = std::env::var("GROK_CHAT_LOG_DIR")
+        .ok()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            dirs::home_dir()
+                .unwrap_or_else(|| PathBuf::from("."))
+                .join(".grok")
+                .join("logs")
+                .join("chat_sessions")
+        });
+
+    let config = chat_logger::ChatLoggerConfig {
+        enabled: chat_logger_enabled,
+        log_dir: chat_log_dir,
+        json_format: true,
+        text_format: true,
+        max_file_size_mb: std::env::var("GROK_CHAT_LOG_MAX_SIZE_MB")
+            .ok()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(10),
+        rotation_count: std::env::var("GROK_CHAT_LOG_ROTATION_COUNT")
+            .ok()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(5),
+        include_system: std::env::var("GROK_CHAT_LOG_INCLUDE_SYSTEM")
+            .unwrap_or_else(|_| "true".to_string())
+            .parse::<bool>()
+            .unwrap_or(true),
+    };
+
+    if let Err(e) = chat_logger::init(config) {
+        eprintln!("Warning: Failed to initialize chat logger: {}", e);
+    }
+
+    // Run the application
+    cli::app::run().await
+}

package/src/mcp/client.rs

@@ -0,0 +1,195 @@
+use anyhow::{anyhow, Result};
+use serde_json::{json, Value};
+use std::collections::HashMap;
+use std::process::Stdio;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{Child, ChildStdin, ChildStdout, Command};
+use tokio::sync::Mutex;
+use tracing::{debug, error, info};
+
+use crate::mcp::config::McpServerConfig;
+use crate::mcp::protocol::{ClientCapabilities, ClientInfo, Tool};
+
+pub struct McpClient {
+    servers: HashMap<String, ServerConnection>,
+}
+
+struct ServerConnection {
+    process: Child,
+    stdin: Mutex<ChildStdin>,
+    reader: Mutex<BufReader<ChildStdout>>,
+}
+
+impl Default for McpClient {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl McpClient {
+    pub fn new() -> Self {
+        Self {
+            servers: HashMap::new(),
+        }
+    }
+
+    pub async fn connect(&mut self, name: &str, config: &McpServerConfig) -> Result<()> {
+        match config {
+            McpServerConfig::Stdio { command, args, env } => {
+                info!(
+                    "Connecting to MCP server '{}' via stdio: {} {:?}",
+                    name, command, args
+                );
+
+                let mut cmd = Command::new(command);
+                cmd.args(args);
+                cmd.envs(env);
+                cmd.stdin(Stdio::piped());
+                cmd.stdout(Stdio::piped());
+                cmd.stderr(Stdio::inherit()); // Log stderr to parent's stderr
+
+                let mut child = cmd
+                    .spawn()
+                    .map_err(|e| anyhow!("Failed to spawn MCP server: {}", e))?;
+
+                let stdin = child
+                    .stdin
+                    .take()
+                    .ok_or_else(|| anyhow!("Failed to open stdin"))?;
+                let stdout = child
+                    .stdout
+                    .take()
+                    .ok_or_else(|| anyhow!("Failed to open stdout"))?;
+
+                let connection = ServerConnection {
+                    process: child,
+                    stdin: Mutex::new(stdin),
+                    reader: Mutex::new(BufReader::new(stdout)),
+                };
+
+                // Initialize handshake
+                self.initialize_handshake(&connection).await?;
+
+                self.servers.insert(name.to_string(), connection);
+                info!("Connected to MCP server '{}'", name);
+                Ok(())
+            }
+            McpServerConfig::Sse { .. } => Err(anyhow!("SSE transport not yet implemented")),
+        }
+    }
+
+    async fn initialize_handshake(&self, connection: &ServerConnection) -> Result<()> {
+        let init_msg = json!({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "0.1.0",
+                "capabilities": {},
+                "clientInfo": {
+                    "name": "grok-cli",
+                    "version": env!("CARGO_PKG_VERSION")
+                }
+            }
+        });
+
+        self.send_message(connection, &init_msg).await?;
+        let response = self.read_response(connection).await?;
+
+        // TODO: Validate response?
+        debug!("Initialize response: {:?}", response);
+
+        // Send initialized notification
+        let initialized_msg = json!({
+            "jsonrpc": "2.0",
+            "method": "notifications/initialized"
+        });
+        self.send_message(connection, &initialized_msg).await?;
+
+        Ok(())
+    }
+
+    async fn send_message(&self, connection: &ServerConnection, message: &Value) -> Result<()> {
+        let mut stdin = connection.stdin.lock().await;
+        let json_str = serde_json::to_string(message)?;
+        stdin.write_all(json_str.as_bytes()).await?;
+        stdin.write_all(b"\n").await?;
+        stdin.flush().await?;
+        Ok(())
+    }
+
+    async fn read_response(&self, connection: &ServerConnection) -> Result<Value> {
+        let mut reader = connection.reader.lock().await;
+        let mut line = String::new();
+        reader.read_line(&mut line).await?;
+
+        if line.is_empty() {
+            return Err(anyhow!("MCP server closed connection"));
+        }
+
+        let value: Value = serde_json::from_str(&line)?;
+        Ok(value)
+    }
+
+    pub async fn list_tools(&self, server_name: &str) -> Result<Vec<Tool>> {
+        let connection = self
+            .servers
+            .get(server_name)
+            .ok_or_else(|| anyhow!("Server not connected: {}", server_name))?;
+
+        let msg = json!({
+            "jsonrpc": "2.0",
+            "id": 2, // simple id gen needed
+            "method": "tools/list",
+            "params": {}
+        });
+
+        self.send_message(connection, &msg).await?;
+        let response = self.read_response(connection).await?;
+
+        // Parse response
+        if let Some(result) = response.get("result")
+            && let Some(tools_val) = result.get("tools") {
+                let tools: Vec<Tool> = serde_json::from_value(tools_val.clone())?;
+                return Ok(tools);
+            }
+
+        Ok(Vec::new())
+    }
+
+    pub async fn call_tool(
+        &self,
+        server_name: &str,
+        tool_name: &str,
+        args: Value,
+    ) -> Result<Value> {
+        let connection = self
+            .servers
+            .get(server_name)
+            .ok_or_else(|| anyhow!("Server not connected: {}", server_name))?;
+
+        let msg = json!({
+            "jsonrpc": "2.0",
+            "id": 3,
+            "method": "tools/call",
+            "params": {
+                "name": tool_name,
+                "arguments": args
+            }
+        });
+
+        self.send_message(connection, &msg).await?;
+        let response = self.read_response(connection).await?;
+
+        // Check for error
+        if let Some(error) = response.get("error") {
+            return Err(anyhow!("Tool call failed: {:?}", error));
+        }
+
+        if let Some(result) = response.get("result") {
+            return Ok(result.clone());
+        }
+
+        Err(anyhow!("Invalid response from tool call"))
+    }
+}

package/src/mcp/config.rs

@@ -0,0 +1,20 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct McpConfig {
+    pub servers: HashMap<String, McpServerConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum McpServerConfig {
+    #[serde(rename = "stdio")]
+    Stdio {
+        command: String,
+        args: Vec<String>,
+        env: HashMap<String, String>,
+    },
+    #[serde(rename = "sse")]
+    Sse { url: String },
+}

package/src/mcp/mod.rs

@@ -0,0 +1,6 @@
+pub mod client;
+pub mod config;
+pub mod protocol;
+
+pub use client::McpClient;
+pub use config::McpConfig;

package/src/mcp/protocol.rs

@@ -0,0 +1,67 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "method", content = "params")]
+pub enum JsonRpcMessage {
+    #[serde(rename = "initialize")]
+    Initialize {
+        protocol_version: String,
+        capabilities: ClientCapabilities,
+        client_info: ClientInfo,
+    },
+    #[serde(rename = "tools/list")]
+    ListTools {},
+    #[serde(rename = "tools/call")]
+    CallTool { name: String, arguments: Value },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ClientCapabilities {
+    pub tools: Option<ToolsCapability>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ToolsCapability {
+    pub list_changed: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ClientInfo {
+    pub name: String,
+    pub version: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Tool {
+    pub name: String,
+    pub description: Option<String>,
+    pub input_schema: Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ListToolsResult {
+    pub tools: Vec<Tool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CallToolResult {
+    pub content: Vec<ToolContent>,
+    pub is_error: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ToolContent {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image")]
+    Image { data: String, mime_type: String },
+    #[serde(rename = "resource")]
+    Resource {
+        uri: String,
+        mime_type: Option<String>,
+        text: Option<String>,
+        blob: Option<String>,
+    },
+}

package/src/utils/auth.rs

@@ -0,0 +1,41 @@
+use anyhow::{anyhow, Result};
+use colored::*;
+use std::process;
+use tracing::error;
+
+use crate::config::Config;
+
+/// Resolves the API key from various sources (CLI arg, config, env vars).
+pub fn resolve_api_key(cli_key: Option<String>, config: &Config) -> Option<String> {
+    cli_key
+        .or(config.api_key.clone())
+        .or_else(|| std::env::var("GROK_API_KEY").ok())
+        .or_else(|| std::env::var("X_API_KEY").ok())
+}
+
+/// Ensures an API key is present, or exits with a helpful error message.
+///
+/// Returns the API key if present.
+pub fn require_api_key(
+    api_key: Option<String>,
+    hide_banner: bool,
+    show_banner_fn: impl FnOnce(),
+) -> String {
+    if let Some(key) = api_key {
+        return key;
+    }
+
+    // Show welcome banner even without API key if requested
+    if !hide_banner {
+        show_banner_fn();
+    }
+
+    error!("No API key provided. Set GROK_API_KEY environment variable or use --api-key option");
+    eprintln!("{}", "Error: No API key provided".red());
+    eprintln!(
+        "Set the {} environment variable or use the {} option",
+        "GROK_API_KEY".yellow(),
+        "--api-key".yellow()
+    );
+    process::exit(1);
+}