drydock-cli 3.0.113__tar.gz → 3.0.115__tar.gz

{drydock_cli-3.0.113/drydock_cli.egg-info → drydock_cli-3.0.115}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.113
+Version: 3.0.115
 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.113 → drydock_cli-3.0.115}/drydock/agent.py

@@ -33,7 +33,7 @@ def _plan_has_unfinished(config: dict) -> bool:
     todo = config.get("_todo")
     return bool(todo) and any(status != "done" for _, status in todo)
 
-from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry, RepetitionDetected
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -194,24 +194,28 @@ def run(
                     elif isinstance(event, AssistantTurn):
                         assistant_turn = event
                 break  # success
-            except StallRetry:
-                # The call stalled or over-thought past stall_retry_secs. First
-                # retry re-issues as-is (handles a transient server hang cheaply);
-                # if it KEEPS happening it's over-thinking, so escalate to decisive
-                # mode — a forcing suffix + a hard token cap that make a long
-                # reasoning turn impossible. Bounded; on exhaustion end cleanly.
+            except StallRetry as _sr:
+                # Stalled/over-thought past stall_retry_secs (wall-time), OR collapsed
+                # into a pure-repetition loop (RepetitionDetected, content-based). A
+                # first wall-time retry re-issues as-is (a transient hang clears); a
+                # persistent stall OR any repetition loop goes straight to decisive
+                # mode — a forcing suffix + hard token cap that make a long reasoning
+                # turn impossible. Repetition escalates immediately (re-issuing a loop
+                # just loops again). Bounded; on exhaustion end cleanly.
+                is_rep = isinstance(_sr, RepetitionDetected)
                 stall_retries += 1
                 if stall_retries > 3:
-                    yield TextChunk("\n[model kept stalling/over-thinking — giving up on this step.]\n")
+                    yield TextChunk("\n[model kept stalling/looping — giving up on this step.]\n")
                     assistant_turn = None
                     break
-                if stall_retries >= 2 and not decisive:
+                if (is_rep or stall_retries >= 2) and not decisive:
                     decisive = True
                     turn_config = dict(turn_config)
                     cur = int(turn_config.get("max_tokens", 8192) or 8192)
                     turn_config["max_tokens"] = min(cur, _DECISIVE_MAX_TOKENS)
                     turn_config["reasoning_effort"] = "low"
-                    yield TextChunk("\n[taking too long — forcing a decisive, single-action step...]\n")
+                    why = "output looping" if is_rep else "taking too long"
+                    yield TextChunk(f"\n[{why} — forcing a decisive, single-action step...]\n")
                 else:
                     yield TextChunk("\n[model server stalled — retrying...]\n")
                 continue

{drydock_cli-3.0.113 → drydock_cli-3.0.115}/drydock/providers.py

@@ -30,6 +30,14 @@ class StallRetry(Exception):
     abandons the wedged request and re-issues it; a fresh generation usually
     doesn't stall. Opt-in via config `stall_retry_secs` (0 = off)."""
 
+
+class RepetitionDetected(StallRetry):
+    """CONTENT trigger for the over-think interrupt: the model collapsed into a
+    pure-repetition loop (same short unit ×6+, 600+ chars) and produced no usable
+    action. Unlike the wall-time StallRetry this fires on the *content*, so it
+    never trips on productive-but-long reasoning — only genuine spinning. A plain
+    re-issue would just loop again, so the agent goes straight to decisive mode."""
+
 from drydock.loop_detect import runaway_repetition_len
 from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
@@ -540,6 +548,11 @@ def stream(
                     _rep_checked_at = len(text)
                     run = runaway_repetition_len(text)
                     if run:
+                        # With the over-think interrupt on, a genuine loop escalates
+                        # to a decisive retry (recover) instead of returning a
+                        # truncated turn. Otherwise keep the advisory trim+stop.
+                        if stall_secs:
+                            raise RepetitionDetected(0)
                         text = (
                             text[: len(text) - run]
                             + "\n[… output began repeating — stopped by drydock]"
@@ -599,10 +612,6 @@ def _complete_nonstreaming(
     # the generic special-token pass would eat the tool_call markers.
     text, had_leak = strip_leaked_tool_calls(msg.content or "")
     thinking, text = extract_thinking(text)
-    if thinking:
-        yield ReasoningChunk(thinking)
-    if text.strip():
-        yield TextChunk(text)
 
     tool_calls = []
     for i, tc in enumerate(getattr(msg, "tool_calls", None) or []):
@@ -613,6 +622,21 @@ def _complete_nonstreaming(
             "input": inp,
         })
 
+    # Repetition trigger for the over-think interrupt (gated by the same
+    # stall_secs feature). Non-streaming gemma turns are where the over-think
+    # lives; if the turn collapsed into a pure loop and produced NO usable action,
+    # go decisive rather than feeding the garbage turn into the conversation. Only
+    # fires on genuine repetition, so productive-but-long reasoning is never hit.
+    if stall_secs and not tool_calls and (
+        runaway_repetition_len(thinking or "") or runaway_repetition_len(text or "")
+    ):
+        raise RepetitionDetected(0)
+
+    if thinking:
+        yield ReasoningChunk(thinking)
+    if text.strip():
+        yield TextChunk(text)
+
     usage = getattr(resp, "usage", None)
     in_tok = usage.prompt_tokens if usage else 0
     out_tok = usage.completion_tokens if usage else 0

{drydock_cli-3.0.113 → drydock_cli-3.0.115}/drydock/tools/__init__.py

@@ -244,6 +244,22 @@ SCHEMAS = [
             "required": ["path"],
         },
     },
+    {
+        "name": "Screenshot",
+        "description": "CAPTURE the current screen and SEE it with your vision — use "
+                       "when the user asks you to look at their screen, review what's "
+                       "displayed, debug a GUI, or read something shown on screen. Takes "
+                       "the screenshot and shows it to you directly (no need to call "
+                       "ViewImage after). Works on Windows (PowerShell), macOS, and "
+                       "Linux with a display. Optionally pass `path` to also save the PNG.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string",
+                         "description": "Optional file to save the PNG to. Omit to use a temp file."},
+            },
+        },
+    },
     {
         "name": "Write",
         "description": "Write content to a file, creating parent directories as needed.",
@@ -711,6 +727,74 @@ def tool_viewimage(params: dict, config: dict) -> str:
             "to you. Describe it, read any text in it, or use it to answer the task.")
 
 
