codemaster-cli 2.2.0__py3-none-any.whl

vibe/acp/tools/session_update.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from acp.helpers import SessionUpdate, ToolCallContentVariant
+from acp.schema import (
+    ContentToolCallContent,
+    TextContentBlock,
+    ToolCallProgress,
+    ToolCallStart,
+    ToolKind,
+)
+
+from vibe.acp.tools.base import (
+    ToolCallSessionUpdateProtocol,
+    ToolResultSessionUpdateProtocol,
+)
+from vibe.core.tools.ui import ToolUIDataAdapter
+from vibe.core.types import ToolCallEvent, ToolResultEvent
+from vibe.core.utils import TaggedText, is_user_cancellation_event
+
+TOOL_KIND: dict[str, ToolKind] = {
+    "grep": "search",
+    "read_file": "read",
+    # Right now, jetbrains implementation of "edit" tool kind is broken
+    # Leading to the tool not appearing in the chat
+    # "write_file": "edit",
+    # "search_replace": "edit",
+}
+
+
+def tool_call_session_update(event: ToolCallEvent) -> SessionUpdate | None:
+    if issubclass(event.tool_class, ToolCallSessionUpdateProtocol):
+        return event.tool_class.tool_call_session_update(event)
+
+    adapter = ToolUIDataAdapter(event.tool_class)
+    display = adapter.get_call_display(event)
+    content: list[ToolCallContentVariant] | None = (
+        [
+            ContentToolCallContent(
+                type="content",
+                content=TextContentBlock(type="text", text=display.content),
+            )
+        ]
+        if display.content
+        else None
+    )
+
+    return ToolCallStart(
+        session_update="tool_call",
+        title=display.summary,
+        content=content,
+        tool_call_id=event.tool_call_id,
+        kind=TOOL_KIND.get(event.tool_name, "other"),
+        raw_input=event.args.model_dump_json(),
+    )
+
+
+def tool_result_session_update(event: ToolResultEvent) -> SessionUpdate | None:
+    if is_user_cancellation_event(event):
+        tool_status = "failed"
+        raw_output = (
+            TaggedText.from_string(event.skip_reason).message
+            if event.skip_reason
+            else None
+        )
+    elif event.result:
+        tool_status = "completed"
+        raw_output = event.result.model_dump_json()
+    else:
+        tool_status = "failed"
+        raw_output = (
+            TaggedText.from_string(event.error).message if event.error else None
+        )
+
+    if event.tool_class is None:
+        return ToolCallProgress(
+            session_update="tool_call_update",
+            tool_call_id=event.tool_call_id,
+            status="failed",
+            raw_output=raw_output,
+            content=[
+                ContentToolCallContent(
+                    type="content",
+                    content=TextContentBlock(type="text", text=raw_output or ""),
+                )
+            ],
+        )
+
+    if issubclass(event.tool_class, ToolResultSessionUpdateProtocol):
+        return event.tool_class.tool_result_session_update(event)
+
+    if tool_status == "failed":
+        content = [
+            ContentToolCallContent(
+                type="content",
+                content=TextContentBlock(type="text", text=raw_output or ""),
+            )
+        ]
+    else:
+        adapter = ToolUIDataAdapter(event.tool_class)
+        display = adapter.get_result_display(event)
+        content: list[ToolCallContentVariant] | None = (
+            [
+                ContentToolCallContent(
+                    type="content",
+                    content=TextContentBlock(type="text", text=display.message),
+                )
+            ]
+            if display.message
+            else None
+        )
+
+    return ToolCallProgress(
+        session_update="tool_call_update",
+        tool_call_id=event.tool_call_id,
+        status=tool_status,
+        raw_output=raw_output,
+        content=content,
+    )

