grok-cli-acp 0.1.2

package/src/bin/banner_demo.rs

@@ -0,0 +1,216 @@
+//! Simple banner demo to showcase Grok CLI visual features
+//!
+//! This binary demonstrates the ASCII art, banners, and visual elements
+//! without requiring API keys or interactive input.
+
+use crate::banner::print_banner;
+use crate::banner::BannerType;
+use colored::*;
+use std::env;
+
+// Import the display modules from the main grok-cli crate
+use grok_cli::display::*;
+
+fn main() {
+    println!(
+        "{}",
+        "🎪 Grok CLI Visual Features Demo".bright_cyan().bold()
+    );
+    println!("{}", "─".repeat(60).dimmed());
+    println!();
+
+    // Get terminal size
+    let (width, height) = get_terminal_size();
+    println!(
+        "{}",
+        format!("Terminal: {}×{} characters", width, height).dimmed()
+    );
+    println!();
+
+    // Demo 1: ASCII Art Logo
+    println!("{}", "1. ASCII Art Logo (Adaptive)".bright_blue().bold());
+    print_grok_logo(width);
+    println!();
+
+    // Demo 2: Welcome Banner
+    println!("{}", "2. Welcome Banner".bright_green().bold());
+    let banner_config = BannerConfig {
+        show_banner: true,
+        show_tips: true,
+        show_updates: true,
+        width: Some(width),
+    };
+    print_welcome_banner(&banner_config);
+
+    // Demo 3: Different Banner Types
+    println!("{}", "3. Banner Variations".bright_magenta().bold());
+
+    // Info banner
+    let info_content = vec![
+        "This is an information banner",
+        "It shows helpful system messages",
+        "Like configuration status or tips",
+    ];
+    print_banner(
+        "System Information",
+        &info_content,
+        BannerType::Info,
+        Some(width),
+    );
+
+    // Directory recommendation (simulated)
+    if env::current_dir()
+        .map(|d| {
+            d.file_name().and_then(|n| n.to_str()).unwrap_or("") == "Users"
+                || d.file_name()
+                    .and_then(|n| n.to_str())
+                    .unwrap_or("")
+                    .contains("home")
+        })
+        .unwrap_or(false)
+    {
+        print_directory_recommendation(
+            &env::current_dir().unwrap().display().to_string(),
+            &banner_config,
+        );
+    }
+
+    // Demo 4: Color Scheme
+    println!("{}", "4. Color Scheme".bright_yellow().bold());
+    println!();
+
+    let color_examples = vec![
+        (
+            "🔵 Primary (Blue)",
+            "Grok branding and main headers",
+            Color::BrightBlue,
+        ),
+        (
+            "🟢 Success (Green)",
+            "Successful operations and confirmations",
+            Color::BrightGreen,
+        ),
+        (
+            "🟡 Warning (Yellow)",
+            "Warnings and important notices",
+            Color::BrightYellow,
+        ),
+        (
+            "🔴 Error (Red)",
+            "Errors and critical issues",
+            Color::BrightRed,
+        ),
+        (
+            "🟣 Accent (Magenta)",
+            "Interactive elements and highlights",
+            Color::BrightMagenta,
+        ),
+        ("🔄 Info (Cyan)", "Information and tips", Color::BrightCyan),
+    ];
+
+    for (label, description, color) in color_examples {
+        println!("  {} - {}", label.color(color), description);
+    }
+    println!();
+
+    // Demo 5: Logo Size Variations
+    println!("{}", "5. Logo Adaptability".bright_cyan().bold());
+    println!();
+
+    let sizes = vec![
+        (80, "Large (80+ columns)"),
+        (50, "Medium (45+ columns)"),
+        (35, "Small (30+ columns)"),
+        (20, "Tiny (<30 columns)"),
+    ];
+
+    for (test_width, description) in sizes {
+        println!("{}: {}", "Testing".dimmed(), description);
+        print_grok_logo(test_width);
+        println!("{}", "─".repeat(40).dimmed());
+        println!();
+    }
+
+    // Demo 6: Status Information
+    println!("{}", "6. Status Display".bright_white().bold());
+    println!();
+
+    println!(
+        "  {} API Key: {}",
+        "🔑".bright_yellow(),
+        "✓ Configured".bright_green()
+    );
+    println!("  {} Model: {}", "🤖".bright_blue(), "grok-3".bright_cyan());
+    println!(
+        "  {} Network: {}",
+        "🌐".bright_green(),
+        "✓ Connected".bright_green()
+    );
+    println!(
+        "  {} Features: {}",
+        "⚡".bright_magenta(),
+        "All systems ready".bright_white()
+    );
+    println!();
+
+    // Demo 7: Tips Display
+    println!("{}", "7. Helpful Tips".bright_green().bold());
+    let tips_content = vec![
+        "💡 Use 'grok chat \"your question\"' for quick answers",
+        "💻 Try 'grok code explain file.rs' for code analysis",
+        "🔧 Run 'grok health --all' for system diagnostics",
+        "⚙️  Configure with 'grok config show' and 'grok config set'",
+        "🎭 Enable Zed integration with 'grok acp server'",
+    ];
+
+    for tip in tips_content {
+        println!("  {}", tip);
+    }
+    println!();
+
+    // Demo 8: Feature Summary
+    let features = [
+        "✨ Beautiful ASCII art with adaptive sizing",
+        "🎨 Professional color scheme throughout",
+        "📱 Responsive design for any terminal width",
+        "🔔 Contextual banners and notifications",
+        "💬 Rich interactive prompts (when working)",
+        "📊 Comprehensive health monitoring",
+        "⚙️  Advanced configuration management",
+        "🚀 Starlink-optimized networking",
+    ];
+
+    let feature_banner_content: Vec<&str> = features.to_vec();
+    print_banner(
+        "Enhanced Features",
+        &feature_banner_content,
+        BannerType::Welcome,
+        Some(width),
+    );
+
+    // Conclusion
+    println!("{}", "🎉 Demo Complete!".bright_green().bold());
+    println!();
+    println!("{}", "The Grok CLI now features:".bright_white());
+    println!(
+        "• {} that rivals modern AI CLI tools",
+        "Visual polish".bright_cyan()
+    );
+    println!(
+        "• {} for any terminal environment",
+        "Adaptive interface".bright_blue()
+    );
+    println!(
+        "• {} with helpful guidance",
+        "User-friendly experience".bright_green()
+    );
+    println!(
+        "• {} for professional use",
+        "Production-ready code".bright_magenta()
+    );
+    println!();
+    println!(
+        "{}",
+        "Ready for interactive mode once the input loop is fixed! 🚀".bright_yellow()
+    );
+}

