jarvis-ai-assistant 0.3.29__py3-none-any.whl → 0.3.31__py3-none-any.whl

jarvis/jarvis_agent/edit_file_handler.py

@@ -13,7 +13,11 @@ class EditFileHandler(OutputHandler):
             ot("PATCH file=(?:'([^']+)'|\"([^\"]+)\"|([^>]+))") + r"\s*"
             r"(?:"
             + ot("DIFF")
-            + r"\s*"
+            + r"\s*(?:"
+            # 可选的RANGE标签，限制替换行号范围
+            + r"(?:" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*)?"
+            + r"(?:"
+            # 单点替换（SEARCH/REPLACE）
             + ot("SEARCH")
             + r"(.*?)"
             + ct("SEARCH")
@@ -21,15 +25,29 @@ class EditFileHandler(OutputHandler):
             + ot("REPLACE")
             + r"(.*?)"
             + ct("REPLACE")
+            + r"|"
+            # 区间替换（SEARCH_START/SEARCH_END/REPLACE）
+            + ot("SEARCH_START")
+            + r"(.*?)"
+            + ct("SEARCH_START")
+            + r"\s*"
+            + ot("SEARCH_END")
+            + r"(.*?)"
+            + ct("SEARCH_END")
             + r"\s*"
+            + ot("REPLACE")
+            + r"(.*?)"
+            + ct("REPLACE")
+            + r")"
+            + r")\s*"
             + ct("DIFF")
             + r"\s*)+"
-            + ct("PATCH"),
-            re.DOTALL,
+            + r"^" + ct("PATCH"),
+            re.DOTALL | re.MULTILINE,
         )
         self.diff_pattern = re.compile(
             ot("DIFF")
-            + r"\s*"
+            + r"\s*(?:" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*)?"
             + ot("SEARCH")
             + r"(.*?)"
             + ct("SEARCH")
@@ -41,6 +59,24 @@ class EditFileHandler(OutputHandler):
             + ct("DIFF"),
             re.DOTALL,
         )
+        self.diff_range_pattern = re.compile(
+            ot("DIFF")
+            + r"\s*(?:" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*)?"
+            + ot("SEARCH_START")
+            + r"(.*?)"
+            + ct("SEARCH_START")
+            + r"\s*"
+            + ot("SEARCH_END")
+            + r"(.*?)"
+            + ct("SEARCH_END")
+            + r"\s*"
+            + ot("REPLACE")
+            + r"(.*?)"
+            + ct("REPLACE")
+            + r"\s*"
+            + ct("DIFF"),
+            re.DOTALL,
+        )
 
     def handle(self, response: str, agent: Any) -> Tuple[bool, str]:
         """处理文件编辑响应
@@ -65,9 +101,7 @@ class EditFileHandler(OutputHandler):
 
         for file_path, diffs in patches.items():
             file_path = os.path.abspath(file_path)
-            file_patches = [
-                {"SEARCH": diff["SEARCH"], "REPLACE": diff["REPLACE"]} for diff in diffs
-            ]
+            file_patches = diffs
 
             success, result = self._fast_edit(file_path, file_patches)
 
@@ -96,17 +130,44 @@ class EditFileHandler(OutputHandler):
         Returns:
             str: 返回处理器的提示字符串
         """
-        return f"""文件编辑指令格式：
-{ot("PATCH file=文件路径")}
-{ot("DIFF")}
+        from jarvis.jarvis_utils.config import get_patch_format
+
+        patch_format = get_patch_format()
+
+        search_prompt = f"""{ot("DIFF")}
 {ot("SEARCH")}原始代码{ct("SEARCH")}
 {ot("REPLACE")}新代码{ct("REPLACE")}
-{ct("DIFF")}
+{ct("DIFF")}"""
+
+        search_range_prompt = f"""{ot("DIFF")}
+{ot("RANGE")}起止行号(如: 10-50)，可选{ct("RANGE")}
+{ot("SEARCH_START")}起始标记{ct("SEARCH_START")}
+{ot("SEARCH_END")}结束标记{ct("SEARCH_END")}
+{ot("REPLACE")}替换内容{ct("REPLACE")}
+{ct("DIFF")}"""
+
+        if patch_format == "search":
+            formats = search_prompt
+            supported_formats = "仅支持单点替换（SEARCH/REPLACE）"
+        elif patch_format == "search_range":
+            formats = search_range_prompt
+            supported_formats = "仅支持区间替换（SEARCH_START/SEARCH_END/REPLACE），可选RANGE限定行号范围"
+        else:  # all
+            formats = f"{search_prompt}\n或\n{search_range_prompt}"
+            supported_formats = "支持两种DIFF块：单点替换（SEARCH/REPLACE）与区间替换（SEARCH_START/SEARCH_END/REPLACE）"
+
+        return f"""文件编辑指令格式：
+{ot("PATCH file=文件路径")}
+{formats}
 {ct("PATCH")}
 
