codemaster-cli 2.2.0__py3-none-any.whl

vibe/acp/entrypoint.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import os
+import sys
+
+from vibe import __version__
+from vibe.core.config import VibeConfig
+from vibe.core.paths.config_paths import CONFIG_FILE, HISTORY_FILE, unlock_config_paths
+from vibe.core.utils import logger
+
+# Configure line buffering for subprocess communication
+sys.stdout.reconfigure(line_buffering=True)  # pyright: ignore[reportAttributeAccessIssue]
+sys.stderr.reconfigure(line_buffering=True)  # pyright: ignore[reportAttributeAccessIssue]
+sys.stdin.reconfigure(line_buffering=True)  # pyright: ignore[reportAttributeAccessIssue]
+
+
+@dataclass
+class Arguments:
+    setup: bool
+
+
+def parse_arguments() -> Arguments:
+    parser = argparse.ArgumentParser(description="Run codeMaster in ACP mode")
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument("--setup", action="store_true", help="Setup API key and exit")
+    args = parser.parse_args()
+    return Arguments(setup=args.setup)
+
+
+def bootstrap_config_files() -> None:
+    if not CONFIG_FILE.path.exists():
+        try:
+            VibeConfig.save_updates(VibeConfig.create_default())
+        except Exception as e:
+            logger.error(f"Could not create default config file: {e}")
+            raise
+
+    if not HISTORY_FILE.path.exists():
+        try:
+            HISTORY_FILE.path.parent.mkdir(parents=True, exist_ok=True)
+            HISTORY_FILE.path.write_text("Hello Vibe!\n", "utf-8")
+        except Exception as e:
+            logger.error(f"Could not create history file: {e}")
+            raise
+
+
+def handle_debug_mode() -> None:
+    if os.environ.get("DEBUG_MODE") != "true":
+        return
+
+    try:
+        import debugpy
+    except ImportError:
+        return
+
+    debugpy.listen(("localhost", 5678))
+    # uncomment this to wait for the debugger to attach
+    # debugpy.wait_for_client()
+
+
+def main() -> None:
+    handle_debug_mode()
+    unlock_config_paths()
+
+    from vibe.acp.acp_agent_loop import run_acp_server
+    from vibe.setup.onboarding import run_onboarding
+
+    bootstrap_config_files()
+    args = parse_arguments()
+    if args.setup:
+        run_onboarding()
+        sys.exit(0)
+    run_acp_server()
+
+
+if __name__ == "__main__":
+    main()

