| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524 |
- """V4A patch parser/applier (codex, cline). ``*** Begin Patch``/``*** End Patch`` wrap ops:
- ``*** Update File: p`` + hunks (``@@ hint @@``, `` ctx``, ``-old``, ``+new``); ``*** Add File: n``
- + ``+`` lines; ``*** Delete File: o``; ``*** Move File: a -> b``. Entry points:
- ``parse_v4a_patch(text) -> (ops, error)`` and ``apply_v4a_operations(ops, file_ops)``."""
- import contextlib
- import difflib
- import inspect
- import ntpath
- import posixpath
- import re
- from dataclasses import dataclass, field
- from enum import Enum
- from typing import TYPE_CHECKING, Any, Callable, Dict, List, NamedTuple, Optional, Tuple
- if TYPE_CHECKING: # annotations only; the real import is per-call in apply_v4a_operations
- from tools.file_operations_common import PatchResult
- from tools.file_operations_common import PatchResult
- class OperationType(Enum):
- ADD = "add"
- UPDATE = "update"
- DELETE = "delete"
- MOVE = "move"
- @dataclass
- class HunkLine:
- prefix: str # ' ', '-', or '+'
- content: str
- @dataclass
- class Hunk:
- context_hint: Optional[str] = None
- lines: list[HunkLine] = field(default_factory=list)
- @dataclass
- class PatchOperation:
- operation: OperationType
- file_path: str
- new_path: Optional[str] = None # MOVE only
- hunks: list[Hunk] = field(default_factory=list)
- # Markers must occupy the whole line at column 0 so content lines that merely
- # mention the format ("+*** End Patch") can't truncate or reset the patch.
- _BEGIN_MARKER = re.compile(r'^\*\*\*\s*Begin\s+Patch\s*$')
- _END_MARKER = re.compile(r'^\*\*\*\s*End\s+Patch\s*$')
- _OP_MARKERS: list[tuple[OperationType, re.Pattern]] = [
- (OperationType.UPDATE, re.compile(r'\*\*\*\s*Update\s+File:\s*(.+)')),
- (OperationType.ADD, re.compile(r'\*\*\*\s*Add\s+File:\s*(.+)')),
- (OperationType.DELETE, re.compile(r'\*\*\*\s*Delete\s+File:\s*(.+)')),
- (OperationType.MOVE, re.compile(r'\*\*\*\s*Move\s+File:\s*(.+?)\s*->\s*(.+)'))]
- _HINT_RE = re.compile(r'@@\s*(.+?)\s*@@')
- def parse_v4a_patch(patch_content: str) -> tuple[list[PatchOperation], Optional[str]]:
- """-> ``(operations, None)`` (empty patch = ``[]``, no error) or ``([], "Parse error: …")``."""
- # Tolerate CRLF: a stray ``\r`` would land in every HunkLine.content and defeat the markers.
- lines = [ln.removesuffix('\r') for ln in patch_content.split('\n')]
- start_idx = -1 # parse from the top when no Begin marker is present
- end_idx = len(lines)
- for i, line in enumerate(lines):
- if _BEGIN_MARKER.match(line):
- start_idx = i
- elif _END_MARKER.match(line):
- end_idx = i
- break
- operations: list[PatchOperation] = []
- current_op: Optional[PatchOperation] = None
- current_hunk: Optional[Hunk] = None
- def _flush_hunk() -> None:
- if current_op and current_hunk and current_hunk.lines:
- current_op.hunks.append(current_hunk)
- def _flush() -> None:
- if current_op:
- _flush_hunk()
- operations.append(current_op)
- for line in lines[start_idx + 1:end_idx]:
- op_match = next(((kind, m) for kind, rx in _OP_MARKERS if (m := rx.match(line))), None)
- if op_match:
- kind, m = op_match
- _flush()
- current_op = PatchOperation(
- operation=kind,
- file_path=m.group(1).strip(),
- new_path=m.group(2).strip() if kind is OperationType.MOVE else None)
- # UPDATE hunks start lazily ('@@' or first hunk line); ADD collects all '+' lines
- # into one hunk; DELETE/MOVE are complete.
- current_hunk = Hunk() if kind is OperationType.ADD else None
- if kind in (OperationType.DELETE, OperationType.MOVE):
- operations.append(current_op)
- current_op = None
- elif line.startswith('@@'):
- if current_op:
- _flush_hunk()
- hint_match = _HINT_RE.match(line)
- current_hunk = Hunk(context_hint=hint_match.group(1) if hint_match else None)
- elif current_op and line:
- if current_hunk is None:
- current_hunk = Hunk()
- if line[0] in '+- ':
- current_hunk.lines.append(HunkLine(line[0], line[1:]))
- elif line[0] != '\\': # "\ No newline at end of file" marker is skipped
- current_hunk.lines.append(HunkLine(' ', line)) # implicit context line
- _flush()
- parse_errors: list[str] = []
- for op in operations:
- if not op.file_path:
- parse_errors.append("Operation with empty file path")
- if op.operation is OperationType.UPDATE and not op.hunks:
- parse_errors.append(f"UPDATE {op.file_path!r}: no hunks found")
- if op.operation is OperationType.MOVE and not op.new_path:
- parse_errors.append(
- f"MOVE {op.file_path!r}: missing destination path (expected 'src -> dst')")
- return ([], "Parse error: " + "; ".join(parse_errors)) if parse_errors else (operations, None)
- def _count_occurrences(text: str, pattern: str) -> int:
- """Count occurrences of *pattern* in *text*, advancing one char per hit (overlaps count)."""
- return sum(1 for i in range(len(text) + 1) if text.startswith(pattern, i))
- def _split_hunk(hunk: Hunk) -> tuple[list[str], list[str]]:
- """``(search_lines, replace_lines)``: context+removed vs context+added."""
- return ([l.content for l in hunk.lines if l.prefix != '+'],
- [l.content for l in hunk.lines if l.prefix != '-'])
- def _no_match_hint(error: Optional[str], search_pattern: str, content: str) -> str:
- """Best-effort 'Did you mean...' suffix; never lets a hint failure mask the real error."""
- with contextlib.suppress(Exception):
- from tools.fuzzy_match import format_no_match_hint
- return format_no_match_hint(error, 0, search_pattern, content)
- return ""
- def _hint_ambiguity(content: str, hint: str, tail: str = "") -> tuple[int, str]:
- """(occurrences, error) for an addition-only hunk's context hint; error is '' when unique."""
- n = _count_occurrences(content, hint)
- return n, f"context hint '{hint}' is ambiguous ({n} occurrences){tail}" if n > 1 else ""
- def _overlay_key(path: str, file_ops: Any) -> str:
- """One validation-overlay key per backend file, however the patch spells it.
- Lexical only (the parser cannot resolve paths on a remote backend): ``x``, ``./x``,
- ``a//x`` and ``<cwd>/x`` share a key, so a second op on an alias validates against the
- first op's simulated result instead of the stale on-disk file. Never merge two real files:
- on POSIX ``..`` is kept, because the kernel resolves it AFTER following symlinks
- (``sub/link/../f`` is ``real/f`` when ``link`` points into ``real/``); Windows collapses
- ``..`` lexically and is case-insensitive, so only a Windows backend gets ntpath folding.
- Keys the path the backend opens: the backend's own ``_expand_path`` (``~`` -> its HOME, a
- host path under a docker workspace mount -> the container path) runs first. A trailing
- ``/`` or ``/.`` needs a directory, so it keeps a marker and never shares the file's key.
- """
- env = getattr(file_ops, "env", None)
- cwd = getattr(env, "cwd", None) or getattr(file_ops, "cwd", None)
- cwd = cwd if isinstance(cwd, str) else ""
- path = path.strip()
- expand = getattr(file_ops, "_expand_path", None)
- expanded = expand(path) if callable(expand) else None
- path = expanded if isinstance(expanded, str) and expanded else path
- if _backend_is_windows(env, cwd):
- tail = "\\" if re.search(r"[\\/]\.?[\\/]*$", path) else ""
- return ntpath.normcase(ntpath.normpath(ntpath.join(cwd, path))) + tail
- raw = posixpath.join(cwd, path) if cwd.startswith("/") else path
- segments = [seg for seg in raw.split("/") if seg not in ("", ".")]
- tail = "/" if segments and raw.split("/")[-1] in ("", ".") else ""
- return ("/" if raw.startswith("/") else "") + "/".join(segments) + tail
- def _backend_is_windows(env: Any, cwd: str) -> bool:
- """A local env on a Windows host, or a backend whose cwd is a drive path. Remote
- sandboxes (docker, ssh, modal ...) are POSIX shells even when Hermes runs on Windows."""
- from tools.environments.local import _IS_WINDOWS
- return bool(_IS_WINDOWS and getattr(env, "is_local", False)) or bool(
- re.match(r"^[A-Za-z]:[\\/]", cwd))
- def _validate_operations(operations: list[PatchOperation], file_ops: Any) -> list[str]:
- """Dry-run every operation -> error strings (empty = safe). UPDATE hunks are simulated in
- order so later hunks see post-earlier-hunk content, exactly as apply will."""
- from tools.fuzzy_match import fuzzy_find_and_replace, is_already_applied
- errors: list[str] = []
- real_change_count = 0
- # Overlay so inter-op state validates (a MOVE creating the path a later UPDATE targets),
- # keyed by _overlay_key so path aliases share one entry.
- pending_content: dict = {}
- removed_paths: set = set()
- def _read(path: str) -> tuple[Optional[str], Optional[str]]:
- key = _overlay_key(path, file_ops)
- if key in pending_content:
- return pending_content[key], None
- if key in removed_paths:
- return None, "file not found"
- r = file_ops.read_file_raw(path)
- return (None, r.error) if r.error else (r.content, None)
- def _occupied(path: str) -> Optional[str]:
- """Why an Add target or Move destination is not free, or None. Only a read that reports
- the path absent (``not_found``) frees it: a read that FAILED (no byte transport, a
- directory, an unreadable file) says nothing about what is there, and taking it as free
- writes over the file the check exists to protect."""
- key = _overlay_key(path, file_ops)
- if key in pending_content:
- return "exists"
- if key in removed_paths:
- return None
- r = file_ops.read_file_raw(path)
- if not r.error:
- return "exists"
- return None if getattr(r, "not_found", False) else f"could not confirm the path is free — {r.error}"
- def _validate_update(op: PatchOperation) -> None:
- nonlocal real_change_count
- simulated, read_err = _read(op.file_path)
- if read_err:
- errors.append(f"{op.file_path}: {read_err}")
- return
- for hunk_index, hunk in enumerate(op.hunks, start=1):
- search_lines, replace_lines = _split_hunk(hunk)
- if search_lines == replace_lines:
- # Context-only anchor hunks (models emit these between changes) are inert; identical
- # -/+ lines are skipped by apply as a no-op — neither may fail validation.
- real_change_count += any(l.prefix in '-+' for l in hunk.lines)
- continue
- real_change_count += 1
- if not search_lines: # addition-only: the context hint must be unique
- if hunk.context_hint:
- occurrences, ambiguous = _hint_ambiguity(simulated, hunk.context_hint)
- if occurrences == 0:
- errors.append(f"{op.file_path}: addition-only hunk context hint "
- f"'{hunk.context_hint}' not found")
- elif ambiguous:
- errors.append(f"{op.file_path}: addition-only hunk {ambiguous}")
- continue
- search_pattern, replacement = '\n'.join(search_lines), '\n'.join(replace_lines)
- new_simulated, count, _strategy, match_error = fuzzy_find_and_replace(
- simulated, search_pattern, replacement, replace_all=False)
- if count:
- simulated = new_simulated
- elif not is_already_applied(simulated or "", search_pattern, replacement):
- # Already-applied hunks are no-ops (apply performs the same skip).
- label = f"'{hunk.context_hint}'" if hunk.context_hint else "(no hint)"
- errors.append(
- f"{op.file_path}: hunk {hunk_index} {label} not found"
- + (f" — {match_error}" if match_error else "")
- + _no_match_hint(match_error, search_pattern, simulated))
- pending_content[_overlay_key(op.file_path, file_ops)] = simulated
- def _remove(path: str) -> None:
- key = _overlay_key(path, file_ops)
- removed_paths.add(key)
- pending_content.pop(key, None)
- for op in operations:
- if op.operation == OperationType.UPDATE:
- _validate_update(op)
- continue
- real_change_count += 1
- if op.operation == OperationType.DELETE:
- if _read(op.file_path)[1]:
- errors.append(f"{op.file_path}: file not found for deletion")
- else:
- _remove(op.file_path)
- elif op.operation == OperationType.MOVE:
- if not op.new_path:
- errors.append(f"{op.file_path}: MOVE operation missing destination path")
- continue
- src_content, src_err = _read(op.file_path)
- if src_err:
- errors.append(f"{op.file_path}: source file not found for move")
- dst_taken = _occupied(op.new_path)
- if dst_taken == "exists":
- errors.append(f"{op.new_path}: destination already exists — move would overwrite")
- elif dst_taken:
- errors.append(f"{op.new_path}: {dst_taken}")
- elif not src_err: # only a cleanly-validated move updates the overlay
- pending_content[_overlay_key(op.new_path, file_ops)] = src_content if src_content is not None else ""
- _remove(op.file_path)
- elif op.operation == OperationType.ADD:
- # An Add must create a NEW file. If the target already exists, write_file
- # would clobber it with only the patch's '+' lines and report success,
- # silently destroying the original contents (models frequently confuse Add
- # with Update). Reject it here so the two-phase contract holds, mirroring
- # the MOVE destination guard. Overlay-aware: an Add after a Delete of the
- # same path in this patch stays legal, and the added content enters the
- # overlay so later hunks against it validate.
- add_taken = _occupied(op.file_path)
- if add_taken == "exists":
- errors.append(f"{op.file_path}: file already exists — use Update File, not Add File")
- elif add_taken:
- errors.append(f"{op.file_path}: {add_taken}")
- else:
- removed_paths.discard(_overlay_key(op.file_path, file_ops))
- pending_content[_overlay_key(op.file_path, file_ops)] = '\n'.join(
- line.content for hunk in op.hunks for line in hunk.lines if line.prefix == '+')
- if not errors and real_change_count == 0:
- errors.append("Patch contains no changes (only context lines were provided)")
- return errors
- class ApplyResult(NamedTuple):
- """Outcome of one ``_apply_*`` handler. ``write`` is the PatchResult._writes entry of a file
- write (None for Delete/Move and failures); ``notes`` tell the caller how the edit was matched
- (escape-drift corrections, hunks located approximately)."""
- ok: bool
- payload: str # the diff on success, the error text on failure
- lsp: Optional[str] = None
- lint: Optional[dict] = None
- write: Optional[tuple] = None
- notes: tuple[str, ...] = ()
- def _fail(error: str) -> ApplyResult:
- return ApplyResult(False, error)
- def _written(result: Any, diff: str, path: str, read_sha256: Optional[str]) -> ApplyResult:
- """Outcome of a write: its error, else success with LSP/lint propagated from the WriteResult
- and the ``(path, read_sha256, written_sha256)`` record of the bytes it replaced and wrote."""
- if result.error:
- return _fail(result.error)
- write = (path, read_sha256, getattr(result, "_content_sha256", None))
- return ApplyResult(True, diff, getattr(result, "lsp_diagnostics", None), getattr(result, "lint", None), write)
- def _unified_diff(path: str, old: str, new: Optional[str]) -> str:
- """Unified diff ``a/path`` -> ``b/path`` (``new=None`` = deletion, ``/dev/null``)."""
- return ''.join(difflib.unified_diff(
- old.splitlines(keepends=True), [] if new is None else new.splitlines(keepends=True),
- fromfile=f"a/{path}", tofile="/dev/null" if new is None else f"b/{path}"))
- def apply_v4a_operations(operations: list[PatchOperation], file_ops: Any) -> PatchResult:
- """Two-phase: validate everything, then apply (atomic on validation failure). A phase-2
- failure (validate/apply race) carries a ``git diff`` note since state may be inconsistent.
- ``file_ops`` needs read_file_raw/write_file/delete_file/move_file."""
- def _bullets(errs: list[str]) -> str:
- return "\n".join(f" • {e}" for e in errs)
- if errors := _validate_operations(operations, file_ops):
- return PatchResult(
- success=False,
- error="Patch validation failed (no files were modified):\n" + _bullets(errors))
- files: dict[str, list[str]] = {"created": [], "deleted": [], "modified": []}
- all_diffs: list[str] = []
- notes: list[str] = []
- # V4A bypasses write_file's WriteResult plumbing: LSP diagnostics and lint propagate per file.
- lsp_blocks: list[str] = []
- lint_results: dict[str, dict] = {}
- writes: list[tuple] = []
- for op in operations:
- handler, verb, bucket = _APPLY_DISPATCH[op.operation]
- try:
- ok, payload, lsp, lint, write, op_notes = handler(op, file_ops)
- except Exception as e:
- ok, payload = None, str(e)
- if not ok:
- prefix = f"Failed to {verb}" if ok is False else "Error processing"
- errors.append(f"{prefix} {op.file_path}: {payload}")
- continue
- is_move = op.operation is OperationType.MOVE
- files[bucket].append(f"{op.file_path} -> {op.new_path}" if is_move else op.file_path)
- all_diffs.append(payload)
- if write:
- writes.append(write)
- notes.extend(op_notes)
- if lsp:
- lsp_blocks.append(lsp)
- if lint:
- lint_results[op.file_path] = lint
- # Each LSP block carries its own <diagnostics file="..."> header; joining keeps attribution.
- return PatchResult(
- success=not errors,
- error=("Apply phase failed (state may be inconsistent — run `git diff` to assess):\n"
- + _bullets(errors)) if errors else None,
- diff='\n'.join(all_diffs),
- files_modified=files["modified"], files_created=files["created"], files_deleted=files["deleted"],
- lint=lint_results or None, lsp_diagnostics="\n\n".join(lsp_blocks) or None, _writes=writes,
- note="\n".join(dict.fromkeys(notes)) or None)
- def _write_file_accepts_pre_content(file_ops: Any) -> bool:
- """Whether ``file_ops.write_file`` accepts ``pre_content`` — read from the signature, not by
- catching TypeError around the call, so a TypeError raised *inside* it can't double-write."""
- try:
- params = inspect.signature(file_ops.write_file).parameters
- except (TypeError, ValueError):
- return False
- return "pre_content" in params or any(
- p.kind is inspect.Parameter.VAR_KEYWORD for p in params.values())
- def _apply_add(op: PatchOperation, file_ops: Any) -> ApplyResult:
- """Create a file from the hunks' '+' lines. Fails closed when the target already
- exists: validation confirmed the path was free (or freed by an earlier DELETE in
- this patch, which has already applied by now), so an existing file here is a
- validate/apply race — never clobber."""
- read_back = file_ops.read_file_raw(op.file_path)
- if not read_back.error:
- return _fail(f"{op.file_path}: file already exists — use Update File, not Add File")
- if not getattr(read_back, "not_found", False):
- # The read FAILED; it did not report an absent path. Treating that as "the path is free"
- # writes the Add payload over whatever is actually there.
- return _fail(f"{op.file_path}: could not confirm the path is free — {read_back.error}")
- content_lines = [line.content for hunk in op.hunks for line in hunk.lines if line.prefix == '+']
- result = file_ops.write_file(op.file_path, '\n'.join(content_lines))
- diff = f"--- /dev/null\n+++ b/{op.file_path}\n" + '\n'.join(f"+{line}" for line in content_lines)
- return _written(result, diff, op.file_path, "")
- def _apply_delete(op: PatchOperation, file_ops: Any) -> ApplyResult:
- """Delete a file, producing a real unified diff of the removed content."""
- read_result = file_ops.read_file_raw(op.file_path) # re-read guards validate/apply races
- if read_result.error:
- return _fail(f"Cannot delete {op.file_path}: file not found")
- result = file_ops.delete_file(op.file_path)
- diff = _unified_diff(op.file_path, read_result.content, None) or f"# Deleted: {op.file_path}"
- return _fail(result.error) if result.error else ApplyResult(True, diff)
- def _apply_move(op: PatchOperation, file_ops: Any) -> ApplyResult:
- """Move, re-checking the destination first: validation's answer is stale once earlier ops of
- this patch have applied, and ``mv`` replaces whatever is there."""
- dst = file_ops.read_file_raw(op.new_path)
- if not dst.error:
- return _fail(f"{op.new_path}: destination already exists — move would overwrite")
- if not getattr(dst, "not_found", False):
- return _fail(f"{op.new_path}: could not confirm the destination is free — {dst.error}")
- result = file_ops.move_file(op.file_path, op.new_path)
- return _fail(result.error) if result.error else ApplyResult(
- True, f"# Moved: {op.file_path} -> {op.new_path}")
- def _insert_addition_only(new_content: str, hunk: Hunk, insert_text: str) -> tuple[Optional[str], Optional[str]]:
- """Place an addition-only hunk after its context hint (or at EOF). Returns (content, error)."""
- if hunk.context_hint:
- occurrences, ambiguous = _hint_ambiguity(
- new_content, hunk.context_hint, " — provide a more unique hint")
- if ambiguous:
- return None, f"Addition-only hunk: {ambiguous}"
- if occurrences == 1:
- eol = new_content.find('\n', new_content.find(hunk.context_hint))
- if eol == -1:
- return new_content + '\n' + insert_text, None
- return new_content[:eol + 1] + insert_text + '\n' + new_content[eol + 1:], None
- # No hint / hint not found — append at end as a safe fallback.
- return new_content.rstrip('\n') + '\n' + insert_text + '\n', None
- def _apply_update(op: PatchOperation, file_ops: Any) -> ApplyResult:
- """Apply each hunk via fuzzy replace, then write once."""
- from tools.fuzzy_match import boundary_note, fuzzy_find_and_replace, is_already_applied
- read_result = file_ops.read_file_raw(op.file_path) # raw: no line numbers / truncation
- if read_result.error:
- return _fail(f"Cannot read file: {read_result.error}")
- current_content = new_content = read_result.content
- notes: list[str] = [] # escape-drift corrections, appended by fuzzy_find_and_replace
- strategies: list[str] = [] # the fuzzy strategies that located the hunks
- for hunk in op.hunks:
- search_lines, replace_lines = _split_hunk(hunk)
- if search_lines and search_lines == replace_lines:
- continue
- search_pattern, replacement = '\n'.join(search_lines), '\n'.join(replace_lines)
- if not search_lines:
- new_content, err = _insert_addition_only(new_content, hunk, replacement)
- if err:
- return _fail(err)
- continue
- new_content, count, strategy, error = fuzzy_find_and_replace(
- new_content, search_pattern, replacement, replace_all=False, correction_notes=notes)
- if not (error and count == 0):
- if count > 0:
- strategies.append(strategy)
- continue
- # Retry inside a window around the context hint, if any.
- hint_pos = new_content.find(hunk.context_hint) if hunk.context_hint else -1
- if hint_pos != -1:
- window_start = max(0, hint_pos - 500)
- window_end = min(len(new_content), hint_pos + 2000)
- window_new, count, strategy, error = fuzzy_find_and_replace(
- new_content[window_start:window_end], search_pattern, replacement, replace_all=False,
- correction_notes=notes)
- if count > 0:
- strategies.append(strategy)
- new_content = new_content[:window_start] + window_new + new_content[window_end:]
- error = None
- if error:
- # Mirror validation's already-applied skip, else the two phases disagree and fail here.
- if is_already_applied(new_content, search_pattern, replacement):
- continue
- hint = _no_match_hint(error, search_pattern, new_content)
- return _fail(f"Could not apply hunk: {error}" + hint)
- # Pass pre_content to skip a redundant re-read inside write_file when supported.
- extra = {"pre_content": current_content} if _write_file_accepts_pre_content(file_ops) else {}
- write_result = file_ops.write_file(op.file_path, new_content, **extra)
- result = _written(write_result, _unified_diff(op.file_path, current_content, new_content),
- op.file_path, getattr(read_result, "_content_sha256", None))
- if not result.ok:
- return result
- # A hunk found by a similarity strategy may have landed a line off; say so, per file.
- if note := boundary_note(strategies, "the hunk's", f" in {op.file_path}"):
- notes.append(note)
- return result._replace(notes=tuple(notes))
- # operation -> (handler, verb for error text, files_* bucket)
- _APPLY_DISPATCH: dict[OperationType, tuple[Callable[[PatchOperation, Any], ApplyResult], str, str]] = {
- OperationType.ADD: (_apply_add, "add", "created"),
- OperationType.DELETE: (_apply_delete, "delete", "deleted"),
- OperationType.MOVE: (_apply_move, "move", "modified"),
- OperationType.UPDATE: (_apply_update, "update", "modified"),
- }
|