anveesa 0.5.2 → 0.6.0

package/Cargo.lock

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

package/Cargo.toml

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

package/README.md

@@ -1,302 +1,207 @@
-# Anveesa
+# anveesa
 
-Anveesa is a Rust terminal wrapper for AI providers. It gives you one command,
-`anveesa`, for interactive prompts and one-shot terminal requests.
+A fast, terminal-native AI coding assistant. One command — interactive TUI or one-shot prompts — backed by any OpenAI-compatible provider.
 
-## 📦 Publishing to npm
-
-Anveesa can be published as an npm package via a Node.js wrapper that invokes the Rust binary.
-
-### Install from npm
-
-```bash
-npm install -g anveesa
-```
-
-## Install locally
-
-```sh
-cargo install --path . --force
 ```
-
-## Quick start
-
-```sh
-anveesa config init
-export SUMOPOD_API_KEY="..."
-anveesa config set-model "your-sumopod-model"
+npm install -g anveesa
 anveesa
 ```
 
-Running `anveesa` with no prompt opens an interactive prompt for the default provider:
+---
 
-```text
-anveesa | provider: sumopod | model: kimi-k2.6
-state   | turns:0 | ctx:on | tools:on | writes:ask | memory:new
-commands| /clear reset | /exit quit
-approve | y once | a all for current turn | enter no
+## Features
 
-anveesa[0]>
-```
+- **Full TUI** — streaming output, diff previews on file edits, cost tracking, plan display
+- **28 built-in tools** — file ops, git, web search, deep-fetch, screenshot, notes, run commands
+- **Multi-provider** — Claude, GPT-4o, Gemini, DeepSeek, local Ollama, any OpenAI-compatible API
+- **Model routing** — `fast_model` for read-only tool rounds, main model for synthesis
+- **Parallel tools** — read-only tool calls run concurrently; write tools stay sequential for approval
+- **Approval flow** — every write/run tool shows a full diff preview; approve once, for the turn, or deny
+- **Multi-image paste** — ⌘V (macOS) / Ctrl+V to queue multiple clipboard images per turn
+- **Project memory** — `.anveesa.md` in your repo root is auto-injected into every session
+- **Path sandboxing** — write tools blocked outside the git root by default
+- **Conversation search** — Ctrl+R to search through all messages
 
-Interactive mode keeps running after each answer. It also keeps the conversation
-context for the same provider/model/system in the same working directory, even
-after restarting Anveesa. Use `/clear` to reset that context and `/exit` to
-return to the shell.
+---
 
-The prompt has full line editing, and your input history is remembered across
-sessions (stored next to the config as `history`). The active conversation is
-stored next to it as `session.json`. Use the up/down arrows to recall previous
-prompts.
+## Install
 
-To include an image, copy it to the clipboard and run `/attach` before your
-question:
+```bash
+# npm (recommended — downloads prebuilt binary)
+npm install -g anveesa
 
-```text
-❯ /attach
-  [image attached for the next message]
-❯ what is in this screenshot?
+# Cargo (builds from source)
+cargo install --path .
 ```
 
-You can also attach an image file directly:
+---
 
-```text
-❯ /attach ./screenshot.png
-❯ explain this UI
-```
+## Quick start
 
-Image input works with OpenAI-compatible providers and models that support
-vision. Terminals do not paste image pixels into the text prompt itself, so use
-`/attach` instead of pressing paste and expecting the image to appear inline.
+```bash
+# 1. Initialize config
+anveesa config init
 
-`ctx:on` means Anveesa sends lightweight terminal context with each request:
-current directory, parent directory, git root/branch/status when available, and
-a capped directory listing. This lets the model answer questions like "where are
-you?" using the terminal workspace instead of guessing.
+# 2. Set your API key
+export ANTHROPIC_API_KEY="sk-ant-..."
+export OPENAI_API_KEY="sk-..."
 
-`tools:on` means OpenAI-compatible providers can ask Anveesa to inspect the
-workspace: list directories, find files by name, search text, read capped file
-snippets, and do a basic web lookup. The tools can inspect paths outside the
-current project, but obvious secret files such as SSH keys and `.env` files are
-blocked.
+# 3. Launch the TUI
+anveesa
 
-`writes:ask` covers the workspace-modifying tools — `create_dir`, `write_file`,
-`edit_file`, and `run_command`. By default Anveesa asks for confirmation on the
-terminal before each one:
+# 4. One-shot prompt
+anveesa "explain the auth middleware in this repo"
 
-```text
-allow run command `cargo test`? [y]es/[a]ll this turn/[N]o
+# 5. Specific provider/model
+anveesa --provider anthropic --model claude-sonnet-4-6 "refactor src/auth.ts"
 ```
 
-Answer `a` to approve the remaining write/run tools for the current assistant
-turn, which is useful when scaffolding several files.
+---
 
-The indicator reflects the active policy: `writes:ask` (confirm each action,
-the interactive default and the default for one-shot prompts typed directly in a
-terminal), `writes:auto` (run without asking, enabled with `--yes`), or
-`writes:off` (disabled for non-interactive stdin runs unless `--yes` is passed).
-
-Responses stream token-by-token as the model generates them. While Anveesa waits
-for the first token it shows a small status line such as:
-
-```text
-- thinking... 2s
-```
+## Configuration
 
