anveesa 0.4.5 → 0.4.6

package/Cargo.lock

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

package/Cargo.toml

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

package/package.json

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

@@ -2516,10 +2516,40 @@ fn workspace_context_for(cwd: &Path) -> Result<String> {
                 }
             }
         }
+        // Recent commits give the model useful project history context
+        if let Some(log) = git_output(&cwd, ["log", "--oneline", "--decorate", "-8"]) {
+            if !log.is_empty() {
+                context.push_str("- recent_commits:\n");
+                for line in log.lines() {
+                    context.push_str(&format!("  {line}\n"));
+                }
+            }
+        }
     } else {
         context.push_str("- git: not inside a git repository\n");
     }
 
+    // Project metadata from package.json / Cargo.toml
+    if let Ok(raw) = fs::read_to_string(cwd.join("package.json")) {
+        if let Ok(pkg) = serde_json::from_str::<serde_json::Value>(&raw) {
+            if let Some(name) = pkg["name"].as_str() {
+                context.push_str(&format!("- project_name: {name}\n"));
+            }
+            if let Some(ver) = pkg["version"].as_str() {
+                context.push_str(&format!("- project_version: {ver}\n"));
+            }
+            if let Some(desc) = pkg["description"].as_str() {
+                context.push_str(&format!("- project_description: {desc}\n"));
+            }
+        }
+    } else if let Ok(raw) = fs::read_to_string(cwd.join("Cargo.toml")) {
+        for line in raw.lines().take(15) {
+            if line.starts_with("name") || line.starts_with("version") || line.starts_with("description") {
+                context.push_str(&format!("- cargo_{}\n", line.trim()));
+            }
+        }
+    }
+
     let entries = directory_entries(cwd)?;
     if entries.is_empty() {
         context.push_str("- directory_entries: empty\n");

package/src/tools.rs

@@ -60,7 +60,7 @@ pub fn is_write_tool(name: &str) -> bool {
     matches!(
         name,
         "create_dir" | "write_file" | "edit_file" | "run_command"
-        | "delete_file" | "move_file" | "copy_file"
+        | "delete_file" | "move_file" | "copy_file" | "patch_file"
         | "git_commit" | "git_stash" | "git_branch"
     )
 }
@@ -105,6 +105,7 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
             else { "git branch".to_string() }
         }
         "git_commit"  => format!("git commit {}", field("message")),
+        "patch_file"  => format!("patch file {}", field("path")),
         "delete_file" => format!("delete {}", field("path")),
         "move_file"   => format!("move {} → {}", field("from"), field("to")),
         "copy_file"   => format!("copy {} → {}", field("from"), field("to")),
@@ -382,6 +383,32 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                     }
                 }
             }),
