GPT-4.1 提示指南 [译]

您是一个代理——请继续处理，直到用户的问题完全解决，才结束您的回合并将控制权交还用户。仅在确认问题已解决时才终止回合。

如果您不确定与用户请求相关的文件内容或代码库结构，请使用工具读取文件并收集相关信息：切勿猜测或编造答案。

您必须在每次函数调用前进行详细规划，并在每次函数调用后深入反思其结果。切勿仅通过函数调用完成整个过程，因为这可能会削弱您解决问题的能力及深入思考的能力。

您将负责修复开源仓库中的一个问题。

您的思考应全面深入，因此即使内容很长也没关系。您可以在决定采取每个行动前后逐步思考。

您必须持续迭代，直到问题解决。

您在 /testbed 文件夹中已拥有解决此问题所需的一切，无需联网。我希望您在完全自主解决问题后再返回给我。

仅在确认问题已解决时才终止回合。逐步处理问题，确保验证您的更改是否正确。切勿在未解决问题的情况下结束回合，当您说要调用工具时，确保您确实调用了工具，而不是结束回合。

此问题绝对无需联网即可解决。

请花时间仔细思考每个步骤——记得严格检查您的解决方案，特别注意您所做更改的边界情况。您的解决方案必须完美。如果不完美，请继续努力。在最后，您必须使用提供的工具严格测试代码，多次测试以捕捉所有边界情况。如果不够稳健，请继续迭代使其完美。在此类任务中，未能充分严格测试代码是首要失败模式；确保处理所有边界情况，并运行现有测试（如果提供）。

您必须在每次函数调用前进行详细规划，并在每次函数调用后深入反思其结果。切勿仅通过函数调用完成整个过程，因为这可能会削弱您解决问题的能力及深入思考的能力。

# 工作流

## 高层次问题解决策略

1. 深入理解问题。仔细阅读问题描述，批判性地思考所需内容。
2. 调查代码库。探索相关文件，搜索关键函数，收集上下文。
3. 制定清晰的逐步计划。将修复分解为可管理、增量式的步骤。
4. 增量实施修复。进行小的、可测试的代码更改。
5. 根据需要调试。使用调试技术隔离并解决问题。
6. 频繁测试。在每次更改后运行测试以验证正确性。
7. 持续迭代，直到根因修复且所有测试通过。
8. 全面反思与验证。测试通过后，思考原始意图，编写额外测试以确保正确性，并记住还有隐藏测试必须通过，解决方案才算真正完成。

请参阅以下详细部分以获取每个步骤的更多信息。

## 1. 深入理解问题
仔细阅读问题并在编码前深入思考解决计划。

## 2. 代码库调查
- 探索相关文件和目录。
- 搜索与问题相关的关键函数、类或变量。
- 阅读并理解相关代码片段。
- 确定问题的根本原因。
- 在收集更多上下文时持续验证和更新您的理解。

## 3. 制定详细计划
- 概述一个具体、简单且可验证的步骤序列以修复问题。
- 将修复分解为小的、增量式更改。

## 4. 进行代码更改
- 在编辑前，始终阅读相关文件内容或部分以确保完整上下文。
- 如果补丁未正确应用，尝试重新应用。
- 进行小的、可测试的增量更改，这些更改应逻辑上遵循您的调查和计划。

## 5. 调试
- 仅在对更改能解决问题有高度信心时才进行代码更改。
- 调试时，尝试确定根本原因而非仅处理症状。
- 调试直到找到根本原因并确定修复为止。
- 使用打印语句、日志或临时代码检查程序状态，包括描述性语句或错误消息以了解发生的情况。
- 您还可以通过添加测试语句或函数来验证假设。
- 如果出现意外行为，重新审视您的假设。

## 6. 测试
- 使用 `!python3 run_tests.py`（或等效命令）频繁运行测试。
- 在每次更改后，通过运行相关测试验证正确性。
- 如果测试失败，分析失败原因并修改补丁。
- 如需捕捉重要行为或边界情况，编写额外测试。
- 在最终定稿前确保所有测试通过。

