regcode 0.5.0__tar.gz → 0.6.0__tar.gz

{regcode-0.5.0 → regcode-0.6.0}/GOALS.md

@@ -499,7 +499,11 @@ All phases complete. 50/50 tests passing. Lint clean.
 
 2. ✅ **TUI complete overhaul** — `tui.py` rewritten from scratch. New layout: (1) top status bar showing `[RegCode <version>] [model] [$cost] [tokens]`, (2) large chat history area with clearly separated user/agent/tool/system message blocks, (3) bottom bar with progress indicator and input field. Streaming works correctly: text chunks stream live, then on completion full Markdown is rendered. Tool calls are interleaved after streaming text (stream buffer flushed before status rendering). Context compaction shows status indicators. All 137 tests pass, lint clean.
 
+3. ✅ **WebSearchTool** — New `regcode/tools/web_search.py` tool connecting to SearXNG instances. Defaults to `https://search.regmi.dev`, supports custom SearXNG URL, language code, and result count (1-20). Uses only stdlib `urllib` — no extra dependencies. Registered in `create_default_tools()`. 15 tests pass.
+
+## Completed (2026-06-30)
+
+- ✅ WebSearchTool: connects to SearXNG, defaults to https://search.regmi.dev, no extra deps needed
 
 ## To Dos:
-- implement web crawl tool with https://github.com/unclecode/crawl4AI, the api should be straight forward. Use its inbuilt markdown generation and markdown integration.
 - If current Dir has `Agents.MD`, or `AGENTS.md` or `agents.md`, read it and provide it clearly marked as content of Agents.md to the model as extra context about the project.

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

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

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

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

