zarz 0.3.1-alpha → 0.3.5-alpha

package/src/mcp/types.rs

@@ -1,170 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// MCP JSON-RPC request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JsonRpcRequest {
-    pub jsonrpc: String,
-    pub id: u64,
-    pub method: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub params: Option<Value>,
-}
-
-/// MCP JSON-RPC response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JsonRpcResponse {
-    pub jsonrpc: String,
-    pub id: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub result: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<JsonRpcError>,
-}
-
-/// MCP JSON-RPC error
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JsonRpcError {
-    pub code: i32,
-    pub message: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub data: Option<Value>,
-}
-
-/// MCP Tool definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct McpTool {
-    pub name: String,
-    pub description: Option<String>,
-    #[serde(rename = "inputSchema")]
-    pub input_schema: Value,
-}
-
-/// MCP Resource definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct McpResource {
-    pub uri: String,
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mime_type: Option<String>,
-}
-
-/// MCP Prompt definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct McpPrompt {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub arguments: Option<Vec<PromptArgument>>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct PromptArgument {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    pub required: bool,
-}
-
-/// MCP Initialize result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InitializeResult {
-    #[serde(rename = "protocolVersion")]
-    pub protocol_version: String,
-    pub capabilities: ServerCapabilities,
-    #[serde(rename = "serverInfo")]
-    pub server_info: ServerInfo,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ServerCapabilities {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tools: Option<ToolsCapability>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub resources: Option<ResourcesCapability>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prompts: Option<PromptsCapability>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ToolsCapability {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub list_changed: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResourcesCapability {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub subscribe: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub list_changed: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PromptsCapability {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub list_changed: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ServerInfo {
-    pub name: String,
-    pub version: String,
-}
-
-/// Tools list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ToolsListResult {
-    pub tools: Vec<McpTool>,
-}
-
-/// Tool call request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct CallToolParams {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub arguments: Option<HashMap<String, Value>>,
-}
-
-/// Tool call result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct CallToolResult {
-    pub content: Vec<ToolContent>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_error: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-#[allow(dead_code)]
-pub enum ToolContent {
-    #[serde(rename = "text")]
-    Text { text: String },
-    #[serde(rename = "image")]
-    Image { data: String, mime_type: String },
-    #[serde(rename = "resource")]
-    Resource { resource: McpResource },
-}
-
-/// Resources list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct ResourcesListResult {
-    pub resources: Vec<McpResource>,
-}
-
-/// Prompts list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct PromptsListResult {
-    pub prompts: Vec<McpPrompt>,
-}

package/src/providers/anthropic.rs

