anveesa 0.4.0 → 0.4.2

package/Cargo.lock

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

package/Cargo.toml

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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/config.rs

@@ -174,6 +174,23 @@ pub struct AppConfig {
 
     #[serde(default)]
     pub providers: BTreeMap<String, ProviderConfig>,
+
+    /// MCP servers to connect to on startup.
+    /// Example config:
+    ///   [mcp.filesystem]
+    ///   command = "npx"
+    ///   args = ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub mcp: BTreeMap<String, McpServerConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct McpServerConfig {
+    pub command: String,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: BTreeMap<String, String>,
 }
 
 impl AppConfig {
@@ -351,6 +368,7 @@ impl AppConfig {
         Self {
             default_provider: Some("sumopod".to_string()),
             providers,
+            mcp: BTreeMap::new(),
         }
     }
 
@@ -375,6 +393,7 @@ impl AppConfig {
             self.default_provider = user_config.default_provider;
         }
         self.providers.extend(user_config.providers);
+        self.mcp.extend(user_config.mcp);
     }
 
     pub fn provider_name<'a>(&'a self, requested: Option<&'a str>) -> Result<&'a str> {
@@ -620,6 +639,7 @@ fn load_user_config_for_write(path: &Path) -> Result<AppConfig> {
         return Ok(AppConfig {
             default_provider: Some("sumopod".to_string()),
             providers: BTreeMap::new(),
+            mcp: BTreeMap::new(),
         });
     }
 

package/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod cli;
 pub mod config;
+pub mod mcp;
 pub mod provider;
 pub mod tools;
 pub mod tui;
@@ -154,6 +155,14 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
 
     // ── TUI mode ──────────────────────────────────────────────────────────────
     if is_tty {
+        // Connect to any configured MCP servers.
+        let mcp_manager = if !config.mcp.is_empty() {
+            let m = mcp::McpManager::connect(&config.mcp).await;
+            Some(std::sync::Arc::new(m))
+        } else {
+            None
+        };
+
         // Spawn a background task to read keyboard events (crossterm::event::read is blocking).
         let (key_tx, key_rx) = tokio::sync::mpsc::unbounded_channel();
         tokio::task::spawn_blocking(move || {
@@ -183,6 +192,7 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
             workspace_context,
             policy,
             key_rx,
+            mcp_manager,
         );
 
         tui::run(app).await?;
@@ -624,6 +634,7 @@ async fn ask_streaming(
         workspace_context: workspace_context.map(str::to_string),
         history: history.to_vec(),
         image,
+        mcp: None, // REPL path: MCP not yet wired here
     };
 
     let result = provider::ask(config, &provider_name, request, policy, &tx).await;
@@ -1764,16 +1775,20 @@ fn read_prompt_line(
                 buffer.clear_all();
                 display_rows = redraw!();
             }
-            22 if images_available => {
-                // Ctrl+V — paste image from clipboard
-                match grab_clipboard_image() {
-                    Some(img) => {
+            22 => {
+                // Ctrl+V — universal paste: image first, then clipboard text
+                if images_available {
+                    if let Some(img) = grab_clipboard_image() {
                         ctrl_v_image = Some(img);
                         display_rows = redraw!();
+                        continue;
                     }
-                    None => {
-                        print!("\x07");
-                        let _ = io::stdout().flush();
+                }
+                // Fall back to clipboard text via pbpaste / xclip
+                if let Some(text) = read_clipboard_text() {
+                    if !text.is_empty() {
+                        buffer.push_text(&text.replace('\r', "\n"));
+                        display_rows = redraw!();
                     }
                 }
             }
@@ -2313,6 +2328,31 @@ fn repl_history_path() -> Option<PathBuf> {
     Some(dir.join("history"))
 }
 
+pub fn read_clipboard_text() -> Option<String> {
+    #[cfg(target_os = "macos")]
+    {
+        let out = std::process::Command::new("pbpaste").output().ok()?;
+        if out.status.success() {
+            let text = String::from_utf8_lossy(&out.stdout).into_owned();
+            if !text.is_empty() { return Some(text); }
+        }
+    }
+    #[cfg(not(target_os = "macos"))]
+    for (cmd, args) in &[
+        ("wl-paste", vec!["--no-newline"]),
+        ("xclip",   vec!["-o", "-selection", "clipboard"]),
+        ("xsel",    vec!["--clipboard", "--output"]),
+    ] {
+        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
+            if out.status.success() {
+                let text = String::from_utf8_lossy(&out.stdout).into_owned();
+                if !text.is_empty() { return Some(text); }
+            }
+        }
+    }
+    None
+}
+
 pub fn unix_now() -> u64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)

package/src/mcp.rs

@@ -0,0 +1,237 @@
+//! MCP (Model Context Protocol) client — connects to external tool servers
+//! over JSON-RPC / stdio, discovers their tools, and routes calls to them.
+
+use std::collections::BTreeMap;
+
+use anyhow::{Context, Result, bail};
+use serde_json::{Value, json};
+use tokio::{
+    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
+    process::Child,
+    sync::Mutex,
+};
+
+use crate::config::McpServerConfig;
+
+// ── Tool definition exposed to the rest of anveesa ───────────────────────────
+
+#[derive(Debug, Clone)]
+pub struct McpTool {
+    /// Namespaced as mcp__{server}__{original_name}
+    pub name: String,
+    pub description: String,
+    pub input_schema: Value,
+    pub server: String,
+    pub original_name: String,
+}
+
+impl McpTool {
+    /// Convert to an OpenAI-compatible function definition.
+    pub fn to_definition(&self) -> Value {
+        json!({
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": format!("[MCP:{}] {}", self.server, self.description),
+                "parameters": self.input_schema,
+            }
+        })
+    }
+}
+
+// ── Single MCP server connection ──────────────────────────────────────────────
+
+struct McpServer {
+    name: String,
+    stdin: Mutex<tokio::process::ChildStdin>,
+    stdout: Mutex<BufReader<tokio::process::ChildStdout>>,
+    next_id: Mutex<u64>,
+    _child: Child,
+}
+
+impl McpServer {
+    async fn connect(name: &str, cfg: &McpServerConfig) -> Result<(Self, Vec<McpTool>)> {
+        let mut child = tokio::process::Command::new(&cfg.command)
+            .args(&cfg.args)
+            .envs(&cfg.env)
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::null())
+            .kill_on_drop(true)
+            .spawn()
+            .with_context(|| format!("failed to start MCP server '{name}' ({})", cfg.command))?;
+
+        let stdin = child.stdin.take().context("MCP server has no stdin")?;
+        let stdout = BufReader::new(child.stdout.take().context("MCP server has no stdout")?);
+
+        let server = Self {
+            name: name.to_string(),
+            stdin: Mutex::new(stdin),
+            stdout: Mutex::new(stdout),
+            next_id: Mutex::new(1),
+            _child: child,
+        };
+
+        server.initialize().await?;
+        let tools = server.list_tools().await?;
+        Ok((server, tools))
+    }
+
+    async fn send_msg(&self, msg: Value) -> Result<()> {
+        let line = serde_json::to_string(&msg)? + "\n";
+        let mut stdin = self.stdin.lock().await;
+        stdin.write_all(line.as_bytes()).await?;
+        stdin.flush().await?;
+        Ok(())
+    }
+
+    async fn recv_msg(&self) -> Result<Value> {
+        let mut stdout = self.stdout.lock().await;
+        let mut line = String::new();
+        stdout.read_line(&mut line).await.context("MCP server closed")?;
+        if line.is_empty() { bail!("MCP server closed connection"); }
+        Ok(serde_json::from_str(line.trim())?)
+    }
+
+    async fn request(&self, method: &str, params: Value) -> Result<Value> {
+        let id = {
+            let mut n = self.next_id.lock().await;
+            let v = *n;
+            *n += 1;
+            v
+        };
+        self.send_msg(json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params })).await?;
+
+        // Drain notifications until we get our response id
+        loop {
+            let resp = self.recv_msg().await?;
+            if resp.get("id").and_then(|v| v.as_u64()) == Some(id) {
+                if let Some(err) = resp.get("error") {
+                    bail!("MCP error from '{}': {}", self.name, err);
+                }
+                return Ok(resp["result"].clone());
+            }
+            // Drop unmatched messages (notifications, other ids)
+        }
+    }
+
+    async fn notify(&self, method: &str, params: Value) -> Result<()> {
+        self.send_msg(json!({ "jsonrpc": "2.0", "method": method, "params": params })).await
+    }
+
+    async fn initialize(&self) -> Result<()> {
+        self.request("initialize", json!({
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": { "name": "anveesa", "version": env!("CARGO_PKG_VERSION") }
+        })).await?;
+        self.notify("notifications/initialized", json!({})).await?;
+        Ok(())
+    }
+
+    async fn list_tools(&self) -> Result<Vec<McpTool>> {
+        let result = self.request("tools/list", json!({})).await?;
+        let raw = result["tools"].as_array().cloned().unwrap_or_default();
+        Ok(raw.into_iter().filter_map(|t| {
+            let original_name = t["name"].as_str()?.to_string();
+            let description = t["description"].as_str().unwrap_or("").to_string();
+            let input_schema = t.get("inputSchema").cloned().unwrap_or(json!({"type":"object","properties":{}}));
+            let safe_server = self.name.replace('-', "_").replace('.', "_");
+            Some(McpTool {
+                name: format!("mcp__{safe_server}__{original_name}"),
+                description,
+                input_schema,
+                server: self.name.clone(),
+                original_name,
+            })
+        }).collect())
+    }
+
+    async fn call_tool(&self, original_name: &str, arguments: Value) -> Result<String> {
+        let result = self.request("tools/call", json!({
+            "name": original_name,
+            "arguments": arguments,
+        })).await?;
+
+        // MCP returns content as an array of typed blocks
+        let content = result["content"].as_array().cloned().unwrap_or_default();
+        let text = content.iter()
+            .filter_map(|c| {
+                match c["type"].as_str() {
+                    Some("text") => c["text"].as_str().map(str::to_string),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let is_error = result["isError"].as_bool().unwrap_or(false);
+        Ok(json!({ "ok": !is_error, "result": text }).to_string())
+    }
+}
+
+// ── McpManager — holds all connected servers ──────────────────────────────────
+
+pub struct McpManager {
+    servers: Vec<(McpServer, Vec<McpTool>)>,
+}
+
+impl std::fmt::Debug for McpManager {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let names: Vec<&str> = self.servers.iter().map(|(s, _)| s.name.as_str()).collect();
+        write!(f, "McpManager {{ servers: {:?} }}", names)
+    }
+}
+
+impl McpManager {
+    /// Connect to all configured MCP servers. Errors for individual servers are
+    /// logged and skipped so one broken server doesn't block startup.
+    pub async fn connect(configs: &BTreeMap<String, McpServerConfig>) -> Self {
+        let mut servers = Vec::new();
+        for (name, cfg) in configs {
+            match McpServer::connect(name, cfg).await {
+                Ok(pair) => {
+                    eprintln!("\x1b[2m  MCP: connected to '{name}' ({} tools)\x1b[0m",
+                        pair.1.len());
+                    servers.push(pair);
+                }
+                Err(e) => {
+                    eprintln!("\x1b[33m  MCP: failed to connect to '{name}': {e:#}\x1b[0m");
+                }
+            }
+        }
+        Self { servers }
+    }
+
+    /// All tool definitions from all connected servers.
+    pub fn tool_definitions(&self) -> Vec<Value> {
+        self.servers.iter()
+            .flat_map(|(_, tools)| tools.iter().map(|t| t.to_definition()))
+            .collect()
+    }
+
+    /// All tool names from all connected servers.
+    pub fn tool_names(&self) -> Vec<String> {
+        self.servers.iter()
+            .flat_map(|(_, tools)| tools.iter().map(|t| t.name.clone()))
+            .collect()
+    }
+
+    /// Dispatch a call to the appropriate MCP server.
+    pub async fn call(&self, tool_name: &str, arguments: &str) -> Option<String> {
+        let args: Value = serde_json::from_str(arguments).unwrap_or(json!({}));
+        for (server, tools) in &self.servers {
+            if let Some(tool) = tools.iter().find(|t| t.name == tool_name) {
+                return Some(match server.call_tool(&tool.original_name, args).await {
+                    Ok(r) => r,
+                    Err(e) => json!({ "ok": false, "error": e.to_string() }).to_string(),
+                });
+            }
+        }
+        None
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.servers.is_empty()
+    }
+}

package/src/provider/command.rs

@@ -222,6 +222,7 @@ mod tests {
             workspace_context: None,
             history: vec![],
             image: None,
+            mcp: None,
         }
     }
 

package/src/provider/mod.rs

@@ -1,5 +1,5 @@
 mod command;
-mod openai_compatible;
+pub mod openai_compatible;
 
 use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
@@ -51,6 +51,8 @@ pub struct PromptRequest {
     pub history: Vec<ChatMessage>,
     /// Optional image grabbed from the clipboard for the current turn only.
     pub image: Option<ImageAttachment>,
+    /// Connected MCP servers (runtime only, not part of session history).
+    pub mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
 }
 
 /// How tool calls that modify the system (write/edit/run) should be handled.

package/src/provider/openai_compatible.rs

@@ -86,7 +86,11 @@ pub async fn ask(
             body["max_tokens"] = json!(max_tokens);
         }
         if tools_enabled {
-            body["tools"] = json!(tools::definitions(policy.allows_write_tools()));
+            let mut defs = tools::definitions(policy.allows_write_tools());
+            if let Some(m) = &request.mcp {
+                defs.extend(m.tool_definitions());
+            }
+            body["tools"] = json!(defs);
             body["tool_choice"] = json!("auto");
         }
 
@@ -168,7 +172,7 @@ pub async fn ask(
 
         messages.push(assistant_tool_message(&state));
         for call in &state.tool_calls {
-            let content = dispatch_tool(call, policy, &mut approval_state, events).await;
+            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,
@@ -209,7 +213,28 @@ async fn dispatch_tool(
     policy: ApprovalPolicy,
     approval_state: &mut ToolApprovalState,
     events: &UnboundedSender<StreamEvent>,
+    mcp: Option<&crate::mcp::McpManager>,
 ) -> String {
+    // Route MCP tools directly — no approval policy, no filesystem restrictions.
+    if tools::is_mcp_tool(&call.name) {
+        let summary = format!("mcp {}", &call.name[5..]); // strip "mcp__"
+        let _ = events.send(StreamEvent::ToolCall { summary: summary.clone() });
+        let result = if let Some(m) = mcp {
+            m.call(&call.name, &call.arguments).await
+                .unwrap_or_else(|| serde_json::json!({ "ok": false, "error": "server not found" }).to_string())
+        } else {
+            serde_json::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: 0,
+            error: err,
+        });
+        return result;
+    }
+
     let summary = tools::describe_call(&call.name, &call.arguments);
 
     // Plan tools — display only, no approval or filesystem access needed.
@@ -316,6 +341,10 @@ async fn dispatch_tool(
     result
 }
 
+pub fn parse_tool_result_status_pub(result: &str) -> (bool, Option<String>) {
+    parse_tool_result_status(result)
+}
+
 fn parse_tool_result_status(result: &str) -> (bool, Option<String>) {
     let Ok(json) = serde_json::from_str::<Value>(result) else {
         return (true, None);
@@ -686,14 +715,23 @@ fn build_messages(
     prompt_cache: bool,
 ) -> Vec<Value> {
     let mut messages = Vec::new();
-    if let Some(system) = &request.system {
-        messages.push(json!({ "role": "system", "content": system }));
-    }
-    if let Some(workspace_context) = &request.workspace_context {
-        messages.push(json!({ "role": "system", "content": workspace_context }));
-    }
-    messages
-        .push(json!({ "role": "system", "content": tools::guidance(policy.allows_write_tools()) }));
+
+    // Merge all system-level content into a single system message.
+    // Many providers (Qwen3, etc.) only allow one system message and require
+    // it to be the very first message — multiple system messages cause HTTP 400.
+    let guidance = tools::guidance(policy.allows_write_tools());
+    let system_content = [
+        request.system.as_deref(),
+        request.workspace_context.as_deref(),
+        Some(guidance.as_str()),
+    ]
+    .into_iter()
+    .flatten()
+    .collect::<Vec<_>>()
+    .join("\n\n");
+
+    messages.push(json!({ "role": "system", "content": system_content }));
+
     for message in &request.history {
         let role = match message.role {
             ChatRole::User => "user",

package/src/tools.rs

@@ -25,8 +25,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. \
-If you need to inspect, read, list, search, or check something, call the relevant tool immediately; \
+search text, read capped file snippets, fetch URLs, run git commands, and do a basic public web lookup. \
+Prefer tools over guessing. \
+If you need to inspect, read, list, search, fetch, or check something, call the relevant tool immediately; \
 do not end a response by saying you will inspect something later.",
     );
     if include_write {
@@ -56,6 +57,11 @@ pub fn is_write_tool(name: &str) -> bool {
     )
 }
 
+/// Whether a tool name belongs to an MCP server (prefix mcp__).
+pub fn is_mcp_tool(name: &str) -> bool {
+    name.starts_with("mcp__")
+}
+
 /// A short, human-readable summary of a tool call for confirmation prompts.
 pub fn describe_call(name: &str, arguments: &str) -> String {
     let args: Value = serde_json::from_str(arguments).unwrap_or(Value::Null);
@@ -74,6 +80,13 @@ 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")),
+        "git_status" => "git status".to_string(),
+        "git_diff"   => {
+            let path = field("path");
+            if path.is_empty() { "git diff".to_string() } else { format!("git diff {path}") }
+        }
+        "git_log"    => "git log".to_string(),
         "create_dir" => format!("create directory {}", field("path")),
         "write_file" => format!("write file {}", field("path")),
         "edit_file" => format!("edit file {}", field("path")),
@@ -202,6 +215,58 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
                 }
             }
         }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "fetch_url",
+                "description": "Fetch the content of a URL and return it as plain text. Strips HTML tags automatically.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "url": { "type": "string", "description": "URL to fetch." },
+                        "max_chars": { "type": "integer", "description": "Max characters to return (default 40000)." }
+                    },
+                    "required": ["url"]
+                }
+            }
+        }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "git_status",
+                "description": "Show the current git branch, staged/unstaged changes, and untracked files.",
+                "parameters": { "type": "object", "properties": {} }
+            }
+        }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "git_diff",
+                "description": "Show the git diff. Optionally limit to staged changes or a specific file path.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "staged": { "type": "boolean", "description": "Show staged diff (git diff --staged). Default false." },
+                        "path":   { "type": "string",  "description": "Limit diff to this file or directory." },
+                        "ref":    { "type": "string",  "description": "Diff against this ref (e.g. HEAD~1, main)." }
+                    }
+                }
+            }
+        }),
+        json!({
+            "type": "function",
+            "function": {
+                "name": "git_log",
+                "description": "Show recent git commit history.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "n":    { "type": "integer", "description": "Number of commits to show (default 20, max 100)." },
+                        "path": { "type": "string",  "description": "Limit log to commits touching this path." }
+                    }
+                }
+            }
+        }),
     ];
 
     if include_write {
@@ -274,14 +339,18 @@ pub fn definitions(include_write: bool) -> Vec<Value> {
 
 pub async fn run(name: &str, arguments: &str) -> String {
     let result = match name {
-        "list_dir" => list_dir(arguments).await,
+        "list_dir"   => list_dir(arguments).await,
         "find_files" => find_files(arguments).await,
         "search_text" => search_text(arguments).await,
-        "read_file" => read_file(arguments).await,
+        "read_file"  => read_file(arguments).await,
         "web_search" => web_search(arguments).await,
+        "fetch_url"  => fetch_url(arguments).await,
+        "git_status" => git_status(arguments).await,
+        "git_diff"   => git_diff(arguments).await,
+        "git_log"    => git_log(arguments).await,
         "create_dir" => create_dir(arguments).await,
         "write_file" => write_file(arguments).await,
-        "edit_file" => edit_file(arguments).await,
+        "edit_file"  => edit_file(arguments).await,
         "run_command" => run_command(arguments).await,
         _ => Err(anyhow!("unknown tool '{name}'")),
     };
@@ -503,6 +572,173 @@ async fn web_search(arguments: &str) -> Result<Value> {
     }))
 }
 
