agentpool 2.2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_commands/pool.py

@@ -0,0 +1,260 @@
+"""Pool-level commands for managing agent pools and configurations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentpool.agents.base_agent import BaseAgent
+from agentpool_commands.base import NodeCommand
+
+
+if TYPE_CHECKING:
+    from slashed import CommandContext
+
+    from agentpool.messaging.context import NodeContext
+
+
+class ListPoolsCommand(NodeCommand):
+    """List available agent pool configurations.
+
+    Examples:
+      /list-pools
+    """
+
+    name = "list-pools"
+    category = "pool"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext[Any]]) -> None:
+        """List available pool configurations.
+
+        Args:
+            ctx: Command context with node context
+        """
+        from agentpool_cli import agent_store
+
+        try:
+            output_lines = ["## 🏊 Agent Pool Configurations\n"]
+
+            # Show current pool info
+            output_lines.append("### 📍 Current Pool")
+
+            # Get config path from context config (works for all agent types)
+            current_config = ctx.context.config.config_file_path if ctx.context.config else None
+            if current_config:
+                output_lines.append(f"**Config:** `{current_config}`")
+            else:
+                output_lines.append("**Config:** *(default/built-in)*")
+
+            # Show agents in current pool
+            pool = ctx.context.pool
+            if pool:
+                agent_names = list(pool.all_agents.keys())
+                output_lines.append(f"**Agents:** {', '.join(f'`{n}`' for n in agent_names)}")
+                output_lines.append(f"**Active agent:** `{ctx.context.node.name}`")
+            else:
+                output_lines.append("**No pool available**")
+            output_lines.append("")
+
+            # Show stored configurations
+            output_lines.append("### 💾 Stored Configurations")
+            stored_configs = agent_store.list_configs()
+            active_config = agent_store.get_active()
+
+            if not stored_configs:
+                output_lines.append("*No stored configurations*")
+                output_lines.append("")
+                output_lines.append("Use `agentpool add <name> <path>` to add configurations.")
+            else:
+                # Build markdown table
+                output_lines.append("| Name | Path |")
+                output_lines.append("|------|------|")
+                for name, path in stored_configs:
+                    is_active = active_config and active_config.name == name
+                    is_current = current_config and path == current_config
+                    markers = []
+                    if is_active:
+                        markers.append("default")
+                    if is_current:
+                        markers.append("current")
+                    name_col = f"{name} ({', '.join(markers)})" if markers else name
+                    output_lines.append(f"| {name_col} | `{path}` |")
+
+            output_lines.append("")
+            output_lines.append("*Use `/set-pool <name>` or `/set-pool <path>` to switch pools.*")
+
+            await ctx.output.print("\n".join(output_lines))
+
+        except Exception as e:  # noqa: BLE001
+            await ctx.output.print(f"❌ **Error listing pools:** {e}")
+
+
+class CompactCommand(NodeCommand):
+    """Compact the conversation history to reduce context size.
+
+    Uses the configured compaction pipeline from the agent pool manifest,
+    or falls back to a default summarizing pipeline.
+
+    Options:
+      --preset <name>   Use a specific preset (minimal, balanced, summarizing)
+
+    Examples:
+      /compact
+      /compact --preset=minimal
+    """
+
+    name = "compact"
+    category = "pool"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[Any]],
+        *,
+        preset: str | None = None,
+    ) -> None:
+        """Compact the conversation history.
+
+        Args:
+            ctx: Command context with node context
+            preset: Optional preset name (minimal, balanced, summarizing)
+        """
+        from agentpool.agents.base_agent import BaseAgent
+
+        # Get agent from context
+        agent = ctx.context.node
+        if not isinstance(agent, BaseAgent):
+            await ctx.output.print(
+                "❌ **This command requires an agent with conversation history**"
+            )
+            return
+
+        # Check if there's any history to compact
+        if not agent.conversation.get_history():
+            await ctx.output.print("📭 **No message history to compact**")
+            return
+
+        try:
+            # Get compaction pipeline
+            from agentpool.messaging.compaction import (
+                balanced_context,
+                minimal_context,
+                summarizing_context,
+            )
+
+            pipeline = None
+
+            # Check for preset override
+            if preset:
+                match preset.lower():
+                    case "minimal":
+                        pipeline = minimal_context()
+                    case "balanced":
+                        pipeline = balanced_context()
+                    case "summarizing":
+                        pipeline = summarizing_context()
+                    case _:
+                        await ctx.output.print(
+                            f"⚠️ **Unknown preset:** `{preset}`\n"
+                            "Available: minimal, balanced, summarizing"
+                        )
+                        return
+
+            # Fall back to pool's configured pipeline
+            if pipeline is None and ctx.context.pool:
+                pipeline = ctx.context.pool.compaction_pipeline
+
+            # Fall back to default summarizing pipeline
+            if pipeline is None:
+                pipeline = summarizing_context()
+
+            await ctx.output.print("🔄 **Compacting conversation history...**")
+
+            # Apply the pipeline using shared helper
+            from agentpool.messaging.compaction import compact_conversation
+
+            original_count, compacted_count = await compact_conversation(
+                pipeline, agent.conversation
+            )
+            reduction = original_count - compacted_count
+
+            await ctx.output.print(
+                f"✅ **Compaction complete**\n"
+                f"- Messages: {original_count} → {compacted_count} ({reduction} removed)\n"
+                f"- Reduction: {reduction / original_count * 100:.1f}%"
+                if original_count > 0
+                else "✅ **Compaction complete** (no messages)"
+            )
+
+        except Exception as e:  # noqa: BLE001
+            await ctx.output.print(f"❌ **Error compacting history:** {e}")
+
+
+class SpawnCommand(NodeCommand):
+    """Spawn a subagent to execute a specific task.
+
+    The subagent runs and its progress is streamed back through the event system.
+    How the progress is displayed depends on the protocol (tool box in ACP, inline, etc.).
+
+    Examples:
+      /spawn agent-name "task description"
+      /spawn code-reviewer "Review main.py for bugs"
+    """
+
+    name = "spawn"
+    category = "pool"
+
+    @classmethod
+    def supports_node(cls, node: Any) -> bool:
+        """Only available when running from an agent (needs events)."""
+        return isinstance(node, BaseAgent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[Any]],
+        agent_name: str,
+        task_prompt: str,
+    ) -> None:
+        """Spawn a subagent to execute a task.
+
+        Args:
+            ctx: Command context with node context
+            agent_name: Name of the agent to spawn
+            task_prompt: Task prompt for the subagent
+        """
+        from agentpool.agents.events import SubAgentEvent
+
+        pool = ctx.context.pool
+        if not pool:
+            await ctx.output.print("❌ **No agent pool available**")
+            return
+
+        if agent_name not in pool.nodes:
+            available = list(pool.nodes.keys())
+            await ctx.output.print(
+                f"❌ **Agent** `{agent_name}` **not found**\n\n"
+                f"Available agents: {', '.join(available)}"
+            )
+            return
+
+        from agentpool.common_types import SupportsRunStream
+
+        agent = pool.nodes[agent_name]
+
+        # Check if node supports streaming
+        if not isinstance(agent, SupportsRunStream):
+            await ctx.output.print(f"❌ **Agent** `{agent_name}` **does not support streaming**")
+            return
+
+        # Stream subagent execution by wrapping events in SubAgentEvent
+        # The event handler system (ACP, OpenCode, CLI, etc.) handles rendering
+        # Get parent agent's context to access event emitter
+        parent_ctx = ctx.context.agent.get_context()
+
+        async for event in agent.run_stream(task_prompt):
+            wrapped = SubAgentEvent(
+                source_name=agent_name,
+                source_type="agent",
+                event=event,
+                depth=1,
+            )
+            # Emit to parent agent's event stream
+            await parent_ctx.events.emit_event(wrapped)

agentpool_commands/session.py

@@ -23,7 +23,7 @@ class ClearCommand(AgentCommand):
         Args:
             ctx: Command context
         """
