rlmy 0.1.0__tar.gz

rlmy-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: rlmy
+Version: 0.1.0
+Summary: An interactive RLM (Recursive Language Model) agent built on DSPy
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: dspy>=3.2.1
+Requires-Dist: boto3>=1.42.0
+Requires-Dist: nest-asyncio>=1.6.0
+Requires-Dist: mcp>=1.26.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: markitdown>=0.1.5
+Requires-Dist: prompt-toolkit>=3.0.50
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: strands-agents-tools>=0.4.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# rlmy
+
+An interactive RLM (Recursive Language Model) agent built on DSPy.
+
+## What is this?
+
+- An AI coding agent that runs in your terminal
+- Uses DSPy's RLM framework — the LLM writes and executes Python code iteratively
+- Connects to MCP servers (Slack, internal tools, etc.) as additional tools
+- Maintains conversation state across turns (trajectory persistence)
+- Supports cooperative interrupt (Ctrl+C pauses gracefully)
+
+## Key Features
+
+- **Iterative REPL**: LLM writes code, sees output, writes more code — until it solves the problem
+- **MCP Integration**: Connect any MCP-compatible tool server
+- **Filesystem Tools**: Read, write, edit files with safety guards (read-before-write)
+- **Shell Access**: Run shell commands with deny-list safety and approval system
+- **Trajectory Persistence**: Resume sessions where you left off
+- **Conversation Continuity**: Prior context injected into new turns
+- **Configurable Models**: Use any DSPy-compatible LM (Anthropic, Bedrock, OpenAI, Groq, Ollama)
+
+## Prerequisites
+
+- Valid LLM credentials (Anthropic API key, AWS profile for Bedrock, etc.)
+- Python 3.12+ and Deno are installed automatically by the setup script
+
+## Installation
+
+Recommended (installs Deno + uv + rlmy in one command):
+
+    curl -LsSf https://raw.githubusercontent.com/diego-lima/rlmy/main/setup_install.sh | bash
+
+Alternative (if you already have Deno and uv):
+
+    uv tool install rlmy
+
+## Quick Start
+
+    rlmy
+
+- First run asks which AI model to use (model selection wizard)
+- Workspaces are created in `~/.config/rlmy/sandboxes/`
+- Ctrl+C pauses gracefully (doesn't lose work)
+
+To skip the wizard (headless/CI):
+
+    export RLM_MAIN_MODEL='bedrock/us.anthropic.claude-sonnet-4-6'
+    export RLM_SUB_MODEL='bedrock/us.anthropic.claude-sonnet-4-6'
+    rlmy
+
+## Try It Out
+
+If your credentials are set, run `rlmy` and type:
+
+> *"curl https://calmcode.io/static/data/pokemon.json and teach me something surprising about it."*
+
+Watch it fetch the data, explore it with code, and teach you something you didn't know. This is the RLM loop in action: it'll iterate until it has a neat insight.
+
+## Configuration
+
+- Priority: env vars > config file > wizard
+- Config file: `~/.config/rlmy/config.toml`
+- Supported model formats: any DSPy model string (e.g., `bedrock/us.anthropic.claude-sonnet-4-6`, `bedrock/us.anthropic.claude-opus-4-6-v1`)
+
+## MCP Tools (optional)
+
+- Config location: `~/.config/rlmy/mcp_servers.json`
+- The setup script creates an empty template
+- Edit it to connect Slack, internal tools, or any MCP-compatible server
+- Agent starts without MCP if config is empty (no crash)
+
+## CLI Options
+
+- `--sandbox-root PATH`: Override sandbox directory (default: `~/.config/rlmy/sandboxes/`)
+- `--cache-path PATH`: Override workspace cache file
+
+## Architecture
+
+- Built on DSPy's experimental RLM module
+- InterruptableRLM: cooperative SIGINT + trajectory injection
+- Sandboxed code execution via Deno + Pyodide (WASM)
+- Tools are plain Python functions registered with DSPy
+
+## License
+
+MIT
+
+## Status
+
+- Early release — works well for the author, may have rough edges
+- Feedback welcome via GitHub issues

rlmy-0.1.0/README.md

@@ -0,0 +1,92 @@
+# rlmy
+
+An interactive RLM (Recursive Language Model) agent built on DSPy.
+
+## What is this?
+
+- An AI coding agent that runs in your terminal
+- Uses DSPy's RLM framework — the LLM writes and executes Python code iteratively
+- Connects to MCP servers (Slack, internal tools, etc.) as additional tools
+- Maintains conversation state across turns (trajectory persistence)
+- Supports cooperative interrupt (Ctrl+C pauses gracefully)
+
+## Key Features
+
+- **Iterative REPL**: LLM writes code, sees output, writes more code — until it solves the problem
+- **MCP Integration**: Connect any MCP-compatible tool server
+- **Filesystem Tools**: Read, write, edit files with safety guards (read-before-write)
+- **Shell Access**: Run shell commands with deny-list safety and approval system
+- **Trajectory Persistence**: Resume sessions where you left off
+- **Conversation Continuity**: Prior context injected into new turns
+- **Configurable Models**: Use any DSPy-compatible LM (Anthropic, Bedrock, OpenAI, Groq, Ollama)
+
+## Prerequisites
+
+- Valid LLM credentials (Anthropic API key, AWS profile for Bedrock, etc.)
+- Python 3.12+ and Deno are installed automatically by the setup script
+
+## Installation
+
+Recommended (installs Deno + uv + rlmy in one command):
+
+    curl -LsSf https://raw.githubusercontent.com/diego-lima/rlmy/main/setup_install.sh | bash
+
+Alternative (if you already have Deno and uv):
+
+    uv tool install rlmy
+
+## Quick Start
+
+    rlmy
+
+- First run asks which AI model to use (model selection wizard)
+- Workspaces are created in `~/.config/rlmy/sandboxes/`
+- Ctrl+C pauses gracefully (doesn't lose work)
+
+To skip the wizard (headless/CI):
+
+    export RLM_MAIN_MODEL='bedrock/us.anthropic.claude-sonnet-4-6'
+    export RLM_SUB_MODEL='bedrock/us.anthropic.claude-sonnet-4-6'
+    rlmy
+
+## Try It Out
+
+If your credentials are set, run `rlmy` and type:
+
+> *"curl https://calmcode.io/static/data/pokemon.json and teach me something surprising about it."*
+
+Watch it fetch the data, explore it with code, and teach you something you didn't know. This is the RLM loop in action: it'll iterate until it has a neat insight.
+
+## Configuration
+
+- Priority: env vars > config file > wizard
+- Config file: `~/.config/rlmy/config.toml`
+- Supported model formats: any DSPy model string (e.g., `bedrock/us.anthropic.claude-sonnet-4-6`, `bedrock/us.anthropic.claude-opus-4-6-v1`)
+
+## MCP Tools (optional)
+
+- Config location: `~/.config/rlmy/mcp_servers.json`
+- The setup script creates an empty template
+- Edit it to connect Slack, internal tools, or any MCP-compatible server
+- Agent starts without MCP if config is empty (no crash)
+
+## CLI Options
+
+- `--sandbox-root PATH`: Override sandbox directory (default: `~/.config/rlmy/sandboxes/`)
+- `--cache-path PATH`: Override workspace cache file
+
+## Architecture
+
+- Built on DSPy's experimental RLM module
+- InterruptableRLM: cooperative SIGINT + trajectory injection
+- Sandboxed code execution via Deno + Pyodide (WASM)
+- Tools are plain Python functions registered with DSPy
+
+## License
+
+MIT
+
+## Status
+
+- Early release — works well for the author, may have rough edges
+- Feedback welcome via GitHub issues

rlmy-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "rlmy"
+version = "0.1.0"
+description = "An interactive RLM (Recursive Language Model) agent built on DSPy"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.11"
+dependencies = [
+    "dspy>=3.2.1",
+    "boto3>=1.42.0",
+    "nest-asyncio>=1.6.0",
+    "mcp>=1.26.0",
+    "rich>=14.0.0",
+    "markitdown>=0.1.5",
+    "prompt-toolkit>=3.0.50",
+    "pydantic>=2.12.0",
+    "platformdirs>=4.0.0",
+    "strands-agents-tools>=0.4.1",
+]
+
+[project.scripts]
+rlmy = "rlmy.cli:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov",
+    "ruff",
+]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+addopts = "-v"
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+

rlmy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rlmy-0.1.0/src/rlmy/__init__.py

@@ -0,0 +1,8 @@
+"""
+RLMY - Interactive RLM agent built on DSPy.
+
+A pip-installable RLM agent with workspace management, trajectory persistence,
+and cooperative interrupt handling.
+"""
+
+__version__ = "0.1.0"

rlmy-0.1.0/src/rlmy/agent/__init__.py

@@ -0,0 +1,14 @@
+"""
+RLMY Agent — core agent logic, trajectory, and workspace management.
+
+Key exports:
+    InterruptableRLM — interrupt-safe RLM subclass with prior trajectory injection
+    RLMContext — mutable context passed to contextual tools
+"""
+
+# NOTE: Heavy imports (InterruptableRLM, etc.) are deferred to avoid loading
+# the entire agent stack on `import rlmy`. Import directly from submodules:
+#   from rlmy.agent.rlm import InterruptableRLM, RLMContext
+#   from rlmy.agent.trajectory import save_trajectory, load_trajectory
+#   from rlmy.agent.sandbox import SandboxManager
+

rlmy-0.1.0/src/rlmy/agent/commands.py

@@ -0,0 +1,155 @@
+"""
+Purpose: Slash command registry — decoupled matching, dispatch signaling, help display.
+Usage:
+    from rlmy.agent.commands import REGISTRY, SlashCommandSignal
+    cmd = REGISTRY.match(user_text)       # returns SlashCommand or None
+    raise SlashCommandSignal(cmd)         # for context-dependent commands
+Key Components:
+    SlashCommand — immutable command descriptor (name, aliases, action key, description)
+    SlashCommandSignal — exception raised when a context-dependent command is triggered
+    CommandRegistry — register, match, help panel
+    REGISTRY — module-level singleton with all commands pre-registered
+Conventions:
+    Commands return action keys (strings), NOT callbacks.
+    Self-contained commands (exit, help) are handled by prompt_user() directly.
+    Context-dependent commands (compact) raise SlashCommandSignal for the caller to handle.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from rich.panel import Panel
+from rich.text import Text
+
+
+@dataclass(frozen=True)
+class SlashCommand:
+    """
+    Purpose: Immutable descriptor for a slash command.
+    Attributes:
+        name: Primary command string (e.g., "/compact")
+        aliases: Alternative triggers (e.g., ["/c"])
+        action: Action key dispatched to callers (e.g., "compact"). NOT a callback.
+        description: Human-readable description for /help display.
+        self_contained: If True, prompt_user() handles it directly (e.g., exit, help).
+                        If False, SlashCommandSignal is raised for the caller.
+    """
+    name: str
+    action: str
+    description: str
+    aliases: list[str] = field(default_factory=list)
+    self_contained: bool = False
+
+
+class SlashCommandSignal(Exception):
+    """
+    Purpose: Raised by prompt_user() when user triggers a context-dependent command.
+
+    Why an exception: prompt_user() doesn't own the conversation loop or trajectory.
+    It can't execute context-dependent commands itself. The exception propagates to
+    the caller (contextual_ask_user_guidance or mainmcp's between-turns loop) which
+    has the necessary context to dispatch.
+
+    Attributes:
+        command: The matched SlashCommand
+        action: Shortcut to command.action for easy dispatch
+    """
+
+    def __init__(self, command: SlashCommand):
+        self.command = command
+        self.action = command.action
+        super().__init__(f"Slash command: {command.name}")
+
+
+class CommandRegistry:
+    """
+    Purpose: Central registry for slash commands. Match user input, render help.
+
+    Usage Patterns:
+        REGISTRY.register(SlashCommand("/foo", "foo", "Do foo"))
+        cmd = REGISTRY.match("/foo")   # returns SlashCommand
+        cmd = REGISTRY.match("hello")  # returns None
+        panel = REGISTRY.help_panel()  # Rich Panel for /help display
+    """
+
+    def __init__(self):
+        self._commands: list[SlashCommand] = []
+        # Lookup: normalized trigger string → SlashCommand
+        self._lookup: dict[str, SlashCommand] = {}
+
+    def register(self, cmd: SlashCommand) -> None:
+        """Register a command. All triggers (name + aliases) are indexed."""
+        self._commands.append(cmd)
+        for trigger in [cmd.name] + cmd.aliases:
+            key = trigger.strip().lower()
+            if key in self._lookup:
+                raise ValueError(
+                    f"Duplicate trigger '{key}': already registered to '{self._lookup[key].name}'"
+                )
+            self._lookup[key] = cmd
+
+    def match(self, text: str) -> Optional[SlashCommand]:
+        """
+        Match user input against registered commands.
+
+        Args:
+            text: The full user input text (already stripped by prompt_user).
+
+        Returns:
+            SlashCommand if the ENTIRE text matches a trigger, else None.
+            Partial matches (e.g., "/comp" for "/compact") do NOT match.
+        """
+        return self._lookup.get(text.lower())
+
+    def help_panel(self) -> Panel:
+        """Build a Rich Panel listing all registered commands."""
+        lines = Text()
+        for cmd in self._commands:
+            triggers = ", ".join([cmd.name] + cmd.aliases)
+            lines.append(f"  {triggers}", style="bold cyan")
+            lines.append(f"  — {cmd.description}\n", style="dim")
+        return Panel(
+            lines,
+            title="[bold]Available Commands[/bold]",
+            border_style="blue",
+            padding=(1, 2),
+        )
+
+
+# =============================================================================
+# Module-level singleton — all commands registered here
+# =============================================================================
+
+REGISTRY = CommandRegistry()
+
+REGISTRY.register(SlashCommand(
+    name="/quit",
+    action="exit",
+    description="Exit the program",
+    aliases=["/q"],
+    self_contained=True,
+))
+
+REGISTRY.register(SlashCommand(
+    name="/help",
+    action="help",
+    description="Show available commands",
+    aliases=["/h", "/?"],
+    self_contained=True,
+))
+
+REGISTRY.register(SlashCommand(
+    name="/compact",
+    action="compact",
+    description="Compact trajectory to free LLM attention (irreversible)",
+    aliases=["/c"],
+    self_contained=False,
+))
+
+REGISTRY.register(SlashCommand(
+    name="/reset",
+    action="reset",
+    description="Clear trajectory and start fresh",
+    aliases=[],
+    self_contained=False,
+))