yycode 0.3.2__py3-none-any.whl

agent/__init__.py

@@ -0,0 +1,33 @@
+"""Agent package."""
+
+from .graph import build_graph
+from .session import Session
+from .skills import LoadedSkill, SkillRegistry, discover_skills, load_skills, parse_skill_paths
+from .streaming import ConsoleStreamRenderer, StreamEvent, StreamPrinter
+from .todo_manager import TodoManager
+from .providers import (
+    LLMProvider,
+    ChatResponse,
+    ToolCall,
+    AnthropicProvider,
+    OpenAIProvider,
+)
+
+__all__ = [
+    "build_graph",
+    "Session",
+    "LoadedSkill",
+    "SkillRegistry",
+    "discover_skills",
+    "load_skills",
+    "parse_skill_paths",
+    "ConsoleStreamRenderer",
+    "StreamEvent",
+    "StreamPrinter",
+    "TodoManager",
+    "LLMProvider",
+    "ChatResponse",
+    "ToolCall",
+    "AnthropicProvider",
+    "OpenAIProvider",
+]

agent/acp/__init__.py

@@ -0,0 +1,2 @@
+"""ACP server support for yoyoagent."""
+

agent/acp/approval_adapter.py

@@ -0,0 +1,134 @@
+"""ACP permission request adapter."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+from agent.approval import ApprovalDecision, ApprovalRequest
+from agent.acp.update_adapter import _tool_kind
+
+
+PermissionRequester = Callable[[str, dict[str, Any]], Awaitable[dict[str, Any]]]
+
+
+class AcpApprovalAdapter:
+    """Convert runtime approval callbacks into ACP permission requests."""
+
+    def __init__(
+        self,
+        session_id: str,
+        requester: PermissionRequester,
+        *,
+        workdir: Path | None = None,
+        timeout_seconds: float | None = None,
+    ) -> None:
+        self.session_id = session_id
+        self.requester = requester
+        self.workdir = workdir
+        self.timeout_seconds = timeout_seconds
+        self._pending: set[asyncio.Task] = set()
+
+    async def callback(self, request: ApprovalRequest) -> bool:
+        """Return True when the ACP client approves the requested action."""
+        return (await self.decide(request)).approved
+
+    async def decide(self, request: ApprovalRequest) -> ApprovalDecision:
+        """Request a permission decision from the ACP client."""
+        task = asyncio.create_task(self.requester("session/request_permission", self.payload(request)))
+        self._pending.add(task)
+        try:
+            if self.timeout_seconds is None:
+                response = await task
+            else:
+                response = await asyncio.wait_for(task, timeout=self.timeout_seconds)
+        except asyncio.CancelledError:
+            return ApprovalDecision("cancelled")
+        except TimeoutError:
+            return ApprovalDecision("denied")
+        finally:
+            self._pending.discard(task)
+        option_id = _response_option_id(response)
+        if option_id in {"approve", "allow", "approved"}:
+            return ApprovalDecision("approved")
+        if option_id in {"cancel", "cancelled"}:
+            return ApprovalDecision("cancelled")
+        return ApprovalDecision("denied")
+
+    def cancel_pending(self) -> int:
+        """Cancel pending permission requests."""
+        count = 0
+        for task in list(self._pending):
+            if not task.done():
+                task.cancel()
+                count += 1
+        self._pending.clear()
+        return count
+
+    def payload(self, request: ApprovalRequest) -> dict[str, Any]:
+        """Build the ACP permission request payload."""
+        locations = []
+        for path in _split_paths(request.path):
+            location_path = str(path)
+            if self.workdir is not None and path and not path.startswith("/"):
+                location_path = str((self.workdir / path).resolve())
+            locations.append({"path": location_path})
+        return {
+            "sessionId": self.session_id,
+            "toolCall": {
+                "title": _permission_title(request),
+                "kind": _tool_kind(request.tool_name),
+                "status": "waiting_for_user",
+                "locations": locations,
+                "rawInput": {
+                    "action": request.action,
+                    "toolName": request.tool_name,
+                    "path": request.path,
+                    "command": request.command,
+                    "reason": request.reason,
+                    "risk": request.risk,
+                    "diffPreview": request.diff_preview,
+                },
+                "content": [
+                    {
+                        "type": "text",
+                        "text": request.format(include_diff=bool(request.diff_preview)),
+                    }
+                ],
+            },
+            "options": [
+                {"optionId": "approve", "name": "Approve", "kind": "allow"},
+                {"optionId": "deny", "name": "Deny", "kind": "reject"},
+            ],
+        }
+
+
+def _permission_title(request: ApprovalRequest) -> str:
+    if request.action == "edit_file":
+        return "Approve file edit"
+    if request.action == "create_file":
+        return "Approve file creation"
+    if request.action == "run_command":
+        return "Approve command"
+    return "Approve action"
+
+
+def _split_paths(path: str) -> list[str]:
+    return [item.strip() for item in path.split(",") if item.strip()]
+
+
+def _response_option_id(response: Any) -> str:
+    if isinstance(response, str):
+        return response
+    if not isinstance(response, dict):
+        return ""
+    for key in ("optionId", "option_id", "decision", "status"):
+        if response.get(key):
+            return str(response[key])
+    if response.get("approved") is True:
+        return "approve"
+    if response.get("approved") is False:
+        return "deny"
+    return ""
+

agent/acp/content_adapter.py

@@ -0,0 +1,45 @@
+"""ACP prompt content conversion helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+MAX_EMBEDDED_TEXT_CHARS = 20_000
+
+
+def content_blocks_to_text(content: Any) -> str:
+    """Convert ACP content blocks or plain text into a yoyoagent prompt string."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, dict):
+        return _block_to_text(content)
+    if not isinstance(content, list):
+        return str(content or "")
+    parts = [_block_to_text(block) for block in content]
+    return "\n\n".join(part for part in parts if part).strip()
+
+
+def _block_to_text(block: Any) -> str:
+    if isinstance(block, str):
+        return block
+    if not isinstance(block, dict):
+        return str(block)
+    block_type = str(block.get("type") or block.get("kind") or "text")
+    if block_type in {"text", "markdown"}:
+        return str(block.get("text") or block.get("content") or "")
+    if block_type in {"resource_link", "resource", "uri"}:
+        uri = block.get("uri") or block.get("url") or block.get("path") or ""
+        name = block.get("name") or block.get("title") or "resource"
+        return f"Context resource: {name}\n{uri}".strip()
+    if block_type in {"embedded_resource", "embedded"}:
+        uri = block.get("uri") or block.get("url") or block.get("path") or ""
+        text = str(block.get("text") or block.get("content") or block.get("data") or "")
+        if len(text) > MAX_EMBEDDED_TEXT_CHARS:
+            text = text[:MAX_EMBEDDED_TEXT_CHARS] + "\n... embedded resource truncated"
+        header = f"Embedded context resource: {uri}" if uri else "Embedded context resource:"
+        return f"{header}\n```\n{text}\n```"
+    if block_type in {"image", "audio"}:
+        return f"[Unsupported ACP {block_type} content omitted]"
+    return str(block.get("text") or block.get("content") or block)
+

agent/acp/jsonrpc.py

@@ -0,0 +1,92 @@
+"""Small JSON-RPC 2.0 helpers for ACP stdio transport."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+
+PARSE_ERROR = -32700
+INVALID_REQUEST = -32600
+METHOD_NOT_FOUND = -32601
+INVALID_PARAMS = -32602
+INTERNAL_ERROR = -32603
+
+
+@dataclass(frozen=True)
+class JsonRpcMessage:
+    """One decoded JSON-RPC message."""
+
+    method: str | None = None
+    params: Any = None
+    id: str | int | None = None
+    is_request: bool = False
+    is_notification: bool = False
+
+
+class JsonRpcError(Exception):
+    """JSON-RPC error with a stable code."""
+
+    def __init__(self, code: int, message: str, data: Any = None):
+        self.code = code
+        self.message = message
+        self.data = data
+        super().__init__(message)
+
+
+def decode_message(line: str) -> JsonRpcMessage:
+    """Decode one newline-delimited JSON-RPC message."""
+    try:
+        payload = json.loads(line)
+    except json.JSONDecodeError as exc:
+        raise JsonRpcError(PARSE_ERROR, "Parse error") from exc
+    if not isinstance(payload, dict) or payload.get("jsonrpc") != "2.0":
+        raise JsonRpcError(INVALID_REQUEST, "Invalid Request")
+    method = payload.get("method")
+    if method is None:
+        return JsonRpcMessage(id=payload.get("id"))
+    if not isinstance(method, str):
+        raise JsonRpcError(INVALID_REQUEST, "Invalid Request")
+    has_id = "id" in payload
+    return JsonRpcMessage(
+        method=method,
+        params=payload.get("params"),
+        id=payload.get("id"),
+        is_request=has_id,
+        is_notification=not has_id,
+    )
+
+
+def response(result: Any, request_id: str | int | None) -> dict[str, Any]:
+    """Build a JSON-RPC success response."""
+    return {"jsonrpc": "2.0", "id": request_id, "result": result}
+
+
+def error_response(
+    code: int,
+    message: str,
+    request_id: str | int | None = None,
+    data: Any = None,
+) -> dict[str, Any]:
+    """Build a JSON-RPC error response."""
+    error: dict[str, Any] = {"code": code, "message": message}
+    if data is not None:
+        error["data"] = data
+    return {"jsonrpc": "2.0", "id": request_id, "error": error}
+
+
+def request(method: str, params: Any, request_id: str | int) -> dict[str, Any]:
+    """Build a JSON-RPC request."""
+    return {"jsonrpc": "2.0", "id": request_id, "method": method, "params": params}
+
+
+def notification(method: str, params: Any) -> dict[str, Any]:
+    """Build a JSON-RPC notification."""
+    return {"jsonrpc": "2.0", "method": method, "params": params}
+
+
+def encode(payload: dict[str, Any]) -> str:
+    """Encode one JSON-RPC payload as a stdio line."""
+    return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+

