regcode 0.1.0__py3-none-any.whl

regcode/__init__.py

@@ -0,0 +1,5 @@
+from regcode.config import Config
+from regcode.main import Agent, AgentStatus, ToolCall
+
+__all__ = ["Agent", "Config", "AgentStatus", "ToolCall"]
+__version__ = "0.1.0"

regcode/cli.py

@@ -0,0 +1,180 @@
+import sys
+
+import click
+import yaml
+
+import regcode
+from regcode.permissions import AgentPermission
+from regcode.tui import ChatUI
+
+
+def _confirm(prompt_text):
+    """Ask yes/no question, accepting y/n (case insensitive)."""
+    answer = click.prompt(
+        prompt_text, type=click.Choice(["y", "n"], case_sensitive=False), default="y"
+    )
+    return answer == "y"
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def cli(ctx):
+    """RegCode - Minimalistic Coding Agent"""
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(chat, full=True)
+
+
+@cli.command()
+@click.option("--model", default=None, help="Model to use (e.g. openai/gpt-4o)")
+@click.option(
+    "--config", "config_path", default="config.yaml", help="Path to config.yaml"
+)
+@click.option("--stream", is_flag=True, help="Stream response")
+@click.option(
+    "--full",
+    is_flag=True,
+    help="Enable full agent mode (read, write, execute permissions)",
+)
+@click.option(
+    "--no-color",
+    is_flag=True,
+    help="Disable colored output",
+)
+def chat(model, config_path, stream, full, no_color):
+    """Chat with the agent."""
+    config = regcode.Config.load(config_path)
+    if model:
+        config.provider.model = model
+    if full:
+        config.permissions.append(AgentPermission.WRITE)
+
+    # Initialize the TUI
+    force_color = not no_color and sys.stdout.isatty()
+    ui = ChatUI(force_color=force_color)
+
+    agent = regcode.Agent(
+        config=config,
+        status_callback=ui.handle_status,
+        result_callback=ui.handle_result,
+    )
+
+    ui.print_welcome(regcode.__version__)
+
+    while True:
+        try:
+            msg = ui.get_user_input()
+            if msg is None:
+                break  # EOF
+            if msg.lower() in ("exit", "quit", "q"):
+                ui.print_exit()
+                break
+            if not msg:
+                continue
+
+            # Ensure agent response starts on a fresh line
+            click.echo()
+
+            # Always stream in TUI so text appears progressively rather than
+            # all at once after the full tool loop completes.
+            ui.start_streaming()
+            agent.chat(msg, stream=True, on_text_chunk=ui.print_text_chunk)
+            ui.end_streaming()
+
+            ui.print_round_complete()
+
+        except KeyboardInterrupt:
+            ui.print_interrupted()
+            break
+        except EOFError:
+            ui.print_exit()
+            break
+        except Exception as e:
+            ui.formatter.error(str(e))
+            break
+
+
+@cli.command()
+@click.option(
+    "--output", "output_path", default="config.yaml", help="Path for config.yaml"
+)
+def configure(output_path):
+    """Interactive config generator for config.yaml."""
+    config = regcode.Config()
+
+    # --- Agent config ---
+    yes = _confirm("Configure agent settings?")
+    if yes:
+        context_window = click.prompt(
+            "Context window size",
+            type=int,
+            default=config.agent.context_window,
+        )
+        compaction_threshold = click.prompt(
+            "Compaction threshold",
+            type=float,
+            default=config.agent.compaction_threshold,
+        )
+        enable_compaction = _confirm("Enable compaction")
+
+        config.agent.context_window = context_window
+        config.agent.compaction_threshold = compaction_threshold
+        config.agent.enable_compaction = enable_compaction
+    else:
+        click.echo("  Using default agent settings.")
+
+    # --- Provider config ---
+    yes = _confirm("Configure API provider?")
+    if yes:
+        model = click.prompt("Model", default=config.provider.model)
+        base_url = click.prompt("Base URL", default=config.provider.base_url)
+        api_key = click.prompt(
+            "API key",
+            default=config.provider.api_key,
+            hide_input=True,
+        )
+        temperature = click.prompt(
+            "Temperature", type=float, default=config.provider.temperature
+        )
+        max_tokens = click.prompt(
+            "Max tokens", type=int, default=config.provider.max_tokens
+        )
+
+        config.provider.model = model
+        config.provider.base_url = base_url
+        config.provider.api_key = api_key
+        config.provider.temperature = temperature
+        config.provider.max_tokens = max_tokens
+    else:
+        click.echo("  Using default provider settings.")
+
+    # --- Write config.yaml ---
+    data = {
+        "agent": {
+            "context_window": config.agent.context_window,
+            "compaction_threshold": config.agent.compaction_threshold,
+            "enable_compaction": config.agent.enable_compaction,
+        },
+        "provider": {
+            "base_url": config.provider.base_url,
+            "api_key": config.provider.api_key,
+            "model": config.provider.model,
+            "temperature": config.provider.temperature,
+            "max_tokens": config.provider.max_tokens,
+        },
+        "permissions": [p.value for p in config.permissions],
+        "tool_budget": config.tool_budget,
+    }
+
+    with open(output_path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False)
+    click.echo(f"\nconfig.yaml written to {output_path}")
+
+
+@cli.command()
+def version():
+    """Print version."""
+    click.echo(f"RegCode v{regcode.__version__}")
+
+
+if __name__ == "__main__":
+    cli(prog_name="regcode")

