monkeyscode 1.0.0__py3-none-any.whl

monkeyscode/daemon.py

@@ -0,0 +1,201 @@
+"""
+MonkeysCode SDK — Daemon Client.
+
+WebSocket JSON-RPC client for communicating with the MonkeysCode daemon process.
+Used when connecting to a running daemon instance (e.g., from an IDE extension
+or a local web UI) rather than making direct HTTP calls.
+
+Usage::
+
+    from monkeyscode.daemon import DaemonClient
+
+    client = DaemonClient("ws://localhost:9120")
+    await client.connect()
+
+    async for event in client.run("fix-123", prompt="Fix all errors"):
+        print(event)
+
+    await client.disconnect()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass, field
+from typing import Any
+
+import httpx
+
+# ── Types ────────────────────────────────────────────────────────────
+
+
+@dataclass
+class DaemonClientOptions:
+    """Options for connecting to the daemon."""
+
+    url: str = "ws://localhost:9120"
+    timeout: float = 30.0
+    auto_reconnect: bool = True
+    max_reconnect_attempts: int = 5
+
+
+@dataclass
+class DaemonRunParams:
+    """Parameters for starting an agent run via the daemon."""
+
+    prompt: str
+    workspace: str | None = None
+    mode: str = "fast"  # "fast" | "plan" | "thinking"
+    model: str | None = None
+    max_tokens: int | None = None
+
+
+@dataclass
+class DaemonEvent:
+    """An event received from the daemon."""
+
+    kind: str
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: int = 0
+
+
+# ── Client ───────────────────────────────────────────────────────────
+
+
+class DaemonClient:
+    """
+    WebSocket JSON-RPC client for the MonkeysCode daemon.
+
+    Provides request/response communication and streaming event delivery.
+    """
+
+    def __init__(self, url: str = "ws://localhost:9120", **kwargs: Any) -> None:
+        self._url = url
+        self._opts = DaemonClientOptions(url=url, **kwargs)
+        self._ws: Any = None
+        self._connected = False
+        self._request_id = 0
+        self._pending: dict[int, asyncio.Future[Any]] = {}
+
+    @property
+    def connected(self) -> bool:
+        return self._connected
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    async def connect(self) -> None:
+        """Connect to the daemon WebSocket."""
+        try:
+            import websockets  # type: ignore[import-untyped]
+            self._ws = await websockets.connect(self._url)
+            self._connected = True
+        except ImportError:
+            # Fallback: use HTTP long-polling via REST API
+            self._connected = True
+
+    async def disconnect(self) -> None:
+        """Disconnect from the daemon."""
+        if self._ws is not None:
+            await self._ws.close()
+        self._connected = False
+        self._ws = None
+
+    async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
+        """Send a JSON-RPC request and wait for a response."""
+        self._request_id += 1
+        req_id = self._request_id
+
+        msg = {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "method": method,
+            "params": params or {},
+        }
+
+        if self._ws is not None:
+            await self._ws.send(json.dumps(msg))
+            response = await self._ws.recv()
+            data = json.loads(response)
+            if "error" in data:
+                raise RuntimeError(f"RPC error: {data['error']}")
+            return data.get("result")
+        else:
+            # HTTP fallback
+            async with httpx.AsyncClient() as client:
+                http_url = self._url.replace("ws://", "http://").replace("wss://", "https://")
+                resp = await client.post(f"{http_url}/rpc", json=msg)
+                resp.raise_for_status()
+                data = resp.json()
+                if "error" in data:
+                    raise RuntimeError(f"RPC error: {data['error']}")
+                return data.get("result")
+
+    async def run(
+        self,
+        run_id: str,
+        *,
+        prompt: str,
+        workspace: str | None = None,
+        mode: str = "fast",
+        model: str | None = None,
+    ) -> AsyncGenerator[DaemonEvent, None]:
+        """Start a run and stream events."""
+        params: dict[str, Any] = {
+            "runId": run_id,
+            "prompt": prompt,
+        }
+        if workspace:
+            params["workspace"] = workspace
+        if model:
+            params["model"] = model
+        params["mode"] = mode
+
+        # Start the run
+        await self.request("agent/run", params)
+
+        # Stream events
+        if self._ws is not None:
+            while True:
+                try:
+                    raw = await asyncio.wait_for(self._ws.recv(), timeout=self._opts.timeout)
+                    data = json.loads(raw)
+
+                    # Skip RPC responses
+                    if "jsonrpc" in data and "id" in data:
+                        continue
+
+                    event = DaemonEvent(
+                        kind=data.get("type", data.get("kind", "unknown")),
+                        data=data,
+                        timestamp=data.get("timestamp", int(time.time() * 1000)),
+                    )
+                    yield event
+
+                    if event.kind in ("complete", "error", "done"):
+                        break
+                except asyncio.TimeoutError:
+                    break
+
+    async def cancel(self, run_id: str) -> None:
+        """Cancel a running agent."""
+        await self.request("agent/cancel", {"runId": run_id})
+
+    async def status(self, run_id: str) -> dict[str, Any]:
+        """Get the status of a run."""
+        return await self.request("agent/status", {"runId": run_id})
+
+    async def list_runs(self) -> list[dict[str, Any]]:
+        """List active runs."""
+        return await self.request("agent/list")
+
+    async def __aenter__(self) -> DaemonClient:
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.disconnect()

monkeyscode/events.py

@@ -0,0 +1,323 @@
+"""
+MonkeysCode SDK — Event Types.
+
+Pydantic models for all events emitted by the agent during a run.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+# ── Token Usage ──────────────────────────────────────────────────────
+
+
+class TokenUsage(BaseModel):
+    """Token usage breakdown."""
+
+    input: int = 0
+    output: int = 0
+    thinking: int = 0
+    total: int = 0
+
+
+# ── File Change ──────────────────────────────────────────────────────
+
+
+class FileChange(BaseModel):
+    """A file changed by the agent."""
+
+    path: str
+    action: Literal["created", "modified", "deleted"] = "modified"
+    diff: str | None = None
+    lines_added: int = 0
+    lines_removed: int = 0
+
+
+# ── Tool Call Record ─────────────────────────────────────────────────
+
+
+class ToolCallRecord(BaseModel):
+    """A recorded tool call."""
+
+    tool: str
+    args: dict[str, Any] = Field(default_factory=dict)
+    duration: int = 0
+    result: str | None = None
+
+
+# ── Verification ─────────────────────────────────────────────────────
+
+
+class VerificationCheck(BaseModel):
+    """A single verification check result."""
+
+    passed: bool
+    output: str = ""
+
+
+class VerificationResult(BaseModel):
+    """Verification results from lint, typecheck, and tests."""
+
+    lint: VerificationCheck | None = None
+    typecheck: VerificationCheck | None = None
+    tests: VerificationCheck | None = None
+
+
+# ── Plan Step ────────────────────────────────────────────────────────
+
+
+class PlanStep(BaseModel):
+    """A step in a plan."""
+
+    description: str
+    status: Literal["pending", "running", "done", "failed"] = "pending"
+    tool: str | None = None
+
+
+# ── Events ───────────────────────────────────────────────────────────
+
+
+class StartEvent(BaseModel):
+    """Emitted when a run starts."""
+
+    type: Literal["start"] = "start"
+    timestamp: int
+    session_id: str
+    model: str
+
+
+class ThinkingEvent(BaseModel):
+    """Emitted when the agent is thinking."""
+
+    type: Literal["thinking"] = "thinking"
+    timestamp: int
+    content: str | None = None
+
+
+class TextEvent(BaseModel):
+    """Emitted for streaming text content."""
+
+    type: Literal["text"] = "text"
+    timestamp: int
+    content: str
+
+
+class ToolCallEvent(BaseModel):
+    """Emitted when the agent calls a tool."""
+
+    type: Literal["tool_call"] = "tool_call"
+    timestamp: int
+    tool: str
+    args: dict[str, Any] = Field(default_factory=dict)
+    summary: str = ""
+
+
+class ToolResultEvent(BaseModel):
+    """Emitted when a tool call completes."""
+
+    type: Literal["tool_result"] = "tool_result"
+    timestamp: int
+    tool: str
+    result: str = ""
+    success: bool = True
+    duration_ms: int = 0
+
+
+class FileEditEvent(BaseModel):
+    """Emitted when the agent edits a file."""
+
+    type: Literal["file_edit"] = "file_edit"
+    timestamp: int
+    path: str
+    diff: str = ""
+    lines_added: int = 0
+    lines_removed: int = 0
+
+
+class FileReadEvent(BaseModel):
+    """Emitted when the agent reads a file."""
+
+    type: Literal["file_read"] = "file_read"
+    timestamp: int
+    path: str
+    lines: int = 0
+
+
+class TerminalCommandEvent(BaseModel):
+    """Emitted when the agent runs a command."""
+
+    type: Literal["terminal_command"] = "terminal_command"
+    timestamp: int
+    command: str
+    exit_code: int = 0
+    output: str = ""
+
+
+class SearchResultEvent(BaseModel):
+    """Emitted for search results."""
+
+    type: Literal["search_result"] = "search_result"
+    timestamp: int
+    query: str
+    matches: list[dict[str, Any]] = Field(default_factory=list)
+
+
+# ── Daemon Events ────────────────────────────────────────────────────
+
+
+class PlanReadyEvent(BaseModel):
+    """Emitted when the agent produces a plan."""
+
+    type: Literal["plan_ready"] = "plan_ready"
+    timestamp: int
+    steps: list[PlanStep] = Field(default_factory=list)
+    summary: str = ""
+
+
+class CostUpdateEvent(BaseModel):
+    """Emitted for mid-run cost updates."""
+
+    type: Literal["cost_update"] = "cost_update"
+    timestamp: int
+    tokens_in: int = 0
+    tokens_out: int = 0
+    tokens_thinking: int = 0
+    cost: float = 0.0
+
+
+class AgentSpawnedEvent(BaseModel):
+    """Emitted when a sub-agent is spawned."""
+
+    type: Literal["agent_spawned"] = "agent_spawned"
+    timestamp: int
+    agent_id: str
+    task: str
+
+
+class AgentCompleteEvent(BaseModel):
+    """Emitted when a sub-agent completes."""
+
+    type: Literal["agent_complete"] = "agent_complete"
+    timestamp: int
+    agent_id: str
+    success: bool = True
+    summary: str = ""
+
+
+class FanOutProgressEvent(BaseModel):
+    """Emitted for parallel progress updates."""
+
+    type: Literal["fan_out_progress"] = "fan_out_progress"
+    timestamp: int
+    total: int = 0
+    completed: int = 0
+    running: int = 0
+
+
+class VerificationEvent(BaseModel):
+    """Emitted when verification runs."""
+
+    type: Literal["verification"] = "verification"
+    timestamp: int
+    command: str
+    passed: bool = False
+    output: str = ""
+
+
+class SuggestionEvent(BaseModel):
+    """Emitted with follow-up suggestions."""
+
+    type: Literal["suggestion"] = "suggestion"
+    timestamp: int
+    suggestions: list[str] = Field(default_factory=list)
+
+
+# ── Terminal Events ──────────────────────────────────────────────────
+
+
+class ErrorEvent(BaseModel):
+    """Emitted on error."""
+
+    type: Literal["error"] = "error"
+    timestamp: int
+    code: str = "UNKNOWN"
+    message: str = ""
+
+
+class CompleteEvent(BaseModel):
+    """Emitted when a run completes."""
+
+    type: Literal["complete"] = "complete"
+    timestamp: int
+    summary: str = ""
+    files_changed: list[FileChange] = Field(default_factory=list)
+    tokens: TokenUsage = Field(default_factory=TokenUsage)
+    cost: float = 0.0
+    duration_ms: int = 0
+
+
+# ── Union Type ───────────────────────────────────────────────────────
+
+AgentEvent = (
+    StartEvent
+    | ThinkingEvent
+    | TextEvent
+    | ToolCallEvent
+    | ToolResultEvent
+    | FileEditEvent
+    | FileReadEvent
+    | TerminalCommandEvent
+    | SearchResultEvent
+    | PlanReadyEvent
+    | CostUpdateEvent
+    | AgentSpawnedEvent
+    | AgentCompleteEvent
+    | FanOutProgressEvent
+    | VerificationEvent
+    | SuggestionEvent
+    | ErrorEvent
+    | CompleteEvent
+)
+
+
+# ── Result Types ─────────────────────────────────────────────────────
+
+
+class AgentResult(BaseModel):
+    """Result from a completed agent run."""
+
+    success: bool = True
+    status: Literal[
+        "completed", "failed", "partial",
+        "timeout", "interrupted", "cancelled",
+    ] = "completed"
+    summary: str = ""
+    files_changed: list[FileChange] = Field(default_factory=list)
+    tool_calls: list[ToolCallRecord] = Field(default_factory=list)
+    tokens: TokenUsage = Field(default_factory=TokenUsage)
+    cost: float = 0.0
+    duration_ms: int = 0
+    session_id: str = ""
+    exit_code: int = 0
+    model: str = "auto"
+    verification: VerificationResult | None = None
+    error: str | None = None
+
+
+class GoalResult(AgentResult):
+    """Result from a goal-mode run."""
+
+    goal_met: bool = False
+    iterations: int = 0
+    iteration_summaries: list[str] = Field(default_factory=list)
+
+
+class GoalOptions(BaseModel):
+    """Options for goal-mode runs."""
+
+    max_iterations: int = 10
+    timeout: int = 300_000
+    max_cost: float | None = None
+    verify_command: str | None = None