search-replace-py 0.0.1__py3-none-any.whl

search_replace/__init__.py

@@ -0,0 +1,38 @@
+from .apply import apply_diff, apply_edits
+from .errors import (
+    ApplyError,
+    MissingFilenameError,
+    ParseError,
+    PathEscapeError,
+    SearchReplaceError,
+)
+from .parser import all_fences, find_original_update_blocks, parse_edit_blocks
+from .prompts import (
+    EditBlockFencedPrompts,
+    FewShotExampleMessages,
+    get_example_messages,
+    render_system_prompt,
+)
+from .types import ApplyResult, DEFAULT_FENCE, EditBlock, Fence, ParseResult
+
+__all__ = [
+    "ApplyError",
+    "ApplyResult",
+    "apply_diff",
+    "apply_edits",
+    "all_fences",
+    "DEFAULT_FENCE",
+    "EditBlock",
+    "EditBlockFencedPrompts",
+    "Fence",
+    "FewShotExampleMessages",
+    "find_original_update_blocks",
+    "get_example_messages",
+    "MissingFilenameError",
+    "parse_edit_blocks",
+    "ParseError",
+    "PathEscapeError",
+    "ParseResult",
+    "render_system_prompt",
+    "SearchReplaceError",
+]

search_replace/apply.py

