regcode 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

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/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/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/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()

regcode/tui.py

@@ -1,331 +1,660 @@
-"""Terminal UI for the RegCode agent CLI.
+"""Terminal UI for the RegCode agent CLI using Textual.
 
-Provides colored, structured output for user/assistant messages,
-tool calls, tool results, and agent status updates.
+Provides a clean, modern chat interface with:
+- Formatted message history with visual separation
+- Sticky bottom bar with progress and input
+- Message queuing during agent execution
 """
 
 from __future__ import annotations
 
-import sys
-import textwrap
-from enum import Enum
-from typing import IO
+import re
+import threading
 
-import click
+from rich.console import Group
+from rich.markdown import Markdown
+from rich.markup import escape
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Vertical
+from textual.widgets import Input, RichLog, Static
 
+from regcode import __version__
 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 ChatApp(App):
+    """Textual chat app with clean modern UI."""
+
+    TITLE = f"RegCode {__version__}"
+    CSS = """
+    Screen {
+        background: $panel;
+    }
+
+    #chat-pane {
+        width: 100%;
+        height: 1fr;
+        padding: 0;
+        margin: 0;
+        border: round $accent;
+        border-title-color: $accent;
+        border-title-align: left;
+    }
+
+    #history {
+        width: 100%;
+        height: 1fr;
+        padding: 0 1;
+        margin: 0;
+        background: transparent;
+        border: none;
+    }
+
+    #history RichLog {
+        color: $text;
+        background: transparent;
+    }
+
+    #bottom-bar {
+        dock: bottom;
+        layout: horizontal;
+        height: 5;
+        padding: 0 1;
+        background: $surface;
+        border: round $accent;
+    }
+
+    #live-response {
+        display: none;
+        width: 100%;
+        padding: 0 1;
+        margin: 0;
+        background: transparent;
+        color: $text;
+    }
+
+    #progress-bar {
+        width: 22;
+        content-align: center middle;
+        padding: 0 1;
+    }
+
+    #input-box {
+        width: 1fr;
+        height: 3;
+        min-height: 3;
+        margin: 0 0 0 1;
+        padding: 0 2;
+        background: $boost;
+        color: $text;
+        border: round $warning;
+    }
+
+    Input:focus {
+        border: round $success;
+        text-style: bold;
+    }
+
+    Footer {
+        display: none;
+    }
+
+    Header {
+        display: none;
+    }
+    """
 
-class _ColorFormatter:
-    """Format terminal output with ANSI colors."""
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("c", "clear", "Clear"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._msg_queue: list[str] = []
+        self._queue_lock = threading.Lock()
+        self._agent_running = False
+        self._agent = None
+        self._lock = threading.Lock()
+        self._current_response: list[str] = []
+        self._streaming_started = False
+        self._stream_pending = ""
+        self._stream_has_label = False
+        self._stream_line_open = False
+        self._stream_trim_leading = True
+        self._live_stream_text = ""
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            RichLog(
+                id="history",
+                markup=True,
+                max_lines=500,
+                auto_scroll=True,
+                wrap=True,
+            ),
+            Static(id="live-response"),
+            id="chat-pane",
+        )
+        yield Container(
+            Static(id="progress-bar", content="Ready"),
+            Input(id="input-box", placeholder="Type message..."),
+            id="bottom-bar",
+        )
 
-    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 on_mount(self) -> None:
+        """Initialize the app when mounted."""
+        self._update_progress(0, 0)
+        log = self.query_one("#history", RichLog)
+        log.write(f"[bold cyan]RegCode {__version__}[/]\n")
+        log.write("[dim]Made by Bijay Regmi in Bonn ❤️[/]\n")
+        log.write("[dim]Type your message and press Enter.[/]\n")
+        log.write("[dim]────────────────────────────────────────────────────[/]\n")
+        self.set_timer(0.1, self._focus_input)
+
+    def _focus_input(self) -> None:
+        input_widget = self.query_one("#input-box", Input)
+        input_widget.focus()
+
+    def on_key(self, event) -> None:
+        """Handle keyboard shortcuts."""
+        if event.key == "q":
+            self.exit()
+        elif event.key == "c":
+            self.query_one("#history", RichLog).clear()
+            self._current_response.clear()
+            self._stream_pending = ""
+            self._stream_has_label = False
+
+    # ── Agent callbacks (called from agent thread) ──────────────────
+
+    def on_status(self, status, tool_call_info=None):
+        """Handle agent status updates from any thread."""
+        self.call_from_thread(self._render_status, status, tool_call_info)
+
+    def _render_status(self, status, tool_call_info) -> None:
+        """Render status updates on the main thread."""
+        log = self.query_one("#history", RichLog)
+        if status.value == "tool_call" and tool_call_info is not None:
+            tool_name = escape(str(tool_call_info.tool_name))
+            parts = [f"[dim]⚙[/dim] [blue]{tool_name}[/blue]"]
+            if tool_call_info.tool_args:
+                for k, v in tool_call_info.tool_args.items():
+                    val = escape(str(v))
+                    parts.append(f"  [dim]{escape(str(k))}=[/dim]{val}")
+            log.write(" ".join(parts) + "\n")
+        elif status.value == "budget_exhausted":
+            log.write("[red]Tool budget exhausted.[/]\n")
+        elif status.value == "idle":
+            log.write("[dim]Agent is idle. Waiting for your input.[/]\n")
 
-    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")
+    def on_result(
+        self,
+        status,
+        result_str: str,
+        error: bool,
+        tool_call: ToolCall | None = None,
+    ):
+        """Handle tool results - silences them."""
+        pass
+
+    def on_context(self, current: int, total: int):
+        """Handle context token usage updates."""
+        self.call_from_thread(self._update_progress, current, total)
+
+    def _update_progress(self, current: int, total: int) -> None:
+        """Update the progress bar on the bottom bar."""
+        if total <= 0:
+            total = 1
+        pct = min(100, int(current / total * 100))
+        bar_width = 11
+        filled = max(0, min(bar_width, round(bar_width * pct / 100)))
+        empty = bar_width - filled
+        bar = "█" * filled + "░" * empty
+
+        if pct >= 90:
+            color = "red"
+        elif pct >= 70:
+            color = "orange"
+        elif pct >= 40:
+            color = "yellow"
         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} "
+            color = "green"
+
+        pct_str = f"  {pct}%"
+        tokens_str = f" {current}/{total}"
+        label = f"[bold {color}]{bar}[/] {pct_str} [dim]{tokens_str}"
+
+        progress_widget = self.query_one("#progress-bar", Static)
+        progress_widget.update(label)
+
+    def on_text_chunk(self, chunk: str) -> None:
+        """Buffer chunks and update live preview during streaming."""
+        self._current_response.append(chunk)
+        self._streaming_started = True
+        self.call_from_thread(self._update_live_stream, chunk)
+
+    def _update_live_stream(self, chunk: str) -> None:
+        """Show in-progress assistant text as markdown in real time."""
+        if self._stream_trim_leading:
+            chunk = chunk.lstrip("\n")
+            self._stream_trim_leading = False
+            if not chunk:
+                return
+
+        self._live_stream_text += chunk
+        history = self.query_one("#history", RichLog)
+        live = self.query_one("#live-response", Static)
+        if not live.display:
+            live.display = True
+            history.styles.height = "auto"
+
+        md_preview = re.sub(r"\n{3,}", "\n\n", self._live_stream_text)
+        live.update(
+            Group(
+                Text("AGENT:", style="bold blue"),
+                Markdown(md_preview),
             )
+        )
+
+    def _render_stream_chunk(self, chunk: str) -> None:
+        """Render streamed chunks directly in history in readable batches."""
+        if not self._streaming_started:
+            self._streaming_started = True
+        self._stream_pending += chunk
+        self._flush_stream_buffer(flush_partial=False)
+
+    def _emit_stream_text(self, text: str) -> None:
+        """Emit a streamed text segment to history with AGENT label once."""
+        if not text:
+            return
+        if self._stream_trim_leading:
+            text = text.lstrip("\n")
+            self._stream_trim_leading = False
+            if not text:
+                return
+        log = self.query_one("#history", RichLog)
+        if not self._stream_has_label:
+            log.write(f"[bold blue]AGENT:[/] {escape(text)}")
+            self._stream_has_label = True
         else:
-            self._stream.write("AGENT [streaming] ")
-        self._stream.flush()
+            log.write(escape(text))
+        self._stream_line_open = not text.endswith("\n")
+
+    def _ensure_stream_line_break(self) -> None:
+        """Ensure subsequent non-stream lines start on a fresh line."""
+        if self._stream_has_label and self._stream_line_open:
+            self.query_one("#history", RichLog).write("\n")
+            self._stream_line_open = False
+
+    def _flush_stream_for_status(self) -> None:
+        """Flush stream text before status output with compact spacing."""
+        if self._stream_pending:
+            pending = self._stream_pending
+            # Avoid large visual gaps before tool/status lines.
+            pending = pending.rstrip("\n")
+            self._stream_pending = ""
+            if pending:
+                self._emit_stream_text(pending)
+        self._ensure_stream_line_break()
+
+    def _flush_stream_buffer(self, flush_partial: bool) -> None:
+        """Flush buffered stream text by line; optionally flush remainder."""
+        while "\n" in self._stream_pending:
+            line, self._stream_pending = self._stream_pending.split("\n", 1)
+            self._emit_stream_text(line + "\n")
+
+        if flush_partial and self._stream_pending:
+            self._emit_stream_text(self._stream_pending)
+            self._stream_pending = ""
+        elif len(self._stream_pending) >= 120:
+            # Keep streaming responsive even when the model emits long lines.
+            self._emit_stream_text(self._stream_pending)
+            self._stream_pending = ""
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Process input when user presses Enter."""
+        message = event.value.strip()
+        if not message:
+            return
+        input_widget = self.query_one("#input-box", Input)
+        input_widget.value = ""
+        if message.lower() in ("exit", "quit"):
+            self.exit()
+        if self._agent_running:
+            self._msg_queue.append(message)
+            self.notify(f"Message queued: {message[:60]}...")
+            return
+        self._process_message(message)
+
+    def _process_message(self, message: str) -> None:
+        """Process a user message by running the agent in a background thread."""
+        self._agent_running = True
+        self._streaming_started = False
+        self._current_response.clear()
+        self._stream_pending = ""
+        self._stream_has_label = False
+        self._stream_line_open = False
+        self._stream_trim_leading = True
+        self._live_stream_text = ""
+        history = self.query_one("#history", RichLog)
+        history.styles.height = "1fr"
+        live = self.query_one("#live-response", Static)
+        live.update("")
+        live.display = False
+        input_widget = self.query_one("#input-box", Input)
+        input_widget.placeholder = "Agent running... (Enter queues)"
+
+        log = self.query_one("#history", RichLog)
+        log.write(f"[bold green]YOU:[/] [bold]{escape(message)}[/]\n")
+
+        t = threading.Thread(target=self._run_agent_sync, args=(message,), daemon=True)
+        t.start()
+
+    def _run_agent_sync(self, message: str) -> None:
+        """Run agent.chat synchronously in a background thread."""
+        try:
+            with self._lock:
+                if self._agent:
+                    result = self._agent.chat(
+                        message, stream=True, on_text_chunk=self.on_text_chunk
+                    )
+                    # Fallback: if no chunks were emitted, render final text.
+                    if result and not self._current_response:
+                        self.call_from_thread(self._set_fallback_response, result)
+                else:
+                    self.call_from_thread(
+                        self._write_error_line, "Agent not initialized!"
+                    )
+        except Exception:
+            self.call_from_thread(self._write_error_line, "Agent error!")
+        finally:
+            self.call_from_thread(self._finish_message)
+
+    def _write_error_line(self, message: str) -> None:
+        """Write an error line safely on the UI thread."""
+        history = self.query_one("#history", RichLog)
+        history.styles.height = "1fr"
+        live = self.query_one("#live-response", Static)
+        live.update("")
+        live.display = False
+        self.query_one("#history", RichLog).write(f"[red]{escape(message)}[/]\n")
+
+    def _set_fallback_response(self, response: str) -> None:
+        """Set fallback response when streaming callback emitted no chunks."""
+        if not self._current_response:
+            self._current_response.append(response)
+            self._streaming_started = False
+
+    def _finish_message(self) -> None:
+        """Called on main thread after agent finishes."""
+        self._agent_running = False
+        try:
+            if self._current_response:
+                log = self.query_one("#history", RichLog)
+                response = "".join(self._current_response).lstrip("\n")
+                # Keep markdown readable but avoid huge accidental vertical gaps.
+                response = re.sub(r"\n{3,}", "\n\n", response)
+                history = self.query_one("#history", RichLog)
+                history.styles.height = "1fr"
+                live = self.query_one("#live-response", Static)
+                live.update("")
+                live.display = False
+                log.write("[bold blue]AGENT:[/]")
+                log.write(Markdown(response))
+                log.write(
+                    "[dim]────────────────────────────────────────────────────[/]\n"
+                )
+        except Exception:
+            self._write_error_line("Failed to render agent response.")
+        finally:
+            self._current_response.clear()
+            self._stream_pending = ""
+            self._stream_has_label = False
+            self._stream_line_open = False
+            self._stream_trim_leading = True
+            input_widget = self.query_one("#input-box", Input)
+            input_widget.placeholder = "Type message..."
+            input_widget.focus()
+            self._process_next_queued()
+
+    def _process_next_queued(self) -> None:
+        """Process the next message from the queue."""
+        with self._queue_lock:
+            if not self._msg_queue:
+                return
+            message = self._msg_queue.pop(0)
+        self._process_message(message)
+
+    def run_agent(self, agent) -> None:
+        """Attach the agent instance so the app can use it."""
+        self._agent = agent
+
+    # ── Backward-compatible API ─────────────────────────────────────
 
