anveesa 0.4.7 → 0.5.1

package/Cargo.lock

@@ -60,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.4.7"
+version = "0.5.1"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.4.7",
+  "version": "0.5.1",
   "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/provider/openai_compatible.rs

@@ -181,17 +181,46 @@ pub async fn ask(
         tool_rounds += 1;
 
         messages.push(assistant_tool_message(&state));
-        for call in &state.tool_calls {
-            if tools::is_write_tool(&call.name) {
-                any_write_tool_used = true;
+
+        let all_readonly = state.tool_calls.len() > 1
+            && state.tool_calls.iter().all(|c| {
+                !tools::is_write_tool(&c.name)
+                    && c.name != "set_plan"
+                    && c.name != "complete_task"
+            });
+
+        if all_readonly {
+            let mut handles = Vec::with_capacity(state.tool_calls.len());
+            for call in state.tool_calls.iter().cloned() {
+                let ev = events.clone();
+                let mcp_arc = request.mcp.clone();
+                handles.push(tokio::spawn(dispatch_read_only_tool(call, ev, mcp_arc)));
+            }
+            for (i, handle) in handles.into_iter().enumerate() {
+                let (id, name, content) = handle.await.unwrap_or_else(|_| {
+                    let c = &state.tool_calls[i];
+                    (c.id.clone(), c.name.clone(), json!({"ok":false,"error":"task panicked"}).to_string())
+                });
+                messages.push(json!({
+                    "role": "tool",
+                    "tool_call_id": id,
+                    "name": name,
+                    "content": content,
+                }));
+            }
+        } else {
+            for call in &state.tool_calls {
+                if tools::is_write_tool(&call.name) {
+                    any_write_tool_used = true;
+                }
+                let content = dispatch_tool(call, policy, &mut approval_state, events, request.mcp.as_deref()).await;
+                messages.push(json!({
+                    "role": "tool",
+                    "tool_call_id": call.id,
+                    "name": call.name,
+                    "content": content,
+                }));
             }
-            let content = dispatch_tool(call, policy, &mut approval_state, events, request.mcp.as_deref()).await;
-            messages.push(json!({
-                "role": "tool",
-                "tool_call_id": call.id,
-                "name": call.name,
-                "content": content,
-            }));
         }
 
         let _ = events.send(StreamEvent::Status {
@@ -221,6 +250,35 @@ struct ToolApprovalState {
     call_counts: std::collections::HashMap<(String, String), usize>,
 }
 
+async fn dispatch_read_only_tool(
+    call: PartialToolCall,
+    events: UnboundedSender<StreamEvent>,
+    mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
+) -> (String, String, String) {
+    if tools::is_mcp_tool(&call.name) {
+        let summary = format!("mcp {}", &call.name[5..]);
+        let _ = events.send(StreamEvent::ToolCall { summary: summary.clone() });
+        let started = Instant::now();
+        let result = if let Some(m) = mcp.as_deref() {
+            m.call(&call.name, &call.arguments).await
+                .unwrap_or_else(|| json!({ "ok": false, "error": "server not found" }).to_string())
+        } else {
+            json!({ "ok": false, "error": "MCP not configured" }).to_string()
+        };
+        let (ok, err) = parse_tool_result_status(&result);
+        let _ = events.send(StreamEvent::ToolResult { summary, ok, elapsed_ms: started.elapsed().as_millis(), error: err });
+        return (call.id, call.name, result);
+    }
+
+    let summary = tools::describe_call(&call.name, &call.arguments);
+    let _ = events.send(StreamEvent::ToolCall { summary: summary.clone() });
+    let started = Instant::now();
+    let result = tools::run(&call.name, &call.arguments).await;
+    let (ok, err) = parse_tool_result_status(&result);
+    let _ = events.send(StreamEvent::ToolResult { summary, ok, elapsed_ms: started.elapsed().as_millis(), error: err });
+    (call.id, call.name, result)
+}
+
 async fn dispatch_tool(
     call: &PartialToolCall,
     policy: ApprovalPolicy,

package/src/tools.rs

@@ -258,12 +258,14 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
             "type": "function",
             "function": {
                 "name": "fetch_url",
-                "description": "Fetch the content of a URL and return it as plain text. Strips HTML tags automatically.",
+                "description": "Fetch a URL. mode=\"text\" (default): returns plain text with HTML tags stripped. mode=\"raw\": returns the full HTML source unchanged. mode=\"deep\": returns HTML source PLUS the full content of every linked CSS file (and JS bundles if include_js=true) in one call — use this when you need to inspect design tokens, Tailwind classes, color variables, font imports, or component structure without multiple round-trips.",
                 "parameters": {
                     "type": "object",
                     "properties": {
                         "url": { "type": "string", "description": "URL to fetch." },
-                        "max_chars": { "type": "integer", "description": "Max characters to return (default 40000)." }
+                        "mode": { "type": "string", "description": "\"text\" (default, strips HTML), \"raw\" (full HTML source), \"deep\" (HTML source + fetch all linked CSS assets, and JS if include_js=true)." },
+                        "max_chars": { "type": "integer", "description": "Max chars per resource (default 40000 for text, 60000 for raw/deep HTML, 30000 per asset)." },
+                        "include_js": { "type": "boolean", "description": "deep mode only — also fetch linked JS bundles (default false; bundles can be large)." }
                     },
                     "required": ["url"]
                 }
@@ -987,6 +989,84 @@ fn scrape_ddg_html(html: &str, max: usize) -> Vec<Value> {
     results
 }
 
+fn tag_attr(tag: &str, attr: &str) -> Option<String> {
+    let dq = format!("{attr}=\"");
+    let sq = format!("{attr}='");
+    if let Some(s) = tag.find(&dq) {
+        let start = s + dq.len();
+        tag[start..].find('"').map(|e| tag[start..start + e].to_string())
+    } else if let Some(s) = tag.find(&sq) {
+        let start = s + sq.len();
+        tag[start..].find('\'').map(|e| tag[start..start + e].to_string())
+    } else {
+        None
+    }
+}
+
+fn url_origin(url: &str) -> String {
+    let skip = if url.starts_with("https://") { 8 } else if url.starts_with("http://") { 7 } else { return String::new() };
+    let scheme = &url[..skip - 3];
+    let host = url[skip..].split('/').next().unwrap_or("");
+    format!("{scheme}://{host}")
+}
+
+fn url_base_path(url: &str) -> String {
+    let skip = if url.starts_with("https://") { 8 } else if url.starts_with("http://") { 7 } else { return "/".to_string() };
+    let rest = &url[skip..];
+    let path = rest.split_once('/').map(|(_, p)| format!("/{p}")).unwrap_or_default();
+    path.rfind('/').map(|i| path[..i + 1].to_string()).unwrap_or_else(|| "/".to_string())
+}
+
+fn resolve_asset_url(href: &str, origin: &str, base_path: &str) -> Option<String> {
+    let h = href.trim();
+    if h.is_empty() { return None; }
+    if h.starts_with("http://") || h.starts_with("https://") {
+        Some(h.to_string())
+    } else if h.starts_with("//") {
+        let scheme = if origin.starts_with("https") { "https" } else { "http" };
+        Some(format!("{scheme}:{h}"))
+    } else if h.starts_with('/') {
+        if origin.is_empty() { None } else { Some(format!("{origin}{h}")) }
+    } else if !origin.is_empty() {
+        Some(format!("{origin}{base_path}{h}"))
+    } else {
+        None
+    }
+}
+
+fn extract_asset_urls(html: &str, base_url: &str, include_js: bool) -> Vec<String> {
+    let origin = url_origin(base_url);
+    let base_path = url_base_path(base_url);
+    let mut urls: Vec<String> = Vec::new();
+    let mut pos = 0;
+
+    while pos < html.len() {
+        let Some(lt) = html[pos..].find('<') else { break };
+        let abs = pos + lt;
+        let Some(gt) = html[abs..].find('>') else { break };
+        let tag = &html[abs..abs + gt + 1];
+        let tag_lo = tag.to_lowercase();
+        pos = abs + gt + 1;
+
+        let href = if tag_lo.starts_with("<link") {
+            let rel = tag_attr(&tag_lo, "rel").unwrap_or_default();
+            let as_ = tag_attr(&tag_lo, "as").unwrap_or_default();
+            if rel == "stylesheet" || (rel == "preload" && as_ == "style") {
+                tag_attr(tag, "href").or_else(|| tag_attr(&tag_lo, "href"))
+            } else { None }
+        } else if include_js && tag_lo.starts_with("<script") {
+            tag_attr(tag, "src").or_else(|| tag_attr(&tag_lo, "src"))
+        } else { None };
+
+        if let Some(h) = href {
+            if let Some(resolved) = resolve_asset_url(&h, &origin, &base_path) {
+                if !urls.contains(&resolved) { urls.push(resolved); }
+            }
+        }
+    }
+    urls
+}
+
 fn extract_attr<'a>(html: &'a str, attr: &str) -> Option<&'a str> {
     let key = format!("{attr}=\"");
     let start = html.find(&key)? + key.len();
@@ -1027,14 +1107,18 @@ async fn fetch_url(arguments: &str) -> Result<Value> {
         url: String,
         #[serde(default)]
         max_chars: Option<usize>,
+        #[serde(default)]
+        mode: Option<String>,
+        #[serde(default)]
+        include_js: Option<bool>,
     }
     let args: Args = parse_args(arguments)?;
-    let url = args.url.trim();
+    let url = args.url.trim().to_string();
     if url.is_empty() { bail!("url is required"); }
-    let max_chars = args.max_chars.unwrap_or(40_000);
+    let mode = args.mode.as_deref().unwrap_or("text").to_string();
 
     let response = http_client()
-        .get(url)
+        .get(&url)
         .send()
         .await
         .with_context(|| format!("failed to fetch {url}"))?;
@@ -1050,23 +1134,98 @@ async fn fetch_url(arguments: &str) -> Result<Value> {
         .to_string();
 
     let body = response.text().await.context("failed to read response body")?;
-    let text = if content_type.contains("html") || content_type.contains("xml") {
-        html_to_text(&body)
-    } else {
-        body
-    };
 
-    let char_count = text.chars().count();
-    let truncated = char_count > max_chars;
-    let text: String = text.chars().take(max_chars).collect();
+    match mode.as_str() {
+        "raw" => {
+            let max = args.max_chars.unwrap_or(80_000);
+            let char_count = body.chars().count();
+            let truncated = char_count > max;
+            let html: String = body.chars().take(max).collect();
+            Ok(json!({
+                "ok": true,
+                "url": url,
+                "content_type": content_type,
+                "html": html,
+                "char_count": char_count,
+                "truncated": truncated,
+            }))
+        }
+        "deep" => {
+            const ASSET_MAX: usize = 30_000;
+            const MAX_ASSETS: usize = 10;
+            let html_max = args.max_chars.unwrap_or(60_000);
+            let include_js = args.include_js.unwrap_or(false);
+
+            let asset_urls: Vec<String> = extract_asset_urls(&body, &url, include_js)
+                .into_iter()
+                .take(MAX_ASSETS)
+                .collect();
 
-    Ok(json!({
-        "ok": true,
-        "url": url,
-        "content_type": content_type,
-        "text": text,
-        "truncated": truncated,
-    }))
+            let mut handles = Vec::new();
+            for asset_url in asset_urls {
+                handles.push(tokio::spawn(async move {
+                    let Ok(resp) = http_client().get(&asset_url).send().await else { return None; };
+                    if !resp.status().is_success() { return None; }
+                    let ct = resp.headers()
+                        .get("content-type")
+                        .and_then(|v| v.to_str().ok())
+                        .unwrap_or("")
+                        .to_string();
+                    let Ok(content) = resp.text().await else { return None; };
+                    let kind = if ct.contains("css") || asset_url.ends_with(".css") { "css" }
+                        else if ct.contains("javascript") || asset_url.contains(".js") { "js" }
+                        else { "other" };
+                    let char_count = content.chars().count();
+                    let truncated = char_count > ASSET_MAX;
+                    let trimmed: String = content.chars().take(ASSET_MAX).collect();
+                    Some(json!({
+                        "url": asset_url,
+                        "type": kind,
+                        "char_count": char_count,
+                        "truncated": truncated,
+                        "content": trimmed,
+                    }))
+                }));
+            }
+
+            let mut assets: Vec<Value> = Vec::new();
+            for h in handles {
+                if let Ok(Some(a)) = h.await { assets.push(a); }
+            }
+
+            let html_chars = body.chars().count();
+            let html_truncated = html_chars > html_max;
+            let html: String = body.chars().take(html_max).collect();
+
+            Ok(json!({
+                "ok": true,
+                "url": url,
+                "html": html,
+                "html_chars": html_chars,
+                "html_truncated": html_truncated,
+                "assets": assets,
+            }))
+        }
+        _ => {
+            // "text" mode — current behaviour
+            let max = args.max_chars.unwrap_or(40_000);
+            let text = if content_type.contains("html") || content_type.contains("xml") {
+                html_to_text(&body)
+            } else {
+                body
+            };
+            let char_count = text.chars().count();
+            let truncated = char_count > max;
+            let text: String = text.chars().take(max).collect();
+            Ok(json!({
+                "ok": true,
+                "url": url,
+                "content_type": content_type,
+                "text": text,
+                "truncated": truncated,
+            }))
+        }
+    }
 }
 
 fn html_to_text(html: &str) -> String {

package/src/tui.rs

@@ -32,7 +32,7 @@ pub enum TuiEvent {
     ToolDone { summary: String, ok: bool },
     // diff: Vec<(is_add, line)>
     FileOp { verb: String, path: String, added: usize, removed: usize, diff: Vec<(bool, String)> },
-    Confirm { summary: String, reply: oneshot::Sender<ApprovalDecision> },
+    Confirm { summary: String, diff: Vec<(bool, String)>, reply: oneshot::Sender<ApprovalDecision> },
     Usage(Usage),
     Error(String),
     PlanSet(Vec<String>),
@@ -60,6 +60,7 @@ struct PendingTool {
 #[derive(Debug)]
 struct PendingConfirm {
     summary: String,
+    diff: Vec<(bool, String)>,
     reply: oneshot::Sender<ApprovalDecision>,
 }
 
@@ -110,6 +111,7 @@ pub struct App {
     provider: String,
     model: String,
     usage: Usage,
+    session_cost_usd: f64,
     cwd: String,
 
     // mode
@@ -195,6 +197,7 @@ impl App {
             provider,
             model,
             usage: Usage::default(),
+            session_cost_usd: 0.0,
             cwd,
 
             mode: Mode::Input,
@@ -816,13 +819,15 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
                     TuiEvent::FileOp { verb, path, added, removed, diff }
                 }
                 StreamEvent::Confirm { preview, reply } => {
-                    let summary = match &preview {
-                        ToolConfirmPreview::FileOp { verb, path, added, removed, .. } =>
+                    let (summary, diff) = match preview {
+                        ToolConfirmPreview::FileOp { verb, path, added, removed, diff, .. } => (
                             format!("{verb} {path}  +{added} -{removed}"),
-                        ToolConfirmPreview::CreateDir { path } => format!("mkdir {path}"),
-                        ToolConfirmPreview::Generic { summary } => summary.clone(),
+                            diff.into_iter().map(|dl| (matches!(dl.kind, crate::provider::DiffKind::Add), dl.text)).collect(),
+                        ),
+                        ToolConfirmPreview::CreateDir { path } => (format!("mkdir {path}"), vec![]),
+                        ToolConfirmPreview::Generic { summary } => (summary, vec![]),
                     };
-                    TuiEvent::Confirm { summary, reply }
+                    TuiEvent::Confirm { summary, diff, reply }
                 }
                 StreamEvent::Usage(u) => TuiEvent::Usage(u),
                 StreamEvent::PlanSet { tasks } => TuiEvent::PlanSet(tasks),
@@ -875,10 +880,10 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.undo_stack.push((path.clone(), old_content));
             app.messages.push(Msg::FileOp { verb, path, added, removed, diff });
         }
-        TuiEvent::Confirm { summary, reply } => {
+        TuiEvent::Confirm { summary, diff, reply } => {
             flush_streaming_buf(app);
             commit_pending_tool(app, true);
-            app.confirm = Some(PendingConfirm { summary, reply });
+            app.confirm = Some(PendingConfirm { summary, diff, reply });
             app.mode = Mode::Confirming;
         }
         TuiEvent::Usage(u) => {
@@ -887,6 +892,11 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.usage.total_tokens += u.total_tokens;
             app.usage.cache_read_tokens += u.cache_read_tokens;
             app.usage.cache_write_tokens += u.cache_write_tokens;
+            let (in_price, out_price, cr_price, cw_price) = model_pricing(&app.model);
+            app.session_cost_usd += (u.prompt_tokens as f64 - u.cache_read_tokens as f64 - u.cache_write_tokens as f64).max(0.0) * in_price / 1_000_000.0
+                + u.completion_tokens as f64 * out_price / 1_000_000.0
+                + u.cache_read_tokens as f64 * cr_price / 1_000_000.0
+                + u.cache_write_tokens as f64 * cw_price / 1_000_000.0;
             finish_turn(app);
         }
         TuiEvent::Error(msg) => {
@@ -977,6 +987,11 @@ fn finish_turn(app: &mut App) {
             }
         }
     }
+    if let Some(started) = app.streaming_started_at {
+        if started.elapsed() > Duration::from_secs(8) {
+            send_desktop_notification("anveesa", "Task complete");
+        }
+    }
     app.mode = Mode::Input;
     app.tool_status.clear();
     app.streaming_started_at = None;
@@ -1013,11 +1028,18 @@ fn render(frame: &mut Frame, app: &mut App) {
     let input_lines = app.input.lines().count().max(1);
     let input_height = (input_lines as u16).clamp(1, 5) + 2;
 
+    let status_height = if app.mode == Mode::Confirming {
+        let diff_rows = app.confirm.as_ref().map(|c| c.diff.len().min(20) as u16).unwrap_or(0);
+        1 + diff_rows
+    } else {
+        1
+    };
+
     let chunks = Layout::vertical([
         Constraint::Length(1),
         Constraint::Min(3),
         Constraint::Length(input_height),
-        Constraint::Length(1),
+        Constraint::Length(status_height),
     ])
     .split(area);
 
@@ -1027,6 +1049,55 @@ fn render(frame: &mut Frame, app: &mut App) {
     render_status(frame, chunks[3], app);
 }
 
+/// Returns (input_$/M, output_$/M, cache_read_$/M, cache_write_$/M).
+fn model_pricing(model: &str) -> (f64, f64, f64, f64) {
+    let m = model.to_lowercase();
+    if m.contains("claude") {
+        if m.contains("opus") {
+            (15.0, 75.0, 1.5, 18.75)
+        } else if m.contains("sonnet") {
+            (3.0, 15.0, 0.3, 3.75)
+        } else if m.contains("haiku") {
+            if m.contains("3-5") || m.contains("3.5") { (0.25, 1.25, 0.03, 0.30) }
+            else { (0.80, 4.0, 0.08, 1.0) }
+        } else {
+            (3.0, 15.0, 0.3, 3.75)
+        }
+    } else if m.contains("gpt-4o-mini") {
+        (0.15, 0.60, 0.075, 0.0)
+    } else if m.contains("gpt-4o") {
+        (2.50, 10.0, 1.25, 0.0)
+    } else if m.contains("gpt-4-turbo") || m.contains("gpt-4-1106") {
+        (10.0, 30.0, 0.0, 0.0)
+    } else if m.contains("gpt-3.5") {
+        (0.50, 1.50, 0.0, 0.0)
+    } else if m.contains("gemini-1.5-flash") {
+        (0.075, 0.30, 0.0, 0.0)
+    } else if m.contains("gemini") {
+        (1.25, 5.0, 0.0, 0.0)
+    } else {
+        (1.0, 3.0, 0.0, 0.0)
+    }
+}
+
+fn send_desktop_notification(title: &str, body: &str) {
+    #[cfg(target_os = "macos")]
+    {
+        let script = format!(
+            "display notification \"{}\" with title \"{}\"",
+            body.replace('"', "'"),
+            title.replace('"', "'")
+        );
+        let _ = std::process::Command::new("osascript").args(["-e", &script]).spawn();
+    }
+    #[cfg(target_os = "linux")]
+    {
+        let _ = std::process::Command::new("notify-send").args([title, body]).spawn();
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    { let _ = (title, body); }
+}
+
 fn context_window_tokens(model: &str) -> usize {
     let m = model.to_lowercase();
     if m.contains("gemini") { 1_000_000 }
@@ -1061,7 +1132,19 @@ fn render_header(frame: &mut Frame, area: Rect, app: &App) {
         else if pct > 50 { Color::Rgb(229, 192, 123) }
         else { Color::Rgb(152, 195, 121) };
 
-    let left = format!(" anveesa v{version}{token_str}");
+    let cost_str = if app.session_cost_usd > 0.0 {
+        if app.session_cost_usd < 0.001 {
+            " <$0.001".to_string()
+        } else if app.session_cost_usd < 1.0 {
+            format!(" ~${:.3}", app.session_cost_usd)
+        } else {
+            format!(" ~${:.2}", app.session_cost_usd)
+        }
+    } else {
+        String::new()
+    };
+
+    let left = format!(" anveesa v{version}{token_str}{cost_str}");
     let mid = format!("  {bar}  ");
     let right = format!(" {} · {} ", app.provider, app.model);
     let gap = (area.width as usize)
@@ -1319,13 +1402,27 @@ fn render_input(frame: &mut Frame, area: Rect, app: &App) {
 fn render_status(frame: &mut Frame, area: Rect, app: &App) {
     match app.mode {
         Mode::Confirming => {
-            let summary = app.confirm.as_ref().map(|c| c.summary.as_str()).unwrap_or("?");
-            let text = format!(" ⚠  {summary}   [y] allow once   [a] allow all   [n] deny ");
-            frame.render_widget(
-                Paragraph::new(text)
-                    .style(Style::default().fg(Color::Black).bg(Color::Rgb(224, 108, 117))),
-                area,
-            );
+            let summary = app.confirm.as_ref().map(|c| c.summary.clone()).unwrap_or_default();
+            let diff = app.confirm.as_ref().map(|c| c.diff.clone()).unwrap_or_default();
+            let w = area.width as usize;
+            let mut lines: Vec<Line<'static>> = Vec::new();
+            for (is_add, line_text) in diff.iter().take(20) {
+                let (prefix, fg, bg) = if *is_add {
+                    ("+ ", Color::Rgb(152, 195, 121), Color::Rgb(20, 35, 20))
+                } else {
+                    ("- ", Color::Rgb(224, 108, 117), Color::Rgb(35, 20, 20))
+                };
+                let truncated: String = line_text.trim_end().chars().take(w.saturating_sub(3)).collect();
+                lines.push(Line::from(Span::styled(
+                    format!(" {prefix}{truncated}"),
+                    Style::default().fg(fg).bg(bg),
+                )));
+            }
+            lines.push(Line::from(Span::styled(
+                format!(" ⚠  {summary}   [y] allow once   [a] allow all   [n] deny "),
+                Style::default().fg(Color::Black).bg(Color::Rgb(224, 108, 117)),
+            )));
+            frame.render_widget(Paragraph::new(lines), area);
         }
         Mode::Streaming => {
             let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];