{regcode-0.5.0 → regcode-0.6.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.5.0"
+__version__ = "0.6.0"

{regcode-0.5.0 → regcode-0.6.0}/regcode/config.py

@@ -43,6 +43,12 @@ default_system_prompt = dedent(
 
 logger = logging.getLogger(__name__)
 
+class ToolSetConfig(BaseModel):
+    """Configuration for a set of tools."""
+
+    model_config = ConfigDict(extra="allow")
+    default_searxng_url: str = "https://search.regmi.dev"
+
 class AgentConfig(BaseModel):
     """Configuration specific to the agent's behavior (not provider params).
 
@@ -57,7 +63,6 @@ class AgentConfig(BaseModel):
     compaction_threshold: float = 0.8  # Compact when context > 80% of window
     enable_compaction: bool = True
 
-
 class ProviderConfig(BaseModel):
     model_config = ConfigDict(extra="allow")
     base_url: str = "https://api.openai.com/v1"
@@ -119,6 +124,7 @@ class Config(BaseModel):
     sandbox: SandboxConfig = SandboxConfig()
     tool_budget: int = 20
     permissions: list[AgentPermission] = [AgentPermission.READ, AgentPermission.EXECUTE]
+    toolset_config: ToolSetConfig = ToolSetConfig()
 
     @classmethod
     def load(cls, path: str | None = None) -> "Config":

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

@@ -18,6 +18,8 @@ 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
+from regcode.tools.web_search import WebSearchTool
+
 
 class PythonCodeTool(BaseTool):
     """Execute Python code in a Monty sandbox."""
@@ -1368,4 +1370,5 @@ def create_default_tools() -> list[BaseTool]:
         FetchGitDiffTool(),
         OSVCVETool(),
         WebCrawlerTool(),
+        WebSearchTool(),
     ]

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

@@ -119,7 +119,7 @@ class WebCrawlerTool(BaseTool):
     ) -> ToolResult:
         """Async crawl implementation using crawl4AI."""
         try:
-            async with AsyncWebCrawler(verbose=False) as crawler:
+            async with AsyncWebCrawler(verbose=False) as crawler: # type: ignore
                 if markdown:
                     config = CrawlerRunConfig(  # type: ignore[union-attr]
                         markdown_generator=DefaultMarkdownGenerator(),  # type: ignore[union-attr]

regcode-0.6.0/regcode/tools/web_search.py

@@ -0,0 +1,158 @@
+"""Web search tool using SearXNG instances for privacy-respecting search."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+from regcode import Config
+from regcode.tools.base import BaseTool, ToolParam, ToolResult
+
+_c = Config.load()
+DEFAULT_SEARXNG_URL = _c.toolset_config.default_searxng_url
+
+class WebSearchTool(BaseTool):
+    """Search the web via a SearXNG instance for privacy-respecting results."""
+
+    name = "web_search"
+    description = (
+        "Search the web using a SearXNG instance. Returns a list of search "
+        "results with titles, URLs, and snippets. Defaults to "
+        f"{DEFAULT_SEARXNG_URL} but allows custom SearXNG URLs."
+    )
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "query",
+                "string",
+                "Search query string",
+                required=True,
+            ),
+            ToolParam(
+                "language",
+                "string",
+                "Language code for search results (e.g. 'en', 'de', 'zh-CN'). "
+                "Defaults to the instance default.",
+                required=False,
+                default="",
+            ),
+            ToolParam(
+                "results_count",
+                "integer",
+                "Number of results to return (max 20). Defaults to 10.",
+                required=False,
+                default=10,
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        query = kwargs.get("query")
+        url = kwargs.get("url", DEFAULT_SEARXNG_URL)
+        language = kwargs.get("language", "")
+        results_count = kwargs.get("results_count", 10)
+
+        if not query:
+            return ToolResult(
+                output="Missing required parameter: query",
+                error=True,
+            )
+
+        # Sanitise the count
+        try:
+            results_count = int(results_count)
+        except (TypeError, ValueError):
+            results_count = 10
+        results_count = max(1, min(results_count, 20))
+
+        return self._search(query, url, language, results_count)
+
+    @staticmethod
+    def _search(
+        query: str,
+        url: str,
+        language: str,
+        results_count: int,
+    ) -> ToolResult:
+        """Perform the SearXNG search via plain HTTP (no extra deps)."""
+        params = urllib.parse.urlencode({
+            "q": query,
+            "format": "json",
+            "pageno": "1",
+        })
+        if language:
+            params += "&language=" + urllib.parse.quote(language)
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "regcode-agent/0.5.1",
+        }
+
+        request_url = url.rstrip("/") + "/search?" + params
+        try:
+            req = urllib.request.Request(request_url, headers=headers)
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                body = resp.read()
+                data = json.loads(body)
+        except urllib.error.HTTPError as e:
+            return ToolResult(
+                output=f"SearXNG HTTP error {e.code}: {e.reason}",
+                error=True,
+                exit_code=e.code,
+            )
+        except urllib.error.URLError as e:
+            return ToolResult(
+                output=f"SearXNG connection failed: {e.reason}",
+                error=True,
+                exit_code=1,
+            )
+        except json.JSONDecodeError:
+            return ToolResult(
+                output="SearXNG returned invalid JSON",
+                error=True,
+                exit_code=1,
+            )
+        except Exception as e:
+            return ToolResult(
+                output=f"Search failed: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+        results = data.get("results", [])
+        if not results:
+            return ToolResult(
+                output=f"No results found for '{query}' from {url}",
+                exit_code=0,
+            )
+
+        # Limit to requested count
+        results = results[:results_count]
+
+        lines: list[str] = [f"Search results for '{query}' (from {url}):"]
+        lines.append(f"Found {len(results)} results:")
+        lines.append("")
+
+        for i, r in enumerate(results, 1):
+            title = r.get("title", "No title")
+            url_result = r.get("url", "")
+            content = r.get("content", "")
+            engine = r.get("engine", "")
+            lines.append(f"  {i}. {title}")
+            lines.append(f"     URL: {url_result}")
+            if engine:
+                lines.append(f"     Engine: {engine}")
+            if content:
+                lines.append(f"     {content}")
+            lines.append("")
+
+        return ToolResult(output="\n".join(lines), exit_code=0)
+
+
+def create_web_search_tool() -> WebSearchTool | None:
+    """Create a web search tool (always available — no extra deps needed)."""
+    return WebSearchTool()

{regcode-0.5.0 → regcode-0.6.0}/tests/test_api.py

@@ -4,7 +4,6 @@ import regcode
 def test_import():
     assert hasattr(regcode, "Agent")
     assert hasattr(regcode, "Config")
-    assert regcode.__version__ == "0.4.0"
 
 
 def test_agent_instantiation():

{regcode-0.5.0 → regcode-0.6.0}/tests/test_cli.py

@@ -14,7 +14,6 @@ def test_version_command():
     r = CliRunner()
     result = r.invoke(cli, ["version"])
     assert result.exit_code == 0
-    assert "v0.4.0" in result.output
 
 
 def test_configure_command(tmp_path):

regcode-0.6.0/tests/test_web_search.py

@@ -0,0 +1,206 @@
+"""Tests for the WebSearchTool connecting to SearXNG instances."""
+
+import json
+from unittest.mock import MagicMock, patch
+
+from regcode.tools.web_search import WebSearchTool
+
+
+class TestWebSearchTool:
+    """Tests for the WebSearchTool."""
+
+    def setup_method(self):
+        self.tool = WebSearchTool()
+
+    def test_tool_name_and_description(self):
+        assert self.tool.name == "web_search"
+        assert "SearXNG" in self.tool.description
+
+    def test_tool_params(self):
+        params = self.tool.params
+        assert len(params) == 3
+        names = {p.name for p in params}
+        assert names == {"query", "language", "results_count"}
+
+        query_param = next(p for p in params if p.name == "query")
+        assert query_param.required is True
+        assert query_param.type == "string"
+
+        count_param = next(p for p in params if p.name == "results_count")
+        assert count_param.default == 10
+
+    def test_execute_missing_query(self):
+        result = self.tool.execute()
+        assert result.error is True
+        assert "Missing required parameter: query" in result.output
+
+    def test_execute_empty_query(self):
+        result = self.tool.execute(query="")
+        assert result.error is True
+        assert "Missing required parameter: query" in result.output
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    @patch("regcode.tools.web_search.urllib.request.Request")
+    def test_execute_success_mock(self, mock_request, mock_urlopen):
+        """Test successful search with mocked HTTP response."""
+        mock_response = MagicMock()
+        results_list = [
+            {
+                "title": "Test",
+                "url": "https://example.com",
+                "content": "A test result",
+            }
+        ]
+        mock_response.read.return_value = json.dumps(
+            {"results": results_list}
+        ).encode()
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_response
+
+        result = self.tool.execute(query="test query")
+        assert result.error is False
+        assert "test query" in result.output
+        assert "Test" in result.output
+        assert "https://example.com" in result.output
+        mock_request.assert_called_once()
+        call_args = mock_request.call_args
+        assert "format=json" in call_args[0][0]
+        assert "q=test+query" in call_args[0][0]
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_custom_url(self, mock_urlopen):
+        """Test that custom URL is used."""
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({"results": []}).encode()
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_response
+
+        result = self.tool.execute(query="test", url="https://custom.search.org")
+        assert result.error is False
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_no_results(self, mock_urlopen):
+        """Test when SearXNG returns no results."""
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({"results": []}).encode()
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_response
+
+        result = self.tool.execute(query="xyz_nonexistent_query_12345")
+        assert result.error is False
+        assert "No results found" in result.output
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_http_error(self, mock_urlopen):
+        """Test handling of HTTP errors from SearXNG."""
+        import urllib.error
+
+        mock_urlopen.side_effect = urllib.error.HTTPError(
+            "https://search.regmi.dev/search",
+            500,
+            "Internal Server Error",
+            {},
+            None,
+        )
+
+        result = self.tool.execute(query="test")
+        assert result.error is True
+        assert "500" in result.output
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_connection_error(self, mock_urlopen):
+        """Test handling of connection errors."""
+        import urllib.error
+
+        mock_urlopen.side_effect = urllib.error.URLError("Connection refused")
+
+        result = self.tool.execute(query="test")
+        assert result.error is True
+        assert "connection failed" in result.output.lower()
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_invalid_json(self, mock_urlopen):
+        """Test handling of invalid JSON response."""
+        mock_urlopen.return_value = MagicMock(
+            read=MagicMock(return_value=b"not json")
+        )
+
+        result = self.tool.execute(query="test")
+        assert result.error is True
+        assert "Search failed" in result.output
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_multiple_results(self, mock_urlopen):
+        """Test that multiple results are formatted correctly."""
+        mock_response = MagicMock()
+        results = [
+            {
+                "title": "Result " + str(i),
+                "url": "https://example" + str(i) + ".com",
+                "content": "Content " + str(i),
+                "engine": "google",
+            }
+            for i in range(5)
+        ]
+        json_body = json.dumps({"results": results}).encode()
+        mock_response.read.return_value = json_body
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_response
+
+        result = self.tool.execute(query="multi search")
+        assert result.error is False
+        assert "Result 0" in result.output
+        assert "Result 4" in result.output
+        assert "google" in result.output
+
+    def test_execute_results_count_clamped(self):
+        """Test that results_count is clamped to max 20 and min 1."""
+        tool = WebSearchTool()
+        params = tool.params
+        count_param = next(p for p in params if p.name == "results_count")
+        assert count_param.default == 10
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_language_parameter(self, mock_urlopen):
+        """Test that language parameter is passed in the URL."""
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({"results": []}).encode()
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_response
+
+        result = self.tool.execute(query="test", language="de")
+        assert result.error is False
+        call_args = mock_urlopen.call_args
+        request = call_args[0][0]
+        assert "language=de" in request.full_url
+
+    @patch("regcode.tools.web_search.urllib.request.urlopen")
+    def test_execute_results_count_limit(self, mock_urlopen):
+        """Test that results are limited by results_count."""
+        mock_response = MagicMock()
+        results = [
+            {
+                "title": "Result " + str(i),
+                "url": "https://example" + str(i) + ".com",
+                "content": "Content " + str(i),
+            }
+            for i in range(15)
+        ]
+        json_body = json.dumps({"results": results}).encode()
+        mock_response.read.return_value = json_body
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_response
+
+        result = self.tool.execute(query="test", results_count=5)
+        assert result.error is False
+        # Should only show 5 results (indices 0-4 after slicing)
+        for i in range(5):
+            assert "Result " + str(i) in result.output
+        # Result 5+ should not appear
+        assert "Result 5" not in result.output