regcode 0.1.0__tar.gz → 0.2.0__tar.gz

{regcode-0.1.0 → regcode-0.2.0}/.gitignore

@@ -10,4 +10,5 @@ wheels/
 .venv
 config.yaml
 review.py
-*.config.yaml
+*.config.yaml
+.env

{regcode-0.1.0 → regcode-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.1.0
+Version: 0.2.0
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.12
 Requires-Dist: click>=8.0
@@ -10,6 +10,7 @@ Requires-Dist: pydantic-settings>=2.14.2
 Requires-Dist: pytest>=8.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: ruff>=0.8
+Requires-Dist: textual>=8.2.7
 Provides-Extra: dev
 Description-Content-Type: text/markdown
 

{regcode-0.1.0 → regcode-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regcode"
-version = "0.1.0"
+version = "0.2.0"
 description = "Minimalistic coding agent with Python API and CLI"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -12,6 +12,7 @@ dependencies = [
     "pytest>=8.0",
     "ruff>=0.8",
     "pydantic-monty>=0.0.18",
+    "textual>=8.2.7",
 ]
 
 [build-system]

{regcode-0.1.0 → regcode-0.2.0}/regcode/cli.py

@@ -41,14 +41,14 @@ def cli(ctx):
     help="Disable colored output",
 )
 def chat(model, config_path, stream, full, no_color):
-    """Chat with the agent."""
+    """Chat with the agent using a Textual TUI with sticky bottom bar."""
     config = regcode.Config.load(config_path)
     if model:
         config.provider.model = model
     if full:
         config.permissions.append(AgentPermission.WRITE)
 
-    # Initialize the TUI
+    # Initialize the TUI (Textual-based)
     force_color = not no_color and sys.stdout.isatty()
     ui = ChatUI(force_color=force_color)
 
@@ -56,41 +56,14 @@ def chat(model, config_path, stream, full, no_color):
         config=config,
         status_callback=ui.handle_status,
         result_callback=ui.handle_result,
+        context_callback=ui.set_context_progress,
     )
 
-    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
+    # Attach agent to the Textual app
+    ui._app.run_agent(agent)
+
+    # Run the Textual app (replaces the old click-based chat loop)
+    ui.run()
 
 
 @cli.command()

{regcode-0.1.0 → regcode-0.2.0}/regcode/main.py

@@ -62,6 +62,7 @@ class Agent:
             | None
         )
         | None = None,
+        context_callback: Callable[[int, int], None] | None = None,
     ) -> None:
         self.config = config or Config.load()
         self.system_prompt = self.config.system_prompt
@@ -69,6 +70,7 @@ class Agent:
         self.registry = ToolRegistry()
         self._status_callback = status_callback
         self._result_callback = result_callback
+        self._context_callback = context_callback
         self._allowed_dir = directory
         self._tool_budget = self.config.tool_budget
         self._tool_budget_remaining = self._tool_budget
@@ -76,6 +78,7 @@ class Agent:
 
         # Context window manager
         self.context_manager = ConversationManager()
+        self._context_window = self.config.agent.context_window
 
         # Review note tools - only register when compaction is enabled
         if self.config.agent.enable_compaction:
@@ -356,7 +359,6 @@ class Agent:
                             AgentStatus.TOOL_RESULT, result_str, is_error, tool_call_obj
                         )
 
-                    # Deduct one tool budget from remaining budget
                     self._tool_budget_remaining -= 1
                     if self._tool_budget_remaining <= 0:
                         self._tool_budget_exhausted = True
@@ -372,8 +374,6 @@ class Agent:
                                 "content": str(result),
                             }
                         )
-                        # Add explicit message telling the agent to stop using
-                        # tools and provide its final response
                         messages.append(
                             {
                                 "role": "user",
@@ -399,13 +399,36 @@ class Agent:
                         }
                     )
                     total_tool_calls += 1
+                    self._update_context_progress(messages)
                 # Safety: if model keeps calling tools without text, force break
                 if total_tool_calls >= 30:
                     break
                 continue
 
+            # Model returned neither text content nor tool calls — re-prompt it
+            # to force an answer with the current context state.
+            if not message_obj.content and (
+                not message_obj.tool_calls or len(message_obj.tool_calls) == 0
+            ):
+                if total_tool_calls >= 5:
+                    # After 5 empty responses, just give up and return empty
+                    break
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": (
+                            "You returned an empty response with no tool calls. "
+                            "Please provide your answer now based on the current "
+                            "conversation state. Respond in plain text only."
+                        ),
+                    }
+                )
+                total_tool_calls += 1
+                continue
+
             break
 
+        self._update_context_progress(messages)
         self._history = [m for m in messages if m.get("role") != "system"]
         return final_text or response_message.get("content", "") or ""
 
@@ -681,15 +704,52 @@ class Agent:
                         }
                     )
                     total_tool_calls += 1
+                    self._update_context_progress(messages)
                 if total_tool_calls >= 30:
                     break
                 continue
 
