jarvis-ai-assistant 0.1.162__py3-none-any.whl → 0.1.163__py3-none-any.whl

jarvis/jarvis_tools/edit_file.py

@@ -1,37 +1,39 @@
-from pydoc import describe
-import re
-from typing import Dict, Any, Tuple
-import os
-
-from networkx import descendants
-
-from yaspin import yaspin # type: ignore
-
-from jarvis.jarvis_agent.output_handler import OutputHandler
-from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_git_utils.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.file_operation import FileOperationTool
-from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
-from jarvis.jarvis_utils.git_utils import get_commits_between, get_latest_commit_hash
-from jarvis.jarvis_utils.globals import add_read_file_record, has_read_file
-from jarvis.jarvis_utils.input import get_multiline_input
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import is_context_overflow, get_file_line_count, user_confirm
-from jarvis.jarvis_utils.tag import ot, ct
-
+"""
+文件搜索替换工具类
+
+功能概述:
+1. 提供精确的文件内容搜索和替换功能
+2. 支持单个文件的编辑操作，包括创建新文件
+3. 实现原子操作：所有修改要么全部成功，要么全部回滚
+4. 严格匹配控制：每个搜索文本必须且只能匹配一次
+
+核心特性:
+- 支持不存在的文件和空文件处理
+- 自动创建所需目录结构
+- 完善的错误处理和回滚机制
+- 严格的格式保持要求
+"""
+from typing import Any, Dict
 
-class PatchOutputHandler:
 
+class FileSearchReplaceTool:
     name = "edit_file"
-    description = """代码编辑工具，用于编辑文件
+    description = """代码编辑工具，用于编辑单个文件
+
 # 代码编辑规范
 
 ## 重要提示
-我可以看到完整的代码，所以不需要生成完整的代码，只需要提供修改的代码片段即可。请尽量精简补丁内容，只包含必要的上下文和修改部分。特别注意：不要提供完整文件内容，只提供需要修改的部分！
+此工具可以查看和修改单个文件的代码，只需提供要修改的代码片段即可。应尽量精简内容，只包含必要的上下文和修改部分。特别注意：不要提供完整文件内容，只提供需要修改的部分！
+
+## 基本使用
+1. 指定需要修改的文件路径
+2. 提供一组或多组"搜索文本"和"替换文本"对
+3. 每个搜索文本需在目标文件中有且仅有一次精确匹配
+4. 创建新文件时，使用空字符串("")作为搜索文本，替换文本作为完整文件内容
+5. 所有修改要么全部成功，要么全部失败并回滚
 
 ## 核心原则
-1. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
+1. **精准修改**：只提供需要修改的代码部分，不需要展示整个文件内容
 2. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
 3. **格式严格保持**：
    - 严格保持原始代码的缩进方式（空格或制表符）
@@ -41,529 +43,237 @@ class PatchOutputHandler:
 4. **新旧区分**：
    - 对于新文件：提供完整的代码内容
    - 对于现有文件：只提供修改部分，不要提供整个文件
-5. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
 
 ## 格式兼容性要求
 1. **缩进一致性**：
-   - 如果原代码使用4个空格缩进，补丁也必须使用4个空格缩进
-   - 如果原代码使用制表符缩进，补丁也必须使用制表符缩进
+   - 如果原代码使用4个空格缩进，替换文本也必须使用4个空格缩进
+   - 如果原代码使用制表符缩进，替换文本也必须使用制表符
 2. **空行保留**：
-   - 如果原代码在函数之间有两个空行，补丁也必须保留这两个空行
-   - 如果原代码在类方法之间有一个空行，补丁也必须保留这一个空行
+   - 如果原代码在函数之间有两个空行，替换文本也必须保留这两个空行
+   - 如果原代码在类方法之间有一个空行，替换文本也必须保留这一个空行
 3. **行尾处理**：
-   - 如果原代码行尾没有空格，补丁也不应添加行尾空格
-   - 如果原代码使用特定的行尾注释风格，补丁也应保持该风格
+   - 不要改变原代码的行尾空格或换行符风格
+   - 保持原有的换行符类型(CR、LF或CRLF)
 
 ## 最佳实践
