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

drydock_cli-2.7.32/.auto_release.lock

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.31
+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.31 → 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.31 → 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,

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.31 → drydock_cli-2.7.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.31"
+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.32/tests/tools/test_search_replace_file_not_found.py

@@ -0,0 +1,109 @@
+"""Regression test: search_replace returns advisory result when file does not exist.
+
+Admiral logs (2026-05-02) showed 18 instances of retry_after_error:search_replace
+with error head '<tool_error>search_replace failed: File does not exist: /dat...' —
+the model was trying to edit a path that didn't exist and retrying it 18+ times
+because the ToolError gave no actionable guidance (no directory listing, no suggestion
+to use write_file).
+
+Fix: catch the "File does not exist" ToolError in run() and yield a SearchReplaceResult
+with the parent directory listing and a write_file suggestion. On 2nd+ retry for the
+same path, include a project-wide .py file listing.
+"""
+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
+
+
+def _make_tool(tmp_path, cwd=None):
+    state = BaseToolState()
+    config = SearchReplaceConfig()
+    tool = SearchReplace(state=state, config=config)
+    return tool, state
+
+
+@pytest.mark.asyncio
+async def test_file_not_found_returns_advisory_not_tool_error(tmp_path):
+    """search_replace on a nonexistent file yields a result, not raises."""
+    os.chdir(tmp_path)
+    tool, _ = _make_tool(tmp_path)
+    args = SearchReplaceArgs(
+        file_path="nonexistent_module.py",
+        content="<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE",
+    )
+    results = await _collect(tool.run(args))
+    assert results, "expected at least one result"
+    result = results[-1]
+    assert isinstance(result, SearchReplaceResult)
+    assert result.blocks_applied == 0
+    assert "FILE NOT FOUND" in result.content or "does not exist" in result.content.lower()
+
+
+@pytest.mark.asyncio
+async def test_file_not_found_includes_directory_listing(tmp_path):
+    """Advisory result includes sibling file names when parent dir exists."""
+    os.chdir(tmp_path)
+    (tmp_path / "existing.py").write_text("# existing")
+    (tmp_path / "other.py").write_text("# other")
+    tool, _ = _make_tool(tmp_path)
+    args = SearchReplaceArgs(
+        file_path="missing.py",
+        content="<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE",
+    )
+    results = await _collect(tool.run(args))
+    result = results[-1]
+    assert isinstance(result, SearchReplaceResult)
+    assert "existing.py" in result.content or "other.py" in result.content
+
+
+@pytest.mark.asyncio
+async def test_file_not_found_escalates_on_second_call(tmp_path):
+    """Second call for the same missing file includes project-wide listing hint."""
+    os.chdir(tmp_path)
+    (tmp_path / "real.py").write_text("# real")
+    tool, _ = _make_tool(tmp_path)
+    args = SearchReplaceArgs(
+        file_path="ghost.py",
+        content="<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE",
+    )
+    # First call
+    await _collect(tool.run(args))
+    # Second call with same missing path
+    results = await _collect(tool.run(args))
+    result = results[-1]
+    assert isinstance(result, SearchReplaceResult)
+    assert "REPEATED ERROR" in result.content
+    assert "write_file" in result.content
+
+
+@pytest.mark.asyncio
+async def test_file_not_found_suggests_write_file(tmp_path):
+    """Advisory result always suggests write_file as the creation alternative."""
+    os.chdir(tmp_path)
+    tool, _ = _make_tool(tmp_path)
+    args = SearchReplaceArgs(
+        file_path="new_module.py",
+        content="<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE",
+    )
+    results = await _collect(tool.run(args))
+    result = results[-1]
+    assert isinstance(result, SearchReplaceResult)
+    assert "write_file" in result.content

{drydock_cli-2.7.31 → drydock_cli-2.7.32}/tests/tools/test_search_replace_no_op_loop_breaker.py

@@ -113,6 +113,33 @@ async def test_noop_edit_does_not_write_file(tool, py_file, ctx):
     )
 
 
+@pytest.mark.asyncio
+async def test_noop_edit_text_not_in_file_returns_already_correct(tool, py_file, ctx):
+    """When SEARCH == REPLACE and the text is NOT in the file, return ALREADY CORRECT early.
+
+    Previously this would fall through to the 'search text not found' error path,
+    causing the model to loop. With the early short-circuit, it returns ALREADY CORRECT
+    regardless of whether the search text exists in the file.
+    """
+    ctx.read_file_state[str(py_file)] = {
+        "content": py_file.read_text(),
+        "timestamp": py_file.stat().st_mtime_ns,
+        "offset": 0,
+        "limit": None,
+    }
+    phantom_text = "    this_text_is_not_in_the_file = True"
+    content = f"<<<<<<< SEARCH\n{phantom_text}\n=======\n{phantom_text}\n>>>>>>> REPLACE\n"
+    args = SearchReplaceArgs(file_path=str(py_file), content=content)
+
+    result = await _run_to_result(tool, args, ctx)
+
+    assert isinstance(result, SearchReplaceResult)
+    assert "ALREADY CORRECT" in result.content, (
+        f"Expected ALREADY CORRECT advisory for byte-identical no-op, got: {result.content!r}"
+    )
+    assert result.lines_changed == 0
+
+
 @pytest.mark.asyncio
 async def test_real_edit_still_works(tool, py_file, ctx):
     """A genuine edit still succeeds and produces a non-zero lines_changed or new content."""