rpr-cli 0.1.1__py3-none-any.whl

rpr/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

rpr/agent/__init__.py

@@ -0,0 +1,29 @@
+from rpr.agent.approval import ApprovalDecision, ApprovalMode
+from rpr.agent.client import (
+    AgentClient,
+    AgentEvent,
+    ConversationMessage,
+    TextDeltaEvent,
+    ToolCallRequestEvent,
+    TurnCompleteEvent,
+)
+from rpr.agent.control import TurnControl
+from rpr.agent.runtime import AgentRuntime, RuntimeCallbacks
+from rpr.agent.session import ChatSession, ToolCallRecord, ToolCallStatus
+
+__all__ = [
+    "AgentClient",
+    "AgentEvent",
+    "AgentRuntime",
+    "ApprovalDecision",
+    "ApprovalMode",
+    "ChatSession",
+    "ConversationMessage",
+    "RuntimeCallbacks",
+    "TextDeltaEvent",
+    "TurnControl",
+    "ToolCallRecord",
+    "ToolCallRequestEvent",
+    "ToolCallStatus",
+    "TurnCompleteEvent",
+]

rpr/agent/approval.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class ApprovalMode(StrEnum):
+    ASK = "ask"
+    AUTO_READONLY = "auto-readonly"
+    AUTO_ALL = "auto-all"
+
+
+class ApprovalDecision(StrEnum):
+    APPROVE = "approve"
+    REJECT = "reject"
+    ALWAYS_ALLOW = "always-allow"
+
+
+def requires_approval(*, is_mutating: bool, mode: ApprovalMode) -> bool:
+    return is_mutating and mode is not ApprovalMode.AUTO_ALL

rpr/agent/bootstrap.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import typer
+
+from rpr.agent.approval import ApprovalMode
+from rpr.agent.client import AgentClient
+from rpr.agent.mock import MockAgentClient
+from rpr.agent.runtime import AgentRuntime, RuntimeCallbacks
+from rpr.agent.session import ChatSession
+from rpr.agent.tools import build_default_tool_registry
+from rpr.context import RunContext
+
+
+@dataclass(slots=True, frozen=True)
+class ChatRuntimeBundle:
+    ctx: RunContext
+    client: AgentClient
+    session: ChatSession
+    runtime: AgentRuntime
+
+
+def resolve_agent_client(provider: str | None, model: str | None) -> AgentClient:
+    provider_name = (provider or "mock").lower()
+    if provider_name != "mock":
+        raise typer.BadParameter(
+            "Only the mock provider is available right now.", param_hint="provider"
+        )
+
+    return MockAgentClient(model_name=model or "mock-1")
+
+
+def build_chat_runtime_bundle(
+    *,
+    ctx: RunContext,
+    client: AgentClient,
+    approval_mode: ApprovalMode,
+    callbacks: RuntimeCallbacks,
+    session: ChatSession | None = None,
+) -> ChatRuntimeBundle:
+    active_session = session or ChatSession(
+        project_dir=ctx.project_dir, approval_mode=approval_mode
+    )
+    active_session.project_dir = ctx.project_dir
+    active_session.approval_mode = approval_mode
+    runtime = AgentRuntime(
+        client=client,
+        session=active_session,
+        tools=build_default_tool_registry(),
+        ctx=ctx,
+        callbacks=callbacks,
+        system_prompt=f"Project root: {ctx.project_dir}",
+    )
+    return ChatRuntimeBundle(
+        ctx=ctx,
+        client=client,
+        session=active_session,
+        runtime=runtime,
+    )

