regcode 0.9.0__tar.gz → 0.10.0__tar.gz

{regcode-0.9.0 → regcode-0.10.0}/GOALS.md

@@ -505,6 +505,45 @@ All phases complete. 50/50 tests passing. Lint clean.
 
 - ✅ WebSearchTool: connects to SearXNG, defaults to https://search.regmi.dev, no extra deps needed
 
+## MCP Support (2026-07-05)
+
+- ✅ `mcp` package added to `pyproject.toml` dependencies
+- ✅ `McpServerConfig` Pydantic model in `regcode/config.py` — supports both stdio (command+args+env) and HTTP (url+headers) transports, with per-tool timeout
+- ✅ `regcode/mcp_client.py` — MCP client with two transport strategies:
+  • **stdio** — uses MCP library's `stdio_client` for command-based servers (npx, uvx)
+  • **HTTP blocking JSON-RPC** — uses `httpx.Client` directly for servers that return 200 OK with JSON body (not 202 + SSE). Supports session-ID propagation via `mcp-session-id` header, credential injection via custom headers.
+  • Discovers tools via `tools/list` JSON-RPC call, registers them into Agent's `ToolRegistry` with `mcp_{server}_{tool}` naming
+  • Credential redaction in error messages
+- ✅ `Agent.__init__` calls `_discover_mcp_tools()` at startup — reads `mcp_servers` from config, connects to each server, registers tools. Gracefully skips if `mcp` package not installed or connection fails.
+- ✅ `Agent.reload_mcp()` method — hot-reloads MCP connections (closes old, discovers new) without restart
+- ✅ `Agent._mcp_status()` — returns formatted text showing all MCP servers, their status, and discovered tools
+- ✅ `Agent.cleanup()` includes MCP session close
+- ✅ `McpClient.get_server_info()` — returns introspection data for all configured servers (name, transport, connected status, error, tool list with params)
+- ✅ `/mcp` slash command in TUI — lists all configured MCP servers, shows connection status, enumerates discovered tools with descriptions and parameters
+- ✅ CLI `configure` command generates `mcp_servers` section in config.yaml (interactive prompt for stdio/HTTP servers)
+- ✅ `config.yaml.template` includes commented MCP server examples for stdio (npx, uvx) and HTTP transport
+- ✅ 31 MCP config tests: `TestMcpServerConfig`, `TestConfigMcpServers`, `TestSanitizeName`, `TestRedactCredentials`, `TestMcpClientAgentIntegration`, `TestMcpClientConnectAll`
+- ✅ 7 MCP status tests: `test_get_server_info_*`, `test_mcp_status_format*`
+- ✅ All 231 tests pass, lint clean
+
+Example config.yaml MCP section:
+```yaml
+mcp_servers:
+  github:
+    command: npx
+    args: ["-y", "@modelcontextprotocol/server-github"]
+    env:
+      GITHUB_TOKEN: ghp_xxxxx
+    timeout: 60
+  filesystem:
+    command: uvx
+    args: ["mcp-server-filesystem", "/tmp"]
+  remote_api:
+    url: https://mcp.example.com/v1/mcp
+    headers:
+      Authorization: Bearer sk-xxxxx
+```
+
 ## Completed (2026-06-30 — TUI fixes)
 
 1. ✅ AGENTS.md injection — Agent now reads AGENTS.md/agents.md from CWD or allowed directory and injects it into system prompt (both `_build_system_prompt` and `_build_system_prompt_no_tools`). Appended after base system_prompt, before tool descriptions.

