@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/tui/acp/api.py

@@ -1,79 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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