-    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
+    @property
+    def formatter(self) -> _ColorFormatter:
+        return _ColorFormatter(True)
 
-        icon = _ICONS.get(status.value, "[STATUS]")
-        header = self.colored(color + _BOLD, icon)
+    @property
+    def agent_running(self) -> bool:
+        return self._agent_running
 
-        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 print_welcome(self, version: str = "0.1.0") -> None:
+        log = self.query_one("#history", RichLog)
+        log.write(f"[bold cyan]RegCode - Minimalistic Coding Agent v{version}[/]\n")
+        log.write("[dim]Type your message and press Enter.[/]\n")
 
-    def heading(self, text: str) -> None:
-        """Print a bold heading."""
-        self._stream.write(f"{_BOLD}{text}{_RESET}\n")
-        self._stream.flush()
+    def print_separator(self) -> None:
+        self.query_one("#history", RichLog).write(
+            "[dim]────────────────────────────────────────────────────[/]\n"
+        )
 
-    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 print_user_message(self, message: str) -> None:
+        self.query_one("#history", RichLog).write(
+            f"[bold green]YOU:[/] [bold]{escape(message)}[/]\n"
+        )
 
-    def flush(self) -> None:
-        """Flush the underlying output stream."""
-        self._stream.flush()
+    def print_assistant_message(self, message: str) -> None:
+        log = self.query_one("#history", RichLog)
+        log.write("[bold blue]AGENT:[/]")
+        log.write(Markdown(message))
 