+// ── fetch_url ─────────────────────────────────────────────────────────────────
+
+async fn fetch_url(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args {
+        url: String,
+        #[serde(default)]
+        max_chars: Option<usize>,
+    }
+    let args: Args = parse_args(arguments)?;
+    let url = args.url.trim();
+    if url.is_empty() { bail!("url is required"); }
+    let max_chars = args.max_chars.unwrap_or(40_000);
+
+    let response = http_client()
+        .get(url)
+        .send()
+        .await
+        .with_context(|| format!("failed to fetch {url}"))?;
+
+    let status = response.status();
+    if !status.is_success() { bail!("HTTP {status}"); }
+
+    let content_type = response
+        .headers()
+        .get("content-type")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("text/plain")
+        .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();
+
+    Ok(json!({
+        "ok": true,
+        "url": url,
+        "content_type": content_type,
+        "text": text,
+        "truncated": truncated,
+    }))
+}
+
+fn html_to_text(html: &str) -> String {
+    let mut out = String::new();
+    let mut in_tag = false;
+    let mut tag_buf = String::new();
+    let mut skip_close: Option<String> = None;
+
+    for c in html.chars() {
+        if let Some(ref close) = skip_close {
+            tag_buf.push(c);
+            if tag_buf.to_lowercase().ends_with(&format!("</{}>", close)) {
+                skip_close = None;
+                tag_buf.clear();
+            }
+            continue;
+        }
+        if c == '<' {
+            in_tag = true;
+            tag_buf.clear();
+        } else if c == '>' {
+            in_tag = false;
+            let raw = tag_buf.trim().to_lowercase();
+            let name = raw.trim_start_matches('/').split_whitespace().next().unwrap_or("");
+            if matches!(name, "script" | "style") && !raw.starts_with('/') {
+                skip_close = Some(name.to_string());
+            }
+            if matches!(name, "p"|"div"|"h1"|"h2"|"h3"|"h4"|"h5"|"h6"|"br"|"li"|"tr"|"section"|"article") {
+                out.push('\n');
+            }
+            tag_buf.clear();
+        } else if in_tag {
+            tag_buf.push(c);
+        } else {
+            out.push(c);
+        }
+    }
+
+    let out = out
+        .replace("&amp;", "&").replace("&lt;", "<").replace("&gt;", ">")
+        .replace("&quot;", "\"").replace("&#39;", "'").replace("&nbsp;", " ")
+        .replace("&#x27;", "'").replace("&#x2F;", "/");
+
+    // Collapse blank lines
+    let mut result = String::new();
+    let mut blank = 0usize;
+    for line in out.lines() {
+        let t = line.trim();
+        if t.is_empty() {
+            blank += 1;
+            if blank <= 1 { result.push('\n'); }
+        } else {
+            blank = 0;
+            result.push_str(t);
+            result.push('\n');
+        }
+    }
+    result.trim().to_string()
+}
+
+// ── git tools ─────────────────────────────────────────────────────────────────
+
+async fn git_status(_arguments: &str) -> Result<Value> {
+    let out = tokio::process::Command::new("git")
+        .args(["status", "-sb"])
+        .kill_on_drop(true)
+        .output()
+        .await
+        .context("failed to run git")?;
+    Ok(json!({
+        "ok": out.status.success(),
+        "output": String::from_utf8_lossy(&out.stdout).trim().to_string(),
+        "error": if !out.status.success() { Some(String::from_utf8_lossy(&out.stderr).trim().to_string()) } else { None },
+    }))
+}
+
+async fn git_diff(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize, Default)]
+    struct Args {
+        #[serde(default)] staged: bool,
+        #[serde(default)] path: Option<String>,
+        #[serde(rename = "ref", default)] refspec: Option<String>,
+    }
+    let args: Args = serde_json::from_str(arguments).unwrap_or_default();
+    let mut cmd = tokio::process::Command::new("git");
+    cmd.arg("diff").kill_on_drop(true);
+    if args.staged { cmd.arg("--staged"); }
+    if let Some(r) = &args.refspec { cmd.arg(r); }
+    if let Some(p) = &args.path { cmd.arg("--").arg(p); }
+    let out = cmd.output().await.context("failed to run git diff")?;
+    let diff = String::from_utf8_lossy(&out.stdout).to_string();
+    let truncated = diff.len() > 30_000;
+    Ok(json!({
+        "ok": true,
+        "diff": if truncated { &diff[..30_000] } else { &diff },
+        "truncated": truncated,
+    }))
+}
+
+async fn git_log(arguments: &str) -> Result<Value> {
+    #[derive(Deserialize)]
+    struct Args {
+        #[serde(default = "default_n")] n: usize,
+        #[serde(default)] path: Option<String>,
+    }
+    fn default_n() -> usize { 20 }
+    let args: Args = serde_json::from_str(arguments).unwrap_or(Args { n: 20, path: None });
+    let n = args.n.clamp(1, 100);
+    let mut cmd = tokio::process::Command::new("git");
+    cmd.args(["log", "--oneline", "--decorate", &format!("-{n}")]).kill_on_drop(true);
+    if let Some(p) = &args.path { cmd.arg("--").arg(p); }
+    let out = cmd.output().await.context("failed to run git log")?;
+    Ok(json!({
+        "ok": out.status.success(),
+        "log": String::from_utf8_lossy(&out.stdout).trim().to_string(),
+        "error": if !out.status.success() { Some(String::from_utf8_lossy(&out.stderr).trim().to_string()) } else { None },
+    }))
+}
+
 async fn create_dir(arguments: &str) -> Result<Value> {
     let args: CreateDirArgs = parse_args(arguments)?;
     let path = resolve_writable_path(&args.path)?;

package/src/tui.rs

@@ -30,7 +30,8 @@ pub enum TuiEvent {
     Status(String),
     ToolCall(String),
     ToolDone { summary: String, ok: bool },
-    FileOp { verb: String, path: String, added: usize, removed: usize },
+    // 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> },
     Usage(Usage),
     Error(String),
@@ -45,7 +46,7 @@ enum Msg {
     User { text: String },
     Assistant { text: String },
     Tool { done: bool, ok: bool, text: String },
-    FileOp { verb: String, path: String, added: usize, removed: usize },
+    FileOp { verb: String, path: String, added: usize, removed: usize, diff: Vec<(bool, String)> },
     Error(String),
     System(String),
 }
@@ -107,6 +108,7 @@ pub struct App {
     // mode
     mode: Mode,
     confirm: Option<PendingConfirm>,
+    mouse_capture: bool, // when false, terminal native text selection works
 
     // history & session
     history: Vec<ChatMessage>,
@@ -118,6 +120,7 @@ pub struct App {
     pub options: AskOptions,
     pub workspace_context: Option<String>,
     pub policy: ApprovalPolicy,
+    pub mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
 
     // channels
     stream_rx: mpsc::UnboundedReceiver<TuiEvent>,
@@ -143,6 +146,7 @@ impl App {
         workspace_context: Option<String>,
         policy: ApprovalPolicy,
         key_rx: mpsc::UnboundedReceiver<Event>,
+        mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
     ) -> Self {
         let (stream_tx, stream_rx) = mpsc::unbounded_channel();
         let messages = history
@@ -183,6 +187,7 @@ impl App {
 
             mode: Mode::Input,
             confirm: None,
+            mouse_capture: true,
 
             history,
             session_path,
@@ -192,6 +197,7 @@ impl App {
             options,
             workspace_context,
             policy,
+            mcp,
 
             stream_rx,
             stream_tx,
@@ -211,10 +217,54 @@ pub async fn run(mut app: App) -> Result<Vec<ChatMessage>> {
     terminal.clear()?;
     let result = event_loop(&mut terminal, &mut app).await;
     ratatui::restore();
+    // Always release mouse capture on exit so the terminal works normally.
     crossterm::execute!(std::io::stdout(), DisableMouseCapture)?;
     result
 }
 
+fn set_mouse_capture(enabled: bool) {
+    if enabled {
+        let _ = crossterm::execute!(std::io::stdout(), EnableMouseCapture);
+    } else {
+        let _ = crossterm::execute!(std::io::stdout(), DisableMouseCapture);
+    }
+}
+
+
+fn write_to_clipboard(text: &str) -> bool {
+    // macOS
+    if cfg!(target_os = "macos") {
+        if let Ok(mut child) = std::process::Command::new("pbcopy").stdin(std::process::Stdio::piped()).spawn() {
+            use std::io::Write;
+            if let Some(stdin) = child.stdin.as_mut() {
+                let _ = stdin.write_all(text.as_bytes());
+            }
+            return child.wait().map(|s| s.success()).unwrap_or(false);
+        }
+    }
+    // Linux — try wl-copy (Wayland) then xclip (X11) then xsel
+    for cmd in &[
+        ("wl-copy", vec![]),
+        ("xclip", vec!["-selection", "clipboard"]),
+        ("xsel", vec!["--clipboard", "--input"]),
+    ] {
+        if let Ok(mut child) = std::process::Command::new(cmd.0)
+            .args(&cmd.1)
+            .stdin(std::process::Stdio::piped())
+            .spawn()
+        {
+            use std::io::Write;
+            if let Some(stdin) = child.stdin.as_mut() {
+                let _ = stdin.write_all(text.as_bytes());
+            }
+            if child.wait().map(|s| s.success()).unwrap_or(false) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 async fn event_loop(terminal: &mut DefaultTerminal, app: &mut App) -> Result<Vec<ChatMessage>> {
     loop {
         terminal.draw(|f| render(f, app))?;
@@ -244,6 +294,26 @@ async fn handle_event(app: &mut App, event: Event) -> Result<()> {
     match event {
         Event::Mouse(MouseEvent { kind, .. }) => handle_mouse(app, kind),
         Event::Key(key) => handle_key(app, key).await?,
+        // Cmd+V / terminal paste — insert text, or attach image if paste is empty
+        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.last_image_fp = None;
+                        return Ok(());
+                    }
+                }
+            } else {
+                let normalized = text.replace('\r', "\n");
+                app.input.insert_str(app.input_cursor, &normalized);
+                app.input_cursor += normalized.len();
+                app.hist_idx = None;
+            }
+        }
         Event::Resize(_, _) => {}
         _ => {}
     }
@@ -339,13 +409,32 @@ 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;
         }
-        KeyCode::Char('v') if modifiers.contains(KeyModifiers::CONTROL) && app.images_available => {
-            if let Some(img) = crate::grab_clipboard_image() {
-                app.pending_image = Some(img);
-                app.last_image_fp = None; // force re-attach
+        // Ctrl+V — universal paste: image first, then clipboard text
+        KeyCode::Char('v') if modifiers.contains(KeyModifiers::CONTROL) => {
+            if app.images_available {
+                if let Some(img) = crate::grab_clipboard_image() {
+                    app.pending_image = Some(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;
+                }
             }
         }
 
+        // Ctrl+M — toggle mouse capture (scroll mode ↔ select mode)
+        KeyCode::Char('m') if modifiers.contains(KeyModifiers::CONTROL) => {
+            app.mouse_capture = !app.mouse_capture;
+            set_mouse_capture(app.mouse_capture);
+        }
+
         // Editing
         KeyCode::Backspace => {
             if app.input_cursor > 0 {
@@ -450,10 +539,11 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
         }
         "/help" => {
             app.messages.push(Msg::System(
-                "Commands: /clear  /export [path]  /model [name]  /provider [name]  /status  /exit\n\
+                "Commands: /clear  /copy  /export [path]  /model [name]  /provider [name]  /status  /exit\n\
                  Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
                  Ctrl+W delete-word  Ctrl+U clear-line  Ctrl+V paste image\n\
-                 PageUp/Dn or scroll wheel to scroll history".into(),
+                 Ctrl+M toggle scroll/select mode  PageUp/Dn scroll\n\
+                 [scroll] = mouse wheel scrolls  [select] = mouse selects text to copy".into(),
             ));
             app.input.clear();
             app.input_cursor = 0;
@@ -474,6 +564,24 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.input_cursor = 0;
             true
         }
+        "/copy" => {
+            let last = app.messages.iter().rev().find_map(|m| {
+                if let Msg::Assistant { text } = m { Some(text.clone()) } else { None }
+            });
+            match last {
+                Some(text) => {
+                    if write_to_clipboard(&text) {
+                        app.messages.push(Msg::System("Last response copied to clipboard.".into()));
+                    } else {
+                        app.messages.push(Msg::Error("Could not write to clipboard (pbcopy/xclip/wl-copy not found).".into()));
+                    }
+                }
+                None => app.messages.push(Msg::System("No assistant response to copy yet.".into())),
+            }
+            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() {
@@ -576,6 +684,7 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
     let history = app.history.clone();
     let workspace_context = app.workspace_context.clone();
     let policy = app.policy;
+    let mcp_arc = app.mcp.clone();
     let tui_tx = app.stream_tx.clone();
     let tui_tx2 = app.stream_tx.clone();
 
@@ -588,6 +697,7 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
             workspace_context,
             history,
             image,
+            mcp: mcp_arc,
         };
         let result = crate::provider::ask(&config, &provider_name, request, policy, &stream_tx_inner).await;
         drop(stream_tx_inner);
@@ -610,8 +720,13 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
                 StreamEvent::Status { message } => TuiEvent::Status(message),
                 StreamEvent::ToolCall { summary } => TuiEvent::ToolCall(summary),
                 StreamEvent::ToolResult { summary, ok, .. } => TuiEvent::ToolDone { summary, ok },
-                StreamEvent::FileOp { verb, path, added, removed, .. } =>
-                    TuiEvent::FileOp { verb, path, added, removed },
+                StreamEvent::FileOp { verb, path, added, removed, preview, .. } => {
+                    let diff = preview.into_iter().map(|dl| {
+                        let is_add = matches!(dl.kind, crate::provider::DiffKind::Add);
+                        (is_add, dl.text)
+                    }).collect();
+                    TuiEvent::FileOp { verb, path, added, removed, diff }
+                }
                 StreamEvent::Confirm { preview, reply } => {
                     let summary = match &preview {
                         ToolConfirmPreview::FileOp { verb, path, added, removed, .. } =>
@@ -654,10 +769,10 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             commit_pending_tool(app, ok);
             app.tool_status = "Thinking".to_string();
         }
-        TuiEvent::FileOp { verb, path, added, removed } => {
+        TuiEvent::FileOp { verb, path, added, removed, diff } => {
             flush_streaming_buf(app);
             commit_pending_tool(app, true);
-            app.messages.push(Msg::FileOp { verb, path, added, removed });
+            app.messages.push(Msg::FileOp { verb, path, added, removed, diff });
         }
         TuiEvent::Confirm { summary, reply } => {
             flush_streaming_buf(app);
@@ -799,7 +914,7 @@ fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
                 )));
                 lines.push(Line::from(""));
             }
-            Msg::FileOp { verb, path, added, removed } => {
+            Msg::FileOp { verb, path, added, removed, diff } => {
                 lines.push(Line::from(vec![
                     Span::styled("  📄 ", Style::default().fg(Color::Rgb(229, 192, 123))),
                     Span::styled(format!("{verb} "), Style::default().fg(Color::White)),
@@ -807,6 +922,25 @@ fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
                     Span::styled(format!("  +{added}"), Style::default().fg(Color::Rgb(152, 195, 121))),
                     Span::styled(format!(" -{removed}"), Style::default().fg(Color::Rgb(224, 108, 117))),
                 ]));
+                // Show inline diff (up to 40 lines)
+                for (is_add, line) in diff.iter().take(40) {
+                    let (prefix, color) = if *is_add {
+                        ("  + ", Color::Rgb(152, 195, 121))
+                    } else {
+                        ("  - ", Color::Rgb(224, 108, 117))
+                    };
+                    let bg = if *is_add { Color::Rgb(20, 35, 20) } else { Color::Rgb(35, 20, 20) };
+                    lines.push(Line::from(Span::styled(
+                        format!("{prefix}{}", &line.trim_end().chars().take(width.saturating_sub(6)).collect::<String>()),
+                        Style::default().fg(color).bg(bg),
+                    )));
+                }
+                if diff.len() > 40 {
+                    lines.push(Line::from(Span::styled(
+                        format!("  … {} more lines", diff.len() - 40),
+                        Style::default().fg(Color::DarkGray),
+                    )));
+                }
                 lines.push(Line::from(""));
             }
             Msg::Error(msg) => {
@@ -921,8 +1055,9 @@ fn render_status(frame: &mut Frame, area: Rect, app: &App) {
             Style::default().fg(Color::Black).bg(Color::Rgb(229, 192, 123)),
         )
     } else {
-        let hints = "PageUp/Dn · scroll · /help";
-        let left = format!(" {}", app.cwd);
+        let mode_tag = if app.mouse_capture { "[scroll]" } else { "[select]" };
+        let hints = "Ctrl+M mode · /copy · /help";
+        let left = format!(" {} {mode_tag}", app.cwd);
         let right = format!("{hints} ");
         let gap = (area.width as usize)
             .saturating_sub(left.chars().count() + right.chars().count());