jarvis-ai-assistant 0.1.88__py3-none-any.whl → 0.1.89__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.88" 
+__version__ = "0.1.89" 

jarvis/jarvis_coder/git_utils.py

@@ -0,0 +1,67 @@
+import os
+from typing import List
+import yaml
+import time
+from jarvis.utils import OutputType, PrettyOutput
+from jarvis.models.registry import PlatformRegistry
+from .model_utils import call_model_with_retry
+
+def has_uncommitted_files() -> bool:
+    """判断代码库是否有未提交的文件"""
+    # 获取未暂存的修改
+    unstaged = os.popen("git diff --name-only").read()
+    # 获取已暂存但未提交的修改
+    staged = os.popen("git diff --cached --name-only").read()
+    # 获取未跟踪的文件
+    untracked = os.popen("git ls-files --others --exclude-standard").read()
+    
+    return bool(unstaged or staged or untracked)
+
+def generate_commit_message(git_diff: str, feature: str) -> str:
+    """根据git diff和功能描述生成commit信息"""
+    prompt = f"""你是一个经验丰富的程序员，请根据以下代码变更和功能描述生成简洁明了的commit信息：
+
+功能描述：
+{feature}
+
+代码变更：
+Git Diff:
+{git_diff}
+
+请遵循以下规则：
+1. 使用英文编写
+2. 采用常规的commit message格式：<type>(<scope>): <subject>
+3. 保持简洁，不超过50个字符
+4. 准确描述代码变更的主要内容
+5. 优先考虑功能描述和git diff中的变更内容
+"""
+    
+    model = PlatformRegistry().get_global_platform_registry().get_codegen_platform()
+    model.set_suppress_output(True)
+    success, response = call_model_with_retry(model, prompt)
+    if not success:
+        return "Update code changes"
+        
+    return response.strip().split("\n")[0]
+
+def save_edit_record(record_dir: str, commit_message: str, git_diff: str) -> None:
+    """保存代码修改记录"""
+    # 获取下一个序号
+    existing_records = [f for f in os.listdir(record_dir) if f.endswith('.yaml')]
+    next_num = 1
+    if existing_records:
+        last_num = max(int(f[:4]) for f in existing_records)
+        next_num = last_num + 1
+    
+    # 创建记录文件
+    record = {
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "commit_message": commit_message,
+        "git_diff": git_diff
+    }
+    
+    record_path = os.path.join(record_dir, f"{next_num:04d}.yaml")
+    with open(record_path, "w", encoding="utf-8") as f:
+        yaml.safe_dump(record, f, allow_unicode=True)
+    
+    PrettyOutput.print(f"已保存修改记录: {record_path}", OutputType.SUCCESS) 

jarvis/jarvis_coder/main.py

@@ -14,6 +14,8 @@ from prompt_toolkit.completion import WordCompleter, Completer, Completion
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.styles import Style
 import fnmatch
+from .patch_handler import PatchHandler
+from .git_utils import has_uncommitted_files, generate_commit_message, save_edit_record
 
 # 全局锁对象
 index_lock = threading.Lock()
@@ -21,13 +23,18 @@ index_lock = threading.Lock()
 class JarvisCoder:
     def __init__(self, root_dir: str, language: str):
         """初始化代码修改工具"""
-
+        self.root_dir = root_dir
+        self.language = language
+        self._init_directories()
+        self._init_codebase()
+        
+    def _init_directories(self):
+        """初始化目录"""
         self.max_context_length = get_max_context_length()
 
-
-        self.root_dir = find_git_root(root_dir)
+        self.root_dir = find_git_root(self.root_dir)
         if not self.root_dir:
-            self.root_dir = root_dir
+            self.root_dir = self.root_dir
 
         PrettyOutput.print(f"Git根目录: {self.root_dir}", OutputType.INFO)
 
@@ -57,13 +64,22 @@ class JarvisCoder:
             # 2.2 提交
             os.system(f"git commit -m 'Initial commit'")
 
+            PrettyOutput.print("代码库有未提交的文件，提交一次", OutputType.INFO)
+            os.system(f"git add .")
+            os.system(f"git commit -m 'commit before code edit'")
         # 3. 查看代码库是否有未提交的文件，如果有，提交一次
         if self._has_uncommitted_files():
+            PrettyOutput.print("代码库有未提交的文件，提交一次", OutputType.INFO)
+            os.system(f"git add .")
+            git_diff = os.popen("git diff --cached").read()
+            commit_message = generate_commit_message(git_diff, "Pre-edit commit")
+            os.system(f"git commit -m '{commit_message}'")
             PrettyOutput.print("代码库有未提交的文件，提交一次", OutputType.INFO)
             os.system(f"git add .")
             os.system(f"git commit -m 'commit before code edit'")
 
-        # 4. 初始化代码库
+    def _init_codebase(self):
+        """初始化代码库"""
         self._codebase = CodeBase(self.root_dir)
 
     def _new_model(self):
@@ -82,260 +98,11 @@ class JarvisCoder:
         
         return bool(unstaged or staged or untracked)
 
