swebot-client 0.9.7__tar.gz

swebot_client-0.9.7/.gitignore

@@ -0,0 +1,54 @@
+# Binary
+/sweet
+/swebot
+
+# Go build artifacts
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+*.test
+*.out
+
+# Go workspace
+/vendor/
+go.work
+go.work.sum
+
+# Database
+*.db
+*.db-shm
+*.db-wal
+
+# Config with secrets (keep config.yaml.example, ignore real one)
+~/.config/swebot/config.yaml
+
+# OS / editor
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Session state (Copilot CLI)
+.copilot/
+startme.txt
+
+# Python virtualenvs
+.venv/
+__pycache__/
+
+# Review notes (not for repo)
+FINDINGS.md
+copilot-session-*.md
+
+# SWE-bench evaluation artifacts
+examples/swe-bench/results/
+examples/swe-bench/.venv/
+logs/
+swebot.swebot-eval*.json
+claude-code/
+*_verbose_debug.log

swebot_client-0.9.7/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: swebot-client
+Version: 0.9.7
+Summary: Python client for the swebot autonomous coding agent
+Project-URL: Homepage, https://github.com/tickup-se/swebot
+Project-URL: Repository, https://github.com/tickup-se/swebot
+Project-URL: Issues, https://github.com/tickup-se/swebot/issues
+Author: Tickup SE
+License-Expression: MIT
+Keywords: ai,automation,coding-agent,llm,swebot
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# swebot-client
+
+Python client for the [swebot](https://github.com/tickup-se/swebot) autonomous coding agent.
+
+Pure Python — zero dependencies beyond the standard library.
+
+## Install
+
+```bash
+# pip
+pip install swebot-client
+
+# uv
+uv add swebot-client
+```
+
+## Quick start
+
+```python
+from swebot_client import SwebotClient
+
+client = SwebotClient("http://localhost:8080")
+session = client.create_session()
+
+# Stream tokens
+for token in session.stream("explain goroutines"):
+    print(token, end="", flush=True)
+
+# Or get the full reply at once
+reply = session.send("what is 2+2?")
+print(reply)
+```
+
+## Features
+
+- **Streaming** — real-time token-by-token output via SSE
+- **Tool callbacks** — observe tool invocations and results
+- **Session management** — create, resume, list, delete sessions
+- **Todos** — read and update agent todo items
+- **MCP management** — configure MCP servers programmatically
+- **Context control** — compact or clear session context
+- **Skills** — list and use built-in skill agents
+
+## Examples
+
+```python
+from swebot_client import SwebotClient, Session, ToolCall, TodoItem
+
+client = SwebotClient("http://localhost:8080")
+
+# Wait for backend to be ready
+client.wait_until_ready(timeout=10)
+
+# Create a session with a specific agent
+session = client.create_session(agent="developer")
+
+# Stream with tool call callbacks
+def on_tool(tc: ToolCall):
+    print(f"  ⚙ {tc.name}")
+
+reply = session.send_with_events(
+    "create a hello.py file",
+    on_tool_start=on_tool,
+)
+
+# Read todos
+for todo in session.get_todos():
+    print(f"[{todo.status}] {todo.title}")
+
+# List MCP servers
+for mcp in client.list_mcp():
+    print(f"{mcp['name']}: {'connected' if mcp.get('connected') else 'disconnected'}")
+
+# Token usage
+usage = session.token_usage()
+print(f"Tokens: {usage['tokens_in']:,} in / {usage['tokens_out']:,} out ({usage['usage_pct']}%)")
+```
+
+## API reference
+
+### `SwebotClient(addr, token="")`
+
+| Method | Description |
+|--------|-------------|
+| `health()` | Check if backend is reachable |
+| `wait_until_ready(timeout)` | Block until backend responds |
+| `create_session(agent)` | Create a new session → `Session` |
+| `get_session(id)` | Resume an existing session → `Session` |
+| `list_sessions()` | List all sessions |
+| `delete_session(id)` | Delete a session |
+| `list_agents()` | List available agents |
+| `list_providers()` | List LLM providers |
+| `stats()` | Backend stats (model, tokens, uptime) |
+| `skills()` | List built-in skill agents |
+| `list_mcp()` | List MCP servers |
+| `add_mcp(...)` | Add an MCP server |
+| `delete_mcp(name)` | Remove an MCP server |
+| `shutdown()` | Gracefully stop the backend |
+
+### `Session`
+
+| Method | Description |
+|--------|-------------|
+| `stream(message)` | Stream tokens → `Iterator[str]` |
+| `send(message)` | Send and get full reply → `str` |
+| `send_with_events(message, ...)` | Send with tool callbacks → `str` |
+| `get_todos()` | List todo items → `list[TodoItem]` |
+| `update_todo(id, status)` | Update a todo's status |
+| `compact()` | Trigger context compaction |
+| `clear()` | Clear all session context |
+| `token_usage()` | Get token usage stats |
+
+## Requirements
+
+- Python 3.9+
+- A running swebot backend (`swebot --serve`)
+
+## License
+
+MIT

swebot_client-0.9.7/README.md

@@ -0,0 +1,120 @@
+# swebot-client
+
+Python client for the [swebot](https://github.com/tickup-se/swebot) autonomous coding agent.
+
+Pure Python — zero dependencies beyond the standard library.
+
+## Install
+
+```bash
+# pip
+pip install swebot-client
+
+# uv
+uv add swebot-client
+```
+
+## Quick start
+
+```python
+from swebot_client import SwebotClient
+
+client = SwebotClient("http://localhost:8080")
+session = client.create_session()
+
+# Stream tokens
+for token in session.stream("explain goroutines"):
+    print(token, end="", flush=True)
+
+# Or get the full reply at once
+reply = session.send("what is 2+2?")
+print(reply)
+```
+
+## Features
+
+- **Streaming** — real-time token-by-token output via SSE
+- **Tool callbacks** — observe tool invocations and results
+- **Session management** — create, resume, list, delete sessions
+- **Todos** — read and update agent todo items
+- **MCP management** — configure MCP servers programmatically
+- **Context control** — compact or clear session context
+- **Skills** — list and use built-in skill agents
+
+## Examples
+
+```python
+from swebot_client import SwebotClient, Session, ToolCall, TodoItem
+
+client = SwebotClient("http://localhost:8080")
+
+# Wait for backend to be ready
+client.wait_until_ready(timeout=10)
+
+# Create a session with a specific agent
+session = client.create_session(agent="developer")
+
+# Stream with tool call callbacks
+def on_tool(tc: ToolCall):
+    print(f"  ⚙ {tc.name}")
+
+reply = session.send_with_events(
+    "create a hello.py file",
+    on_tool_start=on_tool,
+)
+
+# Read todos
+for todo in session.get_todos():
+    print(f"[{todo.status}] {todo.title}")
+
+# List MCP servers
+for mcp in client.list_mcp():
+    print(f"{mcp['name']}: {'connected' if mcp.get('connected') else 'disconnected'}")
+
+# Token usage
+usage = session.token_usage()
+print(f"Tokens: {usage['tokens_in']:,} in / {usage['tokens_out']:,} out ({usage['usage_pct']}%)")
+```
+
+## API reference
+
+### `SwebotClient(addr, token="")`
+
+| Method | Description |
+|--------|-------------|
+| `health()` | Check if backend is reachable |
+| `wait_until_ready(timeout)` | Block until backend responds |
+| `create_session(agent)` | Create a new session → `Session` |
+| `get_session(id)` | Resume an existing session → `Session` |
+| `list_sessions()` | List all sessions |
+| `delete_session(id)` | Delete a session |
+| `list_agents()` | List available agents |
+| `list_providers()` | List LLM providers |
+| `stats()` | Backend stats (model, tokens, uptime) |
+| `skills()` | List built-in skill agents |
+| `list_mcp()` | List MCP servers |
+| `add_mcp(...)` | Add an MCP server |
+| `delete_mcp(name)` | Remove an MCP server |
+| `shutdown()` | Gracefully stop the backend |
+
+### `Session`
+
+| Method | Description |
+|--------|-------------|
+| `stream(message)` | Stream tokens → `Iterator[str]` |
+| `send(message)` | Send and get full reply → `str` |
+| `send_with_events(message, ...)` | Send with tool callbacks → `str` |
+| `get_todos()` | List todo items → `list[TodoItem]` |
+| `update_todo(id, status)` | Update a todo's status |
+| `compact()` | Trigger context compaction |
+| `clear()` | Clear all session context |
+| `token_usage()` | Get token usage stats |
+
+## Requirements
+
+- Python 3.9+
+- A running swebot backend (`swebot --serve`)
+
+## License
+
+MIT

swebot_client-0.9.7/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "swebot-client"
+version = "0.9.7"
+description = "Python client for the swebot autonomous coding agent"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "Tickup SE" }]
+keywords = ["swebot", "coding-agent", "llm", "ai", "automation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/tickup-se/swebot"
+Repository = "https://github.com/tickup-se/swebot"
+Issues = "https://github.com/tickup-se/swebot/issues"

swebot_client-0.9.7/src/swebot_client/__init__.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python3
+"""
+swebot-client — Python client for the swebot autonomous coding agent.
+
+Pure Python — zero dependencies beyond the standard library.
+
+Install:
+    pip install swebot-client
+    uv add swebot-client
+
+Usage:
+    from swebot_client import SwebotClient
+
+    client = SwebotClient("http://localhost:8080")
+    session = client.create_session()
+    for chunk in session.stream("explain goroutines"):
+        print(chunk, end="", flush=True)
+"""
+
+__version__ = "0.9.7"
+__all__ = ["SwebotClient", "Session", "ToolCall", "TodoItem", "Message", "Event"]
+
+import json
+import sys
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Callable, Dict, Iterator, List, Optional, Union
+
+# ── ANSI colours ──────────────────────────────────────────────────────────────
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+BLUE = "\033[94m"
+MAGENTA = "\033[95m"
+CYAN = "\033[96m"
+WHITE = "\033[97m"
+
+def _color(text: str, *codes: str) -> str:
+    if not sys.stdout.isatty():
+        return text
+    return "".join(codes) + text + RESET
+
+
+# ── Data types ─────────────────────────────────────────────────────────────────
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    input: str = ""
+    output: str = ""
+    is_error: bool = False
+
+
+@dataclass
+class TodoItem:
+    id: str
+    title: str
+    description: str
+    status: str  # pending | in_progress | done
+
+
+@dataclass
+class Message:
+    role: str
+    content: str
+    tool_calls: list = field(default_factory=list)
+
+
+@dataclass
+class Event:
+    kind: str
+    data: dict
+
+
+# ── Client ────────────────────────────────────────────────────────────────────
+
+class SwebotClient:
+    """HTTP client for the swebot backend API."""
+
+    def __init__(self, addr: str = "http://localhost:8080", token: str = ""):
+        self.addr = addr.rstrip("/")
+        self.token = token
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def _get(self, path: str) -> Dict:
+        return self._request("GET", path)
+
+    def _delete(self, path: str) -> None:
+        self._request("DELETE", path)
+
+    def _request(self, method: str, path: str, body=None) -> Dict:
+        url = f"{self.addr}{path}"
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(url, method=method, data=data)
+        req.add_header("Content-Type", "application/json")
+        if self.token:
+            req.add_header("Authorization", f"Bearer {self.token}")
+        try:
+            with urllib.request.urlopen(req) as resp:
+                body = resp.read()
+                return json.loads(body) if body else {}
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"HTTP {e.code} {method} {path}: {e.read().decode()}") from e
+
+    def _stream(self, path: str, body: dict) -> Iterator[Event]:
+        url = f"{self.addr}{path}"
+        data = json.dumps(body).encode()
+        req = urllib.request.Request(url, method="POST", data=data)
+        req.add_header("Content-Type", "application/json")
+        if self.token:
+            req.add_header("Authorization", f"Bearer {self.token}")
+        event_type = ""
+        with urllib.request.urlopen(req) as resp:
+            for raw in resp:
+                line = raw.decode().rstrip("\n")
+                if line.startswith("event: "):
+                    event_type = line[7:]
+                elif line.startswith("data: ") and event_type:
+                    yield Event(kind=event_type, data=json.loads(line[6:]))
+                    event_type = ""
+
+    # ── Health ────────────────────────────────────────────────────────────────
+
+    def health(self) -> bool:
+        try:
+            self._request("GET", "/health")
+            return True
+        except Exception:
+            return False
+
+    def wait_until_ready(self, timeout: float = 10.0) -> bool:
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if self.health():
+                return True
+            time.sleep(0.2)
+        return False
+
+    # ── Sessions ──────────────────────────────────────────────────────────────
+
+    def create_session(self, agent: str = "default") -> "Session":
+        resp = self._request("POST", "/api/sessions", {"agent": agent})
+        return Session(self, resp["id"], agent)
+
+    def get_session(self, session_id: str) -> "Session":
+        resp = self._request("GET", f"/api/sessions/{session_id}")
+        return Session(self, resp["id"], resp.get("agent", "default"), resp)
+
+    def list_sessions(self) -> List[dict]:
+        resp = self._request("GET", "/api/sessions")
+        return resp if isinstance(resp, list) else resp.get("sessions", [])
+
+    def delete_session(self, session_id: str) -> None:
+        self._request("DELETE", f"/api/sessions/{session_id}")
+
+    # ── Agents / providers ────────────────────────────────────────────────────
+
+    def list_agents(self) -> List[dict]:
+        resp = self._request("GET", "/api/agents")
+        return resp if isinstance(resp, list) else resp.get("agents", [])
+
+    def list_providers(self) -> List[dict]:
+        resp = self._request("GET", "/api/providers")
+        return resp if isinstance(resp, list) else resp.get("providers", [])
+
+    # ── MCP management ────────────────────────────────────────────────────────
+
+    def list_mcp(self) -> List[dict]:
+        """Return all configured MCP servers with live connection state."""
+        resp = self._request("GET", "/api/mcp")
+        return resp if isinstance(resp, list) else resp.get("servers", [])
+
+    def add_mcp(
+        self,
+        name: str,
+        *,
+        type: str = "stdio",
+        command: str = "",
+        args: Optional[List[str]] = None,
+        url: str = "",
+        env: Optional[List[str]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        tools: Optional[List[str]] = None,
+        disabled: bool = False,
+    ) -> Dict:
+        """Add a new MCP server and connect it immediately."""
+        payload: dict = {"name": name, "type": type}
+        if command:
+            payload["command"] = command
+        if args:
+            payload["args"] = args
+        if url:
+            payload["url"] = url
+        if env:
+            payload["env"] = env
+        if headers:
+            payload["headers"] = headers
+        if tools:
+            payload["tools"] = tools
+        if disabled:
+            payload["disabled"] = True
+        return self._request("POST", "/api/mcp", payload)
+
+    def update_mcp(self, name: str, **fields) -> Dict:
+        """Update an existing MCP server's config (reconnects automatically)."""
+        fields["name"] = name
+        return self._request("PUT", f"/api/mcp/{name}", fields)
+
+    def delete_mcp(self, name: str) -> Dict:
+        """Remove an MCP server from config and disconnect it."""
+        return self._request("DELETE", f"/api/mcp/{name}")
+
+    def enable_mcp(self, name: str) -> Dict:
+        """Enable a disabled MCP server and connect it."""
+        return self._request("POST", f"/api/mcp/{name}/enable")
+
+    def disable_mcp(self, name: str) -> Dict:
+        """Disable an MCP server (keeps config, stops connection)."""
+        return self._request("POST", f"/api/mcp/{name}/disable")
+
+    def reload_mcp(self) -> Dict:
+        """Disconnect all MCP servers and reconnect every enabled one."""
+        return self._request("POST", "/api/mcp/reload")
+
+    # ── Backend management ────────────────────────────────────────────────────
+
+    def stats(self) -> Dict:
+        """Return backend stats: mode, agents, prompts, tools, lines, mcp_count."""
+        return self._request("GET", "/api/stats")
+
+    def skills(self) -> list:
+        """Return the catalogue of all built-in skill agents with active status."""
+        return self._request("GET", "/api/skills")
+
+    def shutdown(self) -> Dict:
+        """Gracefully stop the backend. Returns the last session ID.
+
+        After this call the backend process exits. Resume with:
+            swebot --serve
+            swebot --tui  (or --session <last_session_id>)
+        """
+        return self._request("POST", "/api/shutdown")
+
+
+class Session:
+    """A single conversation session with the swebot agent."""
+
+    def __init__(self, client: SwebotClient, session_id: str,
+                 agent: str = "default", data: dict = None):
+        self.client = client
+        self.id = session_id
+        self.agent = agent
+        self._data = data or {}
+
+    # ── Messaging ─────────────────────────────────────────────────────────────
+
+    def stream(self, message: str) -> Iterator[str]:
+        """Stream the assistant's reply token-by-token."""
+        for ev in self._stream_events(message):
+            if ev.kind == "content_delta":
+                yield ev.data.get("delta", "")
+
+    def send(self, message: str) -> str:
+        """Send a message and return the complete reply (non-streaming)."""
+        reply = ""
+        for ev in self._stream_events(message):
+            if ev.kind == "content_delta":
+                reply += ev.data.get("delta", "")
+            elif ev.kind == "message_complete":
+                reply = ev.data.get("content", reply)
+        return reply
+
+    def send_with_events(
+        self,
+        message: str,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[ToolCall], None]] = None,
+        on_tool_result: Optional[Callable[[ToolCall], None]] = None,
+    ) -> str:
+        """Send a message, firing callbacks for tokens and tool calls."""
+        reply = ""
+        active_tools: dict[str, ToolCall] = {}
+
+        for ev in self._stream_events(message):
+            if ev.kind == "content_delta":
+                delta = ev.data.get("delta", "")
+                reply += delta
+                if on_token:
+                    on_token(delta)
+
+            elif ev.kind == "tool_start":
+                tc = ToolCall(
+                    id=ev.data.get("tool_id", ""),
+                    name=ev.data.get("tool_name", ""),
+                )
+                active_tools[tc.id] = tc
+                if on_tool_start:
+                    on_tool_start(tc)
+
+            elif ev.kind == "tool_result":
+                tid = ev.data.get("tool_id", "")
+                tc = active_tools.pop(tid, ToolCall(id=tid, name=ev.data.get("tool_name", "")))
+                tc.output = ev.data.get("content", "")
+                tc.is_error = ev.data.get("is_error", False)
+                if on_tool_result:
+                    on_tool_result(tc)
+
+            elif ev.kind == "message_complete":
+                reply = ev.data.get("content", reply)
+
+        return reply
+
+    def _stream_events(self, message: str) -> Iterator[Event]:
+        return self.client._stream(
+            f"/api/sessions/{self.id}/messages",
+            {"content": message},
+        )
+
+    # ── Todos ─────────────────────────────────────────────────────────────────
+
+    def compact(self) -> Dict:
+        """Manually trigger context compaction for this session.
+
+        swebot auto-compacts at 85 % of the model context window.  Call this
+        to compact earlier and free up tokens.
+
+        Returns a dict with ``{"compacted": true, "summary": "..."}`` on
+        success or ``{"compacted": false, "reason": "..."}`` when not needed.
+        """
+        return self.client._request("POST", f"/api/sessions/{self.id}/compact")
+
+    def clear(self) -> Dict:
+        """Clear all context (messages + knowledge) from this session.
+
+        Resets the session to a fresh state as if swebot just started, without
+        restarting the process.  The session ID, agent, and model are preserved.
+
+        Useful for:
+        - SWE-bench harness: clean slate between tasks
+        - Switching to a different task without restarting
+
+        Returns ``{"status": "cleared"}`` on success.
+        """
+        return self.client._request("POST", f"/api/sessions/{self.id}/clear")
+
+    def token_usage(self) -> Dict:
+        """Return token usage for this session from the stats endpoint.
+
+        Returns::
+
+            {
+              "tokens_in": 14200,
+              "tokens_out": 3400,
+              "context_window": 200000,
+              "usage_pct": 8.8,
+            }
+        """
+        stats = self.client._request("GET", "/api/stats")
+        win = stats.get("context_window", 0)
+        tin = stats.get("tokens_in", 0)
+        tout = stats.get("tokens_out", 0)
+        pct = round((tin / win * 100), 1) if win else 0
+        return {
+            "tokens_in": tin,
+            "tokens_out": tout,
+            "context_window": win,
+            "usage_pct": pct,
+        }
+
+    def get_todos(self) -> List['TodoItem']:
+        resp = self.client._request("GET", f"/api/sessions/{self.id}/todos")
+        todos_list = resp if isinstance(resp, list) else resp.get("todos", [])
+        return [
+            TodoItem(
+                id=t["id"], title=t["title"],
+                description=t.get("description", ""),
+                status=t.get("status", "pending"),
+            )
+            for t in todos_list
+        ]
+
+    def update_todo(self, todo_id: str, status: str) -> None:
+        self.client._request(
+            "PATCH", f"/api/sessions/{self.id}/todos/{todo_id}",
+            {"status": status},
+        )
+
+    # ── Info ──────────────────────────────────────────────────────────────────
+
+    def refresh(self) -> "Session":
+        self._data = self.client._request("GET", f"/api/sessions/{self.id}")
+        return self
+
+    @property
+    def message_count(self) -> int:
+        return self._data.get("message_count", 0)
+
+    def __repr__(self) -> str:
+        return f"Session(id={self.id!r}, agent={self.agent!r})"