feat: add ClipboardToolkit — copy text, notes, tasks, links to clipboard

4 tools: copy_to_clipboard, copy_note, copy_task, copy_link.
Uses pbcopy (macOS) or xclip (Linux). Accepts optional store + memory
for cross-toolkit copy (e.g. "copy that note to my clipboard").
Wired into daemon's _build_toolkits().

Author: chiruu12

src/hive/__init__.py

@@ -71,6 +71,7 @@
     create_stt_provider,
 )
 from hive.tools.alarms import AlarmChecker, AlarmToolkit
+from hive.tools.clipboard import ClipboardToolkit
 from hive.tools.comms import CommsToolkit
 from hive.tools.knowledge import KnowledgeToolkit
 from hive.tools.links import LinkToolkit
@@ -93,6 +94,7 @@
     "Hive",
     "AgentState",
     "AgentStatus",
+    "ClipboardToolkit",
     "CommsToolkit",
     "ConversationMemory",
     "DaemonAgentAdapter",

src/hive/daemon/loop.py

@@ -33,6 +33,7 @@
 from hive.tools.delegation import DaemonDelegationToolkit
 from hive.tools.file import FileToolkit
 from hive.tools.git import GitToolkit
+from hive.tools.clipboard import ClipboardToolkit
 from hive.tools.knowledge import KnowledgeToolkit
 from hive.tools.links import LinkToolkit
 from hive.tools.memory import MemoryToolkit
@@ -152,6 +153,7 @@ def _build_toolkits(self, agent_id: str) -> list[Any]:
             AlarmToolkit(self._store),
             KnowledgeToolkit(self._get_memory(agent_id)),
             LinkToolkit(self._get_memory(agent_id)),
+            ClipboardToolkit(store=self._store, memory=self._get_memory(agent_id)),
         ]
         if self._economy_enabled and self._ctx.world is not None:
             toolkits.insert(0, WorldToolkit(self._ctx.world, agent_id))

src/hive/tools/clipboard/__init__.py

@@ -0,0 +1,5 @@
+"""Clipboard toolkit."""
+
+from hive.tools.clipboard.toolkit import ClipboardToolkit
+
+__all__ = ["ClipboardToolkit"]

src/hive/tools/clipboard/toolkit.py