-When usage is reported by the provider, a token summary is printed to stderr
-after the answer:
+Config lives at `~/.config/anveesa/config.toml`.
 
-```text
-[tokens: 812 in / 144 out / 956 total]
-```
+```toml
+default_provider = "anthropic"
 
-OpenAI-compatible providers can use up to 32 tool rounds per answer by default.
-After that, Anveesa stops advertising tools and asks the model to produce a
-final answer from the gathered results. Override the cap with
-`ANVEESA_MAX_TOOL_ROUNDS`, up to 256.
+[providers.anthropic]
+api_base      = "https://api.anthropic.com/v1"
+api_key_env   = "ANTHROPIC_API_KEY"
+default_model = "claude-sonnet-4-6"
+fast_model    = "claude-haiku-4-5-20251001"  # cheap model for read-only tool rounds
+prompt_cache  = true
 
-Use GLM/Z.ai:
+[providers.openai]
+api_base      = "https://api.openai.com/v1"
+api_key_env   = "OPENAI_API_KEY"
+default_model = "gpt-4o"
+fast_model    = "gpt-4o-mini"
 
-```sh
-export ZAI_API_KEY="..."
-anveesa config set-provider glm
-anveesa config set-model "glm-5.1"
-anveesa "write a rust module outline"
+[providers.local]
+api_base      = "http://localhost:11434/v1"
+default_model = "qwen2.5-coder:7b"
 ```
 
-You can also use the default `ask` behavior:
-
-```sh
-anveesa "write a git commit message"
-```
+### Project instructions
 
-Pipe stdin into a prompt:
+Drop `.anveesa.md` in your repo root — auto-injected every session:
 
-```sh
-git diff | anveesa ask --stdin "review this diff"
-```
+```markdown
+# My Project
 
-Let the model make changes. In interactive mode and one-shot terminal prompts,
-it asks before each write or command. Pass `--yes` (`-y`) to allow file writes
-and command execution without prompting:
+Stack: React 18, TypeScript, Tailwind, Prisma, PostgreSQL
 
-```sh
-anveesa --provider sumopod --yes "add a Default impl for the Config struct"
+Rules:
+- Use named exports only
+- Tests go in __tests__/ next to the source file
+- Run `pnpm test` before committing
+- DB migrations live in db/migrations/
 ```
 
-Run through Claude Code if the `claude` CLI is installed:
+---
 
-```sh
-anveesa --provider claude-code "summarize this project"
-```
+## TUI shortcuts
 
-Run through Codex if the `codex` CLI is installed:
+| Key | Action |
+|---|---|
+| Enter | Submit prompt |
+| Shift+Enter | Newline in input |
+| ↑ / ↓ | Navigate input history |
+| Tab | Complete `/command` or file path |
+| Ctrl+R | Search conversation |
+| `[` / `]` | Navigate file diffs |
+| Enter (on diff) | Expand / collapse diff |
+| ⌘V / Ctrl+V | Paste image or text (repeat to queue multiple) |
+| j / k | Scroll (empty input) |
+| PageUp / PageDn | Scroll |
+| Ctrl+W | Delete word |
+| Ctrl+U | Clear line |
+| Ctrl+C | Cancel / quit |
 
-```sh
-anveesa --provider codex --model "gpt-5.1-codex" "review this repository"
-```
+---
 
-Run through GitHub Copilot CLI if the `copilot` CLI is installed:
+## Slash commands
 
-```sh
-anveesa --provider copilot --model "gpt-5.1" "explain this function"
-```
+| Command | Description |
+|---|---|
+| `/help` | Show all shortcuts |
+| `/clear` | Reset conversation |
+| `/compact` | Drop old turns to free context |
+| `/search` | Search conversation (or Ctrl+R) |
+| `/undo` | Restore last AI-modified file |
+| `/copy` | Copy last response to clipboard |
+| `/export [path]` | Save as Markdown |
+| `/model [name]` | Switch model |
+| `/provider [name]` | Switch provider |
+| `/status` | Token and cost info |
+| `/exit` | Quit |
 
-Use Sumopod with its OpenAI-compatible API:
+---
 
-```sh
-export SUMOPOD_API_KEY="..."
-anveesa --provider sumopod --model "your-sumopod-model" "explain this error"
-```
+## Tools
 
-## Built-in providers
+**File ops:** `read_file` `write_file` `edit_file` `patch_file` `delete_file` `move_file` `copy_file` `create_dir` `list_dir` `find_files` `search_text`
 
-OpenAI-compatible API providers:
+**Git:** `git_status` `git_diff` `git_log` `git_blame` `git_show` `git_commit` `git_stash` `git_branch`
 
-- `openai`
-- `sumopod`
+**Web:** `web_search` `fetch_url` `screenshot_url`
 
-### How to change the model
+**Notes:** `save_note` `read_notes` `search_notes` `delete_note`
 
-You can change the model using these commands:
+**Execution:** `run_command`
 
-**Via config file:**
-```bash
-anveesa config set-model "your-model"
-```
+### fetch_url modes
 
-**Via command line:**
-```bash
-anveesa --model "your-model" "your prompt"
 ```
-
-**Interactive mode:**
-```bash
-anveesa
-# Then select/change model in the prompt
+fetch_url(url="...", mode="text")   # default — plain text, HTML stripped
+fetch_url(url="...", mode="raw")    # full HTML source
+fetch_url(url="...", mode="deep")   # HTML + all linked CSS (+ JS if include_js=true)
 ```
 