rpr/agent/client.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+from typing import Literal
+
+from rpr.agent.control import TurnControl
+
+type MessageRole = Literal["system", "user", "assistant", "tool"]
+type ToolArguments = dict[str, object]
+
+
+@dataclass(slots=True, frozen=True)
+class TextPart:
+    text: str
+
+
+@dataclass(slots=True, frozen=True)
+class FilePart:
+    path: str
+    mime_type: str
+    data: bytes
+
+    @property
+    def is_text(self) -> bool:
+        return self.mime_type.startswith("text/") or self.mime_type in {
+            "application/json",
+            "application/xml",
+            "application/yaml",
+            "application/x-yaml",
+            "application/javascript",
+        }
+
+    def decoded_text(self) -> str | None:
+        if not self.is_text:
+            return None
+        return self.data.decode("utf-8", errors="replace")
+
+
+type MessagePart = TextPart | FilePart
+type MessageParts = tuple[MessagePart, ...]
+type MessageContent = str | MessageParts
+
+
+@dataclass(slots=True, frozen=True)
+class ConversationMessage:
+    role: MessageRole
+    content: MessageContent
+    name: str | None = None
+
+    @property
+    def parts(self) -> MessageParts:
+        if isinstance(self.content, str):
+            return (TextPart(self.content),)
+        return self.content
+
+    @property
+    def text_content(self) -> str:
+        if isinstance(self.content, str):
+            return self.content
+        return "".join(part.text for part in self.content if isinstance(part, TextPart))
+
+    @property
+    def file_parts(self) -> tuple[FilePart, ...]:
+        if isinstance(self.content, str):
+            return ()
+        return tuple(part for part in self.content if isinstance(part, FilePart))
+
+
+@dataclass(slots=True, frozen=True)
+class TextDeltaEvent:
+    text: str
+
+
+@dataclass(slots=True, frozen=True)
+class ToolCallRequestEvent:
+    call_id: str
+    tool_name: str
+    arguments: ToolArguments
+
+
+@dataclass(slots=True, frozen=True)
+class TurnCompleteEvent:
+    pass
+
+
+type AgentEvent = TextDeltaEvent | ToolCallRequestEvent | TurnCompleteEvent
+
+
+class AgentClient(ABC):
+    """Abstract base class for AI agent clients."""
+
+    @property
+    @abstractmethod
+    def provider_name(self) -> str:
+        """Return the name of the provider."""
+        ...
+
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        """Return the active model name."""
+        ...
+
+    @abstractmethod
+    async def stream(
+        self,
+        history: list[ConversationMessage],
+        *,
+        system_prompt: str | None = None,
+        control: TurnControl | None = None,
+    ) -> AsyncGenerator[AgentEvent, None]:
+        """Stream provider-agnostic events for the current turn."""
+        ...

rpr/agent/control.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from threading import Event
+
+
+@dataclass(slots=True)
+class TurnControl:
+    _cancel_requested: Event = field(default_factory=Event)
+
+    def cancel(self) -> None:
+        self._cancel_requested.set()
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._cancel_requested.is_set()