-    def _call_model_with_retry(self, model: BasePlatform, prompt: str, max_retries: int = 3, initial_delay: float = 1.0) -> Tuple[bool, str]:
-        """调用模型并支持重试
-        
-        Args:
-            prompt: 提示词
-            max_retries: 最大重试次数
-            initial_delay: 初始延迟时间(秒)
-            
-        Returns:
-            Tuple[bool, str]: (是否成功, 响应内容)
-        """
-        delay = initial_delay
-        for attempt in range(max_retries):
-            try:
-                response = model.chat(prompt)
-                return True, response
-            except Exception as e:
-                if attempt == max_retries - 1:  # 最后一次尝试
-                    PrettyOutput.print(f"调用模型失败: {str(e)}", OutputType.ERROR)
-                    return False, str(e)
-                    
-                PrettyOutput.print(f"调用模型失败，{delay}秒后重试: {str(e)}", OutputType.WARNING)
-                time.sleep(delay)
-                delay *= 2  # 指数退避
-                
-    def _remake_patch(self, prompt: str) -> List[str]:
-        success, response = self._call_model_with_retry(self.main_model, prompt, max_retries=5)  # 增加重试次数
-        if not success:
-            return []
-            
-        try:
-            patches = re.findall(r'<PATCH>.*?</PATCH>', response, re.DOTALL)
-            return [patch.replace('<PATCH>', '').replace('</PATCH>', '').strip() 
-                   for patch in patches if patch.strip()]
-        except Exception as e:
-            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.WARNING)
-            return []
-        
-    def _make_patch(self, related_files: List[Dict], feature: str) -> List[str]:
-        """生成修改方案"""
-        prompt = """你是一个资深程序员，请根据需求描述，修改文件内容。
-
-修改格式说明：
-1. 每个修改块格式如下：
-<PATCH>
-> path/to/file
-def old_function():
-    print("old code")
-    return False
-=======
-def old_function():
-    print("new code")
-    return True
-</PATCH>
-
-2. 如果是新文件或者替换整个文件内容，格式如下：
-<PATCH>
-> src/new_module.py
-=======
-from typing import List
-
-def new_function():
-    return "This is a new file"
-</PATCH>
-
-3. 如果要删除文件中的某一段，格式如下：
-<PATCH>
-> path/to/file
-    # 这是要删除的注释
-    deprecated_code = True
-    if deprecated_code:
-        print("old feature")
-=======
-</PATCH>
-
-4. 如果要修改导入语句，格式如下：
-<PATCH>
-> src/main.py
-from old_module import old_class
-=======
-from new_module import new_class
-</PATCH>
-
-5. 如果要修改类定义，格式如下：
-<PATCH>
-> src/models.py
-class OldModel:
-    def __init__(self):
-        self.value = 0
-=======
-class OldModel:
-    def __init__(self):
-        self.value = 1
-        self.name = "new"
-</PATCH>
-
-文件列表如下：
-"""
-        for i, file in enumerate(related_files):
-            if len(prompt) > self.max_context_length:
-                PrettyOutput.print(f'避免上下文超限，丢弃低相关度文件：{file["file_path"]}', OutputType.WARNING)
-                continue
-            prompt += f"""{i}. {file["file_path"]}\n"""
-            prompt += f"""文件内容:\n"""
-            prompt += f"<FILE_CONTENT>\n"
-            prompt += f'{file["file_content"]}\n'
-            prompt += f"</FILE_CONTENT>\n"
-        
-        prompt += f"\n需求描述: {feature}\n"
-        prompt += """
-注意事项：
-1、仅输出补丁内容，不要输出任何其他内容，每个补丁必须用<PATCH>和</PATCH>标记
-2、如果在大段代码中有零星修改，生成多个补丁
-3、要替换的内容，一定要与文件内容完全一致，不要有任何多余或者缺失的内容
-4、每个patch不超过20行，超出20行，请生成多个patch
-"""
-
-        success, response = self._call_model_with_retry(self.main_model, prompt)
-        if not success:
-            return []
-            
-        try:
-            # 使用正则表达式匹配每个patch块
-            patches = re.findall(r'<PATCH>.*?</PATCH>', response, re.DOTALL)
-            return [patch.replace('<PATCH>', '').replace('</PATCH>', '').strip() 
-                   for patch in patches if patch.strip()]
-        except Exception as e:
-            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.WARNING)
-            return []
-
-    def _apply_patch(self, related_files: List[Dict], patches: List[str]) -> Tuple[bool, str]:
-        """应用补丁"""
-        error_info = []
-        modified_files = set()
-
-        # 创建文件内容映射
-        file_map = {file["file_path"]: file["file_content"] for file in related_files}
-        temp_map = file_map.copy()  # 创建临时映射用于尝试应用
-        
-        # 尝试应用所有补丁
-        for i, patch in enumerate(patches):
-            PrettyOutput.print(f"正在应用补丁 {i+1}/{len(patches)}", OutputType.INFO)
-            
-            try:
-                # 解析补丁
-                lines = patch.split("\n")
-                if not lines:
-                    continue
-                    
-                # 获取文件路径
-                file_path_match = re.search(r'> (.*)', lines[0])
-                if not file_path_match:
-                    error_info.append(f"无法解析文件路径: {lines[0]}")
-                    return False, "\n".join(error_info)
-                    
-                file_path = file_path_match.group(1).strip()
-                
-                # 解析补丁内容
-                patch_content = "\n".join(lines[1:])
-                parts = patch_content.split("=======")
-                
-                if len(parts) != 2:
-                    error_info.append(f"补丁格式错误: {file_path}")
-                    return False, "\n".join(error_info)
-                
-                old_content = parts[0]
-                new_content = parts[1].split("</PATCH>")[0]
-                
-                # 处理新文件
-                if not old_content:
-                    temp_map[file_path] = new_content
-                    modified_files.add(file_path)
-                    continue
-                
-                # 处理文件修改
-                if file_path not in temp_map:
-                    error_info.append(f"文件不存在: {file_path}")
-                    return False, "\n".join(error_info)
-                
-                current_content = temp_map[file_path]
-                
-                # 查找并替换代码块
-                if old_content not in current_content:
-                    error_info.append(
-                        f"补丁应用失败: {file_path}\n"
-                        f"原因: 未找到要替换的代码\n"
-                        f"期望找到的代码:\n{old_content}\n"
-                        f"实际文件内容:\n{current_content[:200]}..."  # 只显示前200个字符
-                    )
-                    return False, "\n".join(error_info)
-                
-                # 应用更改
-                temp_map[file_path] = current_content.replace(old_content, new_content)
-                modified_files.add(file_path)
-                
-            except Exception as e:
-                error_info.append(f"处理补丁时发生错误: {str(e)}")
-                return False, "\n".join(error_info)
-        
-        # 所有补丁都应用成功，更新实际文件
-        for file_path in modified_files:
-            try:
-                dir_path = os.path.dirname(file_path)
-                if dir_path and not os.path.exists(dir_path):
-                    os.makedirs(dir_path, exist_ok=True)
-                    
-                with open(file_path, "w", encoding="utf-8") as f:
-                    f.write(temp_map[file_path])
-                    
-                PrettyOutput.print(f"成功修改文件: {file_path}", OutputType.SUCCESS)
-                
-            except Exception as e:
-                error_info.append(f"写入文件失败 {file_path}: {str(e)}")
-                return False, "\n".join(error_info)
-        
-        return True, ""
-
-    def _save_edit_record(self, commit_message: str, git_diff: str) -> None:
-        """保存代码修改记录
-        
-        Args:
-            commit_message: 提交信息
-            git_diff: git diff --cached的输出
-        """
-            
-        # 获取下一个序号
-        existing_records = [f for f in os.listdir(self.record_dir) if f.endswith('.yaml')]
-        next_num = 1
-        if existing_records:
-            last_num = max(int(f[:4]) for f in existing_records)
-            next_num = last_num + 1
-        
-        # 创建记录文件
-        record = {
-            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "commit_message": commit_message,
-            "git_diff": git_diff
-        }
-        
-        record_path = os.path.join(self.record_dir, f"{next_num:04d}.yaml")
-        with open(record_path, "w", encoding="utf-8") as f:
-            yaml.safe_dump(record, f, allow_unicode=True)
-        
-        PrettyOutput.print(f"已保存修改记录: {record_path}", OutputType.SUCCESS)
-
-
-
-
     def _prepare_execution(self) -> None:
         """准备执行环境"""
         self.main_model = self._new_model()
         self._codebase.generate_codebase()
 
