anveesa 0.7.0 → 0.7.1

package/Cargo.lock

@@ -60,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.7.0"
+version = "0.7.1"
 dependencies = [
  "anyhow",
  "axum",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2024"
 default-run = "anveesa"
 description = "Multi-provider terminal AI assistant — TUI, web UI, and one-shot mode backed by any OpenAI-compatible API"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Multi-provider terminal AI assistant — TUI, web UI, and one-shot mode backed by any OpenAI-compatible API",
   "main": "bin/anveesa.js",
   "bin": {

package/src/display.rs

@@ -240,7 +240,13 @@ pub fn print_status(message: &str, is_tty: bool) {
     }
 }
 
-pub fn print_tool_result(summary: &str, ok: bool, elapsed_ms: u128, error: Option<&str>, is_tty: bool) {
+pub fn print_tool_result(
+    summary: &str,
+    ok: bool,
+    elapsed_ms: u128,
+    error: Option<&str>,
+    is_tty: bool,
+) {
     let elapsed = format_duration_ms(elapsed_ms);
     if is_tty {
         if ok {
@@ -287,7 +293,7 @@ pub fn print_file_op(
 
     // Summary: └ Added N lines, removed M lines
     let summary = match (added, removed) {
-        (a, 0) if a == 0 => String::new(),
+        (0, 0) => String::new(),
         (a, 0) => format!("Added {} {}", a, if a == 1 { "line" } else { "lines" }),
         (0, r) => format!("Removed {} {}", r, if r == 1 { "line" } else { "lines" }),
         (a, r) => format!(
@@ -565,11 +571,15 @@ pub fn print_help_inline(is_tty: bool) {
     println!("\x1b[90m  ──────────────────────────────────────\x1b[0m");
     println!("  \x1b[1;32m/status\x1b[0m             provider, model, turns, token usage");
     println!("  \x1b[1;32m/session\x1b[0m            show session file, age, and turn count");
-    println!("  \x1b[1;32m/export\x1b[0m \x1b[2m[path]\x1b[0m     save conversation to a markdown file");
+    println!(
+        "  \x1b[1;32m/export\x1b[0m \x1b[2m[path]\x1b[0m     save conversation to a markdown file"
+    );
     println!("  \x1b[1;32m/model\x1b[0m \x1b[2m[name]\x1b[0m      switch or show current model");
     println!("  \x1b[1;32m/provider\x1b[0m \x1b[2m[name]\x1b[0m   switch or show current provider");
     println!("  \x1b[1;32m/clear\x1b[0m              reset conversation and delete saved session");
-    println!("  \x1b[1;32m/attach\x1b[0m \x1b[2m[path]\x1b[0m     attach image from file or clipboard");
+    println!(
+        "  \x1b[1;32m/attach\x1b[0m \x1b[2m[path]\x1b[0m     attach image from file or clipboard"
+    );
     println!("  \x1b[1;32m/exit\x1b[0m, \x1b[1;32m/quit\x1b[0m       leave the session");
     println!("  \x1b[1;32m/help\x1b[0m               show this message");
     println!();
@@ -584,9 +594,13 @@ pub fn print_help_inline(is_tty: bool) {
     println!();
     println!("\x1b[2m  Images\x1b[0m");
     println!("\x1b[90m  ──────────────────────────────────────\x1b[0m");
-    println!("  \x1b[2mCtrl+V\x1b[0m to paste a clipboard image inline (shows \x1b[2m[📎]\x1b[0m indicator).");
+    println!(
+        "  \x1b[2mCtrl+V\x1b[0m to paste a clipboard image inline (shows \x1b[2m[📎]\x1b[0m indicator)."
+    );
     println!("  Or Cmd+C an image and send any message — it attaches automatically.");
-    println!("  Or use \x1b[1;32m/attach\x1b[0m \x1b[2mpath/to/file.png\x1b[0m for a specific file.");
+    println!(
+        "  Or use \x1b[1;32m/attach\x1b[0m \x1b[2mpath/to/file.png\x1b[0m for a specific file."
+    );
     println!("  For broadest clipboard support: \x1b[2mbrew install pngpaste\x1b[0m");
     println!();
 }
@@ -639,7 +653,10 @@ pub fn print_session_header(
 
     if !is_tty {
         let tag = if resumed {
-            format!(" (resumed · {turns} turns · {})", format_session_age(saved_at))
+            format!(
+                " (resumed · {turns} turns · {})",
+                format_session_age(saved_at)
+            )
         } else {
             String::new()
         };
@@ -670,7 +687,10 @@ pub fn print_session_header(
     }
 
     let greeting = if resumed {
-        format!(" · Resumed ({turns} turns · {})", format_session_age(saved_at))
+        format!(
+            " · Resumed ({turns} turns · {})",
+            format_session_age(saved_at)
+        )
     } else {
         String::new()
     };

package/src/image.rs

@@ -289,19 +289,23 @@ pub fn read_clipboard_text() -> Option<String> {
         let out = std::process::Command::new("pbpaste").output().ok()?;
         if out.status.success() {
             let text = String::from_utf8_lossy(&out.stdout).into_owned();
-            if !text.is_empty() { return Some(text); }
+            if !text.is_empty() {
+                return Some(text);
+            }
         }
     }
     #[cfg(not(target_os = "macos"))]
     for (cmd, args) in &[
         ("wl-paste", vec!["--no-newline"]),
-        ("xclip",   vec!["-o", "-selection", "clipboard"]),
-        ("xsel",    vec!["--clipboard", "--output"]),
+        ("xclip", vec!["-o", "-selection", "clipboard"]),
+        ("xsel", vec!["--clipboard", "--output"]),
     ] {
-        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
-            if out.status.success() {
-                let text = String::from_utf8_lossy(&out.stdout).into_owned();
-                if !text.is_empty() { return Some(text); }
+        if let Ok(out) = std::process::Command::new(cmd).args(args).output()
+            && out.status.success()
+        {
+            let text = String::from_utf8_lossy(&out.stdout).into_owned();
+            if !text.is_empty() {
+                return Some(text);
             }
         }
     }

package/src/lib.rs

@@ -28,16 +28,13 @@ use crate::{
         set_default_provider,
     },
     display::{
-        render_stream, print_session_header, print_help_inline, print_session_info,
-        print_status_inline, prompt_label, print_input_separator, term_width,
-    },
-    image::{
-        attach_image, grab_clipboard_image, image_fingerprint, parse_attach_command,
+        print_help_inline, print_input_separator, print_session_header, print_session_info,
+        print_status_inline, prompt_label, render_stream, term_width,
     },
+    image::{attach_image, grab_clipboard_image, image_fingerprint, parse_attach_command},
     prompt::{PromptRead, read_prompt_line},
     provider::{
-        ApprovalPolicy, ChatMessage, ChatRole, ImageAttachment,
-        PromptRequest, TurnResult, Usage,
+        ApprovalPolicy, ChatMessage, ChatRole, ImageAttachment, PromptRequest, TurnResult, Usage,
     },
     session::{
         append_repl_history, legacy_session_path, load_interactive_session, purge_stale_sessions,
@@ -124,25 +121,31 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
             let _ = fs::remove_file(&legacy);
             Some(session)
         });
-    let mut history = loaded_session.as_ref().map(|s| s.messages.clone()).unwrap_or_default();
+    let mut history = loaded_session
+        .as_ref()
+        .map(|s| s.messages.clone())
+        .unwrap_or_default();
     // saved_at at load time — used only for the startup header so it shows when the previous
     // run ended, not the current run's save time.
-    let session_saved_at = loaded_session.as_ref().filter(|s| s.saved_at > 0).map(|s| s.saved_at);
+    let session_saved_at = loaded_session
+        .as_ref()
+        .filter(|s| s.saved_at > 0)
+        .map(|s| s.saved_at);
     // tracks the most recent successful save this run — kept fresh for /session display
     let mut last_saved_at: u64 = session_saved_at.unwrap_or(0);
     // Per-project config: .anveesa.toml (extended) or .anveesa (plain system prompt)
     if let Ok(raw) = fs::read_to_string(cwd.join(".anveesa.toml")) {
         if let Ok(cfg) = toml::from_str::<toml::Value>(&raw) {
-            if session_options.system.is_none() {
-                if let Some(sp) = cfg.get("system_prompt").and_then(|v| v.as_str()) {
-                    session_options.system = Some(sp.trim().to_string());
-                }
+            if session_options.system.is_none()
+                && let Some(sp) = cfg.get("system_prompt").and_then(|v| v.as_str())
+            {
+                session_options.system = Some(sp.trim().to_string());
             }
             // Override model if not set by CLI
-            if session_options.model.is_none() {
-                if let Some(m) = cfg.get("model").and_then(|v| v.as_str()) {
-                    session_options.model = Some(m.to_string());
-                }
+            if session_options.model.is_none()
+                && let Some(m) = cfg.get("model").and_then(|v| v.as_str())
+            {
+                session_options.model = Some(m.to_string());
             }
             // auto_approve
             if let Some(true) = cfg.get("auto_approve").and_then(|v| v.as_bool()) {
@@ -150,12 +153,12 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
                 images_available = true; // keep as-is; just document capability
             }
         }
-    } else if session_options.system.is_none() {
-        if let Ok(text) = fs::read_to_string(cwd.join(".anveesa")) {
-            let trimmed = text.trim().to_string();
-            if !trimmed.is_empty() {
-                session_options.system = Some(trimmed);
-            }
+    } else if session_options.system.is_none()
+        && let Ok(text) = fs::read_to_string(cwd.join(".anveesa"))
+    {
+        let trimmed = text.trim().to_string();
+        if !trimmed.is_empty() {
+            session_options.system = Some(trimmed);
         }
     }
 
@@ -164,7 +167,12 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
     let input_history: Vec<String> = history_path
         .as_deref()
         .and_then(|p| fs::read_to_string(p).ok())
-        .map(|c| c.lines().filter(|l| !l.is_empty()).map(String::from).collect())
+        .map(|c| {
+            c.lines()
+                .filter(|l| !l.is_empty())
+                .map(String::from)
+                .collect()
+        })
         .unwrap_or_default();
 
     print_session_header(
@@ -190,10 +198,9 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
         // Spawn a background task to read keyboard events (crossterm::event::read is blocking).
         let (key_tx, key_rx) = tokio::sync::mpsc::unbounded_channel();
         tokio::task::spawn_blocking(move || {
-            loop {
-                match crossterm::event::read() {
-                    Ok(ev) => { if key_tx.send(ev).is_err() { break; } }
-                    Err(_) => break,
+            while let Ok(ev) = crossterm::event::read() {
+                if key_tx.send(ev).is_err() {
+                    break;
                 }
             }
         });
@@ -204,7 +211,10 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
 
         let app = tui::App::new(
             provider_name.clone(),
-            session_options.model.clone().unwrap_or_else(|| "-".to_string()),
+            session_options
+                .model
+                .clone()
+                .unwrap_or_else(|| "-".to_string()),
             short_cwd,
             history,
             images_available,
@@ -234,16 +244,21 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
 
     loop {
         print_input_separator(is_tty, width);
-        let (line, ctrl_v_image) =
-            match read_prompt_line(&label, width, &mut paste_count, images_available, &input_history) {
-                Ok(PromptRead::Line(line, img)) => (line, img),
-                Ok(PromptRead::Interrupted) => continue,
-                Ok(PromptRead::Eof) => {
-                    println!();
-                    break;
-                }
-                Err(error) => return Err(error).context("failed to read interactive prompt"),
-            };
+        let (line, ctrl_v_image) = match read_prompt_line(
+            &label,
+            width,
+            &mut paste_count,
+            images_available,
+            &input_history,
+        ) {
+            Ok(PromptRead::Line(line, img)) => (line, img),
+            Ok(PromptRead::Interrupted) => continue,
+            Ok(PromptRead::Eof) => {
+                println!();
+                break;
+            }
+            Err(error) => return Err(error).context("failed to read interactive prompt"),
+        };
 
         // Ctrl+V image takes precedence over a previously pending image.
         if let Some(img) = ctrl_v_image {
@@ -321,7 +336,10 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
             s if s.starts_with("/model") => {
                 let arg = s.strip_prefix("/model").unwrap().trim();
                 if arg.is_empty() {
-                    let current = session_options.model.as_deref().unwrap_or("(provider default)");
+                    let current = session_options
+                        .model
+                        .as_deref()
+                        .unwrap_or("(provider default)");
                     if is_tty {
                         println!("\x1b[2m  model: {current}\x1b[0m");
                     } else {
@@ -341,14 +359,18 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
                 let arg = s.strip_prefix("/provider").unwrap().trim();
                 if arg.is_empty() {
                     if is_tty {
-                        println!("\x1b[2m  provider: {provider_name}  model: {}\x1b[0m",
-                            session_options.model.as_deref().unwrap_or("(default)"));
+                        println!(
+                            "\x1b[2m  provider: {provider_name}  model: {}\x1b[0m",
+                            session_options.model.as_deref().unwrap_or("(default)")
+                        );
                     } else {
                         println!("provider: {provider_name}");
                     }
                 } else if !config.providers.contains_key(arg) {
                     if is_tty {
-                        eprintln!("\x1b[1;31m✗\x1b[0m unknown provider '{arg}' — run: anveesa providers");
+                        eprintln!(
+                            "\x1b[1;31m✗\x1b[0m unknown provider '{arg}' — run: anveesa providers"
+                        );
                     } else {
                         eprintln!("error: unknown provider '{arg}'");
                     }
@@ -361,7 +383,9 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
                     session_options.provider = Some(arg.to_string());
                     let model_display = session_options.model.as_deref().unwrap_or("(default)");
                     if is_tty {
-                        println!("\x1b[2m  Switched to provider: {arg}  model: {model_display}\x1b[0m");
+                        println!(
+                            "\x1b[2m  Switched to provider: {arg}  model: {model_display}\x1b[0m"
+                        );
                     } else {
                         println!("switched provider: {arg}  model: {model_display}");
                     }
@@ -373,7 +397,9 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
         if let Some(path) = parse_attach_command(&prompt) {
             if !images_available {
                 if is_tty {
-                    eprintln!("\x1b[1;31m✗\x1b[0m image attachments require an openai-compatible provider");
+                    eprintln!(
+                        "\x1b[1;31m✗\x1b[0m image attachments require an openai-compatible provider"
+                    );
                 } else {
                     eprintln!("error: image attachments require an openai-compatible provider");
                 }
@@ -451,10 +477,17 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
                 }
                 history.push(ChatMessage::user(prompt));
                 history.push(ChatMessage::assistant(result.text));
-                if let Some(path) = &session_path {
-                    if save_interactive_session(path, &cwd, &provider_name, &session_options, &history).is_ok() {
-                        last_saved_at = unix_now();
-                    }
+                if let Some(path) = &session_path
+                    && save_interactive_session(
+                        path,
+                        &cwd,
+                        &provider_name,
+                        &session_options,
+                        &history,
+                    )
+                    .is_ok()
+                {
+                    last_saved_at = unix_now();
                 }
             }
             Some(Err(error)) => {
@@ -468,10 +501,17 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
                 history.push(ChatMessage::assistant(format!(
                     "The previous turn failed inside Anveesa before a final answer was produced: {error:#}"
                 )));
-                if let Some(path) = &session_path {
-                    if save_interactive_session(path, &cwd, &provider_name, &session_options, &history).is_ok() {
-                        last_saved_at = unix_now();
-                    }
+                if let Some(path) = &session_path
+                    && save_interactive_session(
+                        path,
+                        &cwd,
+                        &provider_name,
+                        &session_options,
+                        &history,
+                    )
+                    .is_ok()
+                {
+                    last_saved_at = unix_now();
                 }
             }
             None => {
@@ -483,7 +523,13 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
                     eprintln!("interrupted");
                 }
                 if let Some(path) = &session_path {
-                    let _ = save_interactive_session(path, &cwd, &provider_name, &session_options, &history);
+                    let _ = save_interactive_session(
+                        path,
+                        &cwd,
+                        &provider_name,
+                        &session_options,
+                        &history,
+                    );
                 }
                 break;
             }
@@ -530,6 +576,7 @@ async fn run_ask(options: AskOptions, prompt_parts: Vec<String>) -> Result<()> {
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn ask_streaming(
     config: &AppConfig,
     options: &AskOptions,
@@ -579,8 +626,7 @@ pub fn export_conversation(path: &std::path::Path, history: &[ChatMessage]) -> R
             }
         }
     }
-    fs::write(path, out.trim_end())
-        .with_context(|| format!("failed to write {}", path.display()))
+    fs::write(path, out.trim_end()).with_context(|| format!("failed to write {}", path.display()))
 }
 
 fn list_providers() -> Result<()> {
@@ -591,7 +637,11 @@ fn list_providers() -> Result<()> {
         for (name, provider) in &config.providers {
             let is_default = config.default_provider.as_deref() == Some(name.as_str());
             let model = provider.default_model().unwrap_or("-");
-            println!("{}  {name}  {model}  {}", if is_default { "*" } else { " " }, provider.kind());
+            println!(
+                "{}  {name}  {model}  {}",
+                if is_default { "*" } else { " " },
+                provider.kind()
+            );
         }
         return Ok(());
     }

package/src/mcp.rs

@@ -88,8 +88,13 @@ impl McpServer {
     async fn recv_msg(&self) -> Result<Value> {
         let mut stdout = self.stdout.lock().await;
         let mut line = String::new();
-        stdout.read_line(&mut line).await.context("MCP server closed")?;
-        if line.is_empty() { bail!("MCP server closed connection"); }
+        stdout
+            .read_line(&mut line)
+            .await
+            .context("MCP server closed")?;
+        if line.is_empty() {
+            bail!("MCP server closed connection");
+        }
         Ok(serde_json::from_str(line.trim())?)
     }
 
@@ -100,7 +105,8 @@ impl McpServer {
             *n += 1;
             v
         };
-        self.send_msg(json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params })).await?;
+        self.send_msg(json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params }))
+            .await?;
 
         // Wait for our response with a timeout
         let timeout = tokio::time::Duration::from_secs(30);
@@ -117,20 +123,28 @@ impl McpServer {
             }
         })
         .await
-        .context(format!("MCP request to '{}' timed out after 30s", self.name))??;
+        .context(format!(
+            "MCP request to '{}' timed out after 30s",
+            self.name
+        ))??;
         Ok(result)
     }
 
     async fn notify(&self, method: &str, params: Value) -> Result<()> {
-        self.send_msg(json!({ "jsonrpc": "2.0", "method": method, "params": params })).await
+        self.send_msg(json!({ "jsonrpc": "2.0", "method": method, "params": params }))
+            .await
     }
 
     async fn initialize(&self) -> Result<()> {
-        self.request("initialize", json!({
-            "protocolVersion": "2024-11-05",
-            "capabilities": {},
-            "clientInfo": { "name": "anveesa", "version": env!("CARGO_PKG_VERSION") }
-        })).await?;
+        self.request(
+            "initialize",
+            json!({
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": { "name": "anveesa", "version": env!("CARGO_PKG_VERSION") }
+            }),
+        )
+        .await?;
         self.notify("notifications/initialized", json!({})).await?;
         Ok(())
     }
@@ -138,35 +152,45 @@ impl McpServer {
     async fn list_tools(&self) -> Result<Vec<McpTool>> {
         let result = self.request("tools/list", json!({})).await?;
         let raw = result["tools"].as_array().cloned().unwrap_or_default();
-        Ok(raw.into_iter().filter_map(|t| {
-            let original_name = t["name"].as_str()?.to_string();
-            let description = t["description"].as_str().unwrap_or("").to_string();
-            let input_schema = t.get("inputSchema").cloned().unwrap_or(json!({"type":"object","properties":{}}));
-            let safe_server = self.name.replace('-', "_").replace('.', "_");
-            Some(McpTool {
-                name: format!("mcp__{safe_server}__{original_name}"),
-                description,
-                input_schema,
-                server: self.name.clone(),
-                original_name,
+        Ok(raw
+            .into_iter()
+            .filter_map(|t| {
+                let original_name = t["name"].as_str()?.to_string();
+                let description = t["description"].as_str().unwrap_or("").to_string();
+                let input_schema = t
+                    .get("inputSchema")
+                    .cloned()
+                    .unwrap_or(json!({"type":"object","properties":{}}));
+                let safe_server = self.name.replace(['-', '.'], "_");
+                Some(McpTool {
+                    name: format!("mcp__{safe_server}__{original_name}"),
+                    description,
+                    input_schema,
+                    server: self.name.clone(),
+                    original_name,
+                })
             })
-        }).collect())
+            .collect())
     }
 
     async fn call_tool(&self, original_name: &str, arguments: Value) -> Result<String> {
-        let result = self.request("tools/call", json!({
-            "name": original_name,
-            "arguments": arguments,
-        })).await?;
+        let result = self
+            .request(
+                "tools/call",
+                json!({
+                    "name": original_name,
+                    "arguments": arguments,
+                }),
+            )
+            .await?;
 
         // MCP returns content as an array of typed blocks
         let content = result["content"].as_array().cloned().unwrap_or_default();
-        let text = content.iter()
-            .filter_map(|c| {
-                match c["type"].as_str() {
-                    Some("text") => c["text"].as_str().map(str::to_string),
-                    _ => None,
-                }
+        let text = content
+            .iter()
+            .filter_map(|c| match c["type"].as_str() {
+                Some("text") => c["text"].as_str().map(str::to_string),
+                _ => None,
             })
             .collect::<Vec<_>>()
             .join("\n");
@@ -197,8 +221,10 @@ impl McpManager {
         for (name, cfg) in configs {
             match McpServer::connect(name, cfg).await {
                 Ok(pair) => {
-                    eprintln!("\x1b[2m  MCP: connected to '{name}' ({} tools)\x1b[0m",
-                        pair.1.len());
+                    eprintln!(
+                        "\x1b[2m  MCP: connected to '{name}' ({} tools)\x1b[0m",
+                        pair.1.len()
+                    );
                     servers.push(pair);
                 }
                 Err(e) => {
@@ -211,14 +237,16 @@ impl McpManager {
 
     /// All tool definitions from all connected servers.
     pub fn tool_definitions(&self) -> Vec<Value> {
-        self.servers.iter()
+        self.servers
+            .iter()
             .flat_map(|(_, tools)| tools.iter().map(|t| t.to_definition()))
             .collect()
     }
 
     /// All tool names from all connected servers.
     pub fn tool_names(&self) -> Vec<String> {
-        self.servers.iter()
+        self.servers
+            .iter()
             .flat_map(|(_, tools)| tools.iter().map(|t| t.name.clone()))
             .collect()
     }