@@ -0,0 +1,436 @@
+import re
+from pathlib import Path
+from typing import Sequence
+
+from .errors import ApplyError, ParseError, PathEscapeError
+from .fuzzy import find_similar_lines, replace_closest_edit_distance
+from .parser import parse_edit_blocks
+from .types import DEFAULT_FENCE, ApplyResult, EditBlock, Fence
+
+
+def prep(content: str) -> tuple[str, list[str]]:
+    if content and not content.endswith("\n"):
+        content += "\n"
+    lines = content.splitlines(keepends=True)
+    return content, lines
+
+
+def perfect_or_whitespace(
+    whole_lines: list[str],
+    part_lines: list[str],
+    replace_lines: list[str],
+) -> str | None:
+    # Try for a perfect match.
+    result = perfect_replace(whole_lines, part_lines, replace_lines)
+    if result:
+        return result
+
+    # Try being flexible about leading whitespace.
+    result = replace_part_with_missing_leading_whitespace(
+        whole_lines, part_lines, replace_lines
+    )
+    if result:
+        return result
+
+    return None
+
+
+def perfect_replace(
+    whole_lines: list[str], part_lines: list[str], replace_lines: list[str]
+) -> str | None:
+    part_tup = tuple(part_lines)
+    part_len = len(part_lines)
+
+    for index in range(len(whole_lines) - part_len + 1):
+        whole_tup = tuple(whole_lines[index : index + part_len])
+        if part_tup == whole_tup:
+            result = (
+                whole_lines[:index] + replace_lines + whole_lines[index + part_len :]
+            )
+            return "".join(result)
+
+    return None
+
+
+def replace_most_similar_chunk(whole: str, part: str, replace: str) -> str | None:
+    """Best efforts to find `part` lines in `whole` and replace them with `replace`."""
+    whole, whole_lines = prep(whole)
+    part, part_lines = prep(part)
+    replace, replace_lines = prep(replace)
+
+    result = perfect_or_whitespace(whole_lines, part_lines, replace_lines)
+    if result:
+        return result
+
+    # Drop leading empty line, GPT sometimes adds them spuriously (issue #25).
+    if len(part_lines) > 2 and not part_lines[0].strip():
+        skip_blank_line_part_lines = part_lines[1:]
+        result = perfect_or_whitespace(
+            whole_lines, skip_blank_line_part_lines, replace_lines
+        )
+        if result:
+            return result
+
+    # Try to handle when it elides code with ...
+    try:
+        result = try_dotdotdots(whole, part, replace)
+        if result:
+            return result
+    except ValueError:
+        pass
+
+    return None
+    # Try fuzzy matching.
+    result = replace_closest_edit_distance(whole_lines, part, part_lines, replace_lines)
+    if result:
+        return result
+
+    return None
+
+
+def try_dotdotdots(whole: str, part: str, replace: str) -> str | None:
+    """
+    See if the edit block has ... lines.
+    If not, return none.
+
+    If yes, try and do a perfect edit with the ... chunks.
+    If there's a mismatch or otherwise imperfect edit, raise ValueError.
+
+    If perfect edit succeeds, return the updated whole.
+    """
+    dots_re = re.compile(r"(^\s*\.\.\.\n)", re.MULTILINE | re.DOTALL)
+
+    part_pieces = re.split(dots_re, part)
+    replace_pieces = re.split(dots_re, replace)
+
+    if len(part_pieces) != len(replace_pieces):
+        raise ValueError("Unpaired ... in SEARCH/REPLACE block")
+
+    if len(part_pieces) == 1:
+        # No dots in this edit block, just return None.
+        return None
+
+    # Compare odd strings in part_pieces and replace_pieces.
+    all_dots_match = all(
+        part_pieces[i] == replace_pieces[i] for i in range(1, len(part_pieces), 2)
+    )
+    if not all_dots_match:
+        raise ValueError("Unmatched ... in SEARCH/REPLACE block")
+
+    part_pieces = [part_pieces[i] for i in range(0, len(part_pieces), 2)]
+    replace_pieces = [replace_pieces[i] for i in range(0, len(replace_pieces), 2)]
+
+    pairs = zip(part_pieces, replace_pieces)
+    for part_piece, replace_piece in pairs:
+        if not part_piece and not replace_piece:
+            continue
+
+        if not part_piece and replace_piece:
+            if not whole.endswith("\n"):
+                whole += "\n"
+            whole += replace_piece
+            continue
+
+        if whole.count(part_piece) == 0:
+            raise ValueError
+        if whole.count(part_piece) > 1:
+            raise ValueError
+
+        whole = whole.replace(part_piece, replace_piece, 1)
+
+    return whole
+
+
+def replace_part_with_missing_leading_whitespace(
+    whole_lines: list[str],
+    part_lines: list[str],
+    replace_lines: list[str],
+) -> str | None:
+    # GPT often messes up leading whitespace.
+    # It usually does it uniformly across the ORIG and UPD blocks.
+    # Either omitting all leading whitespace, or including only some of it.
+
+    # Outdent everything in part_lines and replace_lines by the max fixed amount possible.
+    leading: list[int] = [len(p) - len(p.lstrip()) for p in part_lines if p.strip()] + [
+        len(p) - len(p.lstrip()) for p in replace_lines if p.strip()
+    ]
+
+    if leading:
+        num_leading = min(leading)
+        if num_leading:
+            part_lines = [p[num_leading:] if p.strip() else p for p in part_lines]
+            replace_lines = [p[num_leading:] if p.strip() else p for p in replace_lines]
+
+    # Can we find an exact match not including the leading whitespace.
+    num_part_lines = len(part_lines)
+
+    for index in range(len(whole_lines) - num_part_lines + 1):
+        add_leading = match_but_for_leading_whitespace(
+            whole_lines[index : index + num_part_lines], part_lines
+        )
+
+        if add_leading is None:
+            continue
+
+        replace_lines = [
+            add_leading + line if line.strip() else line for line in replace_lines
+        ]
+        whole_lines = (
+            whole_lines[:index] + replace_lines + whole_lines[index + num_part_lines :]
+        )
+        return "".join(whole_lines)
+
+    return None
+
+
+def match_but_for_leading_whitespace(
+    whole_lines: list[str], part_lines: list[str]
+) -> str | None:
+    num = len(whole_lines)
+
+    # Does the non-whitespace all agree?
+    if not all(whole_lines[i].lstrip() == part_lines[i].lstrip() for i in range(num)):
+        return None
+
+    # Are they all offset the same?
+    add = set(
+        whole_lines[i][: len(whole_lines[i]) - len(part_lines[i])]
+        for i in range(num)
+        if whole_lines[i].strip()
+    )
+    if len(add) != 1:
+        return None
+
+    return add.pop()
+
+
+def strip_quoted_wrapping(
+    res: str, fname: str | None = None, fence: Fence = DEFAULT_FENCE
+) -> str:
+    """
+    Given an input string which may have extra "wrapping" around it, remove the wrapping.
+    For example:
+
+    filename.ext
+    ```
+    We just want this content
+    Not the filename and triple quotes
+    ```
+    """
+    if not res:
+        return res
+
+    res_lines = res.splitlines()
+
+    if fname and res_lines[0].strip().endswith(Path(fname).name):
+        res_lines = res_lines[1:]
+
+    if (
+        res_lines
+        and res_lines[0].startswith(fence[0])
+        and res_lines[-1].startswith(fence[1])
+    ):
+        res_lines = res_lines[1:-1]
+
+    result = "\n".join(res_lines)
+    if result and result[-1] != "\n":
+        result += "\n"
+
+    return result
+
+
+def do_replace(
+    fname: str | Path,
+    content: str | None,
+    before_text: str,
+    after_text: str,
+    fence: Fence | None = None,
+) -> str | None:
+    local_fence = fence or DEFAULT_FENCE
+    before_text = strip_quoted_wrapping(before_text, str(fname), local_fence)
+    after_text = strip_quoted_wrapping(after_text, str(fname), local_fence)
+    path = Path(fname)
+
+    # Does it want to make a new file?
+    if not path.exists() and not before_text.strip():
+        path.touch()
+        content = ""
+
+    if content is None:
+        return None
+
+    new_content: str | None
+    if not before_text.strip():
+        # Append to existing file, or start a new file.
+        new_content = content + after_text
+    else:
+        new_content = replace_most_similar_chunk(content, before_text, after_text)
+
+    return new_content
+
+
+def apply_edits(
+    edits: Sequence[EditBlock],
+    root: str | Path,
+    chat_files: Sequence[str | Path] | None = None,
+    fence: Fence = DEFAULT_FENCE,
+    dry_run: bool = False,
+) -> ApplyResult:
+    failed: list[EditBlock] = []
+    passed: list[EditBlock] = []
+    updated_edits: list[EditBlock] = []
+
+    root_path = Path(root)
+    fallback_files = _resolve_chat_files(root_path, chat_files)
+
+    for edit in edits:
+        path = edit.path
+        original = edit.original
+        updated = edit.updated
+
+        full_path = _resolve_path(root_path, path)
+        new_content: str | None = None
+
+        if full_path.exists():
+            content = full_path.read_text(encoding="utf-8")
+            new_content = do_replace(full_path, content, original, updated, fence)
+        elif not original.strip():
+            new_content = do_replace(full_path, None, original, updated, fence)
+
+        # If the edit failed, and this is not a "create a new file" with an empty original...
+        # https://github.com/Aider-AI/aider/issues/2258
+        if not new_content and original.strip():
+            # Try patching any of the other files in the chat.
+            for candidate_file in fallback_files:
+                content = candidate_file.read_text(encoding="utf-8")
+                new_content = do_replace(
+                    candidate_file, content, original, updated, fence
+                )
+                if new_content:
+                    path = _make_relative(candidate_file, root_path)
+                    full_path = candidate_file
+                    break
+
+        updated_edit = EditBlock(path=path, original=original, updated=updated)
+        updated_edits.append(updated_edit)
+
+        if new_content:
+            if not dry_run:
+                full_path.write_text(new_content, encoding="utf-8")
+            passed.append(edit)
+        else:
+            failed.append(edit)
+
+    if not failed:
+        return ApplyResult(updated_edits=updated_edits)
+
+    blocks = "block" if len(failed) == 1 else "blocks"
+    result = f"# {len(failed)} SEARCH/REPLACE {blocks} failed to match!\n"
+    for edit in failed:
+        path = edit.path
+        original = edit.original
+        updated = edit.updated
+
+        full_path = _resolve_path(root_path, path)
+        content = full_path.read_text(encoding="utf-8")
+
+        result += f"""
+## SearchReplaceNoExactMatch: This SEARCH block failed to exactly match lines in {path}
+<<<<<<< SEARCH
+{original}=======
+{updated}>>>>>>> REPLACE
+
+"""
+        did_you_mean = find_similar_lines(original, content)
+        if did_you_mean:
+            result += f"""Did you mean to match some of these actual lines from {path}?
+
+{fence[0]}
+{did_you_mean}
+{fence[1]}
+
+"""
+
+        if updated in content and updated:
+            result += f"""Are you sure you need this SEARCH/REPLACE block?
+The REPLACE lines are already in {path}!
+
+"""
+
+    result += (
+        "The SEARCH section must exactly match an existing block of lines including all white"
+        " space, comments, indentation, docstrings, etc\n"
+    )
+    if passed:
+        passed_blocks = "block" if len(passed) == 1 else "blocks"
+        if dry_run:
+            result += f"""
+# The other {len(passed)} SEARCH/REPLACE {passed_blocks} would apply successfully.
+"""
+        else:
+            result += f"""
+# The other {len(passed)} SEARCH/REPLACE {passed_blocks} were applied successfully.
+Don't re-send them.
+Just reply with fixed versions of the {blocks} above that failed to match.
+"""
+
+    raise ApplyError(
+        message=result, failed=failed, passed=passed, updated_edits=updated_edits
+    )
+
+
+def _resolve_path(root_path: Path, path: str | Path) -> Path:
+    resolved_root = root_path.resolve()
+    file_path = Path(path)
+    if file_path.is_absolute():
+        resolved_path = file_path.resolve()
+    else:
+        resolved_path = (resolved_root / file_path).resolve()
+
+    try:
+        resolved_path.relative_to(resolved_root)
+    except ValueError as exc:
+        raise PathEscapeError(
+            f"Refusing to edit path '{path}' because it resolves outside root "
+            f"'{resolved_root}'."
+        ) from exc
+
+    return resolved_path
+
+
+def _resolve_chat_files(
+    root_path: Path,
+    chat_files: Sequence[str | Path] | None,
+) -> list[Path]:
+    if chat_files is None:
+        return []
+
+    resolved_paths: list[Path] = []
+    for chat_file in chat_files:
+        resolved_paths.append(_resolve_path(root_path, chat_file))
+    return resolved_paths
+
+
+def _make_relative(path: Path, root_path: Path) -> str:
+    try:
+        return str(path.relative_to(root_path))
+    except ValueError:
+        return str(path)
+
+
+def apply_diff(
+    llm_response: str,
+    root: str | Path,
+    chat_files: Sequence[str | Path] | None = None,
+    fence: Fence = DEFAULT_FENCE,
+) -> ApplyResult:
+    """Parse SEARCH/REPLACE blocks from an LLM response and apply them to disk.
+
+    Convenience wrapper around ``parse_edit_blocks`` + ``apply_edits``.
+    Raises ``ParseError`` if the response contains no valid blocks or has
+    malformed syntax, and ``ApplyError`` if one or more blocks fail to match.
+    """
+    result = parse_edit_blocks(llm_response, fence=fence)
+    if not result.edits:
+        raise ParseError("No SEARCH/REPLACE blocks found in the LLM response.")
+    return apply_edits(result.edits, root=root, chat_files=chat_files, fence=fence)