-    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 print_tool_call(self, tool_name: str, tool_args: dict | None = None) -> None:
+        parts = [f"[dim]⚙[/dim] [blue]{escape(str(tool_name))}[/blue]"]
+        if tool_args:
+            for k, v in tool_args.items():
+                val = escape(str(v))
+                parts.append(f"  [dim]{escape(str(k))}=[/dim]{val}")
+        self.query_one("#history", RichLog).write(" ".join(parts) + "\n")
 
-    def success(self, text: str) -> None:
-        """Print a success message in green."""
-        self._stream.write(f"{self.colored(_GREEN, text)}\n")
-        self._stream.flush()
+    def print_tool_result(self, tool_name, result, error=False):
+        pass
 
+    def handle_status(self, status, tool_call_info=None):
+        self.on_status(status, tool_call_info)
 
-class ChatUI:
-    """Terminal UI for the RegCode chat session.
+    def handle_result(self, status, result_str, error, tool_call=None):
+        self.on_result(status, result_str, error, tool_call)
 
-    Provides colored, structured output for user/assistant messages,
-    tool calls, tool results, and agent status updates.
+    def print_text_chunk(self, chunk: str) -> None:
+        self.on_text_chunk(chunk)
+
+    def get_user_input(self) -> str | None:
+        return None
 
-    Usage:
-        ui = ChatUI()
-        ui.print_heading("RegCode v0.1.0")
-        ui.print_separator()
+    def print_exit(self) -> None:
+        self.query_one("#history", RichLog).write("[dim]Goodbye![/]\n")
 
-        # Set up status callback on the agent
-        agent = Agent(
-            config=config,
-            status_callback=ui.handle_status,
+    def print_round_complete(self) -> None:
+        self.query_one("#history", RichLog).write(
+            "[dim]────────────────────────────────────────────────────[/]\n"
         )
 
-        # Chat loop
-        ui.print_user_message("Hello")
-        reply = agent.chat("Hello")
-        ui.print_assistant_message(reply)
-    """
+    def print_interrupted(self) -> None:
+        self.query_one("#history", RichLog).write(
+            "[bold red]Interrupted by user. Goodbye![/]\n"
+        )
+
+    def start_streaming(self) -> None:
+        log = self.query_one("#history", RichLog)
+        log.write("[dim]...[/]\n")
+
+    def end_streaming(self) -> None:
+        self.query_one("#history", RichLog).write("\n")
 
