regcode 0.4.0__tar.gz → 0.5.0__tar.gz

{regcode-0.4.0 → regcode-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.4.0
+Version: 0.5.0
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.12
 Requires-Dist: click>=8.0

{regcode-0.4.0 → regcode-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regcode"
-version = "0.4.0"
+version = "0.5.0"
 description = "Minimalistic coding agent with Python API and CLI"
 readme = "README.md"
 requires-python = ">=3.12"

{regcode-0.4.0 → regcode-0.5.0}/regcode/__init__.py

@@ -2,4 +2,4 @@ from regcode.config import Config
 from regcode.main import Agent, AgentStatus, ToolCall
 
 __all__ = ["Agent", "Config", "AgentStatus", "ToolCall"]
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{regcode-0.4.0 → regcode-0.5.0}/regcode/cli.py

@@ -1,3 +1,4 @@
+import logging
 import sys
 from pathlib import Path
 
@@ -5,9 +6,14 @@ import click
 import yaml
 
 import regcode
+from regcode.dependencies import ensure_playwright_browsers
 from regcode.permissions import AgentPermission
 from regcode.tui import ChatUI
 
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+_logger = logging.getLogger(__name__)
+
 
 def _confirm(prompt_text):
     """Ask yes/no question, accepting y/n (case insensitive)."""
@@ -43,6 +49,14 @@ def cli(ctx):
 )
 def chat(model, config_path, stream, full, no_color):
     """Chat with the agent using a Textual TUI with sticky bottom bar."""
+    # Ensure Playwright browsers are available for web_crawl tool
+    _logger.info("Checking startup dependencies...")
+    if not ensure_playwright_browsers():
+        _logger.warning(
+            "Playwright browsers are not available. "
+            "The web_crawl tool will not function."
+        )
+
     # Pass None if the file doesn't exist so Config.load falls back
     # to ~/.regcode/config.yaml (matching the TUI's expected behaviour).
     _effective_path = config_path if Path(config_path).exists() else None

regcode-0.5.0/regcode/dependencies.py

@@ -0,0 +1,71 @@
+"""Startup dependency checks and auto-installation."""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import sys
+
+_logger = logging.getLogger(__name__)
+
+
+def ensure_playwright_browsers() -> bool:
+    """Check if Playwright browsers are installed; install if missing.
+
+    Returns True if browsers are available (either already installed
+    or newly installed), False if installation was skipped due to
+    user setting PLAYWRIGHT_NO_INSTALL=1.
+    """
+    if os.environ.get("PLAYWRIGHT_NO_INSTALL"):
+        _logger.warning(
+            "PLAYWRIGHT_NO_INSTALL is set; skipping browser check."
+        )
+        return False
+
+    # Dynamic import so tests can mock before calling
+    try:
+        from playwright.sync_api import sync_playwright  # noqa: F811
+    except ImportError:
+        _logger.warning(
+            "playwright is not installed. Install with: "
+            "uv add playwright playwright-stealth && "
+            "uv run playwright install"
+        )
+        return False
+
+    try:
+        with sync_playwright() as p:
+            # Trigger a simple launch test — if browsers are missing,
+            # Chromium.launch() raises BrowserType.launch: Executable
+            # doesn't exist. We catch that specific error.
+            p.chromium.executable_path  # noqa: B018
+            # Try to actually launch; this is the definitive check
+            browser = p.chromium.launch()
+            browser.close()
+            return True
+    except Exception:
+        pass
+
+    # Browsers are missing — attempt automatic installation
+    _logger.info("Playwright browsers not found. Installing...")
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "playwright", "install", "--with-deps"],
+            check=True,
+            capture_output=True,
+        )
+        _logger.info("Playwright browsers installed successfully.")
+        return True
+    except subprocess.CalledProcessError as e:
+        stderr_text = e.stderr.decode() if e.stderr else ""
+        _logger.error(
+            "Failed to install Playwright browsers: %s", stderr_text
+        )
+        return False
+    except FileNotFoundError:
+        _logger.error(
+            "Could not find 'playwright' module. "
+            "Install it with: uv add playwright && uv run playwright install"
+        )
+        return False