-可以返回多个PATCH块用于同时修改多个文件
-每个PATCH块可以包含多个DIFF块，每个DIFF块包含一组搜索和替换内容。
-搜索文本必须能在文件中唯一匹配，否则编辑将失败。"""
+注意：
+- {ot("PATCH")} 和 {ct("PATCH")} 必须出现在行首，否则不生效（会被忽略）
+- {supported_formats}
+- {ot("RANGE")}start-end{ct("RANGE")} 仅用于区间替换模式（SEARCH_START/SEARCH_END），表示只在指定行号范围内进行匹配与替换（1-based，闭区间）；省略则在整个文件范围内处理
+- 单点替换要求 SEARCH 在有效范围内唯一匹配（仅替换第一个匹配）
+- 区间替换命中有效范围内的第一个 {ot("SEARCH_START")} 及其后的第一个 {ot("SEARCH_END")}
+否则编辑将失败。"""
 
     def name(self) -> str:
         """获取处理器的名称
@@ -139,18 +200,75 @@ class EditFileHandler(OutputHandler):
                 }
         """
         patches: Dict[str, List[Dict[str, str]]] = {}
+
         for match in self.patch_pattern.finditer(response):
             # Get the file path from the appropriate capture group
             file_path = match.group(1) or match.group(2) or match.group(3)