-    def __init__(self, stream: IO[str] = sys.stdout, force_color: bool = False) -> None:
-        self._formatter = _ColorFormatter(stream, force_color)
+    def print_prompt(self) -> None:
+        pass
+
+    def clear(self) -> None:
+        self.query_one("#history", RichLog).clear()
+        self._current_response.clear()
+
+    def set_context_progress(self, current: int, total: int) -> None:
+        self.on_context(current, total)
+
+    def queue_message(self, message: str) -> None:
+        with self._queue_lock:
+            self._msg_queue.append(message)
+
+    def get_queued_messages(self) -> list[str]:
+        with self._queue_lock:
+            messages = list(self._msg_queue)
+            self._msg_queue.clear()
+            return messages
+
+    def is_queue_empty(self) -> bool:
+        with self._queue_lock:
+            return len(self._msg_queue) == 0
+
+    def set_agent_running(self, running: bool) -> None:
+        self._agent_running = running
+
+    def start_input_thread(self) -> None:
+        pass
+
+    def stop_input_thread(self) -> None:
+        pass
+
+    def run_app(self) -> None:
+        """Run the Textual application."""
+        self.run()
+
+
+class _ColorFormatter:
+    """Color formatter for CLI output, with Textual integration."""
+
+    def __init__(self, stream=None, force_color: bool = True, textui=None) -> None:
         self._stream = stream
