jarvis-ai-assistant 0.1.132__py3-none-any.whl → 0.1.138__py3-none-any.whl

jarvis/jarvis_agent/patch.py

@@ -5,26 +5,30 @@ import os
 from yaspin import yaspin
 
 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_tools.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 ct, ot, get_file_line_count, user_confirm
 
+
 class PatchOutputHandler(OutputHandler):
     def name(self) -> str:
         return "PATCH"
-    def handle(self, response: str) -> Tuple[bool, Any]:
-        return False, apply_patch(response)
-    
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
+        return False, apply_patch(response, agent)
+
     def can_handle(self, response: str) -> bool:
         if _parse_patch(response):
             return True
         return False
-    
+
     def prompt(self) -> str:
         return f"""
 # 代码补丁规范
@@ -43,18 +47,17 @@ Reason: [修改原因]
 ```
 
 ## 核心原则
-1. **上下文完整性**：代码片段必须包含足够的上下文（修改前后各3行）
-2. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
-3. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
-4. **格式严格保持**：
+1. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
+2. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
+3. **格式严格保持**：
    - 严格保持原始代码的缩进方式（空格或制表符）
    - 保持原始代码的空行数量和位置
    - 保持原始代码的行尾空格处理方式
    - 不改变原始代码的换行风格
-5. **新旧区分**：
+4. **新旧区分**：
    - 对于新文件：提供完整的代码内容
-   - 对于现有文件：只提供修改部分及必要上下文，不要提供整个文件
-6. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
+   - 对于现有文件：只提供修改部分，不要提供整个文件
+5. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
 
 ## 格式兼容性要求
 1. **缩进一致性**：
@@ -85,17 +88,21 @@ def add(a, b):
 
 ## 最佳实践
 - 每个补丁专注于单一职责的修改
-- 提供足够的上下文，但避免包含过多无关代码
+- 避免包含过多无关代码
 - 确保修改理由清晰明确，便于理解变更目的
 - 保持代码风格一致性，遵循项目现有的编码规范
 - 在修改前仔细分析原代码的格式风格，确保补丁与之完全兼容
 - 绝不提供完整文件内容，除非是新建文件
+- 每个文件的修改是独立的，不能出现“参照xxx文件的修改”这样的描述
+- 不要出现未实现的代码，如：TODO
 """
 
+
 def _parse_patch(patch_str: str) -> Dict[str, str]:
     """解析新的上下文补丁格式"""
     result = {}
-    patches = re.findall(ot("PATCH")+r'\n?(.*?)\n?'+ct("PATCH"), patch_str, re.DOTALL)
+    patches = re.findall(ot("PATCH")+r'\n?(.*?)\n?' +
+                         ct("PATCH"), patch_str, re.DOTALL)
     if patches:
         for patch in patches:
             first_line = patch.splitlines()[0]
@@ -110,7 +117,8 @@ def _parse_patch(patch_str: str) -> Dict[str, str]:
                 result[filepath] += "\n\n" + patch
     return result
 
-def apply_patch(output_str: str) -> str:
+
+def apply_patch(output_str: str, agent: Any) -> str:
     """Apply patches to files"""
     with yaspin(text="正在应用补丁...", color="cyan") as spinner:
         try:
@@ -118,12 +126,17 @@ def apply_patch(output_str: str) -> str:
         except Exception as e:
             PrettyOutput.print(f"解析补丁失败: {str(e)}", OutputType.ERROR)
             return ""
-        
+
         # 获取当前提交hash作为起始点
-        spinner.text= "开始获取当前提交hash..."
+        spinner.text = "开始获取当前提交hash..."
         start_hash = get_latest_commit_hash()
         spinner.write("✅ 当前提交hash获取完成")
-        
+
+        not_read_file = [f for f in patches.keys() if not has_read_file(f)]
+        if not_read_file:
+            yaspin.write(f"❌ 以下文件未读取: {not_read_file}，应用补丁存在风险，将先读取文件后再生成补丁", color="red")
+            return f"以下文件未读取: {not_read_file}，应用补丁存在风险，请先读取文件后再生成补丁"
+
         # 按文件逐个处理
         for filepath, patch_content in patches.items():
             try:
