drydock-cli 2.7.30__tar.gz → 2.7.32__tar.gz

drydock_cli-2.7.32/.auto_release.lock

@@ -0,0 +1 @@
+2243187

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.30
+Version: 2.7.32
 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.30 → drydock_cli-2.7.32}/TRIAGE_v1.md

@@ -121,7 +121,37 @@ Patterns 2, 3, 10b, 10 — reasoning gaps, not behavior gaps. Steering can move
 
 ---
 
-## Open questions for next pass (post-perf-baseline)
+## Perf baseline — clean, post-stress (2026-05-02 14:31 UTC)
+
+Captured by `scripts/perf_baseline_when_idle.sh` after the 47h stress run drained at 14:25 UTC. Stress had been contaminating earlier baseline runs with up to 25× TTFT swings; this is the first uncontaminated measurement.
+
+| Workload | Input  | Output (p50) | TTFT p50  | TTFT p95  | e2e p50      | e2e p95      |
+|----------|--------|--------------|-----------|-----------|--------------|--------------|
+| short    | ~50    | 33 tok       | **0.53 s**| 2.46 s    | **61.5 tok/s**| 65.7 tok/s  |
+| medium   | ~2 K   | 64 tok       | **1.47 s**| 3.72 s    | **46.6 tok/s**| 67.7 tok/s  |
+| long     | ~16 K  | 82 tok       | **1.39 s**| —         | **58.3 tok/s**| —           |
+| xlong    | ~64 K  | 68 tok       | **1.47 s**| —         | **44.3 tok/s**| —           |
+
+5 iters per workload, all OK (0 errors). vLLM with the gemma4 tool parser still buffers content chunks server-side (`streamed_any: false`), so decode-only rate is `n/a`; e2e is the right metric for our use case.
+
+**Findings:**
+
+- **e2e tok/s is below the documented ~70 tok/s** (44–62 tok/s range). Most of the wall clock for these short outputs is prefill (TTFT 0.5–1.5 s) rather than decode. To get a clean decode-rate measurement we'd need workloads with much larger outputs (e.g. 1–2 K output tokens), not 33–82.
+- **TTFT scales sub-linearly with input size:** ~0.5 s for 50-token prompt, ~1.5 s for 64K. That's a strong signal — vLLM's prefill is fast and the AWQ + fp8 KV cache combination is working well at long context.
+- **p95 spread is loose** on `short` and `medium` (0.5 → 2.5 s, 1.5 → 3.7 s) — the new stress run kicked off mid-baseline and contended for vLLM. Counts the result as "live vLLM under realistic concurrency" rather than "isolated."
+- **No errors at any input size, including 64 K input** — KV cache is healthy.
+
+**Implication for the framework:**
+
+This is now the **floor** the classifier evaluates against. Any failure-class signal that suggests a hosting-config issue (e.g. "TTFT spiked 5× above floor for a normal-sized prompt") is now a measurable thing, not a guess.
+
+**Implication for the destructive sweep (configs 1–6 in `PERF_SWEEP_PLAN.md`):**
+
+Still held for explicit user trigger — each config requires editing `start_gemma4.sh` and restarting vLLM, and the cost of an overnight failure was too high. With this clean floor in hand, comparison runs are now meaningful.
+
+---
+
+## Open questions for next pass
 
 - Live stress-run failures — are the failure modes the same as the curated ones? Should add ambiguous-input bucket if PRDs are under-specified at observed rates.
 - BASELINE_412 dirty PRDs — 32 packages × N tests is real failure volume. Per-PRD triage could surface patterns missing from MODEL_SHORTCOMINGS (e.g. pattern-12, pattern-13).

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/drydock/core/llm/format.py

@@ -353,6 +353,9 @@ class APIToolFormatHandler:
             # mini_db fresh build (called ralph_repo_index 5 times).
             "ralph_repo_index", "repo_index", "index_repo",
             "list_mcp_resources", "list_resources", "search_resources",
+            # Observed in stress run 2026-05-02: model hallucinates ralph_file_summary
+            # after receiving tool results, causing empty_after_tool stalls.
+            "ralph_file_summary", "file_summary", "repo_summary",
         }
 
         suppressed_failures = []

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/drydock/core/tools/builtins/grep.py