-        ctx.context.agent.conversation.clear()
+        await ctx.context.agent.conversation.clear()
         await ctx.print("🧹 **Chat history cleared**")
 
 

agentpool_commands/text_sharing/__init__.py

@@ -0,0 +1,119 @@
+"""Text sharing services for sharing content via paste services."""
+
+from __future__ import annotations
+
+from typing import Literal, assert_never, overload
+
+from agentpool_commands.text_sharing.base import ShareResult, TextSharer, Visibility
+from agentpool_commands.text_sharing.github_gist import GistSharer
+from agentpool_commands.text_sharing.opencode import OpenCodeSharer
+from agentpool_commands.text_sharing.paste_rs import PasteRsSharer
+from agentpool_commands.text_sharing.pastebin import PastebinSharer
+from agentpool_commands.text_sharing.shittycodingagent import ShittyCodingAgentSharer
+
+
+TextSharerStr = Literal["gist", "pastebin", "paste_rs", "opencode", "shittycodingagent"]
+
+
+@overload
+def get_sharer(
+    provider: Literal["gist"],
+    *,
+    token: str | None = None,
+) -> GistSharer: ...
+
+
+@overload
+def get_sharer(
+    provider: Literal["pastebin"],
+    *,
+    api_key: str | None = None,
+) -> PastebinSharer: ...
+
+
+@overload
+def get_sharer(
+    provider: Literal["paste_rs"],
+) -> PasteRsSharer: ...
+
+
+@overload
+def get_sharer(
+    provider: Literal["opencode"],
+    *,
+    api_url: str | None = None,
+) -> OpenCodeSharer: ...
+
+
+@overload
+def get_sharer(
+    provider: Literal["shittycodingagent"],
+    *,
+    token: str | None = None,
+) -> ShittyCodingAgentSharer: ...
+
+
+def get_sharer(
+    provider: TextSharerStr,
+    **kwargs: str | None,
+) -> TextSharer:
+    """Get a text sharer based on provider name.
+
+    Args:
+        provider: The text sharing provider to use
+        **kwargs: Keyword arguments to pass to the provider constructor
+
+    Returns:
+        An instance of the specified text sharer
+
+    Example:
+        ```python
+        # GitHub Gist (reads GITHUB_TOKEN/GH_TOKEN from env)
+        sharer = get_sharer("gist")
+
+        # GitHub Gist with explicit token
+        sharer = get_sharer("gist", token="ghp_...")
+
+        # Pastebin (reads PASTEBIN_API_KEY from env)
+        sharer = get_sharer("pastebin")
+
+        # Pastebin with explicit key
+        sharer = get_sharer("pastebin", api_key="...")
+
+        # paste.rs (no auth needed)
+        sharer = get_sharer("paste_rs")
+
+        # OpenCode (no auth needed)
+        sharer = get_sharer("opencode")
+
+        # OpenCode with custom API URL
+        sharer = get_sharer("opencode", api_url="https://api.dev.opencode.ai")
+        ```
+    """
+    match provider:
+        case "gist":
+            return GistSharer(**kwargs)
+        case "pastebin":
+            return PastebinSharer(**kwargs)
+        case "paste_rs":
+            return PasteRsSharer()
+        case "opencode":
+            return OpenCodeSharer(**kwargs)  # type: ignore[arg-type]
+        case "shittycodingagent":
+            return ShittyCodingAgentSharer(**kwargs)
+        case _ as unreachable:
+            assert_never(unreachable)
+
+
+__all__ = [
+    "GistSharer",
+    "OpenCodeSharer",
+    "PasteRsSharer",
+    "PastebinSharer",
+    "ShareResult",
+    "ShittyCodingAgentSharer",
+    "TextSharer",
+    "TextSharerStr",
+    "Visibility",
+    "get_sharer",
+]