-            diffs = []
-            for diff_match in self.diff_pattern.finditer(match.group(0)):
-                # 完全保留原始格式（包括所有空白和换行）
-                diffs.append(
-                    {
-                        "SEARCH": diff_match.group(1),  # 原始SEARCH内容
-                        "REPLACE": diff_match.group(2),  # 原始REPLACE内容
+            diffs: List[Dict[str, str]] = []
+
+            # 逐块解析，保持 DIFF 顺序
+            diff_block_pattern = re.compile(ot("DIFF") + r"(.*?)" + ct("DIFF"), re.DOTALL)
+            for block_match in diff_block_pattern.finditer(match.group(0)):
+                block_text = block_match.group(1)
+
+                # 提取可选的行号范围
+                range_scope = None
+                range_scope_match = re.match(
+                    r"^\s*" + ot("RANGE") + r"(.*?)" + ct("RANGE") + r"\s*",
+                    block_text,
+                    re.DOTALL,
+                )
+                if range_scope_match:
+                    range_scope = range_scope_match.group(1).strip()
+                    # 仅移除块首部的RANGE标签，避免误删内容中的同名标记
+                    block_text = block_text[range_scope_match.end():]
+                # 统一按 all 解析：无视配置，始终尝试区间替换
+                range_match = re.search(
+                    ot("SEARCH_START")
+                    + r"(.*?)"
+                    + ct("SEARCH_START")
+                    + r"\s*"
+                    + ot("SEARCH_END")
+                    + r"(.*?)"
+                    + ct("SEARCH_END")
+                    + r"\s*"
+                    + ot("REPLACE")
+                    + r"(.*?)"
+                    + ct("REPLACE"),
+                    block_text,
+                    re.DOTALL,
+                )
+                if range_match:
+                    diff_item: Dict[str, str] = {
+                        "SEARCH_START": range_match.group(1),  # 原始SEARCH_START内容
+                        "SEARCH_END": range_match.group(2),  # 原始SEARCH_END内容
+                        "REPLACE": range_match.group(3),  # 原始REPLACE内容
                     }
+                    if range_scope:
+                        diff_item["RANGE"] = range_scope
+                    diffs.append(diff_item)
+                    continue
+
+                # 解析单点替换（统一按 all 解析：无视配置，始终尝试单点替换）
+                single_match = re.search(
+                    ot("SEARCH")
+                    + r"(.*?)"
+                    + ct("SEARCH")
+                    + r"\s*"
+                    + ot("REPLACE")
+                    + r"(.*?)"
+                    + ct("REPLACE"),
+                    block_text,
+                    re.DOTALL,
                 )
+                if single_match:
+                    diff_item = {
+                        "SEARCH": single_match.group(1),  # 原始SEARCH内容
+                        "REPLACE": single_match.group(2),  # 原始REPLACE内容
+                    }
+                    # SEARCH 模式不支持 RANGE，直接忽略
+                    diffs.append(diff_item)
+
             if diffs:
                 if file_path in patches:
                     patches[file_path].extend(diffs)
@@ -194,85 +312,214 @@ class EditFileHandler(OutputHandler):
             failed_patches: List[Dict[str, Any]] = []
             successful_patches = 0
 
-            for patch in patches:
-                patch_count += 1
-                search_text = patch["SEARCH"]
-                replace_text = patch["REPLACE"]
-
-                # 精确匹配搜索文本（保留原始换行和空格）
-                exact_search = search_text
+            # 当存在RANGE时，确保按行号从后往前应用补丁，避免前面补丁影响后续RANGE的行号
+            ordered_patches: List[Dict[str, str]] = []
+            range_items: List[Tuple[int, int, int, Dict[str, str]]] = []
+            non_range_items: List[Tuple[int, Dict[str, str]]] = []
+            for idx, p in enumerate(patches):
+                r = p.get("RANGE")
+                if r and str(r).strip():
+                    m = re.match(r"\s*(\d+)\s*-\s*(\d+)\s*$", str(r))
+                    if m:
+                        start_line = int(m.group(1))
+                        end_line = int(m.group(2))
+                        range_items.append((start_line, end_line, idx, p))
+                    else:
+                        # RANGE格式无效的补丁保持原有顺序
+                        non_range_items.append((idx, p))
+                else:
+                    # 无RANGE的补丁保持原有顺序
+                    non_range_items.append((idx, p))
+            # 先应用RANGE补丁：按start_line、end_line、原始索引逆序
+            range_items.sort(key=lambda x: (x[0], x[1], x[2]), reverse=True)
+            ordered_patches = [item[3] for item in range_items] + [item[1] for item in non_range_items]
+
+            patch_count = len(ordered_patches)
+            for patch in ordered_patches:
                 found = False
 
-                if exact_search in modified_content:
-                    # 直接执行替换（保留所有原始格式），只替换第一个匹配
-                    modified_content = modified_content.replace(
-                        exact_search, replace_text, 1
-                    )
-
-                    found = True
-                else:
-                    # 如果匹配不到，并且search与replace块的首尾都是换行，尝试去掉第一个和最后一个换行
+                # 处理可选的RANGE范围：格式 "start-end"（1-based, 闭区间）
+                scoped = False
+                prefix = suffix = ""
+                base_content = modified_content
+                if "RANGE" in patch and str(patch["RANGE"]).strip():
+                    m = re.match(r"\s*(\d+)\s*-\s*(\d+)\s*$", str(patch["RANGE"]))
+                    if not m:
+                        error_msg = "RANGE格式无效，应为 'start-end' 的行号范围（1-based, 闭区间）"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                        # 不进行本补丁其它处理
+                        continue
+                    start_line = int(m.group(1))
+                    end_line = int(m.group(2))
+
+                    # 拆分为三段
+                    lines = modified_content.splitlines(keepends=True)
+                    total_lines = len(lines)
                     if (
-                        search_text.startswith("\n")
-                        and search_text.endswith("\n")
-                        and replace_text.startswith("\n")
-                        and replace_text.endswith("\n")
+                        start_line < 1
+                        or end_line < 1
+                        or start_line > end_line
+                        or start_line > total_lines
                     ):
-                        stripped_search = search_text[1:-1]
-                        stripped_replace = replace_text[1:-1]
-                        if stripped_search in modified_content:
-                            modified_content = modified_content.replace(
-                                stripped_search, stripped_replace, 1
-                            )
-
-                            found = True
-
-                    if not found:
-                        # 尝试增加缩进重试
-                        current_search = search_text
-                        current_replace = replace_text
+                        error_msg = f"RANGE行号无效（文件共有{total_lines}行）"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                        continue
+                    # 截断end_line不超过总行数
+                    end_line = min(end_line, total_lines)
+
+                    prefix = "".join(lines[: start_line - 1])
+                    base_content = "".join(lines[start_line - 1 : end_line])
+                    suffix = "".join(lines[end_line:])
+                    scoped = True
+
+                # 单点替换
+                if "SEARCH" in patch:
+                    search_text = patch["SEARCH"]
+                    replace_text = patch["REPLACE"]
+
+                    # 精确匹配搜索文本（保留原始换行和空格）
+                    exact_search = search_text
+
+                    def _count_occurrences(haystack: str, needle: str) -> int:
+                        if not needle:
+                            return 0
+                        return haystack.count(needle)
+
+                    # 1) 精确匹配，要求唯一
+                    cnt = _count_occurrences(base_content, exact_search)
+                    if cnt == 1:
+                        base_content = base_content.replace(exact_search, replace_text, 1)
+                        found = True
+                    elif cnt > 1:
+                        error_msg = "SEARCH 在指定范围内出现多次，要求唯一匹配"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                        # 不继续尝试其它变体
+                        continue
+                    else:
+                        # 2) 若首尾均为换行，尝试去掉首尾换行后匹配，要求唯一
                         if (
-                            current_search.startswith("\n")
-                            and current_search.endswith("\n")
-                            and current_replace.startswith("\n")
-                            and current_replace.endswith("\n")
+                            search_text.startswith("\n")
+                            and search_text.endswith("\n")
+                            and replace_text.startswith("\n")
+                            and replace_text.endswith("\n")
                         ):
-                            current_search = current_search[1:-1]
-                            current_replace = current_replace[1:-1]
-
-                        for space_count in range(1, 17):
-                            indented_search = "\n".join(
-                                " " * space_count + line if line.strip() else line
-                                for line in current_search.split("\n")
-                            )
-                            indented_replace = "\n".join(
-                                " " * space_count + line if line.strip() else line
-                                for line in current_replace.split("\n")
-                            )
-                            if indented_search in modified_content:
-                                modified_content = modified_content.replace(
-                                    indented_search, indented_replace, 1
+                            stripped_search = search_text[1:-1]
+                            stripped_replace = replace_text[1:-1]
+                            cnt2 = _count_occurrences(base_content, stripped_search)
+                            if cnt2 == 1:
+                                base_content = base_content.replace(
+                                    stripped_search, stripped_replace, 1
                                 )
-
                                 found = True
-                                break
+                            elif cnt2 > 1:
+                                error_msg = "SEARCH 在指定范围内出现多次（去掉首尾换行后），要求唯一匹配"
+                                failed_patches.append({"patch": patch, "error": error_msg})
+                                continue
+
+                        # 3) 尝试缩进适配（1..16个空格），要求唯一
+                        if not found:
+                            current_search = search_text
+                            current_replace = replace_text
+                            if (
+                                current_search.startswith("\n")
+                                and current_search.endswith("\n")
+                                and current_replace.startswith("\n")
+                                and current_replace.endswith("\n")
+                            ):
+                                current_search = current_search[1:-1]
+                                current_replace = current_replace[1:-1]
+
+                            for space_count in range(1, 17):
+                                indented_search = "\n".join(
+                                    " " * space_count + line if line.strip() else line
+                                    for line in current_search.split("\n")
+                                )
+                                indented_replace = "\n".join(
+                                    " " * space_count + line if line.strip() else line
+                                    for line in current_replace.split("\n")
+                                )
+                                cnt3 = _count_occurrences(base_content, indented_search)
+                                if cnt3 == 1:
+                                    base_content = base_content.replace(
+                                        indented_search, indented_replace, 1
+                                    )
+                                    found = True
+                                    break
+                                elif cnt3 > 1:
+                                    error_msg = "SEARCH 在指定范围内出现多次（缩进适配后），要求唯一匹配"
+                                    failed_patches.append({"patch": patch, "error": error_msg})
+                                    # 多匹配直接失败，不再继续尝试其它缩进
+                                    found = False
+                                    break
+
+                        if not found:
+                            # 未找到任何可用的唯一匹配
+                            failed_patches.append({"patch": patch, "error": "未找到唯一匹配的SEARCH"})
+
+                # 区间替换
+                elif "SEARCH_START" in patch and "SEARCH_END" in patch:
+                    search_start = patch["SEARCH_START"]
+                    search_end = patch["SEARCH_END"]
+                    replace_text = patch["REPLACE"]
+
+                    # 范围替换（包含边界），命中第一个起始标记及其后的第一个结束标记
+                    start_idx = base_content.find(search_start)
+                    if start_idx == -1:
+                        error_msg = "未找到SEARCH_START"
+                        failed_patches.append({"patch": patch, "error": error_msg})
+                    else:
+                        end_idx = base_content.find(search_end, start_idx)
+                        if end_idx == -1:
+                            error_msg = "在SEARCH_START之后未找到SEARCH_END"
+                            failed_patches.append({"patch": patch, "error": error_msg})
+                        else:
+                            # 避免额外空行:
+                            # 若 REPLACE 以换行结尾且 SEARCH_END 后紧跟换行符，
+                            # 则将该换行并入替换范围，防止出现双重换行导致“多一行”
+                            end_of_range = end_idx + len(search_end)
+                            if (
+                                end_of_range < len(base_content)
+                                and base_content[end_of_range] == "\n"
+                                and replace_text.endswith("\n")
+                            ):
+                                end_of_range += 1
+                            base_content = (
+                                base_content[:start_idx]
+                                + replace_text
+                                + base_content[end_of_range:]
+                            )
+                            found = True
 
-                if found:
-                    successful_patches += 1
                 else:
-                    error_msg = "搜索文本在文件中不存在"
-
+                    error_msg = "不支持的补丁格式"
                     failed_patches.append({"patch": patch, "error": error_msg})
 
+                # 若使用了RANGE，则将局部修改写回整体内容
+                if found:
+                    if scoped:
+                        modified_content = prefix + base_content + suffix
+                    else:
+                        modified_content = base_content
+                    successful_patches += 1
+
             # 写入修改后的内容
             with open(file_path, "w", encoding="utf-8") as f:
                 f.write(modified_content)
 
             if failed_patches:
-                error_details = [
-                    f"  - 失败的补丁: \n{p['patch']['SEARCH']}\n    错误: {p['error']}"
-                    for p in failed_patches
-                ]
+                error_details = []
+                for p in failed_patches:
+                    patch = p["patch"]
+                    if "SEARCH" in patch:
+                        patch_desc = patch["SEARCH"]
+                    else:
+                        patch_desc = (
+                            "SEARCH_START:\n"
+                            + (patch.get("SEARCH_START", ""))
+                            + "\nSEARCH_END:\n"
+                            + (patch.get("SEARCH_END", ""))
+                        )
+                    error_details.append(f"  - 失败的补丁: \n{patch_desc}\n    错误: {p['error']}")
                 if successful_patches == 0:
                     summary = (
                         f"文件 {file_path} 修改失败（全部失败）。\n"

jarvis/jarvis_agent/run_loop.py

@@ -78,9 +78,7 @@ class AgentRunLoop:
                 if need_return:
                     return ag.session.prompt
 
-                # 执行回调
-                if ag.after_tool_call_cb:
-                    ag.after_tool_call_cb(ag)
+
                 # 广播工具调用后的事件（不影响主流程）
                 try:
                     ag.event_bus.emit(

jarvis/jarvis_code_agent/code_agent.py

@@ -12,6 +12,7 @@ from typing import List, Optional, Tuple
 import typer
 
 from jarvis.jarvis_agent import Agent
+from jarvis.jarvis_agent.events import AFTER_TOOL_CALL
 from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
 from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
 from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
@@ -94,7 +95,7 @@ class CodeAgent:
             use_analysis=False,  # 禁用分析
         )
 
-        self.agent.set_after_tool_call_cb(self.after_tool_call_cb)
+        self.agent.event_bus.subscribe(AFTER_TOOL_CALL, self._on_after_tool_call)
 
     def _get_system_prompt(self) -> str:
         """获取代码工程师的系统提示词"""
@@ -528,8 +529,9 @@ class CodeAgent:
             if self.agent.force_save_memory:
                 self.agent.memory_manager.prompt_memory_save()
         elif start_commit:
-            os.system(f"git reset --hard {str(start_commit)}")  # 确保转换为字符串
-            PrettyOutput.print("已重置到初始提交", OutputType.INFO)
+            if user_confirm("是否要重置到初始提交？", True):
+                os.system(f"git reset --hard {str(start_commit)}")  # 确保转换为字符串
+                PrettyOutput.print("已重置到初始提交", OutputType.INFO)
 
     def run(self, user_input: str, prefix: str = "", suffix: str = "") -> Optional[str]:
         """使用给定的用户输入运行代码代理。
@@ -598,14 +600,96 @@ class CodeAgent:
         except RuntimeError as e:
             return f"Error during execution: {str(e)}"
 
-    def after_tool_call_cb(self, agent: Agent) -> None:
+    def _on_after_tool_call(self, agent: Agent, current_response=None, need_return=None, tool_prompt=None, **kwargs) -> None:
         """工具调用后回调函数。"""
         final_ret = ""
         diff = get_diff()
+
+        # 构造按文件的状态映射与差异文本，删除文件不展示diff，仅提示删除
+        def _build_name_status_map() -> dict:
+            status_map = {}
+            try:
+                head_exists = bool(get_latest_commit_hash())
+                # 临时 -N 以包含未跟踪文件的差异检测
+                subprocess.run(["git", "add", "-N", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                cmd = ["git", "diff", "--name-status"] + (["HEAD"] if head_exists else [])
+                res = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    check=False,
+                )
+            finally:
+                subprocess.run(["git", "reset"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+            if res.returncode == 0 and res.stdout:
+                for line in res.stdout.splitlines():
+                    if not line.strip():
+                        continue
+                    parts = line.split("\t")
+                    if not parts:
+                        continue
+                    status = parts[0]
+                    if status.startswith("R") or status.startswith("C"):
+                        # 重命名/复制：使用新路径作为键
+                        if len(parts) >= 3:
+                            old_path, new_path = parts[1], parts[2]
+                            status_map[new_path] = status
+                            # 也记录旧路径，便于匹配 name-only 的结果
+                            status_map[old_path] = status
+                        elif len(parts) >= 2:
+                            status_map[parts[-1]] = status
+                    else:
+                        if len(parts) >= 2:
+                            status_map[parts[1]] = status
+            return status_map
+
+        def _get_file_diff(file_path: str) -> str:
+            """获取单文件的diff，包含新增文件内容；失败时返回空字符串"""
+            head_exists = bool(get_latest_commit_hash())
+            try:
+                # 为了让未跟踪文件也能展示diff，临时 -N 该文件
+                subprocess.run(["git", "add", "-N", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                cmd = ["git", "diff"] + (["HEAD"] if head_exists else []) + ["--", file_path]
+                res = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    check=False,
+                )
+                if res.returncode == 0:
+                    return res.stdout or ""
+                return ""
+            finally:
+                subprocess.run(["git", "reset", "--", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+        def _build_per_file_patch_preview(modified_files: List[str]) -> str:
+            status_map = _build_name_status_map()
+            lines: List[str] = []
+            for f in modified_files:
+                status = status_map.get(f, "")
+                # 删除文件：不展示diff，仅提示
+                if (status.startswith("D")) or (not os.path.exists(f)):
+                    lines.append(f"- {f} 文件被删除")
+                    continue
+                # 其它情况：展示该文件的diff
+                file_diff = _get_file_diff(f)
+                if file_diff.strip():
+                    lines.append(f"文件: {f}\n```diff\n{file_diff}\n```")
+                else:
+                    # 当无法获取到diff（例如重命名或特殊状态），避免空输出
+                    lines.append(f"- {f} 变更已记录（无可展示的文本差异）")
+            return "\n".join(lines)
+
         if diff:
             start_hash = get_latest_commit_hash()
             PrettyOutput.print(diff, OutputType.CODE, lang="diff")
             modified_files = get_diff_file_list()
+            per_file_preview = _build_per_file_patch_preview(modified_files)
             commited = handle_commit_workflow()
             if commited:
                 # 统计代码行数变化
@@ -629,15 +713,14 @@ class CodeAgent:
 
                 StatsManager.increment("code_modifications", group="code_agent")
 
-
                 # 获取提交信息
                 end_hash = get_latest_commit_hash()
                 commits = get_commits_between(start_hash, end_hash)
 
-                # 添加提交信息到final_ret
+                # 添加提交信息到final_ret（按文件展示diff；删除文件仅提示）
                 if commits:
                     final_ret += (
-                        f"\n\n代码已修改完成\n补丁内容:\n```diff\n{diff}\n```\n"
+                        f"\n\n代码已修改完成\n补丁内容（按文件）:\n{per_file_preview}\n"
                     )
                     # 修改后的提示逻辑
                     lint_tools_info = "\n".join(
@@ -664,7 +747,7 @@ class CodeAgent:
                     final_ret += "\n\n修改没有生效\n"
             else:
                 final_ret += "\n修改被拒绝\n"
-                final_ret += f"# 补丁预览:\n```diff\n{diff}\n```"
+                final_ret += f"# 补丁预览（按文件）:\n{per_file_preview}"
         else:
             return
         # 用户确认最终结果