drydock-cli 3.0.54__tar.gz → 3.0.56__tar.gz

{drydock_cli-3.0.54/drydock_cli.egg-info → drydock_cli-3.0.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.54
+Version: 3.0.56
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.54 → drydock_cli-3.0.56}/drydock/cli.py

@@ -268,6 +268,33 @@ def _first_run_setup(cfg: dict, cfg_path, cfgmod) -> tuple[dict, str]:
     return cfg, f"⚓ Using {model} at {url}"
 
 
+def _connect_mcp(config: dict) -> None:
+    """Start configured MCP servers and register their tools into the registry.
+    Quiet + crash-proof: any failure is logged to config['mcp_log'], never
+    raised. No-op when no mcp.json exists."""
+    import atexit
+
+    from drydock import mcp
+    from drydock.tool_registry import ToolDef, register
+
+    log: list[str] = []
+    try:
+        schemas = mcp.connect_all(config.get("cwd") or os.getcwd(), log=log.append)
+    except Exception as e:  # noqa: BLE001 — never block startup on MCP
+        config["mcp_log"] = [f"MCP init error: {e}"]
+        return
+    for sch in schemas:
+        _, server, tool = sch["name"].split("__", 2)
+        register(ToolDef(
+            name=sch["name"], schema=sch,
+            func=(lambda params, cfg, s=server, t=tool: mcp.call(s, t, params)),
+            read_only=False,
+        ))
+    config["mcp_log"] = log
+    if mcp.connected():
+        atexit.register(mcp.shutdown)
+
+
 def main():
     parser = argparse.ArgumentParser(description="DryDock — local coding agent")
     parser.add_argument(
@@ -349,6 +376,11 @@ def main():
     # call load_project_instructions directly (see run_interactive/run_oneshot).
     config["project_instructions"] = load_project_instructions()
 
+    # Connect any configured MCP servers and register their tools so the model
+    # can call them like native tools. Failures are skipped (never block start);
+    # status is stashed for /mcp. Servers are torn down at exit.
+    _connect_mcp(config)
+
     if args.prompt:
         run_oneshot(args.prompt, config)
     elif args.cli:

drydock_cli-3.0.56/drydock/mcp.py

@@ -0,0 +1,213 @@
+"""MCP (Model Context Protocol) client — connect to MCP servers, expose their
+tools to the agent.
+
+Clean-room, stdlib only (no `mcp` SDK dependency): a minimal JSON-RPC 2.0 client
+over the stdio transport (newline-delimited JSON), which is what local MCP
+servers use. We do the initialize handshake, list the server's tools, and call
+them on demand; results come back as text the model reads like any tool output.
+
+Config (standard mcpServers shape, like Claude Desktop):
+    ~/.drydock/mcp.json   and/or   <cwd>/.drydock/mcp.json
+    {
+      "mcpServers": {
+        "files": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"]},
+        "weather": {"command": "python", "args": ["weather_server.py"], "env": {"KEY": "..."}}
+      }
+    }
+
+Tools are registered as ``mcp__<server>__<tool>``. Everything degrades cleanly:
+a server that fails to start or times out is skipped with a logged note, never
+crashing drydock.
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import threading
+from pathlib import Path
+
+_PROTOCOL_VERSION = "2024-11-05"
+# Live servers for this process, by name. The tool funcs look servers up here.
+_SERVERS: dict[str, "MCPServer"] = {}
+
+
+class MCPError(RuntimeError):
+    pass
+
+
+class MCPServer:
+    """One stdio MCP server subprocess + a synchronous JSON-RPC channel."""
+
+    def __init__(self, name: str, command: str, args: list[str], env: dict | None = None):
+        self.name = name
+        self.command = command
+        self.args = args or []
+        self.env = env or {}
+        self.proc: subprocess.Popen | None = None
+        self.tools: list[dict] = []
+        self._id = 0
+        self._lock = threading.Lock()
+
+    # ── transport ──────────────────────────────────────────────────────────
+    def _send(self, msg: dict) -> None:
+        assert self.proc and self.proc.stdin
+        self.proc.stdin.write(json.dumps(msg) + "\n")
+        self.proc.stdin.flush()
+
+    def _read_result(self, want_id: int, timeout: float = 20.0) -> dict:
+        """Read newline-delimited JSON until the response with want_id arrives.
+        Notifications / other-id messages are skipped. (Requests are serialized
+        under _lock, so responses effectively arrive in order.)"""
+        assert self.proc and self.proc.stdout
+        import time
+        deadline = time.monotonic() + timeout
+        while True:
+            if time.monotonic() > deadline:
+                raise MCPError(f"{self.name}: timed out waiting for response {want_id}")
+            line = self.proc.stdout.readline()
+            if line == "":
+                raise MCPError(f"{self.name}: server closed the connection")
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except ValueError:
+                continue  # stray non-JSON (some servers log to stdout — ignore)
+            if msg.get("id") == want_id:
+                if "error" in msg:
+                    raise MCPError(f"{self.name}: {msg['error'].get('message', msg['error'])}")
+                return msg.get("result", {})
+
+    def _request(self, method: str, params: dict | None = None, timeout: float = 20.0) -> dict:
+        with self._lock:
+            self._id += 1
+            rid = self._id
+            self._send({"jsonrpc": "2.0", "id": rid, "method": method, "params": params or {}})
+            return self._read_result(rid, timeout=timeout)
+
+    def _notify(self, method: str, params: dict | None = None) -> None:
+        with self._lock:
+            self._send({"jsonrpc": "2.0", "method": method, "params": params or {}})
+
+    # ── lifecycle ──────────────────────────────────────────────────────────
+    def start(self, timeout: float = 20.0) -> None:
+        env = {**os.environ, **self.env}
+        self.proc = subprocess.Popen(
+            [self.command, *self.args],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            text=True, env=env, bufsize=1,
+        )
+        self._request("initialize", {
+            "protocolVersion": _PROTOCOL_VERSION,
+            "capabilities": {},
+            "clientInfo": {"name": "drydock", "version": "1"},
+        }, timeout=timeout)
+        self._notify("notifications/initialized")
+        result = self._request("tools/list", {}, timeout=timeout)
+        self.tools = result.get("tools", []) or []
+
+    def call(self, tool: str, arguments: dict, timeout: float = 60.0) -> str:
+        result = self._request("tools/call", {"name": tool, "arguments": arguments or {}},
+                               timeout=timeout)
+        return _content_to_text(result)
+
+    def stop(self) -> None:
+        if self.proc:
+            try:
+                self.proc.terminate()
+            except Exception:  # noqa: BLE001
+                pass
+            self.proc = None
+
+
+def _content_to_text(result: dict) -> str:
+    """Flatten an MCP tools/call result (content blocks) to text."""
+    if not isinstance(result, dict):
+        return str(result)
+    blocks = result.get("content")
+    if isinstance(blocks, list):
+        parts = []
+        for b in blocks:
+            if isinstance(b, dict):
+                if b.get("type") == "text":
+                    parts.append(b.get("text", ""))
+                else:
+                    parts.append(json.dumps(b))
+        text = "\n".join(p for p in parts if p)
+    else:
+        text = json.dumps(result)
+    if result.get("isError"):
+        text = f"[tool reported an error]\n{text}"
+    return text or "(empty result)"
+
+
+# ── config + connection ────────────────────────────────────────────────────
+
+def config_paths(cwd: str) -> list[Path]:
+    return [Path.home() / ".drydock" / "mcp.json", Path(cwd) / ".drydock" / "mcp.json"]
+
+
+def load_config(cwd: str) -> dict:
+    """Merge mcpServers from user + project config (project overrides by name)."""
+    servers: dict[str, dict] = {}
+    for p in config_paths(cwd):
+        if not p.is_file():
+            continue
+        try:
+            data = json.loads(p.read_text("utf-8"))
+        except (OSError, ValueError):
+            continue
+        for name, spec in (data.get("mcpServers") or {}).items():
+            if isinstance(spec, dict) and spec.get("command"):
+                servers[name] = spec
+    return servers
+
+
+def connect_all(cwd: str, *, log=None) -> list[dict]:
+    """Start every configured MCP server and return drydock tool schemas for
+    their tools (namespaced mcp__<server>__<tool>). Failures are skipped."""
+    _say = log or (lambda *_: None)
+    schemas: list[dict] = []
+    for name, spec in load_config(cwd).items():
+        if name in _SERVERS:
+            continue
+        srv = MCPServer(name, spec["command"], spec.get("args") or [], spec.get("env") or {})
+        try:
+            srv.start()
+        except (MCPError, OSError, Exception) as e:  # noqa: BLE001 — never crash startup
+            _say(f"MCP server '{name}' failed to start: {e}")
+            srv.stop()
+            continue
+        _SERVERS[name] = srv
+        for t in srv.tools:
+            schemas.append({
+                "name": f"mcp__{name}__{t['name']}",
+                "description": (t.get("description") or f"{name} tool {t['name']}")[:1024],
+                "input_schema": t.get("inputSchema") or {"type": "object", "properties": {}},
+            })
+        _say(f"MCP server '{name}': {len(srv.tools)} tool(s)")
+    return schemas
+
+
+def call(server: str, tool: str, arguments: dict) -> str:
+    srv = _SERVERS.get(server)
+    if srv is None:
+        return f"MCP server '{server}' is not connected."
+    try:
+        return srv.call(tool, arguments)
+    except MCPError as e:
+        return f"MCP call failed: {e}"
+
+
+def connected() -> dict[str, "MCPServer"]:
+    return dict(_SERVERS)
+
+
+def shutdown() -> None:
+    for srv in _SERVERS.values():
+        srv.stop()
+    _SERVERS.clear()

{drydock_cli-3.0.54 → drydock_cli-3.0.56}/drydock/tools/__init__.py

@@ -41,7 +41,7 @@ def _resolve_path(path: str, config: dict) -> str:
 SCHEMAS = [
     {
         "name": "Read",
-        "description": "Read a file. Returns content with line numbers. Use limit/offset for large files.",
+        "description": "Read a file. Returns content with line numbers. Use limit/offset for large files. A very large file with no limit returns a STRUCTURE INDEX (key symbols + line numbers) instead of the whole file — then Read the ranges you need with offset/limit.",
         "input_schema": {
             "type": "object",
             "properties": {
@@ -303,18 +303,67 @@ SCHEMAS = [
 
 # ── Tool implementations ──────────────────────────────────────────────────
 
+# Above this many lines, a Read with no explicit window returns a structural
+# INDEX (key symbols + line numbers) instead of dumping the file — semantic
+# chunking so a huge file can't blow the context window. The model then Reads
+# the ranges it needs with offset/limit.
+_BIG_FILE_LINES = 1500
+
+# Structural anchors: a definition → a node the model can jump to. Code anchors
+# apply to every file; markdown headers (anchored at column 0 so indented code
+# COMMENTS aren't mistaken for headings) apply only to doc files.
+_CODE_RE = re.compile(
+    r"^\s*("
+    r"(?:async\s+)?def\s+\w+"            # python functions
+    r"|class\s+\w+"                       # python/js/etc classes
+    r"|(?:export\s+)?(?:async\s+)?function\s+\w+"  # js/ts functions
+    r"|(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\("  # js arrow fns
+    r"|func\s+\w+"                        # go
+    r"|fn\s+\w+"                          # rust
+    r")"
+)
+_MD_RE = re.compile(r"^#{1,6}\s+\S")  # markdown headers, column 0 only
+_DOC_EXT = {".md", ".markdown", ".rst", ".txt", ".org"}
+
+
+def _file_index(lines: list[str], fp: str) -> str:
+    """A compact, line-numbered index of a large file's structure."""
+    is_doc = Path(fp).suffix.lower() in _DOC_EXT
+    anchors = [
+        f"  L{i + 1}: {ln.rstrip()[:100]}"
+        for i, ln in enumerate(lines)
+        if _CODE_RE.match(ln) or (is_doc and _MD_RE.match(ln))
+    ]
+    head = (
+        f"{fp} is large ({len(lines)} lines) — showing a STRUCTURE INDEX instead "
+        f"of the whole file (to save context). Read a specific section with "
+        f"offset/limit (e.g. {{\"file_path\": ..., \"offset\": <line-1>, "
+        f"\"limit\": 120}}).\n"
+    )
+    if not anchors:
+        return head + "(no def/class/header anchors found — read ranges with offset/limit.)"
+    body = "\n".join(anchors[:400])
+    if len(anchors) > 400:
+        body += f"\n  [... {len(anchors) - 400} more anchors ...]"
+    return f"{head}\nKey locations ({len(anchors)}):\n{body}"
+
+
 def tool_read(params: dict, config: dict) -> str:
     fp = _resolve_path(params["file_path"], config)
-    limit = params.get("limit", 2000)
+    limit = params.get("limit")  # None = caller didn't specify a window
     offset = params.get("offset", 0)
     try:
         with open(fp, "r", encoding="utf-8", errors="replace") as f:
             lines = f.readlines()
-        selected = lines[offset:offset + limit]
+        # Huge file, no explicit window → index it instead of dumping it.
+        if limit is None and offset == 0 and len(lines) > _BIG_FILE_LINES:
+            return _file_index(lines, fp)
+        eff_limit = 2000 if limit is None else limit
+        selected = lines[offset:offset + eff_limit]
         numbered = [f"{i + offset + 1}\t{line.rstrip()}" for i, line in enumerate(selected)]
         result = "\n".join(numbered)
-        if len(lines) > offset + limit:
-            result += f"\n[... {len(lines) - offset - limit} more lines]"
+        if len(lines) > offset + eff_limit:
+            result += f"\n[... {len(lines) - offset - eff_limit} more lines]"
         return result or "(empty file)"
     except FileNotFoundError:
         return f"Error: file not found: {fp}"

{drydock_cli-3.0.54 → drydock_cli-3.0.56}/drydock/tui/app.py

@@ -494,10 +494,13 @@ class DrydockApp(App):
                 "                   /graphrag build <path> · /graphrag status · /graphrag clear\n"
                 "  /skills          list your reusable /<name> skills\n"
                 "  /loop            /loop <count> <prompt> — repeat a prompt (Esc stops)\n"
+                "  /mcp             list connected MCP servers and their tools\n"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
                 "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
             )
