zarz 0.3.1-alpha → 0.3.5-alpha

package/src/config.rs

@@ -1,249 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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)
-    }
-}

package/src/executor.rs

@@ -1,164 +0,0 @@
-use anyhow::{Context, Result};
-use std::process::Stdio;
-use tokio::io::{AsyncBufReadExt, BufReader};
-use tokio::process::Command;
-
-pub struct CommandExecutor;
-
-#[derive(Debug)]
-pub struct CommandResult {
-    pub stdout: String,
-    pub stderr: String,
-    pub exit_code: i32,
-    pub success: bool,
-}
-
-impl CommandExecutor {
-    pub async fn execute(command: &str) -> Result<CommandResult> {
-        let (shell, flag) = if cfg!(target_os = "windows") {
-            ("cmd", "/C")
-        } else {
-            ("sh", "-c")
-        };
-
-        let mut child = Command::new(shell)
-            .arg(flag)
-            .arg(command)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .with_context(|| format!("Failed to execute command: {}", command))?;
-
-        let stdout = child
-            .stdout
-            .take()
-            .context("Failed to capture stdout")?;
-
-        let stderr = child
-            .stderr
-            .take()
-            .context("Failed to capture stderr")?;
-
-        let mut stdout_lines = BufReader::new(stdout).lines();
-        let mut stderr_lines = BufReader::new(stderr).lines();
-
-        let stdout_handle = tokio::spawn(async move {
-            let mut output = String::new();
-            while let Ok(Some(line)) = stdout_lines.next_line().await {
-                output.push_str(&line);
-                output.push('\n');
-            }
-            output
-        });
-
-        let stderr_handle = tokio::spawn(async move {
-            let mut output = String::new();
-            while let Ok(Some(line)) = stderr_lines.next_line().await {
-                output.push_str(&line);
-                output.push('\n');
-            }
-            output
-        });
-
-        let stdout_output = stdout_handle
-            .await
-            .context("Failed to join stdout task")?;
-
-        let stderr_output = stderr_handle
-            .await
-            .context("Failed to join stderr task")?;
-
-        let status = child
-            .wait()
-            .await
-            .context("Failed to wait for command")?;
-
-        let exit_code = status.code().unwrap_or(-1);
-        let success = status.success();
-
-        Ok(CommandResult {
-            stdout: stdout_output,
-            stderr: stderr_output,
-            exit_code,
-            success,
-        })
-    }
-
-    #[allow(dead_code)]
-    pub async fn execute_streaming<F>(command: &str, mut on_output: F) -> Result<CommandResult>
-    where
-        F: FnMut(&str) + Send,
-    {
-        let (shell, flag) = if cfg!(target_os = "windows") {
-            ("cmd", "/C")
-        } else {
-            ("sh", "-c")
-        };
-
-        let mut child = Command::new(shell)
-            .arg(flag)
-            .arg(command)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .with_context(|| format!("Failed to execute command: {}", command))?;
-
-        let stdout = child
-            .stdout
-            .take()
-            .context("Failed to capture stdout")?;
-
-        let stderr = child
-            .stderr
-            .take()
-            .context("Failed to capture stderr")?;
-
-        let mut stdout_lines = BufReader::new(stdout).lines();
-        let mut stderr_lines = BufReader::new(stderr).lines();
-
-        let mut stdout_output = String::new();
-        let mut stderr_output = String::new();
-
-        loop {
-            tokio::select! {
-                result = stdout_lines.next_line() => {
-                    match result {
-                        Ok(Some(line)) => {
-                            on_output(&line);
-                            stdout_output.push_str(&line);
-                            stdout_output.push('\n');
-                        }
-                        Ok(None) => break,
-                        Err(_) => break,
-                    }
-                }
-                result = stderr_lines.next_line() => {
-                    match result {
-                        Ok(Some(line)) => {
-                            on_output(&line);
-                            stderr_output.push_str(&line);
-                            stderr_output.push('\n');
-                        }
-                        Ok(None) => {},
-                        Err(_) => {},
-                    }
-                }
-            }
-        }
-
-        let status = child
-            .wait()
-            .await
-            .context("Failed to wait for command")?;
-
-        let exit_code = status.code().unwrap_or(-1);
-        let success = status.success();
-
-        Ok(CommandResult {
-            stdout: stdout_output,
-            stderr: stderr_output,
-            exit_code,
-            success,
-        })
-    }
-}

package/src/fs_ops.rs

@@ -1,117 +0,0 @@
-use anyhow::{Context, Result};
-use std::path::{Path, PathBuf};
-use tokio::fs;
-use walkdir::WalkDir;
-
-pub struct FileSystemOps;
-
-impl FileSystemOps {
-    pub async fn create_file(path: &Path, content: &str) -> Result<()> {
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent)
-                .await
-                .with_context(|| format!("Failed to create parent directories for {}", path.display()))?;
-        }
-
-        fs::write(path, content)
-            .await
-            .with_context(|| format!("Failed to write file {}", path.display()))?;
-
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub async fn delete_file(path: &Path) -> Result<()> {
-        fs::remove_file(path)
-            .await
-            .with_context(|| format!("Failed to delete file {}", path.display()))?;
-
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub async fn rename_file(from: &Path, to: &Path) -> Result<()> {
-        if let Some(parent) = to.parent() {
-            fs::create_dir_all(parent)
-                .await
-                .with_context(|| format!("Failed to create parent directories for {}", to.display()))?;
-        }
-
-        fs::rename(from, to)
-            .await
-            .with_context(|| format!("Failed to rename {} to {}", from.display(), to.display()))?;
-
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub async fn create_directory(path: &Path) -> Result<()> {
-        fs::create_dir_all(path)
-            .await
-            .with_context(|| format!("Failed to create directory {}", path.display()))?;
-
-        Ok(())
-    }
-
-    pub async fn read_file(path: &Path) -> Result<String> {
-        fs::read_to_string(path)
-            .await
-            .with_context(|| format!("Failed to read file {}", path.display()))
-    }
-
-    pub async fn file_exists(path: &Path) -> bool {
-        fs::metadata(path).await.is_ok()
-    }
-
-    #[allow(dead_code)]
-    pub fn list_files(root: &Path, pattern: Option<&str>) -> Result<Vec<PathBuf>> {
-        let mut files = Vec::new();
-
-        for entry in WalkDir::new(root)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            if entry.file_type().is_file() {
-                let path = entry.path();
-
-                if let Some(pattern) = pattern {
-                    if let Some(file_name) = path.file_name() {
-                        if file_name.to_string_lossy().contains(pattern) {
-                            files.push(path.to_path_buf());
-                        }
-                    }
-                } else {
-                    files.push(path.to_path_buf());
-                }
-            }
-        }
-
-        Ok(files)
-    }
-
-    #[allow(dead_code)]
-    pub fn get_directory_structure(root: &Path, max_depth: Option<usize>) -> Result<String> {
-        let mut output = String::new();
-        let max_depth = max_depth.unwrap_or(3);
-
-        for entry in WalkDir::new(root)
-            .max_depth(max_depth)
-            .follow_links(false)
-            .into_iter()
-            .filter_map(|e| e.ok())
-        {
-            let depth = entry.depth();
-            let indent = "  ".repeat(depth);
-            let name = entry.file_name().to_string_lossy();
-
-            if entry.file_type().is_dir() {
-                output.push_str(&format!("{}{}/\n", indent, name));
-            } else {
-                output.push_str(&format!("{}{}\n", indent, name));
-            }
-        }
-
-        Ok(output)
-    }
-}