rpr-cli 0.3.7__cp314-abi3-win_amd64.whl

rpr/__init__.py

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

rpr/_native.pyi

@@ -0,0 +1,32 @@
+from typing import Literal, TypedDict
+
+
+Language = Literal["python", "typescript", "javascript", "rust", "cpp"]
+
+
+class DependencyNode(TypedDict):
+    abs_path: str
+    rel_path: str
+    language: Language
+
+
+class DependencyGraphPayload(TypedDict):
+    nodes: list[DependencyNode]
+    edges: dict[str, list[str]]
+    reverse_edges: dict[str, list[str]]
+    cycles: list[list[str]]
+
+
+class RenamePlan:
+    @property
+    def backend(self) -> Literal["rust"]: ...
+    def summary(self) -> dict[str, object]: ...
+
+
+def init_env() -> None: ...
+def close_env() -> None: ...
+def reset_logging() -> None: ...
+def build_dependency_graph(abs_root: str) -> DependencyGraphPayload: ...
+def ensure_rename_ignore(abs_root: str) -> bool: ...
+def plan_project_rename(abs_root: str, new_name: str) -> RenamePlan: ...
+def apply_project_rename(plan: RenamePlan) -> None: ...

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)"