search_replace/errors.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+
+from .types import EditBlock
+
+
+class SearchReplaceError(ValueError):
+    pass
+
+
+class ParseError(SearchReplaceError):
+    pass
+
+
+class MissingFilenameError(ParseError):
+    pass
+
+
+class PathEscapeError(SearchReplaceError):
+    pass
+
+
+@dataclass(slots=True)
+class ApplyError(SearchReplaceError):
+    message: str
+    failed: list[EditBlock]
+    passed: list[EditBlock]
+    updated_edits: list[EditBlock]
+
+    def __str__(self) -> str:
+        return self.message

search_replace/fuzzy.py

@@ -0,0 +1,80 @@
+import math
+from difflib import SequenceMatcher
+
+
+def replace_closest_edit_distance(
+    whole_lines: list[str],
+    part: str,
+    part_lines: list[str],
+    replace_lines: list[str],
+) -> str | None:
+    similarity_thresh = 0.8
+
+    max_similarity = 0.0
+    most_similar_chunk_start = -1
+    most_similar_chunk_end = -1
+
+    scale = 0.1
+    min_len = math.floor(len(part_lines) * (1 - scale))
+    max_len = math.ceil(len(part_lines) * (1 + scale))
+
+    for length in range(min_len, max_len):
+        for i in range(len(whole_lines) - length + 1):
+            chunk_lines = whole_lines[i : i + length]
+            chunk = "".join(chunk_lines)
+
+            similarity = SequenceMatcher(None, chunk, part).ratio()
+
+            if similarity > max_similarity and similarity:
+                max_similarity = similarity
+                most_similar_chunk_start = i
+                most_similar_chunk_end = i + length
+
+    if max_similarity < similarity_thresh:
+        return None
+
+    modified_whole = (
+        whole_lines[:most_similar_chunk_start]
+        + replace_lines
+        + whole_lines[most_similar_chunk_end:]
+    )
+    return "".join(modified_whole)
+
+
+def find_similar_lines(
+    search_lines: str, content_lines: str, threshold: float = 0.6
+) -> str:
+    search_lines_list = search_lines.splitlines()
+    content_lines_list = content_lines.splitlines()
+
+    best_ratio = 0.0
+    best_match: list[str] | None = None
+    best_match_i = -1
+
+    for i in range(len(content_lines_list) - len(search_lines_list) + 1):
+        chunk = content_lines_list[i : i + len(search_lines_list)]
+        ratio = SequenceMatcher(None, search_lines_list, chunk).ratio()
+        if ratio > best_ratio:
+            best_ratio = ratio
+            best_match = chunk
+            best_match_i = i
+
+    if best_ratio < threshold or best_match is None:
+        return ""
+
+    if (
+        best_match
+        and search_lines_list
+        and best_match[0] == search_lines_list[0]
+        and best_match[-1] == search_lines_list[-1]
+    ):
+        return "\n".join(best_match)
+
+    context_lines = 5
+    best_match_end = min(
+        len(content_lines_list), best_match_i + len(search_lines_list) + context_lines
+    )
+    best_match_i = max(0, best_match_i - context_lines)
+
+    best = content_lines_list[best_match_i:best_match_end]
+    return "\n".join(best)