-The model can be set per provider (e.g., `sumopod`, `openai`, `openrouter`, etc.) and can be overridden per command with `--model`.
-- `openrouter`
-- `glm`
-- `glm-coding`
-- `deepseek`
-- `gemini`
-- `github-models`
-- `groq`
-- `mistral`
-- `xai`
-- `together`
-- `fireworks`
-- `cerebras`
-- `sambanova`
-- `nvidia`
-- `dashscope`
-- `qwen`
-- `huggingface`
-- `vercel-ai-gateway`
-- `perplexity`
-- `ollama`
-- `lm-studio`
-- `vllm`
-- `litellm`
-- `localai`
-
-Terminal command providers:
-
-- `claude-code`
-- `codex`
-- `copilot`
-
-Check the effective list any time:
-
-```sh
-anveesa providers
+### screenshot_url
+
+```
+screenshot_url(url="https://localhost:3000", full_page=true)
 ```
 
-## Config
+Requires Playwright: `npm install -g playwright && npx playwright install chromium`
 
-Default path:
+---
 
-```sh
-anveesa config path
-```
+## Security
 
-The path can be overridden with `ANVEESA_CONFIG`.
+- **Approval flow** — file writes and commands show a diff preview before running; `--yes` to auto-approve
+- **Path sandboxing** — writes outside the git root are refused
+- **Dangerous commands** — `rm -rf /`, pipe-to-shell, and similar patterns are hard-blocked
+- **Secret guard** — model is instructed never to expose API keys, `.env` files, or SSH keys
 
-Set defaults once:
+---
 
-```sh
-anveesa config set-provider sumopod
-anveesa config set-model "kimi-k2.6"
-```
+## Environment variables
 
-After that, just run:
+| Variable | Purpose |
+|---|---|
+| `ANTHROPIC_API_KEY` | Anthropic |
+| `OPENAI_API_KEY` | OpenAI |
+| `GEMINI_API_KEY` | Google Gemini |
+| `BRAVE_SEARCH_API_KEY` | Better web search |
+| `SERPER_API_KEY` | Alternative web search |
+| `ANVEESA_MAX_TOOL_ROUNDS` | Override tool round limit (default 32) |
 
-```sh
-anveesa
-```
+---
 
-Example provider config:
+## Build from source
 
-```toml
-default_provider = "sumopod"
-
-[providers.sumopod]
-kind = "openai-compatible"
-base_url = "https://ai.sumopod.com/v1"
-api_key_env = "SUMOPOD_API_KEY"
-default_model = "your-sumopod-model"
-
-[providers.openrouter]
-kind = "openai-compatible"
-base_url = "https://openrouter.ai/api/v1"
-api_key_env = "OPENROUTER_API_KEY"
-
-[providers.glm]
-kind = "openai-compatible"
-base_url = "https://api.z.ai/api/paas/v4"
-api_key_env = "ZAI_API_KEY"
-default_model = "glm-5.1"
-
-[providers.codex]
-kind = "command"
-command = "codex"
-args = ["exec", "{model_args}", "{prompt}"]
-model_args = ["--model", "{model}"]
-
-[providers.claude-code]
-kind = "command"
-command = "claude"
-args = ["-p", "{system_args}", "{model_args}", "{prompt}"]
-model_args = ["--model", "{model}"]
-system_args = ["--system-prompt", "{system}"]
+```bash
+git clone https://github.com/PandhuWibowo/anveesa-cli
+cd anveesa-cli
+cargo build --release
+./target/release/anveesa
 ```
 
-Command providers can use placeholders in args or env values:
+Requires Rust 1.85+ (2024 edition).
+
+---
 
-- `{prompt}`
-- `{model}`
-- `{system}`
-- `{model_args}`
-- `{system_args}`
+MIT License

package/package.json

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