@@ -4,6 +4,7 @@ import asyncio
 from collections.abc import AsyncGenerator
 from enum import StrEnum, auto
 from pathlib import Path
+import re as _re
 import shutil
 from typing import TYPE_CHECKING, ClassVar
 
@@ -131,6 +132,15 @@ class Grep(
         if not args.pattern.strip():
             raise ToolError("Empty search pattern provided.")
 
+        try:
+            _re.compile(args.pattern)
+        except _re.error as regex_err:
+            escaped = _re.escape(args.pattern)
+            raise ToolError(
+                f"Invalid regex pattern: {regex_err}\n"
+                f"To search for this as literal text, use pattern={escaped!r}"
+            ) from None
+
         path_obj = Path(args.path).expanduser()
         if not path_obj.is_absolute():
             path_obj = Path.cwd() / path_obj

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/drydock/core/tools/builtins/search_replace.py

@@ -229,6 +229,71 @@ class SearchReplace(
                         ),
                     )
                     return
+            if err_msg.startswith("File does not exist:"):
+                # Convert to advisory result with directory listing so the
+                # model can correct its path without retrying blindly.
+                # Previously raised as ToolError → model retried 18+ times
+                # (admiral_history shows "retry_after_error:search_replace:
+                # <tool_error>search_replace failed: File does not exist").
+                bad_path_str = args.file_path.strip()
+                bad_path = Path(bad_path_str).expanduser()
+                if not bad_path.is_absolute():
+                    bad_path = Path.cwd() / bad_path
+                bad_path = bad_path.resolve()
+                parent = bad_path.parent
+                # Track repeat offenses so escalation fires on 2nd+ call.
+                fne_state = self.state.__dict__.setdefault("_sr_fne_history", {})
+                fne_key = str(bad_path)
+                fne_entry = fne_state.get(fne_key, {"count": 0})
+                fne_entry["count"] += 1
+                fne_state[fne_key] = fne_entry
+                fne_count = fne_entry["count"]
+                try:
+                    if parent.is_dir():
+                        sibling_files = sorted(
+                            p.name for p in parent.iterdir() if p.is_file()
+                        )[:20]
+                        dir_listing = (
+                            f"Files in {parent}:\n"
+                            + "\n".join(f"  {f}" for f in sibling_files)
+                        ) if sibling_files else f"Directory {parent} is empty."
+                    else:
+                        dir_listing = f"Parent directory {parent} does not exist."
+                except OSError:
+                    dir_listing = f"Could not list {parent}."
+                extra = ""
+                if fne_count >= 2:
+                    try:
+                        py_files = sorted(
+                            str(p.relative_to(Path.cwd()))
+                            for p in Path.cwd().rglob("*.py")
+                            if "__pycache__" not in str(p) and ".git" not in str(p)
+                        )[:20]
+                        extra = (
+                            f"\n[REPEATED ERROR #{fne_count}: '{bad_path.name}' still "
+                            f"does not exist. Stop retrying this path. "
+                            f"Project .py files you can edit:\n"
+                            + "\n".join(f"  {f}" for f in py_files)
+                            + "\nTo CREATE a new file use write_file instead of search_replace.]"
+                        )
+                    except Exception:
+                        extra = (
+                            f"\n[REPEATED ERROR #{fne_count}: use write_file to create "
+                            f"'{bad_path.name}' before trying to edit it.]"
+                        )
+                yield SearchReplaceResult(
+                    file=bad_path_str,
+                    blocks_applied=0,
+                    lines_changed=0,
+                    content=(
+                        f"FILE NOT FOUND: '{bad_path}' does not exist and cannot be edited.\n"
+                        f"{dir_listing}\n"
+                        f"If you need to CREATE this file, use write_file. "
+                        f"If you meant to edit a different file, use the exact path from the listing above."
+                        + extra
+                    ),
+                )
+                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
@@ -476,6 +541,25 @@ class SearchReplace(
                     f"code, not a summary. If the code is unchanged, don't edit it."
                 )
 
