`c7a21e5`

Steer stale patch repairs

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: c7a21e5bf274b1c377dcfb2be7cc6c67c85dbbc0
Parents: 7f616be
Tree: d6c12e5

2 changed files

Status	File	+	-
M	`src/loader/runtime/recovery.py`	72	0
M	`tests/test_recovery.py`	77	0

src/loader/runtime/recovery.pymodified

      ):
          return ErrorCategory.INVALID_ARGUMENTS
++    if any(
++        token in error_lower
++        for token in [
++            "structured patch",
++            "patch hunks are missing",
++            "hunks must not be empty",
++            "old_string not found",
++        ]
++    ):
++        return ErrorCategory.INVALID_ARGUMENTS
++
      if any(
          token in error_lower
          for token in [
+     ]
++def _is_patch_context_failure(error: str) -> bool:
++    error_lower = str(error or "").lower()
++    return any(
++        token in error_lower
++        for token in (
++            "structured patch hunk consumed",
++            "structured patch context mismatch",
++            "structured patch references lines past the end",
++            "structured patch hunks overlap",
++        )
++    )
++
++
++def _patch_context_failure_hints(
++    tool_name: str,
++    args: dict[str, Any] | None,
++    error: str,
++) -> list[str]:
++    """Return recovery hints for brittle structured patch coordinates."""
++
++    if tool_name != "patch" or not _is_patch_context_failure(error):
++        return []
++
++    target = str(
++        (args or {}).get("file_path") or (args or {}).get("path") or ""
++    ).strip()
++    target_suffix = f" for `{target}`" if target else ""
++    return [
++        (
++            "`patch` hunk coordinates/context did not match the current file"
++            f"{target_suffix}; do not retry line-number hunks from memory."
++        ),
++        (
++            "Displayed wrapping is not source line numbering; line-number hunks "
++            "past the real file length will fail."
++        ),
++        (
++            "For generated-file repairs, prefer "
++            "`write(file_path=..., content=...)` with the full corrected file, "
++            "or `edit` using exact current on-disk text."
++        ),
++        (
++            "If more evidence is truly needed, read only the target file; do not "
++            "consult notepad/project memory or unrelated references."
++        ),
++    ]
++
++
  RECOVERY_PROMPT = """## TOOL FAILURE - INVESTIGATE AND ADAPT
  The command failed. You MUST analyze the error and take a DIFFERENT action.
      mismatch_hints = _edit_old_string_mismatch_hints(tool_name, args, error)
      if mismatch_hints:
          hints = "\n".join(f"- {hint}" for hint in mismatch_hints) + "\n" + hints
++    patch_hints = _patch_context_failure_hints(tool_name, args, error)
++    if patch_hints:
++        hints = "\n".join(f"- {hint}" for hint in patch_hints) + "\n" + hints
      args_str = ", ".join(f"{key}={value!r}" for key, value in args.items())
      return RECOVERY_PROMPT.format(
              "Use exact current on-disk text for `edit`, or switch to `patch`/`write`",
              "For large generated-file repairs, replace the whole file or anchor a patch to current content",
+         ]
++    elif (
++        last_attempt is not None
++        and last_attempt.tool_name == "patch"
++        and _is_patch_context_failure(last_attempt.error)
++    ):
++        specific_suggestions = [
++            "Patch hunk coordinates/context were stale; do not retry line-number hunks from memory",
++            "Use `write(file_path=..., content=...)` for a full generated-file replacement",
++            "Or use `edit` with exact current on-disk text from the target file",
++        ]
      else:
          specific_suggestions = suggestions.get(
              last_category,

tests/test_recovery.pymodified

+             )
              == ErrorCategory.INVALID_ARGUMENTS
+         )
++        assert (
++            categorize_error(
++                "Error patching file: structured patch hunk consumed a different "
++                "number of original lines than declared"
++            )
++            == ErrorCategory.INVALID_ARGUMENTS
++        )
      def test_network_error(self):
          assert categorize_error("Network unreachable") == ErrorCategory.NETWORK_ERROR
          assert "current on-disk file" in prompt
          assert "write` with the complete replacement content" in prompt
++    def test_format_recovery_prompt_for_patch_context_miss_prefers_replacement(self):
++        ctx = RecoveryContext(
++            original_tool="patch",
++            original_args={
++                "file_path": "~/Loader/guides/nginx/chapters/05-load-balancing.html",
++                "hunks": [
++                    {
++                        "old_start": 64,
++                        "old_lines": 1,
++                        "lines": ["<h2>More</h2>"],
++                    }
++                ],
++            },
++        )
++        ctx.add_attempt(
++            "patch",
++            ctx.original_args,
++            (
++                "Error patching file: structured patch hunk consumed a different "
++                "number of original lines than declared (0 vs 1)"
++            ),
++        )
++
++        prompt = format_recovery_prompt(
++            ctx,
++            "patch",
++            ctx.original_args,
++            (
++                "Error patching file: structured patch hunk consumed a different "
++                "number of original lines than declared (0 vs 1)"
++            ),
++        )
++
++        assert "did not match the current file" in prompt
++        assert "Displayed wrapping is not source line numbering" in prompt
++        assert "write(file_path=..., content=...)" in prompt
++        assert "notepad/project memory" in prompt
++
  class TestFormatFailureMessage:
      """Tests for failure message formatting."""
          assert "`old_string` was stale" in msg
          assert "exact current on-disk text" in msg
          assert "Try a completely different approach" not in msg
++
++    def test_format_failure_message_for_patch_context_miss_is_specific(self):
++        ctx = RecoveryContext(
++            original_tool="patch",
++            original_args={
++                "file_path": "guide.html",
++                "hunks": [
++                    {
++                        "old_start": 12,
++                        "old_lines": 1,
++                        "lines": ["<h2>More</h2>"],
++                    }
++                ],
++            },
++            max_retries=2,
++        )
++        ctx.add_attempt(
++            "patch",
++            ctx.original_args,
++            "Error patching file: structured patch references lines past the end of the file",
++        )
++        ctx.add_attempt(
++            "patch",
++            ctx.original_args,
++            "Error patching file: structured patch references lines past the end of the file",
++        )
++
++        msg = format_failure_message(ctx)
++
++        assert "Patch hunk coordinates/context were stale" in msg
++        assert "write(file_path=..., content=...)" in msg
++        assert "Try a completely different approach" not in msg