package/src/bin/docgen.rs

@@ -0,0 +1,18 @@
+use clap::CommandFactory;
+use clap_markdown::MarkdownOptions;
+use grok_cli::cli::app::Cli;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let out_dir = PathBuf::from("docs");
+    if !out_dir.exists() {
+        fs::create_dir_all(&out_dir).expect("Failed to create docs directory");
+    }
+
+    let markdown = clap_markdown::help_markdown::<Cli>();
+    let out_path = out_dir.join("CLI_REFERENCE.md");
+
+    fs::write(&out_path, markdown).expect("Failed to write CLI_REFERENCE.md");
+    println!("Generated CLI documentation at {:?}", out_path);
+}

package/src/bin/installer.rs

@@ -0,0 +1,217 @@
+use colored::*;
+use std::env;
+use std::fs;
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+#[cfg(windows)]
+use winreg::RegKey;
+#[cfg(windows)]
+use winreg::enums::*;
+
+fn find_project_root() -> Option<PathBuf> {
+    let mut current = env::current_dir().ok()?;
+    loop {
+        if current.join("Cargo.toml").exists() {
+            return Some(current);
+        }
+        if !current.pop() {
+            break;
+        }
+    }
+    None
+}
+
+fn main() {
+    println!("{}", "Grok CLI Installer for Windows 11".green().bold());
+    println!("=======================================");
+
+    if !cfg!(windows) {
+        eprintln!("{}", "This installer is designed for Windows only.".red());
+        std::process::exit(1);
+    }
+
+    #[cfg(windows)]
+    install_windows();
+}
+
+#[cfg(windows)]
+fn install_windows() {
+    let root_dir = find_project_root().expect("Failed to find project root (Cargo.toml not found)");
+
+    // 1. Build the release binary
+    println!("{}", "Building release binary...".cyan());
+    let status = Command::new("cargo")
+        .current_dir(&root_dir)
+        .args(["build", "--release", "--bin", "grok"])
+        .status()
+        .expect("Failed to execute cargo build");
+
+    if !status.success() {
+        eprintln!("{}", "Build failed. Aborting installation.".red());
+        std::process::exit(1);
+    }
+
+    // 2. Define paths
+    let local_app_data = env::var("LOCALAPPDATA").expect("LOCALAPPDATA not set");
+    let install_dir = PathBuf::from(&local_app_data).join("grok-cli").join("bin");
+    let exe_name = "grok.exe";
+    let target_exe = install_dir.join(exe_name);
+
+    let source_exe = root_dir.join("target").join("release").join(exe_name);
+
+    if !source_exe.exists() {
+        eprintln!(
+            "{} {}",
+            "Source binary not found at:".red(),
+            source_exe.display()
+        );
+        std::process::exit(1);
+    }
+
+    // 3. Create directory
+    if !install_dir.exists() {
+        println!("Creating installation directory: {}", install_dir.display());
+        fs::create_dir_all(&install_dir).expect("Failed to create installation directory");
+    }
+
+    // 4. Copy binary
+    println!("Copying binary to {}", target_exe.display());
+    fs::copy(&source_exe, &target_exe).expect("Failed to copy binary");
+
+    // 5. Update PATH
+    println!("{}", "Updating PATH environment variable...".cyan());
+    update_path(&install_dir);
+
+    // 6. Create Start Menu Shortcut
+    println!("{}", "Creating Start Menu shortcut...".cyan());
+    create_shortcut(&target_exe);
+
+    // 7. Setup Configuration
+    println!("{}", "Setting up configuration...".cyan());
+    setup_config();
+
+    println!("\n{}", "Installation Complete!".green().bold());
+    println!("Please restart your terminal to use the 'grok' command.");
+}
+
+#[cfg(windows)]
+fn setup_config() {
+    let config_dir = dirs::config_dir()
+        .expect("Failed to get config directory")
+        .join("grok-cli");
+
+    if !config_dir.exists()
+        && let Err(e) = fs::create_dir_all(&config_dir)
+    {
+        eprintln!("Failed to create config directory: {}", e);
+        return;
+    }
+
+    let config_file = config_dir.join("config.toml");
+    if !config_file.exists() {
+        println!("Configuration file not found at: {}", config_file.display());
+        print!("Do you want to set up your Grok API Key now? [Y/n]: ");
+        io::stdout().flush().unwrap_or_default();
+
+        let mut input = String::new();
+        if io::stdin().read_line(&mut input).is_ok() {
+            let input = input.trim().to_lowercase();
+            if input != "n" && input != "no" {
+                print!("Enter your X API Key: ");
+                io::stdout().flush().unwrap_or_default();
+                let mut key = String::new();
+                if io::stdin().read_line(&mut key).is_ok() {
+                    let key = key.trim();
+                    if !key.is_empty() {
+                        let config_content = format!(
+                            r#"# Grok CLI Configuration
+
+# X API Key
+api_key = "{}"
+
+# Default Model
+default_model = "grok-3"
+
+# Network Configuration
+[network]
+starlink_optimizations = true
+health_monitoring = true
+"#,
+                            key
+                        );
+                        if let Err(e) = fs::write(&config_file, config_content) {
+                            eprintln!("Failed to write config file: {}", e);
+                        } else {
+                            println!("Configuration saved to {}", config_file.display());
+                        }
+                    } else {
+                        println!("Skipping API key setup (empty key provided).");
+                    }
+                }
+            }
+        }
+    } else {
+        println!(
+            "Configuration file already exists at: {}",
+            config_file.display()
+        );
+    }
+}
+
+#[cfg(windows)]
+fn update_path(install_dir: &Path) {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    let env_key = hkcu
+        .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
+        .expect("Failed to open Environment registry key");
+
+    let current_path: String = env_key.get_value("Path").unwrap_or_default();
+    let install_path_str = install_dir.to_string_lossy();
+
+    // Simple check to avoid duplicates (case-insensitive check would be better but this is a start)
+    if !current_path.contains(&*install_path_str) {
+        let new_path = if current_path.is_empty() {
+            install_path_str.to_string()
+        } else {
+            format!("{};{}", current_path, install_path_str)
+        };
+
+        env_key
+            .set_value("Path", &new_path)
+            .expect("Failed to update Path");
+        println!("Added {} to PATH.", install_path_str);
+    } else {
+        println!("Path already configured.");
+    }
+}
+
+#[cfg(windows)]
+fn create_shortcut(target_exe: &Path) {
+    let roaming = env::var("APPDATA").expect("APPDATA not set");
+    let start_menu = PathBuf::from(roaming)
+        .join("Microsoft")
+        .join("Windows")
+        .join("Start Menu")
+        .join("Programs")
+        .join("Grok CLI.lnk");
+
+    // PowerShell script to create shortcut
+    let script = format!(
+        "$WS = New-Object -ComObject WScript.Shell; $SC = $WS.CreateShortcut('{}'); $SC.TargetPath = '{}'; $SC.Save()",
+        start_menu.display(),
+        target_exe.display()
+    );
+
+    let status = Command::new("powershell")
+        .args(["-NoProfile", "-Command", &script])
+        .status()
+        .expect("Failed to create shortcut");
+
+    if status.success() {
+        println!("Shortcut created at: {}", start_menu.display());
+    } else {
+        eprintln!("{}", "Failed to create Start Menu shortcut.".yellow());
+    }
+}