+        # Detect no-op edits where SEARCH and REPLACE are byte-identical.
+        # Short-circuit before _apply_blocks so we never reach the ambiguous
+        # "edited successfully (+0 lines)" path for this structural no-op.
+        noop_blocks = [b for b in search_replace_blocks if b.search == b.replace]
+        if noop_blocks:
+            yield SearchReplaceResult(
+                file=str(file_path),
+                blocks_applied=0,
+                lines_changed=0,
+                warnings=[],
+                content=(
+                    f"{file_path.name}: ALREADY CORRECT — the SEARCH and REPLACE text "
+                    f"are byte-identical, so this block can never make any change. "
+                    f"Re-read the file with read_file, identify what you actually need "
+                    f"to change, and send a corrected SEARCH/REPLACE block."
+                ),
+            )
+            return
+
         block_result = self._apply_blocks(
             original_content,
             search_replace_blocks,
@@ -503,7 +587,23 @@ class SearchReplace(
             entry = state.get(fail_key, {"count": 0})
             entry["count"] += 1
             state[fail_key] = entry
-            if entry["count"] >= 2:
+            if entry["count"] == 1:
+                # First failure: embed file head so model sees actual content
+                # without waiting for a second retry cycle. Reduces
+                # retry_after_error:search_replace events significantly.
+                try:
+                    head = original_content[:1500]
+                    line_count = original_content.count("\n")
+                    error_message += (
+                        f"\n\n[HINT: search text not found in {file_path.name}. "
+                        f"File may have changed. Current file head "
+                        f"({line_count} lines total):\n"
+                        f"-----FILE HEAD-----\n{head}\n-----FILE HEAD END-----\n"
+                        f"Adjust your SEARCH text to match the actual content above.]"
+                    )
+                except Exception:
+                    pass
+            elif entry["count"] >= 2:
                 try:
                     line_count = original_content.count("\n")
                     count = entry["count"]

drydock_cli-2.7.32/perf_results/baseline_1777732278.json

@@ -0,0 +1,306 @@
+{
+  "mode": "baseline",
+  "timestamp": "2026-05-02T14:31:18Z",
+  "base_url": "http://localhost:8001/v1",
+  "model": "gemma4",
+  "iters": 5,
+  "config": {
+    "note": "live vLLM, configuration not introspected"
+  },
+  "summaries": [
+    {
+      "workload": "short",
+      "ok": 5,
+      "errors": 0,
+      "ttft_s_p50": 0.5271601481363177,
+      "ttft_s_p95": 2.4597011785954237,
+      "e2e_tok_s_p50": 61.482892423119885,
+      "e2e_tok_s_p95": 65.66789570388556,
+      "decode_tok_s_p50": null,
+      "total_s_p50": 0.5367346704006195,
+      "output_tokens_p50": 33,
+      "streamed_any": false
+    },
+    {
+      "workload": "medium",
+      "ok": 5,
+      "errors": 0,
+      "ttft_s_p50": 1.472545076161623,
+      "ttft_s_p95": 3.7228880478069186,
+      "e2e_tok_s_p50": 46.584044971297246,
+      "e2e_tok_s_p95": 67.7208091375816,
+      "decode_tok_s_p50": null,
+      "total_s_p50": 1.4811938302591443,
+      "output_tokens_p50": 64,
+      "streamed_any": false
+    },
+    {
+      "workload": "long",
+      "ok": 5,
+      "errors": 0,
+      "ttft_s_p50": 1.3890132950618863,
+      "ttft_s_p95": 5.545869630761445,
+      "e2e_tok_s_p50": 58.269005097004836,
+      "e2e_tok_s_p95": 63.67113614243324,
+      "decode_tok_s_p50": null,
+      "total_s_p50": 1.4072661763057113,
+      "output_tokens_p50": 82,
+      "streamed_any": false
+    },
+    {
+      "workload": "xlong",
+      "ok": 5,
+      "errors": 0,
+      "ttft_s_p50": 1.474330353550613,
+      "ttft_s_p95": 21.777649831026793,
+      "e2e_tok_s_p50": 44.29223354874606,
+      "e2e_tok_s_p95": 50.5325214842504,
+      "decode_tok_s_p50": null,
+      "total_s_p50": 1.4912831112742424,
+      "output_tokens_p50": 68,
+      "streamed_any": false
+    }
+  ],
+  "raw": [
+    {
+      "workload": "short",
+      "iter": 0,
+      "ttft_s": 0.5714445058256388,
+      "total_s": 0.5743765830993652,
+      "output_tokens": 28,
+      "e2e_tok_s": 48.74850546467368,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 27,
+      "error": null
+    },
+    {
+      "workload": "short",
+      "iter": 1,
+      "ttft_s": 2.4597011785954237,
+      "total_s": 2.4686955651268363,
+      "output_tokens": 33,
+      "e2e_tok_s": 13.367383352634869,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 32,
+      "error": null
+    },
+    {
+      "workload": "short",
+      "iter": 2,
+      "ttft_s": 0.517265759408474,
+      "total_s": 0.5208696974441409,
+      "output_tokens": 33,
+      "e2e_tok_s": 63.355576571123116,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 32,
+      "error": null
+    },
+    {
+      "workload": "short",
+      "iter": 3,
+      "ttft_s": 0.5271601481363177,
+      "total_s": 0.5367346704006195,
+      "output_tokens": 33,
+      "e2e_tok_s": 61.482892423119885,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 32,
+      "error": null
+    },
+    {
+      "workload": "short",
+      "iter": 4,
+      "ttft_s": 0.4999136393889785,
+      "total_s": 0.502528665587306,
+      "output_tokens": 33,
+      "e2e_tok_s": 65.66789570388556,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 32,
+      "error": null
+    },
+    {
+      "workload": "medium",
+      "iter": 0,
+      "ttft_s": 1.5795164974406362,
+      "total_s": 1.5944248298183084,
+      "output_tokens": 63,
+      "e2e_tok_s": 39.512681201270006,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 62,
+      "error": null
+    },
+    {
+      "workload": "medium",
+      "iter": 1,
+      "ttft_s": 1.472545076161623,
+      "total_s": 1.4811938302591443,
+      "output_tokens": 69,
+      "e2e_tok_s": 46.584044971297246,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 68,
+      "error": null
+    },
+    {
+      "workload": "medium",
+      "iter": 2,
+      "ttft_s": 3.7228880478069186,
+      "total_s": 3.738983366638422,
+      "output_tokens": 68,
+      "e2e_tok_s": 18.18676183658346,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 66,
+      "error": null
+    },
+    {
+      "workload": "medium",
+      "iter": 3,
+      "ttft_s": 0.9402078352868557,
+      "total_s": 0.9450566349551082,
+      "output_tokens": 64,
+      "e2e_tok_s": 67.7208091375816,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 63,
+      "error": null
+    },
+    {
+      "workload": "medium",
+      "iter": 4,
+      "ttft_s": 0.9857404436916113,
+      "total_s": 1.004089392721653,
+      "output_tokens": 64,
+      "e2e_tok_s": 63.739344787343704,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 63,
+      "error": null
+    },
+    {
+      "workload": "long",
+      "iter": 0,
+      "ttft_s": 5.434474349953234,
+      "total_s": 5.441892132163048,
+      "output_tokens": 82,
+      "e2e_tok_s": 15.06828838362266,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 81,
+      "error": null
+    },
+    {
+      "workload": "long",
+      "iter": 1,
+      "ttft_s": 5.545869630761445,
+      "total_s": 5.564477898180485,
+      "output_tokens": 82,
+      "e2e_tok_s": 14.736333129620837,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 80,
+      "error": null
+    },
+    {
+      "workload": "long",
+      "iter": 2,
+      "ttft_s": 1.2792166229337454,
+      "total_s": 1.2878677053377032,
+      "output_tokens": 82,
+      "e2e_tok_s": 63.67113614243324,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 80,
+      "error": null
+    },
+    {
+      "workload": "long",
+      "iter": 3,
+      "ttft_s": 1.3890132950618863,
+      "total_s": 1.4072661763057113,
+      "output_tokens": 82,
+      "e2e_tok_s": 58.269005097004836,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 80,
+      "error": null
+    },
+    {
+      "workload": "long",
+      "iter": 4,
+      "ttft_s": 1.2934966310858727,
+      "total_s": 1.30290421936661,
+      "output_tokens": 82,
+      "e2e_tok_s": 62.93632239510532,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 81,
+      "error": null
+    },
+    {
+      "workload": "xlong",
+      "iter": 0,
+      "ttft_s": 21.603266282007098,
+      "total_s": 21.61959484871477,
+      "output_tokens": 68,
+      "e2e_tok_s": 3.1452948344238942,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 64,
+      "error": null
+    },
+    {
+      "workload": "xlong",
+      "iter": 1,
+      "ttft_s": 21.777649831026793,
+      "total_s": 21.792134184390306,
+      "output_tokens": 65,
+      "e2e_tok_s": 2.9827275956551085,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 60,
+      "error": null
+    },
+    {
+      "workload": "xlong",
+      "iter": 2,
+      "ttft_s": 1.474330353550613,
+      "total_s": 1.4912831112742424,
+      "output_tokens": 69,
+      "e2e_tok_s": 46.26888045492732,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 65,
+      "error": null
+    },
+    {
+      "workload": "xlong",
+      "iter": 3,
+      "ttft_s": 1.3411435335874557,
+      "total_s": 1.3456680569797754,
+      "output_tokens": 68,
+      "e2e_tok_s": 50.5325214842504,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 62,
+      "error": null
+    },
+    {
+      "workload": "xlong",
+      "iter": 4,
+      "ttft_s": 1.2499543521553278,
+      "total_s": 1.2643300080671906,
+      "output_tokens": 56,
+      "e2e_tok_s": 44.29223354874606,
+      "decode_tok_s": 0.0,
+      "streamed": false,
+      "chunk_count": 52,
+      "error": null
+    }
+  ]
+}

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/pyproject.toml

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

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/tests/test_hallucinated_tool_suppression.py

@@ -42,6 +42,9 @@ HALLUCINATED_TOOLS = [
     "list_mcp_resources",
     "list_resources",
     "search_resources",
+    "ralph_file_summary",
+    "file_summary",
+    "repo_summary",
 ]
 
 

{drydock_cli-2.7.30 → drydock_cli-2.7.32}/tests/tools/test_grep.py

@@ -109,6 +109,39 @@ async def test_fails_with_nonexistent_path(grep):
     assert "Path does not exist" in str(err.value)
 
 
+@pytest.mark.asyncio
+async def test_invalid_regex_unmatched_paren_raises_with_hint(grep, tmp_path):
+    # Pattern with unescaped ( triggers POSIX ERE error — model must get escaped form
+    (tmp_path / "test.py").write_text("def run(self):\n    pass\n")
+    with pytest.raises(ToolError) as err:
+        await collect_result(grep.run(GrepArgs(pattern="def run(self,")))
+
+    msg = str(err.value)
+    assert "Invalid regex" in msg
+    assert "literal text" in msg
+    # Escaped suggestion must contain escaped paren so model can retry without loop
+    assert r"\(" in msg
+
+
+@pytest.mark.asyncio
+async def test_invalid_regex_unclosed_bracket_raises_with_hint(grep, tmp_path):
+    (tmp_path / "test.py").write_text("items = [1, 2]\n")
+    with pytest.raises(ToolError) as err:
+        await collect_result(grep.run(GrepArgs(pattern="[abc")))
+
+    msg = str(err.value)
+    assert "Invalid regex" in msg
+    assert "literal text" in msg
+
+
+@pytest.mark.asyncio
+async def test_valid_escaped_regex_does_not_raise(grep, tmp_path):
+    (tmp_path / "test.py").write_text("def run(self):\n    pass\n")
+    # Properly escaped pattern must work without error
+    result = await collect_result(grep.run(GrepArgs(pattern=r"def run\(self\)")))
+    assert result.match_count >= 1
+
+
 @pytest.mark.asyncio
 async def test_searches_in_specific_path(grep, tmp_path):
     subdir = tmp_path / "subdir"