regcode/config.py

@@ -0,0 +1,153 @@
+import os
+from pathlib import Path
+from textwrap import dedent
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, ConfigDict
+
+from regcode.permissions import AgentPermission
+
+default_system_prompt = dedent(
+    """
+    # RegCode coding agent
+
+    ## Instructions
+    You are a coding agent. You have access to tools for reading and writing files,
+    executing code, and running tests. You can also use a sandboxed environment for
+    running untrusted code. You should use these tools to help you understand and
+    modify the codebase in the current directory.
+
+    When you need to read or write files, execute code, or run tests, you should use
+    the appropriate tool. You should not attempt to read or write files directly, or
+    execute code directly. You should also not attempt to run tests directly.
+
+    You should always be careful when executing code, as it may have side effects.
+    You should also be careful when reading or writing files, as it may affect the
+    state of the codebase.
+
+    Your goal is to help the user understand and modify the codebase in the current
+    directory. You should provide clear and concise explanations of the code and
+    suggest modifications that will improve the codebase.
+
+    Make sure to provide thorough explanations of your reasoning and the steps you
+    are taking.
+
+    ## Review Format
+    Start directly with your review content. Do not address user or
+    use fillers like "Now I have enough information to provide a review." or
+    "Here is my review:"
+    """
+)
+
+
+class AgentConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    context_window: int = 128000
+    compaction_threshold: float = 0.8  # Compact when context > 80% of window
+    enable_compaction: bool = True
+
+
+class ProviderConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    base_url: str = "https://api.openai.com/v1"
+    api_key: str = ""
+    temperature: float = 1
+    model: str = "openai/gpt-4o"
+    max_tokens: int = 4096
+    # Optional litellm completion kwargs (passed through to litellm.completion)
+    # See https://docs.litellm.ai/docs/completion/input for full list
+    extra_headers: dict | None = None
+    stop: list[str] | None = None
+    top_p: float | None = None
+    frequency_penalty: float | None = None
+    presence_penalty: float | None = None
+    logit_bias: dict | None = None
+    response_format: type[BaseModel] | None = None
+    seed: int | None = None
+    service_tier: str | None = None
+
+
+class SandboxConfig(BaseModel):
+    """Configuration for the Monty sandbox."""
+
+    model_config = ConfigDict(extra="allow")
+    use_monty: bool = True
+    max_duration_secs: float = 10.0
+    max_memory_mb: int = 64
+    max_recursion_depth: int = 100
+    type_check: bool = True
+    allowed_imports: list[str] = []
+
+
+class Config(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    agent: AgentConfig = AgentConfig()
+    provider: ProviderConfig = ProviderConfig()
+    system_prompt: str = default_system_prompt
+    tools: dict = {}
+    sandbox: SandboxConfig = SandboxConfig()
+    tool_budget: int = 20
+    permissions: list[AgentPermission] = [AgentPermission.READ, AgentPermission.EXECUTE]
+
+    @classmethod
+    def load(cls, path: str | None = None) -> "Config":
+        # get default home dir for user first
+        if path is None:
+            alt_config_path = Path.home() / ".regcode" / "config.yaml"
+            if alt_config_path.exists():
+                _path = alt_config_path
+            else:
+                _path = Path("config.yaml")
+        else:
+            _path = Path(path)
+        if not _path.exists():
+            return cls()
+        with open(_path) as f:
+            data = yaml.safe_load(f)
+        # Expand env vars in values
+        data = _expand_env_vars(data)
+        return cls(**data)
+
+    def get_litellm_completion_kwargs(self) -> dict[str, Any]:
+        """Build litellm.completion kwargs from this config.
+
+        Combines model, provider, and agent config into a single dict
+        ready to pass to litellm.completion().
+
+        Args:
+            extra_kwargs: Additional kwargs to merge on top of the
+                config-derived values (e.g. 'messages', 'tools', 'stream').
+
+        Returns:
+            Dict of litellm.completion keyword arguments.
+        """
+        extra_kwargs = {}
+        if hasattr(self.provider, "model_extra"):
+            extra_kwargs = self.provider.model_extra
+        result = self.provider.model_dump()
+        if extra_kwargs:
+            result.update(extra_kwargs)
+        # Agent-level config overrides provider defaults for known keys
+        if self.agent.context_window is not None:
+            result["context_window"] = self.agent.context_window
+        if hasattr(self.agent, "compaction_threshold"):
+            result["compaction_threshold"] = self.agent.compaction_threshold
+        if hasattr(self.agent, "enable_compaction"):
+            result["enable_compaction"] = self.agent.enable_compaction
+        # Apply agent-level extra fields (e.g. model, max_tokens, temperature
+        # from YAML agent section) as overrides over provider defaults
+        if hasattr(self.agent, "model_extra") and self.agent.model_extra:
+            result.update(self.agent.model_extra)
+        return result
+
+
+def _expand_env_vars(obj):
+    if isinstance(obj, str):
+        return os.path.expandvars(obj)
+    if isinstance(obj, dict):
+        return {k: _expand_env_vars(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_expand_env_vars(v) for v in obj]
+    return obj

regcode/conversation_manager.py

@@ -0,0 +1,154 @@
+"""Context window management with automatic compaction and review notes.
+
+Handles context window limits by triggering compaction when the context
+approaches the maximum size. Maintains review notes across compaction
+for persistent findings about large repos.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import litellm
+
+from regcode.config import Config
+
+
+class ConversationManager:
+    """Manages conversation history with automatic compaction and review notes."""
+
+    def __init__(
+        self,
+    ) -> None:
+        c = Config.load()
+        self.c = c
+        self.context_window = c.agent.context_window
+        self.max_tokens = c.provider.max_tokens
+        self.compaction_threshold = c.agent.compaction_threshold
+
+        # Conversation messages
+        self.messages: list[dict[str, Any]] = []
+
+        # Review notes persist across compaction
+        self._review_notes: list[dict[str, Any]] = []
+
+        # Cached token estimate (invalidate on message/compaction changes)
+        self._cached_token_estimate: int | None = None
+
+    def add_message(self, message: dict[str, Any]) -> None:
+        """Add a message to the context."""
+        self.messages.append(message)
+        self._cached_token_estimate = None
+
+    def should_compact(self) -> bool:
+        """Check if context needs compaction."""
+        if self._cached_token_estimate is None:
+            self._cached_token_estimate = self._estimate_tokens()
+        # Ensure available space is always at least 1 to avoid edge cases
+        # where max_tokens >= context_window would make threshold zero.
+        available_space = max(1, self.context_window - self.max_tokens)
+        return self._cached_token_estimate > available_space * self.compaction_threshold
+
+    def compact(self) -> None:
+        """Compact the context by keeping the first message, review notes,
+        and the most recent messages.
+
+        This preserves user instructions and accumulated review notes while
+        discarding older conversation history to stay within token limits.
+        """
+        if not self.messages:
+            return
+
+        # Keep the first message (system prompt / user instruction),
+        # but strip any previously embedded review notes section so they
+        # don't appear twice when _build_system_prompt() re-appends them.
+        first_msg = self.messages[0]
+        if first_msg.get("role") == "system" and isinstance(
+            first_msg.get("content"), str
+        ):
+            first_msg = {
+                "role": first_msg["role"],
+                "content": self._strip_review_notes(first_msg["content"]),
+            }
+
+        # Keep the last N messages instead of just 1.
+        # Cap at total_remaining so we never include more than available,
+        # and use min with total_remaining to handle small histories safely.
+        total_remaining = len(self.messages) - 1
+        if total_remaining <= 0:
+            recent_count = 0
+        else:
+            # Retain at least 5 recent messages, or 1/3 of history, whichever
+            # is larger, capped at total_remaining.
+            recent_count = min(max(5, total_remaining // 3), total_remaining)
+        # Get the last N messages (these don't include index 0 since we
+        # already extracted first_msg)
+        recent_msgs = self.messages[-recent_count:] if recent_count > 0 else []
+
+        # Build compacted list: first message + recent messages
+        self.messages = [first_msg]
+        self.messages.extend(recent_msgs)
+
+        # Invalidate cached token estimate since message count changed
+        self._cached_token_estimate = None
+
+    @staticmethod
+    def _strip_review_notes(text: str) -> str:
+        """Remove the 'Prior Review Notes' section from a system prompt.
+
+        This prevents review notes from being duplicated after compaction
+        since they will be re-appended by _build_system_prompt() on the
+        next chat call via get_review_notes().
+        """
+        marker = "\n\n### Prior Review Notes\n"
+        if marker not in text:
+            return text
+        # Find the marker and truncate the text at that point,
+        # then strip any trailing whitespace left behind
+        idx = text.index(marker)
+        return text[:idx].rstrip()
+
+    def _estimate_tokens(self) -> int:
+        """Estimate token count from messages using litellm token counter.
+
+        Uses litellm's built-in token counting which accurately counts tokens
+        for the specific model, including system prompt and tool definitions.
+        """
+        return litellm.token_counter(
+            model=self.c.provider.model,
+            messages=self.messages,
+        )
+
+    def add_review_note(
+        self,
+        title: str,
+        content: str,
+        importance: str = "medium",
+    ) -> None:
+        """Add a review note (persists across compaction)."""
+        self._review_notes.append({
+            "title": title,
+            "content": content,
+            "importance": importance,
+        })
+
+    def get_review_notes(self) -> list[dict[str, Any]]:
+        """Get all review notes."""
+        return list(self._review_notes)
+
+    def clear_review_notes(self) -> None:
+        """Clear all review notes."""
+        self._review_notes = []
+
+    def reset(self) -> None:
+        """Clear all messages and review notes."""
+        self.messages = []
+        self._review_notes = []
+
+    def get_messages(self) -> list[dict[str, Any]]:
+        """Get current messages."""
+        return list(self.messages)
+
+
+# Backwards-compatible alias for import paths that use 'context_manager'
+ContextManager = ConversationManager