rpr/agent/mock.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import asyncio
+import re
+from collections.abc import AsyncGenerator, Iterator
+from typing import override
+
+from rpr.agent.client import (
+    AgentClient,
+    ConversationMessage,
+    FilePart,
+    TextDeltaEvent,
+    ToolArguments,
+    ToolCallRequestEvent,
+    TurnCompleteEvent,
+)
+from rpr.agent.control import TurnControl
+
+
+class MockAgentClient(AgentClient):
+    """A mock agent client for testing and default behavior."""
+
+    def __init__(self, *, model_name: str = "mock-1") -> None:
+        self._model_name = model_name
+
+    @property
+    @override
+    def provider_name(self) -> str:
+        return "mock"
+
+    @property
+    @override
+    def model_name(self) -> str:
+        return self._model_name
+
+    @override
+    async def stream(
+        self,
+        history: list[ConversationMessage],
+        *,
+        system_prompt: str | None = None,
+        control: TurnControl | None = None,
+    ) -> AsyncGenerator[
+        TextDeltaEvent | ToolCallRequestEvent | TurnCompleteEvent, None
+    ]:
+        del system_prompt
+        last_message = history[-1]
+        if last_message.role == "tool":
+            async for event in self._stream_text(
+                f"I used `{last_message.name}` and summarized the result below.\n\n{last_message.text_content}",
+                control=control,
+            ):
+                yield event
+            if control is None or not control.is_cancelled:
+                yield TurnCompleteEvent()
+            return
+
+        if last_message.role != "user":
+            async for event in self._stream_text(
+                "I am ready for the next prompt.", control=control
+            ):
+                yield event
+            if control is None or not control.is_cancelled:
+                yield TurnCompleteEvent()
+            return
+
+        tool_request = self._parse_tool_request(last_message.text_content)
+        if tool_request is not None:
+            async for event in self._stream_text(
+                "I’m going to inspect the repository before answering.\n\n",
+                control=control,
+            ):
+                yield event
+            if control is None or not control.is_cancelled:
+                yield ToolCallRequestEvent(
+                    call_id=f"mock-{len(history)}",
+                    tool_name=tool_request[0],
+                    arguments=tool_request[1],
+                )
+            return
+
+        response_text = self._render_response_text(last_message)
+        async for event in self._stream_text(response_text, control=control):
+            yield event
+        if control is None or not control.is_cancelled:
+            yield TurnCompleteEvent()
+
+    async def _stream_text(
+        self,
+        text: str,
+        *,
+        control: TurnControl | None = None,
+    ) -> AsyncGenerator[TextDeltaEvent, None]:
+        for chunk in self._iter_chunks(text):
+            if control is not None and control.is_cancelled:
+                return
+            await asyncio.sleep(0.1)
+            yield TextDeltaEvent(text=chunk)
+
+    @staticmethod
+    def _iter_chunks(text: str) -> Iterator[str]:
+        for match in re.finditer(r"\n+|[^\s\n]+\s*", text):
+            yield match.group(0)
+
+    def _parse_tool_request(self, message: str) -> tuple[str, ToolArguments] | None:
+        read_match = re.search(
+            r"(?:read|show) file (?P<path>\S+)", message, re.IGNORECASE
+        )
+        if read_match:
+            return "read_file", {"path": read_match.group("path")}
+
+        list_match = re.search(
+            r"(?:list|show) (?:directory|files)(?: (?P<path>\S+))?",
+            message,
+            re.IGNORECASE,
+        )
+        if list_match:
+            return "list_directory", {"path": list_match.group("path") or "."}
+
+        search_match = re.search(
+            r"search(?: for)? (?P<query>.+)", message, re.IGNORECASE
+        )
+        if search_match:
+            return "search_text", {"query": search_match.group("query").strip()}
+
+        write_match = re.search(
+            r"write file (?P<path>\S+)\s*:(?P<content>.+)",
+            message,
+            re.IGNORECASE | re.DOTALL,
+        )
+        if write_match:
+            return "write_file", {
+                "path": write_match.group("path"),
+                "content": write_match.group("content").lstrip(),
+            }
+
+        return None
+
+    def _render_response_text(self, message: ConversationMessage) -> str:
+        response_text = (
+            f"I received your message: '{message.text_content}'.\n\n"
+            f"This is a mock response from the **Mock Provider** using `{self.model_name}`."
+        )
+        if not message.file_parts:
+            return response_text
+
+        attachment_lines = [
+            self._format_attachment(part) for part in message.file_parts
+        ]
+        return f"{response_text}\n\nAttachments:\n" + "\n".join(attachment_lines)
+
+    @staticmethod
+    def _format_attachment(part: FilePart) -> str:
+        if part.is_text:
+            preview = (part.decoded_text() or "").splitlines()
+            if preview:
+                return f"- {part.path} ({part.mime_type}, {len(part.data)} bytes): {preview[0][:80]}"
+        return f"- {part.path} ({part.mime_type}, {len(part.data)} bytes)"

