anveesa 0.2.5 → 0.2.7

package/Cargo.lock

@@ -54,7 +54,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.2.5"
+version = "0.2.7"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.2.5"
+version = "0.2.7"
 edition = "2024"
 default-run = "anveesa"
 

package/README.md

@@ -1,7 +1,7 @@
 # Anveesa
 
 Anveesa is a Rust terminal wrapper for AI providers. It gives you one command,
-`anveesa`, while each provider is configured as either:
+`anveesa`, for interactive prompts and one-shot terminal requests.
 
 ## 📦 Publishing to npm
 
@@ -13,20 +13,6 @@ Anveesa can be published as an npm package via a Node.js wrapper that invokes th
 npm install -g anveesa
 ```
 
-### Build and publish
-
-```bash
-git tag v$(node -p "require('./package.json').version")
-git push origin main --tags
-npm publish
-```
-
-Wait for the GitHub release binary workflow to finish before publishing to npm.
-See `npm-publish.md` for the full release checklist.
-
-- `openai-compatible`: HTTP chat completions providers such as OpenRouter and other compatible gateways.
-- `command`: local CLIs such as Codex, Copilot, and Claude Code, where Anveesa spawns a command and passes the prompt.
-
 ## Install locally
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {

package/src/lib.rs

@@ -326,6 +326,7 @@ async fn render_stream(
     let mut usage: Option<Usage> = None;
     let mut plan_tasks: Vec<String> = vec![];
     let mut plan_done: Vec<bool> = vec![];
+    let mut status_message = "Waiting for provider response".to_string();
 
     static TIPS: &[&str] = &[
         "Tip: type /clear to reset context",
@@ -337,6 +338,18 @@ async fn render_stream(
     loop {
         tokio::select! {
             maybe = rx.recv() => match maybe {
+                Some(StreamEvent::Status { message }) => {
+                    clear_spinner(spinner, spinner_active);
+                    spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
+                    status_message = message;
+                    print_status(&status_message, spinner);
+                    first_token = true;
+                    frame = 0;
+                }
                 Some(StreamEvent::Token(text)) => {
                     if first_token {
                         clear_spinner(spinner, spinner_active);
@@ -359,10 +372,27 @@ async fn render_stream(
                         println!();
                         line_open = false;
                     }
+                    status_message = format!("Running {summary}");
                     print_tool_call(&summary, spinner);
                     first_token = true;
                     frame = 0;
                 }
+                Some(StreamEvent::ToolResult { summary, ok, elapsed_ms, error }) => {
+                    clear_spinner(spinner, spinner_active);
+                    spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
+                    print_tool_result(&summary, ok, elapsed_ms, error.as_deref(), spinner);
+                    status_message = if ok {
+                        "Waiting for the model to continue".to_string()
+                    } else {
+                        "Waiting for the model to handle the tool failure".to_string()
+                    };
+                    first_token = true;
+                    frame = 0;
+                }
                 Some(StreamEvent::Confirm { preview, reply }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
@@ -374,6 +404,20 @@ async fn render_stream(
                         show_confirm_preview(&preview, spinner);
                         prompt_confirm_decision(spinner)
                     });
+                    match decision {
+                        ApprovalDecision::AllowOnce => {
+                            print_status("Approved; applying action", spinner);
+                            status_message = "Applying approved action".to_string();
+                        }
+                        ApprovalDecision::AllowForTurn => {
+                            print_status("Approved all actions for this turn; applying action", spinner);
+                            status_message = "Applying approved action".to_string();
+                        }
+                        ApprovalDecision::Deny => {
+                            print_status("Declined action; returning decision to model", spinner);
+                            status_message = "Waiting for the model to continue".to_string();
+                        }
+                    }
                     let _ = reply.send(decision);
                     // Re-arm the spinner for the next API round.
                     first_token = true;
@@ -428,17 +472,18 @@ async fn render_stream(
                 let dots = ["", ".", "..", "…"][frame % 4];
                 // Tip rotates every 40 frames (~4 s)
                 let tip = TIPS[(frame / 40) % TIPS.len()];
+                let status = truncate_for_status(&status_message, 76);
 
                 if !spinner_active {
                     // First paint — just print 2 lines (no overwrite needed).
                     eprint!(
-                        "\x1b[1;32m+\x1b[0m Thinking{dots} \x1b[2m({time_str})\x1b[0m\n  \x1b[90m└\x1b[0m \x1b[2m{tip}\x1b[0m"
+                        "\x1b[1;32m+\x1b[0m {status}{dots} \x1b[2m({time_str})\x1b[0m\n  \x1b[90m└\x1b[0m \x1b[2m{tip}\x1b[0m"
                     );
                     spinner_active = true;
                 } else {
                     // Overwrite: move up 1 line, clear both lines, reprint.
                     eprint!(
-                        "\r\x1b[2K\x1b[1A\x1b[2K\r\x1b[1;32m+\x1b[0m Thinking{dots} \x1b[2m({time_str})\x1b[0m\n  \x1b[90m└\x1b[0m \x1b[2m{tip}\x1b[0m"
+                        "\r\x1b[2K\x1b[1A\x1b[2K\r\x1b[1;32m+\x1b[0m {status}{dots} \x1b[2m({time_str})\x1b[0m\n  \x1b[90m└\x1b[0m \x1b[2m{tip}\x1b[0m"
                     );
                 }
                 let _ = io::stderr().flush();
@@ -483,6 +528,33 @@ fn print_tool_call(summary: &str, is_tty: bool) {
     }
 }
 
+fn print_status(message: &str, is_tty: bool) {
+    if is_tty {
+        eprintln!("\x1b[90m  · {message}\x1b[0m");
+    } else {
+        eprintln!("status: {message}");
+    }
+}
+
+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 {
+            eprintln!("\x1b[1;32m  ✓\x1b[0m \x1b[90m{summary} completed in {elapsed}\x1b[0m");
+        } else if let Some(error) = error {
+            eprintln!("\x1b[1;31m  ✗\x1b[0m \x1b[90m{summary} failed in {elapsed}: {error}\x1b[0m");
+        } else {
+            eprintln!("\x1b[1;31m  ✗\x1b[0m \x1b[90m{summary} failed in {elapsed}\x1b[0m");
+        }
+    } else if ok {
+        eprintln!("tool ok: {summary} ({elapsed})");
+    } else if let Some(error) = error {
+        eprintln!("tool failed: {summary} ({elapsed}): {error}");
+    } else {
+        eprintln!("tool failed: {summary} ({elapsed})");
+    }
+}
+
 fn print_file_op(
     verb: &str,
     path: &str,
@@ -590,6 +662,29 @@ fn format_elapsed(secs: f32) -> String {
     }
 }
 
+fn format_duration_ms(ms: u128) -> String {
+    if ms >= 1000 {
+        format!("{:.1}s", ms as f64 / 1000.0)
+    } else {
+        format!("{ms}ms")
+    }
+}
+
+fn truncate_for_status(value: &str, max_chars: usize) -> String {
+    let mut chars = value.chars();
+    let mut output = String::new();
+    for _ in 0..max_chars {
+        let Some(ch) = chars.next() else {
+            return output;
+        };
+        output.push(ch);
+    }
+    if chars.next().is_some() {
+        output.push('…');
+    }
+    output
+}
+
 fn show_confirm_preview(preview: &ToolConfirmPreview, is_tty: bool) {
     match preview {
         ToolConfirmPreview::FileOp {

package/src/provider/command.rs

@@ -37,6 +37,10 @@ pub async fn ask(
         command.stdin(Stdio::piped());
     }
 
+    let _ = events.send(StreamEvent::Status {
+        message: format!("Running command provider `{}`", config.command),
+    });
+
     let mut child = command.spawn().with_context(|| {
         format!(
             "failed to spawn command provider '{}' at {}",

package/src/provider/mod.rs

@@ -112,12 +112,21 @@ pub enum ToolConfirmPreview {
 /// Events streamed from a provider back to the renderer, which owns the terminal.
 #[derive(Debug)]
 pub enum StreamEvent {
+    /// Durable progress/status message for long waits between model/tool phases.
+    Status { message: String },
     /// A chunk of assistant text to display as it arrives.
     Token(String),
     /// Final token accounting for the turn.
     Usage(Usage),
     /// A read-only tool is running. Used to make multi-round inspection visible.
     ToolCall { summary: String },
+    /// A tool finished running. Used to show explicit success/failure after approval.
+    ToolResult {
+        summary: String,
+        ok: bool,
+        elapsed_ms: u128,
+        error: Option<String>,
+    },
     /// A write/run tool needs the user's approval. The renderer shows the
     /// preview, prompts for a decision, and sends it back through the reply channel.
     Confirm {

package/src/provider/openai_compatible.rs

@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use anyhow::{Context, Result, bail};
 use reqwest::header::{AUTHORIZATION, CONTENT_TYPE, HeaderMap, HeaderName, HeaderValue};
@@ -62,6 +62,14 @@ pub async fn ask(
     let mut tool_intent_reprompts = 0usize;
 
     loop {
+        let _ = events.send(StreamEvent::Status {
+            message: if tool_rounds == 0 {
+                format!("Waiting for {provider_name} response")
+            } else {
+                format!("Sending tool results to {provider_name}")
+            },
+        });
+
         let mut body = json!({
             "model": model,
             "messages": messages,
@@ -134,6 +142,10 @@ pub async fn ask(
             }));
         }
 
+        let _ = events.send(StreamEvent::Status {
+            message: "Tool results sent; waiting for the next model response".to_string(),
+        });
+
         if tool_rounds >= max_tool_rounds {
             tools_enabled = false;
             messages.push(tool_limit_message(max_tool_rounds));
@@ -163,6 +175,8 @@ async fn dispatch_tool(
     approval_state: &mut ToolApprovalState,
     events: &UnboundedSender<StreamEvent>,
 ) -> String {
+    let summary = tools::describe_call(&call.name, &call.arguments);
+
     // Plan tools — display only, no approval or filesystem access needed.
     if call.name == "set_plan" {
         if let Ok(args) = serde_json::from_str::<serde_json::Value>(&call.arguments) {
@@ -213,7 +227,7 @@ async fn dispatch_tool(
         }
     } else {
         let _ = events.send(StreamEvent::ToolCall {
-            summary: tools::describe_call(&call.name, &call.arguments),
+            summary: summary.clone(),
         });
     }
 
@@ -233,9 +247,24 @@ async fn dispatch_tool(
             ApprovalDecision::AllowForTurn => approval_state.allow_for_turn = true,
             ApprovalDecision::Deny => return denied_message("user declined this action"),
         }
+        let _ = events.send(StreamEvent::Status {
+            message: format!("Applying approved action: {summary}"),
+        });
+    } else if tools::is_write_tool(&call.name) {
+        let _ = events.send(StreamEvent::ToolCall {
+            summary: summary.clone(),
+        });
     }
 
+    let tool_started = Instant::now();
     let result = tools::run(&call.name, &call.arguments).await;
+    let (ok, error) = parse_tool_result_status(&result);
+    let _ = events.send(StreamEvent::ToolResult {
+        summary: summary.clone(),
+        ok,
+        elapsed_ms: tool_started.elapsed().as_millis(),
+        error,
+    });
 
     // When the user already reviewed the diff in the approval preview, skip the
     // post-run FileOp so the same diff isn't printed twice.
@@ -252,6 +281,18 @@ async fn dispatch_tool(
     result
 }
 
+fn parse_tool_result_status(result: &str) -> (bool, Option<String>) {
+    let Ok(json) = serde_json::from_str::<Value>(result) else {
+        return (true, None);
+    };
+    let ok = json.get("ok").and_then(Value::as_bool).unwrap_or(true);
+    let error = json
+        .get("error")
+        .and_then(Value::as_str)
+        .map(str::to_string);
+    (ok, error)
+}
+
 // ── File-op diff helpers ──────────────────────────────────────────────────────
 
 enum FileOpSnapshot {
@@ -1048,4 +1089,17 @@ mod tests {
         ));
         assert!(!looks_like_unfinished_tool_intent(""));
     }
+
+    #[test]
+    fn parses_tool_result_status() {
+        assert_eq!(parse_tool_result_status(r#"{"ok":true}"#), (true, None));
+        assert_eq!(
+            parse_tool_result_status(r#"{"ok":false,"error":"boom"}"#),
+            (false, Some("boom".to_string()))
+        );
+        assert_eq!(
+            parse_tool_result_status(r#"{"content":"no explicit ok"}"#),
+            (true, None)
+        );
+    }
 }