-- 每个补丁专注于单一职责的修改
-- 避免包含过多无关代码
-- 确保修改理由清晰明确，便于理解变更目的
-- 保持代码风格一致性，遵循项目现有的编码规范
-- 在修改前仔细分析原代码的格式风格，确保补丁与之完全兼容
-- 绝不提供完整文件内容，除非是新建文件
-- 每个文件的修改是独立的，不能出现“参照xxx文件的修改”这样的描述
-- 不要出现未实现的代码，如：TODO
-- 如果要修改的内容较多，请分多次修改
-    """
+1. 每个修改应专注于单一职责，避免包含过多无关代码
+2. 设计唯一的搜索文本，避免多处匹配的风险
+3. 创建新文件时提供完整、格式良好的内容
+4. 不要出现未实现的代码，如：TODO
+"""
     parameters = {
         "type": "object",
         "properties": {
-            "file": {"type": "string", "description": "文件路径"},
-            "reason": {"type": "string", "description": "修改原因"},
-            "content": {"type": "string", "description": "补丁内容"}
-        }
+            "file": {
+                "type": "string",
+                "description": "需要修改的文件路径"
+            },
+            "changes": {
+                "type": "array",
+                "description": "一组或多组搜索替换对",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "search": {
+                            "type": "string",
+                            "description": "需要被替换的文本，必须在文件中唯一匹配，新文件用空字符串"
+                        },
+                        "replace": {
+                            "type": "string", 
+                            "description": "替换的目标文本，需保持与原代码相同的缩进和格式风格"
+                        }
+                    },
+                    "required": ["search", "replace"]
+                }
+            }
+        },
+        "required": ["file", "changes"]
     }
 