agentpool_commands/text_sharing/base.py

@@ -0,0 +1,123 @@
+"""Base class for text sharing services."""
+
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+
+if TYPE_CHECKING:
+    from agentpool.messaging.message_history import MessageHistory
+
+
+Visibility = Literal["public", "unlisted", "private"]
+
+
+@dataclass
+class ShareResult:
+    """Result of a text sharing operation."""
+
+    url: str
+    """URL to access the shared content."""
+
+    raw_url: str | None = None
+    """Direct URL to raw content, if available."""
+
+    delete_url: str | None = None
+    """URL to delete the content, if available."""
+
+    id: str | None = None
+    """Provider-specific ID of the shared content."""
+
+
+class TextSharer(abc.ABC):
+    """Base class for text sharing services."""
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """Name of the sharing service."""
+
+    @abc.abstractmethod
+    async def share(
+        self,
+        content: str,
+        *,
+        title: str | None = None,
+        syntax: str | None = None,
+        visibility: Visibility = "unlisted",
+        expires_in: int | None = None,
+    ) -> ShareResult:
+        """Share text content.
+
+        Args:
+            content: The text content to share
+            title: Optional title/filename for the content
+            syntax: Syntax highlighting hint (e.g. "python", "markdown")
+            visibility: Visibility level (not all providers support all levels)
+            expires_in: Expiration time in seconds (not supported by all providers)
+
+        Returns:
+            ShareResult with URL and metadata
+        """
+
+    async def share_conversation(
+        self,
+        conversation: MessageHistory,
+        *,
+        title: str | None = None,
+        visibility: Visibility = "unlisted",
+        expires_in: int | None = None,
+        num_messages: int | None = None,
+    ) -> ShareResult:
+        """Share a conversation in structured format.
+
+        Default implementation formats conversation as text and calls share().
+        Providers that support structured conversations (e.g., OpenCode)
+        should override this method.
+
+        Args:
+            conversation: MessageHistory object to share
+            title: Optional title for the conversation
+            visibility: Visibility level
+            expires_in: Expiration time in seconds
+            num_messages: Number of messages to include (None = all)
+
+        Returns:
+            ShareResult with URL and metadata
+        """
+        # Default: format as plain text
+        content = await conversation.format_history(
+            num_messages=num_messages,
+        )
+        return await self.share(
+            content,
+            title=title,
+            syntax="markdown",
+            visibility=visibility,
+            expires_in=expires_in,
+        )
+
+    def share_sync(
+        self,
+        content: str,
+        *,
+        title: str | None = None,
+        syntax: str | None = None,
+        visibility: Visibility = "unlisted",
+        expires_in: int | None = None,
+    ) -> ShareResult:
+        """Synchronous version of share."""
+        from anyenv import run_sync
+
+        async def wrapper() -> ShareResult:
+            return await self.share(
+                content,
+                title=title,
+                syntax=syntax,
+                visibility=visibility,
+                expires_in=expires_in,
+            )
+
+        return run_sync(wrapper())

