@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/acp/api.py

@@ -0,0 +1,79 @@
+# mypy: disable-error-code="empty-body"
+"""
+ACP remote API
+"""
+
+from tui import jsonrpc
+from tui.acp import protocol
+
+API = jsonrpc.API()
+
+
+@API.method()
+def initialize(
+    protocolVersion: int,
+    clientCapabilities: protocol.ClientCapabilities,
+    clientInfo: protocol.Implementation,
+) -> protocol.InitializeResponse:
+    """https://agentclientprotocol.com/protocol/initialization"""
+    ...
+
+
+@API.method(name="session/new")
+def session_new(
+    cwd: str, mcpServers: list[protocol.McpServer]
+) -> protocol.NewSessionResponse:
+    """https://agentclientprotocol.com/protocol/session-setup#session-id"""
+    ...
+
+
+@API.method(name="session/load")
+def session_load(
+    cwd: str, mcpServers: list[protocol.McpServer], sessionId: str
+) -> protocol.LoadSessionResponse:
+    """https://agentclientprotocol.com/protocol/session-setup#loading-a-session"""
+    ...
+
+
+@API.notification(name="session/cancel")
+def session_cancel(sessionId: str, _meta: dict):
+    """https://agentclientprotocol.com/protocol/prompt-turn#cancellation"""
+    ...
+
+
+@API.method(name="session/prompt")
+def session_prompt(
+    prompt: list[protocol.ContentBlock], sessionId: str
+) -> protocol.SessionPromptResponse:
+    """https://agentclientprotocol.com/protocol/prompt-turn#1-user-message"""
+    ...
+
+
+@API.method(name="session/set_mode")
+def session_set_mode(sessionId: str, modeId: str) -> protocol.SetSessionModeResponse:
+    """https://agentclientprotocol.com/protocol/session-modes#from-the-client"""
+    ...
+
+
+@API.method(name="session/save")
+def session_save(sessionId: str) -> dict:
+    """Save the session state."""
+    ...
+
+
+@API.method(name="session/clear_todos")
+def session_clear_todos(sessionId: str) -> dict:
+    """Clear all todos in the current session."""
+    ...
+
+
+@API.method(name="session/compact")
+def session_compact(sessionId: str) -> dict:
+    """Compact the context to reduce token usage."""
+    ...
+
+
+@API.method(name="session/load_earlier")
+def session_load_earlier(sessionId: str, offset: int, limit: int) -> dict:
+    """Load a range of earlier messages from the current session."""
+    ...

package/tui/acp/encode_tool_call_id.py

@@ -0,0 +1,12 @@
+def encode_tool_call_id(tool_call_id: str) -> str:
+    """Encode the tool call id so that it fits within a TCSS id.
+
+    Args:
+        tool_call_id: Raw tool call id.
+
+    Returns:
+        Tool call usable as widget id.
+    """
+    hex_tool_call_id = "".join(f"{ord(character):2X}" for character in tool_call_id)
+    encoded_tool_call_id = f"tool-call-{hex_tool_call_id}"
+    return encoded_tool_call_id

