drydock-cli 2.7.5__tar.gz → 2.7.6__tar.gz

drydock_cli-2.7.6/.auto_release.lock

@@ -0,0 +1 @@
+3733529

{drydock_cli-2.7.5 → drydock_cli-2.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.5
+Version: 2.7.6
 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.5 → drydock_cli-2.7.6}/drydock/core/agent_loop.py

@@ -1741,7 +1741,14 @@ class AgentLoop:
         # Claude Code's microCompact targets BOTH tool results AND
         # tool_use blocks; our old code only shrunk results.
         # Keep the last KEEP_RECENT assistant-with-tools messages full;
-        # truncate older ones' arguments to just {tool_name, path}.
+        # truncate older ones' arguments to a small VALID JSON stub.
+        # CRITICAL: arguments must remain valid JSON because vLLM's
+        # tool-call parser re-parses them as JSON. The old code that
+        # appended "\n[…truncated N bytes…]" injected raw newlines into
+        # the JSON string and made vLLM 400 every request that hit the
+        # truncated message — see issue #13 stress recurrence on
+        # 2026-04-25 (each stress run accumulated dozens of 400s after
+        # ~30 prompts as old write_file args got truncated this way).
         assistant_tc_idxs = [
             i for i, m in enumerate(self.messages)
             if m.role == Role.assistant and m.tool_calls
@@ -1757,13 +1764,29 @@ class AgentLoop:
                     args = tc.function.arguments
                     if len(args) <= SOFT_CAP_BYTES:
                         continue
-                    if "[…truncated" in args:
+                    if '"_truncated"' in args:
                         continue
-                    # Keep just enough to identify what was called
-                    tc.function.arguments = (
-                        args[:HEAD_BYTES]
-                        + f"\n[…truncated {len(args) - HEAD_BYTES} bytes…]"
-                    )
+                    # Try to keep the most-useful field (path / file_path /
+                    # command / cmd) plus a marker, rebuild as valid JSON.
+                    stub: dict[str, Any] = {
+                        "_truncated": True,
+                        "_original_bytes": len(args),
+                    }
+                    try:
+                        import json as _json
+                        parsed = _json.loads(args)
+                        if isinstance(parsed, dict):
+                            for k in ("path", "file_path", "command",
+                                      "cmd", "url", "file"):
+                                if k in parsed and isinstance(parsed[k], str):
+                                    v = parsed[k]
+                                    stub[k] = (
+                                        v if len(v) <= 200 else v[:200] + "…"
+                                    )
+                                    break
+                    except Exception:
+                        pass
+                    tc.function.arguments = json.dumps(stub, ensure_ascii=True)
 
     def _sanitize_message_ordering(self) -> None:
         """Fix any role ordering violations before sending to vLLM/Mistral.

{drydock_cli-2.7.5 → drydock_cli-2.7.6}/drydock/core/tools/builtins/search_replace.py

@@ -141,27 +141,62 @@ class SearchReplace(
                     if target.exists():
                         import logging as _log
                         existing_size = target.stat().st_size
-                        # SAFETY CHECK: refuse to shrink a file by >50% via the
-                        # raw-code fallback. The model almost certainly intended
-                        # a partial patch, not a full replace, if the new content
-                        # is dramatically shorter.
+                        # SAFETY CHECK: a raw-code overwrite that would shrink
+                        # the file by >50% is almost certainly a partial patch
+                        # the model intended to APPEND, not a full rewrite.
+                        # Old behavior REFUSED — model retried the same broken
+                        # call in a loop. Try APPEND first when the combined
+                        # file still parses cleanly (Python only); fall back
+                        # to the directive REFUSED only if append would break
+                        # the syntax.
                         if existing_size > 500 and len(raw_content) < existing_size * 0.5:
                             _log.getLogger(__name__).warning(
-                                "search_replace: REFUSING destructive overwrite of %s "
-                                "(existing=%d chars, new=%d chars, would shrink by %d%%)",
-                                target, existing_size, len(raw_content),
+                                "search_replace: shrink-overwrite would lose %d%% "
+                                "of %s (existing=%d, new=%d) — trying APPEND instead",
                                 100 - int(len(raw_content) * 100 / existing_size),
+                                target, existing_size, len(raw_content),
+                            )
+                            existing_text = target.read_text(errors="replace")
+                            sep = "\n\n" if not existing_text.endswith("\n") else "\n"
+                            combined = existing_text + sep + raw_content + (
+                                "" if raw_content.endswith("\n") else "\n"
                             )
+                            append_safe = True
+                            if target.suffix == ".py":
+                                try:
+                                    import ast as _ast
+                                    _ast.parse(combined)
+                                except SyntaxError:
+                                    append_safe = False
+                            if append_safe:
+                                _log.getLogger(__name__).info(
+                                    "search_replace: APPEND %d chars to %s (parsed clean)",
+                                    len(raw_content), target,
+                                )
+                                await self._write_file(target, combined)
+                                yield SearchReplaceResult(
+                                    file=str(target),
+                                    blocks_applied=1,
+                                    lines_changed=raw_content.count("\n") + 1,
+                                    warnings=[
+                                        "Appended raw content to end of file (no "
+                                        "SEARCH/REPLACE blocks sent). Use proper "
+                                        "SEARCH/REPLACE blocks for non-append edits."
+                                    ],
+                                    content=raw_content[:100] + "...",
+                                )
+                                return
                             raise ToolError(
                                 f"REFUSED: the raw content you sent ({len(raw_content)} "
                                 f"chars) is much shorter than the existing {target.name} "
-                                f"({existing_size} chars). This would destroy most of "
-                                f"the file. If you intended a small patch, use proper "
-                                f"SEARCH/REPLACE blocks:\n"
+                                f"({existing_size} chars), and appending it would break "
+                                f"the file's syntax. To add new code, use a SEARCH/REPLACE "
+                                f"block anchored on the last line of the file:\n"
                                 f"<<<<<<< SEARCH\n"
-                                f"[exact existing text to replace]\n"
+                                f"[the file's actual final line, copied exactly]\n"
                                 f"=======\n"
-                                f"[new text]\n"
+                                f"[the same final line]\n\n"
+                                f"[your new code]\n"
                                 f">>>>>>> REPLACE\n"
                                 f"If you intended a full rewrite, use write_file instead."
                             )

{drydock_cli-2.7.5 → drydock_cli-2.7.6}/pyproject.toml

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

drydock_cli-2.7.6/tests/test_truncate_args_valid_json.py

@@ -0,0 +1,181 @@
+"""Regression test for the stress-run 400 spiral on 2026-04-25.
+
+Repro: `_truncate_old_tool_results` truncates assistant tool_call
+arguments by appending `"\\n[…truncated N bytes…]"` directly into the
+JSON STRING that vLLM later re-parses as JSON for the tool-call
+arguments. A raw `\\n` byte inside a JSON string is invalid JSON; vLLM's
+parser 400s with "Invalid control character at line 1 col 401". The
+old run could go ~30 prompts before truncation kicked in, then 100+
+400s before recovery.
+
+Fix: build a small VALID JSON stub from the original (parsed) args
+keeping just one identifying field. The stub must round-trip through
+json.loads cleanly, including via vLLM's strict parser.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from drydock.core.types import (
+    FunctionCall,
+    LLMMessage,
+    Role,
+    ToolCall,
+)
+from tests.conftest import build_test_agent_loop
+
+
+def _make_tc(name: str, arguments: str, idx: int = 0) -> ToolCall:
+    return ToolCall(
+        id=f"tc_{idx}",
+        index=idx,
+        function=FunctionCall(name=name, arguments=arguments),
+    )
+
+
+def _build_history(num_old: int) -> list[LLMMessage]:
+    """Build a conversation with `num_old` old assistant-with-tools
+    messages plus 8 newer messages (so KEEP_RECENT=6 plus margin)."""
+    msgs: list[LLMMessage] = [
+        LLMMessage(role=Role.system, content="be helpful"),
+        LLMMessage(role=Role.user, content="please help"),
+    ]
+    # Old assistant-with-tools that should be truncated.
+    big_content = "x" * 5000
+    big_args = json.dumps({
+        "file_path": "/data3/test/foo.py",
+        "content": big_content,
+    })
+    for i in range(num_old):
+        msgs.append(
+            LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[_make_tc("write_file", big_args, i)],
+            )
+        )
+        msgs.append(
+            LLMMessage(
+                role=Role.tool,
+                tool_call_id=f"tc_{i}",
+                name="write_file",
+                content=f"Wrote {i}",
+            )
+        )
+    # 8 newer messages — keep these full.
+    for i in range(8):
+        msgs.append(
+            LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[_make_tc("read_file", '{"path":"/x"}', 100 + i)],
+            )
+        )
+        msgs.append(
+            LLMMessage(
+                role=Role.tool,
+                tool_call_id=f"tc_{100+i}",
+                name="read_file",
+                content="ok",
+            )
+        )
+    return msgs
+
+
+class TestTruncateArgsValidJson:
+    def test_truncated_args_remain_valid_json(self):
+        loop = build_test_agent_loop()
+        loop.messages.reset(_build_history(num_old=10))
+
+        loop._truncate_old_tool_results()
+
+        # All assistant tool_calls.arguments must parse as valid JSON.
+        for m in loop.messages:
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                args = tc.function.arguments or ""
+                if not args:
+                    continue
+                # Must round-trip cleanly via the strict json parser.
+                parsed = json.loads(args)  # raises on invalid
+
+    def test_truncated_args_have_no_raw_control_chars(self):
+        loop = build_test_agent_loop()
+        loop.messages.reset(_build_history(num_old=10))
+
+        loop._truncate_old_tool_results()
+
+        for m in loop.messages:
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                args = (tc.function.arguments or "").encode("utf-8")
+                bad = [b for b in args if b < 0x20 and b not in (9, 10, 13)]
+                assert not bad, (
+                    f"arguments still has raw control bytes: "
+                    f"{[hex(b) for b in bad[:5]]} in {tc.function.arguments!r}"
+                )
+
+    def test_truncated_args_keep_identifying_field(self):
+        loop = build_test_agent_loop()
+        loop.messages.reset(_build_history(num_old=10))
+
+        loop._truncate_old_tool_results()
+
+        # The OLDEST assistant-with-tools message should be truncated;
+        # its stub should retain file_path so the model can still
+        # remember "I wrote /data3/test/foo.py earlier".
+        old_assistants = [
+            m for m in loop.messages
+            if m.role == Role.assistant and m.tool_calls
+        ]
+        # First few are the OLD ones (truncated).
+        oldest = old_assistants[0]
+        args = json.loads(oldest.tool_calls[0].function.arguments)
+        assert args.get("_truncated") is True
+        assert args.get("file_path") == "/data3/test/foo.py"
+        assert "_original_bytes" in args
+
+    def test_recent_args_not_touched(self):
+        loop = build_test_agent_loop()
+        loop.messages.reset(_build_history(num_old=10))
+
+        loop._truncate_old_tool_results()
+
+        # The LATEST 6 assistant-with-tools messages should keep their
+        # full args. Find them by argument size — newer ones use a small
+        # `'{"path":"/x"}'`, which stays untouched.
+        old_assistants = [
+            m for m in loop.messages
+            if m.role == Role.assistant and m.tool_calls
+        ]
+        recent = old_assistants[-6:]
+        for m in recent:
+            args = m.tool_calls[0].function.arguments
+            # Should NOT have the truncation marker.
+            assert '"_truncated"' not in args, (
+                f"recent args were truncated unexpectedly: {args[:120]}"
+            )
+
+    def test_idempotent_on_already_truncated(self):
+        loop = build_test_agent_loop()
+        loop.messages.reset(_build_history(num_old=10))
+
+        loop._truncate_old_tool_results()
+        # Snapshot truncated args.
+        first_pass = [
+            tc.function.arguments
+            for m in loop.messages if m.role == Role.assistant and m.tool_calls
+            for tc in m.tool_calls
+        ]
+        # Second pass — should be a no-op for already-truncated entries.
+        loop._truncate_old_tool_results()
+        second_pass = [
+            tc.function.arguments
+            for m in loop.messages if m.role == Role.assistant and m.tool_calls
+            for tc in m.tool_calls
+        ]
+        assert first_pass == second_pass

