drydock-cli 3.0.106__tar.gz → 3.0.108__tar.gz

{drydock_cli-3.0.106/drydock_cli.egg-info → drydock_cli-3.0.108}/PKG-INFO

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

@@ -13,6 +13,20 @@ from typing import Generator
 # stall-loop while letting a long, productive plan run as far as it needs.
 PLAN_CONTINUE_CAP = 3
 
+# Over-think interrupt: when a call keeps stalling/over-thinking (repeated
+# StallRetry), re-issue in "decisive mode" — a forcing suffix + a hard token cap
+# so the model physically cannot burn thousands of reasoning tokens without
+# acting. The model that produced this loop (gemma) generates 5-15 min / 5k+
+# token "thinking" turns that stall_retry alone can't break (tokens flow); this
+# forces a short, single-action turn instead.
+_DECISIVE_MAX_TOKENS = 1500
+_DECISIVE_SUFFIX = (
+    "\n\nURGENT — you have spent too long reasoning without acting. STOP "
+    "analyzing. Your reply must be SHORT and take exactly ONE concrete action "
+    "right now: emit a single tool call (run a command or write a file) with "
+    "little or no explanation. Do NOT lay out a plan; act."
+)
+
 
 def _plan_has_unfinished(config: dict) -> bool:
     """True if the model laid out a `todo` plan that still has non-done items."""
