rpr-cli 0.1.1__py3-none-any.whl

rpr/agent/session.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from enum import StrEnum
+from pathlib import Path
+from uuid import uuid4
+
+from rpr.agent.approval import ApprovalMode
+from rpr.agent.client import ConversationMessage, MessageContent, ToolArguments
+
+
+class ToolCallStatus(StrEnum):
+    PENDING = "pending"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass(slots=True)
+class ToolCallRecord:
+    call_id: str
+    tool_name: str
+    arguments: ToolArguments
+    is_mutating: bool
+    status: ToolCallStatus = ToolCallStatus.PENDING
+    output: str | None = None
+    error: str | None = None
+
+
+@dataclass(slots=True)
+class ChatSession:
+    project_dir: Path
+    approval_mode: ApprovalMode = ApprovalMode.ASK
+    session_id: str = field(default_factory=lambda: uuid4().hex)
+    title: str = "New chat"
+    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+    messages: list[ConversationMessage] = field(default_factory=list)
+    tool_calls: list[ToolCallRecord] = field(default_factory=list)
+
+    def add_user_message(self, content: MessageContent) -> None:
+        stripped = self._message_title_text(content).strip()
+        if stripped and self.title == "New chat":
+            self.title = stripped.splitlines()[0][:60]
+        self.touch()
+        self.messages.append(ConversationMessage(role="user", content=content))
+
+    def add_assistant_message(self, content: str) -> None:
+        if content:
+            self.touch()
+            self.messages.append(ConversationMessage(role="assistant", content=content))
+
+    def add_tool_message(self, tool_name: str, content: str) -> None:
+        self.touch()
+        self.messages.append(
+            ConversationMessage(role="tool", content=content, name=tool_name)
+        )
+
+    def create_tool_call(
+        self,
+        *,
+        call_id: str,
+        tool_name: str,
+        arguments: ToolArguments,
+        is_mutating: bool,
+    ) -> ToolCallRecord:
+        record = ToolCallRecord(
+            call_id=call_id,
+            tool_name=tool_name,
+            arguments=arguments,
+            is_mutating=is_mutating,
+        )
+        self.tool_calls.append(record)
+        self.touch()
+        return record
+
+    def enable_auto_all(self) -> None:
+        self.approval_mode = ApprovalMode.AUTO_ALL
+        self.touch()
+
+    def touch(self) -> None:
+        self.updated_at = datetime.now(UTC)
+
+    @staticmethod
+    def _message_title_text(content: MessageContent) -> str:
+        if isinstance(content, str):
+            return content
+        return "".join(part.text for part in content if hasattr(part, "text"))

rpr/agent/tools/__init__.py

@@ -0,0 +1,10 @@
+from rpr.agent.tools.base import AgentTool, ToolResult, ToolSpec
+from rpr.agent.tools.registry import ToolRegistry, build_default_tool_registry
+
+__all__ = [
+    "AgentTool",
+    "ToolRegistry",
+    "ToolResult",
+    "ToolSpec",
+    "build_default_tool_registry",
+]

rpr/agent/tools/base.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+
+from rpr.agent.client import ToolArguments
+from rpr.agent.control import TurnControl
+from rpr.context import RunContext
+
+
+@dataclass(slots=True, frozen=True)
+class ToolSpec:
+    name: str
+    description: str
+    is_mutating: bool = False
+
+
+@dataclass(slots=True, frozen=True)
+class ToolResult:
+    tool_name: str
+    success: bool
+    output: str
+    cancelled: bool = False
+
+    def as_message_content(self) -> str:
+        if self.cancelled:
+            status = "cancelled"
+        else:
+            status = "succeeded" if self.success else "failed"
+        return f"Tool {self.tool_name} {status}.\n\n{self.output}".strip()
+
+
+class AgentTool(ABC):
+    @property
+    @abstractmethod
+    def spec(self) -> ToolSpec: ...
+
+    @abstractmethod
+    def execute(
+        self,
+        arguments: ToolArguments,
+        ctx: RunContext,
+        *,
+        control: TurnControl | None = None,
+    ) -> ToolResult: ...
+
+
+def resolve_project_path(project_dir: Path, raw_path: object) -> Path:
+    if not isinstance(raw_path, str) or not raw_path.strip():
+        raise ValueError("Tool argument 'path' must be a non-empty string.")
+
+    candidate = Path(raw_path)
+    resolved = (
+        candidate.resolve()
+        if candidate.is_absolute()
+        else (project_dir / candidate).resolve()
+    )
+    project_root = project_dir.resolve()
+    if not resolved.is_relative_to(project_root):
+        raise ValueError(f"Path must stay within the project root: {project_root}")
+    return resolved

rpr/agent/tools/mutating.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from rpr.agent.client import ToolArguments
+from rpr.agent.control import TurnControl
+from rpr.agent.tools.base import AgentTool, ToolResult, ToolSpec, resolve_project_path
+from rpr.context import RunContext
+
+
+class WriteFileTool(AgentTool):
+    @property
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="write_file",
+            description="Create or update a file in the repository.",
+            is_mutating=True,
+        )
+
+    def execute(
+        self,
+        arguments: ToolArguments,
+        ctx: RunContext,
+        *,
+        control: TurnControl | None = None,
+    ) -> ToolResult:
+        if control is not None and control.is_cancelled:
+            return ToolResult(
+                tool_name=self.spec.name,
+                success=False,
+                output="Tool execution cancelled.",
+                cancelled=True,
+            )
+        path = resolve_project_path(ctx.project_dir, arguments.get("path"))
+        content = arguments.get("content")
+        if not isinstance(content, str):
+            raise ValueError("Tool argument 'content' must be a string.")
+
+        if path.exists():
+            ctx.update_file(path, content)
+        else:
+            ctx.write_file(path, content)
+
+        relative_path = path.relative_to(ctx.project_dir)
+        return ToolResult(
+            tool_name=self.spec.name,
+            success=True,
+            output=f"Wrote {relative_path}",
+        )