drydock_cli-2.7.6/tests/tools/test_search_replace_append_fallback.py

@@ -0,0 +1,121 @@
+"""Regression test: search_replace APPEND fallback for short raw content.
+
+Stress run on 2026-04-25 caught Gemma 4 stuck in a loop on
+`search_replace` calls that sent only a new function (no SEARCH/REPLACE
+blocks) — the safety check refused the overwrite ("would shrink file by
+N%"), the model retried the same call, and the prompt was lost. Model
+intent in those cases is to APPEND, not rewrite. New behavior: when the
+combined (existing + raw) text parses cleanly, append it; only refuse
+when an append would break the syntax.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from drydock.core.tools.base import BaseToolState, InvokeContext, ToolError
+from drydock.core.tools.builtins.search_replace import (
+    SearchReplace,
+    SearchReplaceArgs,
+    SearchReplaceConfig,
+    SearchReplaceResult,
+)
+
+
+@pytest.fixture
+def tool():
+    return SearchReplace(SearchReplaceConfig(), BaseToolState())
+
+
+@pytest.fixture
+def big_existing_py(tmp_path: Path) -> Path:
+    """A 2000+ char Python file the model would consider 'done'."""
+    src = "# big existing module\n"
+    for i in range(50):
+        src += f"\n\ndef existing_{i}(x):\n    return x * {i}\n"
+    p = tmp_path / "tools.py"
+    p.write_text(src)
+    return p
+
+
+@pytest.fixture
+def ctx() -> InvokeContext:
+    return InvokeContext(tool_call_id="tc_1", read_file_state={})
+
+
+async def _run_to_result(tool, args, ctx):
+    last = None
+    async for event in tool.run(args, ctx):
+        last = event
+    return last
+
+
+@pytest.mark.asyncio
+async def test_append_when_combined_parses(tool, big_existing_py, ctx):
+    """Raw content that's a valid new def → append onto the existing file."""
+    raw = "def is_prime(n):\n    if n < 2:\n        return False\n    return all(n % i for i in range(2, int(n**0.5)+1))\n"
+    args = SearchReplaceArgs(file_path=str(big_existing_py), content=raw)
+
+    result = await _run_to_result(tool, args, ctx)
+
+    assert isinstance(result, SearchReplaceResult), f"got {type(result).__name__}: {result}"
+    assert result.blocks_applied == 1
+    assert any("Appended" in w for w in result.warnings)
+
+    final = big_existing_py.read_text()
+    assert "def is_prime(n):" in final
+    assert "def existing_0(x):" in final  # existing kept
+    assert "def existing_49(x):" in final
+
+
+@pytest.mark.asyncio
+async def test_refuses_when_append_would_break_syntax(tool, big_existing_py, ctx):
+    """Raw content that would yield a SyntaxError when appended → refuse."""
+    raw = "def broken(x:\n  return"  # invalid python
+    args = SearchReplaceArgs(file_path=str(big_existing_py), content=raw)
+
+    with pytest.raises(ToolError) as excinfo:
+        await _run_to_result(tool, args, ctx)
+
+    msg = str(excinfo.value)
+    assert "REFUSED" in msg
+    assert "syntax" in msg.lower()
+    # Existing file untouched
+    final = big_existing_py.read_text()
+    assert "broken(x:" not in final
+
+
+@pytest.mark.asyncio
+async def test_non_python_short_raw_appends(tool, tmp_path: Path, ctx):
+    """For non-.py files we don't AST-check — append always wins (no
+    syntax to break). Repro of the loop pattern: model sends a small
+    fragment, file is much larger, append succeeds."""
+    target = tmp_path / "data.txt"
+    target.write_text("line1\nline2\nline3\nline4\n" * 80)  # ~2000 bytes
+    # Need >20 chars to enter the fallback branch.
+    raw = "appended_marker_line that is long enough to clear the 20-char gate\n"
+    args = SearchReplaceArgs(file_path=str(target), content=raw)
+
+    result = await _run_to_result(tool, args, ctx)
+    assert isinstance(result, SearchReplaceResult)
+    final = target.read_text()
+    assert "appended_marker_line" in final
+    assert "line1" in final  # existing preserved
+
+
+@pytest.mark.asyncio
+async def test_small_existing_file_still_overwrites(tool, tmp_path: Path, ctx):
+    """Existing < 500 bytes — pre-existing behavior (full overwrite) is
+    preserved because the safety check only fires above 500 bytes."""
+    target = tmp_path / "tiny.py"
+    target.write_text("x = 1\n")
+    # >20 chars so fallback fires; existing<500 so overwrite path runs.
+    raw = "y = 2\nz = 3\nlong_enough_to_clear_the_20_char_gate = 1\n"
+    args = SearchReplaceArgs(file_path=str(target), content=raw)
+
+    result = await _run_to_result(tool, args, ctx)
+    assert isinstance(result, SearchReplaceResult)
+    final = target.read_text()
+    # Existing < 500 bytes, so OVERWRITE path runs (not append).
+    assert final.strip() == raw.strip()

drydock_cli-2.7.5/.auto_release.lock

@@ -1 +0,0 @@
-3714091