+        elif cmd == "/mcp":
+            self._cmd_mcp()
         elif cmd == "/loop":
             self._cmd_loop(arg)
         elif cmd == "/skills":
@@ -507,6 +510,27 @@ class DrydockApp(App):
         else:
             self._mount(ErrorMessage(f"unknown command: {cmd} (try /help)"))
 
+    def _cmd_mcp(self) -> None:
+        """List connected MCP servers and the tools they expose."""
+        from drydock import mcp
+
+        servers = mcp.connected()
+        lines: list[str] = []
+        if not servers:
+            lines.append(
+                "No MCP servers connected. Configure them in ~/.drydock/mcp.json "
+                "(or <project>/.drydock/mcp.json) under \"mcpServers\", then restart."
+            )
+        else:
+            lines.append(f"MCP servers ({len(servers)} connected):")
+            for name, srv in servers.items():
+                tools = ", ".join(t["name"] for t in srv.tools) or "(no tools)"
+                lines.append(f"  • {name}: {tools}")
+            lines.append("Call them as mcp__<server>__<tool> (the model does this automatically).")
+        for msg in self.config.get("mcp_log") or []:
+            lines.append(f"  · {msg}")
+        self._info("\n".join(lines))
+
     def _cmd_loop(self, arg: str) -> None:
         """/loop <count> <prompt> — run <prompt> up to <count> times (1–50),
         re-submitting after each turn finishes. Esc (or /stop) ends the loop."""