+            # Model returned neither text content nor tool calls — re-prompt it
+            # to force an answer with the current context state.
+            if not full_text and (
+                not response_message.get("tool_calls") or
+                len(response_message.get("tool_calls", [])) == 0
+            ):
+                if total_tool_calls >= 5:
+                    # After 5 empty responses, just give up and return empty
+                    break
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": (
+                            "You returned an empty response with no tool calls. "
+                            "Please provide your answer now based on the current "
+                            "conversation state. Respond in plain text only."
+                        ),
+                    }
+                )
+                total_tool_calls += 1
+                continue
+
             break
 
+        self._update_context_progress(messages)
         self._history = [m for m in messages if m.get("role") != "system"]
         return final_text or response_message.get("content", "") or ""
 
+    def _update_context_progress(self, messages: list[dict[str, Any]]) -> None:
+        """Estimate token usage and report progress via context_callback."""
+        if self._context_callback is None:
+            return
+        try:
+            token_count = litellm.token_counter(
+                model=self.config.provider.model,
+                messages=messages,
+            )
+            self._context_callback(token_count, self._context_window)
+        except Exception:
+            pass
+
     def reset(self) -> None:
         """Clear conversation history."""
         self._history = []

{regcode-0.1.0 → regcode-0.2.0}/regcode/tools/__init__.py

@@ -4,6 +4,8 @@ from regcode.tools.base import BaseTool, ToolParam, ToolResult
 from regcode.tools.builtins import create_default_tools
 from regcode.tools.registry import ToolRegistry
 
+__version__ = "0.2.0"
+
 __all__ = [
     "BaseTool",
     "ToolParam",

{regcode-0.1.0 → regcode-0.2.0}/regcode/tools/builtins.py

@@ -791,10 +791,18 @@ class SearchDirTool(BaseTool):
 
 
 class RunPythonScriptTool(BaseTool):
-    """Run a Python script from a file."""
+    """Execute a Python script file in an isolated Monty sandbox.
+
+    Reads the script file and executes its contents through the
+    Monty sandbox (Rust-based security, resource limits) rather than
+    spawning a subprocess on the host.
+    """
 
     name = "run_script"
-    description = "Execute a Python script file in the Monty sandbox."
+    description = (
+        "Execute a Python script file in an isolated Monty sandbox "
+        "with Rust-based security and resource limits."
+    )
 
     @property
     def params(self) -> list[ToolParam]:
@@ -805,13 +813,6 @@ class RunPythonScriptTool(BaseTool):
                 "Path to the Python script file",
                 required=True,
             ),
-            ToolParam(
-                "args",
-                "string",
-                "Command-line arguments for the script",
-                required=False,
-                default="",
-            ),
             ToolParam(
                 "timeout",
                 "number",
@@ -823,52 +824,52 @@ class RunPythonScriptTool(BaseTool):
 
     def execute(self, **kwargs: Any) -> ToolResult:
         script_path = kwargs.get("script_path")
-        args = kwargs.get("args", "")
         timeout = kwargs.get("timeout", 10)
         if not script_path:
             return ToolResult(
                 output="Missing required parameter: script_path",
                 error=True,
             )
+        # Coerce timeout to float (LLM may send string like "15")
+        try:
+            timeout = float(timeout)
+        except (TypeError, ValueError):
+            timeout = 10.0
+
         sandbox = MontySandbox()
         try:
-            script_full = sandbox.sandbox_root / script_path
-            if not script_full.exists():
+            # Read script file from the host filesystem
+            p = Path(script_path)
+            if not p.exists():
                 return ToolResult(
                     output=f"Script not found: {script_path}",
                     error=True,
                     exit_code=1,
                 )
-            import subprocess
-
-            cmd = ["python3", str(script_full)]
-            if args:
-                cmd.extend(args.split())
-
-            result = subprocess.run(
-                cmd,
-                cwd=str(sandbox.sandbox_root),
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-            )
+            try:
+                code = p.read_text()
+            except Exception as e:
+                return ToolResult(
+                    output=f"Error reading script: {str(e)}",
+                    error=True,
+                    exit_code=1,
+                )
 
+            # Execute script contents through Monty sandbox (Rust-based isolation)
+            result = sandbox.run_python(code, timeout=timeout)
             return ToolResult(
                 output=(
                     f"stdout: {result.stdout}\n"
                     f"stderr: {result.stderr}\n"
-                    f"exit_code: {result.returncode}"
+                    f"exit_code: {result.exit_code}\n"
+                    f"time: {result.execution_time:.2f}s\n"
+                    f"result: {result.result}"
                 ),
-                error=result.returncode != 0,
+                error=not result.success,
                 stdout=result.stdout,
                 stderr=result.stderr,
-                exit_code=result.returncode,
-            )
-        except subprocess.TimeoutExpired:
-            return ToolResult(
-                output="SANDBOX_ERROR: Execution timed out",
-                error=True,
-                exit_code=-1,
+                exit_code=result.exit_code,
+                result=result.result,
             )
         finally:
             sandbox.cleanup()