regcode 0.4.0__tar.gz → 0.4.1__tar.gz

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

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

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

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

{regcode-0.4.0 → regcode-0.4.1}/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.4.1"

{regcode-0.4.0 → regcode-0.4.1}/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.4.1/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.4.1}/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.4.1}/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.4.1}/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.1/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.4.1}/uv.lock

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