vibe/acp/utils.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import TYPE_CHECKING, Literal, cast
+
+from acp.schema import (
+    AgentMessageChunk,
+    AgentThoughtChunk,
+    ContentToolCallContent,
+    PermissionOption,
+    SessionMode,
+    TextContentBlock,
+    ToolCallProgress,
+    ToolCallStart,
+    UserMessageChunk,
+)
+
+from vibe.core.agents.models import AgentProfile, AgentType
+from vibe.core.proxy_setup import SUPPORTED_PROXY_VARS, get_current_proxy_settings
+from vibe.core.types import CompactEndEvent, CompactStartEvent, LLMMessage
+from vibe.core.utils import compact_reduction_display
+
+if TYPE_CHECKING:
+    from vibe.core.agents.manager import AgentManager
+
+
+class ToolOption(StrEnum):
+    ALLOW_ONCE = "allow_once"
+    ALLOW_ALWAYS = "allow_always"
+    REJECT_ONCE = "reject_once"
+    REJECT_ALWAYS = "reject_always"
+
+
+TOOL_OPTIONS = [
+    PermissionOption(
+        option_id=ToolOption.ALLOW_ONCE,
+        name="Allow once",
+        kind=cast(Literal["allow_once"], ToolOption.ALLOW_ONCE),
+    ),
+    PermissionOption(
+        option_id=ToolOption.ALLOW_ALWAYS,
+        name="Allow always",
+        kind=cast(Literal["allow_always"], ToolOption.ALLOW_ALWAYS),
+    ),
+    PermissionOption(
+        option_id=ToolOption.REJECT_ONCE,
+        name="Reject once",
+        kind=cast(Literal["reject_once"], ToolOption.REJECT_ONCE),
+    ),
+]
+
+
+def agent_profile_to_acp(profile: AgentProfile) -> SessionMode:
+    return SessionMode(
+        id=profile.name, name=profile.display_name, description=profile.description
+    )
+
+
+def is_valid_acp_agent(agent_manager: AgentManager, agent_name: str) -> bool:
+    return agent_name in agent_manager.available_agents
+
+
+def get_all_acp_session_modes(agent_manager: AgentManager) -> list[SessionMode]:
+    return [
+        agent_profile_to_acp(profile)
+        for profile in agent_manager.available_agents.values()
+        if profile.agent_type == AgentType.AGENT
+    ]
+
+
+def create_compact_start_session_update(event: CompactStartEvent) -> ToolCallStart:
+    # WORKAROUND: Using tool_call to communicate compact events to the client.
+    # This should be revisited when the ACP protocol defines how compact events
+    # should be represented.
+    # [RFD](https://agentclientprotocol.com/rfds/session-usage)
+    return ToolCallStart(
+        session_update="tool_call",
+        tool_call_id=event.tool_call_id,
+        title="Compacting conversation history...",
+        kind="other",
+        status="in_progress",
+        content=[
+            ContentToolCallContent(
+                type="content",
+                content=TextContentBlock(
+                    type="text",
+                    text="Automatic context management, no approval required. This may take some time...",
+                ),
+            )
+        ],
+    )
+
+
+def create_compact_end_session_update(event: CompactEndEvent) -> ToolCallProgress:
+    # WORKAROUND: Using tool_call_update to communicate compact events to the client.
+    # This should be revisited when the ACP protocol defines how compact events
+    # should be represented.
+    # [RFD](https://agentclientprotocol.com/rfds/session-usage)
+    return ToolCallProgress(
+        session_update="tool_call_update",
+        tool_call_id=event.tool_call_id,
+        title="Compacted conversation history",
+        status="completed",
+        content=[
+            ContentToolCallContent(
+                type="content",
+                content=TextContentBlock(
+                    type="text",
+                    text=(
+                        compact_reduction_display(
+                            event.old_context_tokens, event.new_context_tokens
+                        )
+                    ),
+                ),
+            )
+        ],
+    )
+
+
+def get_proxy_help_text() -> str:
+    lines = [
+        "## Proxy Configuration",
+        "",
+        "Configure proxy and SSL settings for HTTP requests.",
+        "",
+        "### Usage:",
+        "- `/proxy-setup` - Show this help and current settings",
+        "- `/proxy-setup KEY value` - Set an environment variable",
+        "- `/proxy-setup KEY` - Remove an environment variable",
+        "",
+        "### Supported Variables:",
+    ]
+
+    for key, description in SUPPORTED_PROXY_VARS.items():
+        lines.append(f"- `{key}`: {description}")
+
+    lines.extend(["", "### Current Settings:"])
+
+    current = get_current_proxy_settings()
+    any_set = False
+    for key, value in current.items():
+        if value:
+            lines.append(f"- `{key}={value}`")
+            any_set = True
+
+    if not any_set:
+        lines.append("- (none configured)")
+
+    return "\n".join(lines)
+
+
+def create_user_message_replay(msg: LLMMessage) -> UserMessageChunk:
+    content = msg.content if isinstance(msg.content, str) else ""
+    return UserMessageChunk(
+        session_update="user_message_chunk",
+        content=TextContentBlock(type="text", text=content),
+        field_meta={"messageId": msg.message_id} if msg.message_id else {},
+    )
+
+
+def create_assistant_message_replay(msg: LLMMessage) -> AgentMessageChunk | None:
+    content = msg.content if isinstance(msg.content, str) else ""
+    if not content:
+        return None
+
+    return AgentMessageChunk(
+        session_update="agent_message_chunk",
+        content=TextContentBlock(type="text", text=content),
+        field_meta={"messageId": msg.message_id} if msg.message_id else {},
+    )
+
+
+def create_reasoning_replay(msg: LLMMessage) -> AgentThoughtChunk | None:
+    if not isinstance(msg.reasoning_content, str) or not msg.reasoning_content:
+        return None
+
+    return AgentThoughtChunk(
+        session_update="agent_thought_chunk",
+        content=TextContentBlock(type="text", text=msg.reasoning_content),
+        field_meta={"messageId": msg.message_id} if msg.message_id else {},
+    )
+
+
+def create_tool_call_replay(
+    tool_call_id: str, tool_name: str, arguments: str | None
+) -> ToolCallStart:
+    return ToolCallStart(
+        session_update="tool_call",
+        title=tool_name,
+        tool_call_id=tool_call_id,
+        kind="other",
+        raw_input=arguments,
+    )
+
+
+def create_tool_result_replay(msg: LLMMessage) -> ToolCallProgress | None:
+    if not msg.tool_call_id:
+        return None
+
+    content = msg.content if isinstance(msg.content, str) else ""
+    return ToolCallProgress(
+        session_update="tool_call_update",
+        tool_call_id=msg.tool_call_id,
+        status="completed",
+        raw_output=content,
+        content=[
+            ContentToolCallContent(
+                type="content", content=TextContentBlock(type="text", text=content)
+            )
+        ]
+        if content
+        else None,
+    )

