drydock-cli 2.7.16__tar.gz → 2.7.17__tar.gz

drydock_cli-2.7.17/.auto_release.lock

@@ -0,0 +1 @@
+291967

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.16
+Version: 2.7.17
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/drydock/admiral/detectors.py

@@ -80,18 +80,28 @@ def detect_struggle(messages: Sequence[LLMMessage], threshold: int = 20) -> Find
                 calls_since_write += 1
     if calls_since_write < threshold:
         return None
-    hint = (
-        "Either (a) you already have enough context — commit to a plan and "
-        "start writing code now, or (b) you're genuinely stuck — stop and "
-        "report what's blocking you to the user."
-    )
-    return Finding(
-        code=f"struggle:{calls_since_write}:{last_write_tool or 'none'}",
-        directive=(
+    # Stable code (no count) so DEDUP_WINDOW_SEC suppresses repeated firings.
+    # Previously included the count, which caused 33 identical interventions
+    # in a single session (each with a unique key that bypassed dedup).
+    code = f"struggle:{last_write_tool or 'none'}"
+    if calls_since_write >= 30:
+        directive = (
+            f"Admiral: you have made {calls_since_write} tool calls without "
+            f"writing any file — search_replace is clearly not finding the text. "
+            f"STOP retrying. Call `write_file` with `overwrite=True` to rewrite "
+            f"the target file from scratch right now."
+        )
+    else:
+        hint = (
+            "Either (a) you already have enough context — commit to a plan and "
+            "start writing code now, or (b) you're genuinely stuck — stop and "
+            "report what's blocking you to the user."
+        )
+        directive = (
             f"Admiral: you have made {calls_since_write} tool calls without "
             f"writing or editing any file. {hint}"
-        ),
-    )
+        )
+    return Finding(code=code, directive=directive)
 
 
 def run_all(messages: Sequence[LLMMessage]) -> list[Finding]:

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/drydock/core/agent_loop.py

@@ -1131,10 +1131,12 @@ class AgentLoop:
         token-level sampling bumps don't help when the model picks
         the SAME serialized args every time.
 
-        Conservative thresholds — only fires on truly pathological
-        repeat counts that would never be a "valid retry":
+        Thresholds tuned for 45-prompt session windows (stress sessions
+        reset every 45 prompts — a threshold of 12 never fires in practice
+        because the model loops 4-8 times then moves on; admiral advisories
+        fire at 3 but the model ignores them):
           search_replace, write_file, bash: after 8 identical calls