@@ -1,214 +0,0 @@
-use anyhow::{anyhow, Context, Result};
-use bytes::Bytes;
-use futures::stream::StreamExt;
-use reqwest::Client;
-use serde::Deserialize;
-use serde_json::json;
-
-use super::{CompletionRequest, CompletionResponse, CompletionStream};
-
-const DEFAULT_ENDPOINT: &str = "https://api.anthropic.com/v1/messages";
-const DEFAULT_VERSION: &str = "2023-06-01";
-
-pub struct AnthropicClient {
-    http: Client,
-    endpoint: String,
-    api_key: String,
-    version: String,
-}
-
-impl AnthropicClient {
-    pub fn from_env(
-        api_key_override: Option<String>,
-        endpoint_override: Option<String>,
-        timeout_override: Option<u64>,
-    ) -> Result<Self> {
-        let api_key = api_key_override
-            .or_else(|| std::env::var("ANTHROPIC_API_KEY").ok())
-            .ok_or_else(|| anyhow::anyhow!("ANTHROPIC_API_KEY is required. Please set it in ~/.zarz/config.toml or as an environment variable"))?;
-        let endpoint = endpoint_override
-            .or_else(|| std::env::var("ANTHROPIC_API_URL").ok())
-            .unwrap_or_else(|| DEFAULT_ENDPOINT.to_string());
-        let version = std::env::var("ANTHROPIC_API_VERSION")
-            .ok()
-            .filter(|v| !v.trim().is_empty())
-            .unwrap_or_else(|| DEFAULT_VERSION.to_string());
-
-        let timeout_secs = timeout_override
-            .or_else(|| {
-                std::env::var("ANTHROPIC_TIMEOUT_SECS")
-                    .ok()
-                    .and_then(|raw| raw.parse::<u64>().ok())
-            })
-            .unwrap_or(120);
-
-        let http = Client::builder()
-            .user_agent("zarz-cli/0.1")
-            .timeout(std::time::Duration::from_secs(timeout_secs))
-            .build()
-            .context("Failed to build HTTP client for Anthropic")?;
-
-        Ok(Self {
-            http,
-            endpoint,
-            api_key,
-            version,
-        })
-    }
-
-    pub async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        let mut payload = serde_json::Map::new();
-        payload.insert("model".to_string(), serde_json::Value::String(request.model.clone()));
-        payload.insert(
-            "max_tokens".to_string(),
-            serde_json::Value::Number(serde_json::Number::from(request.max_output_tokens)),
-        );
-        payload.insert("temperature".to_string(), json!(request.temperature));
-        if let Some(system_prompt) = &request.system_prompt {
-            payload.insert(
-                "system".to_string(),
-                serde_json::Value::String(system_prompt.clone()),
-            );
-        }
-        payload.insert(
-            "messages".to_string(),
-            json!([{
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": request.user_prompt
-                }]
-            }]),
-        );
-
-        let response = self
-            .http
-            .post(&self.endpoint)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", &self.version)
-            .json(&payload)
-            .send()
-            .await
-            .context("Anthropic request failed")?;
-
-        let response = response.error_for_status().context("Anthropic returned an error status")?;
-        let parsed: AnthropicResponse = response
-            .json()
-            .await
-            .context("Failed to decode Anthropic response")?;
-        let text = parsed
-            .content
-            .into_iter()
-            .find_map(|block| match block {
-                AnthropicResponseBlock::Text { text, .. } => Some(text),
-            })
-            .ok_or_else(|| anyhow!("Anthropic response did not include text content"))?;
-        Ok(CompletionResponse { text })
-    }
-
-    #[allow(dead_code)]
-    pub async fn complete_stream(&self, request: &CompletionRequest) -> Result<CompletionStream> {
-        let mut payload = serde_json::Map::new();
-        payload.insert("model".to_string(), serde_json::Value::String(request.model.clone()));
-        payload.insert(
-            "max_tokens".to_string(),
-            serde_json::Value::Number(serde_json::Number::from(request.max_output_tokens)),
-        );
-        payload.insert("temperature".to_string(), json!(request.temperature));
-        payload.insert("stream".to_string(), json!(true));
-
-        if let Some(system_prompt) = &request.system_prompt {
-            payload.insert(
-                "system".to_string(),
-                serde_json::Value::String(system_prompt.clone()),
-            );
-        }
-        payload.insert(
-            "messages".to_string(),
-            json!([{
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": request.user_prompt
-                }]
-            }]),
-        );
-
-        let response = self
-            .http
-            .post(&self.endpoint)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", &self.version)
-            .json(&payload)
-            .send()
-            .await
-            .context("Anthropic streaming request failed")?;
-
-        let response = response
-            .error_for_status()
-            .context("Anthropic returned an error status")?;
-
-        let stream = response.bytes_stream();
-        let text_stream = stream.map(|result| {
-            let bytes = result?;
-            parse_anthropic_sse_chunk(&bytes)
-        });
-
-        Ok(Box::pin(text_stream))
-    }
-}
-
-#[allow(dead_code)]
-fn parse_anthropic_sse_chunk(bytes: &Bytes) -> Result<String> {
-    let text = String::from_utf8_lossy(bytes);
-    let mut result = String::new();
-
-    for line in text.lines() {
-        if let Some(data) = line.strip_prefix("data: ") {
-            if data == "[DONE]" {
-                break;
-            }
-
-            if let Ok(event) = serde_json::from_str::<StreamEvent>(data) {
-                match event.event_type.as_str() {
-                    "content_block_delta" => {
-                        if let Some(delta) = event.delta {
-                            if let Some(text) = delta.text {
-                                result.push_str(&text);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamEvent {
-    #[serde(rename = "type")]
-    event_type: String,
-    delta: Option<StreamDelta>,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamDelta {
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnthropicResponse {
-    content: Vec<AnthropicResponseBlock>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(tag = "type")]
-enum AnthropicResponseBlock {
-    #[serde(rename = "text")]
-    Text { text: String },
-}

package/src/providers/glm.rs

@@ -1,209 +0,0 @@
-use anyhow::{anyhow, Context, Result};
-use bytes::Bytes;
-use futures::stream::StreamExt;
-use reqwest::Client;
-use serde::Deserialize;
-use serde_json::json;
-
-use super::{CompletionRequest, CompletionResponse, CompletionStream};
-
-// GLM Coding Plan endpoint (base URL only, no /chat/completions)
-const DEFAULT_ENDPOINT: &str = "https://api.z.ai/api/coding/paas/v4";
-
-pub struct GlmClient {
-    http: Client,
-    endpoint: String,
-    api_key: String,
-}
-
-impl GlmClient {
-    pub fn from_env(
-        api_key_override: Option<String>,
-        endpoint_override: Option<String>,
-        timeout_override: Option<u64>,
-    ) -> Result<Self> {
-        let api_key = api_key_override
-            .or_else(|| std::env::var("GLM_API_KEY").ok())
-            .ok_or_else(|| anyhow::anyhow!("GLM_API_KEY is required. Please set it in ~/.zarz/config.toml or as an environment variable"))?;
-        let endpoint = endpoint_override
-            .or_else(|| std::env::var("GLM_API_URL").ok())
-            .unwrap_or_else(|| DEFAULT_ENDPOINT.to_string());
-
-        let timeout_secs = timeout_override
-            .or_else(|| {
-                std::env::var("GLM_TIMEOUT_SECS")
-                    .ok()
-                    .and_then(|raw| raw.parse::<u64>().ok())
-            })
-            .unwrap_or(120);
-
-        let http = Client::builder()
-            .user_agent("zarz-cli/0.1")
-            .timeout(std::time::Duration::from_secs(timeout_secs))
-            .build()
-            .context("Failed to build HTTP client for GLM")?;
-
-        Ok(Self {
-            http,
-            endpoint,
-            api_key,
-        })
-    }
-
-    pub async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        let mut messages = Vec::new();
-        if let Some(system) = &request.system_prompt {
-            messages.push(json!({
-                "role": "system",
-                "content": system,
-            }));
-        }
-        messages.push(json!({
-            "role": "user",
-            "content": request.user_prompt,
-        }));
-
-        let payload = json!({
-            "model": request.model,
-            "max_tokens": request.max_output_tokens,
-            "messages": messages,
-        });
-
-        // Construct full endpoint URL
-        let full_url = format!("{}/chat/completions", self.endpoint);
-
-        let response = self
-            .http
-            .post(&full_url)
-            .bearer_auth(&self.api_key)
-            .json(&payload)
-            .send()
-            .await
-            .context("GLM request failed")?;
-
-        // Check status and get error details if failed
-        let status = response.status();
-        if !status.is_success() {
-            let error_body = response.text().await.unwrap_or_else(|_| "Unable to read error body".to_string());
-            return Err(anyhow!("GLM API error ({}): {}", status, error_body));
-        }
-
-        let response = response;
-
-        let parsed: GlmResponse = response
-            .json()
-            .await
-            .context("Failed to decode GLM response")?;
-
-        let text = parsed
-            .choices
-            .into_iter()
-            .find_map(|choice| choice.message.content)
-            .ok_or_else(|| anyhow!("GLM response did not include content"))?;
-
-        Ok(CompletionResponse { text })
-    }
-
-    #[allow(dead_code)]
-    pub async fn complete_stream(&self, request: &CompletionRequest) -> Result<CompletionStream> {
-        let mut messages = Vec::new();
-        if let Some(system) = &request.system_prompt {
-            messages.push(json!({
-                "role": "system",
-                "content": system,
-            }));
-        }
-        messages.push(json!({
-            "role": "user",
-            "content": request.user_prompt,
-        }));
-
-        let payload = json!({
-            "model": request.model,
-            "max_tokens": request.max_output_tokens,
-            "messages": messages,
-            "stream": true,
-        });
-
-        // Construct full endpoint URL
-        let full_url = format!("{}/chat/completions", self.endpoint);
-
-        let response = self
-            .http
-            .post(&full_url)
-            .bearer_auth(&self.api_key)
-            .json(&payload)
-            .send()
-            .await
-            .context("GLM streaming request failed")?;
-
-        let response = response
-            .error_for_status()
-            .context("GLM returned an error status")?;
-
-        let stream = response.bytes_stream();
-        let text_stream = stream.map(|result| {
-            let bytes = result?;
-            parse_glm_sse_chunk(&bytes)
-        });
-
-        Ok(Box::pin(text_stream))
-    }
-}
-
-#[allow(dead_code)]
-fn parse_glm_sse_chunk(bytes: &Bytes) -> Result<String> {
-    let text = String::from_utf8_lossy(bytes);
-    let mut result = String::new();
-
-    for line in text.lines() {
-        if let Some(data) = line.strip_prefix("data: ") {
-            if data == "[DONE]" {
-                break;
-            }
-
-            if let Ok(chunk) = serde_json::from_str::<StreamChunk>(data) {
-                if let Some(choice) = chunk.choices.first() {
-                    if let Some(content) = &choice.delta.content {
-                        result.push_str(content);
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamDelta {
-    content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmResponse {
-    choices: Vec<GlmChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmChoice {
-    message: GlmMessage,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmMessage {
-    content: Option<String>,
-}

package/src/providers/mod.rs

@@ -1,90 +0,0 @@
-use anyhow::Result;
-use async_trait::async_trait;
-use futures::Stream;
-use std::pin::Pin;
-
-use crate::cli::Provider;
-
-mod anthropic;
-mod openai;
-mod glm;
-
-#[derive(Debug, Clone)]
-pub struct CompletionRequest {
-    pub model: String,
-    pub system_prompt: Option<String>,
-    pub user_prompt: String,
-    pub max_output_tokens: u32,
-    pub temperature: f32,
-}
-
-#[derive(Debug, Clone)]
-pub struct CompletionResponse {
-    pub text: String,
-}
-
-#[allow(dead_code)]
-pub type StreamChunk = Result<String>;
-#[allow(dead_code)]
-pub type CompletionStream = Pin<Box<dyn Stream<Item = StreamChunk> + Send>>;
-
-#[async_trait]
-pub trait CompletionProvider: Send + Sync {
-    async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse>;
-    #[allow(dead_code)]
-    async fn complete_stream(&self, request: &CompletionRequest) -> Result<CompletionStream>;
-}
-
-pub enum ProviderClient {
-    Anthropic(anthropic::AnthropicClient),
-    OpenAi(openai::OpenAiClient),
-    Glm(glm::GlmClient),
-}
-
-impl ProviderClient {
-    pub fn new(
-        provider: Provider,
-        api_key: Option<String>,
-        endpoint_override: Option<String>,
-        timeout_override: Option<u64>,
-    ) -> Result<Self> {
-        match provider {
-            Provider::Anthropic => Ok(Self::Anthropic(
-                anthropic::AnthropicClient::from_env(api_key, endpoint_override, timeout_override)?,
-            )),
-            Provider::OpenAi => Ok(Self::OpenAi(
-                openai::OpenAiClient::from_env(api_key, endpoint_override, timeout_override)?,
-            )),
-            Provider::Glm => Ok(Self::Glm(
-                glm::GlmClient::from_env(api_key, endpoint_override, timeout_override)?,
-            )),
-        }
-    }
-
-    pub fn name(&self) -> &'static str {
-        match self {
-            ProviderClient::Anthropic(_) => "anthropic",
-            ProviderClient::OpenAi(_) => "openai",
-            ProviderClient::Glm(_) => "glm",
-        }
-    }
-}
-
-#[async_trait]
-impl CompletionProvider for ProviderClient {
-    async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        match self {
-            ProviderClient::Anthropic(client) => client.complete(request).await,
-            ProviderClient::OpenAi(client) => client.complete(request).await,
-            ProviderClient::Glm(client) => client.complete(request).await,
-        }
-    }
-
-    async fn complete_stream(&self, request: &CompletionRequest) -> Result<CompletionStream> {
-        match self {
-            ProviderClient::Anthropic(client) => client.complete_stream(request).await,
-            ProviderClient::OpenAi(client) => client.complete_stream(request).await,
-            ProviderClient::Glm(client) => client.complete_stream(request).await,
-        }
-    }
-}