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

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())