feat(mcp): Add 5 developer enhancements (git, logs, clipboard watcher, ast skeleton, nvim ghost text)

server/src/handlers/vision.rs

@@ -0,0 +1,195 @@
+use crate::router::McpTool;
+use crate::state::MemoryState;
+use crate::tools::{ReadClipboardTool, WriteClipboardTool};
+use async_trait::async_trait;
+use image::{imageops::FilterType, ImageBuffer};
+use serde_json::{json, Value};
+use std::sync::Arc;
+use clipboard_win::{formats, get_clipboard, Clipboard, raw, Setter};
+use arboard::ImageData;
+use std::borrow::Cow;
+
+pub struct WriteClipboardHandler;
+
+#[async_trait]
+impl McpTool for WriteClipboardHandler {
+    fn name(&self) -> &'static str {
+        "write_clipboard"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<WriteClipboardTool>(
+            "write_clipboard",
+            "Write text, HTML, files, and/or images directly to the OS clipboard.",
+        )
+    }
+
+    async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> Result<String, String> {
+        let tool_args: WriteClipboardTool =
+            serde_json::from_value(args).map_err(|e| format!("Invalid args: {}", e))?;
+            
+        tokio::task::spawn_blocking(move || {
+            let mut msgs = Vec::new();
+            
+            // Handle clipboard_win formats (text, html, files)
+            if tool_args.text.is_some() || tool_args.html.is_some() || tool_args.files.is_some() {
+                if let Ok(_clip) = Clipboard::new_attempts(3) {
+                    if let Some(text) = &tool_args.text {
+                        if clipboard_win::set_clipboard_string(text).is_ok() {
+                            msgs.push("Wrote text");
+                        }
+                    }
+                    if let Some(html) = &tool_args.html {
+                        if formats::Html::new().unwrap().write_clipboard(html).is_ok() {
+                            msgs.push("Wrote HTML");
+                        }
+                    }
+                    if let Some(files) = &tool_args.files {
+                        if raw::set_file_list(files).is_ok() {
+                            msgs.push("Wrote FileList");
+                        }
+                    }
+                }
+            }
+            
+            // Handle arboard for image
+            if let Some(image_path) = &tool_args.image_path {
+                match image::open(image_path) {
+                    Ok(img) => {
+                        let rgba = img.into_rgba8();
+                        let (w, h) = rgba.dimensions();
+                        let img_data = ImageData {
+                            width: w as usize,
+                            height: h as usize,
+                            bytes: Cow::Owned(rgba.into_raw()),
+                        };
+                        if let Ok(mut clipboard) = arboard::Clipboard::new() {
+                            if clipboard.set_image(img_data).is_ok() {
+                                msgs.push("Wrote image");
+                            } else {
+                                return Err("Failed to write image to clipboard".to_string());
+                            }
+                        }
+                    },
+                    Err(e) => return Err(format!("Failed to open image {}: {}", image_path, e)),
+                }
+            }
+            
+            if msgs.is_empty() {
+                Ok("No valid clipboard data provided or failed to write.".to_string())
+            } else {
+                Ok(format!("Successfully populated clipboard: {}", msgs.join(", ")))
+            }
+        })
+        .await
+        .map_err(|e| format!("Task panic: {}", e))?
+    }
+}
+
+pub struct ReadClipboardHandler;
+
+#[async_trait]
+impl McpTool for ReadClipboardHandler {
+    fn name(&self) -> &'static str {
+        "read_clipboard"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<ReadClipboardTool>(
+            "read_clipboard",
+            "Read the current OS clipboard. Extracts text, HTML, file paths, and/or an image if available.",
+        )
+    }
+
+    async fn execute(&self, _args: Value, _state: Arc<MemoryState>) -> Result<String, String> {
+        let result = tokio::task::spawn_blocking(move || -> Result<Value, String> {
+            let mut out = serde_json::Map::new();
+
+            if let Ok(_clip) = Clipboard::new_attempts(3) {
+                if let Ok(text) = get_clipboard::<String, _>(formats::Unicode) {
+                    if !text.trim().is_empty() {
+                        out.insert("text".into(), json!(text));
+                    }
+                }
+                if let Ok(html) = get_clipboard::<String, _>(formats::Html::new().unwrap()) {
+                    if !html.trim().is_empty() {
+                        out.insert("html".into(), json!(html));
+                    }
+                }
+                if let Ok(files) = get_clipboard::<Vec<String>, _>(formats::FileList) {
+                    if !files.is_empty() {
+                        out.insert("files".into(), json!(files));
+                    }
+                }
+            }
+
+            if let Ok(mut clipboard) = arboard::Clipboard::new() {
+                if let Ok(image_data) = clipboard.get_image() {
+                    if let Some(img) = ImageBuffer::<image::Rgba<u8>, _>::from_raw(
+                        image_data.width as u32,
+                        image_data.height as u32,
+                        image_data.bytes.into_owned(),
+                    ) {
+                        let mut dynamic_img = image::DynamicImage::ImageRgba8(img);
+                        let max_dim = 1024;
+                        if dynamic_img.width() > max_dim || dynamic_img.height() > max_dim {
+                            dynamic_img = dynamic_img.resize(max_dim, max_dim, FilterType::Lanczos3);
+                        }
+                        let rgb_img = dynamic_img.into_rgb8();
+
+                        let cache_dir = dirs::home_dir()
+                            .unwrap_or_default()
+                            .join(".gemini/mcp_memory/clipboard");
+                        let _ = std::fs::create_dir_all(&cache_dir);
+
+                        let timestamp = std::time::SystemTime::now()
+                            .duration_since(std::time::UNIX_EPOCH)
+                            .unwrap()
+                            .as_secs();
+                        let file_path = cache_dir.join(format!("clipboard_{}.jpg", timestamp));
+
+                        if rgb_img.save_with_format(&file_path, image::ImageFormat::Jpeg).is_ok() {
+                            out.insert("image_path".into(), json!(file_path.to_string_lossy().to_string()));
+                        }
+                    }
+                }
+            }
+
+            Ok(Value::Object(out))
+        })
+        .await
+        .map_err(|e| format!("Task panic: {}", e))??;
+
+        Ok(serde_json::to_string_pretty(&result).unwrap())
+    }
+}
+use crate::tools::ToggleClipboardWatchModeTool;
+
+pub struct ToggleClipboardWatchModeHandler;
+
+#[async_trait]
+impl McpTool for ToggleClipboardWatchModeHandler {
+    fn name(&self) -> &'static str {
+        "toggle_clipboard_watch_mode"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<ToggleClipboardWatchModeTool>(
+            "toggle_clipboard_watch_mode",
+            "Enable or disable clipboard watch mode (auto-ingesting into StickyNotes).",
+        )
+    }
+
+    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> Result<String, String> {
+        let tool_args: ToggleClipboardWatchModeTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        
+        let mut watch_mode = state.clipboard_watch_mode.write().await;
+        *watch_mode = tool_args.enable;
+
+        if tool_args.enable {
+            Ok("Clipboard watch mode enabled. Changes will be ingested as StickyNotes.".to_string())
+        } else {
+            Ok("Clipboard watch mode disabled.".to_string())
+        }
+    }
+}