vibe/cli/autocompletion/base.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Protocol
+
+
+class CompletionResult(StrEnum):
+    IGNORED = "ignored"
+    HANDLED = "handled"
+    SUBMIT = "submit"
+
+
+class CompletionView(Protocol):
+    def render_completion_suggestions(
+        self, suggestions: list[tuple[str, str]], selected_index: int
+    ) -> None: ...
+
+    def clear_completion_suggestions(self) -> None: ...
+
+    def replace_completion_range(
+        self, start: int, end: int, replacement: str
+    ) -> None: ...

vibe/cli/autocompletion/path_completion.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import atexit
+from concurrent.futures import Future, ThreadPoolExecutor
+from threading import Lock
+
+from textual import events
+
+from vibe.cli.autocompletion.base import CompletionResult, CompletionView
+from vibe.core.autocompletion.completers import PathCompleter
+
+MAX_SUGGESTIONS_COUNT = 10
+
+
+class PathCompletionController:
+    _executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="path-completion")
+
+    def __init__(self, completer: PathCompleter, view: CompletionView) -> None:
+        self._completer = completer
+        self._view = view
+        self._suggestions: list[tuple[str, str]] = []
+        self._selected_index = 0
+        self._pending_future: Future | None = None
+        self._last_query: tuple[str, int] | None = None
+        self._query_lock = Lock()
+
+    def can_handle(self, text: str, cursor_index: int) -> bool:
+        if cursor_index < 0 or cursor_index > len(text):
+            return False
+
+        if cursor_index == 0:
+            return False
+
+        before_cursor = text[:cursor_index]
+        if "@" not in before_cursor:
+            return False
+
+        at_index = before_cursor.rfind("@")
+
+        if cursor_index <= at_index:
+            return False
+
+        fragment = before_cursor[at_index:cursor_index]
+        # fragment must not be empty (including @) and not contain any spaces
+        return bool(fragment) and " " not in fragment
+
+    def reset(self) -> None:
+        with self._query_lock:
+            if self._pending_future and not self._pending_future.done():
+                self._pending_future.cancel()
+            self._pending_future = None
+            self._last_query = None
+        if self._suggestions:
+            self._suggestions.clear()
+            self._selected_index = 0
+            self._view.clear_completion_suggestions()
+
+    def on_text_changed(self, text: str, cursor_index: int) -> None:
+        if not self.can_handle(text, cursor_index):
+            self.reset()
+            return
+
+        query = (text, cursor_index)
+        with self._query_lock:
+            if query == self._last_query:
+                return
+
+            if self._pending_future and not self._pending_future.done():
+                # NOTE (Vince): this is a "best effort" cancellation: it only works if the task
+                # hasn't started; once running in the thread pool, it cannot be cancelled
+                self._pending_future.cancel()
+
+            self._last_query = query
+
+        app = getattr(self._view, "app", None)
+        if app:
+            with self._query_lock:
+                self._pending_future = self._executor.submit(
+                    self._compute_completions, text, cursor_index
+                )
+                self._pending_future.add_done_callback(
+                    lambda f: self._handle_completion_result(f, query)
+                )
+        else:
+            suggestions = self._compute_completions(text, cursor_index)
+            self._update_suggestions(suggestions)
+
+    def _compute_completions(
+        self, text: str, cursor_index: int
+    ) -> list[tuple[str, str]]:
+        return self._completer.get_completion_items(text, cursor_index)
+
+    def _handle_completion_result(self, future: Future, query: tuple[str, int]) -> None:
+        if future.cancelled():
+            return
+
+        try:
+            suggestions = future.result()
+            with self._query_lock:
+                if query == self._last_query:
+                    self._update_suggestions(suggestions)
+        except Exception:
+            with self._query_lock:
+                self._pending_future = None
+                self._last_query = None
+
+    def _update_suggestions(self, suggestions: list[tuple[str, str]]) -> None:
+        if len(suggestions) > MAX_SUGGESTIONS_COUNT:
+            suggestions = suggestions[:MAX_SUGGESTIONS_COUNT]
+
+        app = getattr(self._view, "app", None)
+
+        if suggestions:
+            self._suggestions = suggestions
+            self._selected_index = 0
+            if app:
+                app.call_after_refresh(
+                    self._view.render_completion_suggestions,
+                    self._suggestions,
+                    self._selected_index,
+                )
+            else:
+                self._view.render_completion_suggestions(
+                    self._suggestions, self._selected_index
+                )
+        elif app:
+            app.call_after_refresh(self.reset)
+        else:
+            self.reset()
+
+    def on_key(
+        self, event: events.Key, text: str, cursor_index: int
+    ) -> CompletionResult:
+        if not self._suggestions:
+            return CompletionResult.IGNORED
+
+        match event.key:
+            case "tab" | "enter":
+                if self._apply_selected_completion(text, cursor_index):
+                    return CompletionResult.HANDLED
+                return CompletionResult.IGNORED
+            case "down":
+                self._move_selection(1)
+                return CompletionResult.HANDLED
+            case "up":
+                self._move_selection(-1)
+                return CompletionResult.HANDLED
+            case _:
+                return CompletionResult.IGNORED
+
+    def _move_selection(self, delta: int) -> None:
+        if not self._suggestions:
+            return
+
+        count = len(self._suggestions)
+        self._selected_index = (self._selected_index + delta) % count
+        self._view.render_completion_suggestions(
+            self._suggestions, self._selected_index
+        )
+
+    def _apply_selected_completion(self, text: str, cursor_index: int) -> bool:
+        if not self._suggestions:
+            return False
+
+        completion, _ = self._suggestions[self._selected_index]
+        replacement_range = self._completer.get_replacement_range(text, cursor_index)
+        if replacement_range is None:
+            self.reset()
+            return False
+
+        start, end = replacement_range
+        self._view.replace_completion_range(start, end, completion)
+        self.reset()
+        return True
+
+
+atexit.register(PathCompletionController._executor.shutdown)