+def _capture_screen(out: str) -> str | None:
+    """Grab the whole (virtual) screen to PNG `out`. Returns an error string, or
+    None on success. Per-OS: Windows uses PowerShell + System.Drawing; macOS uses
+    screencapture; Linux tries the common grabbers in turn."""
+    import shutil
+    import subprocess
+    try:
+        if _IS_WINDOWS:
+            ps = (
+                "Add-Type -AssemblyName System.Windows.Forms,System.Drawing; "
+                "$s=[System.Windows.Forms.SystemInformation]::VirtualScreen; "
+                "$b=New-Object System.Drawing.Bitmap $s.Width,$s.Height; "
+                "$g=[System.Drawing.Graphics]::FromImage($b); "
+                "$g.CopyFromScreen($s.Left,$s.Top,0,0,$b.Size); "
+                f"$b.Save('{out}',[System.Drawing.Imaging.ImageFormat]::Png); "
+                "$g.Dispose(); $b.Dispose()"
+            )
+            exe = shutil.which("pwsh") or shutil.which("powershell") or "powershell"
+            subprocess.run([exe, "-NoProfile", "-NonInteractive", "-Command", ps],
+                           capture_output=True, timeout=30)
+        elif sys.platform == "darwin":
+            subprocess.run(["screencapture", "-x", out], capture_output=True, timeout=30)
+        else:  # Linux/BSD — try grabbers in order of ubiquity (X11 + wayland)
+            grabbers = (["scrot", "-o", out], ["import", "-window", "root", out],
+                        ["gnome-screenshot", "-f", out], ["grim", out],
+                        ["spectacle", "-b", "-n", "-o", out], ["maim", out])
+            tried = [g[0] for g in grabbers if shutil.which(g[0])]
+            if not tried:
+                return ("no screenshot tool found. Install one of: scrot, imagemagick "
+                        "(import), gnome-screenshot, grim (wayland), spectacle, maim.")
+            for g in grabbers:
+                if shutil.which(g[0]):
+                    subprocess.run(g, capture_output=True, timeout=30)
+                    if os.path.isfile(out) and os.path.getsize(out):
+                        break
+    except subprocess.TimeoutExpired:
+        return "screen capture timed out (30s)."
+    except Exception as e:  # noqa: BLE001 — report, never crash the loop
+        return f"screen capture failed: {e}"
+    return None
+
+
+def tool_screenshot(params: dict, config: dict) -> str:
+    """Capture the screen to a PNG and make it visible to the vision model — the
+    returned absolute path is auto-attached by the API boundary, same as ViewImage."""
+    import tempfile
+
+    raw = _as_str_arg(params.get("path")).strip()
+    out = os.path.abspath(_resolve_path(raw, config) if raw
+                          else os.path.join(tempfile.gettempdir(), "drydock_screenshot.png"))
+    try:
+        if os.path.dirname(out):
+            os.makedirs(os.path.dirname(out), exist_ok=True)
+    except OSError:
+        pass
+    err = _capture_screen(out)
+    if err:
+        return (f"Error: {err} (On a headless server there is no display to capture.)")
+    if not os.path.isfile(out) or not os.path.getsize(out):
+        return "Error: screen capture produced no image (no display, or the grabber failed)."
+    size = os.path.getsize(out)
+    if size > _MAX_VIEW_IMAGE_BYTES:
+        return (f"Captured the screen to {out} but it is {size // 1_000_000}MB — too "
+                "large to view (limit 20MB). The file is saved; open it manually.")
+    return (f"Captured the screen to {out} (PNG, {size // 1024 or 1}KB) — it is now "
+            "visible to you. Describe what's on screen or use it to answer the task.")
+
+
 def tool_read(params: dict, config: dict) -> str:
     fp = _resolve_path(_as_str_arg(params.get("file_path")), config)
     # Reading an image as text yields binary garbage — point at the vision tool.
