comate-cli 0.1.0__py3-none-any.whl

comate_cli/terminal_agent/rpc_protocol.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any
+
+
+class ErrorCodes:
+    PARSE_ERROR = -32700
+    INVALID_REQUEST = -32600
+    METHOD_NOT_FOUND = -32601
+    INVALID_PARAMS = -32602
+    INTERNAL_ERROR = -32603
+    INVALID_STATE = -32000
+
+
+class JSONRPCProtocolError(Exception):
+    def __init__(
+        self,
+        *,
+        code: int,
+        message: str,
+        request_id: str | int | None = None,
+        data: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        self.data = data
+
+
+def parse_jsonrpc_message(raw_line: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(raw_line)
+    except json.JSONDecodeError as exc:
+        raise JSONRPCProtocolError(code=ErrorCodes.PARSE_ERROR, message=f"invalid json: {exc.msg}") from exc
+
+    if not isinstance(parsed, dict):
+        raise JSONRPCProtocolError(
+            code=ErrorCodes.INVALID_REQUEST,
+            message="json-rpc payload must be an object",
+        )
+
+    if parsed.get("jsonrpc") != "2.0":
+        raise JSONRPCProtocolError(
+            code=ErrorCodes.INVALID_REQUEST,
+            message="jsonrpc must be '2.0'",
+            request_id=_coerce_request_id(parsed.get("id")),
+        )
+
+    return parsed
+
+
+def build_success_response(request_id: str | int, result: Any) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": request_id, "result": _to_jsonable(result)}
+
+
+def build_error_response(
+    *,
+    request_id: str | int | None,
+    code: int,
+    message: str,
+    data: Any = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "error": {"code": int(code), "message": str(message)},
+    }
+    if data is not None:
+        payload["error"]["data"] = _to_jsonable(data)
+    return payload
+
+
+def build_event_notification(event: Any) -> dict[str, Any]:
+    params = _to_jsonable(event)
+    if isinstance(params, dict):
+        params = {"event_type": type(event).__name__, **params}
+    else:
+        params = {"event_type": type(event).__name__, "value": params}
+    return {"jsonrpc": "2.0", "method": "event", "params": params}
+
+
+def _coerce_request_id(raw_value: Any) -> str | int | None:
+    if isinstance(raw_value, str | int):
+        return raw_value
+    return None
+
+
+def _to_jsonable(value: Any) -> Any:
+    if value is None or isinstance(value, bool | int | float | str):
+        return value
+    if is_dataclass(value):
+        return {key: _to_jsonable(item) for key, item in asdict(value).items()}
+    if isinstance(value, dict):
+        normalized: dict[str, Any] = {}
+        for key, item in value.items():
+            normalized[str(key)] = _to_jsonable(item)
+        return normalized
+    if isinstance(value, list | tuple | set):
+        return [_to_jsonable(item) for item in value]
+    return str(value)

comate_cli/terminal_agent/rpc_stdio.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+from typing import Any
+
+from comate_agent_sdk.agent import ChatSession
+
+from comate_cli.terminal_agent.rpc_protocol import (
+    ErrorCodes,
+    JSONRPCProtocolError,
+    build_error_response,
+    build_event_notification,
+    build_success_response,
+    parse_jsonrpc_message,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StdioRPCBridge:
+    """JSON-RPC 2.0 bridge over stdin/stdout (NDJSON)."""
+
+    def __init__(self, session: ChatSession) -> None:
+        self._session = session
+        self._write_lock = asyncio.Lock()
+        self._closing = False
+        self._active_prompt_task: asyncio.Task[dict[str, Any]] | None = None
+        self._active_prompt_request_id: str | int | None = None
+
+    async def run(self) -> None:
+        while not self._closing:
+            raw_line = await asyncio.to_thread(sys.stdin.readline)
+            if raw_line == "":
+                break
+
+            line = raw_line.strip()
+            if not line:
+                continue
+
+            await self._handle_incoming_line(line)
+
+        await self._cancel_active_prompt()
+
+    async def _handle_incoming_line(self, line: str) -> None:
+        try:
+            message = parse_jsonrpc_message(line)
+        except JSONRPCProtocolError as exc:
+            await self._send(
+                build_error_response(
+                    request_id=exc.request_id,
+                    code=exc.code,
+                    message=exc.message,
+                    data=exc.data,
+                )
+            )
+            return
+
+        method = message.get("method")
+        request_id = message.get("id")
+        params = message.get("params") or {}
+
+        if method is None:
+            await self._send(
+                build_error_response(
+                    request_id=request_id if isinstance(request_id, str | int) else None,
+                    code=ErrorCodes.INVALID_REQUEST,
+                    message="response payload is not supported on this endpoint",
+                )
+            )
+            return
+
+        if method == "initialize":
+            await self._handle_initialize(request_id)
+            return
+        if method == "prompt":
+            await self._handle_prompt(request_id, params)
+            return
+        if method == "cancel":
+            await self._handle_cancel(request_id)
+            return
+        if method == "replay":
+            await self._handle_replay(request_id)
+            return
+
+        await self._send(
+            build_error_response(
+                request_id=request_id if isinstance(request_id, str | int) else None,
+                code=ErrorCodes.METHOD_NOT_FOUND,
+                message=f"method not found: {method}",
+            )
+        )
+
+    async def _handle_initialize(self, request_id: Any) -> None:
+        if not isinstance(request_id, str | int):
+            await self._send(
+                build_error_response(
+                    request_id=None,
+                    code=ErrorCodes.INVALID_REQUEST,
+                    message="initialize requires request id",
+                )
+            )
+            return
+
+        await self._send(
+            build_success_response(
+                request_id,
+                {
+                    "status": "ok",
+                    "protocol_version": "1.0",
+                    "session_id": self._session.session_id,
+                },
+            )
+        )
+
+    async def _handle_prompt(self, request_id: Any, params: Any) -> None:
+        if not isinstance(request_id, str | int):
+            await self._send(
+                build_error_response(
+                    request_id=None,
+                    code=ErrorCodes.INVALID_REQUEST,
+                    message="prompt requires request id",
+                )
+            )
+            return
+
+        if self._active_prompt_task is not None and not self._active_prompt_task.done():
+            await self._send(
+                build_error_response(
+                    request_id=request_id,
+                    code=ErrorCodes.INVALID_STATE,
+                    message="prompt already running",
+                )
+            )
+            return
+
+        if not isinstance(params, dict):
+            await self._send(
+                build_error_response(
+                    request_id=request_id,
+                    code=ErrorCodes.INVALID_PARAMS,
+                    message="params must be an object",
+                )
+            )
+            return
+
+        user_input = params.get("user_input")
+        if not isinstance(user_input, str) or not user_input.strip():
+            await self._send(
+                build_error_response(
+                    request_id=request_id,
+                    code=ErrorCodes.INVALID_PARAMS,
+                    message="params.user_input must be a non-empty string",
+                )
+            )
+            return
+
+        task = asyncio.create_task(
+            self._run_prompt_stream(user_input),
+            name=f"rpc-prompt-{request_id}",
+        )
+        self._active_prompt_task = task
+        self._active_prompt_request_id = request_id
+        asyncio.create_task(
+            self._finalize_prompt_task(task=task, request_id=request_id),
+            name=f"rpc-prompt-finalize-{request_id}",
+        )
+
+    async def _handle_cancel(self, request_id: Any) -> None:
+        if not isinstance(request_id, str | int):
+            await self._send(
+                build_error_response(
+                    request_id=None,
+                    code=ErrorCodes.INVALID_REQUEST,
+                    message="cancel requires request id",
+                )
+            )
+            return
+
+        cancelled = await self._cancel_active_prompt()
+        await self._send(build_success_response(request_id, {"cancelled": cancelled}))
+
+    async def _handle_replay(self, request_id: Any) -> None:
+        if not isinstance(request_id, str | int):
+            await self._send(
+                build_error_response(
+                    request_id=None,
+                    code=ErrorCodes.INVALID_REQUEST,
+                    message="replay requires request id",
+                )
+            )
+            return
+
+        await self._send(
+            build_success_response(
+                request_id,
+                {
+                    "supported": False,
+                    "reason": "replay is not implemented for stdio bridge",
+                },
+            )
+        )
+
+    async def _run_prompt_stream(self, user_input: str) -> dict[str, Any]:
+        waiting_for_input = False
+        stop_reason = "completed"
+        try:
+            async for event in self._session.query_stream(user_input):
+                await self._send(build_event_notification(event))
+                reason = getattr(event, "reason", None)
+                if reason == "waiting_for_input":
+                    waiting_for_input = True
+                    stop_reason = "waiting_for_input"
+                if reason == "waiting_for_plan_approval":
+                    stop_reason = "waiting_for_plan_approval"
+        except asyncio.CancelledError:
+            stop_reason = "cancelled"
+            raise
+        except Exception as exc:
+            logger.exception("rpc prompt stream failed")
+            raise RuntimeError(f"stream failed: {exc}") from exc
+
+        if stop_reason == "waiting_for_plan_approval":
+            status = "waiting_for_plan_approval"
+        else:
+            status = "waiting_for_input" if waiting_for_input else "completed"
+        return {"status": status, "stop_reason": stop_reason}
+
+    async def _finalize_prompt_task(
+        self,
+        *,
+        task: asyncio.Task[dict[str, Any]],
+        request_id: str | int,
+    ) -> None:
+        try:
+            result = await task
+            await self._send(build_success_response(request_id, result))
+        except asyncio.CancelledError:
+            await self._send(
+                build_success_response(
+                    request_id,
+                    {"status": "cancelled", "stop_reason": "cancelled"},
+                )
+            )
+        except Exception as exc:
+            await self._send(
+                build_error_response(
+                    request_id=request_id,
+                    code=ErrorCodes.INTERNAL_ERROR,
+                    message=str(exc),
+                )
+            )
+        finally:
+            if self._active_prompt_task is task:
+                self._active_prompt_task = None
+                self._active_prompt_request_id = None
+
+    async def _cancel_active_prompt(self) -> bool:
+        task = self._active_prompt_task
+        if task is None or task.done():
+            return False
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        return True
+
+    async def _send(self, payload: dict[str, Any]) -> None:
+        encoded = f"{self._dump_json(payload)}\n"
+        async with self._write_lock:
+            await asyncio.to_thread(sys.stdout.write, encoded)
+            await asyncio.to_thread(sys.stdout.flush)
+
+    @staticmethod
+    def _dump_json(payload: dict[str, Any]) -> str:
+        import json
+
+        return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))

comate_cli/terminal_agent/selection_menu.py

@@ -0,0 +1,305 @@
+"""通用选择菜单 UI 组件。
+
+提供简单的单选菜单界面，支持上下选择、Enter 确认、Esc 取消。
+可用于模型切换、配置选择等二级选择场景。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from prompt_toolkit.layout import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+
+@dataclass(frozen=True, slots=True)
+class SelectionOption:
+    """单个选项。"""
+
+    value: str
+    label: str
+    description: str = ""
+
+
+@dataclass(slots=True)
+class SelectionMenuState:
+    """选择菜单状态。"""
+
+    title: str = ""
+    options: list[SelectionOption] = field(default_factory=list)
+    selected_index: int = 0
+    is_confirmed: bool = False
+    is_cancelled: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class SelectionResult:
+    """选择结果。"""
+
+    confirmed: bool
+    value: str | None = None
+    label: str | None = None
+
+
+class SelectionMenuUI:
+    """通用选择菜单 UI 组件。
+
+    适用于简单的单选场景，如：
+    - 模型级别切换 (LOW/MID/HIGH)
+    - 配置选项选择
+    - 快捷操作菜单
+
+    按键：
+    - ↑/↓ 或 k/j: 移动选择
+    - Enter: 确认选择
+    - Esc: 取消
+    """
+
+    def __init__(self) -> None:
+        self._state = SelectionMenuState()
+        self._on_confirm: Callable[[str], None] | None = None
+        self._on_cancel: Callable[[], None] | None = None
+
+        self._title_control = FormattedTextControl(text=self._title_fragments)
+        self._options_control = FormattedTextControl(text=self._options_fragments)
+
+        self._title_window = Window(
+            content=self._title_control,
+            height=1,
+            dont_extend_height=True,
+            style="class:selection.title",
+        )
+        self._options_window = Window(
+            content=self._options_control,
+            wrap_lines=True,
+            dont_extend_height=False,
+            style="class:selection.body",
+        )
+
+        self._root = HSplit(
+            [
+                self._title_window,
+                Window(height=1, char="─", style="class:selection.divider"),
+                self._options_window,
+            ]
+        )
+
+    @property
+    def container(self) -> HSplit:
+        return self._root
+
+    def set_options(
+        self,
+        title: str,
+        options: list[dict[str, str]],
+        on_confirm: Callable[[str], None] | None = None,
+        on_cancel: Callable[[], None] | None = None,
+    ) -> bool:
+        """设置选项。
+
+        Args:
+            title: 菜单标题
+            options: 选项列表，每个选项为 {"value": "xxx", "label": "显示文本", "description": "描述"}
+            on_confirm: 确认回调，参数为选中的 value
+            on_cancel: 取消回调
+
+        Returns:
+            是否成功设置（至少有一个有效选项）
+        """
+        parsed_options: list[SelectionOption] = []
+        for opt in options:
+            if not isinstance(opt, dict):
+                continue
+            value = str(opt.get("value", "")).strip()
+            label = str(opt.get("label", "")).strip()
+            if not value or not label:
+                continue
+            description = str(opt.get("description", "")).strip()
+            parsed_options.append(SelectionOption(value=value, label=label, description=description))
+
+        if not parsed_options:
+            return False
+
+        self._state.title = title
+        self._state.options = parsed_options
+        self._state.selected_index = 0
+        self._state.is_confirmed = False
+        self._state.is_cancelled = False
+        self._on_confirm = on_confirm
+        self._on_cancel = on_cancel
+        return True
+
+    def clear(self) -> None:
+        """清除状态。"""
+        self._state = SelectionMenuState()
+        self._on_confirm = None
+        self._on_cancel = None
+
+    def has_options(self) -> bool:
+        """是否有选项。"""
+        return bool(self._state.options)
+
+    def move_selection(self, delta: int) -> None:
+        """移动选择。"""
+        if not self._state.options:
+            return
+        count = len(self._state.options)
+        self._state.selected_index = (self._state.selected_index + delta) % count
+
+    def confirm(self) -> SelectionResult | None:
+        """确认当前选择。
+
+        Returns:
+            选择结果，如果没有选项则返回 None
+        """
+        if not self._state.options:
+            return None
+
+        option = self._state.options[self._state.selected_index]
+        self._state.is_confirmed = True
+
+        if self._on_confirm:
+            self._on_confirm(option.value)
+
+        return SelectionResult(confirmed=True, value=option.value, label=option.label)
+
+    def cancel(self) -> SelectionResult:
+        """取消选择。
+
+        Returns:
+            取消结果
+        """
+        self._state.is_cancelled = True
+
+        if self._on_cancel:
+            self._on_cancel()
+
+        return SelectionResult(confirmed=False)
+
+    def get_selected(self) -> SelectionOption | None:
+        """获取当前选中的选项。"""
+        if not self._state.options:
+            return None
+        return self._state.options[self._state.selected_index]
+
+    def _title_fragments(self) -> list[tuple[str, str]]:
+        if not self._state.title:
+            return [("class:selection.title", "  Select an option")]
+        return [("class:selection.title", f"  {self._state.title}")]
+
+    def _options_fragments(self) -> list[tuple[str, str]]:
+        if not self._state.options:
+            return [("class:selection.body", "  No options available")]
+
+        fragments: list[tuple[str, str]] = []
+        for idx, option in enumerate(self._state.options):
+            is_selected = idx == self._state.selected_index
+            cursor = "▶" if is_selected else " "
+            marker = "●" if is_selected else "○"
+
+            line_style = "class:selection.option.selected" if is_selected else "class:selection.option"
+            desc_style = "class:selection.description.selected" if is_selected else "class:selection.description"
+
+            # 主选项行
+            fragments.append((line_style, f"  {cursor} {marker} {option.label}"))
+            fragments.append(("", "\n"))
+
+            # 描述行（如果有）
+            if option.description:
+                fragments.append((desc_style, f"      {option.description}"))
+                fragments.append(("", "\n"))
+
+        # 底部提示
+        fragments.append(("", "\n"))
+        fragments.append(
+            ("class:selection.hint", "  ↑/↓ or k/j: Move  Enter: Confirm  Esc: Cancel")
+        )
+        return fragments
+
+    def refresh(self) -> None:
+        """刷新显示（触发重绘）。"""
+        self._title_control.text = self._title_fragments
+        self._options_control.text = self._options_fragments
+
+    def focus_target(self) -> Window:
+        """获取焦点目标窗口。"""
+        return self._options_window
+
+    def __pt_formatted_text__(self) -> list[tuple[str, str]]:
+        """支持直接作为 formatted text 使用。"""
+        return self._options_fragments()
+
+
+# 便捷函数：创建模型级别选择菜单
+def create_model_level_menu(
+    current_level: str | None,
+    llm_levels: dict[str, Any] | None,
+    on_confirm: Callable[[str], None],
+    on_cancel: Callable[[], None],
+) -> SelectionMenuUI:
+    """创建模型级别选择菜单。
+
+    Args:
+        current_level: 当前级别 (LOW/MID/HIGH)
+        llm_levels: LLM 级别配置字典，包含实际的模型实例
+        on_confirm: 确认回调
+        on_cancel: 取消回调
+
+    Returns:
+        配置好的 SelectionMenuUI 实例
+    """
+    ui = SelectionMenuUI()
+
+    title, options = build_model_level_options(
+        current_level=current_level or "MID",
+        llm_levels=llm_levels,
+    )
+
+    ui.set_options(
+        title=title,
+        options=options,
+        on_confirm=on_confirm,
+        on_cancel=on_cancel,
+    )
+    return ui
+
+
+def build_model_level_options(
+    *,
+    current_level: str,
+    llm_levels: dict[str, Any] | None,
+) -> tuple[str, list[dict[str, str]]]:
+    def get_model_name(level: str) -> str:
+        if llm_levels and level in llm_levels:
+            llm = llm_levels[level]
+            model = getattr(llm, "model", None)
+            if model:
+                return str(model)
+        return "unknown"
+
+    options = [
+        {
+            "value": "LOW",
+            "label": "LOW  - Fast & Cheap",
+            "description": f"{get_model_name('LOW')}",
+        },
+        {
+            "value": "MID",
+            "label": "MID  - Balanced",
+            "description": f"{get_model_name('MID')}",
+        },
+        {
+            "value": "HIGH",
+            "label": "HIGH - Best Quality",
+            "description": f"{get_model_name('HIGH')}",
+        },
+    ]
+
+    normalized = current_level.upper().strip() or "MID"
+    for opt in options:
+        if opt["value"] == normalized:
+            opt["label"] = f"{opt['label']}  (current)"
+            break
+
+    return "Select Model Level", options