{regcode-0.4.0 → regcode-0.5.0}/regcode/tools/__init__.py

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

{regcode-0.4.0 → regcode-0.5.0}/regcode/tools/builtins.py

@@ -17,7 +17,7 @@ from typing import Any
 
 from regcode.monty_sandbox import MontySandbox
 from regcode.tools.base import BaseTool, ToolParam, ToolResult
-
+from regcode.tools.web_crawl import WebCrawlerTool
 
 class PythonCodeTool(BaseTool):
     """Execute Python code in a Monty sandbox."""
@@ -1367,4 +1367,5 @@ def create_default_tools() -> list[BaseTool]:
         SystemInfoTool(),
         FetchGitDiffTool(),
         OSVCVETool(),
+        WebCrawlerTool(),
     ]

{regcode-0.4.0 → regcode-0.5.0}/regcode/tools/web_crawl.py

@@ -7,12 +7,13 @@ from typing import Any
 from regcode.tools.base import BaseTool, ToolParam, ToolResult
 
 try:
-    from crawl4ai import AsyncWebCrawler
+    from crawl4ai import AsyncWebCrawler, CrawlerRunConfig
     from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator
 
     CRAWL4AI_AVAILABLE = True
 except ImportError:
     AsyncWebCrawler = None  # type: ignore
+    CrawlerRunConfig = None  # type: ignore
     DefaultMarkdownGenerator = None  # type: ignore
     CRAWL4AI_AVAILABLE = False
 
@@ -95,24 +96,13 @@ class WebCrawlerTool(BaseTool):
                 exit_code=1,
             )
 
-        try:
-            import asyncio
+        import asyncio
 