rpr/agent/runtime.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import mimetypes
+import re
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from rpr.agent.approval import ApprovalDecision, requires_approval
+from rpr.agent.client import (
+    AgentClient,
+    ConversationMessage,
+    FilePart,
+    MessageContent,
+    TextDeltaEvent,
+    TextPart,
+    ToolCallRequestEvent,
+    TurnCompleteEvent,
+)
+from rpr.agent.control import TurnControl
+from rpr.agent.session import ChatSession, ToolCallRecord, ToolCallStatus
+from rpr.agent.tools import ToolRegistry
+from rpr.agent.tools.base import ToolResult, resolve_project_path
+from rpr.context import RunContext
+
+
+MAX_ATTACHMENT_BYTES = 64_000
+FILE_REFERENCE_PATTERN = re.compile(r"(?<!\S)@(?P<path>[A-Za-z0-9_./-]+/?)(?=\s|$)")
+
+
+@dataclass(slots=True)
+class RuntimeCallbacks:
+    on_text_delta: Callable[[str], None]
+    on_tool_call: Callable[[ToolCallRecord], None]
+    on_tool_result: Callable[[ToolCallRecord, ToolResult], None]
+    request_approval: Callable[
+        [ToolCallRecord], ApprovalDecision | Awaitable[ApprovalDecision]
+    ]
+    on_attachment_notice: Callable[[str], None] = lambda _message: None
+
+
+class AgentRuntime:
+    def __init__(
+        self,
+        *,
+        client: AgentClient,
+        session: ChatSession,
+        tools: ToolRegistry,
+        ctx: RunContext,
+        callbacks: RuntimeCallbacks,
+        system_prompt: str | None = None,
+    ) -> None:
+        self._client = client
+        self._session = session
+        self._tools = tools
+        self._ctx = ctx
+        self._callbacks = callbacks
+        self._system_prompt = system_prompt
+
+    async def execute_turn(
+        self, user_input: str, *, control: TurnControl | None = None
+    ) -> None:
+        turn_user_message = self._create_turn_user_message(user_input)
+        self._session.add_user_message(user_input)
+        history = [*self._session.messages[:-1], turn_user_message]
+
+        while True:
+            if self._is_cancelled(control):
+                return
+
+            assistant_content = ""
+            requested_tool = False
+            stream = self._client.stream(
+                history,
+                system_prompt=self._system_prompt,
+                control=control,
+            )
+            async for event in stream:
+                if self._is_cancelled(control):
+                    break
+
+                if isinstance(event, TextDeltaEvent):
+                    assistant_content += event.text
+                    self._callbacks.on_text_delta(event.text)
+                    continue
+
+                if isinstance(event, ToolCallRequestEvent):
+                    if assistant_content:
+                        self._session.add_assistant_message(assistant_content)
+                        history.append(self._session.messages[-1])
+                        assistant_content = ""
+
+                    requested_tool = True
+                    message_count = len(self._session.messages)
+                    await self._handle_tool_call(event, control=control)
+                    history.extend(self._session.messages[message_count:])
+                    break
+
+                if isinstance(event, TurnCompleteEvent):
+                    break
+
+            if assistant_content:
+                self._session.add_assistant_message(assistant_content)
+                history.append(self._session.messages[-1])
+
+            if self._is_cancelled(control) or not requested_tool:
+                return
+
+    async def _handle_tool_call(
+        self, event: ToolCallRequestEvent, *, control: TurnControl | None = None
+    ) -> None:
+        if self._is_cancelled(control):
+            return
+
+        tool = self._tools.get(event.tool_name)
+        is_mutating = False if tool is None else tool.spec.is_mutating
+        record = self._session.create_tool_call(
+            call_id=event.call_id,
+            tool_name=event.tool_name,
+            arguments=event.arguments,
+            is_mutating=is_mutating,
+        )
+        self._callbacks.on_tool_call(record)
+
+        if tool is None:
+            result = ToolResult(
+                tool_name=event.tool_name,
+                success=False,
+                output=f"Unknown tool: {event.tool_name}",
+            )
+            record.status = ToolCallStatus.FAILED
+            record.error = result.output
+            self._session.add_tool_message(event.tool_name, result.as_message_content())
+            self._callbacks.on_tool_result(record, result)
+            return
+
+        if requires_approval(
+            is_mutating=tool.spec.is_mutating, mode=self._session.approval_mode
+        ):
+            if self._is_cancelled(control):
+                return
+
+            decision = self._callbacks.request_approval(record)
+            if inspect.isawaitable(decision):
+                decision = await decision
+            if self._is_cancelled(control):
+                result = ToolResult(
+                    tool_name=tool.spec.name,
+                    success=False,
+                    output="Tool execution cancelled.",
+                    cancelled=True,
+                )
+                record.status = ToolCallStatus.CANCELLED
+                record.error = result.output
+                self._session.add_tool_message(
+                    tool.spec.name, result.as_message_content()
+                )
+                self._callbacks.on_tool_result(record, result)
+                return
+            if decision is ApprovalDecision.ALWAYS_ALLOW:
+                self._session.enable_auto_all()
+            if decision is ApprovalDecision.REJECT:
+                result = ToolResult(
+                    tool_name=tool.spec.name,
+                    success=False,
+                    output="Tool execution was rejected by the user.",
+                )
+                record.status = ToolCallStatus.REJECTED
+                record.error = result.output
+                self._session.add_tool_message(
+                    tool.spec.name, result.as_message_content()
+                )
+                self._callbacks.on_tool_result(record, result)
+                return
+
+            record.status = ToolCallStatus.APPROVED
+
+        if self._is_cancelled(control):
+            result = ToolResult(
+                tool_name=tool.spec.name,
+                success=False,
+                output="Tool execution cancelled.",
+                cancelled=True,
+            )
+            record.status = ToolCallStatus.CANCELLED
+            record.error = result.output
+            self._session.add_tool_message(tool.spec.name, result.as_message_content())
+            self._callbacks.on_tool_result(record, result)
+            return
+
+        try:
+            result = await asyncio.to_thread(
+                tool.execute, event.arguments, self._ctx, control=control
+            )
+        except Exception as exc:
+            result = ToolResult(
+                tool_name=event.tool_name, success=False, output=str(exc)
+            )
+
+        if result.cancelled:
+            record.status = ToolCallStatus.CANCELLED
+        else:
+            record.status = (
+                ToolCallStatus.COMPLETED if result.success else ToolCallStatus.FAILED
+            )
+        if result.success:
+            record.output = result.output
+        else:
+            record.error = result.output
+        self._session.add_tool_message(event.tool_name, result.as_message_content())
+        self._callbacks.on_tool_result(record, result)
+
+    @staticmethod
+    def _is_cancelled(control: TurnControl | None) -> bool:
+        return False if control is None else control.is_cancelled
+
+    def _create_turn_user_message(self, user_input: str) -> ConversationMessage:
+        content = self._build_user_message(user_input)
+        return ConversationMessage(role="user", content=content)
+
+    def _build_user_message(self, user_input: str) -> MessageContent:
+        attachments: list[FilePart] = []
+        seen_paths: set[str] = set()
+
+        for raw_path in self._extract_paths(user_input):
+            try:
+                resolved = resolve_project_path(self._ctx.project_dir, raw_path)
+            except ValueError:
+                self._callbacks.on_attachment_notice(
+                    f"Ignored @{raw_path}: path must stay within the project root."
+                )
+                continue
+
+            if resolved.is_dir():
+                self._callbacks.on_attachment_notice(
+                    f"Ignored @{raw_path}: directories cannot be attached."
+                )
+                continue
+
+            if not resolved.is_file():
+                self._callbacks.on_attachment_notice(
+                    f"Ignored @{raw_path}: file not found."
+                )
+                continue
+
+            relative_path = resolved.relative_to(self._ctx.project_dir).as_posix()
+            if relative_path in seen_paths:
+                continue
+            seen_paths.add(relative_path)
+
+            attachment = self._build_file_part(resolved, relative_path)
+            if attachment is None:
+                continue
+            attachments.append(attachment)
+
+        if not attachments:
+            return user_input
+
+        return (TextPart(user_input), *attachments)
+
+    def _build_file_part(self, resolved: Path, relative_path: str) -> FilePart | None:
+        try:
+            data = resolved.read_bytes()
+        except OSError as exc:
+            self._callbacks.on_attachment_notice(f"Ignored @{relative_path}: {exc}.")
+            return None
+
+        truncated = False
+        if len(data) > MAX_ATTACHMENT_BYTES:
+            data = data[:MAX_ATTACHMENT_BYTES]
+            truncated = True
+
+        mime_type = (
+            mimetypes.guess_type(resolved.as_posix(), strict=False)[0]
+            or "application/octet-stream"
+        )
+        suffix = (
+            f" ({len(data)} bytes attached, truncated)"
+            if truncated
+            else f" ({len(data)} bytes attached)"
+        )
+        self._callbacks.on_attachment_notice(f"Attached @{relative_path}{suffix}.")
+        return FilePart(path=relative_path, mime_type=mime_type, data=data)
+
+    @staticmethod
+    def _extract_paths(user_input: str) -> tuple[str, ...]:
+        return tuple(
+            match.group("path") for match in FILE_REFERENCE_PATTERN.finditer(user_input)
+        )