search_replace/parser.py

@@ -0,0 +1,220 @@
+import difflib
+import re
+from pathlib import Path
+from typing import Iterator, Sequence, TypeAlias
+
+from .errors import MissingFilenameError, ParseError
+from .types import DEFAULT_FENCE, EditBlock, Fence, ParseResult
+
+
+def wrap_fence(name: str) -> Fence:
+    return f"<{name}>", f"</{name}>"
+
+
+all_fences = [
+    ("`" * 3, "`" * 3),
+    ("`" * 4, "`" * 4),  # LLMs ignore and revert to triple-backtick, causing #2879
+    wrap_fence("source"),
+    wrap_fence("code"),
+    wrap_fence("pre"),
+    wrap_fence("codeblock"),
+    wrap_fence("sourcecode"),
+]
+
+
+HEAD = r"^<{5,9} SEARCH>?\s*$"
+DIVIDER = r"^={5,9}\s*$"
+UPDATED = r"^>{5,9} REPLACE\s*$"
+
+HEAD_ERR = "<<<<<<< SEARCH"
+DIVIDER_ERR = "======="
+UPDATED_ERR = ">>>>>>> REPLACE"
+
+separators = "|".join([HEAD, DIVIDER, UPDATED])
+split_re = re.compile(r"^((?:" + separators + r")[ ]*\n)", re.MULTILINE | re.DOTALL)
+
+missing_filename_err = (
+    "Bad/missing filename. The filename must be alone on the line before the opening fence"
+    " {fence[0]}"
+)
+
+# Always be willing to treat triple-backticks as a fence when searching for filenames.
+triple_backticks = "`" * 3
+
+ParsedEditBlock: TypeAlias = tuple[str, str, str]
+
+
+def strip_filename(filename: str, fence: Fence) -> str | None:
+    filename = filename.strip()
+
+    if filename == "...":
+        return None
+
+    start_fence = fence[0]
+    if filename.startswith(start_fence):
+        candidate = filename[len(start_fence) :]
+        if candidate and ("." in candidate or "/" in candidate):
+            return candidate
+        return None
+
+    if filename.startswith(triple_backticks):
+        candidate = filename[len(triple_backticks) :]
+        if candidate and ("." in candidate or "/" in candidate):
+            return candidate
+        return None
+
+    filename = filename.rstrip(":")
+    filename = filename.lstrip("#")
+    filename = filename.strip()
+    filename = filename.strip("`")
+    filename = filename.strip("*")
+
+    # https://github.com/Aider-AI/aider/issues/1158
+    # filename = filename.replace("\\_", "_")
+    return filename
+
+
+def find_filename(
+    lines: list[str], fence: Fence, valid_fnames: Sequence[str] | None
+) -> str | None:
+    """
+    Deepseek Coder v2 has been doing this:
+
+     ```python
+    word_count.py
+    ```
+    ```python
+    <<<<<<< SEARCH
+    ...
+
+    This is a more flexible search back for filenames.
+    """
+    if valid_fnames is None:
+        valid_fnames = []
+
+    # Go back through the 3 preceding lines.
+    lines.reverse()
+    lines = lines[:3]
+
+    filenames: list[str] = []
+    for line in lines:
+        filename = strip_filename(line, fence)
+        if filename:
+            filenames.append(filename)
+
+        # Only continue as long as we keep seeing fences.
+        if not line.startswith(fence[0]) and not line.startswith(triple_backticks):
+            break
+
+    if not filenames:
+        return None
+
+    # Check for exact match first.
+    for fname in filenames:
+        if fname in valid_fnames:
+            return fname
+
+    # Check for partial match (basename match).
+    for fname in filenames:
+        for valid_name in valid_fnames:
+            if fname == Path(valid_name).name:
+                return valid_name
+
+    # Perform fuzzy matching with valid_fnames.
+    for fname in filenames:
+        close_matches = difflib.get_close_matches(fname, valid_fnames, n=1, cutoff=0.8)
+        if len(close_matches) == 1:
+            return close_matches[0]
+
+    # If no fuzzy match, look for a file w/extension.
+    for fname in filenames:
+        if "." in fname:
+            return fname
+
+    if filenames:
+        return filenames[0]
+
+    return None
+
+
+def find_original_update_blocks(
+    content: str,
+    fence: Fence = DEFAULT_FENCE,
+    valid_fnames: Sequence[str] | None = None,
+) -> Iterator[ParsedEditBlock]:
+    lines = content.splitlines(keepends=True)
+    i = 0
+    current_filename: str | None = None
+
+    head_pattern = re.compile(HEAD)
+    divider_pattern = re.compile(DIVIDER)
+    updated_pattern = re.compile(UPDATED)
+
+    while i < len(lines):
+        line = lines[i]
+
+        if head_pattern.match(line.strip()):
+            try:
+                # If next line after HEAD exists and is DIVIDER, it's a new file.
+                if i + 1 < len(lines) and divider_pattern.match(lines[i + 1].strip()):
+                    filename = find_filename(lines[max(0, i - 3) : i], fence, None)
+                else:
+                    filename = find_filename(
+                        lines[max(0, i - 3) : i], fence, valid_fnames
+                    )
+
+                if not filename:
+                    if current_filename:
+                        filename = current_filename
+                    else:
+                        raise MissingFilenameError(
+                            missing_filename_err.format(fence=fence)
+                        )
+
+                current_filename = filename
+
+                original_text: list[str] = []
+                i += 1
+                while i < len(lines) and not divider_pattern.match(lines[i].strip()):
+                    original_text.append(lines[i])
+                    i += 1
+
+                if i >= len(lines) or not divider_pattern.match(lines[i].strip()):
+                    raise ParseError(f"Expected `{DIVIDER_ERR}`")
+
+                updated_text: list[str] = []
+                i += 1
+                while i < len(lines) and not (
+                    updated_pattern.match(lines[i].strip())
+                    or divider_pattern.match(lines[i].strip())
+                ):
+                    updated_text.append(lines[i])
+                    i += 1
+
+                if i >= len(lines) or not (
+                    updated_pattern.match(lines[i].strip())
+                    or divider_pattern.match(lines[i].strip())
+                ):
+                    raise ParseError(f"Expected `{UPDATED_ERR}` or `{DIVIDER_ERR}`")
+
+                yield filename, "".join(original_text), "".join(updated_text)
+            except ValueError as exc:
+                processed = "".join(lines[: i + 1])
+                err = exc.args[0]
+                raise ParseError(f"{processed}\n^^^ {err}") from exc
+
+        i += 1
+
+
+def parse_edit_blocks(
+    content: str,
+    fence: Fence = DEFAULT_FENCE,
+    valid_fnames: Sequence[str] | None = None,
+) -> ParseResult:
+    edits = [
+        EditBlock(path=block[0], original=block[1], updated=block[2])
+        for block in find_original_update_blocks(
+            content, fence=fence, valid_fnames=valid_fnames
+        )
+    ]
+    return ParseResult(edits=edits)