rpr/agent/tools/readonly.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from rpr.agent.client import ToolArguments
+from rpr.agent.control import TurnControl
+from rpr.agent.tools.base import AgentTool, ToolResult, ToolSpec, resolve_project_path
+from rpr.context import RunContext
+from rpr.map.walker import _IGNORED_DIRS
+
+
+class ReadFileTool(AgentTool):
+    @property
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="read_file", description="Read a file from the repository."
+        )
+
+    def execute(
+        self,
+        arguments: ToolArguments,
+        ctx: RunContext,
+        *,
+        control: TurnControl | None = None,
+    ) -> ToolResult:
+        if control is not None and control.is_cancelled:
+            return ToolResult(
+                tool_name=self.spec.name,
+                success=False,
+                output="Tool execution cancelled.",
+                cancelled=True,
+            )
+        path = resolve_project_path(ctx.project_dir, arguments.get("path"))
+        start_line = int(arguments.get("start_line", 1))
+        end_line = arguments.get("end_line")
+        content = path.read_text()
+        lines = content.splitlines()
+        if end_line is None:
+            end_line = len(lines)
+        end_line = int(end_line)
+        selected = lines[max(start_line - 1, 0) : max(end_line, 0)]
+        output = "\n".join(
+            f"{index}: {line}" for index, line in enumerate(selected, start=start_line)
+        )
+        return ToolResult(
+            tool_name=self.spec.name,
+            success=True,
+            output=output or "(file is empty)",
+        )
+
+
+class ListDirectoryTool(AgentTool):
+    @property
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="list_directory", description="List files under a directory."
+        )
+
+    def execute(
+        self,
+        arguments: ToolArguments,
+        ctx: RunContext,
+        *,
+        control: TurnControl | None = None,
+    ) -> ToolResult:
+        if control is not None and control.is_cancelled:
+            return ToolResult(
+                tool_name=self.spec.name,
+                success=False,
+                output="Tool execution cancelled.",
+                cancelled=True,
+            )
+        path = resolve_project_path(ctx.project_dir, arguments.get("path", "."))
+        entries = sorted(
+            path.iterdir(), key=lambda entry: (not entry.is_dir(), entry.name.lower())
+        )
+        output = "\n".join(
+            f"{entry.name}/" if entry.is_dir() else entry.name for entry in entries
+        )
+        return ToolResult(
+            tool_name=self.spec.name,
+            success=True,
+            output=output or "(directory is empty)",
+        )
+
+
+class SearchTextTool(AgentTool):
+    @property
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="search_text", description="Search repository text for a query."
+        )
+
+    def execute(
+        self,
+        arguments: ToolArguments,
+        ctx: RunContext,
+        *,
+        control: TurnControl | None = None,
+    ) -> ToolResult:
+        query = arguments.get("query")
+        if not isinstance(query, str) or not query.strip():
+            raise ValueError("Tool argument 'query' must be a non-empty string.")
+
+        max_results = int(arguments.get("max_results", 20))
+        normalized_query = query.casefold()
+        matches: list[str] = []
+        for current_root, dir_names, file_names in ctx.project_dir.walk():
+            if control is not None and control.is_cancelled:
+                return ToolResult(
+                    tool_name=self.spec.name,
+                    success=False,
+                    output="Tool execution cancelled.",
+                    cancelled=True,
+                )
+            dir_names[:] = [name for name in dir_names if name not in _IGNORED_DIRS]
+            for file_name in sorted(file_names):
+                if control is not None and control.is_cancelled:
+                    return ToolResult(
+                        tool_name=self.spec.name,
+                        success=False,
+                        output="Tool execution cancelled.",
+                        cancelled=True,
+                    )
+                path = current_root / file_name
+                try:
+                    content = path.read_text()
+                except OSError, UnicodeDecodeError:
+                    continue
+
+                for line_number, line in enumerate(content.splitlines(), start=1):
+                    if control is not None and control.is_cancelled:
+                        return ToolResult(
+                            tool_name=self.spec.name,
+                            success=False,
+                            output="Tool execution cancelled.",
+                            cancelled=True,
+                        )
+                    if normalized_query in line.casefold():
+                        relative_path = path.relative_to(ctx.project_dir)
+                        matches.append(f"{relative_path}:{line_number}: {line.strip()}")
+                        if len(matches) >= max_results:
+                            output = "\n".join(matches)
+                            return ToolResult(
+                                tool_name=self.spec.name, success=True, output=output
+                            )
+
+        output = "\n".join(matches) if matches else f"No matches found for: {query}"
+        return ToolResult(tool_name=self.spec.name, success=True, output=output)

rpr/agent/tools/registry.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from rpr.agent.tools.base import AgentTool
+from rpr.agent.tools.mutating import WriteFileTool
+from rpr.agent.tools.readonly import ListDirectoryTool, ReadFileTool, SearchTextTool
+
+
+@dataclass(slots=True)
+class ToolRegistry:
+    tools: dict[str, AgentTool] = field(default_factory=dict)
+
+    def register(self, tool: AgentTool) -> None:
+        self.tools[tool.spec.name] = tool
+
+    def get(self, name: str) -> AgentTool | None:
+        return self.tools.get(name)
+
+
+def build_default_tool_registry() -> ToolRegistry:
+    registry = ToolRegistry()
+    for tool in (
+        ReadFileTool(),
+        ListDirectoryTool(),
+        SearchTextTool(),
+        WriteFileTool(),
+    ):
+        registry.register(tool)
+    return registry

rpr/application/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations