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

drydock_cli-2.7.19/.auto_release.lock

@@ -0,0 +1 @@
+361748

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.17
+Version: 2.7.19
 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.17 → drydock_cli-2.7.19}/drydock/core/llm/format.py

@@ -412,7 +412,7 @@ class APIToolFormatHandler:
                         tool_name=parsed_call.tool_name,
                         call_id=parsed_call.call_id,
                         error=(
-                            f"{parsed_call.tool_name}: your call used a "
+                            f"your call used a "
                             f"truncated history entry as a template (it contained "
                             f"'_truncated'/'_original_bytes' instead of real "
                             f"arguments).{file_embed} Provide the full required arguments."
@@ -438,11 +438,56 @@ class APIToolFormatHandler:
                     and "path" in error_str
                     and "Field required" in error_str
                 ):
+                    # Try to infer path from the first comment line of content.
+                    # Gemma 4 frequently calls write_file(content="...") without path.
+                    content_val = parsed_call.raw_args.get("content", "")
+                    inferred_path: str | None = None
+                    if content_val:
+                        for _line in content_val.splitlines()[:5]:
+                            _line = _line.strip()
+                            _m = _re.match(
+                                r'^#\s+([\w./+-]+\.(?:py|js|ts|json|yaml|yml|toml|md|txt|sh|cfg|ini))\s*$',
+                                _line,
+                            )
+                            if _m:
+                                inferred_path = _m.group(1)
+                                break
+                    if inferred_path:
+                        try:
+                            _new_args = dict(parsed_call.raw_args)
+                            _new_args["path"] = inferred_path
+                            validated_args = args_model.model_validate(_new_args)
+                            resolved_calls.append(
+                                ResolvedToolCall(
+                                    tool_name=parsed_call.tool_name,
+                                    tool_class=tool_class,
+                                    validated_args=validated_args,
+                                    call_id=parsed_call.call_id,
+                                )
+                            )
+                            continue
+                        except ValidationError:
+                            pass
+                    # List project .py files as hints so the model can pick the right one
+                    _candidates: list[str] = []
+                    try:
+                        _candidates = [
+                            str(p.relative_to(Path.cwd()))
+                            for p in sorted(Path.cwd().rglob("*.py"))
+                            if "__pycache__" not in str(p) and ".git" not in str(p)
+                        ][:12]
+                    except Exception:
+                        pass
+                    _hint = (
+                        f"Project .py files: {', '.join(_candidates)}"
+                        if _candidates
+                        else "Use read_file or glob to list available files."
+                    )
                     error_msg = (
-                        "write_file: missing required `path` parameter. "
-                        "You must pass BOTH `path` AND `content` as separate arguments. "
-                        'Fix: write_file(path="your/file.py", content="..."). '
-                        "Do NOT omit `path`."
+                        "missing required `path` parameter. "
+                        "You must pass BOTH `path` AND `content` as separate arguments: "
+                        'write_file(path="pkg/file.py", content="..."). '
+                        f"Do NOT omit `path`. {_hint}"
                     )
                 else:
                     error_msg = f"Invalid arguments: {e}"

{drydock_cli-2.7.17 → drydock_cli-2.7.19}/drydock/core/tools/builtins/read_file.py

@@ -45,7 +45,7 @@ class ReadFileResult(BaseModel):
     content: str
     lines_read: int
     was_truncated: bool = Field(
-        description="True if the reading was stopped due to the max_read_bytes limit."
+        description="True if the reading was stopped due to the line limit or max_read_bytes limit."
     )
 
 
@@ -111,25 +111,48 @@ class ReadFile(
             and prior.get("offset") == args.offset
             and prior.get("limit") == args.limit
         ):
+            # Re-embed the cached content so the model has it even if the
+            # earlier tool_result was truncated by _truncate_old_tool_results.
+            # Pointing at a stale/truncated prior result causes re-read loops.
+            cached_content = prior.get("content", "")
+            prior_lines = prior.get("lines_read", 0)
+            dedup_count = prior.get("dedup_count", 0)
+            if dedup_count == 0:
+                header = "[Unchanged since last read — content re-embedded]\n"
+            else:
+                header = (
+                    f"[REPEATED READ #{dedup_count + 1}: file has not changed across your last "
+                    f"{dedup_count + 1} reads with these exact arguments. "
+                    f"Reading again will produce this same result. "
+                    f"To make progress: write or edit a file, use offset= to read a different section, "
+                    f"or move on to the next task.]\n"
+                )
+            if read_state is not None:
+                read_state[path_key] = {**prior, "dedup_count": dedup_count + 1}
             yield ReadFileResult(
                 path=path_key,
-                content=(
-                    "<system-reminder>\n"
-                    f"File unchanged since your earlier read this session "
-                    f"({file_path.name}, mtime unchanged, same offset/limit). "
-                    "Use the content from the earlier Read tool_result — "
-                    "do NOT re-read. If you need to take action, call "
-                    "search_replace or write_file on what you already have.\n"
-                    "</system-reminder>"
-                ),
-                lines_read=0,
-                was_truncated=True,
+                content=f"{header}{cached_content}",
+                lines_read=prior_lines,
+                was_truncated=prior.get("was_truncated", False),
             )
             return
 
         read_result = await self._read_file(args, file_path)
         content = "".join(read_result.lines)
 
+        # When stopped by the line limit (not byte limit), append a hint so
+        # the model knows to paginate with offset= instead of re-reading.
+        if (
+            read_result.was_truncated
+            and args.limit is not None
+            and len(read_result.lines) == args.limit
+        ):
+            next_offset = args.offset + args.limit
+            content += (
+                f"\n[lines {args.offset + 1}–{next_offset} shown; "
+                f"use offset={next_offset} to read more]"
+            )
+
         # Record read state so Write/Edit can enforce Read-before-Write
         # and so future re-reads can dedup against this one.
         if read_state is not None:
@@ -138,6 +161,8 @@ class ReadFile(
                 "timestamp": current_mtime,
                 "offset": args.offset,
                 "limit": args.limit,
+                "lines_read": len(read_result.lines),
+                "was_truncated": read_result.was_truncated,
             }
 
         yield ReadFileResult(
@@ -195,6 +220,7 @@ class ReadFile(
                         continue
 
                     if args.limit is not None and len(lines_to_return) >= args.limit:
+                        was_truncated = True
                         break
 
                     line_bytes = len(line.encode("utf-8"))

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

@@ -131,6 +131,46 @@ 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("Empty content provided.") or err_msg.startswith("File path is required."):
+                # Model sent search_replace with missing content or file_path.
+                # Convert to a soft result so the model corrects — a ToolError
+                # causes panic-retry loops (feedback: never raise ToolError for
+                # loop detection). Track count to escalate on repeat offenses.
+                empty_state = self.state.__dict__.setdefault("_sr_empty_history", {})
+                key = args.file_path.strip() or "<no-path>"
+                entry = empty_state.get(key, {"count": 0})
+                entry["count"] += 1
+                empty_state[key] = entry
+                count = entry["count"]
+                escalate = count >= 2
+                extra = ""
+                if escalate:
+                    # Show project files so model can recover context
+                    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[This is the #{count} empty search_replace on '{key}'. "
+                            f"Stop retrying. Current .py files in project:\n"
+                            + "\n".join(f"  {f}" for f in py_files)
+                            + "\nUse write_file to create a file, or read_file to "
+                            f"see file contents before editing.]"
+                        )
+                    except Exception:
+                        extra = (
+                            f"\n[This is the #{count} empty search_replace on '{key}'. "
+                            "Stop retrying. Use write_file or read the file first.]"
+                        )
+                yield SearchReplaceResult(
+                    file=key,
+                    blocks_applied=0,
+                    lines_changed=0,
+                    content=err_msg + extra,
+                )
+                return
             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

{drydock_cli-2.7.17 → drydock_cli-2.7.19}/drydock/core/tools/builtins/write_file.py

@@ -735,6 +735,19 @@ class WriteFile(
             file_path = Path.cwd() / file_path
         file_path = file_path.resolve()
 
+        if file_path.is_dir():
+            try:
+                children = sorted(p.name for p in file_path.iterdir())[:20]
+                listing = ", ".join(children) if children else "(empty)"
+            except OSError:
+                listing = "(unreadable)"
+            raise ToolError(
+                f"'{file_path}' is a directory, not a file. "
+                f"Specify the exact file path inside it.\n"
+                f"Files in that directory: {listing}\n"
+                f"Example: {file_path}/{children[0] if children else 'yourfile.py'}"
+            )
+
         file_existed = file_path.exists()
 
         if file_existed and not args.overwrite:

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

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

drydock_cli-2.7.19/tests/test_write_file_missing_path.py

@@ -0,0 +1,75 @@
+"""Regression test: write_file missing-path loop fix.
+
+Stress run 2026-04-28 showed Gemma 4 calling write_file(content="...")
+without a path. format.py returned "write_file: missing required `path`..."
+and agent_loop.py wrapped it as "<tool_error>write_file: write_file: ..."
+producing a confusing double-prefix. Also, the error message placeholder
+"your/file.py" gave the model no real hint.
+
+Fixes in format.py:
+1. Remove tool-name prefix from error msg (agent_loop adds it already).
+2. When content first line is "# filename.py", infer path and succeed.
+3. When path can't be inferred, include project .py file listing in error.
+"""
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from drydock.core.llm.format import APIToolFormatHandler, ParsedMessage, ParsedToolCall
+
+
+def _make_tool_manager():
+    tm = MagicMock()
+    from drydock.core.tools.builtins.write_file import WriteFile
+    tm.available_tools = {"write_file": WriteFile}
+    return tm
+
+
+class TestWriteFileMissingPath:
+    def _resolve(self, raw_args: dict) -> object:
+        handler = APIToolFormatHandler()
+        parsed = ParsedMessage(
+            tool_calls=[
+                ParsedToolCall(
+                    tool_name="write_file",
+                    call_id="tc1",
+                    raw_args=raw_args,
+                )
+            ],
+            text_content="",
+        )
+        return handler.resolve_tool_calls(parsed, _make_tool_manager())
+
+    def test_missing_path_no_double_prefix(self):
+        """Error for missing path must NOT start with 'write_file:'."""
+        result = self._resolve({"content": "import os\nprint('hello')\n"})
+        assert result.failed_calls
+        err = result.failed_calls[0].error
+        # agent_loop.py will add "write_file: " prefix — the error itself must not
+        assert not err.startswith("write_file:"), f"Double prefix found: {err!r}"
+
+    def test_missing_path_error_has_useful_hint(self):
+        """Error should mention path parameter and how to fix it."""
+        result = self._resolve({"content": "import os\nprint('hello')\n"})
+        err = result.failed_calls[0].error
+        assert "path" in err.lower()
+        # Must not contain the useless placeholder "your/file.py"
+        assert "your/file.py" not in err
+
+    def test_path_inferred_from_comment(self, tmp_path, monkeypatch):
+        """When first line is '# mymodule.py', path is inferred and write succeeds."""
+        monkeypatch.chdir(tmp_path)
+        content = "# mymodule.py\nimport os\n\ndef hello():\n    pass\n"
+        result = self._resolve({"content": content})
+        # Should resolve (no failed call), path inferred as mymodule.py
+        assert not result.failed_calls, f"Expected no failure, got: {result.failed_calls[0].error!r}"
+        assert result.tool_calls
+        assert result.tool_calls[0].validated_args.path == "mymodule.py"
+
+    def test_path_not_inferred_from_plain_import(self):
+        """Content starting with bare import (no comment) must produce a failed call."""
+        result = self._resolve({"content": "import abc\nimport os\nimport datetime\n"})
+        assert result.failed_calls
+        assert not result.tool_calls

drydock_cli-2.7.19/tests/tools/test_read_file_dedup_reembed.py

@@ -0,0 +1,136 @@
+"""Regression test: read_file dedup re-embeds cached content instead of pointing
+at a possibly-truncated prior tool_result.
+
+The model (Gemma 4) looped re-reading cli.py with limit=100 because:
+1. First read: stored in read_state, returned truncated content.
+2. _truncate_old_tool_results pruned that tool_result from message history.
+3. Second read (same offset/limit/mtime): dedup fired with "use earlier result."
+4. Model couldn't find the earlier result (truncated) and re-read again → loop.
+
+Fix: when dedup fires, embed the cached content directly in the response
+rather than pointing at the prior (possibly absent) tool_result.
+"""
+from __future__ import annotations
+
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.read_file import ReadFile, ReadFileArgs, ReadFileResult, ReadFileToolConfig
+
+
+async def _run_result(tool, args, ctx) -> ReadFileResult:
+    async for event in tool.run(args, ctx):
+        if isinstance(event, ReadFileResult):
+            return event
+    raise AssertionError("no ReadFileResult yielded")
+
+
+@pytest.mark.asyncio
+async def test_dedup_reembeds_cached_content(tmp_path):
+    """Second identical read returns cached content, not a pointer stub."""
+    f = tmp_path / "cli.py"
+    f.write_text("def main():\n    pass\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+
+    # First read populates the cache.
+    result1 = await _run_result(tool, args, ctx)
+    assert "def main" in result1.content
+
+    # Second read with same args/mtime must return real content, not a pointer.
+    result2 = await _run_result(tool, args, ctx)
+    assert "def main" in result2.content, "dedup must re-embed content, not point at prior result"
+    assert "re-embedded" in result2.content
+
+
+@pytest.mark.asyncio
+async def test_dedup_does_not_fire_after_file_changes(tmp_path):
+    """Dedup must not fire if the file has been modified on disk."""
+    f = tmp_path / "cli.py"
+    f.write_text("version = 1\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+
+    result1 = await _run_result(tool, args, ctx)
+    assert "version = 1" in result1.content
+
+    # Modify the file (mtime changes).
+    import time; time.sleep(0.01)
+    f.write_text("version = 2\n")
+
+    result2 = await _run_result(tool, args, ctx)
+    assert "version = 2" in result2.content, "should read updated file, not cached content"
+    assert "re-embedded" not in result2.content
+
+
+@pytest.mark.asyncio
+async def test_dedup_escalates_on_repeated_reads(tmp_path):
+    """Third and later identical reads get an escalating REPEATED READ advisory."""
+    f = tmp_path / "cli.py"
+    f.write_text("def main():\n    pass\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+
+    # First read: no dedup.
+    r1 = await _run_result(tool, args, ctx)
+    assert "re-embedded" not in r1.content
+    assert "REPEATED READ" not in r1.content
+
+    # Second read: first dedup hit — gentle re-embed message.
+    r2 = await _run_result(tool, args, ctx)
+    assert "re-embedded" in r2.content
+    assert "REPEATED READ" not in r2.content
+    assert read_state[str(f)]["dedup_count"] == 1
+
+    # Third read: second dedup hit — escalated advisory.
+    r3 = await _run_result(tool, args, ctx)
+    assert "REPEATED READ #2" in r3.content
+    assert "def main" in r3.content
+    assert read_state[str(f)]["dedup_count"] == 2
+
+    # Fourth read: third dedup hit — counter increments.
+    r4 = await _run_result(tool, args, ctx)
+    assert "REPEATED READ #3" in r4.content
+    assert read_state[str(f)]["dedup_count"] == 3
+
+
+@pytest.mark.asyncio
+async def test_dedup_stores_lines_read_and_was_truncated(tmp_path):
+    """read_state must record lines_read and was_truncated for correct dedup re-embedding."""
+    f = tmp_path / "big.py"
+    f.write_text("\n".join(f"line{i}" for i in range(1, 201)))  # 200 lines
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=50)
+    await _run_result(tool, args, ctx)
+
+    path_key = str(f)
+    assert "lines_read" in read_state[path_key]
+    assert read_state[path_key]["lines_read"] == 50
+    assert read_state[path_key]["was_truncated"] is True
+
+    # Second read: dedup fires, re-embeds with correct metadata.
+    result2 = await _run_result(tool, args, ctx)
+    assert result2.lines_read == 50
+    assert result2.was_truncated is True

drydock_cli-2.7.19/tests/tools/test_read_file_limit_truncation.py

@@ -0,0 +1,76 @@
+"""Regression test: read_file with limit= sets was_truncated and appends pagination hint.
+
+The model (Gemma 4) called read_file with limit=100 on large files, received
+was_truncated=False and no hint, and then re-read the same file 10+ times
+confused about why it was seeing partial content. Fix: set was_truncated=True
+when the line limit stops reading, and append an "offset=N to read more" hint
+so the model knows to paginate rather than re-read.
+"""
+from __future__ import annotations
+
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.read_file import ReadFile, ReadFileArgs, ReadFileResult, ReadFileToolConfig
+
+
+async def _run_result(tool, args, ctx) -> ReadFileResult:
+    async for event in tool.run(args, ctx):
+        if isinstance(event, ReadFileResult):
+            return event
+    raise AssertionError("no ReadFileResult yielded")
+
+
+@pytest.mark.asyncio
+async def test_limit_sets_was_truncated_and_adds_hint(tmp_path):
+    """was_truncated=True and pagination hint appended when limit stops the read."""
+    f = tmp_path / "big.py"
+    f.write_text("\n".join(f"line{i}" for i in range(1, 201)))  # 200 lines
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+    ctx = MagicMock()
+    ctx.read_file_state = {}
+
+    result = await _run_result(tool, args, ctx)
+
+    assert result.was_truncated is True
+    assert result.lines_read == 100
+    assert "offset=100" in result.content
+    assert "read more" in result.content
+
+
+@pytest.mark.asyncio
+async def test_no_truncation_when_file_fits_in_limit(tmp_path):
+    """was_truncated=False when file has fewer lines than the limit."""
+    f = tmp_path / "small.py"
+    f.write_text("\n".join(f"line{i}" for i in range(1, 11)))  # 10 lines
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+    ctx = MagicMock()
+    ctx.read_file_state = {}
+
+    result = await _run_result(tool, args, ctx)
+
+    assert result.was_truncated is False
+    assert "offset=" not in result.content
+
+
+@pytest.mark.asyncio
+async def test_offset_pagination_hint_uses_correct_next_offset(tmp_path):
+    """Hint shows the correct next offset when reading a middle chunk."""
+    f = tmp_path / "file.py"
+    f.write_text("\n".join(f"line{i}" for i in range(1, 301)))  # 300 lines
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    args = ReadFileArgs(path=str(f), offset=50, limit=100)
+    ctx = MagicMock()
+    ctx.read_file_state = {}
+
+    result = await _run_result(tool, args, ctx)
+
+    assert result.was_truncated is True
+    assert "offset=150" in result.content  # 50 + 100

drydock_cli-2.7.19/tests/tools/test_search_replace_empty_content.py

@@ -0,0 +1,90 @@
+"""Regression test: search_replace empty-content raises ToolError → retry loop.
+
+Stress run 2026-04-28 showed Gemma 4 calling search_replace with empty
+content (content="") 20+ times consecutively. The ToolError path caused
+panic-retry loops (feedback: never raise ToolError for loop detection).
+
+Fix: detect empty content/file_path in the ToolError handler in run()
+and yield a soft SearchReplaceResult instead of re-raising. Track count
+per call-target so the 2nd+ offense escalates with project file listing.
+"""
+from __future__ import annotations
+
+import asyncio
+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,
+)
+
+
+def _make_tool() -> SearchReplace:
+    config = SearchReplaceConfig()
+    state = BaseToolState()
+    return SearchReplace(config=config, state=state)
+
+
+async def _run(tool: SearchReplace, args: SearchReplaceArgs, tmp_path: Path) -> SearchReplaceResult:
+    ctx = InvokeContext(tool_call_id="test-1", read_file_state={})
+    results = []
+    async for item in tool.run(args, ctx):
+        if isinstance(item, SearchReplaceResult):
+            results.append(item)
+    assert results, "Expected at least one SearchReplaceResult"
+    return results[-1]
+
+
+@pytest.mark.asyncio
+async def test_empty_content_returns_result_not_raises(tmp_path: Path) -> None:
+    """Empty content must yield a result, never raise ToolError."""
+    tool = _make_tool()
+    result = await _run(
+        tool,
+        SearchReplaceArgs(file_path="foo.py", content=""),
+        tmp_path,
+    )
+    assert isinstance(result, SearchReplaceResult)
+    assert result.blocks_applied == 0
+    assert "Empty content" in result.content
+
+
+@pytest.mark.asyncio
+async def test_empty_content_escalates_on_repeat(tmp_path: Path) -> None:
+    """2nd consecutive empty-content call adds project file listing."""
+    tool = _make_tool()
+    # First call
+    result1 = await _run(
+        tool,
+        SearchReplaceArgs(file_path="foo.py", content=""),
+        tmp_path,
+    )
+    assert "Empty content" in result1.content
+    assert "#2" not in result1.content  # no escalation yet
+
+    # Second call — same key, should escalate
+    result2 = await _run(
+        tool,
+        SearchReplaceArgs(file_path="foo.py", content=""),
+        tmp_path,
+    )
+    assert "#2" in result2.content
+    assert "Stop retrying" in result2.content
+
+
+@pytest.mark.asyncio
+async def test_missing_file_path_returns_result_not_raises(tmp_path: Path) -> None:
+    """Missing file_path (can't infer) must also yield a result, not raise."""
+    tool = _make_tool()
+    result = await _run(
+        tool,
+        SearchReplaceArgs(file_path="", content=""),
+        tmp_path,
+    )
+    assert isinstance(result, SearchReplaceResult)
+    assert result.blocks_applied == 0