{regcode-0.9.0 → regcode-0.10.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.9.0
+Version: 0.10.0
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
 Requires-Dist: boto3>=1.43.40
 Requires-Dist: click>=8.0
 Requires-Dist: crawl4ai>=0.4.0
 Requires-Dist: litellm>=1.83.17
+Requires-Dist: mcp>=1.0.0
 Requires-Dist: mlflow>=3.14.0
 Requires-Dist: pathspec>=1.1.1
 Requires-Dist: pydantic-monty>=0.0.18

regcode-0.10.0/config.yaml.template

@@ -0,0 +1,56 @@
+agent:
+  # Context window management
+  enable_compaction: true
+  compaction_threshold: 0.8
+  context_window: 128000
+
+provider:
+  api_key: "${OPENAI_API_KEY}"
+  model: "openai/gpt-4o"
+  max_tokens: 4096
+  temperature: 0.7
+
+# ── MCP Servers (optional) ──────────────────────────────────────
+#
+# Add MCP servers to extend the agent with external tools.
+# The agent connects on startup, discovers available tools,
+# and registers them as `mcp_{server}_{tool_name}`.
+#
+# Two transport types are supported:
+#
+# 1. Stdio (command-based, e.g. npx, uvx):
+#      command  — executable to run
+#      args     — arguments passed to the command
+#      env      — environment variables (only these are passed,
+#                 NOT the full shell environment)
+#
+# 2. HTTP (StreamableHTTP URL):
+#      url      — server endpoint
+#      headers  — HTTP headers sent with each request
+#
+# Example:
+
+mcp_servers:
+  # GitHub server — uses npx to run the official MCP server
+  #github:
+  #  command: "npx"
+  #  args: ["-y", "@modelcontextprotocol/server-github"]
+  #  env:
+  #    GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_TOKEN}"
+  #  timeout: 60
+
+  # Filesystem server — lets the agent read/write arbitrary files
+  # filesystem:
+  #  command: "uvx"
+  #  args: ["mcp-server-filesystem", "/tmp"]
+
+  # Remote HTTP server
+  # remote_api:
+  #   url: "https://mcp.example.com/v1/mcp"
+  #   headers:
+  #     Authorization: "Bearer ${MCP_API_KEY}"
+
+tools:
+  code_review: true
+  security_scan: false
+  sandbox: false

{regcode-0.9.0 → regcode-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regcode"
-version = "0.9.0"
+version = "0.10.0"
 description = "Minimalistic coding agent with Python API and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,6 +18,7 @@ dependencies = [
     "pathspec>=1.1.1",
     "pyperclip>=1.9.0",
     "boto3>=1.43.40",
+    "mcp>=1.0.0",
 ]
 
 [project.scripts]

{regcode-0.9.0 → regcode-0.10.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.9.0"
+__version__ = "0.10.0"

{regcode-0.9.0 → regcode-0.10.0}/regcode/cli.py

@@ -139,8 +139,84 @@ def configure(output_path):
     else:
         click.echo("  Using default provider settings.")
 
+    # --- MCP servers config ---
+    yes = _confirm("Configure MCP servers? (optional)")
+    if yes:
+        mcp_section: dict[str, dict] = {}
+        while True:
+            server_name = click.prompt(
+                "Server name (e.g. github, filesystem)",
+                default="",
+            )
+            if not server_name:
+                break
+
+            transport = click.prompt(
+                "Transport type",
+                type=click.Choice(["stdio", "http"]),
+                default="stdio",
+            )
+
+            if transport == "stdio":
+                command = click.prompt("Command (e.g. npx, uvx)")
+                args_str = click.prompt(
+                    "Arguments (comma-separated, e.g. -y,package-name)",
+                    default="",
+                )
+                args = [
+                    a.strip()
+                    for a in args_str.split(",")
+                    if a.strip()
+                ] if args_str else []
+
+                env_str = click.prompt(
+                    "Environment variables (KEY=VALUE lines, empty to skip)",
+                    default="",
+                )
+                env = {}
+                for line in env_str.splitlines():
+                    line = line.strip()
+                    if line and "=" in line:
+                        k, v = line.split("=", 1)
+                        env[k.strip()] = v.strip()
+
+                mcp_section[server_name] = {
+                    "command": command,
+                    "args": args,
+                    "env": env if env else None,
+                }
+            else:
+                url = click.prompt("Server URL (e.g. https://example.com/mcp)")
+                headers_str = click.prompt(
+                    "Headers (KEY=VALUE lines, empty to skip)",
+                    default="",
+                )
+                headers = {}
+                for line in headers_str.splitlines():
+                    line = line.strip()
+                    if line and "=" in line:
+                        k, v = line.split("=", 1)
+                        headers[k.strip()] = v.strip()
+
+                mcp_section[server_name] = {
+                    "url": url,
+                    "headers": headers if headers else None,
+                }
+
+        if mcp_section:
+            from regcode.config import McpServerConfig
+
+            config.mcp_servers = {
+                name: McpServerConfig.model_validate(
+                    {k: v for k, v in cfg.items() if v is not None}
+                )
+                for name, cfg in mcp_section.items()
+            }
+    else:
+        click.echo("  Using default MCP settings (no servers).")
+
     # --- Write config.yaml ---
-    data = {
+    data: dict = {
         "agent": {
             "context_window": config.agent.context_window,
             "compaction_threshold": config.agent.compaction_threshold,
@@ -157,6 +233,13 @@ def configure(output_path):
         "tool_budget": config.tool_budget,
     }
 
+    # Add MCP servers section if configured
+    if hasattr(config, "mcp_servers") and config.mcp_servers:
+        data["mcp_servers"] = {
+            name: cfg.model_dump(exclude_none=True)
+            for name, cfg in config.mcp_servers.items()
+        }
+
     with open(output_path, "w") as f:
         yaml.dump(data, f, default_flow_style=False)
     click.echo(f"\nconfig.yaml written to {output_path}")

{regcode-0.9.0 → regcode-0.10.0}/regcode/config.py

@@ -38,11 +38,46 @@ default_system_prompt = dedent(
     Start directly with your review content. Do not address user or
     use fillers like "Now I have enough information to provide a review." or
     "Here is my review:"
+
+    ## Code implementation
+    If you are asked to implement code, do what a responsible developer would do:
+    - researh what library versions are used
+    - if library versions are newer than your knowledge cutoff, research first.
+    - write code
+    - check if tests exist. Always write tests for your code if they don't exist.
+    - Make sure to comply to users coding pattern and style.
     """
 )
 
 logger = logging.getLogger(__name__)
 
+class McpServerConfig(BaseModel):
+    """Configuration for a single MCP server.
+
+    Supports two transport types:
+    - Stdio: command-based (npx, uvx, or any executable)
+    - HTTP: URL-based (StreamableHTTP)
+
+    Exactly one of ``command`` or ``url`` must be provided.
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    # Stdio transport
+    command: str | None = None
+    args: list[str] = []
+    env: dict[str, str] = {}
+    connect_timeout: int = 60
+
+    # HTTP transport
+    url: str | None = None
+    headers: dict[str, str] = {}
+    connect_timeout_http: int = 60
+
+    # Per-tool-call timeout
+    timeout: int = 120
+
+
 class ToolSetConfig(BaseModel):
     """Configuration for a set of tools."""
 
@@ -126,6 +161,7 @@ class Config(BaseModel):
     permissions: list[AgentPermission] = [AgentPermission.READ, AgentPermission.EXECUTE]
     toolset_config: ToolSetConfig = ToolSetConfig()
     debug_mode: bool = False
+    mcp_servers: dict[str, McpServerConfig] = {}
 
     @classmethod
     def load(cls, path: str | None = None) -> "Config":

{regcode-0.9.0 → regcode-0.10.0}/regcode/main.py

@@ -121,6 +121,16 @@ class Agent:
         for tool in create_default_tools():
             self.registry.register(tool)
 
+        # Discover and register MCP tools
+        self._mcp_client = None
+        mcp_results = self._discover_mcp_tools()
+        if mcp_results:
+            logger.info(
+                "MCP discovery complete: %d servers, %d tools",
+                len(mcp_results),
+                sum(len(t) for t in mcp_results.values()),
+            )
+
         # Apply permission filtering after tools are registered
         self._filter_tools_by_permissions()
 
@@ -135,6 +145,105 @@ class Agent:
             if not has_all:
                 self.registry.disable_tool(tool_name)
 
+    def _discover_mcp_tools(self) -> dict[str, list[str]]:
+        """Discover and register MCP tools from configured servers.
+
+        Reads ``mcp_servers`` from config, connects to each server,
+        discovers available tools, and registers them into the agent's
+        tool registry with the prefix ``mcp_{server}_{tool}``.
+
+        Returns a dict mapping server name → list of registered tool names.
+        """
+        if not self.config.mcp_servers:
+            return {}
+
+        from regcode.mcp_client import McpClient
+
+        try:
+            self._mcp_client = McpClient(
+                mcp_servers_config={
+                    name: cfg.model_dump(exclude_none=True)
+                    for name, cfg in self.config.mcp_servers.items()
+                },
+                registry=self.registry,
+            )
+            results = self._mcp_client.connect_all()
+            return results
+        except Exception:
+            logger.error(
+                "MCP discovery failed: %s",
+                sys.exc_info()[1],
+                exc_info=True,
+            )
+            return {}
+
+    def reload_mcp(self) -> dict[str, list[str]]:
+        """Reload MCP servers and re-register their tools.
+
+        Closes any existing connections, discovers new tools, and
+        registers them into the registry. Useful after changing
+        ``mcp_servers`` in config without restarting the agent.
+
+        Returns a dict mapping server name → list of registered tool names.
+        """
+        # Close existing connections
+        if self._mcp_client is not None:
+            self._mcp_client.close()
+            self._mcp_client = None
+
+        return self._discover_mcp_tools()
+
+    def _mcp_status(self) -> str:
+        """Return formatted text showing all MCP servers and their tools.
+
+        Used by the /mcp slash command for debugging and visibility.
+        """
+        if self._mcp_client is None:
+            return "No MCP servers configured."
+
+        servers = self._mcp_client.get_server_info()
+
+        if not servers:
+            return "No MCP servers configured."
+
+        lines = ["═══ MCP Servers ═══"]
+
+        for server in servers:
+            if server["connected"]:
+                status = "[green]connected[/]"
+            else:
+                status = f"[red]{server['error']}[/]"
+            transport = server["transport"]
+            name = server["name"]
+            lines.append(
+                f"\n  [bold]{name}[/] "
+                f"— transport: {transport}, status: {status}"
+            )
+
+            if server["tools"]:
+                for tool in server["tools"]:
+                    lines.append(f"    • {tool['name']}")
+                    desc = tool.get("description", "")
+                    if desc:
+                        # Truncate long descriptions
+                        if len(desc) > 80:
+                            desc = desc[:77] + "..."
+                        lines.append(f"      {desc}")
+                    if tool.get("params"):
+                        for p in tool["params"]:
+                            pdef = f"{p['name']} ({p['type']})"
+                            if p.get("description"):
+                                if len(p["description"]) > 60:
+                                    pdef += f" — {p['description'][:57]}..."
+                                else:
+                                    pdef += f" — {p['description']}"
+                            lines.append(f"      └─ {pdef}")
+            else:
+                lines.append("    (no tools discovered)")
+
+        lines.append("")
+        return "\n".join(lines)
+
     def _format_tool_descriptions(self) -> str:
         """Format tool definitions for inclusion in system prompts.
 
@@ -1304,8 +1413,10 @@ class Agent:
         )
 
     def cleanup(self) -> None:
-        """Clean up sandbox resources."""
+        """Clean up sandbox and MCP resources."""
         self.sandbox.cleanup()
+        if self._mcp_client is not None:
+            self._mcp_client.close()
 
     def __enter__(self) -> "Agent":
         """Enter context manager."""