-
+    def __init__(self):
+        """初始化文件搜索替换工具"""
+        pass
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """Apply patches to files"""
-
-        from jarvis.jarvis_agent import Agent
-        filepath = args["file"]
-        patch_content = args["content"]
-        agent: Agent = args["agent"]
-
-        with yaspin(text="正在应用补丁...", color="cyan") as spinner:
-
-            # 获取当前提交hash作为起始点
-            spinner.text = "开始获取当前提交hash..."
-            start_hash = get_latest_commit_hash()
-            spinner.write("✅ 当前提交hash获取完成")
-
-            not_read_file = not has_read_file(filepath) and os.path.exists(filepath) and os.path.getsize(filepath) > 0
-            if not_read_file:
-                spinner.text=f"以下文件未读取: {filepath}，应用补丁存在风险，将先读取文件后再生成补丁"
-                spinner.fail("❌")
-                return {
-                    "success": False,
-                    "stdout": f"以下文件未读取: {filepath}，应用补丁存在风险，请先读取文件后再生成补丁",
-                    "stderr": ""
-                }
-
-            # 检查是否有文件在Git仓库外
-            in_git_repo = _is_file_in_git_repo(filepath)
-
-            try:
-                spinner.text = f"正在处理文件: {filepath}"
-                if not os.path.exists(filepath):
-                    # 新建文件
-                    spinner.text = "文件不存在，正在创建文件..."
-                    os.makedirs(os.path.dirname(filepath), exist_ok=True)
-                    open(filepath, 'w', encoding='utf-8').close()
-                    spinner.write("✅ 文件创建完成")
-                    add_read_file_record(filepath)
-                with spinner.hidden():
-                    while not handle_code_operation(filepath, patch_content):
-                        if user_confirm("补丁应用失败，是否重试？", default=True):
-                            pass
-                        else:
-                            raise Exception("补丁应用失败")
-                spinner.write(f"✅ 文件 {filepath} 处理完成")
-            except Exception as e:
-                spinner.text = f"文件 {filepath} 处理失败: {str(e)}, 回滚文件"
-                revert_file(filepath)  # 回滚单个文件
-                spinner.write(f"✅ 文件 {filepath} 回滚完成")
-
-            final_ret = ""
-            if in_git_repo:
-                diff = get_diff()
-                if diff:
-                    PrettyOutput.print(diff, OutputType.CODE, lang="diff")
-                    with spinner.hidden():
-                        commited = handle_commit_workflow()
-                    if commited:
-                        # 获取提交信息
-                        end_hash = get_latest_commit_hash()
-                        commits = get_commits_between(start_hash, end_hash)
-
-                        # 添加提交信息到final_ret
-                        if commits:
-                            final_ret += "✅ 补丁已应用\n"
-                            final_ret += "# 提交信息:\n"
-                            for commit_hash, commit_message in commits:
-                                final_ret += f"- {commit_hash[:7]}: {commit_message}\n"
-
-                            final_ret += f"# 应用补丁:\n```diff\n{diff}\n```"
-
-                            # 修改后的提示逻辑
-                            addon_prompt = f"如果用户的需求未完成，请继续生成补丁，如果已经完成，请终止，不要输出新的PATCH，不要实现任何超出用户需求外的内容\n"
-                            addon_prompt += "如果有任何信息不明确，调用工具获取信息\n"
-                            addon_prompt += "每次响应必须且只能包含一个操作\n"
-
-                            agent.set_addon_prompt(addon_prompt)
-
-                        else:
-                            final_ret += "✅ 补丁已应用（没有新的提交）"
-                    else:
-                        final_ret += "❌ 补丁应用被拒绝\n"
-                        final_ret += f"# 补丁预览:\n```diff\n{diff}\n```"
-                else:
-                    commited = False
-                    final_ret += "❌ 没有要提交的更改\n"
-            else:
-                # 对于Git仓库外的文件，直接返回成功
-                final_ret += "✅ 补丁已应用（文件不在Git仓库中）"
-                commited = True
-            # 用户确认最终结果
-            with spinner.hidden():
-                if commited:
-                    return {
-                        "success": True,
-                        "stdout": final_ret,
-                        "stderr": ""
-                    }
-                PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
-                if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
-                    return {
-                        "success": True,
-                        "stdout": final_ret,
-                        "stderr": ""
-                    }
-                custom_reply = get_multiline_input("请输入自定义回复")
-                if not custom_reply.strip():  # 如果自定义回复为空，返回空字符串
-                    return {
-                        "success": True,
-                        "stdout": final_ret,
-                        "stderr": ""
-                    }
-                agent.set_addon_prompt(custom_reply)
-                return {
-                    "success": True,
-                    "stdout": final_ret,
-                    "stderr": ""
+        """
+        执行文件搜索替换操作，每个搜索文本只允许有且只有一次匹配，否则失败
+        特殊支持不存在的文件和空文件处理
+
+        参数:
+            file (str): 文件路径
+            changes (list): 一组或多组搜索替换对，格式如下：
+            [
+                {
+                    "search": "搜索文本1",
+                    "replace": "替换文本1"
+                },
+                {
+                    "search": "搜索文本2",
+                    "replace": "替换文本2"
                 }
-
-def _is_file_in_git_repo(filepath: str) -> bool:
-    """检查文件是否在当前Git仓库中"""
-    import subprocess
-    try:
-        # 获取Git仓库根目录
-        repo_root = subprocess.run(
-            ['git', 'rev-parse', '--show-toplevel'],
-            capture_output=True,
-            text=True
-        ).stdout.strip()
-        
-        # 检查文件路径是否在仓库根目录下
-        return os.path.abspath(filepath).startswith(os.path.abspath(repo_root))
-    except:
-        return False
-
-def revert_file(filepath: str):
-    """增强版git恢复，处理新文件"""
-    import subprocess
-    try:
-        # 检查文件是否在版本控制中
-        result = subprocess.run(
-            ['git', 'ls-files', '--error-unmatch', filepath],
-            stderr=subprocess.PIPE,
-            text=False  # 禁用自动文本解码
-        )
-        if result.returncode == 0:
-            subprocess.run(['git', 'checkout', 'HEAD',
-                           '--', filepath], check=True)
-        else:
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        subprocess.run(['git', 'clean', '-f', '--', filepath], check=True)
-    except subprocess.CalledProcessError as e:
-        error_msg = e.stderr.decode('utf-8', errors='replace') if e.stderr else str(e)
-        PrettyOutput.print(f"恢复文件失败: {error_msg}", OutputType.ERROR)
-# 修改后的恢复函数
-
-
-def revert_change():
-    """恢复所有未提交的修改到HEAD状态"""
-    import subprocess
-    try:
-        # 检查是否为空仓库
-        head_check = subprocess.run(
-            ['git', 'rev-parse', '--verify', 'HEAD'],
-            stderr=subprocess.PIPE,
-            stdout=subprocess.PIPE
-        )
-        if head_check.returncode == 0:
-            subprocess.run(['git', 'reset', '--hard', 'HEAD'], check=True)
-        subprocess.run(['git', 'clean', '-fd'], check=True)
-    except subprocess.CalledProcessError as e:
-        return f"恢复更改失败: {str(e)}"
-# 修改后的获取差异函数
-
-
-def get_diff() -> str:
-    """使用git获取暂存区差异"""
-    import subprocess
-    
-    # 初始化状态
-    need_reset = False
-    
-    try:
-        # 暂存所有修改
-        subprocess.run(['git', 'add', '.'], check=True)
-        need_reset = True
-        
-        # 获取差异
-        result = subprocess.run(
-            ['git', 'diff', '--cached'],
-            capture_output=True,
-            text=False,
-            check=True
-        )
-        
-        # 解码输出
-        try:
-            ret = result.stdout.decode('utf-8')
-        except UnicodeDecodeError:
-            ret = result.stdout.decode('utf-8', errors='replace')
+            ]
+
+        返回:
+            dict: 包含执行结果的字典
+            {
+                "success": bool,  # 是否成功完成所有替换
+                "stdout": str,    # 标准输出信息
+                "stderr": str     # 错误信息
+            }
+        """
+        import os
+        from jarvis.jarvis_utils.output import PrettyOutput, OutputType
         
-        # 重置暂存区
-        subprocess.run(['git', "reset", "--mixed"], check=False)
-        return ret
+        stdout_messages = []
+        stderr_messages = []
+        success = True
         
-    except subprocess.CalledProcessError as e:
-        if need_reset:
-            subprocess.run(['git', "reset", "--mixed"], check=False)
-        return f"获取差异失败: {str(e)}"
-    except Exception as e:
-        if need_reset:
-            subprocess.run(['git', "reset", "--mixed"], check=False)
-        return f"发生意外错误: {str(e)}"
-
-
-def handle_commit_workflow() -> bool:
-    """Handle the git commit workflow and return the commit details.
-
-    Returns:
-        bool: 提交是否成功
-    """
-    if is_confirm_before_apply_patch() and not user_confirm("是否要提交代码？", default=True):
-        revert_change()
-        return False
-    
-    import subprocess
-    try:
-        # 获取当前分支的提交总数
-        commit_count = subprocess.run(
-            ['git', 'rev-list', '--count', 'HEAD'],
-            capture_output=True,
-            text=True
-        )
-        if commit_count.returncode != 0:
-            return False
-            
-        commit_count = int(commit_count.stdout.strip())
+        file_path = args["file"]
+        changes = args["changes"]
         
-        # 暂存所有修改
-        subprocess.run(['git', 'add', '.'], check=True)
-        
-        # 提交变更
-        subprocess.run(
-            ['git', 'commit', '-m', f'CheckPoint #{commit_count + 1}'], 
-            check=True
-        )
-        return True
-    except subprocess.CalledProcessError as e:
-        return False
-
-
-def handle_code_operation(filepath: str, patch_content: str) -> bool:
-    """处理代码操作"""
-    if get_file_line_count(filepath) < 5:
-        return handle_small_code_operation(filepath, patch_content)
-    else:
-        retry_count = 5
-        while retry_count > 0:
-            retry_count -= 1
-            if handle_large_code_operation(filepath, patch_content, PlatformRegistry().get_normal_platform() if retry_count > 2 else PlatformRegistry().get_thinking_platform()):
-                return True
-        return handle_small_code_operation(filepath, patch_content)
+        # 创建已处理文件变量，用于失败时回滚
+        original_content = None
+        processed = False
 
-
-def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
-    """处理基于上下文的代码片段"""
-    with yaspin(text=f"正在修改文件 {filepath}...", color="cyan") as spinner:
         try:
-            model = PlatformRegistry().get_normal_platform()
-            file_content = FileOperationTool().execute({"operation":"read", "files":[{"path":filepath}]})["stdout"]
-
-            model.set_suppress_output(False)
-
-            prompt = f"""
-# 代码合并专家指南
-
-## 任务描述
-你是一位精确的代码审查与合并专家，需要将补丁内容与原始代码智能合并。
-
-### 补丁内容
-```
-{patch_content}
-```
-
-## 合并要求
-1. **精确性**：严格按照补丁的意图修改代码
-2. **完整性**：确保所有需要的更改都被应用
-3. **一致性**：严格保留原始代码的格式、空行和缩进风格
-4. **上下文保留**：保持未修改部分的代码完全不变
-
-## 输出格式规范
-- 仅在{ot("MERGED_CODE")}标签内输出合并后的完整代码
-- 每次最多输出300行代码
-- 不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
-- 除了合并后的代码，不要输出任何其他文本
-- 所有代码输出完成后，输出{ot("!!!FINISHED!!!")}标记
-
-## 输出模板
-{ot("MERGED_CODE")}
-[合并后的完整代码，包括所有空行和缩进]
-{ct("MERGED_CODE")}
-
-# 原始代码
-{file_content}
-"""
-
-            count = 30
-            start_line = -1
-            end_line = -1
-            code = []
-            finished = False
-            while count > 0:
-                count -= 1
-                with spinner.hidden():
-                    response = model.chat_until_success(prompt).splitlines()
-                try:
-                    start_line = response.index(ot("MERGED_CODE")) + 1
-                    try:
-                        end_line = response.index(ct("MERGED_CODE"))
-                        code = response[start_line:end_line]
-                    except:
-                        pass
-                except:
-                    pass
-
-                try:
-                    response.index(ot("!!!FINISHED!!!"))
-                    finished = True
-                    break
-                except:
-                    prompt += f"""
-# 继续输出
-
-## 说明
-请继续输出接下来的300行代码
-
-## 要求
-- 严格保留原始代码的格式、空行和缩进
-- 仅在{ot("MERGED_CODE")}块中包含实际代码内容
-- 不要使用markdown代码块（```）或反引号
-- 除了合并后的代码，不要输出任何其他文本
-- 所有代码输出完成后，输出{ot("!!!FINISHED!!!")}标记
-"""
-                    pass
-            if not finished:
-                spinner.text = "生成代码失败"
-                spinner.fail("❌")
-                return False
-            # 写入合并后的代码
-            spinner.text = "写入合并后的代码..."
-            with open(filepath, 'w', encoding='utf-8', errors="ignore") as f:
-                f.write("\n".join(code)+"\n")
-            spinner.write("✅ 合并后的代码写入完成")
-            spinner.text = "代码修改完成"
-            spinner.ok("✅")
-            return True
-        except Exception as e:
-            spinner.text = "代码修改失败"
-            spinner.fail("❌")
-            return False
-
-
-
-def handle_large_code_operation(filepath: str, patch_content: str, model: BasePlatform) -> bool:
-    """处理大型代码文件的补丁操作，使用差异化补丁格式"""
-    with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
-        try:
-            file_content = FileOperationTool().execute({"operation":"read", "files":[{"path":filepath}]})["stdout"]
-            need_upload_file = is_context_overflow(file_content)
-            upload_success = False
-            # 读取原始文件内容
-            with spinner.hidden():  
-                if need_upload_file and model.upload_files([filepath]):
-                    upload_success = True
-
-
-            model.set_suppress_output(False)
-
-            main_prompt = f"""
-# 代码补丁生成专家指南
-
-## 任务描述
-你是一位精确的代码补丁生成专家，需要根据补丁描述生成精确的代码差异。
-
-### 补丁内容
-```
-{patch_content}
-```
-
-## 补丁生成要求
-1. **精确性**：严格按照补丁的意图修改代码
-2. **格式一致性**：严格保持原始代码的格式风格
-   - 缩进方式（空格或制表符）必须与原代码保持一致
-   - 空行数量和位置必须与原代码风格匹配
-   - 行尾空格处理必须与原代码一致
-3. **最小化修改**：只修改必要的代码部分，保持其他部分不变
-4. **上下文完整性**：提供足够的上下文，确保补丁能准确应用
-
-## 输出格式规范
-- 使用{ot("DIFF")}块包围每个需要修改的代码段
-- 每个{ot("DIFF")}块必须包含SEARCH部分和REPLACE部分
-- SEARCH部分是需要查找的原始代码
-- REPLACE部分是替换后的新代码
-- 确保SEARCH部分能在原文件中**唯一匹配**
-- 如果修改较大，可以使用多个{ot("DIFF")}块
-
-## 输出模板
-{ot("DIFF")}
-{">" * 5} SEARCH
-[需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]
-{'='*5}
-[替换后的新代码]
-{"<" * 5} REPLACE
-{ct("DIFF")}
-
-{ot("DIFF")}
-{">" * 5} SEARCH
-[另一处需要查找的原始代码，包含足够上下文，避免出现可匹配多处的情况]
-{'='*5}
-[另一处替换后的新代码]
-{"<" * 5} REPLACE
-{ct("DIFF")}
-"""
+            file_exists = os.path.exists(file_path)
+            content = ""
             
-            for _ in range(3):
-                file_prompt = ""
-                if not need_upload_file:
-                    file_prompt = f"""
-    # 原始代码
-    {file_content}
-    """
-                    with spinner.hidden():
-                        response = model.chat_until_success(main_prompt + file_prompt)
-                else:
-                    if upload_success:
-                        with spinner.hidden():
-                            response = model.chat_until_success(main_prompt)
+            try:
+                # 如果文件存在，则读取内容
+                if file_exists:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                        original_content = content
+                
+                # 创建一个临时内容副本进行操作
+                temp_content = content
+                replaced_count = 0
+                
+                # 处理所有搜索替换对
+                for change in changes:
+                    search_text = change["search"]
+                    replace_text = change["replace"]
+                    
+                    # 特殊处理不存在的文件或空文件
+                    if not file_exists or content == "":
+                        if search_text == "":
+                            # 对于不存在的文件或空文件，如果搜索文本为空，则直接使用替换文本作为内容
+                            temp_content = replace_text
+                            replaced_count += 1
+                            # 只允许有一个空字符串搜索
+                            break
+                        else:
+                            stderr_message = f"文件 {file_path} {'不存在' if not file_exists else '为空'}，但搜索文本非空: '{search_text}'"
+                            stderr_messages.append(stderr_message)
+                            PrettyOutput.print(stderr_message, OutputType.ERROR)
+                            success = False
+                            break
                     else:
-                        with spinner.hidden():
-                            response = model.chat_big_content(file_content, main_prompt)
-
-                # 解析差异化补丁
-                diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"),
-                                        response, re.DOTALL)
-
-                # 读取原始文件内容
-                with open(filepath, 'r', encoding='utf-8', errors="ignore") as f:
-                    file_content = f.read()
-
-                # 应用所有差异化补丁
-                modified_content = file_content
-                patch_count = 0
-                success = True
-                for match in diff_blocks:
-                    search_text = match.group(1).strip()
-                    replace_text = match.group(2).strip()
-                    patch_count += 1
-                    # 检查搜索文本是否存在于文件中
-                    if search_text in modified_content:
-                        # 如果有多处，报错
-                        if modified_content.count(search_text) > 1:
-                            spinner.write(f"❌ 补丁 #{patch_count} 应用失败：找到多个匹配的代码段")
+                        # 正常文件处理 - 检查匹配次数
+                        match_count = temp_content.count(search_text)
+                        
+                        if match_count == 0:
+                            stderr_message = f"文件 {file_path} 中未找到匹配文本: '{search_text}'"
+                            stderr_messages.append(stderr_message)
+                            PrettyOutput.print(stderr_message, OutputType.ERROR)
                             success = False
                             break