@@ -636,7 +636,7 @@ async fn ask_streaming(
     history: &[ChatMessage],
     workspace_context: Option<&str>,
     policy: ApprovalPolicy,
-    image: Option<ImageAttachment>,
+    image: Option<ImageAttachment>, // single-image path kept for REPL compatibility
     mode: RenderMode,
 ) -> Result<TurnResult> {
     let provider_name = config
@@ -652,7 +652,7 @@ async fn ask_streaming(
         system: options.system.clone(),
         workspace_context: workspace_context.map(str::to_string),
         history: history.to_vec(),
-        image,
+        images: image.into_iter().collect(),
         mcp: None, // REPL path: MCP not yet wired here
     };
 
@@ -2518,7 +2518,49 @@ fn workspace_context_for(cwd: &Path) -> Result<String> {
         context.push_str(&format!("- parent: {}\n", parent.display()));
     }
 
+    // .anveesa.md — project-level instructions (highest priority context)
+    let project_md_paths = [cwd.join(".anveesa.md"), cwd.join("ANVEESA.md")];
+    for md_path in &project_md_paths {
+        if let Ok(content) = fs::read_to_string(md_path) {
+            if !content.trim().is_empty() {
+                context.push_str("\nProject instructions (.anveesa.md):\n");
+                let capped: String = content.chars().take(8_000).collect();
+                context.push_str(&capped);
+                context.push('\n');
+            }
+            break;
+        }
+    }
+
+    // README — auto-inject up to 3 000 chars for project overview
+    for readme in &["README.md", "readme.md", "Readme.md"] {
+        if let Ok(content) = fs::read_to_string(cwd.join(readme)) {
+            if !content.trim().is_empty() {
+                context.push_str("\nProject README (first 3000 chars):\n");
+                let capped: String = content.chars().take(3_000).collect();
+                context.push_str(&capped);
+                context.push('\n');
+            }
+            break;
+        }
+    }
+
     if let Some(git_root) = git_output(&cwd, ["rev-parse", "--show-toplevel"]) {
+        // Also check git root for .anveesa.md if different from cwd
+        let git_root_path = std::path::Path::new(&git_root);
+        if git_root_path != cwd {
+            for md_path in &[git_root_path.join(".anveesa.md"), git_root_path.join("ANVEESA.md")] {
+                if let Ok(content) = fs::read_to_string(md_path) {
+                    if !content.trim().is_empty() {
+                        context.push_str("\nProject instructions (from git root):\n");
+                        let capped: String = content.chars().take(8_000).collect();
+                        context.push_str(&capped);
+                        context.push('\n');
+                    }
+                    break;
+                }
+            }
+        }
         context.push_str(&format!("- git_root: {git_root}\n"));
         if let Some(branch) = git_output(&cwd, ["branch", "--show-current"])
             && !branch.is_empty()

package/src/provider/mod.rs

@@ -49,8 +49,8 @@ pub struct PromptRequest {
     pub system: Option<String>,
     pub workspace_context: Option<String>,
     pub history: Vec<ChatMessage>,
-    /// Optional image grabbed from the clipboard for the current turn only.
-    pub image: Option<ImageAttachment>,
+    /// Images attached to the current turn (clipboard paste or explicit attach).
+    pub images: Vec<ImageAttachment>,
     /// Connected MCP servers (runtime only, not part of session history).
     pub mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
 }

package/src/provider/openai_compatible.rs

@@ -250,6 +250,93 @@ struct ToolApprovalState {
     call_counts: std::collections::HashMap<(String, String), usize>,
 }
 
+fn git_root() -> Option<std::path::PathBuf> {
+    let cwd = std::env::current_dir().ok()?;
+    let out = std::process::Command::new("git")
+        .args(["rev-parse", "--show-toplevel"])
+        .current_dir(&cwd)
+        .output()
+        .ok()?;
+    if out.status.success() {
+        let s = String::from_utf8(out.stdout).ok()?.trim().to_string();
+        Some(std::path::PathBuf::from(s))
+    } else {
+        None
+    }
+}
+
+fn normalize_path(p: &std::path::Path) -> std::path::PathBuf {
+    let mut out = std::path::PathBuf::new();
+    for comp in p.components() {
+        match comp {
+            std::path::Component::ParentDir => { out.pop(); }
+            std::path::Component::CurDir => {}
+            _ => out.push(comp),
+        }
+    }
+    out
+}
+
+/// Returns Some(error) if `path_str` resolves to a location outside the sandbox root.
+fn sandbox_check(tool_name: &str, arguments: &str) -> Option<String> {
+    // Tools that don't take a filesystem path — always allowed
+    if matches!(tool_name, "git_commit" | "git_stash" | "git_branch" | "save_note" | "delete_note" | "run_command") {
+        return None;
+    }
+    let Ok(args) = serde_json::from_str::<serde_json::Value>(arguments) else { return None };
+    let path_str = args.get("path")
+        .or_else(|| args.get("destination"))
+        .or_else(|| args.get("dest"))
+        .and_then(|v| v.as_str())?;
+
+    let cwd = std::env::current_dir().unwrap_or_default();
+    let raw = if std::path::Path::new(path_str).is_absolute() {
+        std::path::PathBuf::from(path_str)
+    } else {
+        cwd.join(path_str)
+    };
+    let resolved = normalize_path(&raw);
+    let root = git_root().unwrap_or_else(|| cwd.clone());
+
+    if resolved.starts_with(&root) || resolved.starts_with(&cwd) {
+        None
+    } else {
+        Some(format!(
+            "Path '{}' is outside the project root '{}' — blocked for safety. \
+             Use a path inside the project.",
+            path_str,
+            root.display()
+        ))
+    }
+}
+
+const DANGEROUS_PATTERNS: &[&str] = &[
+    "rm -rf /",
+    "rm -rf ~",
+    "rm -rf $HOME",
+    "dd if=",
+    "mkfs",
+    "> /dev/sda",
+    ":(){ :|:& };:",
+    "chmod -R 777 /",
+    "chown -R",
+    "curl | sh",
+    "curl | bash",
+    "wget | sh",
+    "wget | bash",
+];
+
+fn dangerous_command_check(arguments: &str) -> Option<String> {
+    let Ok(args) = serde_json::from_str::<serde_json::Value>(arguments) else { return None };
+    let cmd = args["command"].as_str()?;
+    for pat in DANGEROUS_PATTERNS {
+        if cmd.contains(pat) {
+            return Some(format!("blocked: command matches dangerous pattern '{pat}'"));
+        }
+    }
+    None
+}
+
 async fn dispatch_read_only_tool(
     call: PartialToolCall,
     events: UnboundedSender<StreamEvent>,
@@ -356,6 +443,16 @@ async fn dispatch_tool(
         if !policy.allows_write_tools() {
             return denied_message("write tools are disabled (pass --yes or run interactively)");
         }
+        // Path sandbox: refuse writes that escape the project root
+        if let Some(err) = sandbox_check(&call.name, &call.arguments) {
+            return json!({"ok": false, "error": err}).to_string();
+        }
+        // Dangerous command patterns
+        if call.name == "run_command" {
+            if let Some(err) = dangerous_command_check(&call.arguments) {
+                return json!({"ok": false, "error": err}).to_string();
+            }
+        }
     } else {
         let _ = events.send(StreamEvent::ToolCall {
             summary: summary.clone(),
@@ -822,13 +919,15 @@ fn build_messages(
         messages.push(json!({ "role": role, "content": message.content }));
     }
 
-    // Current user turn — multimodal when a clipboard image is attached.
-    let user_content = match &request.image {
-        Some(img) => json!([
-            { "type": "text", "text": &request.prompt },
-            { "type": "image_url", "image_url": { "url": format!("data:{};base64,{}", img.mime, img.data) } }
-        ]),
-        None => json!(&request.prompt),
+    // Current user turn — multimodal when images are attached.
+    let user_content = if request.images.is_empty() {
+        json!(&request.prompt)
+    } else {
+        let mut parts = vec![json!({ "type": "text", "text": &request.prompt })];
+        for img in &request.images {
+            parts.push(json!({ "type": "image_url", "image_url": { "url": format!("data:{};base64,{}", img.mime, img.data) } }));
+        }
+        json!(parts)
     };
     messages.push(json!({ "role": "user", "content": user_content }));
 

package/src/tools.rs

@@ -102,6 +102,7 @@ pub fn describe_call(name: &str, arguments: &str) -> String {
         "read_file" => format!("read file {}", field("path")),
         "web_search"  => format!("web search `{}`", field("query")),
         "fetch_url"   => format!("fetch {}", field("url")),
+        "screenshot_url" => format!("screenshot {}", field("url")),
         "git_status"  => "git status".to_string(),
         "git_diff"    => {
             let path = field("path");
@@ -271,6 +272,24 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                 }
             }
         }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "screenshot_url",
+                "description": "Take a full-page or viewport screenshot of a URL using a headless browser (Playwright). Returns the saved file path and a note. Use when you need to visually inspect a web page, compare UI designs, or verify a running app.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "url": { "type": "string", "description": "URL to screenshot." },
+                        "output": { "type": "string", "description": "File path to save the PNG (default: /tmp/anveesa-screenshot-<timestamp>.png)." },
+                        "width": { "type": "integer", "description": "Viewport width in pixels (default 1440)." },
+                        "height": { "type": "integer", "description": "Viewport height in pixels (default 900)." },
+                        "full_page": { "type": "boolean", "description": "Capture the full scrollable page (default false)." }
+                    },
+                    "required": ["url"]
+                }
+            }
+        }),
         json!({
             "type": "function",
             "function": {
@@ -607,6 +626,7 @@ pub async fn run(name: &str, arguments: &str) -> String {
         "write_file" => write_file(arguments).await,
         "edit_file"  => edit_file(arguments).await,
         "run_command" => run_command(arguments).await,
+        "screenshot_url" => screenshot_url(arguments).await,
         _ => Err(anyhow!("unknown tool '{name}'")),
     };
 
@@ -2101,6 +2121,68 @@ fn percent_encode(value: &str) -> String {
         .collect()
 }
 
+// ── screenshot_url ─────────────────────────────────────────────────────────────
+
+async fn screenshot_url(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args {
+        url: String,
+        #[serde(default)]
+        output: Option<String>,
+        #[serde(default)]
+        width: Option<u32>,
+        #[serde(default)]
+        height: Option<u32>,
+        #[serde(default)]
+        full_page: Option<bool>,
+    }
+    let args: Args = parse_args(arguments)?;
+    let url = args.url.trim().to_string();
+    if url.is_empty() { bail!("url is required"); }
+
+    let ts = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs();
+    let output = args.output.unwrap_or_else(|| format!("/tmp/anveesa-screenshot-{ts}.png"));
+    let width = args.width.unwrap_or(1440);
+    let height = args.height.unwrap_or(900);
+    let viewport = format!("{width},{height}");
+
+    let mut cmd = tokio::process::Command::new("npx");
+    cmd.args(["playwright", "screenshot", "--viewport-size", &viewport]);
+    if args.full_page.unwrap_or(false) {
+        cmd.arg("--full-page");
+    }
+    cmd.arg(&url).arg(&output);
+
+    let result = cmd.output().await;
+    match result {
+        Ok(out) if out.status.success() => {
+            let size_kb = tokio::fs::metadata(&output).await
+                .map(|m| m.len() / 1024)
+                .unwrap_or(0);
+            Ok(json!({
+                "ok": true,
+                "saved_to": output,
+                "url": url,
+                "width": width,
+                "height": height,
+                "size_kb": size_kb,
+                "note": format!("Screenshot saved to {output}. Open it with: open {output}")
+            }))
+        }
+        Ok(out) => {
+            let stderr = String::from_utf8_lossy(&out.stderr);
+            bail!("playwright failed (exit {}): {}", out.status, stderr.trim())
+        }
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+            bail!("playwright not found — install with: npm install -g playwright && npx playwright install chromium")
+        }
+        Err(e) => bail!("failed to run playwright: {e}"),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/src/tui.rs

@@ -69,6 +69,7 @@ enum Mode {
     Input,
     Streaming,
     Confirming,
+    Search,
 }
 
 // ── Application state ─────────────────────────────────────────────────────────
@@ -98,7 +99,7 @@ pub struct App {
     input_history: Vec<String>,
     hist_idx: Option<usize>,
     hist_saved: String,
-    pending_image: Option<ImageAttachment>,
+    pending_images: Vec<ImageAttachment>,
     last_image_fp: Option<String>,
     images_available: bool,
 
@@ -118,6 +119,12 @@ pub struct App {
     msg_focus: Option<usize>,
     msg_line_offsets: Vec<usize>,
 
+    // conversation search
+    search_query: String,
+    search_results: Vec<usize>,
+    search_idx: usize,
+    search_scroll_saved: usize,
+
     // tab completion state: (original input, candidates, current index)
     tab_state: Option<(String, Vec<String>, usize)>,
 
@@ -193,7 +200,7 @@ impl App {
             input_history,
             hist_idx: None,
             hist_saved: String::new(),
-            pending_image: None,
+            pending_images: Vec::new(),
             last_image_fp: None,
             images_available,
 
@@ -211,6 +218,11 @@ impl App {
             msg_line_offsets: Vec::new(),
             tab_state: None,
 
+            search_query: String::new(),
+            search_results: Vec::new(),
+            search_idx: 0,
+            search_scroll_saved: 0,
+
             mode: Mode::Input,
             confirm: None,
             mouse_capture: true,
@@ -324,11 +336,9 @@ async fn handle_event(app: &mut App, event: Event) -> Result<()> {
         Event::Paste(text) => {
             if app.mode != Mode::Input { return Ok(()); }
             if text.trim().is_empty() {
-                // Empty paste = user pasted an image (terminal can't forward it as text)
-                // Try to grab it directly from the clipboard
                 if app.images_available {
                     if let Some(img) = crate::grab_clipboard_image() {
-                        app.pending_image = Some(img);
+                        app.pending_images.push(img);
                         app.last_image_fp = None;
                         return Ok(());
                     }
@@ -338,6 +348,7 @@ async fn handle_event(app: &mut App, event: Event) -> Result<()> {
                 app.input.insert_str(app.input_cursor, &normalized);
                 app.input_cursor += normalized.len();
                 app.hist_idx = None;
+                app.tab_state = None;
             }
         }
         Event::Resize(_, _) => {}
@@ -396,6 +407,48 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
         return Ok(());
     }
 
+    // ── Search mode ───────────────────────────────────────────────────────────
+    if app.mode == Mode::Search {
+        match code {
+            KeyCode::Esc => {
+                app.mode = Mode::Input;
+                app.auto_scroll = false;
+                app.scroll = app.search_scroll_saved;
+                app.search_query.clear();
+                app.search_results.clear();
+            }
+            KeyCode::Enter | KeyCode::Down
+            | KeyCode::Char('n') => {
+                if !app.search_results.is_empty() {
+                    app.search_idx = (app.search_idx + 1) % app.search_results.len();
+                    let idx = app.search_results[app.search_idx];
+                    if let Some(&off) = app.msg_line_offsets.get(idx) {
+                        app.scroll = off.saturating_sub(2);
+                    }
+                }
+            }
+            KeyCode::Up | KeyCode::Char('p') => {
+                if !app.search_results.is_empty() {
+                    app.search_idx = app.search_idx.checked_sub(1).unwrap_or(app.search_results.len() - 1);
+                    let idx = app.search_results[app.search_idx];
+                    if let Some(&off) = app.msg_line_offsets.get(idx) {
+                        app.scroll = off.saturating_sub(2);
+                    }
+                }
+            }
+            KeyCode::Backspace => {
+                app.search_query.pop();
+                update_search(app);
+            }
+            KeyCode::Char(c) => {
+                app.search_query.push(c);
+                update_search(app);
+            }
+            _ => {}
+        }
+        return Ok(());
+    }
+
     // ── Input mode ────────────────────────────────────────────────────────────
     match code {
         // Submit (Enter) or newline (Shift+Enter)
@@ -475,26 +528,38 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
             delete_word_before(&mut app.input, &mut app.input_cursor);
             app.hist_idx = None;
         }
-        // Ctrl+V — universal paste: image first, then clipboard text
-        KeyCode::Char('v') if modifiers.contains(KeyModifiers::CONTROL) => {
+        // Ctrl+V (all platforms) or Cmd+V (macOS) — image first, then text
+        KeyCode::Char('v')
+            if modifiers.contains(KeyModifiers::CONTROL)
+                || (cfg!(target_os = "macos") && modifiers.contains(KeyModifiers::SUPER)) =>
+        {
             if app.images_available {
                 if let Some(img) = crate::grab_clipboard_image() {
-                    app.pending_image = Some(img);
+                    app.pending_images.push(img);
                     app.last_image_fp = None;
                     return Ok(());
                 }
             }
-            // No image — fall back to clipboard text
             if let Some(text) = crate::read_clipboard_text() {
                 if !text.is_empty() {
                     let normalized = text.replace('\r', "\n");
                     app.input.insert_str(app.input_cursor, &normalized);
                     app.input_cursor += normalized.len();
                     app.hist_idx = None;
+                    app.tab_state = None;
                 }
             }
         }
 
+        // Ctrl+R — activate conversation search
+        KeyCode::Char('r') if modifiers.contains(KeyModifiers::CONTROL) => {
+            app.search_scroll_saved = app.scroll;
+            app.search_query.clear();
+            app.search_results.clear();
+            app.search_idx = 0;
+            app.mode = Mode::Search;
+        }
+
         // Ctrl+M — toggle mouse capture (scroll mode ↔ select mode)
         KeyCode::Char('m') if modifiers.contains(KeyModifiers::CONTROL) => {
             app.mouse_capture = !app.mouse_capture;
@@ -610,7 +675,7 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.streaming_buf.clear();
             app.accumulated_response.clear();
             app.usage = Usage::default();
-            app.pending_image = None;
+            app.pending_images.clear();
             app.seen_paths.clear();
             app.undo_stack.clear();
             app.input.clear();
@@ -631,10 +696,11 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
                  /model [name] · /provider [name] · /status · /exit\n\
                  \n\
                  Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
-                 Tab   complete /command or file path (press again to cycle)\n\
-                 [ ]   navigate between file diffs  Enter expand/collapse focused diff\n\
+                 Tab     complete /command or file path (press again to cycle)\n\
+                 Ctrl+R  search conversation  (or /search)\n\
+                 [ ]     navigate between file diffs  Enter expand/collapse focused diff\n\
                  j/k scroll (when input empty)  PageUp/Dn scroll\n\
-                 Ctrl+V paste (image or text)  Ctrl+M scroll/select mode\n\
+                 ⌘V (macOS) / Ctrl+V  paste image or text (repeat to queue multiple images)\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(),
@@ -698,7 +764,6 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             true
         }
         "/compact" => {
-            // Keep only the last 10 turns, drop older history to free context
             let keep = 10usize;
             let total_turns = app.history.len() / 2;
             if total_turns <= keep {
@@ -708,16 +773,35 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             } else {
                 let drop_turns = total_turns - keep;
                 let drop_msgs = drop_turns * 2;
+                // Summarise dropped content before removing it
+                let dropped_text: String = app.history[..drop_msgs].iter()
+                    .map(|m| m.content.as_str())
+                    .collect::<Vec<_>>()
+                    .join(" ");
+                // Extract file paths mentioned in dropped turns
+                let mut files: Vec<&str> = dropped_text.split_whitespace()
+                    .filter(|w| w.contains('/') || w.ends_with(".rs") || w.ends_with(".ts")
+                        || w.ends_with(".py") || w.ends_with(".js") || w.ends_with(".go"))
+                    .collect::<std::collections::HashSet<_>>()
+                    .into_iter()
+                    .collect();
+                files.sort();
+                files.truncate(12);
+                let file_hint = if files.is_empty() { String::new() }
+                    else { format!("  Files discussed: {}.", files.join(", ")) };
                 app.history.drain(..drop_msgs);
-                // Also remove older messages from the display (keep separators and last N turns)
                 let msg_count = app.messages.len();
                 if msg_count > keep * 3 {
                     app.messages.drain(..(msg_count - keep * 3));
                 }
-                app.seen_paths.clear(); // refresh seen paths for the new context window
+                app.seen_paths.clear();
+                // Inject a context breadcrumb so the model knows what was compacted
+                app.history.insert(0, ChatMessage::user(format!(
+                    "[Context note: {drop_turns} earlier turn(s) were compacted to save context.{file_hint} \
+                     Use read_file / list_dir to re-inspect any files if needed.]"
+                )));
                 app.messages.insert(0, Msg::System(format!(
-                    "Context compacted: dropped {drop_turns} older turn(s), keeping the last {keep}. \
-                     Use /clear to start fresh."
+                    "Context compacted: dropped {drop_turns} older turn(s), keeping the last {keep}.{file_hint}"
                 )));
                 app.messages.push(Msg::Separator);
             }
@@ -725,6 +809,16 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.input_cursor = 0;
             true
         }
+        "/search" => {
+            app.search_scroll_saved = app.scroll;
+            app.search_query.clear();
+            app.search_results.clear();
+            app.search_idx = 0;
+            app.mode = Mode::Search;
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
         s if s.starts_with("/export") => {
             let arg = s.strip_prefix("/export").unwrap().trim();
             let path = if arg.is_empty() {
@@ -784,11 +878,41 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
     }
 }
 
+// ── Conversation search ───────────────────────────────────────────────────────
+
+fn msg_text(msg: &Msg) -> Option<&str> {
+    match msg {
+        Msg::User { text } | Msg::Assistant { text } | Msg::Error(text) | Msg::System(text) => Some(text),
+        Msg::Tool { text, .. } => Some(text),
+        Msg::FileOp { path, .. } => Some(path),
+        Msg::Separator => None,
+    }
+}
+
+fn update_search(app: &mut App) {
+    let q = app.search_query.to_lowercase();
+    app.search_results = if q.is_empty() {
+        vec![]
+    } else {
+        app.messages.iter().enumerate()
+            .filter(|(_, m)| msg_text(m).map(|t| t.to_lowercase().contains(&q)).unwrap_or(false))
+            .map(|(i, _)| i)
+            .collect()
+    };
+    app.search_idx = 0;
+    if let Some(&first) = app.search_results.first() {
+        if let Some(&off) = app.msg_line_offsets.get(first) {
+            app.auto_scroll = false;
+            app.scroll = off.saturating_sub(2);
+        }
+    }
+}
+
 // ── Tab completion ────────────────────────────────────────────────────────────
 
 const SLASH_COMMANDS: &[&str] = &[
     "/clear", "/compact", "/copy", "/exit", "/export",
-    "/help", "/model", "/provider", "/quit", "/status", "/undo",
+    "/help", "/model", "/provider", "/quit", "/search", "/status", "/undo",
 ];
 
 fn tab_complete(app: &mut App) {
@@ -874,17 +998,24 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
     app.pending_prompt = text.clone();
     app.accumulated_response.clear();
 
-    // Auto-attach clipboard image if nothing was explicitly Ctrl+V'd
-    let image = app.pending_image.take().or_else(|| {
-        if !app.images_available { return None; }
-        let img = crate::grab_clipboard_image()?;
-        let fp = crate::image_fingerprint(&img);
-        if app.last_image_fp.as_deref() == Some(&fp) {
-            return None; // same image as last time
+    // Collect explicitly pasted images; if none, auto-attach a new clipboard image once.
+    let images: Vec<crate::provider::ImageAttachment> = if !app.pending_images.is_empty() {
+        std::mem::take(&mut app.pending_images)
+    } else if app.images_available {
+        if let Some(img) = crate::grab_clipboard_image() {
+            let fp = crate::image_fingerprint(&img);
+            if app.last_image_fp.as_deref() == Some(&fp) {
+                vec![]
+            } else {
+                app.last_image_fp = Some(fp);
+                vec![img]
+            }
+        } else {
+            vec![]
         }
-        app.last_image_fp = Some(fp);
-        Some(img)
-    });
+    } else {
+        vec![]
+    };
 
     app.messages.push(Msg::User { text: text.clone() });
     app.input.clear();
@@ -924,7 +1055,7 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
             system: options.system.clone(),
             workspace_context,
             history,
-            image,
+            images,
             mcp: mcp_arc,
         };
         let result = crate::provider::ask(&config, &provider_name, request, policy, &stream_tx_inner).await;
@@ -1510,9 +1641,9 @@ fn assistant_header(model: &str) -> Line<'static> {
 fn render_input(frame: &mut Frame, area: Rect, app: &App) {
     // Border color reflects mode: ready=green, streaming=yellow, confirming=orange
     let border_color = match app.mode {
-        Mode::Input     => Color::Rgb(152, 195, 121), // green — "your turn"
+        Mode::Input | Mode::Search => Color::Rgb(152, 195, 121), // green — "your turn"
         Mode::Streaming => Color::Rgb(229, 192, 123), // yellow — "thinking"
-        Mode::Confirming=> Color::Rgb(224, 108, 117), // red — "needs decision"
+        Mode::Confirming => Color::Rgb(224, 108, 117), // red — "needs decision"
     };
     let block = Block::default()
         .borders(Borders::TOP)
@@ -1520,15 +1651,14 @@ fn render_input(frame: &mut Frame, area: Rect, app: &App) {
     let inner = block.inner(area);
     frame.render_widget(block, area);
 
-    if app.mode != Mode::Input {
+    if app.mode != Mode::Input && app.mode != Mode::Search {
         // Don't show cursor or text while AI is working
         return;
     }
 
-    if app.input.is_empty() && app.pending_image.is_none() {
-        // Placeholder hint
+    if app.input.is_empty() && app.pending_images.is_empty() {
         frame.render_widget(
-            Paragraph::new("  ❯ Ask anything…  (↑/↓ history · Ctrl+V paste image)")
+            Paragraph::new("  ❯ Ask anything…  (↑/↓ history · ⌘V paste image)")
                 .style(Style::default().fg(Color::Rgb(60, 60, 80))),
             inner,
         );
@@ -1536,7 +1666,11 @@ fn render_input(frame: &mut Frame, area: Rect, app: &App) {
         return;
     }
 
-    let label = if app.pending_image.is_some() { "  [📎] ❯ " } else { "  ❯ " };
+    let label = match app.pending_images.len() {
+        0 => "  ❯ ".to_string(),
+        1 => "  [📎] ❯ ".to_string(),
+        n => format!("  [📎 ×{n}] ❯ "),
+    };
     let label_w = label.chars().count();
     let display = format!("{label}{}", app.input);
 
@@ -1599,6 +1733,19 @@ fn render_status(frame: &mut Frame, area: Rect, app: &App) {
                 area,
             );
         }
+        Mode::Search => {
+            let n = app.search_results.len();
+            let pos = if n == 0 { String::new() } else { format!("  {}/{n}", app.search_idx + 1) };
+            let left = format!(" 🔍 {}{pos}", app.search_query);
+            let right = " ↑↓ navigate  Esc close ";
+            let gap = (area.width as usize).saturating_sub(left.chars().count() + right.chars().count());
+            let text = format!("{left}{}{right}", " ".repeat(gap));
+            frame.render_widget(
+                Paragraph::new(text)
+                    .style(Style::default().fg(Color::White).bg(Color::Rgb(30, 20, 50))),
+                area,
+            );
+        }
         Mode::Input => {
             let mode_icon = if app.mouse_capture { "⊙" } else { "⊕" };
             let mode_label = if app.mouse_capture { "scroll" } else { "select" };