search_replace/prompts.py

@@ -0,0 +1,242 @@
+# flake8: noqa: E501
+
+from typing import NamedTuple
+
+from .types import DEFAULT_FENCE, Fence
+
+
+class FewShotExampleMessages(NamedTuple):
+    """Two-turn few-shot examples that demonstrate the SEARCH/REPLACE format.
+
+    Include these at the *beginning* of the conversation history (before the real
+    user request) to improve format reliability. Models that see worked examples
+    in context produce significantly better-structured diffs.
+
+    Fields are plain strings — the caller maps them into whatever message type
+    their framework expects (e.g. Pydantic AI ``ModelRequest``/``ModelResponse``,
+    OpenAI ``{"role": "user", ...}`` dicts, etc.).
+    """
+
+    first_user_message: str
+    first_assistant_message: str
+    second_user_message: str
+    second_assistant_message: str
+
+
+class EditBlockFencedPrompts:
+    main_system = """Act as an expert software developer.
+Always use best practices when coding.
+Respect and use existing conventions, libraries, etc that are already present in the code base.
+{final_reminders}
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+
+Once you understand the request you MUST:
+
+1. Decide if you need to propose *SEARCH/REPLACE* edits to any files that haven't been added to the chat. You can create new files without asking!
+
+But if you need to propose edits to existing files not already added to the chat, you *MUST* tell the user their full path names and ask them to *add the files to the chat*.
+End your reply and wait for their approval.
+You can keep asking if you then decide you need to edit more files.
+
+2. Think step-by-step and explain the needed changes in a few short sentences.
+
+3. Describe each change with a *SEARCH/REPLACE block* per the examples below.
+
+All changes to files must use this *SEARCH/REPLACE block* format.
+ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
+"""
+
+    system_reminder = """
+# *SEARCH/REPLACE block* Rules:
+
+Every *SEARCH/REPLACE block* must use this format:
+1. The opening fence and code language, eg: {fence[0]}python
+2. The *FULL* file path alone on a line, verbatim. No bold asterisks, no quotes around it, no escaping of characters, etc.
+3. The start of search block: <<<<<<< SEARCH
+4. A contiguous chunk of lines to search for in the existing source code
+5. The dividing line: =======
+6. The lines to replace into the source code
+7. The end of the replace block: >>>>>>> REPLACE
+8. The closing fence: {fence[1]}
+
+Use the *FULL* file path, as shown to you by the user.
+{quad_backtick_reminder}
+Every *SEARCH* section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, etc.
+If the file contains code or other data wrapped/escaped in json/xml/quotes or other containers, you need to propose edits to the literal contents of the file, including the container markup.
+
+*SEARCH/REPLACE* blocks will *only* replace the first match occurrence.
+Including multiple unique *SEARCH/REPLACE* blocks if needed.
+Include enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+
+Keep *SEARCH/REPLACE* blocks concise.
+Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
+Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+Do not include long runs of unchanging lines in *SEARCH/REPLACE* blocks.
+
+Only create *SEARCH/REPLACE* blocks for files that the user has added to the chat!
+
+To move code within a file, use 2 *SEARCH/REPLACE* blocks: 1 to delete it from its current location, 1 to insert it in the new location.
+
+Pay attention to which filenames the user wants you to edit, especially if they are asking you to create a new file.
+
+If you want to put code in a new file, use a *SEARCH/REPLACE block* with:
+- A new file path, including dir name if needed
+- An empty `SEARCH` section
+- The new file's contents in the `REPLACE` section
+
+
+If the user just says something like "ok" or "go ahead" or "do that" they probably want you to make SEARCH/REPLACE blocks for the code changes you just proposed.
+The user will say when they've applied your edits. If they haven't explicitly confirmed the edits have been applied, they probably want proper SEARCH/REPLACE blocks.
+
+{final_reminders}
+ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
+"""
+
+    example_messages = [
+        dict(
+            role="user",
+            content="Change get_factorial() to use math.factorial",
+        ),
+        dict(
+            role="assistant",
+            content="""To make this change we need to modify `mathweb/flask/app.py` to:
+
+1. Import the math package.
+2. Remove the existing factorial() function.
+3. Update get_factorial() to call math.factorial instead.
+
+Here are the *SEARCH/REPLACE* blocks:
+
+{fence[0]}python
+mathweb/flask/app.py
+<<<<<<< SEARCH
+from flask import Flask
+=======
+import math
+from flask import Flask
+>>>>>>> REPLACE
+{fence[1]}
+
+{fence[0]}python
+mathweb/flask/app.py
+<<<<<<< SEARCH
+def factorial(n):
+    "compute factorial"
+
+    if n == 0:
+        return 1
+    else:
+        return n * factorial(n-1)
+
+=======
+>>>>>>> REPLACE
+{fence[1]}
+
+{fence[0]}python
+mathweb/flask/app.py
+<<<<<<< SEARCH
+    return str(factorial(n))
+=======
+    return str(math.factorial(n))
+>>>>>>> REPLACE
+{fence[1]}
+""",
+        ),
+        dict(
+            role="user",
+            content="Refactor hello() into its own file.",
+        ),
+        dict(
+            role="assistant",
+            content="""To make this change we need to modify `main.py` and make a new file `hello.py`:
+
+1. Make a new hello.py file with hello() in it.
+2. Remove hello() from main.py and replace it with an import.
+
+Here are the *SEARCH/REPLACE* blocks:
+
+{fence[0]}python
+hello.py
+<<<<<<< SEARCH
+=======
+def hello():
+    "print a greeting"
+
+    print("hello")
+>>>>>>> REPLACE
+{fence[1]}
+
+{fence[0]}python
+main.py
+<<<<<<< SEARCH
+def hello():
+    "print a greeting"
+
+    print("hello")
+=======
+from hello import hello
+>>>>>>> REPLACE
+{fence[1]}
+""",
+        ),
+    ]
+
+
+def render_prompt(
+    template: str,
+    *,
+    fence: Fence = DEFAULT_FENCE,
+    final_reminders: str = "",
+    quad_backtick_reminder: str = "",
+) -> str:
+    return template.format(
+        fence=fence,
+        final_reminders=final_reminders,
+        quad_backtick_reminder=quad_backtick_reminder,
+    )
+
+
+def render_system_prompt(
+    *,
+    fence: Fence = DEFAULT_FENCE,
+    final_reminders: str = "",
+    quad_backtick_reminder: str = "",
+) -> str:
+    """Return the fully rendered system prompt string for the fenced editblock format.
+
+    The returned string is plain text — the caller decides how to include it in
+    their message list (e.g. as the ``content`` of a ``{"role": "system", ...}``
+    dict, or as the ``instructions`` argument of a Pydantic AI agent).
+    """
+    body = render_prompt(
+        EditBlockFencedPrompts.main_system,
+        fence=fence,
+        final_reminders=final_reminders,
+        quad_backtick_reminder=quad_backtick_reminder,
+    )
+    reminder = render_prompt(
+        EditBlockFencedPrompts.system_reminder,
+        fence=fence,
+        final_reminders=final_reminders,
+        quad_backtick_reminder=quad_backtick_reminder,
+    )
+    return body + reminder
+
+
+def get_example_messages(*, fence: Fence = DEFAULT_FENCE) -> FewShotExampleMessages:
+    """Return the two-turn few-shot examples with all fence placeholders expanded.
+
+    Prepend these to the conversation history (before the real user request) to
+    improve format reliability.  See ``FewShotExampleMessages`` for field names.
+    """
+    expanded = [
+        msg["content"].format(fence=fence)
+        for msg in EditBlockFencedPrompts.example_messages
+    ]
+    return FewShotExampleMessages(
+        first_user_message=expanded[0],
+        first_assistant_message=expanded[1],
+        second_user_message=expanded[2],
+        second_assistant_message=expanded[3],
+    )