-        self._streaming = False
+        self._force_color = force_color
+        self._textui = textui
+
+    def colored(self, color: str, text: str) -> str:
+        return f"{color}{text}\033[0m" if self._force_color else text
+
+    def context_progress(self, current: int, total: int) -> None:
+        if self._stream is not None:
+            pct = min(100, int(current / max(total, 1) * 100))
+            bar_width = 11
+            filled = max(0, min(bar_width, round(bar_width * pct / 100)))
+            empty = bar_width - filled
+            bar = self.colored("green", "━" * filled) + self.colored("dim", "━" * empty)
+            pct_str = self.colored("yellow", f"  {pct}%")
+            tokens_str = self.colored("dim", f" {current}/{total} tokens")
+            self._stream.write(f"{bar}{pct_str}{tokens_str}\n")
+
+        if self._textui is not None:
+            self._textui.set_context_progress(current, total)
+
+
+class ChatUI:
+    """Facade that bridges the old CLI code to the new Textual implementation."""
+
+    def __init__(self, force_color: bool = True) -> None:
+        self._app = ChatApp()
 
     @property
     def formatter(self) -> _ColorFormatter:
-        """Return the underlying formatter."""
-        return self._formatter
+        return self._app.formatter
 
-    # -- Public API --
+    @property
+    def agent_running(self) -> bool:
+        return self._app.agent_running
 
     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()