vibe/cli/autocompletion/slash_command.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from textual import events
+
+from vibe.cli.autocompletion.base import CompletionResult, CompletionView
+from vibe.core.autocompletion.completers import CommandCompleter
+
+MAX_SUGGESTIONS_COUNT = 10
+
+
+class SlashCommandController:
+    def __init__(self, completer: CommandCompleter, view: CompletionView) -> None:
+        self._completer = completer
+        self._view = view
+        self._suggestions: list[tuple[str, str]] = []
+        self._selected_index = 0
+
+    def can_handle(self, text: str, cursor_index: int) -> bool:
+        return text.startswith("/")
+
+    def reset(self) -> None:
+        if self._suggestions:
+            self._suggestions.clear()
+            self._selected_index = 0
+            self._view.clear_completion_suggestions()
+
+    def on_text_changed(self, text: str, cursor_index: int) -> None:
+        if cursor_index < 0 or cursor_index > len(text):
+            self.reset()
+            return
+
+        if not self.can_handle(text, cursor_index):
+            self.reset()
+            return
+
+        suggestions = self._completer.get_completion_items(text, cursor_index)
+        if len(suggestions) > MAX_SUGGESTIONS_COUNT:
+            suggestions = suggestions[:MAX_SUGGESTIONS_COUNT]
+        if suggestions:
+            self._suggestions = suggestions
+            self._selected_index = 0
+            self._view.render_completion_suggestions(
+                self._suggestions, self._selected_index
+            )
+        else:
+            self.reset()
+
+    def on_key(
+        self, event: events.Key, text: str, cursor_index: int
+    ) -> CompletionResult:
+        if not self._suggestions:
+            return CompletionResult.IGNORED
+
+        match event.key:
+            case "tab":
+                if self._apply_selected_completion(text, cursor_index):
+                    result = CompletionResult.HANDLED
+                else:
+                    result = CompletionResult.IGNORED
+            case "enter":
+                if self._apply_selected_completion(text, cursor_index):
+                    result = CompletionResult.SUBMIT
+                else:
+                    result = CompletionResult.HANDLED
+            case "down":
+                self._move_selection(1)
+                result = CompletionResult.HANDLED
+            case "up":
+                self._move_selection(-1)
+                result = CompletionResult.HANDLED
+            case _:
+                result = CompletionResult.IGNORED
+
+        return result
+
+    def _move_selection(self, delta: int) -> None:
+        if not self._suggestions:
+            return
+
+        count = len(self._suggestions)
+        self._selected_index = (self._selected_index + delta) % count
+        self._view.render_completion_suggestions(
+            self._suggestions, self._selected_index
+        )
+
+    def _apply_selected_completion(self, text: str, cursor_index: int) -> bool:
+        if not self._suggestions:
+            return False
+
+        alias, _ = self._suggestions[self._selected_index]
+        replacement_range = self._completer.get_replacement_range(text, cursor_index)
+        if replacement_range is None:
+            self.reset()
+            return False
+
+        start, end = replacement_range
+        self._view.replace_completion_range(start, end, alias)
+        self.reset()
+        return True