agent/acp/server.py

@@ -0,0 +1,197 @@
+"""ACP stdio server."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Any, TextIO
+
+from agent.acp.jsonrpc import (
+    INTERNAL_ERROR,
+    INVALID_PARAMS,
+    METHOD_NOT_FOUND,
+    JsonRpcError,
+    decode_message,
+    encode,
+    error_response,
+    notification,
+    request,
+    response,
+)
+from agent.acp.session_manager import AcpSessionManager
+
+
+ACP_PROTOCOL_VERSION = 1
+
+
+class AcpServer:
+    """Minimal newline-delimited JSON-RPC server for ACP stdio."""
+
+    def __init__(
+        self,
+        *,
+        stdin: TextIO | None = None,
+        stdout: TextIO | None = None,
+        stderr: TextIO | None = None,
+        auto_approve: bool = False,
+    ) -> None:
+        self.stdin = stdin or sys.stdin
+        self.stdout = stdout or sys.stdout
+        self.stderr = stderr or sys.stderr
+        self._write_lock = asyncio.Lock()
+        self._next_id = 1
+        self._pending: dict[str | int, asyncio.Future] = {}
+        self.sessions = AcpSessionManager(self.notify, self.request_client, auto_approve=auto_approve)
+
+    async def serve(self) -> None:
+        """Run the stdio read loop until EOF."""
+        try:
+            while True:
+                line = await asyncio.to_thread(self.stdin.readline)
+                if not line:
+                    break
+                await self.handle_line(line)
+        finally:
+            await self.sessions.close()
+
+    async def handle_line(self, line: str) -> None:
+        """Handle one JSON-RPC line."""
+        try:
+            message = decode_message(line)
+        except JsonRpcError as exc:
+            await self._write(error_response(exc.code, exc.message))
+            return
+
+        if not message.method:
+            self._resolve_response(line)
+            return
+        if message.is_notification:
+            await self._handle_notification(message.method, message.params)
+            return
+        try:
+            result = await self._dispatch(message.method, _params_dict(message.params))
+        except JsonRpcError as exc:
+            await self._write(error_response(exc.code, exc.message, message.id, exc.data))
+        except Exception as exc:
+            print(f"ACP method failed: {message.method}: {exc}", file=self.stderr)
+            await self._write(error_response(INTERNAL_ERROR, str(exc), message.id))
+        else:
+            await self._write(response(result, message.id))
+
+    async def notify(self, method: str, params: dict[str, Any]) -> None:
+        """Send a JSON-RPC notification to the ACP client."""
+        await self._write(notification(method, params))
+
+    async def request_client(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Send a JSON-RPC request to the ACP client and await its response."""
+        request_id = self._next_request_id()
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        self._pending[request_id] = future
+        await self._write(request(method, params, request_id))
+        result = await future
+        return result if isinstance(result, dict) else {"result": result}
+
+    async def _dispatch(self, method: str, params: dict[str, Any]) -> Any:
+        if method == "initialize":
+            return _initialize_result()
+        if method == "session/new":
+            return await self.sessions.new_session(params)
+        if method == "session/load":
+            return await self.sessions.load_session(params)
+        if method == "session/prompt":
+            return await self.sessions.prompt(params)
+        if method == "session/cancel":
+            return await self.sessions.cancel(params)
+        raise JsonRpcError(METHOD_NOT_FOUND, f"Method not found: {method}")
+
+    async def _handle_notification(self, method: str, params: Any) -> None:
+        if method in {"initialized", "$/cancelRequest"}:
+            return
+        print(f"Ignoring ACP notification: {method} {params!r}", file=self.stderr)
+
+    def _resolve_response(self, line: str) -> None:
+        import json
+
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError:
+            return
+        request_id = payload.get("id")
+        future = self._pending.pop(request_id, None)
+        if future is None or future.done():
+            return
+        if "error" in payload:
+            error = payload.get("error") or {}
+            future.set_exception(RuntimeError(str(error.get("message") or error)))
+        else:
+            future.set_result(payload.get("result"))
+
+    async def _write(self, payload: dict[str, Any]) -> None:
+        async with self._write_lock:
+            self.stdout.write(encode(payload))
+            self.stdout.write("\n")
+            self.stdout.flush()
+
+    def _next_request_id(self) -> str:
+        value = f"yoyo-acp-{self._next_id}"
+        self._next_id += 1
+        return value
+
+
+def _params_dict(params: Any) -> dict[str, Any]:
+    if params is None:
+        return {}
+    if not isinstance(params, dict):
+        raise JsonRpcError(INVALID_PARAMS, "params must be an object")
+    return params
+
+
+def _initialize_result() -> dict[str, Any]:
+    return {
+        "protocolVersion": ACP_PROTOCOL_VERSION,
+        "agentCapabilities": {
+            "loadSession": True,
+            "promptCapabilities": {
+                "image": False,
+                "audio": False,
+                "embeddedContext": True,
+            },
+            "mcpCapabilities": {
+                "http": False,
+                "sse": False,
+            },
+        },
+        "agentInfo": {
+            "name": "yycode",
+            "title": "yycode",
+            "version": _project_version(),
+        },
+        "authMethods": [],
+    }
+
+
+def _project_version() -> str:
+    try:
+        import tomllib
+
+        root = Path(__file__).resolve().parents[2]
+        payload = tomllib.loads((root / "pyproject.toml").read_text(encoding="utf-8"))
+        return str(payload.get("project", {}).get("version") or "")
+    except Exception:
+        return ""
+
+
+async def run_stdio_server(*, auto_approve: bool = False) -> None:
+    """Run the ACP stdio server."""
+    await AcpServer(auto_approve=auto_approve).serve()
+
+
+def main(*, auto_approve: bool = False) -> None:
+    """Synchronous entrypoint for python -m agent.acp.server."""
+    asyncio.run(run_stdio_server(auto_approve=auto_approve))
+
+
+if __name__ == "__main__":
+    main()