-            result = asyncio.get_event_loop().run_until_complete(
+        try:
+            result = asyncio.run(
                 self._crawl_async(url, markdown, word_count_threshold, only_text)
             )
             return result
-        except ImportError:
-            # Fallback: try to run in a new event loop
-            import asyncio
-
-            async def _crawl():
-                return await self._crawl_async(
-                    url, markdown, word_count_threshold, only_text
-                )
-
-            result = asyncio.run(_crawl())
-            return result
         except Exception as e:
             return ToolResult(
                 output=f"Error crawling URL: {str(e)}",
@@ -131,18 +121,17 @@ class WebCrawlerTool(BaseTool):
         try:
             async with AsyncWebCrawler(verbose=False) as crawler:
                 if markdown:
-                    result = await crawler.arun(
-                        url=url,
-                        markdown_generator=DefaultMarkdownGenerator(
-                            word_count_threshold=word_count_threshold
-                        ),
+                    config = CrawlerRunConfig(  # type: ignore[union-attr]
+                        markdown_generator=DefaultMarkdownGenerator(),  # type: ignore[union-attr]
+                        word_count_threshold=word_count_threshold,
                         only_text=only_text,
                     )
+                    result = await crawler.arun(url=url, config=config)
                 else:
-                    result = await crawler.arun(
-                        url=url,
+                    config = CrawlerRunConfig(  # type: ignore[union-attr]
                         only_text=only_text,
                     )
+                    result = await crawler.arun(url=url, config=config)
 
                 if not result.success:
                     return ToolResult(
@@ -155,7 +144,8 @@ class WebCrawlerTool(BaseTool):
                 if markdown and result.markdown:
                     output = f"URL: {url}\n\n{result.markdown}"
                 else:
-                    output = f"URL: {url}\n\n{result.html or result.markdown or 'No content extracted'}"
+                    html = result.html or result.markdown or "No content extracted"
+                    output = f"URL: {url}\n\n{html}"
 
                 return ToolResult(
                     output=output,

{regcode-0.4.0 → regcode-0.5.0}/regcode/tui.py

@@ -44,7 +44,6 @@ class ChatMessage:
 # ChatApp — main Textual application
 # ---------------------------------------------------------------------------
 
-
 class ChatApp(App):
     """Clean modern TUI for RegCode agent."""
 
@@ -150,6 +149,7 @@ class ChatApp(App):
         self._cumulative_cost: float = 0.0
         self._total_tokens: int = 0
         self._context_window: int = 128000
+        self._pending_tool_line: str = ""
 
     # ── Compose ───────────────────────────────────────────────────
 
@@ -338,6 +338,27 @@ class ChatApp(App):
 
     def _run_agent_sync(self, message: str) -> None:
         """Run agent.chat synchronously in a background thread."""
+        # Suppress noise from litellm, mlflow, crawl4ai, and other
+        # library loggers during agent execution — they spew logging
+        # lines to stdout/stderr which corrupt the TUI display.
+        _noisy_loggers = (
+            "LiteLLM",
+            "mlflow",
+            "mlflow.tracking",
+            "crawl4ai",
+            "urllib3",
+            "httpx",
+            "httpcore",
+            "openai",
+            "http11",
+            "hpack",
+        )
+        _old_levels: dict[str, int] = {}
+        for name in _noisy_loggers:
+            logger = logging.getLogger(name)
+            _old_levels[name] = logger.level
+            logger.setLevel(logging.WARNING)
+
         try:
             with self._lock:
                 if self._agent is None:
@@ -364,6 +385,9 @@ class ChatApp(App):
             )
         finally:
             self.call_from_thread(self._finish_message)
+            # Restore logger levels in the same thread (background thread, not main)
+            for name, level in _old_levels.items():
+                logging.getLogger(name).setLevel(level)
 
     # ── Agent callbacks (any thread → main thread) ────────────────
 
@@ -383,6 +407,9 @@ class ChatApp(App):
         self._flush_stream_for_status()
 
         if status == AgentStatus.TOOL_CALL and tool_call_info is not None:
+            # Buffer the tool call text — RichLog always starts a new line
+            # per write(), so we can't append the ✓ on the same line until
+            # TOOL_RESULT arrives.
             tool_name = rich_escape(str(tool_call_info.tool_name))
             parts = [f"[dim]  [dim]⚙[/dim] {tool_name}[/dim]"]
             if tool_call_info.tool_args:
@@ -391,11 +418,13 @@ class ChatApp(App):
                     parts.append(
                         f"  [dim]{rich_escape(str(k))}=[/dim]{val}"
                     )
-            log.write(" ".join(parts) + "\n")
+            self._pending_tool_line = " ".join(parts)
 
         elif status == AgentStatus.TOOL_RESULT \
                 and tool_call_info is not None:
-            log.write("[dim]  [dim]✓[/dim] tool completed[/dim]\n")
+            # Emit the complete tool line with ✓ appended
+            log.write(self._pending_tool_line + "  [dim]✓[/dim]\n")
+            self._pending_tool_line = ""
 
         elif status == AgentStatus.COMPACTION_START:
             log.write(

regcode-0.5.0/tests/test_dependencies.py

@@ -0,0 +1,149 @@
+"""Tests for regcode.dependencies startup checks."""
+
+import subprocess
+import sys
+from unittest.mock import MagicMock, patch
+
+
+def _clear_regcode_deps():
+    """Remove cached regcode modules so re-import picks up mocks."""
+    for mod in list(sys.modules):
+        if mod == "regcode" or mod.startswith("regcode."):
+            del sys.modules[mod]
+
+
+class TestEnsurePlaywrightBrowsers:
+    """Tests for Playwright browser availability checking."""
+
+    def test_playwright_not_installed(self):
+        """When playwright is not installed, return False with warning."""
+        _clear_regcode_deps()
+
+        with patch.dict("sys.modules", {
+            "playwright": None,
+            "playwright.sync_api": None,
+        }):
+            from regcode import dependencies
+            result = dependencies.ensure_playwright_browsers()
+            assert result is False
+
+    def test_playwright_available_no_launch(self):
+        """When launch fails, auto-install is triggered."""
+        _clear_regcode_deps()
+
+        mock_browser = MagicMock()
+        mock_browser.close = MagicMock()
+        mock_p = MagicMock()
+        mock_p.chromium = MagicMock()
+        mock_p.chromium.executable_path = "/fake/path"
+        mock_p.chromium.launch = MagicMock(side_effect=Exception(
+            "BrowserType.launch: Executable doesn't exist"
+        ))
+        mock_instance = MagicMock()
+        mock_instance.__enter__ = MagicMock(return_value=mock_p)
+        mock_instance.__exit__ = MagicMock(return_value=None)
+
+        # Mock at the playwright module level so the import in
+        # dependencies.py picks up our mock
+        with patch.dict("sys.modules", {
+            "playwright": MagicMock(),
+            "playwright.sync_api": MagicMock(
+                sync_playwright=MagicMock(return_value=mock_instance)
+            ),
+        }):
+            from regcode.dependencies import ensure_playwright_browsers
+            # Auto-install succeeds
+            with patch.object(
+                subprocess, "run", return_value=MagicMock(returncode=0)
+            ):
+                result = ensure_playwright_browsers()
+                assert result is True
+
+    def test_playwright_available_with_launch(self):
+        """When browser launches successfully, return True."""
+        _clear_regcode_deps()
+
+        mock_browser = MagicMock()
+        mock_browser.close = MagicMock()
+        mock_p = MagicMock()
+        mock_p.chromium = MagicMock()
+        mock_p.chromium.executable_path = "/fake/path"
+        mock_p.chromium.launch = MagicMock(return_value=mock_browser)
+
+        mock_instance = MagicMock()
+        mock_instance.__enter__ = MagicMock(return_value=mock_p)
+        mock_instance.__exit__ = MagicMock(return_value=None)
+
+        with patch.dict("sys.modules", {
+            "playwright": MagicMock(),
+            "playwright.sync_api": MagicMock(
+                sync_playwright=MagicMock(return_value=mock_instance)
+            ),
+        }):
+            from regcode.dependencies import ensure_playwright_browsers
+            result = ensure_playwright_browsers()
+            assert result is True
+            mock_browser.close.assert_called_once()
+
+    def test_playwright_no_install_env_var(self):
+        """When PLAYWRIGHT_NO_INSTALL=1, skip check and return False."""
+        _clear_regcode_deps()
+
+        with patch.dict("os.environ", {"PLAYWRIGHT_NO_INSTALL": "1"}):
+            from regcode.dependencies import ensure_playwright_browsers
+            result = ensure_playwright_browsers()
+            assert result is False
+
+    def test_install_failure_returns_false(self):
+        """When auto-install fails, return False with error."""
+        _clear_regcode_deps()
+
+        mock_p = MagicMock()
+        mock_p.chromium = MagicMock()
+        mock_p.chromium.executable_path = "/fake/path"
+        mock_p.chromium.launch = MagicMock(side_effect=Exception("missing"))
+
+        mock_instance = MagicMock()
+        mock_instance.__enter__ = MagicMock(return_value=mock_p)
+        mock_instance.__exit__ = MagicMock(return_value=None)
+
+        with patch.dict("sys.modules", {
+            "playwright": MagicMock(),
+            "playwright.sync_api": MagicMock(
+                sync_playwright=MagicMock(return_value=mock_instance)
+            ),
+        }):
+            with patch.object(
+                subprocess,
+                "run",
+                side_effect=subprocess.CalledProcessError(1, "cmd", stderr=b"fail"),
+            ):
+                from regcode.dependencies import ensure_playwright_browsers
+                result = ensure_playwright_browsers()
+                assert result is False
+
+    def test_install_file_not_found(self):
+        """When playwright module is not found, return False."""
+        _clear_regcode_deps()
+
+        mock_p = MagicMock()
+        mock_p.chromium = MagicMock()
+        mock_p.chromium.executable_path = "/fake/path"
+        mock_p.chromium.launch = MagicMock(side_effect=Exception("missing"))
+
+        mock_instance = MagicMock()
+        mock_instance.__enter__ = MagicMock(return_value=mock_p)
+        mock_instance.__exit__ = MagicMock(return_value=None)
+
+        with patch.dict("sys.modules", {
+            "playwright": MagicMock(),
+            "playwright.sync_api": MagicMock(
+                sync_playwright=MagicMock(return_value=mock_instance)
+            ),
+        }):
+            with patch.object(
+                subprocess, "run", side_effect=FileNotFoundError("no playwright")
+            ):
+                from regcode.dependencies import ensure_playwright_browsers
+                result = ensure_playwright_browsers()
+                assert result is False

{regcode-0.4.0 → regcode-0.5.0}/uv.lock

@@ -2835,7 +2835,7 @@ wheels = [
 
 [[package]]
 name = "regcode"
-version = "0.4.0"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

regcode-0.4.0/repair_tui.md

@@ -1,115 +0,0 @@
-# TUI Streaming Repair — step by step
-
-File to edit: `regcode/tui.py` — class `ChatApp`.
-
-## Goal
-Stop printing every streamed text chunk on its own line in the chat history.
-Instead, buffer all chunks during streaming and render one final markdown block when the agent finishes.
-
----
-
-## Step 1 — add a state flag
-
-In `__init__`, after the other streaming-related lines, add:
-
-```python
-self._streaming = False
-```
-
-Also reset it in every place that already resets streaming state. For example, in the reset method that sets `_streaming_started = False`, also set:
-
-```python
-self._streaming = False
-```
-
-And in the final cleanup block of `_finish_message`, also set:
-
-```python
-self._streaming = False
-```
-
----
-
-## Step 2 — stop high-frequency live writes
-
-Replace `on_text_chunk`:
-
-- Keep appending to `self._current_response`.
-- Keep updating `self._streaming_started = True`.
-- Remove the call to `_write_streaming_chunk`.
-- Add logic so the first chunk starts a single visual “AGENT:” label.
-
-Example:
-
-```python
-def on_text_chunk(self, chunk: str) -> None:
-    self._current_response.append(chunk)
-    self._streaming_started = True
-    if not self._streaming:
-        self._streaming = True
-        self.call_from_thread(self._start_streaming_label)
-```
-
-Add this new method:
-
-```python
-def _start_streaming_label(self) -> None:
-    log = self.query_one("#history", RichLog)
-    log.write("[bold blue]AGENT:[/]\n")
-```
-
-Remove the old `_write_streaming_chunk` method entirely (or leave it unused if your agent does not delete code).
-
----
-
-## Step 3 — fix the final render
-
-In `_finish_message`:
-
-- Save the flag at the start: `streaming = self._streaming`
-- Then set `self._streaming = False`
-- Only write the `AGENT:` label if we never started streaming
-- Keep the existing markdown rendering logic
-
-Example:
-
-```python
-def _finish_message(self) -> None:
-    self._agent_running = False
-    streaming = self._streaming
-    self._streaming = False
-    try:
-        if self._current_response:
-            response = "".join(self._current_response).lstrip("\n")
-            response = re.sub(r"\n{3,}", "\n\n", response)
-            log = self.query_one("#history", RichLog)
-            if not streaming:
-                log.write("[bold blue]AGENT:[/]\n")
-            log.write(self._render_markdown_to_string(response))
-            log.write("[dim]────────────────────────────────────────────────────[/]\n")
-    except Exception:
-        self._write_error_line("Failed to render agent response.")
-    finally:
-        # reset buffers here
-        ...
-```
-
----
-
-## Step 4 — verify the reset paths
-
-Any place that currently resets `_streaming_started = False` must also reset `self._streaming = False`.
-
-If a reset method exists, update it. If several reset points exist, patch all of them.
-
----
-
-## Rules for the agent
-- Do only the edits above.
-- Do not change CSS or widgets.
-- Do not change markdown rendering in `_render_markdown_to_string`.
-- Do not add extra logs or prints.
-- After editing, the expected behavior is:
-  - One `AGENT:` label per message
-  - Final markdown appears once
-  - Streaming chunks are no longer written one per line