@@ -0,0 +1,189 @@
+"""Clipboard toolkit — copy text, notes, tasks, and links to the system clipboard."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import platform
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from hive.tools.base import Toolkit, tool
+
+if TYPE_CHECKING:
+    from hive.memory.semantic import SemanticMemory
+    from hive.memory.store import HiveStore
+
+logger = logging.getLogger(__name__)
+
+
+async def _copy_to_system_clipboard(text: str) -> bool:
+    """Copy text to system clipboard. Supports macOS and Linux."""
+    system = platform.system()
+    if system == "Darwin":
+        cmd = ["pbcopy"]
+    elif system == "Linux":
+        cmd = ["xclip", "-selection", "clipboard"]
+    else:
+        logger.warning("Clipboard not supported on %s", system)
+        return False
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await asyncio.wait_for(proc.communicate(input=text.encode()), timeout=5)
+        return proc.returncode == 0
+    except Exception as e:
+        logger.warning("Clipboard copy failed: %s", e)
+        return False
+
+
+class ClipboardToolkit(Toolkit):
+    """Tools for copying content to the system clipboard.
+
+    Usage:
+        # With access to store + memory (can copy tasks, notes, links):
+        tk = ClipboardToolkit(store=hive_store, memory=semantic_memory)
+
+        # Standalone (copy text only):
+        tk = ClipboardToolkit()
+    """
+
+    def __init__(
+        self,
+        store: HiveStore | None = None,
+        memory: SemanticMemory | None = None,
+        db_path: str | Path | None = None,
+        memory_dir: str | Path | None = None,
+    ) -> None:
+        self._store: HiveStore | None = None
+        self._memory: SemanticMemory | None = None
+        self._memory_dir: Path | None = None
+        self._initialized = False
+
+        if store is not None:
+            self._store = store
+            self._initialized = True
+        elif db_path is not None:
+            from hive.memory.store import HiveStore as _Store
+
+            self._store = _Store(Path(db_path))
+
+        if memory is not None:
+            self._memory = memory
+        elif memory_dir is not None:
+            self._memory_dir = Path(memory_dir)
+
+    def bind(self, agent_id: str) -> None:
+        super().bind(agent_id)
+        if self._memory_dir is not None:
+            from hive.memory.semantic import SemanticMemory
+
+            self._memory = SemanticMemory(self._memory_dir, agent_id)
+
+    def rebind(self, agent_id: str) -> None:
+        super().rebind(agent_id)
+        if self._memory_dir is not None:
+            from hive.memory.semantic import SemanticMemory
+
+            self._memory = SemanticMemory(self._memory_dir, agent_id)
+
+    async def _ensure_init(self) -> None:
+        if not self._initialized and self._store is not None:
+            await self._store.initialize()
+            self._initialized = True
+
+    @property
+    def instructions(self) -> str:
+        return "You can copy text, notes, tasks, or links to the user's clipboard."
+
+    @tool()
+    async def copy_to_clipboard(self, text: str) -> str:
+        """Copy text to the system clipboard.
+
+        Args:
+            text: The text to copy.
+        """
+        ok = await _copy_to_system_clipboard(text)
+        if ok:
+            preview = text[:80] + ("..." if len(text) > 80 else "")
+            return f"Copied to clipboard: {preview}"
+        return "Failed to copy to clipboard."
+
+    @tool()
+    async def copy_note(self, note_id: str) -> str:
+        """Copy a note's content to the clipboard.
+
+        Args:
+            note_id: The note/memory ID to copy.
+        """
+        if self._memory is None:
+            return "No knowledge base available."
+
+        record = await self._memory.recall(note_id)
+        if record is None:
+            return f"Note {note_id} not found."
+
+        ok = await _copy_to_system_clipboard(record.thought)
+        if ok:
+            preview = record.thought[:80] + ("..." if len(record.thought) > 80 else "")
+            return f"Copied note to clipboard: {preview}"
+        return "Failed to copy to clipboard."
+
+    @tool()
+    async def copy_task(self, task_id: str) -> str:
+        """Copy a task's description to the clipboard.
+
+        Args:
+            task_id: The task ID to copy.
+        """
+        if self._store is None:
+            return "No task store available."
+
+        await self._ensure_init()
+        tasks = await self._store.list_tasks(self._agent_id, "pending")
+        tasks += await self._store.list_tasks(self._agent_id, "done")
+
+        task = next((t for t in tasks if t["task_id"] == task_id), None)
+        if task is None:
+            return f"Task {task_id} not found."
+
+        text = task["description"]
+        if task.get("due_date"):
+            text += f" (due: {task['due_date']})"
+
+        ok = await _copy_to_system_clipboard(text)
+        if ok:
+            return f"Copied task to clipboard: {text[:80]}"
+        return "Failed to copy to clipboard."
+
+    @tool()
+    async def copy_link(self, query: str) -> str:
+        """Find a saved link by search and copy its URL to the clipboard.
+
+        Args:
+            query: Search query to find the link.
+        """
+        if self._memory is None:
+            return "No knowledge base available."
+
+        results = await self._memory.search(query, top_k=5)
+        links = [r for r in results if r.metadata.get("type") == "link"]
+
+        if not links:
+            return f"No saved link matching '{query}'."
+
+        link = links[0]
+        url = link.metadata.get("url", "")
+        if not url:
+            return "Link found but has no URL."
+
+        ok = await _copy_to_system_clipboard(url)
+        if ok:
+            title = link.metadata.get("title", url)
+            return f"Copied URL to clipboard: {title} ({url})"
+        return "Failed to copy to clipboard."

tests/tools/test_clipboard.py

@@ -0,0 +1,111 @@
+"""Tests for ClipboardToolkit."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from hive.memory.semantic import SemanticMemory
+from hive.tools.clipboard.toolkit import ClipboardToolkit
+
+
+@pytest.fixture
+def memory(tmp_path: Path) -> SemanticMemory:
+    return SemanticMemory(tmp_path, "test-agent")
+
+
+@pytest.fixture
+def toolkit(memory: SemanticMemory) -> ClipboardToolkit:
+    tk = ClipboardToolkit(memory=memory)
+    tk.bind("test-agent")
+    return tk
+
+
+class TestClipboardToolkit:
+    def test_standalone_creation(self) -> None:
+        tk = ClipboardToolkit()
+        tk.bind("agent")
+        tools = tk.get_tools()
+        tool_names = {t.name for t in tools}
+        assert "copy_to_clipboard" in tool_names
+        assert "copy_note" in tool_names
+        assert "copy_task" in tool_names
+        assert "copy_link" in tool_names
+
+    @pytest.mark.asyncio
+    async def test_copy_to_clipboard(self, toolkit: ClipboardToolkit) -> None:
+        with patch(
+            "hive.tools.clipboard.toolkit._copy_to_system_clipboard",
+            new_callable=AsyncMock,
+            return_value=True,
+        ):
+            result = await toolkit.copy_to_clipboard("hello world")
+        assert "Copied to clipboard" in result
+        assert "hello world" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_to_clipboard_failure(self, toolkit: ClipboardToolkit) -> None:
+        with patch(
+            "hive.tools.clipboard.toolkit._copy_to_system_clipboard",
+            new_callable=AsyncMock,
+            return_value=False,
+        ):
+            result = await toolkit.copy_to_clipboard("test")
+        assert "Failed" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_note(
+        self, toolkit: ClipboardToolkit, memory: SemanticMemory
+    ) -> None:
+        mid = await memory.store("Important meeting notes", {"tags": "work"})
+        with patch(
+            "hive.tools.clipboard.toolkit._copy_to_system_clipboard",
+            new_callable=AsyncMock,
+            return_value=True,
+        ):
+            result = await toolkit.copy_note(mid)
+        assert "Copied note" in result
+        assert "Important meeting notes" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_note_not_found(self, toolkit: ClipboardToolkit) -> None:
+        result = await toolkit.copy_note("nonexistent")
+        assert "not found" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_note_no_memory(self) -> None:
+        tk = ClipboardToolkit()
+        tk.bind("agent")
+        result = await tk.copy_note("some-id")
+        assert "No knowledge base" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_link(
+        self, toolkit: ClipboardToolkit, memory: SemanticMemory
+    ) -> None:
+        await memory.store(
+            "Python docs",
+            {"type": "link", "url": "https://python.org", "title": "Python"},
+        )
+        with patch(
+            "hive.tools.clipboard.toolkit._copy_to_system_clipboard",
+            new_callable=AsyncMock,
+            return_value=True,
+        ):
+            result = await toolkit.copy_link("python")
+        assert "Copied URL" in result
+        assert "python.org" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_link_not_found(self, toolkit: ClipboardToolkit) -> None:
+        result = await toolkit.copy_link("nonexistent-thing-xyz")
+        assert "No saved link" in result
+
+    @pytest.mark.asyncio
+    async def test_copy_task_no_store(self) -> None:
+        tk = ClipboardToolkit()
+        tk.bind("agent")
+        result = await tk.copy_task("task-123")
+        assert "No task store" in result