yycode 0.3.2__py3-none-any.whl

agent/acp/session_manager.py

@@ -0,0 +1,193 @@
+"""ACP session lifecycle management."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+from agent.acp.approval_adapter import AcpApprovalAdapter
+from agent.acp.content_adapter import content_blocks_to_text
+from agent.acp.update_adapter import (
+    plan_snapshot_to_update,
+    replay_event_to_updates,
+    stream_event_to_updates,
+)
+from agent.cancellation import CancellationController
+from agent.plan_snapshot import build_plan_snapshot
+from agent.session import Session
+from agent.streaming import StreamEvent
+
+
+Notifier = Callable[[str, dict[str, Any]], Awaitable[None]]
+Requester = Callable[[str, dict[str, Any]], Awaitable[dict[str, Any]]]
+
+
+async def auto_approval_callback(_request: Any) -> bool:
+    """Approve runtime approval requests without asking the ACP client."""
+    return True
+
+
+@dataclass
+class AcpManagedSession:
+    """Runtime state for one ACP session."""
+
+    session: Session
+    approval_adapter: AcpApprovalAdapter
+    cancel_controller: CancellationController = field(default_factory=CancellationController)
+
+
+class AcpSessionManager:
+    """Create, load, run, and cancel ACP-backed yoyoagent sessions."""
+
+    def __init__(self, notify: Notifier, request: Requester, *, auto_approve: bool = False):
+        self.notify = notify
+        self.request = request
+        self.auto_approve = auto_approve
+        self.sessions: dict[str, AcpManagedSession] = {}
+
+    async def new_session(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Create a new yoyoagent session for an ACP client."""
+        cwd = _resolve_cwd(params)
+        session = self._create_session(cwd)
+        self.sessions[session.id] = self._managed(session)
+        await self._send_available_commands(session)
+        return {"sessionId": session.id}
+
+    async def load_session(self, params: dict[str, Any]) -> dict[str, Any] | None:
+        """Load a persisted yoyoagent session and replay display events."""
+        cwd = _resolve_cwd(params)
+        session_id = _session_id_from_params(params)
+        session = self._create_session(cwd, session_id=session_id, resume=True)
+        self.sessions[session.id] = self._managed(session)
+        await self._send_available_commands(session)
+        for replay_event in session.replay_view():
+            for update in replay_event_to_updates(replay_event):
+                await self._send_update(session.id, update)
+        return {"sessionId": session.id}
+
+    async def prompt(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Run one prompt turn."""
+        session_id = _session_id_from_params(params)
+        managed = self._require_session(session_id)
+        prompt_text = content_blocks_to_text(
+            params.get("content")
+            or params.get("prompt")
+            or params.get("message")
+            or params.get("input")
+            or ""
+        )
+        task = asyncio.create_task(managed.session.send(prompt_text))
+        managed.cancel_controller.set_task(task)
+        try:
+            await task
+        except asyncio.CancelledError:
+            managed.approval_adapter.cancel_pending()
+            return {"stopReason": "cancelled"}
+        finally:
+            managed.cancel_controller.clear_task(task)
+        await self._send_update(session_id, plan_snapshot_to_update(build_plan_snapshot(managed.session.todo_manager)))
+        return {"stopReason": "end_turn"}
+
+    async def cancel(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Cancel an active prompt turn."""
+        session_id = _session_id_from_params(params)
+        managed = self._require_session(session_id)
+        managed.approval_adapter.cancel_pending()
+        result = await managed.cancel_controller.cancel()
+        return {"status": result.status}
+
+    async def close(self) -> None:
+        """Close all managed sessions."""
+        for managed in list(self.sessions.values()):
+            managed.approval_adapter.cancel_pending()
+            await managed.cancel_controller.cancel()
+            await managed.session.close()
+        self.sessions.clear()
+
+    def _managed(self, session: Session) -> AcpManagedSession:
+        approval = AcpApprovalAdapter(
+            session.id,
+            self.request,
+            workdir=session.workdir,
+        )
+        session.approval_callback = auto_approval_callback if self.auto_approve else approval.callback
+        session.stream_callback = self._stream_callback(session)
+        session._graph = None
+        return AcpManagedSession(session=session, approval_adapter=approval)
+
+    def _create_session(
+        self,
+        cwd: Path,
+        *,
+        session_id: str | None = None,
+        resume: bool = False,
+    ) -> Session:
+        return Session.from_config(
+            workdir=cwd,
+            session_id=session_id,
+            persist_messages=True,
+            resume=resume,
+        )
+
+    def _stream_callback(self, session: Session):
+        async def callback(event: StreamEvent) -> None:
+            for update in stream_event_to_updates(event, workdir=session.workdir):
+                await self._send_update(session.id, update)
+            if event.event_type == "tool_result" and event.tool_name == "todo":
+                await self._send_update(
+                    session.id,
+                    plan_snapshot_to_update(build_plan_snapshot(session.todo_manager)),
+                )
+
+        return callback
+
+    async def _send_update(self, session_id: str, update: dict[str, Any]) -> None:
+        await self.notify("session/update", {"sessionId": session_id, "update": update})
+
+    async def _send_available_commands(self, session: Session) -> None:
+        commands = [
+            {
+                "name": "/plan",
+                "description": "Discuss requirements and produce an implementation plan without executing changes.",
+            }
+        ]
+        for skill in session.skill_registry.list_skills():
+            commands.append(
+                {
+                    "name": f"/{skill.name}",
+                    "description": skill.description,
+                }
+            )
+        await self._send_update(
+            session.id,
+            {
+                "sessionUpdate": "available_commands_update",
+                "commands": commands,
+            },
+        )
+
+    def _require_session(self, session_id: str) -> AcpManagedSession:
+        if session_id not in self.sessions:
+            raise ValueError(f"Unknown ACP session: {session_id}")
+        return self.sessions[session_id]
+
+
+def _resolve_cwd(params: dict[str, Any]) -> Path:
+    raw = params.get("cwd") or params.get("workdir") or os.getcwd()
+    cwd = Path(str(raw)).expanduser()
+    if not cwd.is_absolute():
+        cwd = Path.cwd() / cwd
+    cwd = cwd.resolve()
+    if not cwd.exists() or not cwd.is_dir():
+        raise ValueError(f"cwd must be an existing directory: {cwd}")
+    return cwd
+
+
+def _session_id_from_params(params: dict[str, Any]) -> str:
+    session_id = params.get("sessionId") or params.get("session_id") or params.get("id")
+    if not session_id:
+        raise ValueError("sessionId is required")
+    return str(session_id)

agent/acp/update_adapter.py

@@ -0,0 +1,192 @@
+"""Map yoyoagent stream and replay events to ACP session updates."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from agent.plan_snapshot import PlanSnapshot
+from agent.session_replay import ReplayEvent
+from agent.streaming import StreamEvent
+
+
+READ_TOOLS = {"read_file", "read_many_files", "list_files", "git_show", "workspace_state", "git_diff"}
+SEARCH_TOOLS = {"grep", "web_search"}
+EDIT_TOOLS = {"apply_patch", "write_file", "edit_file"}
+EXECUTE_TOOLS = {"bash", "verify"}
+
+
+def stream_event_to_updates(event: StreamEvent, *, workdir: Path | None = None) -> list[dict[str, Any]]:
+    """Return ACP session/update payloads for one yoyoagent stream event."""
+    if event.event_type == "text_delta":
+        return [_update("agent_message_chunk", {"content": event.content})]
+    if event.event_type == "tool_start":
+        return [
+            _update(
+                "tool_call",
+                {
+                    "toolCallId": _tool_call_id(event),
+                    "title": event.title or event.content or event.tool_name or "Tool call",
+                    "kind": _tool_kind(event.tool_name),
+                    "status": _tool_status(event.status, default="in_progress"),
+                    "content": _tool_content(event),
+                    "locations": _locations(event.file_paths, workdir),
+                    "rawInput": (event.metadata or {}).get("args") or event.metadata or {},
+                    "_meta": {"yoyo": event.to_dict()},
+                },
+            )
+        ]
+    if event.event_type == "tool_end":
+        return [
+            _update(
+                "tool_call_update",
+                {
+                    "toolCallId": _tool_call_id(event),
+                    "status": _tool_status(event.status, default="completed"),
+                    "elapsedMs": event.elapsed_ms,
+                    "_meta": {"yoyo": event.to_dict()},
+                },
+            )
+        ]
+    if event.event_type == "tool_result":
+        return [
+            _update(
+                "tool_call_update",
+                {
+                    "toolCallId": _tool_call_id(event),
+                    "title": event.title,
+                    "kind": _tool_kind(event.tool_name),
+                    "status": _tool_status(event.status, default="completed"),
+                    "content": [{"type": "text", "text": event.content}],
+                    "locations": _locations(event.file_paths, workdir),
+                    "rawOutput": event.content,
+                    "_meta": {"yoyo": event.to_dict()},
+                },
+            )
+        ]
+    if event.event_type in {"context_compressed", "context_summarized"}:
+        return []
+    if event.event_type == "session_warning":
+        return [_update("agent_message_chunk", {"content": f"\n[{event.title or 'context'}] {event.content}\n"})]
+    if event.event_type == "usage":
+        return [_update("usage", {"usage": event.usage or {}, "_meta": {"yoyo": event.to_dict()}})]
+    if event.event_type in {"llm_waiting", "llm_timeout", "llm_retry", "llm_error"}:
+        return [
+            _update(
+                "status",
+                {
+                    "title": event.title or "Model status",
+                    "content": event.content,
+                    "status": event.status or "running",
+                    "_meta": {"yoyo": event.to_dict()},
+                },
+            )
+        ]
+    return []
+
+
+def plan_snapshot_to_update(snapshot: PlanSnapshot) -> dict[str, Any]:
+    """Return an ACP plan update payload from a public plan snapshot."""
+    return _update(
+        "plan",
+        {
+            "entries": [
+                {
+                    "id": entry.id,
+                    "title": entry.title,
+                    "status": entry.status,
+                    "priority": entry.priority,
+                }
+                for entry in snapshot.entries
+            ],
+            "_meta": {
+                "yoyo": {
+                    "memory": snapshot.memory,
+                    "updatedAt": snapshot.updated_at,
+                    "taskStarted": snapshot.task_started,
+                    "taskCompleted": snapshot.task_completed,
+                }
+            },
+        },
+    )
+
+
+def replay_event_to_updates(event: ReplayEvent) -> list[dict[str, Any]]:
+    """Return ACP replay updates for one session replay event."""
+    if event.kind == "summary":
+        return [_update("agent_message_chunk", {"content": f"\n[Session summary]\n{event.content}\n"})]
+    if event.role == "user":
+        return [_update("user_message_chunk", {"content": event.content})]
+    if event.role == "assistant":
+        return [_update("agent_message_chunk", {"content": event.content})]
+    if event.role == "tool":
+        tool_name = str(event.metadata.get("tool_name") or "tool")
+        tool_call_id = str(event.metadata.get("tool_call_id") or f"replay-{tool_name}")
+        return [
+            _update(
+                "tool_call_update",
+                {
+                    "toolCallId": tool_call_id,
+                    "title": tool_name,
+                    "kind": _tool_kind(tool_name),
+                    "status": "completed",
+                    "content": [{"type": "text", "text": event.content}],
+                    "rawOutput": event.content,
+                    "_meta": {"yoyo": {"replay": True, **event.metadata}},
+                },
+            )
+        ]
+    return []
+
+
+def _update(update_type: str, payload: dict[str, Any]) -> dict[str, Any]:
+    return {"sessionUpdate": update_type, **payload}
+
+
+def _tool_content(event: StreamEvent) -> list[dict[str, str]]:
+    detail = event.detail or event.content or ""
+    return [{"type": "text", "text": detail}] if detail else []
+
+
+def _tool_call_id(event: StreamEvent) -> str:
+    metadata = event.metadata or {}
+    args = metadata.get("args") if isinstance(metadata, dict) else None
+    explicit = metadata.get("tool_call_id") or metadata.get("id") if isinstance(metadata, dict) else None
+    if explicit:
+        return str(explicit)
+    if isinstance(args, dict) and args.get("tool_call_id"):
+        return str(args["tool_call_id"])
+    return f"{event.session_id}:{event.tool_name or event.event_type}"
+
+
+def _tool_status(status: str | None, *, default: str) -> str:
+    if status in {"failed", "denied", "cancelled"}:
+        return "failed" if status == "denied" else status
+    if status in {"completed", "running", "in_progress", "waiting_for_user"}:
+        return "in_progress" if status == "running" else status
+    return default
+
+
+def _tool_kind(tool_name: str | None) -> str:
+    name = tool_name or ""
+    if name in READ_TOOLS:
+        return "read"
+    if name in SEARCH_TOOLS or name.startswith("lsp_"):
+        return "search"
+    if name in EDIT_TOOLS:
+        return "edit"
+    if name in EXECUTE_TOOLS:
+        return "execute"
+    if name in {"todo", "subagent"}:
+        return "think"
+    return "other"
+
+
+def _locations(paths: list[str] | None, workdir: Path | None) -> list[dict[str, Any]]:
+    locations = []
+    for path in paths or []:
+        location: dict[str, Any] = {"path": str(path)}
+        if workdir is not None and path and not str(path).startswith("/"):
+            location["path"] = str((workdir / path).resolve())
+        locations.append(location)
+    return locations

agent/app_paths.py

@@ -0,0 +1,25 @@
+"""Application-level path helpers."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def resolve_app_root(raw_app_root: str | Path | None = None) -> Path:
+    """Resolve the yoyoagent application root directory."""
+    raw = raw_app_root or os.environ.get("YOYO_APP_ROOT")
+    if raw:
+        return Path(raw).expanduser().resolve()
+    return Path(__file__).resolve().parents[1]
+
+
+def resolve_runtime_data_dir(
+    app_root: Path,
+    raw_runtime_data_dir: str | Path | None = None,
+) -> Path:
+    """Resolve the runtime data directory for yoyoagent-owned data."""
+    raw = raw_runtime_data_dir or os.environ.get("YOYO_RUNTIME_DATA_DIR")
+    if raw:
+        return Path(raw).expanduser().resolve()
+    return app_root

agent/approval.py

@@ -0,0 +1,169 @@
+"""Runtime approval helpers for high-risk tool calls."""
+
+from dataclasses import dataclass
+import re
+from pathlib import Path
+from typing import Awaitable, Callable, Literal, Optional
+
+from tools.safety import approval_required
+from tools.safety import unsafe_command_response
+from tools.apply_patch import preview_apply_patch_diff
+from tools.write_file import preview_write_file_diff
+
+
+ApprovalDecisionStatus = Literal["approved", "denied", "cancelled"]
+ApprovalCallback = Callable[["ApprovalRequest"], Awaitable[bool]]
+
+
+class ApprovalDenied(Exception):
+    """Raised when the user denies a runtime approval request."""
+
+    def __init__(self, request: "ApprovalRequest"):
+        self.request = request
+        super().__init__(request.format())
+
+
+class ApprovalTargetMissing(Exception):
+    """Raised when a file approval cannot identify the target path."""
+
+    def __init__(self, tool_name: str):
+        self.tool_name = tool_name
+        super().__init__(missing_file_target_message(tool_name))
+
+
+@dataclass(frozen=True)
+class ApprovalRequest:
+    """A request to approve a risky tool execution."""
+
+    action: str
+    tool_name: str
+    reason: str
+    risk: str
+    path: str = ""
+    command: str = ""
+    diff_preview: str = ""
+
+    def format(self, include_diff: bool = True) -> str:
+        """Format the request using the stable tool response shape."""
+        formatted = approval_required(
+            action=self.action,
+            command=self.command,
+            path=self.path,
+            reason=self.reason,
+            risk=self.risk,
+        )
+        if include_diff and self.diff_preview:
+            formatted = f"{formatted}\n\ndiff_preview:\n{self.diff_preview}"
+        return formatted
+
+
+@dataclass(frozen=True)
+class ApprovalDecision:
+    """UI-independent approval decision."""
+
+    status: ApprovalDecisionStatus
+
+    @property
+    def approved(self) -> bool:
+        """Return whether the request was approved."""
+        return self.status == "approved"
+
+
+async def callback_from_decider(
+    request: ApprovalRequest,
+    decider: Callable[[ApprovalRequest], Awaitable[ApprovalDecision]],
+) -> bool:
+    """Adapt a decision-oriented approval adapter to the legacy bool callback."""
+    return (await decider(request)).approved
+
+
+def approval_request_for_tool(
+    tool_name: str,
+    args: dict,
+    workdir: Path | str | None = None,
+) -> Optional[ApprovalRequest]:
+    """Return an approval request for tool calls that require runtime confirmation."""
+    if tool_name == "bash":
+        command = args.get("command", "")
+        if unsafe_command_response(command):
+            return ApprovalRequest(
+                action="run_command",
+                tool_name=tool_name,
+                command=command,
+                reason="bash command matches a high-risk command pattern.",
+                risk="This operation may be destructive or affect files outside the intended task.",
+            )
+        return None
+    if tool_name == "apply_patch":
+        path = args.get("path") or _paths_from_unified_diff(args.get("patch", ""))
+        if not path:
+            raise ApprovalTargetMissing(tool_name)
+        return ApprovalRequest(
+            action="edit_file",
+            tool_name=tool_name,
+            path=path,
+            reason="apply_patch edits workspace files.",
+            risk="File edits can overwrite user work or introduce unintended code changes.",
+            diff_preview=preview_apply_patch_diff(
+                patch=args.get("patch", ""),
+                path=args.get("path", ""),
+                old_text=args.get("old_text", ""),
+                new_text=args.get("new_text", ""),
+                workdir=workdir,
+            ),
+        )
+    if tool_name == "write_file":
+        if not args.get("path"):
+            raise ApprovalTargetMissing(tool_name)
+        return ApprovalRequest(
+            action="create_file",
+            tool_name=tool_name,
+            path=args.get("path", ""),
+            reason="write_file creates a new workspace file.",
+            risk="Creating files changes the workspace and may add unwanted artifacts.",
+            diff_preview=preview_write_file_diff(
+                args.get("path", ""),
+                args.get("content", ""),
+                workdir=workdir,
+            ),
+        )
+    return None
+
+
+def missing_file_target_message(tool_name: str) -> str:
+    """Return a model-facing correction when a write tool has no target path."""
+    return (
+        f"File edit blocked for {tool_name}: no target file was detected.\n\n"
+        "Retry with an explicit target file using one of these formats:\n"
+        "- apply_patch with path + old_text + new_text\n"
+        "- apply_patch with a unified diff that includes ---/+++ file headers\n"
+        "- apply_patch with Begin Patch lines such as *** Update File: path\n"
+        "- write_file with a path for a brand-new file"
+    )
+
+
+def approval_cache_key(request: ApprovalRequest) -> tuple[str, str, str]:
+    """Return the cache key for approvals within one agent run."""
+    return (request.action, request.tool_name, request.path)
+
+
+def _paths_from_unified_diff(patch: str) -> str:
+    paths = []
+    for line in patch.splitlines():
+        path = None
+        begin_patch_match = re.match(r"\*\*\* (?:Add|Update|Delete) File: (.+)$", line)
+        if begin_patch_match:
+            path = begin_patch_match.group(1).strip()
+        elif line.startswith("*** Move to: "):
+            path = line[len("*** Move to: "):].strip()
+        if line.startswith("diff --git "):
+            match = re.match(r"diff --git a/(.+?) b/(.+)$", line)
+            if match:
+                path = match.group(2)
+        elif line.startswith("+++ "):
+            raw = line[4:].split("\t", 1)[0].strip()
+            if raw != "/dev/null":
+                path = raw[2:] if raw.startswith("b/") else raw
+        if path and path not in paths:
+            paths.append(path)
+    return ", ".join(paths)

agent/cancellation.py

@@ -0,0 +1,52 @@
+"""Shared cancellation controller for interactive runners."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from dataclasses import dataclass
+from typing import Literal
+
+
+CancelStatus = Literal["cancelled", "not_running", "already_finished"]
+
+
+@dataclass(frozen=True)
+class CancelResult:
+    """Result of a cancellation attempt."""
+
+    status: CancelStatus
+
+
+class CancellationController:
+    """Track and cancel one active asyncio task."""
+
+    def __init__(self) -> None:
+        self.current_task: asyncio.Task | None = None
+
+    def set_task(self, task: asyncio.Task) -> None:
+        """Set the currently active task."""
+        self.current_task = task
+
+    def clear_task(self, task: asyncio.Task | None = None) -> None:
+        """Clear the active task if it matches."""
+        if task is None or self.current_task is task:
+            self.current_task = None
+
+    def is_running(self) -> bool:
+        """Return whether a task is currently running."""
+        return self.current_task is not None and not self.current_task.done()
+
+    async def cancel(self) -> CancelResult:
+        """Cancel the active task and return a stable status."""
+        task = self.current_task
+        if task is None:
+            return CancelResult("not_running")
+        if task.done():
+            self.current_task = None
+            return CancelResult("already_finished")
+        task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await task
+        self.current_task = None
+        return CancelResult("cancelled")