package/tui/acp/event_tap.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from tui.acp.protocol import SessionUpdate
+
+logger = logging.getLogger("tui.acp.event_tap")
+
+
+@dataclass
+class AcpTapMetrics:
+    tool_call_count: int = 0
+    tool_call_updates: int = 0
+    user_message_chunks: int = 0
+    agent_message_chunks: int = 0
+    thought_chunks: int = 0
+    subagent_starts: int = 0
+    ask_user_count: int = 0
+    turn_count: int = 0
+    tool_errors: int = 0
+    verification_passed: int = 0
+    verification_failed: int = 0
+
+
+class AcpEventTap:
+    """Passively sniff ACP session/update stream.
+
+    Requires zero cooperation from the engine — it simply observes
+    the existing ACP protocol messages that every engine already sends.
+    Works with any engine: onecode, opencode, claude, cursor, etc.
+    """
+
+    def __init__(self) -> None:
+        self.metrics = AcpTapMetrics()
+        self._session_id: str = ""
+        self._collecting: bool = False
+
+    def start_collecting(self, session_id: str) -> None:
+        self._session_id = session_id
+        self.metrics = AcpTapMetrics()
+        self._collecting = True
+
+    def stop_collecting(self) -> dict[str, Any]:
+        self._collecting = False
+        return self._derive_session_metrics()
+
+    def on_session_update(self, update: SessionUpdate) -> None:
+        """Called for every session/update message. Thread-safe call from ACP dispatch."""
+        if not self._collecting:
+            return
+
+        discriminator = update.get("sessionUpdate", "")
+
+        if discriminator == "tool_call":
+            self.metrics.tool_call_count += 1
+        elif discriminator == "tool_call_update":
+            self.metrics.tool_call_updates += 1
+        elif discriminator == "user_message_chunk":
+            self.metrics.user_message_chunks += 1
+        elif discriminator == "agent_message_chunk":
+            self.metrics.agent_message_chunks += 1
+        elif discriminator == "agent_thought_chunk":
+            self.metrics.thought_chunks += 1
+        elif discriminator == "subagent_start":
+            self.metrics.subagent_starts += 1
+        elif discriminator == "ask_user":
+            self.metrics.ask_user_count += 1
+
+    def on_session_event(self, event: dict) -> None:
+        """Handle structured session/event notification (onecode enhancement).
+
+        Provides more precise metrics than passive session/update sniffing.
+        """
+        if not self._collecting:
+            return
+
+        event_type = event.get("type", "")
+
+        if event_type == "tool_executed":
+            self.metrics.tool_call_count += 1
+        elif event_type == "tool_result":
+            if event.get("is_error"):
+                self.metrics.tool_errors += 1
+        elif event_type == "session_ended":
+            self.metrics.turn_count = event.get("turn_count", 0)
+        elif event_type == "verification_passed":
+            self.metrics.verification_passed += 1
+        elif event_type == "verification_failed":
+            self.metrics.verification_failed += 1
+
+    def _derive_session_metrics(self) -> dict[str, Any]:
+        tool_efficiency = 1.0
+        if self.metrics.tool_call_count > 0:
+            tool_efficiency = min(1.0, 10.0 / max(self.metrics.tool_call_count, 1))
+
+        return {
+            "session_id": self._session_id,
+            "tool_call_count": self.metrics.tool_call_count,
+            "tool_errors": self.metrics.tool_errors,
+            "tool_efficiency": tool_efficiency,
+            "turn_count": self.metrics.turn_count,
+            "has_subagents": self.metrics.subagent_starts > 0,
+            "verification_passed": self.metrics.verification_passed,
+            "verification_failed": self.metrics.verification_failed,
+        }