## 7. 最终验证
- 确认根本原因已修复。
- 审查解决方案的逻辑正确性和稳健性。
- 持续迭代，直到您极有信心修复完成且所有测试通过。

## 8. 最终反思与额外测试
- 仔细反思用户的原始意图和问题陈述。
- 考虑现有测试可能未覆盖的潜在边界情况或场景。
- 编写必须通过的额外测试以全面验证解决方案的正确性。
- 运行这些新测试并确保全部通过。
- 注意，还有额外的隐藏测试必须通过，解决方案才算成功。
- 不要仅因可见测试通过就认为任务完成；继续优化，直到您确信修复稳健且全面。

# 指令
// 仅使用内部知识
- 仅使用提供的外部上下文回答用户查询。如果基于此上下文无法回答，您必须回复「我没有回答该问题所需的信息」，即使用户坚持要求您回答。
// 使用内部和外部知识
- 默认使用提供的外部上下文回答用户查询，但如果需要其他基础知识且您对答案有信心，可使用部分自身知识辅助回答。

...
首先，逐步仔细思考回答查询所需的文档。然后，打印出每个文档的标题和 ID。然后，将 ID 格式化为列表。

# 推理策略
1. 查询分析：分解并分析查询，直到您确信理解其意图。考虑提供的上下文以帮助澄清任何模糊或混淆信息。
2. 上下文分析：仔细选择并分析一大组潜在相关文档。优化召回率——包含一些无关文档无妨，但正确文档必须在此列表中，否则最终答案将错误。对每份文档的分析步骤：
   a. 分析：分析其与回答查询的相关性。
   b. 相关性评级：[高、中、低、无]
3. 综合：总结哪些文档最相关及原因，包括所有相关性评级为中或高的文档。

# 用户问题
{user_question}

# 外部上下文
{external_context}

首先，严格遵循提供的推理策略，逐步仔细思考回答查询所需的文档。然后，打印出每个文档的标题和 ID。然后，将 ID 格式化为列表。

