The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Conservative correction of escape drift before shared fuzzy matching.
Corrections require the corrected ``old_string`` to appear verbatim in the file.
That evidence cannot establish the intended escaping of newly added code: deliberate
double backslashes look the same as a serialization artifact. Backslash correction
therefore halves only ``old_string`` and requires a backslash-free ``new_string``.
An otherwise verified doubled anchor with replacement backslashes raises an explicit
error; callers must reject it before fuzzy matching can apply the ambiguous text.
Quote correction retains its separate consistency checks. Successful corrections
return a note for the tool result; already-exact anchors are left unchanged.
"""
from __future__ import annotations
import re
from typing import Optional
_BACKSLASH_RUN_RE = re.compile(r"\\+")
class AmbiguousEscapeDriftError(ValueError):
"""The replacement's intentional backslashes cannot be distinguished from drift."""
def _halve_backslash_runs(s: str) -> str:
"""Replace every maximal run of backslashes with half its length."""
return _BACKSLASH_RUN_RE.sub(lambda m: "\\" * (len(m.group(0)) // 2), s)
def _all_backslash_runs_even(s: str) -> bool:
return all(len(run) % 2 == 0 for run in _BACKSLASH_RUN_RE.findall(s))
def maybe_correct_backslash_doubling(old_string: str, new_string: str, content: str) -> tuple[str, str]:
"""Halve a verified doubled anchor only when the replacement has no backslashes.
Every old_string run must be even and its halved form must occur in the file.
Replacement backslashes are ambiguous regardless of run length, so raise
``AmbiguousEscapeDriftError`` rather than let fuzzy matching apply them.
"""
if "\\" not in old_string or old_string in content:
return old_string, new_string
if not _all_backslash_runs_even(old_string):
return old_string, new_string
halved_old = _halve_backslash_runs(old_string)
if halved_old not in content:
return old_string, new_string
if "\\" in new_string:
raise AmbiguousEscapeDriftError(
"Escape-drift detected: halving old_string's backslashes matches the file, "
"but correcting new_string could remove intentional backslashes. "
"Re-read the file and resend old_string/new_string with their intended escaping."
)
return halved_old, new_string
_QUOTE_WITH_BACKSLASHES_RE = {q: re.compile(r"(\\*)" + q) for q in ("'", '"')}
def _strip_spurious_quote_escapes(s: str) -> str:
"""Un-escape a spurious backslash before a quote character: ``\\'`` -> ``'``, ``\\"`` -> ``"``."""
return s.replace("\\'", "'").replace('\\"', '"')
def _quote_escapes_all_spurious(*strings: str) -> bool:
"""True when every escaped quote in ``strings`` is attributable to the wire artifact.
The artifact escapes quotes mechanically, so a quote kind it touched is escaped at EVERY
occurrence across the whole call, by exactly one backslash. A backslash the model meant
(``"say \\"hi\\""`` in new code) went through the same extra escape and therefore arrives
as two or more backslashes before the quote, never one. So for each kind that appears as
``\\q`` anywhere: every ``q`` in every string must be preceded by exactly one backslash.
A bare ``q`` beside a ``\\q`` (the kind was not drifted, so the ``\\q`` is real) or a longer
run (an intended escape) cannot be told apart from the artifact, so it refuses.
"""
for quote, pattern in _QUOTE_WITH_BACKSLASHES_RE.items():
if not any("\\" + quote in s for s in strings):
continue
if any(len(m.group(1)) != 1 for s in strings for m in pattern.finditer(s)):
return False
return True
def maybe_correct_quote_escaping(old_string: str, new_string: str, content: str) -> tuple[str, str]:
"""Return a corrected ``(old_string, new_string)`` if a spurious backslash-before-quote wire
artifact is detected AND verified against the file's actual content; otherwise unchanged.
Mirrors ``_detect_escape_drift``'s quote-suspect check: ``\\'`` or ``\\"`` present in BOTH
old_string and new_string is the signature of an apostrophe/quote that picked up a spurious
backslash in transit, not a literal escape the model intended. The stripped old_string must
appear verbatim in content, which verifies old_string (and rules out a file that really
contains ``\\'``/``\\"``). new_string's added code is not in the file, so it is only
stripped when ``_quote_escapes_all_spurious`` holds for the whole call; otherwise the call
is left unchanged for the existing reject-and-ask guard. Raises ``AmbiguousEscapeDriftError``
when new_string escapes a quote kind that old_string does not.
"""
has_quote_suspect = (
("\\'" in old_string and "\\'" in new_string)
or ('\\"' in old_string and '\\"' in new_string)
)
if not has_quote_suspect or old_string in content:
return old_string, new_string
if not _quote_escapes_all_spurious(old_string, new_string):
return old_string, new_string
stripped_old = _strip_spurious_quote_escapes(old_string)
if stripped_old not in content:
return old_string, new_string
# Only old_string is checked against the file, so only the quote kinds it escapes are
# proven drift. A kind escaped only in new_string may be an escape the model meant.
unproven = [q for q in ("'", '"') if "\\" + q in new_string and "\\" + q not in old_string]
if unproven:
shown = " and ".join("\\" + q for q in unproven)
raise AmbiguousEscapeDriftError(
"Escape-drift detected: removing the spurious quote escapes in old_string matches "
f"the file, but new_string also contains {shown}, which old_string gives no evidence "
"for. Re-read the file and resend old_string/new_string with their intended escaping."
)
return stripped_old, _strip_spurious_quote_escapes(new_string)
def maybe_correct_escape_drift(old_string: str, new_string: str, content: str) -> tuple[str, str, Optional[str]]:
"""Apply whichever escape-drift auto-correction (if any) is verified against the file's
actual content and report which one fired.
Tries quote escaping, then backslash correction of the anchor only. Raises
``AmbiguousEscapeDriftError`` for a verified doubled anchor whose replacement
contains backslashes, or a verified quote correction whose replacement escapes a
quote kind the anchor does not; the caller must return an error without matching.
Returns ``(corrected_old, corrected_new, note)``: ``note`` is a human-readable description
of the correction that was applied, or ``None`` if neither fired. The caller attaches
``note`` to the successful result (e.g. ``PatchResult.note``) so a corrected call stays
distinguishable from one whose arguments never needed correction.
"""
corrected_old, corrected_new = maybe_correct_quote_escaping(old_string, new_string, content)
if corrected_old != old_string:
return corrected_old, corrected_new, (
"escape-drift auto-corrected: stripped a spurious backslash before a quote/apostrophe "
"in old_string/new_string (a JSON-double-escaping wire artifact) before matching."
)
corrected_old, corrected_new = maybe_correct_backslash_doubling(old_string, new_string, content)
if corrected_old != old_string:
return corrected_old, corrected_new, (
"escape-drift auto-corrected: halved doubled backslash runs in old_string "
"before matching; new_string has no backslashes and was left unchanged."
)
return old_string, new_string, None