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

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

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

@@ -19,7 +19,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
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -159,6 +159,7 @@ def run(
 
         # Stream from LLM — with retry on context-length 400 error
         retries = 0
+        stall_retries = 0
         while retries < 2:
             try:
                 available = schemas()
@@ -178,6 +179,19 @@ def run(
                     elif isinstance(event, AssistantTurn):
                         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`.
+                stall_retries += 1
+                if stall_retries > 3:
+                    yield TextChunk("\n[model server kept stalling — giving up on this step.]\n")
+                    assistant_turn = None
+                    break
+                yield TextChunk("\n[model server stalled — retrying...]\n")
+                continue
             except Exception as e:
                 err = str(e)
                 if is_context_length_error(err):

{drydock_cli-3.0.104 → drydock_cli-3.0.106}/drydock/config.py

@@ -34,6 +34,11 @@ DEFAULTS: dict[str, object] = {
     # real window BEFORE compacting (the server 400s) — set this to your -c
     # value. Default 65536 matches the bundled gemma4 server (-c 65536).
     "context_limit": 65536,
+    # Auto-retry a hung model call: if the server produces NOTHING for this many
+    # seconds, drydock abandons the wedged request and re-issues it (a fresh
+    # generation usually isn't stalled — a known gemma/llama.cpp hang). 0 = off.
+    # Set to e.g. 600 on a stall-prone local server. Bounded to a few retries.
+    "stall_retry_secs": 0,
     "theme": "harbor",
     # Optional SECOND model ("advisor") for a stronger second opinion — e.g. a
     # Gemini OpenAI-compatible endpoint on another box. Empty = disabled. The

{drydock_cli-3.0.104 → drydock_cli-3.0.106}/drydock/providers.py

@@ -23,6 +23,13 @@ _LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_pre
 class _StopRequested(Exception):
     """Internal: STOP was pressed during a blocking LLM call."""
 
+
+class StallRetry(Exception):
+    """The model server produced no progress for `stall_retry_secs` — the local
+    server has hung mid-generation (a known gemma/llama.cpp failure). The agent
+    abandons the wedged request and re-issues it; a fresh generation usually
+    doesn't stall. Opt-in via config `stall_retry_secs` (0 = off)."""
+
 from drydock.loop_detect import runaway_repetition_len
 from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
@@ -138,19 +145,26 @@ def _safe_create(client, kwargs: dict, base_url: str, provider: str, timeout_s:
 
 
 def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel,
-                      timeout_s: float = 600.0):
+                      timeout_s: float = 600.0, stall_secs: float = 0.0):
     """Like _safe_create, but runs off-thread and polls a cancel Event so STOP
     can abandon a blocked decode (raising _StopRequested). The orphaned request
-    runs to completion in the pool thread and its result is dropped."""
+    runs to completion in the pool thread and its result is dropped.
+
+    If stall_secs > 0 and the request produces nothing in that long, raise
+    StallRetry so the caller can abandon a hung server and re-issue."""
     import openai
+    import time as _time
 
     fut = _LLM_POOL.submit(client.chat.completions.create, **kwargs)
+    start = _time.monotonic()
     while True:
         try:
             return fut.result(timeout=0.2)
         except concurrent.futures.TimeoutError:
             if cancel is not None and cancel.is_set():
                 raise _StopRequested
+            if stall_secs and (_time.monotonic() - start) > stall_secs:
+                raise StallRetry(stall_secs)  # orphan the wedged request; caller retries
         # APITimeoutError subclasses APIConnectionError — catch it FIRST.
         except openai.APITimeoutError as e:
             raise LLMUnreachable(_friendly_timeout(base_url, timeout_s)) from e
@@ -158,12 +172,17 @@ def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel
             raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
 
 
-def _stream_chunks(response, cancel):
+def _stream_chunks(response, cancel, stall_secs: float = 0.0):
     """Yield streamed chunks, but pull them via a background thread + queue so a
     STOP can abandon a read that's blocked waiting for the first token (the
     thinking phase). On cancel we just stop reading; the orphaned producer
-    drains in the background."""
+    drains in the background.
+
+    If stall_secs > 0 and no chunk arrives for that long, raise StallRetry — a
+    hung server. (A slow-but-alive stream still emits chunks, which reset the
+    timer, so this fires only on a true stall.)"""
     import queue as _queue
+    import time as _time
 
     q: _queue.Queue = _queue.Queue()
     _DONE = object()
@@ -178,13 +197,17 @@ def _stream_chunks(response, cancel):
             q.put(_DONE)
 
     _LLM_POOL.submit(_produce)
+    last = _time.monotonic()
     while True:
         if cancel is not None and cancel.is_set():
             return
         try:
             item = q.get(timeout=0.2)
         except _queue.Empty:
+            if stall_secs and (_time.monotonic() - last) > stall_secs:
+                raise StallRetry(stall_secs)
             continue
+        last = _time.monotonic()
         if item is _DONE:
             return
         if isinstance(item, Exception):
@@ -410,6 +433,10 @@ def stream(
         read_timeout = float(config.get("request_timeout") or 1800.0)
     except (TypeError, ValueError):
         read_timeout = 1800.0
+    try:
+        stall_secs = float(config.get("stall_retry_secs") or 0)  # 0 = disabled
+    except (TypeError, ValueError):
+        stall_secs = 0.0
     client = OpenAI(
         api_key=api_key,
         base_url=base_url,
@@ -461,7 +488,7 @@ def stream(
         # streaming. If STOP closes the client mid-call the blocking request
         # raises — swallow that as a clean cancel rather than an error.
         try:
-            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel, read_timeout)
+            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel, read_timeout, stall_secs)
         except _StopRequested:
             return  # STOP — abandon the in-flight request, clean stop
         except Exception:
@@ -482,11 +509,11 @@ def stream(
     _rep_checked_at = 0
 
     try:
-        response = _create_abortable(client, kwargs, base_url, provider, cancel, read_timeout)
+        response = _create_abortable(client, kwargs, base_url, provider, cancel, read_timeout, stall_secs)
     except _StopRequested:
         config.get("_abort", {}).pop("client", None)
         return
-    for chunk in _stream_chunks(response, cancel):
+    for chunk in _stream_chunks(response, cancel, stall_secs):
         if not chunk.choices:
             if hasattr(chunk, "usage") and chunk.usage:
                 in_tok = chunk.usage.prompt_tokens or in_tok
@@ -557,13 +584,13 @@ def stream(
 
 def _complete_nonstreaming(
     client, kwargs: dict, base_url: str = "", provider: str = "", cancel=None,
-    timeout_s: float = 600.0,
+    timeout_s: float = 600.0, stall_secs: float = 0.0,
 ) -> Generator:
     """Single non-streaming completion. Yields one TextChunk (if any text)
     then the AssistantTurn. Used when streaming would corrupt tool-call JSON.
     Runs off-thread so STOP can abandon a blocked decode.
     """
-    resp = _create_abortable(client, kwargs, base_url, provider, cancel, timeout_s)
+    resp = _create_abortable(client, kwargs, base_url, provider, cancel, timeout_s, stall_secs)
     choice = resp.choices[0]
     msg = choice.message
 

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

@@ -82,14 +82,20 @@ def _detect_bash() -> str | None:
     found = shutil.which("bash")
     if found:
         return found
-    for p in ("/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash"):
+    # Common absolute locations, incl. Git-for-Windows and WSL bash on Windows.
+    for p in ("/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash",
+              r"C:\Program Files\Git\bin\bash.exe",
+              r"C:\Program Files (x86)\Git\bin\bash.exe",
+              r"C:\Windows\System32\bash.exe"):
         if os.path.exists(p):
             return p
     return None
 
 
-# Resolved once at import (in whatever environment drydock runs — host or the
-# task container). None → bash unavailable, fall back to the default shell.
+_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).
 _BASH_SHELL = _detect_bash()
 
 
@@ -928,6 +934,18 @@ def kill_process_group(proc) -> None:
     if the group can't be resolved (e.g. process already gone)."""
     if proc is None:
         return
+    if _IS_WINDOWS:
+        # No process groups / SIGKILL on Windows — taskkill /T kills the whole
+        # child tree (the shell + everything it spawned).
+        try:
+            subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                           capture_output=True, timeout=10)
+        except Exception:  # noqa: BLE001
+            try:
+                proc.kill()
+            except Exception:  # noqa: BLE001
+                pass
+        return
     try:
         os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
     except (ProcessLookupError, PermissionError, OSError):
@@ -1016,9 +1034,19 @@ def tool_bash(params: dict, config: dict) -> str:
     # overall timeout between slices.
     cancel = config.get("_cancel")
     proc = None
+    # Invoke bash explicitly as [bash, "-c", cmd] rather than shell=True +
+    # executable — cross-platform correctness: on Windows shell=True builds
+    # `{executable} /c {cmd}` (cmd.exe syntax), so a real bash.exe (Git Bash/WSL)
+    # 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:
+        popen_cmd, use_shell = cmd, True
     try:
         proc = subprocess.Popen(
-            cmd, shell=True, executable=_BASH_SHELL,
+            popen_cmd, shell=use_shell,
             stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
             # stdin=DEVNULL so a command that reads stdin gets immediate EOF
             # (correct for a non-interactive tool) instead of inheriting the
@@ -1033,7 +1061,12 @@ def tool_bash(params: dict, config: dict) -> str:
             # which killed the thread and handed the agent "(no output)", losing
             # even the text parts of mixed output.
             text=True, encoding="utf-8", errors="replace",
-            cwd=config.get("cwd"), start_new_session=True,
+            cwd=config.get("cwd"),
+            # Own process group / job so kill_process_group takes down the whole
+            # tree: setsid on POSIX; a new process group on Windows (getattr keeps
+            # the Windows-only flag out of the POSIX code path — it resolves to 0).
+            start_new_session=not _IS_WINDOWS,
+            creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
         )
         config.setdefault("_abort", {})["proc"] = proc
         # Read output in a daemon thread with a HARD byte cap, so memory can't

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

@@ -91,6 +91,12 @@ _DEFAULT_SYSTEM_PROMPT = (
     "NOT stop to ask whether to proceed. Call `todo` again to flip a step to "
     "done and the next to in-progress as you finish each, and only stop when "
     "every step is done. Don't write a TODO.md file for this.\n"
+    "Before you finish, RE-READ the task and confirm EVERY requirement is met — "
+    "exact filenames, paths, formats, and values matter, so check them literally. "
+    "If the task ships a test/eval/check script (eval.py, test.sh, a make target), "
+    "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"
     "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 "
@@ -121,6 +127,12 @@ _GEMMA_SYSTEM_PROMPT = (
     "steps — do NOT stop to ask whether to proceed. Call `todo` again to update "
     "it as you finish each step, and only stop when every step is done. Do not "
     "write a TODO.md file for this.\n"
+    "Before you finish, RE-READ the task and confirm EVERY requirement is met — "
+    "exact filenames, paths, formats, and values matter, so check them literally. "
+    "If the task ships a test/eval/check script (eval.py, test.sh, a make target), "
+    "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"
     "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 "

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

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

@@ -51,6 +51,7 @@ tests/test_approval.py
 tests/test_back_command.py
 tests/test_bash_background.py
 tests/test_bash_binary_output.py
+tests/test_bash_crossplatform.py
 tests/test_bash_output_bounding.py
 tests/test_bash_process_group.py
 tests/test_bash_safety.py
@@ -96,6 +97,7 @@ tests/test_rmf_stig_graph.py
 tests/test_runaway_repetition.py
 tests/test_server_probe.py
 tests/test_skills.py
+tests/test_stall_retry.py
 tests/test_stig.py
 tests/test_stop.py
 tests/test_streaming_newlines.py

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

drydock_cli-3.0.106/tests/test_bash_crossplatform.py

@@ -0,0 +1,49 @@
+"""tool_bash must run on Linux AND Windows. The Windows blocker was shell=True +
+executable=bash → Popen builds `bash /c cmd` (cmd.exe syntax) which a real
+bash.exe rejects. Fix: invoke `[bash, "-c", cmd]` explicitly; use taskkill on
+Windows for the process-tree kill; setsid only on POSIX."""
+from __future__ import annotations
+
+import os
+import subprocess
+
+from drydock import tools
+from drydock.tools import _detect_bash, _IS_WINDOWS, kill_process_group, tool_bash
+
+
+def test_platform_flag_matches_os():
+    assert _IS_WINDOWS == (os.name == "nt")
+
+
+def test_detect_bash_returns_path_or_none():
+    r = _detect_bash()
+    assert r is None or (isinstance(r, str) and "bash" in r.lower())
+
+
+def test_bash_invoked_as_argv_not_shell_c(monkeypatch):
+    """When bash is available, Popen is called with [bash, '-c', cmd] and
+    shell=False — never shell=True+executable (which breaks on Windows)."""
+    if not tools._BASH_SHELL:
+        return
+    seen = {}
+    real = subprocess.Popen
+
+    def spy(popen_cmd, *a, **kw):
+        seen["cmd"] = popen_cmd
+        seen["shell"] = kw.get("shell")
+        return real(popen_cmd, *a, **kw)
+
+    monkeypatch.setattr(subprocess, "Popen", spy)
+    tool_bash({"command": "echo hi", "timeout": 5}, {"cwd": "/tmp"})
+    assert seen["shell"] is False
+    assert isinstance(seen["cmd"], list) and seen["cmd"][1] == "-c"
+    assert seen["cmd"][0].lower().endswith(("bash", "bash.exe"))
+
+
+def test_kill_process_group_none_is_safe():
+    kill_process_group(None)  # must not raise
+
+
+def test_command_still_runs_here():
+    out = tool_bash({"command": "echo cross_platform_ok", "timeout": 5}, {"cwd": "/tmp"})
+    assert "cross_platform_ok" in out

drydock_cli-3.0.106/tests/test_stall_retry.py

@@ -0,0 +1,53 @@
+"""Auto-retry on server stall (config stall_retry_secs, default 0=off): a hung
+model call (server produces nothing for stall_secs) raises StallRetry so the
+agent abandons the wedged request and re-issues it. Plus the self-verify /
+run-test-script / act prompt guidance."""
+from __future__ import annotations
+
+import time
+
+from drydock.providers import StallRetry, _create_abortable
+from drydock import config
+from drydock.tuning import system_prompt_for_model
+
+
+class _HangingClient:
+    class chat:
+        class completions:
+            @staticmethod
+            def create(**kw):
+                time.sleep(60)  # simulate a wedged server
+
+
+def test_stall_retry_raised_on_hang():
+    t0 = time.monotonic()
+    raised = False
+    try:
+        _create_abortable(_HangingClient(), {}, "url", "vllm", None,
+                          timeout_s=600, stall_secs=1)
+    except StallRetry:
+        raised = True
+    assert raised and (time.monotonic() - t0) < 4
+
+
+def test_stall_retry_disabled_by_default():
+    assert config.DEFAULTS.get("stall_retry_secs") == 0
+
+
+def test_no_stall_when_secs_zero_returns_quickly():
+    # stall_secs=0 → never raises StallRetry; a fast create returns normally
+    class Fast:
+        class chat:
+            class completions:
+                @staticmethod
+                def create(**kw):
+                    return "ok"
+    assert _create_abortable(Fast(), {}, "u", "vllm", None, stall_secs=0) == "ok"
+
+
+def test_prompts_have_verify_and_act_guidance():
+    for m in ("gemma4", "some-other-model"):
+        p = system_prompt_for_model(m)
+        assert "RE-READ the task" in p
+        assert "eval.py" in p and "test.sh" in p        # run-the-test-script
+        assert "Prefer acting" in p                      # act, don't over-plan