zarz 0.3.1-alpha

package/src/cli.rs

@@ -0,0 +1,201 @@
+use std::path::PathBuf;
+
+use clap::{Args, Parser, Subcommand, ValueEnum};
+
+#[derive(Debug, Clone, PartialEq, ValueEnum)]
+pub enum Provider {
+    Anthropic,
+    OpenAi,
+    Glm,
+}
+
+impl Provider {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Provider::Anthropic => "anthropic",
+            Provider::OpenAi => "openai",
+            Provider::Glm => "glm",
+        }
+    }
+
+    pub fn from_str(name: &str) -> Option<Self> {
+        match name.to_ascii_lowercase().as_str() {
+            "anthropic" => Some(Provider::Anthropic),
+            "openai" => Some(Provider::OpenAi),
+            "glm" => Some(Provider::Glm),
+            _ => None,
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn from_env_or_default() -> Self {
+        match std::env::var("ZARZ_PROVIDER")
+            .ok()
+            .as_deref()
+            .map(|v| v.to_ascii_lowercase())
+        {
+            Some(ref v) if v == "openai" => Provider::OpenAi,
+            Some(ref v) if v == "anthropic" => Provider::Anthropic,
+            Some(ref v) if v == "glm" => Provider::Glm,
+            _ => Provider::Anthropic,
+        }
+    }
+}
+
+#[derive(Debug, Parser)]
+#[command(
+    name = "zarz",
+    version,
+    about = "ZarzCLI · AI-assisted code refactoring and rewrites",
+    author = "Fapzarz",
+    long_about = "ZarzCLI - Interactive AI coding assistant\n\nUsage:\n  zarz                      Start interactive chat\n  zarz --message \"prompt\"   Send a single prompt and exit\n  zarz ask \"question\"       Ask mode (legacy)\n  zarz chat                 Chat mode (legacy)"
+)]
+pub struct Cli {
+    /// Send a message and exit (like Claude Code)
+    #[arg(long, visible_alias = "msg")]
+    pub message: Option<String>,
+
+    /// Additional files to include as context
+    #[arg(short = 'f', long)]
+    pub files: Vec<PathBuf>,
+
+    #[command(flatten)]
+    pub model_args: CommonModelArgs,
+
+    /// Working directory for the session
+    #[arg(long)]
+    pub directory: Option<PathBuf>,
+
+    #[command(subcommand)]
+    pub command: Option<Commands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum Commands {
+    /// Ask the model a question with optional code context.
+    Ask(AskArgs),
+    /// Rewrite one or more files using the model's response.
+    Rewrite(RewriteArgs),
+    /// Start an interactive chat session with AI code assistance.
+    Chat(ChatArgs),
+    /// Configure API keys and settings.
+    Config(ConfigArgs),
+    /// Manage MCP (Model Context Protocol) servers.
+    Mcp(McpArgs),
+}
+
+#[derive(Debug, Args)]
+pub struct CommonModelArgs {
+    /// Target model identifier (e.g. claude-3-5-sonnet-20241022).
+    #[arg(short, long)]
+    pub model: Option<String>,
+    /// Override the default provider.
+    #[arg(long, value_enum)]
+    pub provider: Option<Provider>,
+    /// Override the default API endpoint.
+    #[arg(long)]
+    pub endpoint: Option<String>,
+    /// Optional system prompt override.
+    #[arg(long)]
+    pub system_prompt: Option<String>,
+    /// Timeout in seconds for the request.
+    #[arg(long)]
+    pub timeout: Option<u64>,
+}
+
+#[derive(Debug, Args)]
+pub struct AskArgs {
+    #[command(flatten)]
+    pub model_args: CommonModelArgs,
+    /// Inline prompt text. If omitted, reads from STDIN.
+    #[arg(short, long)]
+    pub prompt: Option<String>,
+    /// Optional file containing additional instructions.
+    #[arg(long)]
+    pub prompt_file: Option<PathBuf>,
+    /// Additional context files to include in the request.
+    #[arg(value_name = "FILE", num_args = 0..)]
+    pub context_files: Vec<PathBuf>,
+}
+
+#[derive(Debug, Args)]
+pub struct RewriteArgs {
+    #[command(flatten)]
+    pub model_args: CommonModelArgs,
+    /// High-level instructions for the rewrite.
+    #[arg(short, long)]
+    pub instructions: Option<String>,
+    /// File containing rewrite instructions.
+    #[arg(long)]
+    pub instructions_file: Option<PathBuf>,
+    /// Apply the changes without confirmation.
+    #[arg(long)]
+    pub yes: bool,
+    /// Preview diff without writing files.
+    #[arg(long)]
+    pub dry_run: bool,
+    /// Target files that will be rewritten.
+    #[arg(value_name = "FILE", num_args = 1..)]
+    pub files: Vec<PathBuf>,
+}
+
+#[derive(Debug, Args)]
+pub struct ChatArgs {
+    #[command(flatten)]
+    pub model_args: CommonModelArgs,
+    /// Working directory for the session (defaults to current directory).
+    #[arg(long)]
+    pub directory: Option<PathBuf>,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct ConfigArgs {
+    /// Reset configuration and run interactive setup.
+    #[arg(long)]
+    pub reset: bool,
+    /// Show current configuration.
+    #[arg(long)]
+    pub show: bool,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct McpArgs {
+    #[command(subcommand)]
+    pub command: McpCommands,
+}
+
+#[derive(Debug, Clone, Subcommand)]
+pub enum McpCommands {
+    /// Add a new MCP server
+    Add {
+        /// Server name
+        name: String,
+        /// Server command (for stdio servers)
+        #[arg(long)]
+        command: Option<String>,
+        /// Server arguments
+        #[arg(long, num_args = 0..)]
+        args: Vec<String>,
+        /// Environment variables (KEY=VALUE)
+        #[arg(long = "env")]
+        env_vars: Vec<String>,
+        /// Server URL (for http/sse servers)
+        #[arg(long)]
+        url: Option<String>,
+        /// Transport type: stdio, http, sse
+        #[arg(long, default_value = "stdio")]
+        transport: String,
+    },
+    /// List all configured MCP servers
+    List,
+    /// Get details of a specific MCP server
+    Get {
+        /// Server name
+        name: String,
+    },
+    /// Remove an MCP server
+    Remove {
+        /// Server name
+        name: String,
+    },
+}

package/src/config.rs

@@ -0,0 +1,249 @@
+use anyhow::{Context, Result};
+use crossterm::style::{Color, Stylize};
+use dialoguer::{theme::ColorfulTheme, Select};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::io::{self, Write};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Config {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub anthropic_api_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub openai_api_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub glm_api_key: Option<String>,
+}
+
+impl Config {
+    /// Get the path to the config file (~/.zarz/config.toml)
+    pub fn config_path() -> Result<PathBuf> {
+        let home = dirs::home_dir()
+            .context("Could not determine home directory")?;
+        Ok(home.join(".zarz").join("config.toml"))
+    }
+
+    /// Load config from file, or return default if file doesn't exist
+    pub fn load() -> Result<Self> {
+        let path = Self::config_path()?;
+
+        if !path.exists() {
+            return Ok(Self::default());
+        }
+
+        let content = fs::read_to_string(&path)
+            .context("Failed to read config file")?;
+
+        let config: Config = toml::from_str(&content)
+            .context("Failed to parse config file")?;
+
+        Ok(config)
+    }
+
+    /// Save config to file
+    pub fn save(&self) -> Result<()> {
+        let path = Self::config_path()?;
+
+        // Create parent directory if it doesn't exist
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)
+                .context("Failed to create config directory")?;
+        }
+
+        let content = toml::to_string_pretty(self)
+            .context("Failed to serialize config")?;
+
+        fs::write(&path, content)
+            .context("Failed to write config file")?;
+
+        Ok(())
+    }
+
+    /// Check if at least one API key is configured
+    pub fn has_api_key(&self) -> bool {
+        self.anthropic_api_key.is_some() || self.openai_api_key.is_some() || self.glm_api_key.is_some()
+    }
+
+    /// Interactive setup to get API keys from user
+    pub fn interactive_setup() -> Result<Self> {
+        let theme = ColorfulTheme::default();
+
+        println!(
+            "\n{}\n",
+            "ZarzCLI Setup".bold().with(Color::Cyan)
+        );
+        println!(
+            "{}",
+            "Choose a provider to configure. Use the arrow keys and press Enter.".with(Color::DarkGrey)
+        );
+        println!(
+            "{}",
+            "API keys are displayed while typing so you can verify them, then hidden before storing.".with(Color::DarkGrey)
+        );
+        println!(
+            "{}\n",
+            "You can configure additional providers later with `zarz config --reset`.".with(Color::DarkGrey)
+        );
+
+        let options = vec![
+            "Anthropic Claude (recommended for coding)".bold().with(Color::Yellow).to_string(),
+            "OpenAI GPT".bold().with(Color::Yellow).to_string(),
+            "GLM (Z.AI - International GLM-4.6)".bold().with(Color::Yellow).to_string(),
+        ];
+
+        let selection = Select::with_theme(&theme)
+            .with_prompt("Select a provider to set up")
+            .items(&options)
+            .default(0)
+            .interact()?;
+
+        let mut config = Self::default();
+        let mut enabled = Vec::new();
+
+        match selection {
+            0 => {
+                let key = Self::prompt_for_key("Anthropic API key")?;
+                config.anthropic_api_key = Some(key);
+                enabled.push("Anthropic Claude");
+                println!("{}\n", "✓ Anthropic ready".with(Color::Green));
+            }
+            1 => {
+                let key = Self::prompt_for_key("OpenAI API key")?;
+                config.openai_api_key = Some(key);
+                enabled.push("OpenAI GPT");
+                println!("{}\n", "✓ OpenAI ready".with(Color::Green));
+            }
+            _ => {
+                let key = Self::prompt_for_key("GLM API key")?;
+                config.glm_api_key = Some(key);
+                enabled.push("GLM 4.6");
+                println!("{}\n", "✓ GLM ready".with(Color::Green));
+            }
+        }
+
+        if !config.has_api_key() {
+            anyhow::bail!("At least one API key is required to use ZarzCLI");
+        }
+
+        config.save()?;
+        println!(
+            "{} {}\n",
+            "✅".with(Color::Green),
+            format!(
+                "Configuration saved to {}",
+                Self::config_path()?.display()
+            )
+            .bold()
+        );
+        println!(
+            "{}",
+            format!("Enabled providers: {}", enabled.join(", ")).with(Color::Green)
+        );
+        println!(
+            "{}\n",
+            "Run `zarz` any time to start chatting.".with(Color::DarkGrey)
+        );
+
+        Ok(config)
+    }
+
+    fn prompt_for_key(label: &str) -> Result<String> {
+        loop {
+            print!("Enter your {}: ", label);
+            io::stdout().flush().ok();
+
+            let mut key = String::new();
+            io::stdin()
+                .read_line(&mut key)
+                .context("Failed to read API key from stdin")?;
+
+            let trimmed = key.trim();
+            if trimmed.is_empty() {
+                println!("{}", "Key cannot be empty. Please try again.".with(Color::Red));
+                continue;
+            }
+
+            println!("{}", "Key captured ✔".with(Color::Green));
+            println!(
+                "{}",
+                "(The key is now stored securely and will no longer be displayed.)".with(Color::DarkGrey)
+            );
+
+            return Ok(trimmed.to_string());
+        }
+    }
+
+    /// Get Anthropic API key from config or environment
+    pub fn get_anthropic_key(&self) -> Option<String> {
+        std::env::var("ANTHROPIC_API_KEY")
+            .ok()
+            .or_else(|| self.anthropic_api_key.clone())
+    }
+
+    /// Get OpenAI API key from config or environment
+    pub fn get_openai_key(&self) -> Option<String> {
+        std::env::var("OPENAI_API_KEY")
+            .ok()
+            .or_else(|| self.openai_api_key.clone())
+    }
+
+    /// Get GLM API key from config or environment
+    pub fn get_glm_key(&self) -> Option<String> {
+        std::env::var("GLM_API_KEY")
+            .ok()
+            .or_else(|| self.glm_api_key.clone())
+    }
+
+    /// Get default provider based on available API keys
+    /// Priority: Anthropic > OpenAI > GLM
+    pub fn get_default_provider(&self) -> Option<crate::cli::Provider> {
+        if self.get_anthropic_key().is_some() {
+            Some(crate::cli::Provider::Anthropic)
+        } else if self.get_openai_key().is_some() {
+            Some(crate::cli::Provider::OpenAi)
+        } else if self.get_glm_key().is_some() {
+            Some(crate::cli::Provider::Glm)
+        } else {
+            None
+        }
+    }
+
+    /// Apply config to environment variables
+    pub fn apply_to_env(&self) {
+        if let Some(key) = &self.anthropic_api_key {
+            if std::env::var("ANTHROPIC_API_KEY").is_err() {
+                unsafe { std::env::set_var("ANTHROPIC_API_KEY", key); }
+            }
+        }
+        if let Some(key) = &self.openai_api_key {
+            if std::env::var("OPENAI_API_KEY").is_err() {
+                unsafe { std::env::set_var("OPENAI_API_KEY", key); }
+            }
+        }
+        if let Some(key) = &self.glm_api_key {
+            if std::env::var("GLM_API_KEY").is_err() {
+                unsafe { std::env::set_var("GLM_API_KEY", key); }
+            }
+        }
+    }
+
+    /// Remove all stored API keys from disk
+    pub fn clear_api_keys(&mut self) -> Result<bool> {
+        let mut removed = false;
+
+        if self.anthropic_api_key.take().is_some() {
+            removed = true;
+        }
+        if self.openai_api_key.take().is_some() {
+            removed = true;
+        }
+        if self.glm_api_key.take().is_some() {
+            removed = true;
+        }
+
+        self.save()?;
+
+        Ok(removed)
+    }
+}

package/src/conversation_store.rs

@@ -0,0 +1,183 @@
+use std::fs;
+use std::path::{PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use anyhow::{Context, Result};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::cli::Provider;
+use crate::session::{Message, MessageRole, Session};
+use crate::config::Config;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConversationSnapshot {
+    pub id: String,
+    pub title: String,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+    pub provider: String,
+    pub model: String,
+    pub working_directory: PathBuf,
+    pub message_count: usize,
+    pub messages: Vec<Message>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ConversationSummary {
+    pub id: String,
+    pub title: String,
+    pub updated_at: DateTime<Utc>,
+    pub provider: String,
+    pub model: String,
+    pub message_count: usize,
+}
+
+pub struct ConversationStore;
+
+impl ConversationStore {
+    fn storage_dir() -> Result<PathBuf> {
+        let config_path = Config::config_path()?;
+        let dir = config_path
+            .parent()
+            .map(|p| p.join("sessions"))
+            .unwrap_or_else(|| PathBuf::from(".zarz/sessions"));
+        fs::create_dir_all(&dir)
+            .with_context(|| format!("Failed to create session storage at {}", dir.display()))?;
+        Ok(dir)
+    }
+
+    fn generate_id() -> String {
+        let now = Utc::now();
+        let nanos = now.timestamp_subsec_nanos();
+        let since_epoch = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_nanos())
+            .unwrap_or(0);
+        format!("{}-{:09}-{:x}", now.format("%Y%m%d-%H%M%S"), nanos, since_epoch)
+    }
+
+    fn derive_title(messages: &[Message]) -> String {
+        const DEFAULT_TITLE: &str = "Untitled session";
+        let candidate = messages
+            .iter()
+            .find_map(|msg| match msg.role {
+                MessageRole::User => {
+                    msg.content
+                        .lines()
+                        .find(|line| !line.trim().is_empty())
+                        .map(|line| line.trim())
+                        .map(str::to_string)
+                }
+                _ => None,
+            })
+            .unwrap_or_else(|| DEFAULT_TITLE.to_string());
+
+        let trimmed = candidate.trim();
+        let title = if trimmed.is_empty() {
+            DEFAULT_TITLE.to_string()
+        } else {
+            trimmed.to_string()
+        };
+
+        if title.len() > 80 {
+            format!("{}…", &title[..80])
+        } else {
+            title
+        }
+    }
+
+    pub fn save_session(session: &mut Session, provider: Provider, model: &str) -> Result<()> {
+        if session.conversation_history.is_empty() {
+            return Ok(());
+        }
+
+        let now = Utc::now();
+        let id = session
+            .storage_id
+            .clone()
+            .unwrap_or_else(Self::generate_id);
+        let created_at = session
+            .created_at
+            .unwrap_or_else(|| {
+                let ts = now;
+                session.created_at = Some(ts);
+                ts
+            });
+
+        let title = session
+            .title
+            .clone()
+            .filter(|t| !t.trim().is_empty())
+            .unwrap_or_else(|| Self::derive_title(&session.conversation_history));
+
+        session.storage_id = Some(id.clone());
+        session.title = Some(title.clone());
+        session.updated_at = Some(now);
+
+        let snapshot = ConversationSnapshot {
+            id: id.clone(),
+            title,
+            created_at,
+            updated_at: now,
+            provider: provider.as_str().to_string(),
+            model: model.to_string(),
+            working_directory: session.working_directory.clone(),
+            message_count: session.conversation_history.len(),
+            messages: session.conversation_history.clone(),
+        };
+
+        let dir = Self::storage_dir()?;
+        let path = dir.join(format!("{id}.json"));
+        let data = serde_json::to_string_pretty(&snapshot)
+            .context("Failed to serialize conversation snapshot")?;
+        fs::write(&path, data)
+            .with_context(|| format!("Failed to write conversation snapshot to {}", path.display()))?;
+
+        Ok(())
+    }
+
+    pub fn list_summaries() -> Result<Vec<ConversationSummary>> {
+        let dir = Self::storage_dir()?;
+        if !dir.exists() {
+            return Ok(Vec::new());
+        }
+
+        let mut summaries = Vec::new();
+        for entry in fs::read_dir(&dir).with_context(|| format!("Failed to read {}", dir.display()))? {
+            let entry = entry?;
+            if !entry.file_type()?.is_file() {
+                continue;
+            }
+            let content = fs::read_to_string(entry.path());
+            let Ok(content) = content else {
+                continue;
+            };
+            let snapshot: Result<ConversationSnapshot, _> = serde_json::from_str(&content);
+            let Ok(snapshot) = snapshot else {
+                continue;
+            };
+            summaries.push(ConversationSummary {
+                id: snapshot.id,
+                title: snapshot.title,
+                updated_at: snapshot.updated_at,
+                provider: snapshot.provider,
+                model: snapshot.model,
+                message_count: snapshot.message_count,
+            });
+        }
+
+        summaries.sort_by(|a, b| b.updated_at.cmp(&a.updated_at));
+        Ok(summaries)
+    }
+
+    pub fn load_snapshot(id: &str) -> Result<ConversationSnapshot> {
+        let dir = Self::storage_dir()?;
+        let path = dir.join(format!("{id}.json"));
+        let data = fs::read_to_string(&path)
+            .with_context(|| format!("Failed to read session file {}", path.display()))?;
+        let snapshot: ConversationSnapshot =
+            serde_json::from_str(&data).context("Failed to parse stored session data")?;
+        Ok(snapshot)
+    }
+}