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

jarvis/jarvis_agent/main.py

@@ -10,17 +10,17 @@ from jarvis.jarvis_utils.utils import init_env
 
 def load_config(config_path: str) -> dict:
     """Load configuration from YAML file
-    
+
     Args:
         config_path: Path to the YAML configuration file
-        
+
     Returns:
         dict: Configuration dictionary
     """
     if not os.path.exists(config_path):
         PrettyOutput.print(f"配置文件 {config_path} 不存在，使用默认配置", OutputType.WARNING)
         return {}
-    
+
     with open(config_path, 'r', encoding='utf-8', errors="ignore") as f:
         try:
             config = yaml.safe_load(f)
@@ -33,42 +33,43 @@ def main():
     """Main entry point for Jarvis agent"""
     # Initialize environment
     init_env()
-    
+
     # Set up argument parser
     parser = argparse.ArgumentParser(description='Jarvis AI assistant')
-    parser.add_argument('-c', '--config', type=str, required=True, 
+    parser.add_argument('-c', '--config', type=str, required=True,
                         help='Path to the YAML configuration file')
     parser.add_argument('-t', '--task', type=str,
                         help='Initial task to execute')
     args = parser.parse_args()
-    
+
     # Load configuration
     config = load_config(args.config)
-    
+
     # Create and run agent
     try:
         agent = Agent(**config)
-        
+
         # Run agent with initial task if specified
         if args.task:
             PrettyOutput.print(f"执行初始任务: {args.task}", OutputType.INFO)
             agent.run(args.task)
             return 0
-        
+
         # Enter interactive mode if no initial task
         while True:
             try:
                 user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
                 if not user_input:
                     break
+                agent.set_addon_prompt("如果有必要，请先指定出行动计划，然后根据计划一步步执行")
                 agent.run(user_input)
             except Exception as e:
                 PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
-                
+
     except Exception as e:
         PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
         return 1
-    
+
     return 0
 
 if __name__ == "__main__":

jarvis/jarvis_agent/output_handler.py

@@ -7,13 +7,13 @@ from typing import Any, Tuple
 
 class OutputHandler(ABC):
     @abstractmethod
-    def handle(self, response: str) -> Tuple[bool, Any]:
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
         pass
-    
+
     @abstractmethod
     def can_handle(self, response: str) -> bool:
         pass
-    
+
     @abstractmethod
     def prompt(self) -> str:
         pass

jarvis/jarvis_agent/patch.py

@@ -11,21 +11,24 @@ 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"""
 # 代码补丁规范
@@ -44,18 +47,17 @@ Reason: [修改原因]
 ```
 
 ## 核心原则
-1. **上下文完整性**：代码片段必须包含足够的上下文（修改前后各3行）
-2. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
-3. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
-4. **格式严格保持**：
+1. **精准修改**：只显示需要修改的代码部分，不需要展示整个文件内容
+2. **最小补丁原则**：始终生成最小范围的补丁，只包含必要的上下文和实际修改
+3. **格式严格保持**：
    - 严格保持原始代码的缩进方式（空格或制表符）
    - 保持原始代码的空行数量和位置
    - 保持原始代码的行尾空格处理方式
    - 不改变原始代码的换行风格
-5. **新旧区分**：
+4. **新旧区分**：
    - 对于新文件：提供完整的代码内容
-   - 对于现有文件：只提供修改部分及必要上下文，不要提供整个文件
-6. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
+   - 对于现有文件：只提供修改部分，不要提供整个文件
+5. **理由说明**：每个补丁必须包含清晰的修改理由，解释为什么需要此更改
 
 ## 格式兼容性要求
 1. **缩进一致性**：
@@ -86,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]
@@ -111,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:
@@ -119,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:
@@ -135,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):
@@ -146,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:
@@ -157,30 +170,29 @@ 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"
-                    final_ret += "   - 所有需要更新的函数\n"
-                    final_ret += "   - 所有需要调整的依赖关系\n"
-                    final_ret += "   - 所有需要同步的文档\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:
@@ -199,8 +211,10 @@ def apply_patch(output_str: str) -> str:
             custom_reply = get_multiline_input("请输入自定义回复")
             if not custom_reply.strip():  # 如果自定义回复为空，返回空字符串
                 return ""
-            return final_ret + "\n\n" + custom_reply
-            
+            agent.set_addon_prompt(custom_reply)
+            return final_ret
+
+
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
     import subprocess
@@ -211,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)
@@ -219,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
@@ -241,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)
     """
@@ -257,7 +277,7 @@ 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
@@ -273,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"""
 # 代码合并专家指南
 
@@ -314,15 +335,16 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
 {ct("MERGED_CODE")}
 """
             model = PlatformRegistry().get_normal_platform()
-            model.set_suppress_output(True)
+            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:
@@ -333,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
@@ -375,14 +397,15 @@ def handle_large_code_operation(filepath: str, patch_content: str, model: BasePl
     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.set_suppress_output(True)
-            
+
+            model.set_suppress_output(False)
+
             prompt = f"""
 # 代码补丁生成专家指南
 
@@ -435,20 +458,21 @@ def handle_large_code_operation(filepath: str, patch_content: str, model: BasePl
 {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()
@@ -461,23 +485,23 @@ def handle_large_code_operation(filepath: str, patch_content: str, model: BasePl
                         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
-    
+