regcode 0.1.0__py3-none-any.whl

regcode/tools/registry.py

@@ -0,0 +1,78 @@
+"""Tool registry for managing available agent tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from regcode.tools.base import BaseTool, ToolResult
+
+
+class ToolRegistry:
+    """Registry for agent tools. Manages tool discovery and execution."""
+
+    def __init__(self) -> None:
+        self._tools: dict[str, BaseTool] = {}
+
+    def register(self, tool: BaseTool) -> None:
+        """Register a tool with the registry."""
+        self._tools[tool.name] = tool
+
+    def unregister(self, tool_name: str) -> None:
+        """Unregister a tool by name."""
+        self._tools.pop(tool_name, None)
+
+    def get(self, name: str) -> BaseTool | None:
+        """Get a tool by name."""
+        return self._tools.get(name)
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        """List all registered tools as OpenAI-compatible tool definitions."""
+        result = []
+        for tool in self._tools.values():
+            result.append({
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": {
+                        p.name: {
+                            "type": p.type,
+                            "description": p.description,
+                            "required": p.required,
+                            "default": p.default,
+                        }
+                        for p in tool.params
+                    }
+                }
+            })
+        return result
+
+    def execute(self, tool_name: str, **kwargs: Any) -> ToolResult:
+        """Execute a registered tool by name."""
+        tool = self.get(tool_name)
+        if tool is None:
+            return ToolResult(
+                output=(
+                    f"Unknown tool: {tool_name}. "
+                    f"Available: {', '.join(self._tools.keys())}"
+                ),
+                error=True,
+            )
+        validation = tool.validate_params(**kwargs)
+        if validation is not None:
+            return validation
+        return tool.execute(**kwargs)
+
+    def enable_tool(self, tool_name: str) -> bool:
+        """Enable a tool (mark for use). Returns False if not registered."""
+        # For now, all registered tools are enabled
+        return tool_name in self._tools
+
+    def disable_tool(self, tool_name: str) -> bool:
+        """Disable a tool by removing it from execution."""
+        return self._tools.pop(tool_name, None) is not None
+
+    @property
+    def enabled_tools(self) -> list[str]:
+        """Get list of enabled tool names."""
+        return list(self._tools.keys())

regcode/tools/review_notes.py

@@ -0,0 +1,122 @@
+"""Review note tools for persistent storage across context compaction.
+
+These tools allow the agent to save preliminary findings and observations
+about the codebase that persist even when the context is compacted.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from regcode.tools.base import BaseTool, ToolParam, ToolResult
+
+if TYPE_CHECKING:
+    from regcode.conversation_manager import ContextManager
+
+
+class AddReviewNoteTool(BaseTool):
+    """Add a review note to persistent storage.
+
+    Review notes are preliminary findings about the codebase that survive
+    context window compaction. Useful for tracking observations, potential
+    issues, or architectural patterns discovered during analysis.
+    """
+
+    name = "add_review_note"
+    description = (
+        "Add a review note to persistent storage. "
+        "Use this to save preliminary findings about the codebase "
+        "that will survive context window compaction. "
+        "Notes are useful for tracking observations, "
+        "potential issues, or architectural patterns."
+    )
+
+    def __init__(self, context_manager: ContextManager) -> None:
+        self._context_manager = context_manager
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "title",
+                "string",
+                "Title for the review note",
+                required=True,
+            ),
+            ToolParam(
+                "content",
+                "string",
+                "The review note content",
+                required=True,
+            ),
+            ToolParam(
+                "importance",
+                "string",
+                "Importance level: low, medium, high",
+                required=False,
+                default="medium",
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        title = kwargs.get("title")
+        content = kwargs.get("content")
+        importance = kwargs.get("importance", "medium")
+
+        if not title:
+            return ToolResult(
+                output="Missing required parameter: title",
+                error=True,
+            )
+        if not content:
+            return ToolResult(
+                output="Missing required parameter: content",
+                error=True,
+            )
+
+        self._context_manager.add_review_note(
+            title=title,
+            content=content,
+            importance=importance,
+        )
+        return ToolResult(
+            output=f"Review note '{title}' added successfully",
+            exit_code=0,
+        )
+
+
+class ReadReviewNotesTool(BaseTool):
+    """Read all review notes from persistent storage.
+
+    Returns all saved review notes, which persist across context window
+    compaction. Use this to recall previous findings about the codebase.
+    """
+
+    name = "read_review_notes"
+    description = (
+        "Read all review notes from persistent storage. "
+        "Returns all previously saved review notes about the codebase."
+    )
+
+    def __init__(self, context_manager: ContextManager) -> None:
+        self._context_manager = context_manager
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return []
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        notes = self._context_manager.get_review_notes()
+        if not notes:
+            return ToolResult(output="No review notes found", exit_code=0)
+
+        lines = []
+        for note in notes:
+            lines.append(
+                f"- [{note.get('importance', 'medium')}] {note.get('title')}: "
+                f"{note.get('content', '')}"
+            )
+        return ToolResult(
+            output="\n".join(lines),
+            exit_code=0,
+        )

regcode/tui.py

@@ -0,0 +1,331 @@
+"""Terminal UI for the RegCode agent CLI.
+
+Provides colored, structured output for user/assistant messages,
+tool calls, tool results, and agent status updates.
+"""
+
+from __future__ import annotations
+
+import sys
+import textwrap
+from enum import Enum
+from typing import IO
+
+import click
+
+from regcode.main import ToolCall
+
+# ANSI color codes
+_RESET = "\033[0m"
+_BOLD = "\033[1m"
+_DIM = "\033[2m"
+_UNDERLINE = "\033[4m"
+
+# Foreground colors
+_CYAN = "\033[36m"
+_GREEN = "\033[32m"
+_YELLOW = "\033[33m"
+_MAGENTA = "\033[35m"
+_BLUE = "\033[34m"
+_RED = "\033[31m"
+_GRAY = "\033[90m"
+_WHITE = "\033[97m"
+_ORANGE = "\033[38;5;208m"
+
+# Status icons (simple text alternatives for terminal compatibility)
+_ICONS = {
+    "tool_call": "[TOOL]",
+    "tool_result": "[RESULT]",
+    "idle": "[IDLE]",
+    "budget_exhausted": "[BUDGET]",
+}
+
+# Separator characters
+_SEP_CHAR = "─"
+
+
+def _wrap_text(text: str, width: int = 72, indent: str = "    ") -> str:
+    """Wrap text with an indent for readable terminal output."""
+    wrapped = textwrap.fill(text, width=width)
+    return "\n".join(f"{indent}{line}" for line in wrapped.splitlines())
+
+
+class _ColorFormatter:
+    """Format terminal output with ANSI colors."""
+
+    def __init__(self, stream: IO[str] = sys.stdout, force_color: bool = False) -> None:
+        # Check if stdout is a TTY or force color
+        self._stream = stream
+        self._force_color = force_color or sys.stdout.isatty()
+
+    def colored(self, color: str, text: str) -> str:
+        """Return colored text, or plain text if colors disabled."""
+        if self._force_color:
+            return f"{color}{text}{_RESET}"
+        return text
+
+    def user_message(self, message: str) -> None:
+        """Print a user message with green highlight."""
+        header = self.colored(_GREEN + _BOLD, "YOU")
+        self._stream.write(f"{header} ")
+        self._stream.write(_wrap_text(message) + "\n")
+        self._stream.flush()
+
+    def assistant_message(self, message: str) -> None:
+        """Print an assistant message with blue/cyan highlight."""
+        header = self.colored(_CYAN + _BOLD, "AGENT")
+        self._stream.write(f"{header} ")
+        if message.strip():
+            self._stream.write(_wrap_text(message) + "\n")
+        else:
+            self._stream.write(" (empty response)\n")
+        self._stream.flush()
+
+    def streaming_indicator(self) -> None:
+        """Print a streaming indicator with blinking cursor."""
+        if self._force_color:
+            self._stream.write(
+                f"{self.colored(_CYAN + _BOLD, 'AGENT')}"
+                f" {_DIM}[streaming]{_RESET} "
+            )
+        else:
+            self._stream.write("AGENT [streaming] ")
+        self._stream.flush()
+
+    def tool_call(self, tool_name: str, tool_args: dict | None = None) -> None:
+        """Print a tool call notification in yellow - compact, no extra blank lines."""
+        header = self.colored(_YELLOW + _BOLD, _ICONS["tool_call"])
+        parts = [self.colored(_YELLOW + _BOLD, tool_name)]
+        if tool_args:
+            for key, value in tool_args.items():
+                val_str = str(value)
+                if len(val_str) > 40:
+                    val_str = val_str[:37] + "..."
+                parts.append(f"{key}={val_str}")
+        line = f" {header} " + " ".join(parts)
+        self._stream.write(line + "\n")
+        self._stream.flush()
+
+    def tool_result(self, tool_name: str, result: str, error: bool = False) -> None:
+        """Print a tool result in magenta (or red if error)."""
+        color = _RED if error else _MAGENTA
+        header = self.colored(color + _BOLD, _ICONS["tool_result"])
+        self._stream.write(f"\n{header} {self.colored(color + _BOLD, tool_name)}\n")
+        truncated = result[:500] + ("..." if len(result) > 500 else "")
+        self._stream.write(_wrap_text(truncated) + "\n")
+        self._stream.flush()
+
+    def status_update(self, status: Enum, tool_call_info=None) -> None:
+        """Print a status update in gray dim text at the bottom area."""
+        color = _GRAY
+        if status.value == "budget_exhausted":
+            color = _RED
+        elif status.value == "idle":
+            color = _DIM
+
+        icon = _ICONS.get(status.value, "[STATUS]")
+        header = self.colored(color + _BOLD, icon)
+
+        if status.value == "budget_exhausted":
+            status_text = self.colored(color + _BOLD, "Tool budget exhausted.")
+            self._stream.write(f"\n{header} {status_text}\n")
+        elif status.value == "idle":
+            status_text = self.colored(color, "Agent is idle. Waiting for your input.")
+            self._stream.write(f"\n{header} {status_text}\n")
+        else:
+            status_text = self.colored(color, "Agent is working...")
+            self._stream.write(f"\n{header} {status_text}\n")
+        self._stream.flush()
+
+    def separator(self) -> None:
+        """Print a visual separator line."""
+        if self._force_color:
+            self._stream.write(
+                f"{self.colored(_DIM, _SEP_CHAR * 72)}\n"
+            )
+        else:
+            self._stream.write(f"{_SEP_CHAR * 72}\n")
+        self._stream.flush()
+
+    def heading(self, text: str) -> None:
+        """Print a bold heading."""
+        self._stream.write(f"{_BOLD}{text}{_RESET}\n")
+        self._stream.flush()
+
+    def info(self, text: str) -> None:
+        """Print an informational message in gray."""
+        self._stream.write(f"{self.colored(_GRAY, text)}\n")
+        self._stream.flush()
+
+    def flush(self) -> None:
+        """Flush the underlying output stream."""
+        self._stream.flush()
+
+    def error(self, text: str) -> None:
+        """Print an error message in red."""
+        prefix = "ERROR: " + text
+        self._stream.write(f"{self.colored(_RED + _BOLD, prefix)}\n")
+        self._stream.flush()
+
+    def success(self, text: str) -> None:
+        """Print a success message in green."""
+        self._stream.write(f"{self.colored(_GREEN, text)}\n")
+        self._stream.flush()
+
+
+class ChatUI:
+    """Terminal UI for the RegCode chat session.
+
+    Provides colored, structured output for user/assistant messages,
+    tool calls, tool results, and agent status updates.
+
+    Usage:
+        ui = ChatUI()
+        ui.print_heading("RegCode v0.1.0")
+        ui.print_separator()
+
+        # Set up status callback on the agent
+        agent = Agent(
+            config=config,
+            status_callback=ui.handle_status,
+        )
+
+        # Chat loop
+        ui.print_user_message("Hello")
+        reply = agent.chat("Hello")
+        ui.print_assistant_message(reply)
+    """
+
+    def __init__(self, stream: IO[str] = sys.stdout, force_color: bool = False) -> None:
+        self._formatter = _ColorFormatter(stream, force_color)
+        self._stream = stream
+        self._streaming = False
+
+    @property
+    def formatter(self) -> _ColorFormatter:
+        """Return the underlying formatter."""
+        return self._formatter
+
+    # -- Public API --
+
+    def print_welcome(self, version: str = "0.1.0") -> None:
+        """Print the welcome/banner message."""
+        self._formatter.heading(f"RegCode - Minimalistic Coding Agent v{version}")
+        self._formatter.info(
+            "Type your message and press Enter. Agent will respond with full "
+            "tool access."
+        )
+        self._formatter.info("Press Ctrl+C to exit.")
+        self._stream.write("\n")
+        self._formatter.flush()
+
+    def print_separator(self) -> None:
+        """Print a visual separator between message rounds."""
+        self._formatter.separator()
+
+    def print_user_message(self, message: str) -> None:
+        """Print a formatted user message."""
+        self._formatter.user_message(message)
+
+    def print_assistant_message(self, message: str) -> None:
+        """Print a formatted assistant message."""
+        self._formatter.assistant_message(message)
+
+    def print_tool_call(self, tool_name: str, tool_args: dict | None = None) -> None:
+        """Print a tool call notification."""
+        self._formatter.tool_call(tool_name, tool_args)
+
+    def print_tool_result(
+        self, tool_name: str, result: str, error: bool = False
+    ) -> None:
+        """Print a tool result."""
+        self._formatter.tool_result(tool_name, result, error)
+
+    def handle_status(self, status, tool_call_info=None) -> None:
+        """Status callback handler for the Agent.
+
+        This method is called by the agent's status_callback mechanism
+        to report what the agent is currently doing.
+        """
+        if status.value == "tool_call" and tool_call_info is not None:
+            self.print_tool_call(
+                tool_call_info.tool_name,
+                tool_call_info.tool_args,
+            )
+        elif status.value == "tool_result" and tool_call_info is not None:
+            # Skip - tool results are printed via result_callback
+            pass
+        elif status.value == "budget_exhausted":
+            self._formatter.status_update(status)
+        elif status.value == "idle":
+            self._formatter.status_update(status)
+
+    def handle_result(
+        self,
+        status,
+        result_str: str,
+        error: bool,
+        tool_call: ToolCall | None = None,
+    ) -> None:
+        """Handle tool result callback.
+        Tool results are NOT displayed - only tool calls are shown via status_callback.
+        """
+        pass  # Silence tool results - user only needs to see tool being called
+
+    def print_text_chunk(self, chunk: str) -> None:
+        """Print a text chunk from streaming output."""
+        sys.stdout.write(chunk)
+        sys.stdout.flush()
+
+    def get_user_input(self) -> str | None:
+        """Get user input with visible prompt. click.prompt echoes the input."""
+        try:
+            msg = click.prompt("YOU", prompt_suffix="> ", show_default=False)
+        except EOFError:
+            return None
+        return msg
+
+    def print_exit(self) -> None:
+        """Print exit message."""
+        self._formatter.info("Goodbye!")
+
+    def print_round_complete(self) -> None:
+        """Print a subtle separator after a complete round."""
+        if self._formatter._force_color:
+            self._stream.write(f"{self._formatter.colored(_DIM, '─' * 72)}\n")
+        else:
+            self._stream.write(f"{'─' * 72}\n")
+        self._stream.flush()
+
+    def print_interrupted(self) -> None:
+        """Print interrupted message."""
+        self._formatter.info("Interrupted by user. Goodbye!")
+
+    def start_streaming(self) -> None:
+        """Print a streaming indicator before streaming output."""
+        self._streaming = True
+        self._formatter.streaming_indicator()
+        self._stream.flush()
+
+    def end_streaming(self) -> None:
+        """Finalize streaming output with a newline."""
+        self._streaming = False
+        self._stream.write("\n")
+        self._stream.flush()
+
+    def print_prompt(self) -> None:
+        """Print the user input prompt."""
+        if self._formatter._force_color:
+            you_label = self._formatter.colored(_GREEN + _BOLD, "YOU")
+            self._stream.write(f" {you_label} ")
+        else:
+            self._stream.write(" YOU ")
+        self._stream.flush()
+
+    def clear(self) -> None:
+        """Clear the terminal screen (optional, best-effort)."""
+        try:
+            self._stream.write("\033[2J\033[H")
+            self._stream.flush()
+        except (IOError, ValueError):
+            pass

regcode-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: regcode
+Version: 0.1.0
+Summary: Minimalistic coding agent with Python API and CLI
+Requires-Python: >=3.12
+Requires-Dist: click>=8.0
+Requires-Dist: litellm>=1.83.17
+Requires-Dist: pydantic-monty>=0.0.18
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: pytest>=8.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: ruff>=0.8
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# RegCode
+
+A minimalistic coding agent with Python API bindings and CLI interface.
+
+## Features
+
+- **litellm** as the LLM backbone (supports OpenAI, Anthropic, and 100+ providers)
+- **YAML configuration** for model, tokens, temperature, provider settings
+- **Pydantic models** for type-safe config loading with environment variable expansion
+- **CLI** via click: `chat`, `configure`, `version`
+- **Python API**: `import regcode; agent = regcode.Agent()`
+- **Host filesystem I/O**: `write_file` and `patch_file` operate directly on the host filesystem with path traversal protection
+- **Patch tool**: `patch_file` replaces a range of lines in an existing file
+- **Robust tool call handling**: malformed tool calls and JSON parse errors are gracefully handled
+- **Progressive streaming**: TUI always streams assistant responses progressively rather than all at once
+
+## Quick Start
+
+```bash
+# Install dependencies
+uv sync
+
+# Configure your API key (or set OPENAI_API_KEY in your environment)
+# Edit config.yaml or use environment variables
+
+# Chat with the agent
+uv run regcode chat
+
+# View current config
+uv run regcode configure
+
+# View version
+uv run regcode version
+```
+
+## Usage as a Library
+
+```python
+import regcode
+
+# Load config (reads config.yaml, falls back to defaults)
+config = regcode.Config.load("config.yaml")
+
+# Create agent
+agent = regcode.Agent(config=config)
+
+# Chat (TUI always streams responses progressively)
+reply = agent.chat("Refactor this function to use async/await.")
+print(reply)
+
+# Reset conversation
+agent.reset()
+```
+
+## Tools
+
+RegCode includes several built-in tools the agent can use:
+
+| Tool | Permission | Description |
+|------|-----------|-------------|
+| `run_script` | `EXECUTE` | Execute a Python script in the Monty sandbox |
+| `shell_command` | `EXECUTE` | Execute shell commands (subprocess, not sandbox) |
+| `read_file` | `READ` | Read the contents of a file from the filesystem |
+| `write_file` | `WRITE` | Write content to a file on the host filesystem |
+| `patch_file` | `WRITE` | Replace a range of lines in an existing file |
+| `list_dir` | `READ` | List contents of a directory |
+| `search_files` | `READ` | Search for files matching a pattern |
+| `browse_dir` | `READ` | Recursively list all files in a directory tree |
+| `search_dir` | `READ` | Search for a pattern inside all files within a directory |
+| `fetch_git_diff` | `READ` | Fetch the git diff of the current repository |
+| `add_review_note` | `WRITE` | Save review notes to persistent storage |
+| `read_review_notes` | `READ` | Read previously saved review notes |
+| `system_info` | `READ` | Get system information (OS, Python version, etc.) |
+
+All file-writing tools (`write_file`, `patch_file`) include path traversal protection (`..` is blocked). The `patch_file` tool validates line number bounds and type correctness before performing the replacement.
+
+## Project Structure
+
+```
+regcode/
+├── config.yaml          # All configuration
+├── regcode/
+│   ├── __init__.py      # Python API entry point
+│   ├── main.py          # Agent core (chat, code review, etc.)
+│   ├── cli.py           # CLI entry point (click)
+│   ├── config.py        # Config loader (yaml + pydantic)
+│   ├── permissions.py    # Tool permission definitions
+│   ├── tui.py           # Terminal UI rendering
+│   ├── conversation_manager.py
+│   ├── sandbox.py
+│   ├── monty_sandbox.py
+│   └── tools/
+│       ├── __init__.py
+│       ├── base.py
+│       ├── builtins.py   # Built-in tool implementations
+│       ├── registry.py
+│       └── review_notes.py
+├── tests/
+│   ├── conftest.py
+│   ├── test_main.py
+│   ├── test_config.py
+│   ├── test_api.py
+│   ├── test_cli.py
+│   ├── test_context_manager.py
+│   ├── test_monty_sandbox.py
+│   ├── test_provider_extra.py
+│   └── test_review_notes.py
+├── pyproject.toml
+├── uv.lock
+└── README.md
+```
+
+## Testing & Linting
+
+```bash
+uv run pytest tests/ -v
+uv run ruff check --fix regcode/ tests/
+```
+
+## Configuration
+
+Edit `config.yaml` to change the model, provider, or tools:
+
+```yaml
+agent:
+  model: "openai/gpt-4o"
+  max_tokens: 4096
+  context_window: 128000
+  temperature: 0.7
+
+provider:
+  name: "openai"
+  api_key: "${OPENAI_API_KEY}"
+
+system_prompt: |
+  You are a coding agent. Help the user with code.
+
+tools:
+  code_review: true
+  security_scan: false
+  sandbox: false
+```
+
+Environment variables are expanded automatically (e.g., `${OPENAI_API_KEY}`).
+
+## License
+
+MIT