drydock-cli 3.1.13__tar.gz → 3.1.14__tar.gz

{drydock_cli-3.1.13/drydock_cli.egg-info → drydock_cli-3.1.14}/PKG-INFO

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

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock/agent.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import os
 import time as _time
+from pathlib import Path
 from dataclasses import dataclass, field
 from typing import Generator
 
@@ -124,6 +125,24 @@ def drop_last_turn(messages: list) -> bool:
     return False
 
 
+def _numbered_snapshot(path: str, max_lines: int = 200, max_chars: int = 8000) -> str:
+    """Line-numbered current content of *path* for the failed-edit thrash breaker,
+    so the model can copy an exact span instead of re-guessing. Bounded and
+    never raises — an unreadable path returns an explanatory line."""
+    try:
+        text = Path(path).read_text(encoding="utf-8", errors="replace")
+    except Exception as e:  # noqa: BLE001
+        return f"(could not read {path}: {e}. Use Read to inspect it.)"
+    lines = text.splitlines()
+    body = lines[:max_lines]
+    out = "\n".join(f"{i + 1:>5}\t{ln}" for i, ln in enumerate(body))
+    if len(lines) > max_lines:
+        out += f"\n[... {len(lines) - max_lines} more lines — use Read for the rest ...]"
+    if len(out) > max_chars:
+        out = out[:max_chars] + "\n[... truncated — use Read for the rest ...]"
+    return out
+
+
 # ── Agent loop ────────────────────────────────────────────────────────────
 
 def run(
@@ -212,6 +231,7 @@ def run(
     )  # scores each action; flags a stalled run
     prev_failing = None  # failing-test count from the previous verification (delta)
     verif_fail_counts: dict[str, int] = {}  # failure-summary -> times seen (Epic J3)
+    edit_fail_counts: dict[str, int] = {}    # file_path -> consecutive "old_string not found" misses
     verification_text = ""    # concatenated verification commands+results (coverage)
     coverage_nudges = 0       # bounded "your checks never touched X" nudges
     # Time-aware effort governor (bench taxonomy: think-bound runs burn a 30-min
@@ -691,9 +711,36 @@ def run(
                     f"path and take a different approach.]\n" + result
                 )
 
+            # Failed-edit thrash breaker: a weak model that guesses a WRONG
+            # old_string gets "old_string not found", then re-guesses a DIFFERENT
+            # wrong old_string — so exact-repeat detection (keyed on identical
+            # input) never fires and it loops "over and over" (seen live on
+            # gemma/vLLM). Track "not found" misses per FILE regardless of the
+            # old_string; after a few, stop hinting and HARD-inject the file's
+            # current content (line-numbered) so the next edit can only copy an
+            # exact span. Also feed the stall machinery so recovery escalates.
+            _edit_thrash = False
+            if tc["name"] in ("Edit", "edit") and isinstance(tc.get("input"), dict):
+                _efp = str(tc["input"].get("file_path") or "")
+                if "old_string not found" in (result or ""):
+                    edit_fail_counts[_efp] = edit_fail_counts.get(_efp, 0) + 1
+                    if edit_fail_counts[_efp] >= 3:
+                        _edit_thrash = True
+                        _snap = _numbered_snapshot(_efp)
+                        result = (
+                            f"[STOP: {edit_fail_counts[_efp]} edits to {_efp} have failed "
+                            f"with 'old_string not found' — you keep guessing text that is "
+                            f"not in the file. Do NOT guess again. The file's CURRENT "
+                            f"content is below, line-numbered. Copy an EXACT span (WITHOUT "
+                            f"the line-number prefixes) as old_string, or take a different "
+                            f"approach.]\n{_snap}\n\n" + (result or "")
+                        )
+                else:
+                    edit_fail_counts.pop(_efp, None)  # a clean edit resets that file
+
             # Verification evidence: if this Bash call was a test/check/exec, parse
             # its result so the completion gate knows whether it PASSED, not just ran.
-            _repeated_outcome = bool(_degen)
+            _repeated_outcome = bool(_degen) or _edit_thrash
             if tc["name"] == "Bash":
                 _vcmd = (tc.get("input") or {}).get("command", "")
                 if looks_like_verification(_vcmd):

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock/compaction.py

@@ -110,15 +110,24 @@ def _truncate_tool_call_args(messages: list, max_len: int) -> None:
                         inp[k] = v[: max_len // 2] + "\n[... arg truncated ...]"
 
 
-def compact(messages: list, context_limit: int = 131072) -> list:
+def compact(messages: list, context_limit: int = 131072,
+            target_frac: float = 0.45) -> list:
     """Compact messages to fit within context limit.
 
     Strategy:
     1. First pass: truncate long tool results to 800 chars
     2. Second pass: drop oldest tool results if still over limit
     3. Always keep: first user message, last 8 messages
+
+    target_frac is the fraction of the window to compact DOWN to. It must be
+    meaningfully below maybe_compact's TRIGGER (0.60): compacting to the same
+    0.60 we trigger at frees almost nothing, so context stays pinned just over
+    the line and re-compacts every turn while never gaining real headroom — the
+    "it doesn't compact when it needs to" symptom. Targeting 0.45 leaves durable
+    headroom so a long /loop (history accumulating across iterations) doesn't
+    creep back over the wall on the very next turn.
     """
-    target = int(context_limit * 0.60)  # Leave 40% headroom
+    target = int(context_limit * target_frac)  # durable headroom below the 0.60 trigger
 
     # Pass 1: Truncate long tool results
     for m in messages:

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock/providers.py

@@ -562,9 +562,11 @@ def stream(
     oai_messages = messages_to_openai(messages, system)
 
     has_tools = bool(tool_schemas)
-    # Gemma corrupts tool-call JSON when streamed; force non-streaming on tool
-    # turns. config["force_stream"] overrides for debugging.
-    do_stream = config.get("force_stream") or use_streaming(model, has_tools)
+    # Gemma (and any local server whose model name we can't trust) corrupts
+    # tool-call JSON when streamed; force non-streaming on tool turns. Passing
+    # provider closes the gap where a Gemma behind vLLM is served under a name
+    # lacking 'gemma'. config["force_stream"] overrides for debugging.
+    do_stream = config.get("force_stream") or use_streaming(model, has_tools, provider)
 
     kwargs = {
         "model": model,

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock/tui/app.py

@@ -890,28 +890,52 @@ class DrydockApp(App):
         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."""
+        """/loop [count|*] <prompt> — re-submit <prompt> after each turn finishes.
+
+        <count> 1–1000 runs that many iterations; `*` (or omitting the count
+        entirely) runs UNBOUNDED until Esc/`/stop`. The loop also stops early on
+        its own when the model reports the task done (replies LOOP_DONE) or when
+        an iteration makes no progress (identical actions + reply as the prior)."""
         parts = arg.split(maxsplit=1)
-        if len(parts) < 2 or not parts[0].isdigit():
+        first = parts[0] if parts else ""
+        if first == "*":
+            total = None  # unbounded
+            prompt = (parts[1] if len(parts) > 1 else "").strip()
+        elif first.isdigit():
+            total = max(1, min(int(first), 1000))
+            prompt = (parts[1] if len(parts) > 1 else "").strip()
+        else:
+            total = None  # no count given → run until stopped
+            prompt = arg.strip()
+        if not prompt:
             self._info(
-                "usage: /loop <count> <prompt>   e.g.  /loop 5 fix the next "
-                "failing test and run pytest\n(count 1–50; Esc stops the loop)"
+                "usage: /loop [count|*] <prompt>   e.g.  /loop 5 fix the next "
+                "failing test and run pytest\n"
+                "(count 1–1000, or `*`/no count = until Esc/stop)"
             )
             return
-        count = max(1, min(int(parts[0]), 50))
-        prompt = parts[1].strip()
-        if not prompt:
-            self._info("usage: /loop <count> <prompt>")
-            return
         if self._busy:
             self._info("A turn is already running — stop it (Esc) before starting a loop.")
             return
-        self._repeat = {"prompt": prompt, "remaining": count, "total": count}
-        self._info(f"↻ looping {count}× (Esc to stop):  {prompt}")
+        self._repeat = {"prompt": prompt, "total": total, "done": 1, "fingerprint": None}
+        label = f"{total}×" if total else "until Esc"
+        self._info(f"↻ looping {label} (Esc to stop):  {prompt}")
         self._mount(UserMessage(prompt))
         self._begin(prompt)
 
+    def _loop_prompt(self, rep: dict) -> str:
+        """The prompt for a continuation iteration — the base task plus a small
+        iteration-awareness header so the model knows it is iterating and can end
+        the loop honestly instead of re-doing finished work."""
+        n = rep["done"]
+        of = f"/{rep['total']}" if rep["total"] else ""
+        return (
+            f"{rep['prompt']}\n\n"
+            f"[loop iteration {n}{of} — continue the task from the CURRENT state. "
+            f"If everything the task asks for is already complete, reply exactly "
+            f"LOOP_DONE and take no tool actions.]"
+        )
+
     def _cmd_ratchet(self, arg: str) -> None:
         """/ratchet <goal> [--verify "<cmd>"] [--rounds N] [--fitness auto|exitcode|<regex>]
 
@@ -1737,14 +1761,41 @@ class DrydockApp(App):
         if self._ratchet and not self._cancel.is_set():
             self.run_worker(self._ratchet_step, thread=True)
             return
-        # /loop: re-run the prompt until the iteration count is exhausted (Esc/
-        # stop clears self._repeat). Queued user prompts take priority (above).
-        if self._repeat and self._repeat["remaining"] > 1 and not self._cancel.is_set():
-            self._repeat["remaining"] -= 1
-            done = self._repeat["total"] - self._repeat["remaining"] + 1
-            self._info(f"↻ loop iteration {done}/{self._repeat['total']}")
-            self._begin(self._repeat["prompt"])
-            return
+        # /loop: re-run the prompt until the count is exhausted OR the loop stops
+        # itself (Esc/stop clears self._repeat). Queued user prompts take priority.
+        if self._repeat and not self._cancel.is_set():
+            rep = self._repeat
+            unbounded = rep["total"] is None
+            more = unbounded or rep["done"] < rep["total"]
+            if more:
+                # Early stop 1: the model reported the task complete.
+                if "LOOP_DONE" in self._last_assistant_text():
+                    self._info("✓ loop stopped — model reported the task complete (LOOP_DONE).")
+                    self._repeat = None
+                else:
+                    # Early stop 2: no progress — this iteration produced the same
+                    # actions AND the same reply as the previous one, so repeating
+                    # will only reproduce it (the "repeats the same actions over and
+                    # over" case). Fingerprint = (tool names used, final reply).
+                    fp = (tuple(sorted(self._turn_tools)), self._last_assistant_text())
+                    if fp == rep.get("fingerprint") and (fp[0] or fp[1]):
+                        self._info("✓ loop stopped — no progress (identical actions "
+                                   "and reply as the previous iteration).")
+                        self._repeat = None
+                    else:
+                        rep["fingerprint"] = fp
+                        rep["done"] += 1
+                        of = f"/{rep['total']}" if rep["total"] else ""
+                        self._info(f"↻ loop iteration {rep['done']}{of}")
+                        # Compact BEFORE the next iteration so accumulated history
+                        # from prior iterations can't creep over the window.
+                        try:
+                            from drydock.compaction import maybe_compact
+                            maybe_compact(self.state, self.config)
+                        except Exception:  # noqa: BLE001 — compaction must never break the loop
+                            pass
+                        self._begin(self._loop_prompt(rep))
+                        return
         self._repeat = None
         self._refresh_status()
         self._update_suggestion()

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock/tui/widgets.py

@@ -186,7 +186,7 @@ SLASH_SPECS: list[SlashSpec] = [
     SlashSpec("/doc", "<sub>", "drive the Document Canvas tools by hand",
               "open <path> · new <name> ..."),
     SlashSpec("/skills", "[new <name> <prompt>]", "list skills, or create a reusable one"),
-    SlashSpec("/loop", "<count> <prompt>", "repeat a prompt N times (Esc stops)"),
+    SlashSpec("/loop", "[count|*] <prompt>", "repeat a prompt (1–1000, or * = until Esc)"),
     SlashSpec("/ratchet", "<goal>", "persist verified progress across rounds until tests pass",
               '--verify "<cmd>" to override the auto-detected verifier'),
     SlashSpec("/mcp", "", "list connected MCP servers and their tools"),

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock/tuning.py

@@ -224,13 +224,25 @@ def hallucinated_tool_message(name: str) -> str | None:
     return _HALLUCINATED_TOOLS.get(name)
 
 
-def use_streaming(model: str | None, has_tools: bool) -> bool:
+# Local OpenAI-compatible servers whose streamed tool-call JSON we don't trust:
+# the model family can't be inferred from the served name (vLLM/Ollama/LM Studio
+# routinely report a checkpoint path, a custom --served-model-name, or 'default'),
+# and streamed tool-call deltas from local models are the corruption we avoid.
+_LOCAL_TOOL_STREAM_UNSAFE = {"vllm", "ollama", "lmstudio"}
+
+
+def use_streaming(model: str | None, has_tools: bool, provider: str | None = None) -> bool:
     """Whether to stream tokens for this turn.
 
-    Gemma corrupts tool-call JSON when streamed, so any turn that offers
-    tools to Gemma must be non-streaming. Text-only turns may stream.
+    Gemma corrupts tool-call JSON when streamed, so any tool turn to Gemma must be
+    non-streaming. Crucially, the decision must NOT rely on the model NAME alone: a
+    local server often reports a name with no 'gemma' in it (a served alias / path),
+    so a Gemma behind vLLM would slip through name-matching, stream its tool turns,
+    and emit the mangled `old_string` that makes Edit loop. So force non-streaming
+    on ANY tool turn to a local OpenAI-compatible provider, regardless of the
+    reported name. Text-only turns still stream everywhere (incremental UX kept).
     """
-    if has_tools and is_gemma(model):
+    if has_tools and (is_gemma(model) or (provider or "") in _LOCAL_TOOL_STREAM_UNSAFE):
         return False
     return True
 

{drydock_cli-3.1.13 → drydock_cli-3.1.14/drydock_cli.egg-info}/PKG-INFO

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

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/drydock_cli.egg-info/SOURCES.txt

@@ -110,6 +110,7 @@ tests/test_dispatch.py
 tests/test_doccanvas.py
 tests/test_e2e_connected.py
 tests/test_edit_replace_all.py
+tests/test_edit_thrash_and_compaction.py
 tests/test_effort_governor.py
 tests/test_empty_response.py
 tests/test_events.py

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

drydock_cli-3.1.14/tests/test_edit_thrash_and_compaction.py

@@ -0,0 +1,123 @@
+"""Regression tests for the four /loop + edit-robustness fixes:
+  - compaction now leaves DURABLE headroom (compacts below the trigger)
+  - _numbered_snapshot renders a bounded, line-numbered file view
+  - the failed-edit thrash breaker fires on repeated same-file misses
+"""
+from drydock import compaction
+from drydock.agent import _numbered_snapshot
+
+
+def _msgs_over(limit_tokens: int):
+    """A realistic long history: a first user msg + many assistant/tool turns whose
+    accumulated tool results blow past the limit (the /loop-accumulation shape)."""
+    chunk = "y" * 4000  # ~1333 tokens each
+    msgs = [{"role": "user", "content": "start the task"}]
+    for i in range(40):
+        msgs.append({"role": "assistant", "content": "",
+                     "tool_calls": [{"id": str(i), "name": "Bash",
+                                     "input": {"command": f"run step {i}"}}]})
+        msgs.append({"role": "tool", "content": f"output {i} " + chunk})
+    msgs.append({"role": "assistant", "content": "done"})
+    return msgs
+
+
+def test_compact_leaves_headroom_below_trigger():
+    """compact() must reduce BELOW the 0.60 maybe_compact trigger, not down to it —
+    otherwise it frees ~nothing and re-fires every turn (the 'doesn't compact' bug)."""
+    limit = 10_000
+    msgs = _msgs_over(limit)
+    assert compaction.estimate_tokens(msgs) > int(limit * 0.60)
+    out = compaction.compact(msgs, limit)
+    after = compaction.estimate_tokens(out)
+    # default target_frac is 0.45 → must sit at/below 45%, comfortably under 60%
+    assert after <= int(limit * 0.45) + 5, (after, int(limit * 0.45))
+
+
+def test_compact_target_frac_is_configurable():
+    limit = 10_000
+    out = compaction.compact(_msgs_over(limit), limit, target_frac=0.30)
+    assert compaction.estimate_tokens(out) <= int(limit * 0.30) + 5
+
+
+def test_maybe_compact_triggers_at_60pct():
+    """maybe_compact still uses a 0.60 trigger against the MAX of estimate and the
+    server's real last_input_tokens."""
+    class S:
+        messages = [{"role": "user", "content": "hi"}]
+        last_input_tokens = 7000  # > 60% of 10k
+    s = S()
+    compaction.maybe_compact(s, {"context_limit": 10_000})
+    # trigger fired (messages object handed to compact and returned) — no crash,
+    # and a below-trigger state is a no-op:
+    class S2:
+        messages = [{"role": "user", "content": "hi"}]
+        last_input_tokens = 100
+    before = list(S2.messages)
+    compaction.maybe_compact(S2(), {"context_limit": 10_000})
+    assert S2.messages == before
+
+
+def test_numbered_snapshot_basic(tmp_path):
+    f = tmp_path / "a.py"
+    f.write_text("line one\nline two\nline three\n")
+    snap = _numbered_snapshot(str(f))
+    assert "    1\tline one" in snap
+    assert "    3\tline three" in snap
+
+
+def test_numbered_snapshot_caps_lines(tmp_path):
+    f = tmp_path / "big.py"
+    f.write_text("\n".join(f"row{i}" for i in range(500)))
+    snap = _numbered_snapshot(str(f), max_lines=50)
+    assert "more lines" in snap
+    assert "row49" in snap and "row400" not in snap
+
+
+def test_numbered_snapshot_missing_file():
+    snap = _numbered_snapshot("/no/such/file/xyz")
+    assert "could not read" in snap.lower()
+
+
+def test_edit_thrash_counter_logic():
+    """The breaker's core rule: count 'old_string not found' per file regardless
+    of the (varying) old_string, fire on the 3rd, and a clean edit resets it.
+    Mirrors the agent-loop bookkeeping so the invariant is pinned even though the
+    full loop needs a live model."""
+    edit_fail_counts: dict[str, int] = {}
+
+    def step(fp: str, result: str) -> bool:
+        thrash = False
+        if "old_string not found" in result:
+            edit_fail_counts[fp] = edit_fail_counts.get(fp, 0) + 1
+            if edit_fail_counts[fp] >= 3:
+                thrash = True
+        else:
+            edit_fail_counts.pop(fp, None)
+        return thrash
+
+    # three DIFFERENT wrong old_strings on the same file → fires on the 3rd
+    assert step("/a.py", "Error: old_string not found in /a.py ...") is False
+    assert step("/a.py", "Error: old_string not found in /a.py ...") is False
+    assert step("/a.py", "Error: old_string not found in /a.py ...") is True
+    # a different file is tracked independently
+    assert step("/b.py", "Error: old_string not found in /b.py ...") is False
+    # a clean edit resets the file's counter
+    assert step("/a.py", "Edited /a.py") is False
+    assert "/a.py" not in edit_fail_counts
+    assert step("/a.py", "Error: old_string not found in /a.py ...") is False
+
+
+def test_use_streaming_forces_nonstream_for_local_tool_turns():
+    """A Gemma behind vLLM served under a non-'gemma' name must NOT stream tool
+    turns (the latent corruption trap). Text-only turns still stream."""
+    from drydock.tuning import use_streaming
+    # non-'gemma' served name on a local provider → tool turns non-streamed
+    assert use_streaming("Q5_K_M", has_tools=True, provider="vllm") is False
+    assert use_streaming("default", has_tools=True, provider="ollama") is False
+    assert use_streaming("model", has_tools=True, provider="lmstudio") is False
+    # text-only turns still stream everywhere
+    assert use_streaming("Q5_K_M", has_tools=False, provider="vllm") is True
+    # name-based gemma match still works regardless of provider
+    assert use_streaming("gemma4", has_tools=True, provider=None) is False
+    # a remote provider (openai) with tools is NOT force-non-streamed by provider
+    assert use_streaming("gpt-4o", has_tools=True, provider="openai") is True

{drydock_cli-3.1.13 → drydock_cli-3.1.14}/tests/test_tui.py

@@ -438,11 +438,13 @@ def test_loop_command_iterates_and_stops():
             begins = []
             app._begin = lambda text: begins.append(text)  # stub out the real agent
 
-            # bad usage → no loop
-            app._handle_slash("/loop notanumber")
+            # empty prompt → usage error, no loop
+            app._handle_slash("/loop")
+            assert app._repeat is None and not begins
+            app._handle_slash("/loop *")   # count but no prompt
             assert app._repeat is None and not begins
 
-            # /loop 3 <prompt> → starts, first iteration begun
+            # /loop 3 <prompt> → starts, first iteration begun with the bare prompt
             app._handle_slash("/loop 3 do the thing")
             assert app._repeat and app._repeat["total"] == 3
             assert begins == ["do the thing"]
@@ -456,7 +458,38 @@ def test_loop_command_iterates_and_stops():
             assert app._repeat is None
             assert len(begins) == 3  # no 4th run
 
+            # unbounded: `*` runs past any count until stopped
+            begins.clear()
+            app._handle_slash("/loop * keep going")
+            assert app._repeat and app._repeat["total"] is None
+            for _ in range(6):
+                app.on_agent_finished(AgentFinished())
+            assert app._repeat is not None  # never self-exhausts
+            assert len(begins) == 7  # initial + 6 continuations
+
+            # no count given → also unbounded, whole arg is the prompt
+            app._handle_slash("/stop")
+            begins.clear()
+            app._handle_slash("/loop just do it")
+            assert app._repeat and app._repeat["total"] is None
+            assert begins == ["just do it"]
+
+            # count is capped at 1000
+            app._handle_slash("/stop")
+            app._handle_slash("/loop 999999 huge")
+            assert app._repeat and app._repeat["total"] == 1000
+
+            # LOOP_DONE reply stops the loop early
+            app._handle_slash("/stop")
+            begins.clear()
+            app._handle_slash("/loop 10 finish up")
+            app.state.messages = [{"role": "assistant", "content": "all set. LOOP_DONE"}]
+            app.on_agent_finished(AgentFinished())
+            assert app._repeat is None
+            assert len(begins) == 1  # stopped before a 2nd iteration
+
             # Esc/stop ends an active loop
+            app.state.messages = []
             app._begin = lambda text: begins.append(text)
             app._handle_slash("/loop 5 again")
             app._busy = True