@@ -1801,6 +1885,7 @@ def tool_build_knowledge(params: dict, config: dict) -> str:
 
 _TOOLS = [
     ("Read", tool_read, True),
+    ("Screenshot", tool_screenshot, True),
     ("Write", tool_write, False),
     ("Edit", tool_edit, False),
     ("Bash", tool_bash, False),
@@ -1829,6 +1914,7 @@ def register_all():
         name = schema["name"]
         func = {
             "Read": tool_read, "ViewImage": tool_viewimage,
+            "Screenshot": tool_screenshot,
             "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
             "todo": tool_todo, "task": tool_task, "Dispatch": tool_dispatch,
@@ -1843,7 +1929,7 @@ def register_all():
         # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
         # GitCommit + GraphAdd write).
         read_only = name in (
-            "Read", "ViewImage", "Glob", "Grep", "task", "Dispatch", "Consult",
+            "Read", "ViewImage", "Screenshot", "Glob", "Grep", "task", "Dispatch", "Consult",
             "Knowledge", "GraphQuery", "StigRules", "StigRule",
             "WebSearch", "WebFetch", "GitStatus", "GitDiff", "GitLog",
         )

{drydock_cli-3.0.113 → drydock_cli-3.0.115/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.113
+Version: 3.0.115
 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.113 → drydock_cli-3.0.115}/drydock_cli.egg-info/SOURCES.txt

@@ -93,10 +93,12 @@ tests/test_plan_autocontinue.py
 tests/test_poam.py
 tests/test_providers_unreachable.py
 tests/test_read_index.py
+tests/test_repetition_interrupt.py
 tests/test_rmf.py
 tests/test_rmf_graph.py
 tests/test_rmf_stig_graph.py
 tests/test_runaway_repetition.py
+tests/test_screenshot.py
 tests/test_server_probe.py
 tests/test_skills.py
 tests/test_stall_retry.py

{drydock_cli-3.0.113 → drydock_cli-3.0.115}/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.113"
+version = "3.0.115"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.115/tests/test_repetition_interrupt.py

@@ -0,0 +1,68 @@
+"""Content-based repetition trigger for the over-think interrupt: a non-streaming
+turn that collapses into a pure loop AND produces no action escalates straight to
+decisive mode. It must NOT fire on varied reasoning, on a turn with a tool call,
+or when the interrupt is disabled (stall_secs=0)."""
+from __future__ import annotations
+
+import pytest
+
+from drydock import agent, providers
+from drydock.providers import AssistantTurn, RepetitionDetected, _complete_nonstreaming
+
+
+class _Fn:
+    def __init__(self, name, args): self.name = name; self.arguments = args
+class _TC:
+    def __init__(self, name, args): self.id = "c1"; self.function = _Fn(name, args)
+class _Msg:
+    def __init__(self, content, tcs=None): self.content = content; self.tool_calls = tcs or []
+class _Choice:
+    def __init__(self, msg): self.message = msg
+class _Resp:
+    def __init__(self, content, tcs=None): self.choices = [_Choice(_Msg(content, tcs))]; self.usage = None
+
+
+def _patch(monkeypatch, content, tcs=None):
+    monkeypatch.setattr(providers, "_create_abortable", lambda *a, **k: _Resp(content, tcs))
+
+
+def test_pure_loop_no_action_raises(monkeypatch):
+    _patch(monkeypatch, "loop " * 300)   # 1500 chars of one unit
+    with pytest.raises(RepetitionDetected):
+        list(_complete_nonstreaming(None, {}, stall_secs=300))
+
+
+def test_varied_reasoning_does_not_raise(monkeypatch):
+    _patch(monkeypatch, "First check the file, then run grep, then write the result and verify it.")
+    out = list(_complete_nonstreaming(None, {}, stall_secs=300))
+    assert any(isinstance(o, AssistantTurn) for o in out)  # completed normally
+
+
+def test_loop_but_has_toolcall_does_not_raise(monkeypatch):
+    _patch(monkeypatch, "loop " * 300, [_TC("Bash", '{"command":"ls"}')])
+    out = list(_complete_nonstreaming(None, {}, stall_secs=300))
+    turn = [o for o in out if isinstance(o, AssistantTurn)][0]
+    assert turn.tool_calls and turn.tool_calls[0]["name"] == "Bash"  # action preserved
+
+
+def test_disabled_when_stall_secs_zero(monkeypatch):
+    _patch(monkeypatch, "loop " * 300)
+    out = list(_complete_nonstreaming(None, {}, stall_secs=0))  # feature off
+    assert any(isinstance(o, AssistantTurn) for o in out)
+
+
+def test_agent_goes_decisive_immediately_on_repetition(monkeypatch):
+    calls = []
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append({"system": system, "max_tokens": config.get("max_tokens")})
+        if len(calls) == 1:
+            raise RepetitionDetected(0)
+        yield AssistantTurn("done", [], 10, 5)
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    st = agent.AgentState()
+    cfg = {"model": "gemma4", "max_tokens": 8192, "stall_retry_secs": 300, "context_limit": 65536}
+    list(agent.run("go", st, cfg, "SYS"))
+    # first call raised repetition → SECOND call is already decisive (no plain retry)
+    assert len(calls) == 2
+    assert agent._DECISIVE_SUFFIX in calls[1]["system"]
+    assert calls[1]["max_tokens"] <= agent._DECISIVE_MAX_TOKENS

drydock_cli-3.0.115/tests/test_screenshot.py

@@ -0,0 +1,59 @@
+"""Screenshot tool: capture the screen to PNG and make it visible to the vision
+model (the returned path auto-attaches, same path as ViewImage). Cross-platform:
+PowerShell on Windows, screencapture on macOS, common grabbers on Linux."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest import mock
+
+from drydock import tools, tool_registry
+from drydock.providers import detect_image_paths
+from drydock.tuning import filter_tool_schemas
+
+
+def test_registered_and_available_to_gemma():
+    names = [s["name"] for s in tool_registry.schemas()]
+    gnames = [s["name"] for s in filter_tool_schemas(tool_registry.schemas(), "gemma4")]
+    assert "Screenshot" in names and "Screenshot" in gnames
+
+
+def test_graceful_when_no_grabber(monkeypatch):
+    monkeypatch.setattr(tools, "_IS_WINDOWS", False)
+    monkeypatch.setattr("sys.platform", "linux")
+    monkeypatch.setattr("shutil.which", lambda _n: None)  # no grabbers installed
+    out = tools.tool_screenshot({}, {"cwd": os.getcwd()})
+    assert out.startswith("Error") and "screenshot tool" in out
+
+
+def test_success_returns_attachable_path():
+    png = tempfile.mktemp(suffix=".png")
+
+    def fake_cap(o):
+        open(o, "wb").write(b"\x89PNG\r\n\x1a\n" + b"\x00" * 200)
+        return None
+
+    with mock.patch.object(tools, "_capture_screen", fake_cap):
+        out = tools.tool_screenshot({"path": png}, {"cwd": os.getcwd()})
+    assert "visible to you" in out
+    assert detect_image_paths(out) == [os.path.abspath(png)]  # auto-attaches
+
+
+def test_windows_builds_powershell_capture():
+    calls = {}
+    with mock.patch.object(tools, "_IS_WINDOWS", True), \
+         mock.patch("shutil.which", side_effect=lambda n: r"C:\pwsh.exe" if n == "pwsh" else None), \
+         mock.patch("subprocess.run", side_effect=lambda a, **k: calls.setdefault("argv", a)):
+        assert tools._capture_screen(r"C:\shot.png") is None
+    argv = calls["argv"]
+    assert argv[0].endswith("pwsh.exe") and argv[1] == "-NoProfile"
+    assert "CopyFromScreen" in argv[-1] and "ImageFormat]::Png" in argv[-1]
+
+
+def test_macos_uses_screencapture(monkeypatch):
+    calls = {}
+    monkeypatch.setattr(tools, "_IS_WINDOWS", False)
+    monkeypatch.setattr("sys.platform", "darwin")
+    monkeypatch.setattr("subprocess.run", lambda a, **k: calls.setdefault("argv", a))
+    tools._capture_screen("/tmp/x.png")
+    assert calls["argv"][0] == "screencapture"