-
     def _load_related_files(self, feature: str) -> List[Dict]:
         """加载相关文件内容"""
         ret = []
@@ -352,135 +119,6 @@ class OldModel:
             ret.append({"file_path": file, "file_content": content})
         return ret
 
-    def _handle_patch_application(self, related_files: List[Dict], patches: List[str], feature: str) -> Dict[str, Any]:
-        """处理补丁应用流程"""
-        while True:
-            PrettyOutput.print(f"生成{len(patches)}个补丁", OutputType.INFO)
-            
-            if not patches:
-                retry_prompt = f"""未生成补丁，请重新生成补丁"""
-                patches = self._remake_patch(retry_prompt)
-                continue
-            
-            success, error_info = self._apply_patch(related_files, patches)
-            
-            if success:
-                user_confirm = input("是否确认修改？(y/n)")
-                if user_confirm.lower() == "y":
-                    self._finalize_changes(feature)
-                    return {
-                        "success": True,
-                        "stdout": f"已完成功能开发{feature}",
-                        "stderr": "",
-                        "error": None
-                    }
-                else:
-                    self._revert_changes()
-                    
-                    # 让用户输入调整意见
-                    user_feedback = get_multiline_input("""
-请提供修改建议，帮助生成更好的补丁：
-1. 修改的位置是否正确？
-2. 修改的内容是否合适？
-3. 是否有遗漏的修改？
-4. 其他调整建议？
-
-请输入调整意见(直接回车跳过):""")
-                    
-                    if not user_feedback:
-                        return {
-                            "success": False,
-                            "stdout": "",
-                            "stderr": "修改被用户取消，文件未发生任何变化",
-                            "error": UserWarning("用户取消修改")
-                        }
-                    
-                    retry_prompt = f"""补丁被用户拒绝，请根据用户意见重新生成补丁：
-
-用户意见：
-{user_feedback}
-
-请重新生成补丁，确保：
-1. 按照用户意见调整修改内容
-2. 准确定位要修改的代码位置
-3. 正确处理代码缩进
-4. 考虑代码上下文
-"""
-                    patches = self._remake_patch(retry_prompt)
-                    continue
-            else:
-                PrettyOutput.print(f"补丁应用失败: {error_info}", OutputType.WARNING)
-                
-                # 让用户输入补充信息
-                user_info = get_multiline_input("""
-补丁应用失败。请提供更多信息来帮助修复问题：
-1. 是否需要调整代码位置？
-2. 是否有特殊的格式要求？
-3. 是否需要考虑其他文件的依赖？
-4. 其他补充说明？
-
-请输入补充信息(直接回车跳过):""")
-                
-                retry_prompt = f"""补丁应用失败，请根据以下信息重新生成补丁：
-
-错误信息：
-{error_info}
-
-用户补充信息：
-{user_info if user_info else "用户未提供补充信息"}
-
-请确保：
-1. 准确定位要修改的代码位置
-2. 正确处理代码缩进
-3. 考虑代码上下文
-4. 对新文件不要包含原始内容
-"""
-                patches = self._remake_patch(retry_prompt)
-
-
-
-
-    def _generate_commit_message(self, git_diff: str, feature: str) -> str:
-        """根据git diff和功能描述生成commit信息
-        
-        Args:
-            git_diff: git diff --cached的输出
-            feature: 用户的功能描述
-            
-        Returns:
-            str: 生成的commit信息
-        """
-        
-        # 生成提示词
-        prompt = f"""你是一个经验丰富的程序员，请根据以下代码变更和功能描述生成简洁明了的commit信息：
-
-功能描述：
-{feature}
-
-代码变更：
-"""
-        # 添加git diff内容
-        prompt += f"Git Diff:\n{git_diff}\n\n"
-            
-        prompt += """
-请遵循以下规则：
-1. 使用英文编写
-2. 采用常规的commit message格式：<type>(<scope>): <subject>
-3. 保持简洁，不超过50个字符
-4. 准确描述代码变更的主要内容
-5. 优先考虑功能描述和git diff中的变更内容
-"""
-        
-        # 使用normal模型生成commit信息
-        model = PlatformRegistry().get_global_platform_registry().get_codegen_platform()
-        model.set_suppress_output(True)
-        success, response = self._call_model_with_retry(model, prompt)
-        if not success:
-            return "Update code changes"
-            
-        # 清理响应内容
-        return response.strip().split("\n")[0]
-
     def _finalize_changes(self, feature: str) -> None:
         """完成修改并提交"""
         PrettyOutput.print("修改确认成功，提交修改", OutputType.INFO)