+            json!({
+                "type": "function",
+                "function": {
+                    "name": "patch_file",
+                    "description": "Apply multiple targeted replacements to a file in one call. Each patch must match exactly once. Prefer this over multiple edit_file calls when editing the same file.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "path": { "type": "string", "description": "File path." },
+                            "patches": {
+                                "type": "array",
+                                "description": "Ordered list of replacements to apply sequentially.",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "old_string": { "type": "string", "description": "Unique text to replace." },
+                                        "new_string": { "type": "string", "description": "Replacement text." }
+                                    },
+                                    "required": ["old_string", "new_string"]
+                                }
+                            }
+                        },
+                        "required": ["path", "patches"]
+                    }
+                }
+            }),
             json!({
                 "type": "function",
                 "function": {
@@ -492,6 +519,7 @@ pub async fn run(name: &str, arguments: &str) -> String {
         "git_stash"   => git_stash(arguments).await,
         "git_branch"  => git_branch(arguments).await,
         "git_commit"  => git_commit(arguments).await,
+        "patch_file"  => patch_file(arguments).await,
         "delete_file" => delete_file(arguments).await,
         "move_file"   => move_file(arguments).await,
         "copy_file"   => copy_file(arguments).await,
@@ -684,7 +712,25 @@ async fn web_search(arguments: &str) -> Result<Value> {
     let query = args.query.trim();
     if query.is_empty() { bail!("query is empty"); }
 
-    // Try DuckDuckGo instant-answer API first
+    // 1. Brave Search API (best quality, free tier available)
+    if let Ok(key) = std::env::var("BRAVE_SEARCH_API_KEY") {
+        if let Ok(results) = search_brave(query, &key).await {
+            if !results.is_empty() {
+                return Ok(json!({ "ok": true, "query": query, "source": "brave", "results": results }));
+            }
+        }
+    }
+
+    // 2. Serper.dev (Google results via API)
+    if let Ok(key) = std::env::var("SERPER_API_KEY") {
+        if let Ok(results) = search_serper(query, &key).await {
+            if !results.is_empty() {
+                return Ok(json!({ "ok": true, "query": query, "source": "serper", "results": results }));
+            }
+        }
+    }
+
+    // 3. DuckDuckGo instant-answer API (no key needed, limited results)
     let api_url = format!(
         "https://api.duckduckgo.com/?q={}&format=json&no_html=1&skip_disambig=1",
         percent_encode(query)
@@ -705,16 +751,13 @@ async fn web_search(arguments: &str) -> Result<Value> {
         }
     }
 
-    // If instant answer had no results, try DuckDuckGo lite (text-only, more reliable)
+    // 4. DuckDuckGo lite HTML fallback
     if results.is_empty() {
-        let lite_url = format!(
-            "https://lite.duckduckgo.com/lite/?q={}",
-            percent_encode(query)
-        );
+        let lite_url = format!("https://lite.duckduckgo.com/lite/?q={}", percent_encode(query));
         if let Ok(resp) = http_client()
             .get(&lite_url)
             .header("Accept-Language", "en-US,en;q=0.9")
-            .header("User-Agent", "Mozilla/5.0 (compatible; anveesa-cli)")
+            .header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36")
             .send()
             .await
         {
@@ -725,7 +768,58 @@ async fn web_search(arguments: &str) -> Result<Value> {
     }
 
     results.truncate(10);
-    Ok(json!({ "ok": true, "query": query, "results": results }))
+    let source = if results.is_empty() { "none" } else { "duckduckgo" };
+    Ok(json!({ "ok": true, "query": query, "source": source, "results": results }))
+}
+
+async fn search_brave(query: &str, api_key: &str) -> Result<Vec<Value>> {
+    let url = format!(
+        "https://api.search.brave.com/res/v1/web/search?q={}&count=10&search_lang=en",
+        percent_encode(query)
+    );
+    let resp = http_client()
+        .get(&url)
+        .header("Accept", "application/json")
+        .header("Accept-Encoding", "gzip")
+        .header("X-Subscription-Token", api_key)
+        .send()
+        .await
+        .context("Brave Search request failed")?;
+
+    if !resp.status().is_success() {
+        bail!("Brave Search HTTP {}", resp.status());
+    }
+    let body: Value = resp.json().await.context("failed to parse Brave response")?;
+    let results = body["web"]["results"].as_array().cloned().unwrap_or_default();
+    Ok(results.into_iter().filter_map(|r| {
+        let title = r["title"].as_str()?;
+        let url   = r["url"].as_str()?;
+        let snip  = r["description"].as_str().unwrap_or("");
+        Some(json!({ "title": title, "snippet": snip, "url": url }))
+    }).collect())
+}
+
+async fn search_serper(query: &str, api_key: &str) -> Result<Vec<Value>> {
+    let resp = http_client()
+        .post("https://google.serper.dev/search")
+        .header("X-API-KEY", api_key)
+        .header("Content-Type", "application/json")
+        .json(&json!({ "q": query, "num": 10 }))
+        .send()
+        .await
+        .context("Serper request failed")?;
+
+    if !resp.status().is_success() {
+        bail!("Serper HTTP {}", resp.status());
+    }
+    let body: Value = resp.json().await.context("failed to parse Serper response")?;
+    let results = body["organic"].as_array().cloned().unwrap_or_default();
+    Ok(results.into_iter().filter_map(|r| {
+        let title = r["title"].as_str()?;
+        let url   = r["link"].as_str()?;
+        let snip  = r["snippet"].as_str().unwrap_or("");
+        Some(json!({ "title": title, "snippet": snip, "url": url }))
+    }).collect())
 }
 
 /// Scrape DuckDuckGo lite (text-only) results page.
@@ -1223,6 +1317,37 @@ async fn write_file(arguments: &str) -> Result<Value> {
     }))
 }
 
+async fn patch_file(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Hunk { old_string: String, new_string: String }
+    #[derive(Deserialize)]
+    struct Args { path: String, patches: Vec<Hunk> }
+
+    let args: Args = parse_args(arguments)?;
+    let path = resolve_writable_path(&args.path)?;
+    if !path.is_file() { bail!("{} is not a file", path.display()); }
+    if is_sensitive_path(&path) { bail!("refusing to edit sensitive file"); }
+    if args.patches.is_empty() { bail!("patches array is empty"); }
+
+    let mut content = fs::read_to_string(&path)
+        .with_context(|| format!("failed to read {}", path.display()))?;
+
+    for (i, hunk) in args.patches.iter().enumerate() {
+        if hunk.old_string.is_empty() { bail!("patch[{i}]: old_string must not be empty"); }
+        if hunk.old_string == hunk.new_string { bail!("patch[{i}]: old_string and new_string are identical"); }
+        let count = content.matches(&hunk.old_string).count();
+        match count {
+            0 => bail!("patch[{i}]: old_string not found in {}", path.display()),
+            1 => {}
+            n => bail!("patch[{i}]: old_string appears {n} times — make it unique"),
+        }
+        content = content.replacen(&hunk.old_string, &hunk.new_string, 1);
+    }
+
+    fs::write(&path, &content).with_context(|| format!("failed to write {}", path.display()))?;
+    Ok(json!({ "ok": true, "path": path.display().to_string(), "patches_applied": args.patches.len() }))
+}
+
 async fn edit_file(arguments: &str) -> Result<Value> {
     let args: EditFileArgs = parse_args(arguments)?;
     let path = resolve_writable_path(&args.path)?;

package/src/tui.rs

@@ -87,8 +87,9 @@ pub struct App {
     streaming_started_at: Option<Instant>,
     tool_started_at: Option<Instant>,
     unread_count: usize,
-    // files/dirs already read this session — injected into workspace context each turn
     seen_paths: std::collections::BTreeSet<String>,
+    // undo stack: (path, old_content) — None content means file didn't exist before
+    undo_stack: Vec<(String, Option<String>)>,
 
     // input
     input: String,
@@ -176,6 +177,7 @@ impl App {
             tool_started_at: None,
             unread_count: 0,
             seen_paths: std::collections::BTreeSet::new(),
+            undo_stack: Vec::new(),
 
             input: String::new(),
             input_cursor: 0,
@@ -553,6 +555,7 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.usage = Usage::default();
             app.pending_image = None;
             app.seen_paths.clear();
+            app.undo_stack.clear();
             app.input.clear();
             app.input_cursor = 0;
             if let Some(path) = &app.session_path {
@@ -562,13 +565,20 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
         }
         "/help" => {
             app.messages.push(Msg::System(
-                "Commands: /clear  /compact  /copy  /export [path]\n\
-                 /model [name]  /provider [name]  /status  /exit\n\
+                "Commands:\n\
+                 /clear        reset conversation\n\
+                 /undo         restore last file changed by AI\n\
+                 /compact      drop old turns to free context\n\
+                 /copy         copy last response to clipboard\n\
+                 /export [path] save conversation as markdown\n\
+                 /model [name] · /provider [name] · /status · /exit\n\
                  \n\
                  Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
                  j/k scroll (when input empty)  PageUp/Dn scroll\n\
-                 Ctrl+W delete-word  Ctrl+U clear-line  Ctrl+V paste\n\
-                 Ctrl+M toggle scroll/select mode".into(),
+                 Ctrl+V paste (image or text)  Ctrl+M scroll/select mode\n\
+                 Ctrl+W delete-word  Ctrl+U clear line\n\
+                 \n\
+                 Search: set BRAVE_SEARCH_API_KEY or SERPER_API_KEY for better results".into(),
             ));
             app.input.clear();
             app.input_cursor = 0;
@@ -607,6 +617,27 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.input_cursor = 0;
             true
         }
+        "/undo" => {
+            match app.undo_stack.pop() {
+                None => app.messages.push(Msg::System("Nothing to undo.".into())),
+                Some((path, Some(old_content))) => {
+                    match std::fs::write(&path, &old_content) {
+                        Ok(()) => app.messages.push(Msg::System(format!("Restored {path}"))),
+                        Err(e) => app.messages.push(Msg::Error(format!("Undo failed: {e}"))),
+                    }
+                }
+                Some((path, None)) => {
+                    // File was newly created — delete it
+                    match std::fs::remove_file(&path) {
+                        Ok(()) => app.messages.push(Msg::System(format!("Deleted {path} (undo create)"))),
+                        Err(e) => app.messages.push(Msg::Error(format!("Undo failed: {e}"))),
+                    }
+                }
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
         "/compact" => {
             // Keep only the last 10 turns, drop older history to free context
             let keep = 10usize;
@@ -838,6 +869,10 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
         TuiEvent::FileOp { verb, path, added, removed, diff } => {
             flush_streaming_buf(app);
             commit_pending_tool(app, true);
+            // Snapshot for /undo (read current content before the write is reflected in messages)
+            let old_content = std::fs::read_to_string(&path).ok();
+            if app.undo_stack.len() >= 20 { app.undo_stack.remove(0); }
+            app.undo_stack.push((path.clone(), old_content));
             app.messages.push(Msg::FileOp { verb, path, added, removed, diff });
         }
         TuiEvent::Confirm { summary, reply } => {
@@ -950,6 +985,25 @@ fn finish_turn(app: &mut App) {
     if !app.history.is_empty() {
         app.messages.push(Msg::Separator);
     }
+    // Auto-compact when history exceeds ~40K estimated tokens (1 char ≈ 0.25 tokens)
+    auto_compact_if_needed(app);
+}
+
+fn auto_compact_if_needed(app: &mut App) {
+    const TOKEN_THRESHOLD: usize = 40_000;
+    let estimated: usize = app.history.iter().map(|m| m.content.len() / 4).sum();
+    if estimated < TOKEN_THRESHOLD || app.history.len() < 8 {
+        return;
+    }
+    // Drop oldest quarter of turns (keep at least 4 turns)
+    let total_turns = app.history.len() / 2;
+    let drop_turns = (total_turns / 4).max(1).min(total_turns.saturating_sub(4));
+    let drop_msgs = drop_turns * 2;
+    app.history.drain(..drop_msgs);
+    app.seen_paths.clear();
+    app.messages.push(Msg::System(format!(
+        "Auto-compacted: dropped {drop_turns} older turn(s) (~{estimated}K est. tokens). Use /compact for manual control."
+    )));
 }
 
 // ── Rendering ─────────────────────────────────────────────────────────────────
@@ -975,7 +1029,11 @@ fn render(frame: &mut Frame, app: &mut App) {
 
 fn render_header(frame: &mut Frame, area: Rect, app: &App) {
     let version = env!("CARGO_PKG_VERSION");
-    let token_str = if app.usage.total_tokens > 0 {
+    let token_str = if app.mode == Mode::Streaming && !app.streaming_buf.is_empty() {
+        // Live estimate: chars / 4 ≈ tokens
+        let live = app.streaming_buf.len() / 4;
+        format!("  → {live}t")
+    } else if app.usage.total_tokens > 0 {
         format!("  {}↓ {}↑", app.usage.prompt_tokens, app.usage.completion_tokens)
     } else {
         String::new()