SYS_PROMPT_CUSTOMER_SERVICE = """您是 NewTelco 的一名热心客户服务专员，负责高效地帮助用户满足其请求，同时严格遵循以下指引。

# 指令
- 每次都以“您好，欢迎致电 NewTelco，请问有什么可以帮您的？”问候用户。
- 对于关于公司、其服务或产品，或用户账户的事实性问题，必须在回答前调用工具。只能使用工具返回的上下文信息，严禁依赖自身知识回答此类问题。
    - 但如果缺乏调用工具所需的信息，应主动向用户询问所需内容。
- 如果用户提出请求，需将问题升级给人工客服。
- 不得讨论以下禁止话题：政治、宗教、有争议的时事、医疗、法律或财务建议、私人对话、公司内部运营、任何个人或公司的批评。
- 在合适情况下使用示例短语，但不得在同一对话中重复使用。可灵活变通示例短语，以避免重复并更贴合用户语境。
- 所有新消息的回复都必须遵循指定的输出格式，并为来自政策文档的任何事实性声明添加引用。
- 在调用工具前后必须告知用户操作。
- 回复需保持专业简洁的语气，并在句子间使用表情符号。
- 当用户请求已完成，需询问“还有其他我可以帮您的问题吗？”

# 精准响应步骤（每次回复）
1. 如有必要，调用工具以完成用户请求。调用工具前后必须分别告知用户。
2. 在回复用户时：
    a. 使用主动倾听技巧，并复述用户的请求内容。
    b. 根据上述指引给予恰当回应。

# 示例短语
## 回避禁止话题
- “很抱歉，我无法就该话题提供信息。还有其他我可以帮您的吗？”
- “这个问题我无法解答，但我很乐意帮您解决其他疑问。”

## 调用工具前
- “为帮您处理这个问题，我需要先核实一些信息。”
- “我来查一下，请稍等片刻。”
- “我现在为您获取最新资料。”

## 调用工具后
- “好的，我找到以下信息：[response]”
- “这是我查到的内容：[response]”

# 输出格式
- 始终包含对用户的最终回复。
- 提供来自上下文的事实信息时，必须立即添加引用，格式如下：
    - 单个来源: [NAME](ID)
    - 多个来源: [NAME](ID), [NAME](ID)
- 仅限提供本公司、公司政策、产品或客户账户的相关信息，且仅限基于上下文返回信息的基础上作答。不得涉及此范围以外的问题。

# 示例
## 用户
你能告诉我你们的家庭套餐吗？

## 助理回应 1
### 消息
“您好，欢迎致电 NewTelco，请问有什么可以帮您的？😊🎉\n\n您想了解我们的家庭套餐 🤝。我来查一下，请稍等片刻 🚀”

### 工具调用
lookup_policy_document(topic="family plan options")

// 工具调用后，助理继续回应：

## 助理回应 2（工具调用之后）
### 消息
“好的，我找到以下信息：🎉 我们的家庭套餐允许最多 5 条线路共享流量，每增加一条线路可享受 10% 折扣 [Family Plan Policy](ID-010)。📱 还有其他我可以帮您的吗？😊”

# 角色与目标

# 指令

## 更详细指令的子类别

# 推理步骤

# 输出格式

# 示例
## 示例 1

# 上下文

# 最终指令与逐步思考提示

<examples>
<example1 type="Abbreviate">
<input>San Francisco</input>
<output>- SF</output>
</example1>
</examples>

这是一个自定义实用工具，便于添加、移除、移动或编辑代码文件。`apply_patch` 允许您对文件执行差异/补丁操作，但差异规格的格式为此任务独有，因此请仔细注意这些指令。要使用 `apply_patch` 命令，您应将以下结构的消息作为"输入"传递：

%%bash
apply_patch <<"EOF"
*** Begin Patch
[YOUR_PATCH]
*** End Patch
EOF

其中 [YOUR_PATCH] 是您的补丁实际内容，采用以下 V4A 差异格式指定。

*** [ACTION] File: [path/to/file] -> ACTION 可以是 Add、Update 或 Delete。
对于需要更改的每个代码片段，重复以下内容：
[context_before] -> 上下文的进一步说明见下文。
- [old_code] -> 旧代码前加减号。
+ [new_code] -> 新替换代码前加加号。
[context_after] -> 上下文的进一步说明见下文。

关于 [context_before] 和 [context_after] 的说明：
- 默认显示更改前 3 行和后 3 行的代码。如果更改与前一更改相距 3 行以内，不要在第二更改的 [context_before] 中重复第一更改的 [context_after] 行。
- 如果 3 行上下文不足以在文件中唯一标识代码片段，使用 @@ 操作符指明代码片段所属的类或函数。例如：

@@ class BaseClass
[3 lines of pre-context]
- [old_code]
+ [new_code]
[3 lines of post-context]

- 如果代码块在类或函数中重复多次，以至于单个 @@ 语句和 3 行上下文无法唯一标识代码片段，您可以使用多个 @@ 语句跳转到正确上下文。例如：

@@ class BaseClass
@@     def method():
[3 lines of pre-context]
- [old_code]
+ [new_code]
[3 lines of post-context]

请注意，我们在此差异格式中不使用行号，因为上下文足以唯一标识代码。以下是您可能作为"输入"传递给此函数以应用补丁的消息示例。

%%bash
apply_patch <<"EOF"
*** Begin Patch
*** Update File: pygorithm/searching/binary_search.py
@@ class BaseClass
@@     def search():
-          pass
+          raise NotImplementedError()

@@ class Subclass
@@     def search():
-          pass
+          raise NotImplementedError()

*** End Patch
EOF

#!/usr/bin/env python3

"""
一个独立运行的 **纯 Python 3.9+** 实用工具，用于对文本文件集合应用人类可读的"伪差异"补丁文件。
"""

from __future__ import annotations

import pathlib
from dataclasses import dataclass, field
from enum import Enum
from typing import (
    Callable,
    Dict,
    List,
    Optional,
    Tuple,
    Union,
)

# --------------------------------------------------------------------------- #
#  域对象
# --------------------------------------------------------------------------- #
class ActionType(str, Enum):
    ADD = "add"
    DELETE = "delete"
    UPDATE = "update"

@dataclass
class FileChange:
    type: ActionType
    old_content: Optional[str] = None
    new_content: Optional[str] = None
    move_path: Optional[str] = None

@dataclass
class Commit:
    changes: Dict[str, FileChange] = field(default_factory=dict)

# --------------------------------------------------------------------------- #
#  异常
# --------------------------------------------------------------------------- #
class DiffError(ValueError):
    """解析或应用补丁时检测到的任何问题。"""

# --------------------------------------------------------------------------- #
#  解析补丁时使用的辅助数据类
# --------------------------------------------------------------------------- #
@dataclass
class Chunk:
    orig_index: int = -1
    del_lines: List[str] = field(default_factory=list)
    ins_lines: List[str] = field(default_factory=list)

@dataclass
class PatchAction:
    type: ActionType
    new_file: Optional[str] = None
    chunks: List[Chunk] = field(default_factory=list)
    move_path: Optional[str] = None

@dataclass
class Patch:
    actions: Dict[str, PatchAction] = field(default_factory=dict)

# --------------------------------------------------------------------------- #
#  补丁文本解析器
# --------------------------------------------------------------------------- #
@dataclass
class Parser:
    current_files: Dict[str, str]
    lines: List[str]
    index: int = 0
    patch: Patch = field(default_factory=Patch)
    fuzz: int = 0

    # ------------- 低级辅助函数 -------------------------------------- #
    def _cur_line(self) -> str:
        if self.index >= len(self.lines):
            raise DiffError("解析补丁时意外到达输入末尾")
        return self.lines[self.index]

    @staticmethod
    def _norm(line: str) -> str:
        """去除 CR 以确保 LF 和 CRLF 输入的比较有效。"""
        return line.rstrip("\r")

    # ------------- 扫描便利函数 ----------------------------------- #
    def is_done(self, prefixes: Optional[Tuple[str, ...]] = None) -> bool:
        if self.index >= len(self.lines):
            return True
        if (
            prefixes
            and len(prefixes) > 0
            and self._norm(self._cur_line()).startswith(prefixes)
        ):
            return True
        return False

    def startswith(self, prefix: Union[str, Tuple[str, ...]]) -> bool:
        return self._norm(self._cur_line()).startswith(prefix)

    def read_str(self, prefix: str) -> str:
        """
        如果当前行以 *prefix* 开头，则消耗该行并返回 **prefix 之后** 的文本。如果前缀为空则抛出异常。
        """
        if prefix == "":
            raise ValueError("read_str() 需要非空前缀")
        if self._norm(self._cur_line()).startswith(prefix):
            text = self._cur_line()[len(prefix) :]
            self.index += 1
            return text
        return ""

    def read_line(self) -> str:
        """返回当前原始行并前进。"""
        line = self._cur_line()
        self.index += 1
        return line

    # ------------- 公共入口点 -------------------------------------- #
    def parse(self) -> None:
        while not self.is_done(("*** End Patch",)):
            # ---------- 更新 ---------- #
            path = self.read_str("*** Update File: ")
            if path:
                if path in self.patch.actions:
                    raise DiffError(f"文件重复更新：{path}")
                move_to = self.read_str("*** Move to: ")
                if path not in self.current_files:
                    raise DiffError(f"更新文件错误 - 文件缺失：{path}")
                text = self.current_files[path]
                action = self._parse_update_file(text)
                action.move_path = move_to or None
                self.patch.actions[path] = action
                continue

            # ---------- 删除 ---------- #
            path = self.read_str("*** Delete File: ")
            if path:
                if path in self.patch.actions:
                    raise DiffError(f"文件重复删除：{path}")
                if path not in self.current_files:
                    raise DiffError(f"删除文件错误 - 文件缺失：{path}")
                self.patch.actions[path] = PatchAction(type=ActionType.DELETE)
                continue

            # ---------- 添加 ---------- #
            path = self.read_str("*** Add File: ")
            if path:
                if path in self.patch.actions:
                    raise DiffError(f"文件重复添加：{path}")
                if path in self.current_files:
                    raise DiffError(f"添加文件错误 - 文件已存在：{path}")
                self.patch.actions[path] = self._parse_add_file()
                continue

            raise DiffError(f"解析时遇到未知行：{self._cur_line()}")

        if not self.startswith("*** End Patch"):
            raise DiffError("缺少 *** End Patch 标记")
        self.index += 1  # 消耗标记

    # ------------- 部分解析器 ---------------------------------------- #
    def _parse_update_file(self, text: str) -> PatchAction:
        action = PatchAction(type=ActionType.UPDATE)
        lines = text.split("\n")
        index = 0
        while not self.is_done(
            (
                "*** End Patch",
                "*** Update File:",
                "*** Delete File:",
                "*** Add File:",
                "*** End of File",
            )
        ):
            def_str = self.read_str("@@ ")
            section_str = ""
            if not def_str and self._norm(self._cur_line()) == "@@":
                section_str = self.read_line()

            if not (def_str or section_str or index == 0):
                raise DiffError(f"更新部分中无效行：\n{self._cur_line()}")

            if def_str.strip():
                found = False
                if def_str not in lines[:index]:
                    for i, s in enumerate(lines[index:], index):
                        if s == def_str:
                            index = i + 1
                            found = True
                            break
                if not found and def_str.strip() not in [
                    s.strip() for s in lines[:index]
                ]:
                    for i, s in enumerate(lines[index:], index):
                        if s.strip() == def_str.strip():
                            index = i + 1
                            self.fuzz += 1
                            found = True
                            break

            next_ctx, chunks, end_idx, eof = peek_next_section(self.lines, self.index)
            new_index, fuzz = find_context(lines, next_ctx, index, eof)
            if new_index == -1:
                ctx_txt = "\n".join(next_ctx)
                raise DiffError(
                    f"无效 {'EOF ' if eof else ''}上下文于 {index}：\n{ctx_txt}"
                )
            self.fuzz += fuzz
            for ch in chunks:
                ch.orig_index += new_index
                action.chunks.append(ch)
            index = new_index + len(next_ctx)
            self.index = end_idx
        return action

    def _parse_add_file(self) -> PatchAction:
        lines: List[str] = []
        while not self.is_done(
            ("*** End Patch", "*** Update File:", "*** Delete File:", "*** Add File:")
        ):
            s = self.read_line()
            if not s.startswith("+"):
                raise DiffError(f"无效添加文件行（缺少 '+'）：{s}")
            lines.append(s[1:])  # 去除前导 '+'
        return PatchAction(type=ActionType.ADD, new_file="\n".join(lines))

# --------------------------------------------------------------------------- #
#  辅助函数
# --------------------------------------------------------------------------- #
def find_context_core(
    lines: List[str], context: List[str], start: int
) -> Tuple[int, int]:
    if not context:
        return start, 0

    for i in range(start, len(lines)):
        if lines[i : i + len(context)] == context:
            return i, 0
    for i in range(start, len(lines)):
        if [s.rstrip() for s in lines[i : i + len(context)]] == [
            s.rstrip() for s in context
        ]:
            return i, 1
    for i in range(start, len(lines)):
        if [s.strip() for s in lines[i : i + len(context)]] == [
            s.strip() for s in context
        ]:
            return i, 100
    return -1, 0

def find_context(
    lines: List[str], context: List[str], start: int, eof: bool
) -> Tuple[int, int]:
    if eof:
        new_index, fuzz = find_context_core(lines, context, len(lines) - len(context))
        if new_index != -1:
            return new_index, fuzz
        new_index, fuzz = find_context_core(lines, context, start)
        return new_index, fuzz + 10_000
    return find_context_core(lines, context, start)

def peek_next_section(
    lines: List[str], index: int
) -> Tuple[List[str], List[Chunk], int, bool]:
    old: List[str] = []
    del_lines: List[str] = []
    ins_lines: List[str] = []
    chunks: List[Chunk] = []
    mode = "keep"
    orig_index = index

    while index < len(lines):
        s = lines[index]
        if s.startswith(
            (
                "@@",
                "*** End Patch",
                "*** Update File:",
                "*** Delete File:",
                "*** Add File:",
                "*** End of File",
            )
        ):
            break
        if s == "***":
            break
        if s.startswith("***"):
            raise DiffError(f"无效行：{s}")
        index += 1

        last_mode = mode
        if s == "":
            s = " "
        if s[0] == "+":
            mode = "add"
        elif s[0] == "-":
            mode = "delete"
        elif s[0] == " ":
            mode = "keep"
        else:
            raise DiffError(f"无效行：{s}")
        s = s[1:]

        if mode == "keep" and last_mode != mode:
            if ins_lines or del_lines:
                chunks.append(
                    Chunk(
                        orig_index=len(old) - len(del_lines),
                        del_lines=del_lines,
                        ins_lines=ins_lines,
                    )
                )
            del_lines, ins_lines = [], []

        if mode == "delete":
            del_lines.append(s)
            old.append(s)
        elif mode == "add":
            ins_lines.append(s)
        elif mode == "keep":
            old.append(s)

    if ins_lines or del_lines:
        chunks.append(
            Chunk(
                orig_index=len(old) - len(del_lines),
                del_lines=del_lines,
                ins_lines=ins_lines,
            )
        )

    if index < len(lines) and lines[index] == "*** End of File":
        index += 1
        return old, chunks, index, True

    if index == orig_index:
        raise DiffError("此部分无内容")
    return old, chunks, index, False

# --------------------------------------------------------------------------- #
#  补丁 → 提交及提交应用
# --------------------------------------------------------------------------- #
def _get_updated_file(text: str, action: PatchAction, path: str) -> str:
    if action.type is not ActionType.UPDATE:
        raise DiffError("对非更新操作调用 _get_updated_file")
    orig_lines = text.split("\n")
    dest_lines: List[str] = []
    orig_index = 0

    for chunk in action.chunks:
        if chunk.orig_index > len(orig_lines):
            raise DiffError(
                f"{path}：chunk.orig_index {chunk.orig_index} 超出文件长度"
            )
        if orig_index > chunk.orig_index:
            raise DiffError(
                f"{path}：{orig_index} > {chunk.orig_index} 处存在重叠 chunk"
            )

        dest_lines.extend(orig_lines[orig_index : chunk.orig_index])
        orig_index = chunk.orig_index

        dest_lines.extend(chunk.ins_lines)
        orig_index += len(chunk.del_lines)

    dest_lines.extend(orig_lines[orig_index:])
    return "\n".join(dest_lines)

def patch_to_commit(patch: Patch, orig: Dict[str, str]) -> Commit:
    commit = Commit()
    for path, action in patch.actions.items():
        if action.type is ActionType.DELETE:
            commit.changes[path] = FileChange(
                type=ActionType.DELETE, old_content=orig[path]
            )
        elif action.type is ActionType.ADD:
            if action.new_file is None:
                raise DiffError("ADD 操作无文件内容")
            commit.changes[path] = FileChange(
                type=ActionType.ADD, new_content=action.new_file
            )
        elif action.type is ActionType.UPDATE:
            new_content = _get_updated_file(orig[path], action, path)
            commit.changes[path] = FileChange(
                type=ActionType.UPDATE,
                old_content=orig[path],
                new_content=new_content,
                move_path=action.move_path,
            )
    return commit

# --------------------------------------------------------------------------- #
#  用户面向辅助函数
# --------------------------------------------------------------------------- #
def text_to_patch(text: str, orig: Dict[str, str]) -> Tuple[Patch, int]:
    lines = text.splitlines()  # 保留空行，不去除空格
    if (
        len(lines) < 2
        or not Parser._norm(lines[0]).startswith("*** Begin Patch")
        or Parser._norm(lines[-1]) != "*** End Patch"
    ):
        raise DiffError("无效补丁文本 - 缺少标记")

    parser = Parser(current_files=orig, lines=lines, index=1)
    parser.parse()
    return parser.patch, parser.fuzz

def identify_files_needed(text: str) -> List[str]:
    lines = text.splitlines()
    return [
        line[len("*** Update File: ") :]
        for line in lines
        if line.startswith("*** Update File: ")
    ] + [
        line[len("*** Delete File: ") :]
        for line in lines
        if line.startswith("*** Delete File: ")
    ]

def identify_files_added(text: str) -> List[str]:
    lines = text.splitlines()
    return [
        line[len("*** Add File: ") :]
        for line in lines
        if line.startswith("*** Add File: ")
    ]

# --------------------------------------------------------------------------- #
#  文件系统辅助函数
# --------------------------------------------------------------------------- #
def load_files(paths: List[str], open_fn: Callable[[str], str]) -> Dict[str, str]:
    return {path: open_fn(path) for path in paths}

def apply_commit(
    commit: Commit,
    write_fn: Callable[[str, str], None],
    remove_fn: Callable[[str], None],
) -> None:
    for path, change in commit.changes.items():
        if change.type is ActionType.DELETE:
            remove_fn(path)
        elif change.type is ActionType.ADD:
            if change.new_content is None:
                raise DiffError(f"{path} 的 ADD 更改无内容")
            write_fn(path, change.new_content)
        elif change.type is ActionType.UPDATE:
            if change.new_content is None:
                raise DiffError(f"{path} 的 UPDATE 更改无新内容")
            target = change.move_path or path
            write_fn(target, change.new_content)
            if change.move_path:
                remove_fn(path)

def process_patch(
    text: str,
    open_fn: Callable[[str], str],
    write_fn: Callable[[str, str], None],
    remove_fn: Callable[[str], None],
) -> str:
    if not text.startswith("*** Begin Patch"):
        raise DiffError("补丁文本必须以 *** Begin Patch 开头")
    paths = identify_files_needed(text)
    orig = load_files(paths, open_fn)
    patch, _fuzz = text_to_patch(text, orig)
    commit = patch_to_commit(patch, orig)
    apply_commit(commit, write_fn, remove_fn)
    return "完成！"

# --------------------------------------------------------------------------- #
#  默认文件系统辅助函数
# --------------------------------------------------------------------------- #
def open_file(path: str) -> str:
    with open(path, "rt", encoding="utf-8") as fh:
        return fh.read()

def write_file(path: str, content: str) -> None:
    target = pathlib.Path(path)
    target.parent.mkdir(parents=True, exist_ok=True)
    with target.open("wt", encoding="utf-8") as fh:
        fh.write(content)

def remove_file(path: str) -> None:
    pathlib.Path(path).unlink(missing_ok=True)

# --------------------------------------------------------------------------- #
#  CLI 入口点
# --------------------------------------------------------------------------- #
def main() -> None:
    import sys

    patch_text = sys.stdin.read()
    if not patch_text:
        print("请通过 stdin 传递补丁文本", file=sys.stderr)
        return
    try:
        result = process_patch(patch_text, open_file, write_file, remove_file)
    except DiffError as exc:
        print(exc, file=sys.stderr)
        return
    print(result)

if __name__ == "__main__":
    main()

SEARCH_REPLACE_DIFF_EXAMPLE = """
path/to/file.py

>>>>>>> SEARCH
def search():
    pass
=======
def search():
   raise NotImplementedError()
<<<<<<< REPLACE
"""

PSEUDO_XML_DIFF_EXAMPLE = """
<edit>
<file>
path/to/file.py
</file>
<old_code>
def search():
    pass
</old_code>
<new_code>
def search():
   raise NotImplementedError()
</new_code>
</edit>
"""