package/tui/acp/messages.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from asyncio import Future
+from typing import Mapping, TYPE_CHECKING
+from textual.message import Message
+
+import rich.repr
+
+from tui.answer import Answer
+from tui.acp import protocol
+from tui.acp.encode_tool_call_id import encode_tool_call_id
+
+if TYPE_CHECKING:
+    from tui.acp.agent import Mode
+    from tui.widgets.terminal_tool import ToolState
+
+
+class AgentMessage(Message):
+    pass
+
+
+@dataclass
+class ContextUpdate(AgentMessage):
+    """Context token usage update from the engine."""
+    used: int
+    size: int
+
+
+@dataclass
+class Thinking(AgentMessage):
+    type: str
+    text: str
+
+
+@dataclass
+class SessionReplay(AgentMessage):
+    """Marks the start/end of a session replay (loading historical messages)."""
+    active: bool
+    total_messages: int = 0
+    visible_count: int = 0
+
+
+@dataclass
+class UpdateStatusLine(AgentMessage):
+    status_line: str
+
+
+@dataclass
+class Update(AgentMessage):
+    type: str
+    text: str
+
+
+@dataclass
+class UserMessage(Message):
+    type: str
+    text: str
+
+
+@dataclass
+@rich.repr.auto
+class RequestPermission(AgentMessage):
+    options: list[protocol.PermissionOption]
+    tool_call: protocol.ToolCallUpdatePermissionRequest
+    result_future: Future[Answer]
+
+
+@dataclass
+class AskUser(AgentMessage):
+    question: str = ""
+    context: str = ""
+    options: list[dict] = field(default_factory=list)
+    questions: list[dict] = field(default_factory=list)
+    tool_id: str = ""
+    checkpoint_id: str = ""
+
+
+@dataclass
+class AwaitingUserInput(AgentMessage):
+    """The agent yielded control to the user without invoking AskUser.
+
+    Sent in response to the ``awaiting_user_input`` ACP sessionUpdate.
+    The next user_input_submitted should be routed as a reply to the
+    question currently on screen, not queued as a brand-new task.
+    """
+    prompt_preview: str = ""
+
+
+@dataclass
+class AIDLCState(AgentMessage):
+    current_phase: str
+    completed_phases: list[str]
+    gate_results: dict
+
+
+@dataclass
+class Plan(AgentMessage):
+    entries: list[protocol.PlanEntry]
+
+
+@dataclass
+class ToolCall(AgentMessage):
+    tool_call: protocol.ToolCall
+
+    @property
+    def tool_id(self) -> str:
+        """An id suitable for use as a TCSS ID."""
+        return encode_tool_call_id(self.tool_call["toolCallId"])
+
+
+@dataclass
+class ToolCallUpdate(AgentMessage):
+    tool_call: protocol.ToolCall
+    update: protocol.ToolCallUpdate
+
+    @property
+    def tool_id(self) -> str:
+        """An id suitable for use as a TCSS ID."""
+        return encode_tool_call_id(self.tool_call["toolCallId"])
+
+
+@dataclass
+class AvailableCommandsUpdate(AgentMessage):
+    """The agent is reporting its slash commands."""
+
+    commands: list[protocol.AvailableCommand]
+
+
+@dataclass
+class CreateTerminal(AgentMessage):
+    """Request a terminal in the conversation."""
+
+    terminal_id: str
+    command: str
+    result_future: Future[bool]
+    args: list[str] | None = None
+    cwd: str | None = None
+    env: Mapping[str, str] | None = None
+    output_byte_limit: int | None = None
+
+
+@dataclass
+class KillTerminal(AgentMessage):
+    """Kill a terminal process."""
+
+    terminal_id: str
+
+
+@dataclass
+class GetTerminalState(AgentMessage):
+    """Get the state of the terminal."""
+
+    terminal_id: str
+    result_future: Future[ToolState]
+
+
+@dataclass
+class ReleaseTerminal(AgentMessage):
+    """Release the terminal."""
+
+    terminal_id: str
+
+
+@dataclass
+class WaitForTerminalExit(AgentMessage):
+    """Wait for the terminal to exit."""
+
+    terminal_id: str
+    result_future: Future[tuple[int, str | None]]
+
+
+@rich.repr.auto
+@dataclass
+class SetModes(AgentMessage):
+    """Set modes from agent."""
+
+    current_mode: str
+    modes: dict[str, Mode]
+
+
+@dataclass
+class ModeUpdate(AgentMessage):
+    """Agent informed us about a mode change."""
+
+    current_mode: str
+
+
+@dataclass
+class SubAgentStart(AgentMessage):
+    """Sub-agent task started."""
+
+    subagent_id: str
+    agent_type: str
+    prompt: str = ""
+
+
+@dataclass
+class SubAgentChunk(AgentMessage):
+    """Sub-agent streaming text chunk."""
+
+    subagent_id: str
+    text: str
+
+
+@dataclass
+class SubAgentThinking(AgentMessage):
+    """Sub-agent thinking block."""
+
+    subagent_id: str
+    text: str
+
+
+@dataclass
+class SubAgentEnd(AgentMessage):
+    """Sub-agent task completed."""
+
+    subagent_id: str
+    agent_type: str
+    status: str = "completed"
+    error: str = ""

package/tui/acp/prompt.py

@@ -0,0 +1,53 @@
+import base64
+from pathlib import Path
+
+from tui.acp import protocol
+from tui.prompt.extract import extract_paths_from_prompt
+from tui.prompt.resource import load_resource, ResourceError
+
+
+def build(project_path: Path, prompt: str) -> list[protocol.ContentBlock]:
+    """Build the prompt structure and extract paths with the @ syntax.
+
+    Args:
+        project_path: The project root.
+        prompt: The prompt text.
+
+    Returns:
+        A list of content blocks.
+    """
+    prompt_content: list[protocol.ContentBlock] = []
+
+    prompt_content.append({"type": "text", "text": prompt})
+    for path, _, _ in extract_paths_from_prompt(prompt):
+        if path.endswith("/"):
+            continue
+        try:
+            resource = load_resource(project_path, Path(path))
+        except ResourceError:
+            continue
+        uri = f"file://{resource.path.absolute().resolve()}"
+        if resource.text is not None:
+            prompt_content.append(
+                {
+                    "type": "resource",
+                    "resource": {
+                        "uri": uri,
+                        "text": resource.text,
+                        "mimeType": resource.mime_type,
+                    },
+                }
+            )
+        elif resource.data is not None:
+            prompt_content.append(
+                {
+                    "type": "resource",
+                    "resource": {
+                        "uri": uri,
+                        "blob": base64.b64encode(resource.data).decode("utf-8"),
+                        "mimeType": resource.mime_type,
+                    },
+                }
+            )
+
+    return prompt_content