{drydock_cli-3.0.54 → drydock_cli-3.0.56}/drydock/tui/widgets.py

@@ -153,7 +153,7 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/graphrag", "/skills", "/loop", "/clear", "/quit",
+    "/compact", "/graphrag", "/skills", "/loop", "/mcp", "/clear", "/quit",
 ]
 
 

{drydock_cli-3.0.54 → drydock_cli-3.0.56/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.54
+Version: 3.0.56
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.54 → drydock_cli-3.0.56}/drydock_cli.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ drydock/gittools.py
 drydock/graphrag.py
 drydock/guards.py
 drydock/loop_detect.py
+drydock/mcp.py
 drydock/providers.py
 drydock/skills.py
 drydock/tool_registry.py
@@ -53,9 +54,11 @@ tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py
 tests/test_leaked_tool_call.py
 tests/test_loop_detect.py
+tests/test_mcp.py
 tests/test_oneshot_unreachable.py
 tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py
+tests/test_read_index.py
 tests/test_runaway_repetition.py
 tests/test_skills.py
 tests/test_stop.py

{drydock_cli-3.0.54 → drydock_cli-3.0.56}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.54"
+version = "3.0.56"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.56/tests/test_mcp.py

@@ -0,0 +1,57 @@
+"""MCP client: connect to a stdio MCP server, list + call its tools. Uses a real
+(mock) server subprocess so the JSON-RPC handshake is exercised end to end."""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from drydock import mcp
+
+_SERVER = str(Path(__file__).parent / "fixtures" / "mock_mcp_server.py")
+
+
+def _write_cfg(cwd: Path):
+    d = cwd / ".drydock"
+    d.mkdir(parents=True, exist_ok=True)
+    (d / "mcp.json").write_text(json.dumps({
+        "mcpServers": {"mock": {"command": sys.executable, "args": [_SERVER]}}
+    }))
+
+
+def teardown_function(_):
+    mcp.shutdown()
+
+
+def test_connect_lists_tools(tmp_path):
+    _write_cfg(tmp_path)
+    schemas = mcp.connect_all(str(tmp_path))
+    names = [s["name"] for s in schemas]
+    assert "mcp__mock__echo" in names
+    assert mcp.connected()["mock"].tools[0]["name"] == "echo"
+
+
+def test_call_tool_round_trips(tmp_path):
+    _write_cfg(tmp_path)
+    mcp.connect_all(str(tmp_path))
+    out = mcp.call("mock", "echo", {"text": "hello mcp"})
+    assert out == "echo: hello mcp"
+
+
+def test_call_unknown_server_is_graceful(tmp_path):
+    assert "not connected" in mcp.call("nope", "echo", {"text": "x"})
+
+
+def test_missing_config_is_noop(tmp_path):
+    assert mcp.connect_all(str(tmp_path)) == []
+
+
+def test_bad_server_is_skipped(tmp_path):
+    d = tmp_path / ".drydock"; d.mkdir(parents=True)
+    (d / "mcp.json").write_text(json.dumps({
+        "mcpServers": {"broken": {"command": "this_command_does_not_exist_xyz", "args": []}}
+    }))
+    logs = []
+    schemas = mcp.connect_all(str(tmp_path), log=logs.append)
+    assert schemas == []
+    assert any("failed to start" in m for m in logs)