@@ -492,7 +130,7 @@ class OldModel:
         git_diff = os.popen("git diff --cached").read()
         
         # 自动生成commit信息，传入feature
-        commit_message = self._generate_commit_message(git_diff, feature)
+        commit_message = generate_commit_message(git_diff, feature)
         
         # 显示并确认commit信息
         PrettyOutput.print(f"自动生成的commit信息: {commit_message}", OutputType.INFO)
@@ -503,7 +141,7 @@ class OldModel:
         
         # 不需要再次 git add，因为已经添加过了
         os.system(f"git commit -m '{commit_message}'")
-        self._save_edit_record(commit_message, git_diff)
+        save_edit_record(self.record_dir, commit_message, git_diff)
 
     def _revert_changes(self) -> None:
         """回退所有修改"""
@@ -519,26 +157,36 @@ class OldModel:
 
         Returns:
             Dict[str, Any]: 包含执行结果的字典
-                - success: 是否成功
-                - stdout: 标准输出信息
-                - stderr: 错误信息
-                - error: 错误对象(如果有)
         """
         try:
             self._prepare_execution()
             related_files = self._load_related_files(feature)
-            patches = self._make_patch(related_files, feature)
-            return self._handle_patch_application(related_files, patches, feature)
+            
+            patch_handler = PatchHandler(self.main_model)
+            if patch_handler.handle_patch_application(related_files, feature):
+                self._finalize_changes(feature)
+                return {
+                    "success": True,
+                    "stdout": "代码修改成功",
+                    "stderr": "",
+                }
+            else:
+                self._revert_changes()
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "代码修改失败，请修改需求后重试",
+                }
                 
         except Exception as e:
+            self._revert_changes()
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"执行失败: {str(e)}",
+                "stderr": f"执行失败: {str(e)}，请修改需求后重试",
                 "error": e
             }
 
-
 def main():
     """命令行入口"""
     import argparse
@@ -550,7 +198,6 @@ def main():
     parser.add_argument('-l', '--language', help='编程语言', default="python")
     args = parser.parse_args()
     
-        
     tool = JarvisCoder(args.dir, args.language)
     
     # 循环处理需求
@@ -569,16 +216,21 @@ def main():
             if result["success"]:
                 PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
             else:
-                if result["stderr"]:
+                if result.get("stderr"):
                     PrettyOutput.print(result["stderr"], OutputType.WARNING)
-                if result["error"]:
-                    PrettyOutput.print(f"错误类型: {type(result['error']).__name__}", OutputType.WARNING)
+                if result.get("error"):  # 使用 get() 方法避免 KeyError
+                    error = result["error"]
+                    PrettyOutput.print(f"错误类型: {type(error).__name__}", OutputType.WARNING)
+                    PrettyOutput.print(f"错误信息: {str(error)}", OutputType.WARNING)
+                # 提示用户可以继续输入
+                PrettyOutput.print("\n您可以修改需求后重试", OutputType.INFO)
                 
         except KeyboardInterrupt:
             print("\n用户中断执行")
             break
         except Exception as e:
             PrettyOutput.print(f"执行出错: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print("\n您可以修改需求后重试", OutputType.INFO)
             continue
             
     return 0
@@ -703,4 +355,4 @@ def get_multiline_input(prompt_text: str, root_dir: str = None) -> str:
     except EOFError:
         pass
     
-    return "\n".join(lines)
+    return "\n".join(lines)

jarvis/jarvis_coder/model_utils.py

@@ -0,0 +1,30 @@
+from typing import Tuple
+import time
+from jarvis.models.base import BasePlatform
+from jarvis.utils import OutputType, PrettyOutput
+
+def call_model_with_retry(model: BasePlatform, prompt: str, max_retries: int = 3, initial_delay: float = 1.0) -> Tuple[bool, str]:
+    """调用模型并支持重试
+    
+    Args:
+        model: 模型实例
+        prompt: 提示词
+        max_retries: 最大重试次数
+        initial_delay: 初始延迟时间(秒)
+        
+    Returns:
+        Tuple[bool, str]: (是否成功, 响应内容)
+    """
+    delay = initial_delay
+    for attempt in range(max_retries):
+        try:
+            response = model.chat(prompt)
+            return True, response
+        except Exception as e:
+            if attempt == max_retries - 1:  # 最后一次尝试
+                PrettyOutput.print(f"调用模型失败: {str(e)}", OutputType.ERROR)
+                return False, str(e)
+                
+            PrettyOutput.print(f"调用模型失败，{delay}秒后重试: {str(e)}", OutputType.WARNING)
+            time.sleep(delay)
+            delay *= 2  # 指数退避 

jarvis/jarvis_coder/patch_handler.py

@@ -0,0 +1,390 @@
+import re
+import os
+from typing import List, Tuple, Dict
+from jarvis.utils import OutputType, PrettyOutput
+from .model_utils import call_model_with_retry
+
+class PatchHandler:
+    def __init__(self, model):
+        self.model = model
+
+    def _extract_patches(self, response: str) -> List[Tuple[str, str, str]]:
+        """从响应中提取补丁
+        
+        Args:
+            response: 模型响应内容
+            
+        Returns:
+            List[Tuple[str, str, str]]: 补丁列表，每个补丁是 (格式, 文件路径, 补丁内容) 的元组
+        """
+        patches = []
+        
+        # 匹配两种格式的补丁
+        fmt1_patches = re.finditer(r'<PATCH_FMT1>\n?(.*?)\n?</PATCH_FMT1>', response, re.DOTALL)
+        fmt2_patches = re.finditer(r'<PATCH_FMT2>\n?(.*?)\n?</PATCH_FMT2>', response, re.DOTALL)
+        
+        # 处理 FMT1 格式的补丁
+        for match in fmt1_patches:
+            patch_content = match.group(1)
+            if not patch_content:
+                continue
+                
+            # 提取文件路径和补丁内容
+            lines = patch_content.split('\n')
+            file_path_match = re.search(r'> (.*)', lines[0])
+            if not file_path_match:
+                continue
+                
+            file_path = file_path_match.group(1).strip()
+            patch_content = '\n'.join(lines[1:])
+            patches.append(("FMT1", file_path, patch_content))
+        
+        # 处理 FMT2 格式的补丁
+        for match in fmt2_patches:
+            patch_content = match.group(1)
+            if not patch_content:
+                continue
+                
+            # 提取文件路径和补丁内容
+            lines = patch_content.split('\n')
+            file_path_match = re.search(r'> (.*)', lines[0])
+            if not file_path_match:
+                continue
+                
+            file_path = file_path_match.group(1).strip()
+            patch_content = '\n'.join(lines[1:])
+            patches.append(("FMT2", file_path, patch_content))
+        
+        return patches
+
+    def make_patch(self, related_files: List[Dict], feature: str) -> List[Tuple[str, str, str]]:
+        """生成修改方案"""
+        prompt = """你是一个资深程序员，请根据需求描述，修改文件内容。
+
+修改格式说明：
+1. 第一种格式 - 完整代码块替换：
+<PATCH_FMT1>
+> path/to/file
+old_content
+@@@@@@
+new_content
+</PATCH_FMT1>
+
+例：
+<PATCH_FMT1>
+> src/main.py
+def old_function():
+    print("old code")
+    return False
+@@@@@@
+def old_function():
+    print("new code")
+    return True
+</PATCH_FMT1>
+
+2. 第二种格式 - 通过首尾行定位要修改的代码范围：
+<PATCH_FMT2>
+> path/to/file
+start_line_content
+end_line_content
+new_content
+...
+</PATCH_FMT2>
+
+例：
+<PATCH_FMT2>
+> src/main.py
+def old_function():
+    return False
+def new_function():
+    print("new code")
+    return True
+</PATCH_FMT2>
+
+例子中 `def old_function():` 是首行内容，`return False` 是尾行内容，第三行开始是新的代码内容，将替换第一行到最后一行之间的所有内容
+
+注意事项：
+1、仅输出补丁内容，不要输出任何其他内容
+2、如果在大段代码中有零星修改，生成多个补丁
+3、要替换的内容，一定要与文件内容完全一致，不要有任何多余或者缺失的内容
+4、每个patch不超过20行，超出20行，请生成多个patch
+5、务必保留原始文件的缩进和格式
+6、优先使用第二种格式（PATCH_FMT2），因为它更准确地定位要修改的代码范围
+7、第二种格式（PATCH_FMT2）的前两行必须完全匹配文件中要修改的代码块的首尾行
+8、如果第二种格式无法准确定位到要修改的代码（比如有重复的行），请使用第一种格式（PATCH_FMT1）
+"""
+        # 添加文件内容到提示
+        for i, file in enumerate(related_files):
+            prompt += f"""\n{i}. {file["file_path"]}\n"""
+            prompt += f"""文件内容:\n"""
+            prompt += f"<FILE_CONTENT>\n"
+            prompt += f'{file["file_content"]}\n'
+            prompt += f"</FILE_CONTENT>\n"
+        
+        prompt += f"\n需求描述: {feature}\n"
+
+        # 调用模型生成补丁
+        success, response = call_model_with_retry(self.model, prompt)
+        if not success:
+            PrettyOutput.print("生成补丁失败", OutputType.ERROR)
+            return []
+            
+        try:
+            patches = self._extract_patches(response)
+            
+            if not patches:
+                PrettyOutput.print("未生成任何有效补丁", OutputType.WARNING)
+                return []
+                
+            PrettyOutput.print(f"生成了 {len(patches)} 个补丁", OutputType.SUCCESS)
+            return patches
+            
+        except Exception as e:
+            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.WARNING)
+            return []
+
+    def apply_patch(self, related_files: List[Dict], patches: List[Tuple[str, str, str]]) -> Tuple[bool, str]:
+        """应用补丁
+        
+        Args:
+            related_files: 相关文件列表
+            patches: 补丁列表，每个补丁是 (格式, 文件路径, 补丁内容) 的元组
+            
+        Returns:
+            Tuple[bool, str]: (是否成功, 错误信息)
+        """
+        error_info = []
+        modified_files = set()
+
+        # 创建文件内容映射
+        file_map = {file["file_path"]: file["file_content"] for file in related_files}
+        temp_map = file_map.copy()  # 创建临时映射用于尝试应用
+        
+        # 尝试应用所有补丁
+        for i, (fmt, file_path, patch_content) in enumerate(patches):
+            PrettyOutput.print(f"正在应用补丁 {i+1}/{len(patches)}", OutputType.INFO)
+            
+            try:
+                # 处理文件修改
+                if file_path not in temp_map:
+                    error_info.append(f"文件不存在: {file_path}")
+                    return False, "\n".join(error_info)
+                
+                current_content = temp_map[file_path]
+                
+                if fmt == "FMT1":  # 完整代码块替换格式
+                    parts = patch_content.split("@@@@@@")
+                    if len(parts) != 2:
+                        error_info.append(f"FMT1补丁格式错误: {file_path}，缺少分隔符")
+                        return False, "\n".join(error_info)
+                        
+                    old_content, new_content = parts
+                    
+                    # 处理新文件
+                    if not old_content:
+                        temp_map[file_path] = new_content
+                        modified_files.add(file_path)
+                        continue
+                    
+                    # 查找并替换代码块
+                    if old_content not in current_content:
+                        error_info.append(
+                            f"补丁应用失败: {file_path}\n"
+                            f"原因: 未找到要替换的代码\n"
+                            f"期望找到的代码:\n{old_content}\n"
+                            f"实际文件内容:\n{current_content[:200]}..."
+                        )
+                        return False, "\n".join(error_info)
+                    
+                    # 应用更改
+                    temp_map[file_path] = current_content.replace(old_content, new_content)
+                    
+                else:  # FMT2 - 首尾行定位格式
+                    lines = patch_content.splitlines()
+                    if len(lines) < 3:
+                        error_info.append(f"FMT2补丁格式错误: {file_path}，行数不足")
+                        return False, "\n".join(error_info)
+                        
+                    first_line = lines[0]
+                    last_line = lines[1]
+                    new_content = '\n'.join(lines[2:])
+                    
+                    # 在文件内容中定位要替换的区域
+                    content_lines = current_content.splitlines()
+                    start_idx = -1
+                    end_idx = -1
+                    
+                    # 查找匹配的起始行和结束行
+                    for idx, line in enumerate(content_lines):
+                        if line.rstrip() == first_line.rstrip():
+                            start_idx = idx
+                        if start_idx != -1 and line.rstrip() == last_line.rstrip():
+                            end_idx = idx
+                            break
+                    
+                    if start_idx == -1 or end_idx == -1:
+                        error_info.append(
+                            f"补丁应用失败: {file_path}\n"
+                            f"原因: 未找到匹配的代码范围\n"
+                            f"起始行: {first_line}\n"
+                            f"结束行: {last_line}"
+                        )
+                        return False, "\n".join(error_info)
+                    
+                    # 替换内容
+                    content_lines[start_idx:end_idx + 1] = new_content.splitlines()
+                    temp_map[file_path] = "\n".join(content_lines)
+                
+                modified_files.add(file_path)
+                
+            except Exception as e:
+                error_info.append(f"处理补丁时发生错误: {str(e)}")
+                return False, "\n".join(error_info)
+        
+        # 所有补丁都应用成功，更新实际文件
+        for file_path in modified_files:
+            try:
+                dir_path = os.path.dirname(file_path)
+                if dir_path and not os.path.exists(dir_path):
+                    os.makedirs(dir_path, exist_ok=True)
+                    
+                with open(file_path, "w", encoding="utf-8") as f:
+                    f.write(temp_map[file_path])
+                    
+                PrettyOutput.print(f"成功修改文件: {file_path}", OutputType.SUCCESS)
+                
+            except Exception as e:
+                error_info.append(f"写入文件失败 {file_path}: {str(e)}")
+                return False, "\n".join(error_info)
+        
+        return True, ""
+
+    def handle_patch_feedback(self, error_msg: str, feature: str) -> List[Tuple[str, str, str]]:
+        """处理补丁应用失败的反馈
+        
+        Args:
+            error_msg: 错误信息
+            feature: 功能描述
+            
+        Returns:
+            List[Tuple[str, str, str]]: 新的补丁列表
+        """
+        PrettyOutput.print("补丁应用失败，尝试重新生成", OutputType.WARNING)
+        
+        # 获取用户补充信息
+        additional_info = input("\n请输入补充信息(直接回车跳过):")
+        PrettyOutput.print(f"开始重新生成补丁", OutputType.INFO)
+        
+        # 构建重试提示
+        retry_prompt = f"""补丁应用失败，请根据以下信息重新生成补丁：
+
+错误信息：
+{error_msg}
+
+原始需求：
+{feature}
+
+用户补充信息：
+{additional_info}
+
+请重新生成补丁，确保：
+1. 代码匹配完全准确
+2. 保持正确的缩进和格式
+3. 避免之前的错误
+"""
+        success, response = call_model_with_retry(self.model, retry_prompt)
+        if not success:
+            return []
+            
+        try:
+            patches = self._extract_patches(response)
+            return patches
+            
+        except Exception as e:
+            PrettyOutput.print(f"解析patch失败: {str(e)}", OutputType.WARNING)
+            return []
+
+    def monitor_patch_result(self, success: bool, error_msg: str) -> bool:
+        """监控补丁应用结果
+        
+        Args:
+            success: 是否成功
+            error_msg: 错误信息
+            
+        Returns:
+            bool: 是否继续尝试
+        """
+        if success:
+            PrettyOutput.print("补丁应用成功", OutputType.SUCCESS)
+            return False
+            
+        PrettyOutput.print(f"补丁应用失败: {error_msg}", OutputType.ERROR)
+        
+        # 询问是否继续尝试
+        retry = input("\n是否重新尝试？(y/n) [y]: ").lower() or "y"
+        return retry == "y"
+
+    def handle_patch_application(self, related_files: List[Dict], feature: str) -> bool:
+        """处理补丁应用流程
+        
+        Args:
+            related_files: 相关文件列表
+            feature: 功能描述
+            
+        Returns:
+            bool: 是否成功应用补丁
+        """
+        max_attempts = 3
+        attempt = 0
+        
+        while attempt < max_attempts:
+            attempt += 1
+            
+            while True:  # 在当前尝试中循环，直到成功或用户放弃
+                # 1. 生成补丁
+                patches = self.make_patch(related_files, feature)
+                if not patches:
+                    return False
+                
+                # 2. 显示补丁内容
+                PrettyOutput.print("\n将要应用以下补丁:", OutputType.INFO)
+                for fmt, file_path, patch_content in patches:
+                    PrettyOutput.print(f"\n文件: {file_path}", OutputType.INFO)
+                    PrettyOutput.print(f"格式: {fmt}", OutputType.INFO)
+                    PrettyOutput.print("补丁内容:", OutputType.INFO)
+                    print(patch_content)
+                
+                # 3. 应用补丁
+                success, error_msg = self.apply_patch(related_files, patches)
+                if not success:
+                    # 4. 如果应用失败，询问是否重试
+                    should_retry = self.monitor_patch_result(success, error_msg)
+                    if not should_retry:
+                        break  # 退出内层循环，尝试下一次完整的迭代
+                        
+                    # 5. 处理失败反馈
+                    patches = self.handle_patch_feedback(error_msg, feature)
+                    if not patches:
+                        return False
+                    continue  # 继续当前迭代
+                
+                # 6. 应用成功，让用户确认修改
+                PrettyOutput.print("\n补丁已应用，请检查修改效果。", OutputType.SUCCESS)
+                confirm = input("\n是否保留这些修改？(y/n) [y]: ").lower() or "y"
+                if confirm != "y":
+                    PrettyOutput.print("用户取消修改，正在回退", OutputType.WARNING)
+                    os.system("git reset --hard")  # 回退所有修改
+                    
+                    # 询问是否要在当前迭代中重试
+                    retry = input("\n是否要重新生成补丁？(y/n) [y]: ").lower() or "y"
+                    if retry != "y":
+                        break  # 退出内层循环，尝试下一次完整的迭代
+                    continue  # 继续当前迭代
+                
+                return True  # 用户确认修改，返回成功
+            
+            # 如果内层循环正常退出（非return），继续外层循环
+            continue
+        
+        PrettyOutput.print(f"达到最大重试次数 ({max_attempts})", OutputType.WARNING)
+        return False 

{jarvis_ai_assistant-0.1.88.dist-info → jarvis_ai_assistant-0.1.89.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.88
+Version: 0.1.89
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

{jarvis_ai_assistant-0.1.88.dist-info → jarvis_ai_assistant-0.1.89.dist-info}/RECORD

@@ -1,11 +1,14 @@
-jarvis/__init__.py,sha256=LBqI57It2XH2RYcs4daPQFNHcA9IzWISqF35HvrX_sk,50
+jarvis/__init__.py,sha256=_3MqMWMf232eVTukktJrSn128MkK9jyds0HMhYHti94,50
 jarvis/agent.py,sha256=_qh4mSojAgClOEz5pTiRIfRJU-5_3QGzBAU09roCjtk,19095
 jarvis/main.py,sha256=72od8757A3bhe0ncE38S7u-YZsAh0y50w9ozMhgqIU8,5423
 jarvis/utils.py,sha256=Y5zig7AgIzdWHF31qHaMUziezythfjVKjxFRtMzd1m4,10357
 jarvis/jarvis_codebase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_codebase/main.py,sha256=hYdDwREfFW5KPbIbLZ75MFCth6VqrwxSeNfXiQavdzE,26473
 jarvis/jarvis_coder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_coder/main.py,sha256=Rdt9w_uGamDHN-jjZXtHdUNGHa0q2fbGe9R9Ay6XXe0,25431
+jarvis/jarvis_coder/git_utils.py,sha256=tJ25kIzglGaPBqu42rZZSsXk0tpOFTiaG8q-bq4CSF0,2343
+jarvis/jarvis_coder/main.py,sha256=5uxexKziA5kMZLNkGPEzz8hKQvarKVflNqRcXZVWnT8,13406
+jarvis/jarvis_coder/model_utils.py,sha256=XXg5ZPlgRsq9K6iJb4vPoZqSiAJbAUIZffmgaLFnLCw,1104
+jarvis/jarvis_coder/patch_handler.py,sha256=U8I19Aq2U3LAU3FE94C3tlFQNtGYA_luwnBU7OnX7pw,15253
 jarvis/jarvis_rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_rag/main.py,sha256=a8TtPVCh5Xd6W1AaRFGeXvU_1hEnHQdoMElxnMuq0ew,24773
 jarvis/jarvis_smart_shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,9 +35,9 @@ jarvis/tools/search.py,sha256=c9dXtyICdl8Lm8shNPNyIx9k67uY0rMF8xnIKu2RsnE,8787
 jarvis/tools/shell.py,sha256=UPKshPyOaUwTngresUw-ot1jHjQIb4wCY5nkJqa38lU,2520
 jarvis/tools/sub_agent.py,sha256=rEtAmSVY2ZjFOZEKr5m5wpACOQIiM9Zr_3dT92FhXYU,2621
 jarvis/tools/webpage.py,sha256=d3w3Jcjcu1ESciezTkz3n3Zf-rp_l91PrVoDEZnckOo,2391
-jarvis_ai_assistant-0.1.88.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.1.88.dist-info/METADATA,sha256=0TMTVTnHXcL9qyqfgvNv0KmAGa1nUDUkD_NQ1bV2EG0,12589
-jarvis_ai_assistant-0.1.88.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jarvis_ai_assistant-0.1.88.dist-info/entry_points.txt,sha256=sdmIO86MrIUepJTGyHs0i_Ho9VGf1q9YRP4RgQvGWcI,280
-jarvis_ai_assistant-0.1.88.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.88.dist-info/RECORD,,
+jarvis_ai_assistant-0.1.89.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.1.89.dist-info/METADATA,sha256=aG0WNMCBnK4O5fPKrNiq7Nj3wlsU5mx2xy1tQUSlmAU,12589
+jarvis_ai_assistant-0.1.89.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jarvis_ai_assistant-0.1.89.dist-info/entry_points.txt,sha256=sdmIO86MrIUepJTGyHs0i_Ho9VGf1q9YRP4RgQvGWcI,280
+jarvis_ai_assistant-0.1.89.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.89.dist-info/RECORD,,