search_replace/types.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import TypeAlias
+
+Fence: TypeAlias = tuple[str, str]
+DEFAULT_FENCE: Fence = ("`" * 3, "`" * 3)
+
+
+@dataclass(frozen=True, slots=True)
+class EditBlock:
+    path: str
+    original: str
+    updated: str
+
+
+@dataclass(frozen=True, slots=True)
+class ParseResult:
+    edits: list[EditBlock]
+
+
+@dataclass(frozen=True, slots=True)
+class ApplyResult:
+    updated_edits: list[EditBlock]

search_replace_py-0.0.1.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: search-replace-py
+Version: 0.0.1
+Summary: Parse and apply Aider-style SEARCH/REPLACE patch blocks to files
+Project-URL: Homepage, https://github.com/marcius-llmus/search-replace-py
+Project-URL: Repository, https://github.com/marcius-llmus/search-replace-py
+Project-URL: Issues, https://github.com/marcius-llmus/search-replace-py/issues
+Project-URL: Changelog, https://github.com/marcius-llmus/search-replace-py/releases
+Author: marcin
+License: MIT License
+        
+        Copyright (c) 2026 marcin
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: aider,diff,editblock,llm,patch,replace,search,tooling
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# search-replace-py
+
+A standalone Python library for parsing and applying SEARCH/REPLACE patch blocks, extracted from [Aider's](https://github.com/Aider-AI/aider) editblock engine.
+
+Use it to give any LLM the ability to propose and apply precise code changes using the battle-tested editblock format.
+
+---
+
+## How it works
+
+The editblock format is Aider's primary mechanism for LLM-driven code editing. The LLM is prompted to output changes as structured `SEARCH/REPLACE` blocks:
+
+````
+```python
+mathweb/flask/app.py
+<<<<<<< SEARCH
+from flask import Flask
+=======
+import math
+from flask import Flask
+>>>>>>> REPLACE
+```
+````
+
+This library provides:
+
+1. **`render_system_prompt()`** — returns the rendered system prompt string to instruct the LLM.
+2. **`get_example_messages()`** — returns a `FewShotExampleMessages` named tuple with four plain strings (two user + two assistant turns) to prepend to the conversation history.
+3. **`apply_diff(llm_response, root)`** — parses the LLM's response and applies all blocks to disk in one call.
+
+---
+
+## What is included
+
+- Block parsing (`<<<<<<< SEARCH`, `=======`, `>>>>>>> REPLACE`) with filename discovery and fuzzy filename resolution.
+- Three replacement strategies:
+  - exact match
+  - leading-whitespace-tolerant match
+  - dotdotdot (`...`) segmented replacement
+- Typed errors (`ParseError`, `ApplyError`) for clean error handling in retry loops.
+
+---
+
+## Installation
+
+```bash
+pip install search-replace-py
+# or with uv
+uv add search-replace-py
+```
+
+---
+
+## Quick start
+
+```python
+from pathlib import Path
+from search_replace import render_system_prompt, get_example_messages, apply_diff
+
+# 1. Build the system prompt — plain string, append your own context if needed
+system_prompt = render_system_prompt()
+
+# 2. Build the messages list; prepend few-shot examples before the real request
+ex = get_example_messages()
+messages = [{"role": "system", "content": system_prompt}]
+messages += [
+    {"role": "user",      "content": ex.first_user_message},
+    {"role": "assistant", "content": ex.first_assistant_message},
+    {"role": "user",      "content": ex.second_user_message},
+    {"role": "assistant", "content": ex.second_assistant_message},
+]
+messages.append({"role": "user", "content": "Add a docstring to the greet() function in hello.py"})
+
+# 3. Send to your LLM and get a response string
+llm_response = "..."
+
+# 4. Parse and apply in one call
+apply_diff(llm_response, root=Path("."))
+```
+
+---
+
+## Integration with Pydantic AI
+
+[Pydantic AI](https://ai.pydantic.dev) accepts a string for `instructions` and a list of `ModelMessage` objects for `message_history`.
+
+```python
+from pathlib import Path
+
+from pydantic_ai import Agent, ModelRequest, ModelResponse, TextPart, UserPromptPart
+from search_replace import render_system_prompt, get_example_messages, apply_diff
+
+ex = get_example_messages()
+
+few_shot = [
+    ModelRequest(parts=[UserPromptPart(content=ex.first_user_message)]),
+    ModelResponse(parts=[TextPart(content=ex.first_assistant_message)]),
+    ModelRequest(parts=[UserPromptPart(content=ex.second_user_message)]),
+    ModelResponse(parts=[TextPart(content=ex.second_assistant_message)]),
+]
+
+agent = Agent("openai:gpt-5.2", instructions=render_system_prompt())
+
+auth_py = Path("auth.py").read_text()
+result = agent.run_sync(
+    f"Refactor the login function in auth.py to use bcrypt.\n\nauth.py\n```python\n{auth_py}\n```",
+    message_history=few_shot,
+)
+
+apply_diff(result.output, root=Path("."))
+```
+
+### With dry-run validation before writing
+
+```python
+from search_replace import parse_edit_blocks, apply_edits
+from search_replace.errors import ApplyError
+
+blocks = parse_edit_blocks(result.output)
+
+# Validate all blocks match before touching disk.
+# Without dry_run, blocks that match are written immediately — a later failure
+# would leave files partially patched with no rollback.
+try:
+    apply_edits(blocks.edits, root=Path("."), dry_run=True)
+except ApplyError as e:
+    # feed the error back to the LLM for a retry
+    print(f"Patch would not apply: {e}")
+else:
+    apply_edits(blocks.edits, root=Path("."))
+```
+
+---
+
+## Public API
+
+```python
+from search_replace import (
+    # Prompt
+    render_system_prompt,
+    get_example_messages,    # returns FewShotExampleMessages
+    FewShotExampleMessages,  # NamedTuple: first/second_user/assistant_message
+    render_prompt,           # render a single template string
+    EditBlockFencedPrompts,  # raw class with main_system, system_reminder, example_messages
+
+    # Parse + apply (convenience)
+    apply_diff,
+
+    # Parsing
+    parse_edit_blocks,
+    find_original_update_blocks,
+    EditBlock,
+
+    # Applying
+    apply_edits,              # pass dry_run=True to validate without writing
+
+    # Errors
+    ParseError,
+    ApplyError,
+    MissingFilenameError,
+)
+```
+
+---
+
+## Tests and validation
+
+- `tests/test_parser.py` — block parsing, filename resolution, edge cases
+- `tests/test_apply.py` — replacement strategies, whitespace tolerance, new-file creation
+- `tests/test_prompts.py` — `render_system_prompt` and `get_example_messages` output
+- `tests/test_parity_harness.py` — byte-for-byte comparison against Aider's reference output on the real 100K-line `chat-history.md` fixture
+
+```bash
+uv run python -m pytest tests/
+```
+
+---
+
+## Credits
+
+The parsing engine, replacement strategies, and prompt templates in this library are derived from [Aider](https://github.com/Aider-AI/aider), created by [Paul Gauthier](https://github.com/paul-gauthier). Aider is an outstanding AI pair-programming tool — this library simply extracts and packages its editblock mechanism so it can be reused in other applications. All credit for the original design and implementation goes to him.
+
+---
+
+## Extraction notes
+
+- Extracted from `aider/coders/editblock_coder.py` and the fenced editblock prompt module.
+- Runtime coupling to Aider's coder/model lifecycle is fully removed.
+- Error message contracts for malformed blocks and failed apply paths are preserved to maintain LLM retry-loop compatibility.
+- `replace_closest_edit_distance()` remains defined but inactive, preserving the original behaviour of the early return in `replace_most_similar_chunk()`.

search_replace_py-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+search_replace/__init__.py,sha256=Jyzs5GZMCtYMVcdqJkoR07EIxGXJxf14wKZDlOneYQ0,907
+search_replace/apply.py,sha256=V04eEtTGRlJ4_gHGsvUJ9UDO7taOgR_sLNLU8jh3tcQ,13363
+search_replace/errors.py,sha256=aR3QrSi9wNFX7auxZ-3b3ehqp6qwng4CAjURldhLztA,497
+search_replace/fuzzy.py,sha256=YsEVhstYnM_dIBF-_UWWinlxyC1kuJrWA2ok6Rel4Vs,2347
+search_replace/parser.py,sha256=88zS_clAgpLl7zIfrKxs6pTiwzJPe67FzwoULNInG1c,6542
+search_replace/prompts.py,sha256=IHcxq-EVp54JgO1DIqHfc8RfWxf90-CV4ypp4x4q8-I,7934
+search_replace/types.py,sha256=aHff-EA8lPg7h3AEpXZdVHP9KTQPwFu1qU7BApb4Xdw,421
+search_replace_py-0.0.1.dist-info/METADATA,sha256=0cElG_DIB_Qu2JIO3l4_RmyZmvicQlqyU4bRo2re9UA,8494
+search_replace_py-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+search_replace_py-0.0.1.dist-info/licenses/LICENSE,sha256=cOD3IuAXuzQsvTmvINNjkW2NCRMgkov1vBliZYjg5gk,1063
+search_replace_py-0.0.1.dist-info/RECORD,,

search_replace_py-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

search_replace_py-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 marcin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.