+        self._app.print_welcome(version)
 
     def print_separator(self) -> None:
-        """Print a visual separator between message rounds."""
-        self._formatter.separator()
+        self._app.print_separator()
 
     def print_user_message(self, message: str) -> None:
-        """Print a formatted user message."""
-        self._formatter.user_message(message)
+        self._app.print_user_message(message)
 
     def print_assistant_message(self, message: str) -> None:
-        """Print a formatted assistant message."""
-        self._formatter.assistant_message(message)
+        self._app.print_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)
+        self._app.print_tool_call(tool_name, tool_args)
 
-    def handle_status(self, status, tool_call_info=None) -> None:
-        """Status callback handler for the Agent.
+    def print_tool_result(self, tool_name, result, error=False):
+        self._app.print_tool_result(tool_name, result, error)
 
-        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_status(self, status, tool_call_info=None):
+        self._app.handle_status(status, tool_call_info)
 
-    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 handle_result(self, status, result_str, error, tool_call=None):
+        self._app.handle_result(status, result_str, error, tool_call)
 
     def print_text_chunk(self, chunk: str) -> None:
-        """Print a text chunk from streaming output."""
-        sys.stdout.write(chunk)
-        sys.stdout.flush()
+        self._app.print_text_chunk(chunk)
 
     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
+        return None
 
     def print_exit(self) -> None:
-        """Print exit message."""
-        self._formatter.info("Goodbye!")
+        self._app.print_exit()
 
     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()
+        self._app.print_round_complete()
 
     def print_interrupted(self) -> None:
-        """Print interrupted message."""
-        self._formatter.info("Interrupted by user. Goodbye!")
+        self._app.print_interrupted()
 
     def start_streaming(self) -> None:
-        """Print a streaming indicator before streaming output."""
-        self._streaming = True
-        self._formatter.streaming_indicator()
-        self._stream.flush()
+        self._app.start_streaming()
 
     def end_streaming(self) -> None:
-        """Finalize streaming output with a newline."""
-        self._streaming = False
-        self._stream.write("\n")
-        self._stream.flush()
+        self._app.end_streaming()
 
     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()
+        self._app.print_prompt()
 
     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
+        self._app.clear()
+
+    def set_context_progress(self, current: int, total: int) -> None:
+        self._app.set_context_progress(current, total)
+
+    def queue_message(self, message: str) -> None:
+        self._app.queue_message(message)
+
+    def get_queued_messages(self) -> list[str]:
+        return self._app.get_queued_messages()
+
+    def is_queue_empty(self) -> bool:
+        return self._app.is_queue_empty()
+
+    def set_agent_running(self, running: bool) -> None:
+        self._app.set_agent_running(running)
+
+    def start_input_thread(self) -> None:
+        self._app.start_input_thread()
+
+    def stop_input_thread(self) -> None:
+        self._app.stop_input_thread()
+
+    def run(self) -> None:
+        """Run the Textual app."""
+        self._app.run()

{regcode-0.1.0.dist-info → regcode-0.2.0.dist-info}/METADATA

@@ -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.dist-info → regcode-0.2.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 regcode/__init__.py,sha256=2Cv_d6ciJzl49HiCT7_xpCw0efN5gtoYM7_MPnYZRE8,168
-regcode/cli.py,sha256=xHt4m8e9p4bKfMDMAzJLf_q4JfkeGhi8kTXmCnbPg18,5354
+regcode/cli.py,sha256=065RqyRFJSbiqpFae1fvy84ngto6KZw4tVksnypg6FA,4637
 regcode/config.py,sha256=c640TNa4-6AU0AK1iCPc9ESNacrTT5MG1w_zYwdzLDY,5583
 regcode/conversation_manager.py,sha256=7b1hB7881ydPkCvePJIZ-HgtUi95FglJ7MyFAYw2H1o,5636
-regcode/main.py,sha256=lE_IcHFnWF_8m8RvMB4YGbJ85G-Wk6hLeera0jaxiMs,37493
+regcode/main.py,sha256=6MOYRZNnFuqE85TmxeqfwJgFweU9ISD3ZVLzYTdDPXU,40084
 regcode/monty_sandbox.py,sha256=UxTFmczQr5F4nlDe1gJ5Ul6GX_5KJkVYekVia-JKKvw,12930
 regcode/permissions.py,sha256=9R1dz6ypxBq_tNj-l4ixq_KJ-kAbXHarOey5EmnZzgU,784
 regcode/sandbox.py,sha256=v7oyl4PZVs4uMGGJRQC7YdQNLf7pbtRpVMXuNfnslJI,11414
-regcode/tui.py,sha256=EsH5OGoTu6R2yS1Hf9W5UOYW10Bg_oXClEzb2fhsN6o,11464
-regcode/tools/__init__.py,sha256=VG2pxPkVSRUaLZ-tgNTcvcJSXUOuVLeCT0yx7k1g2pQ,325
+regcode/tui.py,sha256=RHVnmsaE7f32mvDmbKAo7YbBVBWRZ6Zm0ENihc0Pcgk,22949
+regcode/tools/__init__.py,sha256=GQmpdlMT_xw3sKkK5hNKfB2IBQLUNAurV4HN6QWJRT0,348
 regcode/tools/base.py,sha256=D4oalxZb-cKvCMFeghyKSoLy_M7LUVPMeFTUPmrcuyY,3538
-regcode/tools/builtins.py,sha256=0f6ArIeUysL-8fwdtbNkKHlmebeC5OxYTtKRn-yuG64,30684
+regcode/tools/builtins.py,sha256=-Q4OIW6WpnbdT6CxTi0rn98xxfKEZK3wsP4lzUgTASY,30920
 regcode/tools/registry.py,sha256=jrGtKLlRPgfFQFGlCAaxEfoR0ZXForQUmZexM5-HnEo,2638
 regcode/tools/review_notes.py,sha256=zdbKTKv2hlnfd7Q-F0xlg8n2IHt7h0KssS0OyyY2gcM,3743
-regcode-0.1.0.dist-info/METADATA,sha256=v8s5W2dnPIzYLbcuJUHyPg0e3GBI-qDad_EbU1kMofM,5039
-regcode-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-regcode-0.1.0.dist-info/entry_points.txt,sha256=DzSdoP-DefYTNnnuwctq7neSx19XjfB78Jzk-c1UcsQ,44
-regcode-0.1.0.dist-info/RECORD,,
+regcode-0.2.0.dist-info/METADATA,sha256=HCCJK8N1Bgrzp_biDrh2vGO4jus_tlmSdBq9R63LsLc,5069
+regcode-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+regcode-0.2.0.dist-info/entry_points.txt,sha256=DzSdoP-DefYTNnnuwctq7neSx19XjfB78Jzk-c1UcsQ,44
+regcode-0.2.0.dist-info/RECORD,,