drydock_cli-3.0.56/tests/test_read_index.py

@@ -0,0 +1,52 @@
+"""Semantic chunking: Read returns a STRUCTURE INDEX for a huge file (no
+explicit window) instead of dumping it, so it can't blow the context window."""
+from __future__ import annotations
+
+from drydock.tools import tool_read
+
+
+def _big_py(tmp_path, n=2000):
+    lines = []
+    for i in range(n):
+        if i % 400 == 0:
+            lines.append(f"def func_{i}(x):")
+        elif i % 400 == 1:
+            lines.append("    return x")
+        else:
+            lines.append(f"    # comment {i}")
+    (tmp_path / "big.py").write_text("\n".join(lines))
+    return {"cwd": str(tmp_path)}
+
+
+def test_huge_file_no_window_returns_index(tmp_path):
+    cfg = _big_py(tmp_path)
+    out = tool_read({"file_path": "big.py"}, cfg)
+    assert "STRUCTURE INDEX" in out
+    assert "def func_0" in out and "def func_400" in out
+    assert "# comment" not in out  # comments are not anchors
+
+
+def test_index_is_small_not_a_dump(tmp_path):
+    cfg = _big_py(tmp_path)
+    out = tool_read({"file_path": "big.py"}, cfg)
+    assert len(out.splitlines()) < 50  # an index, not 2000 lines
+
+
+def test_explicit_window_still_reads_slice(tmp_path):
+    cfg = _big_py(tmp_path)
+    out = tool_read({"file_path": "big.py", "offset": 0, "limit": 3}, cfg)
+    assert "STRUCTURE INDEX" not in out
+    assert out.startswith("1\tdef func_0")
+
+
+def test_small_file_reads_fully(tmp_path):
+    (tmp_path / "s.py").write_text("def a():\n    return 1\n")
+    out = tool_read({"file_path": "s.py"}, {"cwd": str(tmp_path)})
+    assert "STRUCTURE INDEX" not in out and "def a()" in out
+
+
+def test_markdown_headers_indexed(tmp_path):
+    body = "\n".join(["# Title"] + [f"para {i}" for i in range(2000)] + ["## Section B"])
+    (tmp_path / "doc.md").write_text(body)
+    out = tool_read({"file_path": "doc.md"}, {"cwd": str(tmp_path)})
+    assert "STRUCTURE INDEX" in out and "# Title" in out and "## Section B" in out