-          read_file, grep, glob, ls: after 12 identical calls
+          read_file, grep, glob, ls: after 5 identical calls
         """
         args_str = json.dumps(tool_call.args_dict, sort_keys=True, default=str)
         sig = hashlib.sha256(
@@ -1143,7 +1145,7 @@ class AgentLoop:
         count, last_result = self._tool_call_history.get(sig, (0, ""))
         tool_name = tool_call.tool_name
         is_readonly = tool_name in ("grep", "read_file", "glob", "ls")
-        threshold = 12 if is_readonly else 8
+        threshold = 5 if is_readonly else 8
         if count < threshold:
             return None
         return (
@@ -2379,6 +2381,30 @@ class AgentLoop:
         if len(recent_sr) >= 2 and recent_sr[0] == recent_sr[1]:
             return "WARNING|search_replace"
 
+        # Early check: write_file with _truncated args twice in a row for the
+        # same path.  format.py already embeds the file content in the error,
+        # but Gemma 4 ignores the advisory and retries identically.  Mute
+        # write_file for 1 turn so the model must use read_file or
+        # search_replace instead — same pattern as the search_replace check.
+        recent_wf_truncated: list[str] = []
+        for msg in reversed(self.messages[-20:]):
+            if msg.role == Role.assistant and msg.tool_calls:
+                for tc in msg.tool_calls:
+                    if tc.function and tc.function.name == "write_file":
+                        try:
+                            args = json.loads(tc.function.arguments or "{}")
+                            if args.get("_truncated"):
+                                p = (args.get("file_path") or args.get("path") or "")
+                                recent_wf_truncated.append(p)
+                        except (json.JSONDecodeError, AttributeError):
+                            pass
+                if len(recent_wf_truncated) >= 2:
+                    break
+        if (len(recent_wf_truncated) >= 2
+                and recent_wf_truncated[0] == recent_wf_truncated[1]):
+            self._hot_tool_path = ("write_file", recent_wf_truncated[0])
+            return "FORCE_STOP"
+
         sigs: list[str] = []
         tool_names: list[str] = []
         lookback = 0

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/drydock/core/llm/format.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import logging
 import re as _re
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
@@ -378,7 +379,34 @@ class APIToolFormatHandler:
                 path_hint = (parsed_call.raw_args.get("path")
                              or parsed_call.raw_args.get("file_path")
                              or "")
-                hint = f" Re-read `{path_hint}` with read_file first." if path_hint else ""
+                # Auto-embed the current file content so the model can
+                # rewrite immediately without an extra read_file round-trip.
+                file_embed = ""
+                if path_hint:
+                    try:
+                        p = Path(path_hint)
+                        if p.exists() and p.is_file():
+                            raw = p.read_text(errors="replace")
+                            lines = raw.splitlines()
+                            max_lines = 120
+                            if len(lines) <= max_lines:
+                                file_embed = (
+                                    f"\n\nCurrent file content of `{path_hint}`:\n"
+                                    f"```\n{raw}\n```\n"
+                                    f"Rewrite it now using write_file with the correct content."
+                                )
+                            else:
+                                snippet = "\n".join(lines[:max_lines])
+                                file_embed = (
+                                    f"\n\nCurrent file content of `{path_hint}` "
+                                    f"(first {max_lines} of {len(lines)} lines):\n"
+                                    f"```\n{snippet}\n```\n"
+                                    f"Use read_file to see the rest, then rewrite with write_file."
+                                )
+                    except Exception:
+                        pass
+                if not file_embed and path_hint:
+                    file_embed = f" Re-read `{path_hint}` with read_file first."
                 failed_calls.append(
                     FailedToolCall(
                         tool_name=parsed_call.tool_name,
@@ -387,7 +415,7 @@ class APIToolFormatHandler:
                             f"{parsed_call.tool_name}: your call used a "
                             f"truncated history entry as a template (it contained "
                             f"'_truncated'/'_original_bytes' instead of real "
-                            f"arguments).{hint} Provide the full required arguments."
+                            f"arguments).{file_embed} Provide the full required arguments."
                         ),
                     )
                 )

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/drydock/core/tools/builtins/search_replace.py

@@ -131,6 +131,34 @@ class SearchReplace(
             file_path, search_replace_blocks = self._prepare_and_validate_args(args)
         except ToolError as e:
             err_msg = str(e)
+            if err_msg.startswith("Path is not a file:"):
+                # Model passed a directory instead of a file path.
+                # Return a result (not raise) so the model corrects the call
+                # rather than retrying the same directory path in a loop.
+                dir_path_str = args.file_path.strip()
+                dir_path = Path(dir_path_str).expanduser()
+                if not dir_path.is_absolute():
+                    dir_path = Path.cwd() / dir_path
+                dir_path = dir_path.resolve()
+                if dir_path.is_dir():
+                    try:
+                        files = sorted(p.name for p in dir_path.iterdir() if p.is_file())
+                    except OSError:
+                        files = []
+                    files_list = "\n".join(f"  {f}" for f in files[:20]) or "  (empty directory)"
+                    yield SearchReplaceResult(
+                        file=str(dir_path),
+                        blocks_applied=0,
+                        lines_changed=0,
+                        content=(
+                            f"PATH ERROR: '{dir_path}' is a directory, not a file. "
+                            f"search_replace requires a path to a specific file.\n"
+                            f"Files in that directory:\n{files_list}\n"
+                            f"Specify the full path including the filename, e.g. "
+                            f"'{dir_path}/<filename.py>'"
+                        ),
+                    )
+                    return
             if err_msg.startswith("NO_BLOCKS:"):
                 # Gemma 4 sent raw code without SEARCH/REPLACE markers.
                 # CAREFULLY fall back to full file overwrite — but refuse if
@@ -383,18 +411,38 @@ class SearchReplace(
             state[fail_key] = entry
             if entry["count"] >= 2:
                 try:
-                    head = original_content[:2000]
                     line_count = original_content.count("\n")
-                    error_message += (
-                        f"\n\n[LOOP-BREAKER: this is the #{entry['count']} "
-                        f"consecutive search_replace failure on "
-                        f"{file_path.name}. Stop retrying the same search. "
-                        f"Actual file content (first 2000 chars of "
-                        f"{line_count} lines):\n"
-                        f"-----FILE START-----\n{head}\n-----FILE END-----\n"
-                        f"Use THIS exact text as your search target, OR "
-                        f"abandon this edit and try write_file.]"
-                    )
+                    count = entry["count"]
+                    if count >= 3:
+                        # Show full file (up to 4000 chars) and prohibit retry.
+                        body = original_content[:4000]
+                        tail = (
+                            f"\n...[truncated, {line_count} lines total]"
+                            if len(original_content) > 4000 else ""
+                        )
+                        error_message += (
+                            f"\n\n[HARD-STOP: this is the #{count} consecutive "
+                            f"search_replace failure on {file_path.name}. "
+                            f"Your search text was NOT found in the file. "
+                            f"DO NOT retry search_replace with the same or similar text. "
+                            f"REQUIRED action: call write_file with overwrite=True "
+                            f"and provide the complete new file content. "
+                            f"Full file content below — use this as the basis "
+                            f"for your write_file call:\n"
+                            f"-----FILE START-----\n{body}{tail}\n-----FILE END-----]"
+                        )
+                    else:
+                        head = original_content[:2000]
+                        error_message += (
+                            f"\n\n[LOOP-BREAKER: this is the #{count} "
+                            f"consecutive search_replace failure on "
+                            f"{file_path.name}. Stop retrying the same search. "
+                            f"Actual file content (first 2000 chars of "
+                            f"{line_count} lines):\n"
+                            f"-----FILE START-----\n{head}\n-----FILE END-----\n"
+                            f"Use THIS exact text as your search target, OR "
+                            f"abandon this edit and try write_file.]"
+                        )
                 except Exception:
                     pass
 

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.16"
+version = "2.7.17"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-2.7.17/tests/core/test_circuit_breaker_readonly_threshold.py

@@ -0,0 +1,93 @@
+"""Regression test: read_file circuit breaker fires at threshold 5, not 12.
+
+Stress sessions reset every 45 prompts. With threshold=12, the model could
+loop 11× on the same read_file call before being blocked — admiral advisories
+fire at 3× but are ignored. Threshold=5 actually engages the block before
+the session's budget is exhausted.
+"""
+import hashlib
+import json
+import unittest
+from unittest.mock import MagicMock
+
+
+def _make_circuit_breaker_check():
+    """Import and bind just the circuit breaker logic for unit testing."""
+    from drydock.core.agent_loop import AgentLoop
+
+    loop = AgentLoop.__new__(AgentLoop)
+    loop._tool_call_history = {}
+    loop._get_attempted_summary = lambda: ""
+    return loop
+
+
+class TestCircuitBreakerReadonlyThreshold(unittest.TestCase):
+    def _make_tool_call(self, name, args):
+        tc = MagicMock()
+        tc.tool_name = name
+        tc.args_dict = args
+        tc.call_id = "test-id"
+        return tc
+
+    def _record(self, loop, tool_call, result="some content"):
+        from drydock.core.agent_loop import AgentLoop
+        AgentLoop._circuit_breaker_record(loop, tool_call, result)
+
+    def test_read_file_blocks_at_5(self):
+        """Circuit breaker fires on the 6th identical call (threshold=5 means count>=5 blocks)."""
+        loop = _make_circuit_breaker_check()
+        tc = self._make_tool_call("read_file", {"path": "foo.py", "offset": 150, "limit": 100})
+
+        # First 5 calls: should not block
+        for i in range(5):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result, f"Expected no block on call {i+1}, got: {result}")
+            self._record(loop, tc)
+
+        # 6th call: should block (count=5 >= threshold=5)
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(result, "Expected circuit breaker to fire on 6th identical read_file")
+        self.assertIn("read_file", result)
+
+    def test_bash_still_blocks_at_8(self):
+        """bash threshold=8, so blocks on 9th call (count=8 >= threshold=8)."""
+        loop = _make_circuit_breaker_check()
+        tc = self._make_tool_call("bash", {"command": "ls -la"})
+
+        for i in range(8):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result, f"Expected no block on bash call {i+1}")
+            self._record(loop, tc)
+
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(result, "Expected circuit breaker to fire on 9th identical bash")
+
+    def test_grep_blocks_at_5(self):
+        loop = _make_circuit_breaker_check()
+        tc = self._make_tool_call("grep", {"pattern": "def foo", "path": "bar.py"})
+
+        for i in range(5):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result)
+            self._record(loop, tc)
+
+        # 6th call blocks (count=5 >= threshold=5)
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(result, "Expected circuit breaker to fire on 6th identical grep")
+
+    def test_different_args_not_blocked(self):
+        loop = _make_circuit_breaker_check()
+
+        # 5 reads of foo.py at offset 150
+        tc1 = self._make_tool_call("read_file", {"path": "foo.py", "offset": 150})
+        for _ in range(5):
+            self._record(loop, tc1)
+
+        # Different offset should not be blocked
+        tc2 = self._make_tool_call("read_file", {"path": "foo.py", "offset": 200})
+        result = loop._circuit_breaker_check(tc2)
+        self.assertIsNone(result, "Different args should not be blocked")
+
+
+if __name__ == "__main__":
+    unittest.main()

drydock_cli-2.7.17/tests/test_admiral_struggle_dedup.py

@@ -0,0 +1,68 @@
+"""Regression tests for struggle detector dedup fix.
+
+Before the fix, the finding code was f"struggle:{count}:{tool}" — each count
+was a unique key, bypassing DEDUP_WINDOW_SEC and producing 33 identical
+interventions in one session that the model ignored.
+
+After the fix, the code is stable (f"struggle:{tool}") so a single entry
+in recent_findings suppresses repeat firings within the 60-second window.
+"""
+from __future__ import annotations
+
+from drydock.admiral.detectors import detect_struggle
+from drydock.core.types import FunctionCall, LLMMessage, Role, ToolCall
+
+
+def _assistant(tool: str, args: str = "{}") -> LLMMessage:
+    return LLMMessage(
+        role=Role.assistant,
+        content="",
+        tool_calls=[ToolCall(function=FunctionCall(name=tool, arguments=args))],
+    )
+
+
+def _make_msgs(write_tool: str, non_write_count: int) -> list[LLMMessage]:
+    msgs: list[LLMMessage] = [LLMMessage(role=Role.user, content="build it")]
+    msgs.append(_assistant(write_tool, '{"path":"x.py","content":"x"}'))
+    msgs.append(LLMMessage(role=Role.tool, content="ok"))
+    for i in range(non_write_count):
+        msgs.append(_assistant("read_file", f'{{"path":"f{i}.py"}}'))
+        msgs.append(LLMMessage(role=Role.tool, content="content"))
+    return msgs
+
+
+def test_struggle_code_is_stable_no_count() -> None:
+    """Finding code must NOT include the count so dedup works across counts."""
+    msgs20 = _make_msgs("search_replace", 20)
+    msgs33 = _make_msgs("search_replace", 33)
+    f20 = detect_struggle(msgs20)
+    f33 = detect_struggle(msgs33)
+    assert f20 is not None
+    assert f33 is not None
+    # Same stable code regardless of count
+    assert f20.code == f33.code
+    assert "20" not in f20.code
+    assert "33" not in f33.code
+
+
+def test_struggle_escalated_directive_at_30() -> None:
+    """At 30+ non-write calls, directive must mention write_file overwrite."""
+    msgs = _make_msgs("search_replace", 30)
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert "write_file" in f.directive
+    assert "overwrite" in f.directive
+
+
+def test_struggle_gentle_directive_below_30() -> None:
+    """Below 30, directive is the gentle nudge (no overwrite mention)."""
+    msgs = _make_msgs("search_replace", 22)
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert "overwrite" not in f.directive
+    assert "commit to a plan" in f.directive
+
+
+def test_struggle_no_fire_below_threshold() -> None:
+    msgs = _make_msgs("write_file", 5)
+    assert detect_struggle(msgs) is None

{drydock_cli-2.7.16 → drydock_cli-2.7.17}/tests/test_truncated_arg_path_hint.py

@@ -92,3 +92,33 @@ class TestTruncatedArgPathHint:
         assert len(result.failed_calls) == 1
         assert "Re-read" not in result.failed_calls[0].error
         assert "_truncated" in result.failed_calls[0].error or "truncated" in result.failed_calls[0].error
+
+    def test_existing_file_content_embedded(self, tmp_path):
+        """When the target file exists, its content is embedded in the error
+        so the model can rewrite without an extra read_file round-trip."""
+        target = tmp_path / "utils.py"
+        target.write_text("def hello():\n    return 42\n")
+
+        handler = APIToolFormatHandler()
+        parsed = ParsedMessage(
+            tool_calls=[
+                ParsedToolCall(
+                    tool_name="write_file",
+                    call_id="tc4",
+                    raw_args={
+                        "_truncated": True,
+                        "_original_bytes": 4096,
+                        "file_path": str(target),
+                    },
+                )
+            ]
+        )
+        tm = _make_tool_manager_with("write_file", _make_write_file_class())
+        result = handler.resolve_tool_calls(parsed, tm)
+        assert len(result.failed_calls) == 1
+        err = result.failed_calls[0].error
+        # Content should be embedded, not just a Re-read directive
+        assert "def hello():" in err
+        assert "return 42" in err
+        # Re-read advisory should NOT appear when content is embedded
+        assert "Re-read" not in err

drydock_cli-2.7.17/tests/tools/test_search_replace_dir_path.py

@@ -0,0 +1,91 @@
+"""Regression test: search_replace returns actionable result when passed a directory.
+
+Admiral logs (2026-04-28) showed 38 instances of retry_after_error:search_replace
+with error head 'file: /data3/.../tool_agent' — the model was passing the package
+directory path instead of a specific file path. The old code raised ToolError
+("Path is not a file") which the framework turned into a tool error, and the model
+retried the same bad path in a loop.
+
+Fix: catch the directory-path case in run() and yield a SearchReplaceResult listing
+the files in the directory. The model can then correct the path instead of looping.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+from drydock.core.tools.base import BaseToolState, InvokeContext
+from drydock.core.tools.builtins.search_replace import (
+    SearchReplace,
+    SearchReplaceArgs,
+    SearchReplaceConfig,
+    SearchReplaceResult,
+)
+
+
+async def _collect(gen):
+    results = []
+    async for item in gen:
+        results.append(item)
+    return results
+
+
+@pytest.fixture
+def tool():
+    return SearchReplace(SearchReplaceConfig(), BaseToolState())
+
+
+@pytest.fixture
+def ctx() -> InvokeContext:
+    return InvokeContext(tool_call_id="tc_1", read_file_state={})
+
+
+@pytest.mark.asyncio
+async def test_directory_path_returns_result_not_error(tool, ctx, tmp_path):
+    """Passing a directory path should yield a SearchReplaceResult with the file list."""
+    # Create some files in the temp dir
+    (tmp_path / "cli.py").write_text("print('cli')\n")
+    (tmp_path / "tools.py").write_text("def run(): pass\n")
+
+    args = SearchReplaceArgs(
+        file_path=str(tmp_path),
+        content="<<<<<<< SEARCH\nold\n=======\nnew\n>>>>>>> REPLACE",
+    )
+    results = await _collect(tool.run(args, ctx))
+    assert results, "expected at least one result"
+    result = results[-1]
+    assert isinstance(result, SearchReplaceResult)
+    assert result.blocks_applied == 0
+    assert "PATH ERROR" in result.content
+    assert "cli.py" in result.content
+    assert "tools.py" in result.content
+
+
+@pytest.mark.asyncio
+async def test_directory_path_does_not_raise(tool, ctx, tmp_path):
+    """Verify no exception propagates when a directory path is given."""
+    args = SearchReplaceArgs(
+        file_path=str(tmp_path),
+        content="<<<<<<< SEARCH\nold\n=======\nnew\n>>>>>>> REPLACE",
+    )
+    # Should not raise
+    results = await _collect(tool.run(args, ctx))
+    assert any(isinstance(r, SearchReplaceResult) for r in results)
+
+
+@pytest.mark.asyncio
+async def test_directory_path_repeated_call_still_returns_result(tool, ctx, tmp_path):
+    """Second call with the same directory path still returns a result (not an error)."""
+    (tmp_path / "main.py").write_text("x = 1\n")
+    args = SearchReplaceArgs(
+        file_path=str(tmp_path),
+        content="<<<<<<< SEARCH\nold\n=======\nnew\n>>>>>>> REPLACE",
+    )
+    for _ in range(3):
+        results = await _collect(tool.run(args, ctx))
+        result = results[-1]
+        assert isinstance(result, SearchReplaceResult)
+        assert result.blocks_applied == 0
+        assert "PATH ERROR" in result.content