-                        # 应用替换
-                        modified_content = modified_content.replace(
-                            search_text, replace_text)
-                        spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
+                        elif match_count > 1:
+                            stderr_message = f"文件 {file_path} 中匹配到多个 ({match_count}) '{search_text}'，搜索文本只允许一次匹配"
+                            stderr_messages.append(stderr_message)
+                            PrettyOutput.print(stderr_message, OutputType.ERROR)
+                            success = False
+                            break
+                        else:
+                            # 只有一个匹配，执行替换
+                            temp_content = temp_content.replace(search_text, replace_text, 1)
+                            replaced_count += 1
+
+                # 只有当所有替换操作都成功时，才写回文件
+                if success and (temp_content != original_content or not file_exists):
+                    # 确保目录存在
+                    os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True)
+                    
+                    with open(file_path, 'w', encoding='utf-8') as f:
+                        f.write(temp_content)
+                    
+                    processed = True
+                    
+                    action = "创建并写入" if not file_exists else "成功替换"
+                    stdout_message = f"文件 {file_path} {action} {replaced_count} 处"
+                    stdout_messages.append(stdout_message)
+                    PrettyOutput.print(stdout_message, OutputType.SUCCESS)
+                elif success:
+                    stdout_message = f"文件 {file_path} 没有找到需要替换的内容"
+                    stdout_messages.append(stdout_message)
+                    PrettyOutput.print(stdout_message, OutputType.INFO)
+                
+            except Exception as e:
+                stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
+                stderr_messages.append(stderr_message)
+                PrettyOutput.print(stderr_message, OutputType.ERROR)
+                success = False
+
+            # 如果操作失败，回滚已修改的文件
+            if not success and processed:
+                rollback_message = "操作失败，正在回滚修改..."
+                stderr_messages.append(rollback_message)
+                PrettyOutput.print(rollback_message, OutputType.WARNING)
+                
+                try:
+                    if original_content is None:
+                        # 如果是新创建的文件，则删除
+                        if os.path.exists(file_path):
+                            os.remove(file_path)
+                        rollback_file_message = f"已删除新创建的文件: {file_path}"
                     else:
-                        spinner.write(f"❌ 补丁 #{patch_count} 应用失败：无法找到匹配的代码段")
-                        success = False
-                        break
-                if not success:
-                    revert_file(filepath)
-                    continue
-
-                # 写入修改后的内容
-                with open(filepath, 'w', encoding='utf-8', errors="ignore") as f:
-                    f.write(modified_content)
-
-                spinner.text = f"文件 {filepath} 修改完成，应用了 {patch_count} 个补丁"
-                spinner.ok("✅")
-                return True
-            spinner.text = f"文件 {filepath} 修改失败"
-            spinner.fail("❌")
-            return False
-
+                        # 如果是修改的文件，则恢复原内容
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            f.write(original_content)
+                        rollback_file_message = f"已回滚文件: {file_path}"
+                        
+                    stderr_messages.append(rollback_file_message)
+                    PrettyOutput.print(rollback_file_message, OutputType.INFO)
+                except Exception as e:
+                    rollback_error = f"回滚文件 {file_path} 失败: {str(e)}"
+                    stderr_messages.append(rollback_error)
+                    PrettyOutput.print(rollback_error, OutputType.ERROR)
+
+            return {
+                "success": success,
+                "stdout": "\n".join(stdout_messages),
+                "stderr": "\n".join(stderr_messages)
+            }
+            
         except Exception as e:
-            spinner.text = f"文件修改失败: {str(e)}"
-            spinner.fail("❌")
-            return False
+            error_msg = f"文件搜索替换操作失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            
+            # 如果有已修改的文件，尝试回滚
+            if processed:
+                rollback_message = "操作失败，正在回滚修改..."
+                stderr_messages.append(rollback_message)
+                PrettyOutput.print(rollback_message, OutputType.WARNING)
+                
+                try:
+                    if original_content is None:
+                        # 如果是新创建的文件，则删除
+                        if os.path.exists(file_path):
+                            os.remove(file_path)
+                        stderr_messages.append(f"已删除新创建的文件: {file_path}")
+                    else:
+                        # 如果是修改的文件，则恢复原内容
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            f.write(original_content)
+                        stderr_messages.append(f"已回滚文件: {file_path}")
+                except:
+                    stderr_messages.append(f"回滚文件失败: {file_path}")
+            
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": error_msg + "\n" + "\n".join(stderr_messages)
+            }
+
+