vibe/acp/tools/base.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Annotated, Protocol, cast, runtime_checkable
+
+from acp import Client
+from acp.helpers import SessionUpdate, ToolCallContentVariant
+from acp.schema import ToolCallProgress
+from pydantic import BaseModel, ConfigDict, Field, SkipValidation
+
+from vibe.core.tools.base import BaseTool, ToolError
+from vibe.core.tools.manager import ToolManager
+from vibe.core.types import ToolCallEvent, ToolResultEvent
+from vibe.core.utils import logger
+
+
+@runtime_checkable
+class ToolCallSessionUpdateProtocol(Protocol):
+    @classmethod
+    def tool_call_session_update(cls, event: ToolCallEvent) -> SessionUpdate | None: ...
+
+
+@runtime_checkable
+class ToolResultSessionUpdateProtocol(Protocol):
+    @classmethod
+    def tool_result_session_update(
+        cls, event: ToolResultEvent
+    ) -> SessionUpdate | None: ...
+
+
+class AcpToolState(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    client: Annotated[Client | None, SkipValidation] = Field(
+        default=None, description="ACP Client"
+    )
+    session_id: str | None = Field(default=None, description="Current ACP session ID")
+    tool_call_id: str | None = Field(
+        default=None, description="Current ACP tool call ID"
+    )
+
+
+class BaseAcpTool[ToolState: AcpToolState](BaseTool):
+    state: ToolState
+
+    @classmethod
+    def get_tool_instance(
+        cls, tool_name: str, tool_manager: ToolManager
+    ) -> BaseAcpTool[AcpToolState]:
+        return cast(BaseAcpTool[AcpToolState], tool_manager.get(tool_name))
+
+    @classmethod
+    def update_tool_state(
+        cls,
+        *,
+        tool_manager: ToolManager,
+        client: Client | None,
+        session_id: str | None,
+        tool_call_id: str | None,
+    ) -> None:
+        tool_instance = cls.get_tool_instance(cls.get_name(), tool_manager)
+        tool_instance.state.client = client
+        tool_instance.state.session_id = session_id
+        tool_instance.state.tool_call_id = tool_call_id
+
+    @classmethod
+    @abstractmethod
+    def _get_tool_state_class(cls) -> type[ToolState]: ...
+
+    def _load_state(self) -> tuple[Client, str, str | None]:
+        if self.state.client is None:
+            raise ToolError(
+                "Client not available in tool state. This tool can only be used within an ACP session."
+            )
+        if self.state.session_id is None:
+            raise ToolError(
+                "Session ID not available in tool state. This tool can only be used within an ACP session."
+            )
+
+        return self.state.client, self.state.session_id, self.state.tool_call_id
+
+    async def _send_in_progress_session_update(
+        self, content: list[ToolCallContentVariant] | None = None
+    ) -> None:
+        client, session_id, tool_call_id = self._load_state()
+        if tool_call_id is None:
+            return
+
+        try:
+            await client.session_update(
+                session_id=session_id,
+                update=ToolCallProgress(
+                    session_update="tool_call_update",
+                    tool_call_id=tool_call_id,
+                    status="in_progress",
+                    content=content,
+                ),
+            )
+        except Exception as e:
+            logger.error(f"Failed to update session: {e!r}")

vibe/acp/tools/builtins/bash.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+from pathlib import Path
+
+from acp.schema import (
+    TerminalToolCallContent,
+    ToolCallProgress,
+    ToolCallStart,
+    WaitForTerminalExitResponse,
+)
+
+from vibe import VIBE_ROOT
+from vibe.acp.tools.base import AcpToolState, BaseAcpTool
+from vibe.core.tools.base import BaseToolState, InvokeContext, ToolError
+from vibe.core.tools.builtins.bash import Bash as CoreBashTool, BashArgs, BashResult
+from vibe.core.types import ToolCallEvent, ToolResultEvent, ToolStreamEvent
+from vibe.core.utils import logger
+
+
+class AcpBashState(BaseToolState, AcpToolState):
+    pass
+
+
+class Bash(CoreBashTool, BaseAcpTool[AcpBashState]):
+    prompt_path = VIBE_ROOT / "core" / "tools" / "builtins" / "prompts" / "bash.md"
+    state: AcpBashState
+
+    @classmethod
+    def _get_tool_state_class(cls) -> type[AcpBashState]:
+        return AcpBashState
+
+    async def run(
+        self, args: BashArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | BashResult, None]:
+        client, session_id, _ = self._load_state()
+
+        timeout = args.timeout or self.config.default_timeout
+        max_bytes = self.config.max_output_bytes
+
+        try:
+            terminal = await client.create_terminal(
+                session_id=session_id,
+                command=args.command,
+                cwd=str(Path.cwd()),
+                output_byte_limit=max_bytes,
+            )
+        except Exception as e:
+            raise ToolError(f"Failed to create terminal: {e!r}") from e
+
+        terminal_id = terminal.terminal_id
+
+        await self._send_in_progress_session_update([
+            TerminalToolCallContent(type="terminal", terminal_id=terminal_id)
+        ])
+
+        try:
+            exit_response = await self._wait_for_terminal_exit(
+                terminal_id=terminal_id, timeout=timeout, command=args.command
+            )
+
+            output_response = await client.terminal_output(
+                session_id=session_id, terminal_id=terminal_id
+            )
+
+            yield self._build_result(
+                command=args.command,
+                stdout=output_response.output,
+                stderr="",
+                returncode=exit_response.exit_code or 0,
+            )
+
+        finally:
+            try:
+                await client.release_terminal(
+                    session_id=session_id, terminal_id=terminal_id
+                )
+            except Exception as e:
+                logger.error(f"Failed to release terminal: {e!r}")
+
+    @classmethod
+    def get_summary(cls, args: BashArgs) -> str:
+        summary = f"{args.command}"
+        if args.timeout:
+            summary += f" (timeout {args.timeout}s)"
+
+        return summary
+
+    async def _wait_for_terminal_exit(
+        self, terminal_id: str, timeout: int, command: str
+    ) -> WaitForTerminalExitResponse:
+        client, session_id, _ = self._load_state()
+
+        try:
+            return await asyncio.wait_for(
+                client.wait_for_terminal_exit(
+                    session_id=session_id, terminal_id=terminal_id
+                ),
+                timeout=timeout,
+            )
+        except TimeoutError:
+            try:
+                await client.kill_terminal(
+                    session_id=session_id, terminal_id=terminal_id
+                )
+            except Exception as e:
+                logger.error(f"Failed to kill terminal: {e!r}")
+
+            raise self._build_timeout_error(command, timeout)
+
+    @classmethod
+    def tool_call_session_update(cls, event: ToolCallEvent) -> ToolCallStart:
+        if not isinstance(event.args, BashArgs):
+            raise ValueError(f"Unexpected tool args: {event.args}")
+
+        return ToolCallStart(
+            session_update="tool_call",
+            title=Bash.get_summary(event.args),
+            content=None,
+            tool_call_id=event.tool_call_id,
+            kind="execute",
+            raw_input=event.args.model_dump_json(),
+        )
+
+    @classmethod
+    def tool_result_session_update(
+        cls, event: ToolResultEvent
+    ) -> ToolCallProgress | None:
+        return ToolCallProgress(
+            session_update="tool_call_update",
+            tool_call_id=event.tool_call_id,
+            status="failed" if event.error else "completed",
+        )

vibe/acp/tools/builtins/read_file.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from vibe import VIBE_ROOT
+from vibe.acp.tools.base import AcpToolState, BaseAcpTool
+from vibe.core.tools.base import ToolError
+from vibe.core.tools.builtins.read_file import (
+    ReadFile as CoreReadFileTool,
+    ReadFileArgs,
+    ReadFileResult,
+    ReadFileState,
+    _ReadResult,
+)
+
+ReadFileResult = ReadFileResult
+
+
+class AcpReadFileState(ReadFileState, AcpToolState):
+    pass
+
+
+class ReadFile(CoreReadFileTool, BaseAcpTool[AcpReadFileState]):
+    state: AcpReadFileState
+    prompt_path = VIBE_ROOT / "core" / "tools" / "builtins" / "prompts" / "read_file.md"
+
+    @classmethod
+    def _get_tool_state_class(cls) -> type[AcpReadFileState]:
+        return AcpReadFileState
+
+    async def _read_file(self, args: ReadFileArgs, file_path: Path) -> _ReadResult:
+        client, session_id, _ = self._load_state()
+
+        line = args.offset + 1 if args.offset > 0 else None
+        limit = args.limit
+
+        await self._send_in_progress_session_update()
+
+        try:
+            response = await client.read_text_file(
+                session_id=session_id, path=str(file_path), line=line, limit=limit
+            )
+        except Exception as e:
+            raise ToolError(f"Error reading {file_path}: {e}") from e
+
+        content_lines = response.content.splitlines(keepends=True)
+        lines_read = len(content_lines)
+        bytes_read = sum(len(line.encode("utf-8")) for line in content_lines)
+
+        was_truncated = args.limit is not None and lines_read >= args.limit
+
+        return _ReadResult(
+            lines=content_lines, bytes_read=bytes_read, was_truncated=was_truncated
+        )

vibe/acp/tools/builtins/search_replace.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from acp.helpers import SessionUpdate
+from acp.schema import (
+    FileEditToolCallContent,
+    ToolCallLocation,
+    ToolCallProgress,
+    ToolCallStart,
+)
+
+from vibe import VIBE_ROOT
+from vibe.acp.tools.base import AcpToolState, BaseAcpTool
+from vibe.core.tools.base import ToolError
+from vibe.core.tools.builtins.search_replace import (
+    SearchReplace as CoreSearchReplaceTool,
+    SearchReplaceArgs,
+    SearchReplaceResult,
+    SearchReplaceState,
+)
+from vibe.core.types import ToolCallEvent, ToolResultEvent
+
+
+class AcpSearchReplaceState(SearchReplaceState, AcpToolState):
+    file_backup_content: str | None = None
+
+
+class SearchReplace(CoreSearchReplaceTool, BaseAcpTool[AcpSearchReplaceState]):
+    state: AcpSearchReplaceState
+    prompt_path = (
+        VIBE_ROOT / "core" / "tools" / "builtins" / "prompts" / "search_replace.md"
+    )
+
+    @classmethod
+    def _get_tool_state_class(cls) -> type[AcpSearchReplaceState]:
+        return AcpSearchReplaceState
+
+    async def _read_file(self, file_path: Path) -> str:
+        client, session_id, _ = self._load_state()
+
+        await self._send_in_progress_session_update()
+
+        try:
+            response = await client.read_text_file(
+                session_id=session_id, path=str(file_path)
+            )
+        except Exception as e:
+            raise ToolError(f"Unexpected error reading {file_path}: {e}") from e
+
+        self.state.file_backup_content = response.content
+        return response.content
+
+    async def _backup_file(self, file_path: Path) -> None:
+        if self.state.file_backup_content is None:
+            return
+
+        await self._write_file(
+            file_path.with_suffix(file_path.suffix + ".bak"),
+            self.state.file_backup_content,
+        )
+
+    async def _write_file(self, file_path: Path, content: str) -> None:
+        client, session_id, _ = self._load_state()
+
+        try:
+            await client.write_text_file(
+                session_id=session_id, path=str(file_path), content=content
+            )
+        except Exception as e:
+            raise ToolError(f"Error writing {file_path}: {e}") from e
+
+    @classmethod
+    def tool_call_session_update(cls, event: ToolCallEvent) -> SessionUpdate | None:
+        args = event.args
+        if not isinstance(args, SearchReplaceArgs):
+            return None
+
+        blocks = cls._parse_search_replace_blocks(args.content)
+
+        return ToolCallStart(
+            session_update="tool_call",
+            title=cls.get_call_display(event).summary,
+            tool_call_id=event.tool_call_id,
+            kind="edit",
+            content=[
+                FileEditToolCallContent(
+                    type="diff",
+                    path=args.file_path,
+                    old_text=block.search,
+                    new_text=block.replace,
+                )
+                for block in blocks
+            ],
+            locations=[ToolCallLocation(path=args.file_path)],
+            raw_input=args.model_dump_json(),
+        )
+
+    @classmethod
+    def tool_result_session_update(cls, event: ToolResultEvent) -> SessionUpdate | None:
+        if event.error:
+            return ToolCallProgress(
+                session_update="tool_call_update",
+                tool_call_id=event.tool_call_id,
+                status="failed",
+            )
+
+        result = event.result
+        if not isinstance(result, SearchReplaceResult):
+            return None
+
+        blocks = cls._parse_search_replace_blocks(result.content)
+
+        return ToolCallProgress(
+            session_update="tool_call_update",
+            tool_call_id=event.tool_call_id,
+            status="completed",
+            content=[
+                FileEditToolCallContent(
+                    type="diff",
+                    path=result.file,
+                    old_text=block.search,
+                    new_text=block.replace,
+                )
+                for block in blocks
+            ],
+            locations=[ToolCallLocation(path=result.file)],
+            raw_output=result.model_dump_json(),
+        )

vibe/acp/tools/builtins/todo.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import cast
+
+from acp.helpers import SessionUpdate
+from acp.schema import AgentPlanUpdate, PlanEntry, PlanEntryPriority, PlanEntryStatus
+
+from vibe import VIBE_ROOT
+from vibe.acp.tools.base import AcpToolState, BaseAcpTool
+from vibe.core.tools.builtins.todo import (
+    Todo as CoreTodoTool,
+    TodoArgs,
+    TodoPriority,
+    TodoResult,
+    TodoState,
+    TodoStatus,
+)
+from vibe.core.types import ToolCallEvent, ToolResultEvent
+
+TodoArgs = TodoArgs
+
+
+class AcpTodoState(TodoState, AcpToolState):
+    pass
+
+
+class Todo(CoreTodoTool, BaseAcpTool[AcpTodoState]):
+    state: AcpTodoState
+    prompt_path = VIBE_ROOT / "core" / "tools" / "builtins" / "prompts" / "todo.md"
+
+    @classmethod
+    def _get_tool_state_class(cls) -> type[AcpTodoState]:
+        return AcpTodoState
+
+    @classmethod
+    def tool_call_session_update(cls, event: ToolCallEvent) -> SessionUpdate | None:
+        return None
+
+    @classmethod
+    def tool_result_session_update(cls, event: ToolResultEvent) -> SessionUpdate | None:
+        result = cast(TodoResult, event.result)
+        todos = [todo for todo in result.todos if todo.status != TodoStatus.CANCELLED]
+        matched_status: dict[TodoStatus, PlanEntryStatus] = {
+            TodoStatus.PENDING: "pending",
+            TodoStatus.IN_PROGRESS: "in_progress",
+            TodoStatus.COMPLETED: "completed",
+        }
+        matched_priority: dict[TodoPriority, PlanEntryPriority] = {
+            TodoPriority.LOW: "low",
+            TodoPriority.MEDIUM: "medium",
+            TodoPriority.HIGH: "high",
+        }
+
+        update = AgentPlanUpdate(
+            session_update="plan",
+            entries=[
+                PlanEntry(
+                    content=todo.content,
+                    status=matched_status[todo.status],
+                    priority=matched_priority[todo.priority],
+                )
+                for todo in todos
+            ],
+        )
+        return update

vibe/acp/tools/builtins/write_file.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from acp.helpers import SessionUpdate
+from acp.schema import (
+    FileEditToolCallContent,
+    ToolCallLocation,
+    ToolCallProgress,
+    ToolCallStart,
+)
+
+from vibe import VIBE_ROOT
+from vibe.acp.tools.base import AcpToolState, BaseAcpTool
+from vibe.core.tools.base import ToolError
+from vibe.core.tools.builtins.write_file import (
+    WriteFile as CoreWriteFileTool,
+    WriteFileArgs,
+    WriteFileResult,
+    WriteFileState,
+)
+from vibe.core.types import ToolCallEvent, ToolResultEvent
+
+
+class AcpWriteFileState(WriteFileState, AcpToolState):
+    pass
+
+
+class WriteFile(CoreWriteFileTool, BaseAcpTool[AcpWriteFileState]):
+    state: AcpWriteFileState
+    prompt_path = (
+        VIBE_ROOT / "core" / "tools" / "builtins" / "prompts" / "write_file.md"
+    )
+
+    @classmethod
+    def _get_tool_state_class(cls) -> type[AcpWriteFileState]:
+        return AcpWriteFileState
+
+    async def _write_file(self, args: WriteFileArgs, file_path: Path) -> None:
+        client, session_id, _ = self._load_state()
+
+        await self._send_in_progress_session_update()
+
+        try:
+            await client.write_text_file(
+                session_id=session_id, path=str(file_path), content=args.content
+            )
+        except Exception as e:
+            raise ToolError(f"Error writing {file_path}: {e}") from e
+
+    @classmethod
+    def tool_call_session_update(cls, event: ToolCallEvent) -> SessionUpdate | None:
+        args = event.args
+        if not isinstance(args, WriteFileArgs):
+            return None
+
+        return ToolCallStart(
+            session_update="tool_call",
+            title=cls.get_call_display(event).summary,
+            tool_call_id=event.tool_call_id,
+            kind="edit",
+            content=[
+                FileEditToolCallContent(
+                    type="diff", path=args.path, old_text=None, new_text=args.content
+                )
+            ],
+            locations=[ToolCallLocation(path=args.path)],
+            raw_input=args.model_dump_json(),
+        )
+
+    @classmethod
+    def tool_result_session_update(cls, event: ToolResultEvent) -> SessionUpdate | None:
+        if event.error:
+            return ToolCallProgress(
+                session_update="tool_call_update",
+                tool_call_id=event.tool_call_id,
+                status="failed",
+            )
+
+        result = event.result
+        if not isinstance(result, WriteFileResult):
+            return None
+
+        return ToolCallProgress(
+            session_update="tool_call_update",
+            tool_call_id=event.tool_call_id,
+            status="completed",
+            content=[
+                FileEditToolCallContent(
+                    type="diff",
+                    path=result.path,
+                    old_text=None,
+                    new_text=result.content,
+                )
+            ],
+            locations=[ToolCallLocation(path=result.path)],
+            raw_output=result.model_dump_json(),
+        )