agentpool_commands/text_sharing/github_gist.py

@@ -0,0 +1,80 @@
+"""GitHub Gist text sharing provider."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+from agentpool_commands.text_sharing.base import ShareResult, TextSharer
+
+
+if TYPE_CHECKING:
+    from agentpool_commands.text_sharing.base import Visibility
+
+
+class GistSharer(TextSharer):
+    """Share text via GitHub Gists."""
+
+    def __init__(self, token: str | None = None) -> None:
+        """Initialize the GitHub Gist sharer.
+
+        Args:
+            token: GitHub personal access token. If not provided,
+                   reads from GITHUB_TOKEN environment variable.
+        """
+        self._token = token or os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+        if not self._token:
+            msg = "GitHub token required. Set GITHUB_TOKEN/GH_TOKEN or pass token parameter."
+            raise ValueError(msg)
+
+    @property
+    def name(self) -> str:
+        """Name of the sharing service."""
+        return "GitHub Gist"
+
+    async def share(
+        self,
+        content: str,
+        *,
+        title: str | None = None,
+        syntax: str | None = None,
+        visibility: Visibility = "unlisted",
+        expires_in: int | None = None,
+    ) -> ShareResult:
+        """Share content as a GitHub Gist.
+
+        Args:
+            content: The text content to share
+            title: Filename for the gist (defaults to "shared.txt" or "shared.{syntax}")
+            syntax: File extension hint (e.g. "py", "md")
+            visibility: "public" or "unlisted" (private not supported)
+            expires_in: Ignored (gists don't expire)
+        """
+        import anyenv
+
+        filename = title or f"shared.{syntax or 'txt'}"
+        public = visibility == "public"
+        payload: dict[str, Any] = {"files": {filename: {"content": content}}, "public": public}
+        headers = {
+            "Authorization": f"Bearer {self._token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+        url = "https://api.github.com/gists"
+        response: dict[str, Any] = await anyenv.post_json(url, payload, headers=headers)
+        raw_url = response["files"][filename]["raw_url"]
+        return ShareResult(url=response["html_url"], raw_url=raw_url, id=response["id"])
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main() -> None:
+        """Example usage of the GistSharer class."""
+        sharer = GistSharer()
+        result = await sharer.share("# Test Gist!", title="test.md", syntax="md")
+        print(f"URL: {result.url}")
+        print(f"Raw: {result.raw_url}")
+        print(f"ID: {result.id}")
+
+    asyncio.run(main())