anveesa 0.2.3 → 0.2.4

package/Cargo.lock

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

package/Cargo.toml

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "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

@@ -302,6 +302,7 @@ async fn render_stream(
     let mut spinner_active = false;
     let mut first_token = true;
     let mut produced = false;
+    let mut line_open = false;
     let mut usage: Option<Usage> = None;
     let mut plan_tasks: Vec<String> = vec![];
     let mut plan_done: Vec<bool> = vec![];
@@ -326,13 +327,29 @@ async fn render_stream(
                         first_token = false;
                     }
                     produced = true;
+                    line_open = true;
                     print!("{text}");
                     let _ = io::stdout().flush();
                 }
                 Some(StreamEvent::Usage(value)) => usage = Some(value),
+                Some(StreamEvent::ToolCall { summary }) => {
+                    clear_spinner(spinner, spinner_active);
+                    spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
+                    print_tool_call(&summary, spinner);
+                    first_token = true;
+                    frame = 0;
+                }
                 Some(StreamEvent::Confirm { preview, reply }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     let decision = tokio::task::block_in_place(|| {
                         show_confirm_preview(&preview, spinner);
                         prompt_confirm_decision(spinner)
@@ -345,6 +362,10 @@ async fn render_stream(
                 Some(StreamEvent::FileOp { verb, path, added, removed, preview, truncated }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     print_file_op(&verb, &path, added, removed, &preview, truncated, spinner);
                     // Re-arm the spinner for the next API round.
                     first_token = true;
@@ -353,6 +374,10 @@ async fn render_stream(
                 Some(StreamEvent::PlanSet { tasks }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     plan_done = vec![false; tasks.len()];
                     plan_tasks = tasks;
                     print_plan_list(&plan_tasks, &plan_done, spinner);
@@ -362,6 +387,10 @@ async fn render_stream(
                 Some(StreamEvent::PlanTaskDone { index }) => {
                     clear_spinner(spinner, spinner_active);
                     spinner_active = false;
+                    if line_open {
+                        println!();
+                        line_open = false;
+                    }
                     if index < plan_done.len() {
                         plan_done[index] = true;
                     }
@@ -398,7 +427,7 @@ async fn render_stream(
         }
     }
 
-    if produced {
+    if produced && line_open {
         println!();
     } else {
         clear_spinner(spinner, spinner_active);
@@ -426,6 +455,14 @@ async fn render_stream(
     }
 }
 
+fn print_tool_call(summary: &str, is_tty: bool) {
+    if is_tty {
+        eprintln!("\x1b[90m  └─ {summary}\x1b[0m");
+    } else {
+        eprintln!("tool: {summary}");
+    }
+}
+
 fn print_file_op(
     verb: &str,
     path: &str,

package/src/provider/mod.rs

@@ -116,6 +116,8 @@ pub enum StreamEvent {
     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 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

@@ -21,6 +21,7 @@ const MAX_RETRIES: usize = 2;
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
 /// How many times the model may call the exact same (tool, arguments) pair before we refuse.
 const MAX_IDENTICAL_CALLS: usize = 3;
+const MAX_TOOL_INTENT_REPROMPTS: usize = 2;
 
 pub async fn ask(
     provider_name: &str,
@@ -58,6 +59,7 @@ pub async fn ask(
     let mut approval_state = ToolApprovalState::default();
     let mut full_text = String::new();
     let mut last_usage: Option<Usage> = None;
+    let mut tool_intent_reprompts = 0usize;
 
     loop {
         let mut body = json!({
@@ -94,12 +96,25 @@ pub async fn ask(
         let mut state = StreamState::default();
         stream_response(response, &mut state, events).await?;
 
-        full_text.push_str(&state.content);
         if let Some(usage) = state.usage {
             last_usage = Some(usage);
         }
 
         if state.tool_calls.is_empty() {
+            if tools_enabled
+                && tool_intent_reprompts < MAX_TOOL_INTENT_REPROMPTS
+                && looks_like_unfinished_tool_intent(&state.content)
+            {
+                tool_intent_reprompts += 1;
+                messages.push(json!({
+                    "role": "assistant",
+                    "content": state.content,
+                }));
+                messages.push(tool_intent_reprompt_message());
+                continue;
+            }
+
+            full_text.push_str(&state.content);
             break;
         }
 
@@ -196,6 +211,10 @@ async fn dispatch_tool(
         if !policy.allows_write_tools() {
             return denied_message("write tools are disabled (pass --yes or run interactively)");
         }
+    } else {
+        let _ = events.send(StreamEvent::ToolCall {
+            summary: tools::describe_call(&call.name, &call.arguments),
+        });
     }
 
     // Snapshot BEFORE the tool runs — needed both for preview and for post-run diff.
@@ -397,6 +416,50 @@ fn tool_limit_message(max_tool_rounds: usize) -> Value {
     })
 }
 
+fn tool_intent_reprompt_message() -> Value {
+    json!({
+        "role": "system",
+        "content": "Your previous message said you would inspect/read/check the workspace, but it did not call any tool or provide a final answer. Do not narrate future tool use. If you need information, call the relevant Anveesa tools now. Otherwise, answer the user directly."
+    })
+}
+
+fn looks_like_unfinished_tool_intent(text: &str) -> bool {
+    let lower = text.trim().to_lowercase();
+    if lower.is_empty() || lower.len() > 600 {
+        return false;
+    }
+
+    let has_intent = [
+        "let me inspect",
+        "let me check",
+        "let me look",
+        "let me read",
+        "let me search",
+        "let me peek",
+        "let me also peek",
+        "i'll inspect",
+        "i'll check",
+        "i'll look",
+        "i'll read",
+        "i'll search",
+        "i will inspect",
+        "i will check",
+        "i will look",
+        "i will read",
+        "i will search",
+        "i'm going to inspect",
+        "i'm going to check",
+        "i'm going to look",
+        "i'm going to read",
+        "i need to inspect",
+        "i need to check",
+    ]
+    .iter()
+    .any(|needle| lower.contains(needle));
+
+    has_intent && (lower.ends_with(':') || lower.ends_with('.') || lower.ends_with("first"))
+}
+
 fn denied_message(reason: &str) -> String {
     json!({ "ok": false, "error": reason }).to_string()
 }
@@ -685,15 +748,14 @@ async fn stream_response(
                 // Stream ended normally
                 break;
             }
-            Err(_e) => {
+            Err(error) => {
                 consecutive_errors += 1;
                 if consecutive_errors >= MAX_CONSECUTIVE_ERRORS {
-                    // Log the error but don't fail the whole request
-                    eprintln!(
-                        "\n[warning: stream interrupted after {} consecutive errors]",
-                        consecutive_errors
+                    bail!(
+                        "stream interrupted while reading provider response after {} consecutive errors: {}",
+                        consecutive_errors,
+                        error
                     );
-                    break;
                 }
                 // Try to continue reading - transient network hiccups happen
                 continue;
@@ -972,4 +1034,18 @@ mod tests {
                 .contains("Do not call tools again")
         );
     }
+
+    #[test]
+    fn detects_unfinished_tool_intent() {
+        assert!(looks_like_unfinished_tool_intent(
+            "Let me inspect the workspace structure more thoroughly."
+        ));
+        assert!(looks_like_unfinished_tool_intent(
+            "Let me also peek at the key files to understand the project:"
+        ));
+        assert!(!looks_like_unfinished_tool_intent(
+            "The project is a Rust CLI with an npm wrapper."
+        ));
+        assert!(!looks_like_unfinished_tool_intent(""));
+    }
 }

package/src/tools.rs

@@ -24,7 +24,9 @@ const MAX_COMMAND_TIMEOUT_SECS: u64 = 300;
 pub fn guidance(include_write: bool) -> String {
     let mut text = String::from(
         "You can use Anveesa tools to inspect the workspace: list directories, find files by name, \
-search text, read capped file snippets, and do a basic public web lookup. Prefer tools over guessing.",
+search text, read capped file snippets, and do a basic public web lookup. Prefer tools over guessing. \
+If you need to inspect, read, list, search, or check something, call the relevant tool immediately; \
+do not end a response by saying you will inspect something later.",
     );
     if include_write {
         text.push_str(
@@ -58,6 +60,19 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
     let args: Value = serde_json::from_str(arguments).unwrap_or(Value::Null);
     let field = |key: &str| args.get(key).and_then(Value::as_str).unwrap_or("");
     match name {
+        "list_dir" => format!("list directory {}", field("path").if_empty(".")),
+        "find_files" => format!(
+            "find files matching `{}` under {}",
+            field("query"),
+            field("root").if_empty(".")
+        ),
+        "search_text" => format!(
+            "search text `{}` under {}",
+            field("query"),
+            field("root").if_empty(".")
+        ),
+        "read_file" => format!("read file {}", field("path")),
+        "web_search" => format!("web search `{}`", field("query")),
         "create_dir" => format!("create directory {}", field("path")),
         "write_file" => format!("write file {}", field("path")),
         "edit_file" => format!("edit file {}", field("path")),
@@ -66,6 +81,16 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
     }
 }
 
+trait EmptyStrExt {
+    fn if_empty(self, fallback: &'static str) -> Self;
+}
+
+impl<'a> EmptyStrExt for &'a str {
+    fn if_empty(self, fallback: &'static str) -> Self {
+        if self.is_empty() { fallback } else { self }
+    }
+}
+
 pub fn definitions(include_write: bool) -> Vec<Value> {
     let mut definitions = vec![
         json!({
@@ -846,6 +871,23 @@ mod tests {
 
     #[test]
     fn describes_calls_for_confirmation() {
+        assert_eq!(describe_call("list_dir", r#"{}"#), "list directory .");
+        assert_eq!(
+            describe_call("find_files", r#"{"query":"Cargo","root":"src"}"#),
+            "find files matching `Cargo` under src"
+        );
+        assert_eq!(
+            describe_call("search_text", r#"{"query":"TODO"}"#),
+            "search text `TODO` under ."
+        );
+        assert_eq!(
+            describe_call("read_file", r#"{"path":"README.md"}"#),
+            "read file README.md"
+        );
+        assert_eq!(
+            describe_call("web_search", r#"{"query":"rust termios"}"#),
+            "web search `rust termios`"
+        );
         assert_eq!(
             describe_call("create_dir", r#"{"path":"hello"}"#),
             "create directory hello"
@@ -863,6 +905,7 @@ mod tests {
     #[test]
     fn guidance_mentions_writes_only_when_enabled() {
         assert!(!guidance(false).contains("write_file"));
+        assert!(guidance(false).contains("call the relevant tool immediately"));
         assert!(guidance(true).contains("create_dir"));
         assert!(guidance(true).contains("write_file"));
     }