@@ -160,6 +174,7 @@ def run(
         # Stream from LLM — with retry on context-length 400 error
         retries = 0
         stall_retries = 0
+        decisive = False  # over-think interrupt: force a short, single-action turn
         while retries < 2:
             try:
                 available = schemas()
@@ -167,7 +182,7 @@ def run(
                     available = [s for s in available if s.get("name") in allow]
                 for event in stream(
                     model=turn_config["model"],
-                    system=system_prompt,
+                    system=(system_prompt + _DECISIVE_SUFFIX) if decisive else system_prompt,
                     messages=state.messages,
                     tool_schemas=filter_tool_schemas(available, turn_config.get("model")),
                     config=turn_config,
@@ -180,17 +195,25 @@ def run(
                         assistant_turn = event
                 break  # success
             except StallRetry:
-                # The local server hung mid-generation (config stall_retry_secs).
-                # Re-issue the same request — a fresh generation usually isn't
-                # stalled. Bounded so a truly-dead server can't loop forever; on
-                # exhaustion end the turn cleanly. Stalls have their OWN budget,
-                # separate from the context-error `retries`.
+                # 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.
                 stall_retries += 1
                 if stall_retries > 3:
-                    yield TextChunk("\n[model server kept stalling — giving up on this step.]\n")
+                    yield TextChunk("\n[model kept stalling/over-thinking — giving up on this step.]\n")
                     assistant_turn = None
                     break
-                yield TextChunk("\n[model server stalled — retrying...]\n")
+                if 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")
+                else:
+                    yield TextChunk("\n[model server stalled — retrying...]\n")
                 continue
             except Exception as e:
                 err = str(e)

{drydock_cli-3.0.106 → drydock_cli-3.0.108}/drydock/tools/__init__.py

@@ -93,9 +93,32 @@ def _detect_bash() -> str | None:
 
 
 _IS_WINDOWS = os.name == "nt"
-# Resolved once at import (in whatever environment drydock runs — host, the task
-# container, Linux, or Windows). None → bash unavailable, fall back to the
-# platform's default shell (cmd.exe on Windows, /bin/sh on POSIX).
+
+
+def _detect_shell() -> tuple[str, str]:
+    """Pick the shell tool_bash runs commands in — returns (kind, path).
+
+    POSIX → bash (so the model's bash-isms work), else /bin/sh.
+    Windows → PowerShell (what users actually launch drydock in — pwsh, else
+    Windows PowerShell), else cmd.exe. WSL / Git-Bash is NOT required on Windows;
+    if you'd rather use them, install bash and it's picked up on POSIX-like paths.
+    """
+    import shutil
+    if _IS_WINDOWS:
+        for name in ("pwsh", "powershell"):
+            p = shutil.which(name)
+            if p:
+                return ("powershell", p)
+        return ("cmd", shutil.which("cmd") or "cmd.exe")
+    b = _detect_bash()
+    if b:
+        return ("bash", b)
+    return ("sh", shutil.which("sh") or "/bin/sh")
+
+
+# Resolved once at import (in whatever environment drydock runs — Linux/macOS,
+# the task container, or native Windows). _BASH_SHELL kept for back-compat.
+_SHELL_KIND, _SHELL_PATH = _detect_shell()
 _BASH_SHELL = _detect_bash()
 
 
@@ -1040,9 +1063,15 @@ def tool_bash(params: dict, config: dict) -> str:
     # would be called as `bash /c ...` and fail. `[bash, "-c", cmd]` runs the same
     # on Linux and Windows. Without bash, fall back to the platform default shell
     # (cmd.exe on Windows, /bin/sh on POSIX) via shell=True.
-    if _BASH_SHELL:
-        popen_cmd, use_shell = [_BASH_SHELL, "-c", cmd], False
-    else:
+    # Build the invocation for the detected shell. Explicit argv (shell=False)
+    # for bash/PowerShell so it's correct on every OS; shell=True lets the
+    # platform default (/bin/sh on POSIX, cmd.exe on Windows) handle the rest.
+    if _SHELL_KIND == "bash":
+        popen_cmd, use_shell = [_SHELL_PATH, "-c", cmd], False
+    elif _SHELL_KIND == "powershell":
+        popen_cmd, use_shell = [_SHELL_PATH, "-NoProfile", "-NonInteractive",
+                                "-Command", cmd], False
+    else:  # "sh" (POSIX) or "cmd" (Windows) → platform default shell
         popen_cmd, use_shell = cmd, True
     try:
         proc = subprocess.Popen(

{drydock_cli-3.0.106 → drydock_cli-3.0.108}/drydock/tuning.py

@@ -97,6 +97,10 @@ _DEFAULT_SYSTEM_PROMPT = (
     "RUN it and fix failures until it passes before you stop. Prefer acting — write "
     "files and run commands — over long planning; don't produce a big plan without "
     "taking a concrete step.\n"
+    "A script you write must run with ONLY what is already installed — prefer "
+    "the standard library or shelling out to the task's own tools (openssl, git, "
+    "sqlite3); do NOT depend on a package you just pip-installed unless the task "
+    "explicitly says to (the grader runs in a clean environment).\n"
     "You have VISION: when the user references an image file path (.png/.jpg/"
     ".jpeg/.gif/.webp/.bmp on disk — a screenshot, mockup, diagram, or photo), it "
     "is attached and you can SEE it; you can also call the `ViewImage` tool to "
@@ -133,6 +137,10 @@ _GEMMA_SYSTEM_PROMPT = (
     "RUN it and fix failures until it passes before you stop. Prefer acting — write "
     "files and run commands — over long planning; don't produce a big plan without "
     "taking a concrete step.\n"
+    "A script you write must run with ONLY what is already installed — prefer "
+    "the standard library or shelling out to the task's own tools (openssl, git, "
+    "sqlite3); do NOT depend on a package you just pip-installed unless the task "
+    "explicitly says to (the grader runs in a clean environment).\n"
     "You have VISION: when the user's message references an image file path "
     "(.png/.jpg/.jpeg/.gif/.webp/.bmp that exists on disk — a screenshot, mockup, "
     "diagram, or photo), that image is attached and you can SEE it. You can also "
@@ -264,10 +272,36 @@ _DRYDOCK_COMMANDS_HELP = (
 )
 
 
+def _shell_env_note() -> str:
+    """On Windows, tell the model its shell is PowerShell/cmd so it stops
+    emitting bash it can't run. Empty on POSIX (bash is the default assumption)."""
+    import os
+    import shutil
+    if os.name != "nt":
+        return ""
+    if shutil.which("pwsh") or shutil.which("powershell"):
+        return (
+            "\nENVIRONMENT: You are on WINDOWS and the Bash tool runs your commands "
+            "through POWERSHELL, not bash. Use PowerShell / Windows commands: "
+            "Get-ChildItem (ls), Get-Content (cat), Select-String (grep), Copy-Item, "
+            "Move-Item, Remove-Item, New-Item, Test-Path, Where-Object. Many Unix "
+            "aliases (ls, cat, cp, rm, pwd, echo) also work. Do NOT use bash-only "
+            "syntax ([[ ]], <<<, $(...) subshells, grep/sed/awk pipelines) — it "
+            "fails. Use Windows paths (backslashes) and $env:VAR for environment "
+            "variables. Chain commands with ';' (not '&&')."
+        )
+    return (
+        "\nENVIRONMENT: You are on WINDOWS and the Bash tool runs your commands "
+        "through cmd.exe, not bash. Use Windows/cmd commands (dir, type, findstr, "
+        "copy, del, move, mkdir); do NOT use bash syntax. Use backslash paths, "
+        "%VAR% for environment variables, and '&' or '&&' to chain commands."
+    )
+
+
 def system_prompt_for_model(model: str | None) -> str:
     """Return the system prompt best suited to the model."""
     base = _GEMMA_SYSTEM_PROMPT if is_gemma(model) else _DEFAULT_SYSTEM_PROMPT
-    return base + _DRYDOCK_COMMANDS_HELP
+    return base + _DRYDOCK_COMMANDS_HELP + _shell_env_note()
 
 
 def thinking_level_for_turn(turn_count: int, is_user_turn: bool) -> str:

{drydock_cli-3.0.106 → drydock_cli-3.0.108/drydock_cli.egg-info}/PKG-INFO

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

@@ -87,6 +87,7 @@ tests/test_leaked_tool_call.py
 tests/test_loop_detect.py
 tests/test_mcp.py
 tests/test_oneshot_unreachable.py
+tests/test_overthink_interrupt.py
 tests/test_plan_autocontinue.py
 tests/test_poam.py
 tests/test_providers_unreachable.py
@@ -113,5 +114,6 @@ tests/test_tuning.py
 tests/test_viewimage.py
 tests/test_vision_input.py
 tests/test_web_tools.py
+tests/test_windows_shell.py
 tests/test_write_content_coerce.py
 tests/test_xccdf.py

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

drydock_cli-3.0.108/tests/test_overthink_interrupt.py

@@ -0,0 +1,47 @@
+"""Over-think interrupt: when a call keeps stalling/over-thinking (repeated
+StallRetry), the agent escalates to 'decisive mode' — a forcing suffix on the
+system prompt + a hard max_tokens cap — so the model can't burn a 5k-token
+reasoning turn without acting. First retry re-issues as-is; 2nd+ goes decisive."""
+from __future__ import annotations
+
+from drydock import agent
+from drydock.agent import AgentState, _DECISIVE_SUFFIX, _DECISIVE_MAX_TOKENS
+from drydock.providers import StallRetry, AssistantTurn
+
+
+def _drive(monkeypatch, stalls):
+    calls = []
+
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append({"system": system, "max_tokens": config.get("max_tokens"),
+                      "effort": config.get("reasoning_effort")})
+        if len(calls) <= stalls:
+            raise StallRetry(1)
+        yield AssistantTurn(text="done", tool_calls=[], input_tokens=10, output_tokens=5)
+
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    state = AgentState()
+    cfg = {"model": "gemma4", "max_tokens": 8192, "stall_retry_secs": 1, "context_limit": 65536}
+    list(agent.run("do it", state, cfg, "SYS"))
+    return calls
+
+
+def test_first_retry_not_decisive_second_is(monkeypatch):
+    calls = _drive(monkeypatch, stalls=2)   # stall twice, succeed on 3rd
+    assert len(calls) == 3
+    assert _DECISIVE_SUFFIX not in calls[0]["system"]      # attempt 1: as-is
+    assert _DECISIVE_SUFFIX not in calls[1]["system"]      # attempt 2 (retry 1): as-is
+    assert _DECISIVE_SUFFIX in calls[2]["system"]          # attempt 3 (retry 2): decisive
+    assert calls[2]["max_tokens"] <= _DECISIVE_MAX_TOKENS   # hard token cap
+    assert calls[2]["effort"] == "low"
+
+
+def test_gives_up_after_bounded_retries(monkeypatch):
+    # stalls forever → bounded (>3) → ends cleanly, doesn't loop forever
+    calls = _drive(monkeypatch, stalls=99)
+    assert len(calls) <= 5   # 1 initial + up to ~3 retries then give up
+
+
+def test_no_stall_no_decisive(monkeypatch):
+    calls = _drive(monkeypatch, stalls=0)   # succeeds first try
+    assert len(calls) == 1 and _DECISIVE_SUFFIX not in calls[0]["system"]

drydock_cli-3.0.108/tests/test_windows_shell.py

@@ -0,0 +1,67 @@
+"""drydock runs natively on Windows via PowerShell/cmd — no WSL/bash required.
+tool_bash picks the shell (POSIX→bash, Windows→PowerShell else cmd) and builds
+the right invocation; the system prompt tells the model which shell it's on."""
+from __future__ import annotations
+
+import subprocess
+from unittest import mock
+
+import drydock.tools as T
+from drydock import tuning
+
+
+def test_posix_uses_bash():
+    assert T._SHELL_KIND in ("bash", "sh")
+
+
+def test_windows_prefers_powershell():
+    with mock.patch.object(T, "_IS_WINDOWS", True), \
+         mock.patch("shutil.which", side_effect=lambda n: r"C:\ps\pwsh.exe" if n == "pwsh" else None):
+        kind, path = T._detect_shell()
+    assert kind == "powershell" and path.endswith("pwsh.exe")
+
+
+def test_windows_falls_back_to_cmd():
+    with mock.patch.object(T, "_IS_WINDOWS", True), \
+         mock.patch("shutil.which", side_effect=lambda n: r"C:\Windows\System32\cmd.exe" if n == "cmd" else None):
+        kind, _ = T._detect_shell()
+    assert kind == "cmd"
+
+
+def test_powershell_invocation_argv(monkeypatch):
+    """When the shell is PowerShell, Popen is called [pwsh -NoProfile
+    -NonInteractive -Command <cmd>] with shell=False — not shell=True."""
+    seen = {}
+    real = subprocess.Popen
+
+    class FakeProc:
+        stdout = None
+        pid = 1
+        def wait(self): return 0
+        def poll(self): return 0
+    def spy(popen_cmd, *a, **kw):
+        seen["cmd"] = popen_cmd; seen["shell"] = kw.get("shell")
+        raise RuntimeError("stop-after-capture")  # don't actually run pwsh on Linux
+
+    monkeypatch.setattr(T, "_SHELL_KIND", "powershell")
+    monkeypatch.setattr(T, "_SHELL_PATH", r"C:\ps\pwsh.exe")
+    monkeypatch.setattr(subprocess, "Popen", spy)
+    out = T.tool_bash({"command": "Get-ChildItem", "timeout": 5}, {"cwd": "."})
+    assert seen["shell"] is False
+    assert seen["cmd"][:4] == [r"C:\ps\pwsh.exe", "-NoProfile", "-NonInteractive", "-Command"]
+    assert seen["cmd"][4] == "Get-ChildItem"
+
+
+def test_prompt_note_windows_powershell():
+    with mock.patch("os.name", "nt"), \
+         mock.patch("shutil.which", side_effect=lambda n: "x" if n in ("pwsh", "powershell") else None):
+        assert "POWERSHELL" in tuning._shell_env_note()
+
+
+def test_prompt_note_windows_cmd():
+    with mock.patch("os.name", "nt"), mock.patch("shutil.which", return_value=None):
+        assert "cmd.exe" in tuning._shell_env_note()
+
+
+def test_prompt_note_empty_on_posix():
+    assert tuning._shell_env_note() == ""