@@ -134,6 +147,7 @@ def apply_patch(output_str: str) -> str:
                     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):
@@ -145,7 +159,7 @@ def apply_patch(output_str: str) -> str:
                 spinner.text = f"文件 {filepath} 处理失败: {str(e)}, 回滚文件"
                 revert_file(filepath)  # 回滚单个文件
                 spinner.write(f"✅ 文件 {filepath} 回滚完成")
-        
+
         final_ret = ""
         diff = get_diff()
         if diff:
@@ -156,45 +170,50 @@ def apply_patch(output_str: str) -> str:
                 # 获取提交信息
                 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```"
-                    
+
                     # 增加代码变更分析和错误提示
-                    final_ret += "\n\n# 代码变更分析：\n"
-                    final_ret += "1. 请仔细检查以上变更是否引入了潜在错误\n"
-                    final_ret += "2. 如果发现代码错误，请立即提出修复方案\n"
-                    final_ret += "3. 修复代码错误的优先级高于继续实现功能\n"
-                    final_ret += "4. 常见错误类型：语法错误、逻辑错误、命名错误、路径错误等\n"
-                    final_ret += "5. 确保修改后代码的一致性和完整性\n"
-                    final_ret += "\n\n"
-                    final_ret += "如果没有问题，请继续进行下一步修改，如果所有修改都已经完成，请终止"
-                    
+
+                    addon_prompt = "1. 请调用静态检查工具（如有）检查以上变更是否引入了潜在错误\n"
+                    addon_prompt += "2. 如果发现代码错误，请立即提出修复方案\n"
+                    addon_prompt += "3. 如果错误并非是本次修改引入，要询问用户是否需要立即修复\n"
+                    addon_prompt += "\n\n"
+                    addon_prompt += "如果没有问题，请继续进行下一步修改\n"
+                    addon_prompt += f"如果用户的需求已经完成，请终止，不要输出新的 {ot('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"
         # 用户确认最终结果
         with spinner.hidden():
+            if commited:
+                return final_ret
             PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
             if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
                 return final_ret
             custom_reply = get_multiline_input("请输入自定义回复")
             if not custom_reply.strip():  # 如果自定义回复为空，返回空字符串
                 return ""
-            if not commited:
-                return final_ret + "\n\n" + custom_reply
-            else:
-                return custom_reply
+            agent.set_addon_prompt(custom_reply)
+            return final_ret
+
 
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
@@ -206,7 +225,8 @@ def revert_file(filepath: str):
             stderr=subprocess.PIPE
         )
         if result.returncode == 0:
-            subprocess.run(['git', 'checkout', 'HEAD', '--', filepath], check=True)
+            subprocess.run(['git', 'checkout', 'HEAD',
+                           '--', filepath], check=True)
         else:
             if os.path.exists(filepath):
                 os.remove(filepath)
@@ -214,11 +234,15 @@ def revert_file(filepath: str):
     except subprocess.CalledProcessError as e:
         PrettyOutput.print(f"恢复文件失败: {str(e)}", OutputType.ERROR)
 # 修改后的恢复函数
+
+
 def revert_change():
     import subprocess
     subprocess.run(['git', 'reset', '--hard', 'HEAD'], check=True)
     subprocess.run(['git', 'clean', '-fd'], check=True)
 # 修改后的获取差异函数
+
+
 def get_diff() -> str:
     """使用git获取暂存区差异"""
     import subprocess
@@ -236,9 +260,10 @@ def get_diff() -> str:
     except subprocess.CalledProcessError as e:
         return f"获取差异失败: {str(e)}"
 
-def handle_commit_workflow()->bool:
+
+def handle_commit_workflow() -> bool:
     """Handle the git commit workflow and return the commit details.
-    
+
     Returns:
         tuple[bool, str, str]: (continue_execution, commit_id, commit_message)
     """
@@ -252,13 +277,13 @@ def handle_commit_workflow()->bool:
 
 def handle_code_operation(filepath: str, patch_content: str) -> bool:
     """处理代码操作"""
-    if get_file_line_count(filepath) < 100:
+    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):
+            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)
 
@@ -268,11 +293,12 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
     with yaspin(text=f"正在修改文件 {filepath}...", color="cyan") as spinner:
         try:
             with spinner.hidden():
-                old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
+                old_file_content = FileOperationTool().execute(
+                    {"operation": "read", "files": [{"path": filepath}]})
                 if not old_file_content["success"]:
                     spinner.write("❌ 文件读取失败")
                     return False
-            
+
             prompt = f"""
 # 代码合并专家指南
 
@@ -308,16 +334,17 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
 [合并后的完整代码，包括所有空行和缩进]
 {ct("MERGED_CODE")}
 """
-            model = PlatformRegistry().get_codegen_platform()
-            model.set_suppress_output(True)
+            model = PlatformRegistry().get_normal_platform()
+            model.set_suppress_output(False)
             count = 30
             start_line = -1
             end_line = -1
             code = []
             finished = False
-            while count>0:
+            while count > 0:
                 count -= 1
-                response = model.chat_until_success(prompt).splitlines()
+                with spinner.hidden():
+                    response = model.chat_until_success(prompt).splitlines()
                 try:
                     start_line = response.index(ot("MERGED_CODE")) + 1
                     try:
@@ -328,7 +355,7 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
                 except:
                     pass
 
-                try: 
+                try:
                     response.index(ot("!!!FINISHED!!!"))
                     finished = True
                     break
@@ -365,20 +392,20 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
             return False
 
 
-def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
+def handle_large_code_operation(filepath: str, patch_content: str, model: BasePlatform) -> bool:
     """处理大型代码文件的补丁操作，使用差异化补丁格式"""
     with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
         try:
             # 读取原始文件内容
-            old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
+            old_file_content = FileOperationTool().execute(
+                {"operation": "read", "files": [{"path": filepath}]})
             if not old_file_content["success"]:
                 spinner.text = "文件读取失败"
                 spinner.fail("❌")
                 return False
-            
-            model = PlatformRegistry().get_codegen_platform()
-            model.set_suppress_output(True)
-            
+
+            model.set_suppress_output(False)
+
             prompt = f"""
 # 代码补丁生成专家指南
 
@@ -431,20 +458,21 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
 {ct("DIFF")}
 """
             # 获取补丁内容
-            response = model.chat_until_success(prompt)
-            
+            with spinner.hidden():
+                response = model.chat_until_success(prompt)
+
             # 解析差异化补丁
-            diff_blocks = re.finditer(ot("DIFF")+r'\s*>{4,} SEARCH\n?(.*?)\n?={4,}\n?(.*?)\s*<{4,} REPLACE\n?'+ct("DIFF"), 
-                                     response, re.DOTALL)
-            
+            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
-            
+
             for match in diff_blocks:
                 search_text = match.group(1).strip()
                 replace_text = match.group(2).strip()
@@ -457,23 +485,23 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
                         spinner.fail("❌")
                         return False
                     # 应用替换
-                    modified_content = modified_content.replace(search_text, replace_text)
+                    modified_content = modified_content.replace(
+                        search_text, replace_text)
                     spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
                 else:
                     spinner.text = f"补丁 #{patch_count} 应用失败：无法找到匹配的代码段"
                     spinner.fail("❌")
                     return False
-            
+
             # 写入修改后的内容
             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
-            
+
         except Exception as e:
             spinner.text = f"文件修改失败: {str(e)}"
             spinner.fail("❌")
             return False
-

jarvis/jarvis_agent/shell_input_handler.py

@@ -21,7 +21,9 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
                 "arguments": {
                     "script_content": script
                 }
-            })
-            return f"{user_input}\n\n用户执行以下脚本：\n{script}\n\n执行结果：\n{output}", False
+            }, agent)
+            if user_confirm("是否将执行结果反馈给Agent？", default=True):
+                return f"{user_input}\n\n用户执行以下脚本：\n{script}\n\n执行结果：\n{output}", False
+            return "", True
         return user_input, False
-    
+