jarvis-ai-assistant 0.1.97__py3-none-any.whl → 0.1.98__py3-none-any.whl

jarvis/jarvis_coder/patch_handler.py

@@ -15,13 +15,13 @@ class PatchHandler:
 
 
     def _extract_patches(self, response: str) -> List[Patch]:
-        """从响应中提取补丁
+        """Extract patches from response
         
         Args:
-            response: 模型响应内容
+            response: Model response content
             
         Returns:
-            List[Tuple[str, str, str]]: 补丁列表，每个补丁是 (格式, 文件路径, 补丁内容) 的元组
+            List[Tuple[str, str, str]]: Patch list, each patch is a tuple of (format, file path, patch content)
         """
         # 修改后的正则表达式匹配三种补丁格式
         fmt_pattern = r'<PATCH>\n>>>>>> SEARCH\n(.*?)\n?(={5,})\n(.*?)\n?<<<<<< REPLACE\n</PATCH>'
@@ -32,21 +32,21 @@ class PatchHandler:
 
 
     def _confirm_and_apply_changes(self, file_path: str) -> bool:
-        """确认并应用修改"""
+        """Confirm and apply changes"""
         os.system(f"git diff --cached {file_path}")
-        confirm = input(f"\n是否接受 {file_path} 的修改？(y/n) [y]: ").lower() or "y"
+        confirm = input(f"\nAccept {file_path} changes? (y/n) [y]: ").lower() or "y"
         if confirm == "y":
             return True
         else:
-            # 回退修改
+            # Rollback changes
             os.system(f"git reset {file_path}")
             os.system(f"git checkout -- {file_path}")
-            PrettyOutput.print(f"已回退 {file_path} 的修改", OutputType.WARNING)
+            PrettyOutput.print(f"Changes to {file_path} have been rolled back", OutputType.WARNING)
             return False
 
     
     def apply_file_patch(self, file_path: str, patches: List[Patch]) -> bool:
-        """应用文件补丁"""
+        """Apply file patch"""
         if not os.path.exists(file_path):
             base_dir = os.path.dirname(file_path)
             os.makedirs(base_dir, exist_ok=True)
@@ -54,20 +54,20 @@ class PatchHandler:
         file_content = open(file_path, "r", encoding="utf-8").read()
         for i, patch in enumerate(patches):
             if patch.old_code == "" and patch.new_code == "":
-                PrettyOutput.print(f"应用第 {i+1}/{len(patches)} 个补丁：删除文件 {file_path}", OutputType.INFO)
+                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)}: Delete file {file_path}", OutputType.INFO)
                 file_content = ""
                 os.system(f"git rm {file_path}")
-                PrettyOutput.print(f"应用第 {i+1}/{len(patches)} 个补丁成功", OutputType.SUCCESS)
+                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)} successfully", OutputType.SUCCESS)
             elif patch.old_code == "":
-                PrettyOutput.print(f"应用第 {i+1}/{len(patches)} 个补丁：替换文件 {file_path} 内容：\n{patch.new_code}", OutputType.INFO)
+                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)}: Replace file {file_path} content: \n{patch.new_code}", OutputType.INFO)
                 file_content = patch.new_code
                 open(file_path, "w", encoding="utf-8").write(patch.new_code)
                 os.system(f"git add {file_path}")
-                PrettyOutput.print(f"应用第 {i+1}/{len(patches)} 个补丁成功", OutputType.SUCCESS)
+                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)} successfully", OutputType.SUCCESS)
             else:
-                PrettyOutput.print(f"应用第 {i+1}/{len(patches)} 个补丁：文件原始内容：\n{patch.old_code}\n替换为：\n{patch.new_code}", OutputType.INFO)
+                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)}: File original content: \n{patch.old_code}\nReplace with: \n{patch.new_code}", OutputType.INFO)
                 if file_content.find(patch.old_code) == -1:
-                    PrettyOutput.print(f"文件 {file_path} 中不存在 {patch.old_code}", OutputType.WARNING)
+                    PrettyOutput.print(f"File {file_path} does not contain {patch.old_code}", OutputType.WARNING)
                     os.system(f"git reset {file_path}")
                     os.system(f"git checkout -- {file_path}")
                     return False
@@ -75,20 +75,20 @@ class PatchHandler:
                     file_content = file_content.replace(patch.old_code, patch.new_code, 1)
                     open(file_path, "w", encoding="utf-8").write(file_content)
                     os.system(f"git add {file_path}")
-                    PrettyOutput.print(f"应用第 {i+1}/{len(patches)} 个补丁成功", OutputType.SUCCESS)
+                    PrettyOutput.print(f"Apply patch {i+1}/{len(patches)} successfully", OutputType.SUCCESS)
         return True
             
     
-    def retry_comfirm(self) -> Tuple[str, str]:# 恢复用户选择逻辑
-        choice = input("\n请选择操作: (1) 重试 (2) 跳过 (3) 完全中止 [1]: ") or "1"
+    def retry_comfirm(self) -> Tuple[str, str]:# Restore user selection logic
+        choice = input("\nPlease choose an action: (1) Retry (2) Skip (3) Completely stop [1]: ") or "1"
         if choice == "2":
             return "skip", ""
         if choice == "3":
             return "break", ""
-        return "continue", get_multiline_input("请输入补充说明和要求:")
+        return "continue", get_multiline_input("Please enter additional information and requirements:")
 
     def apply_patch(self, feature: str, raw_plan: str, structed_plan: Dict[str, str]) -> Tuple[bool, str]:
-        """应用补丁（主入口）"""
+        """Apply patch (main entry)"""
         for file_path, current_plan in structed_plan.items():
             additional_info = ""            
             while True:
@@ -96,7 +96,7 @@ class PatchHandler:
                 if os.path.exists(file_path):
                     content = open(file_path, "r", encoding="utf-8").read()
                 else:
-                    content = "<文件不存在，需要创建>"
+                    content = "<File does not exist, need to create>"
                 prompt = """You are a senior software development expert who can generate code patches based on the complete modification plan, current original code file path, code content, and current file's modification plan. The output format should be as follows:
                         <PATCH>
                         >>>>>> SEARCH
@@ -135,20 +135,20 @@ class PatchHandler:
                     """
 
 
-                PrettyOutput.print(f"为{file_path}生成格式化补丁...", OutputType.PROGRESS)
+                PrettyOutput.print(f"Generating formatted patches for {file_path}...", OutputType.PROGRESS)
                 response = PlatformRegistry.get_global_platform_registry().get_codegen_platform().chat_until_success(prompt)
                 patches = self._extract_patches(response)
 
                 if not patches or not self.apply_file_patch(file_path, patches) or not self._confirm_and_apply_changes(file_path):
                     os.system(f"git reset {file_path}")
                     os.system(f"git checkout -- {file_path}")
-                    PrettyOutput.print("补丁生成失败", OutputType.WARNING)
+                    PrettyOutput.print("Patch generation failed", OutputType.WARNING)
                     act, msg = self.retry_comfirm()
                     if act == "break":
-                        PrettyOutput.print("终止补丁应用", OutputType.WARNING)
+                        PrettyOutput.print("Terminate patch application", OutputType.WARNING)
                         return False, msg
                     if act == "skip":
-                        PrettyOutput.print(f"跳过文件 {file_path}", OutputType.WARNING)
+                        PrettyOutput.print(f"Skip file {file_path}", OutputType.WARNING)
                         break
                     else:
                         additional_info += msg + "\n"
@@ -161,31 +161,31 @@ class PatchHandler:
 
 
     def handle_patch_application(self, feature: str, raw_plan: str, structed_plan: Dict[str,str]) -> bool:
-        """处理补丁应用流程
+        """Process patch application process
         
         Args:
-            related_files: 相关文件列表
-            feature: 功能描述
-            modification_plan: 修改方案
+            related_files: Related files list
+            feature: Feature description
+            modification_plan: Modification plan
             
         Returns:
-            bool: 是否成功应用补丁
+            bool: Whether patch application is successful
         """
-        PrettyOutput.print("\n将要应用以下修改方案:", OutputType.INFO)
+        PrettyOutput.print("\nThe following modification plan will be applied:", OutputType.INFO)
         for file_path, patches_code in structed_plan.items():
-            PrettyOutput.print(f"\n文件: {file_path}", OutputType.INFO)
-            PrettyOutput.print(f"修改方案: \n{patches_code}", OutputType.INFO)
-        # 3. 应用补丁
+            PrettyOutput.print(f"\nFile: {file_path}", OutputType.INFO)
+            PrettyOutput.print(f"Modification plan: \n{patches_code}", OutputType.INFO)
+        # 3. Apply patches
         success, error_msg = self.apply_patch(feature, raw_plan, structed_plan)
         if not success:
             os.system("git reset --hard")
             return False
-        # 6. 应用成功，让用户确认修改
-        PrettyOutput.print("\n补丁已应用，请检查修改效果。", OutputType.SUCCESS)
-        confirm = input("\n是否保留这些修改？(y/n) [y]: ").lower() or "y"
+        # 6. Apply successfully, let user confirm changes
+        PrettyOutput.print("\nPatches applied, please check the modification effect.", OutputType.SUCCESS)
+        confirm = input("\nKeep these changes? (y/n) [y]: ").lower() or "y"
         if confirm != "y":
-            PrettyOutput.print("用户取消修改，正在回退", OutputType.WARNING)
-            os.system("git reset --hard")  # 回退所有修改
+            PrettyOutput.print("User cancelled changes, rolling back", OutputType.WARNING)
+            os.system("git reset --hard")  # Rollback all changes
             return False
         else:
             return True

jarvis/jarvis_coder/plan_generator.py

@@ -4,18 +4,18 @@ from jarvis.models.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType, get_multiline_input
 
 class PlanGenerator:
-    """修改方案生成器"""
+    """Modification plan generator"""   
     
     def _build_prompt(self, feature: str, related_files: List[Dict], additional_info: str) -> str:
-        """构建提示词
+        """Build prompt
         
         Args:
-            feature: 功能描述
-            related_files: 相关文件列表
-            additional_info: 用户补充信息
+            feature: Feature description
+            related_files: Related files list
+            additional_info: User supplement information
             
         Returns:
-            str: 完整的提示词
+            str: Complete prompt
         """
         prompt = "You are a code modification expert who can generate modification plans based on requirements and relevant code snippets. I need your help to analyze how to implement the following feature:\n\n"
         prompt += f"{feature}\n\n"
@@ -49,37 +49,37 @@ class PlanGenerator:
     
     
     def generate_plan(self, feature: str, related_files: List[Dict]) -> Tuple[str, Dict[str,str]]:
-        """生成修改方案
+        """Generate modification plan
         
         Args:
-            feature: 功能描述
-            related_files: 相关文件列表
+            feature: Feature description
+            related_files: Related files list
             
         Returns:
-            Tuple[str, Dict[str,str]]: 修改方案，如果用户取消则返回 None
+            Tuple[str, Dict[str,str]]: Modification plan, return None if user cancels
         """
         additional_info = ""
         while True:
             prompt = self._build_prompt(feature, related_files, additional_info)
-            # 构建提示词
-            PrettyOutput.print("开始生成修改方案...", OutputType.PROGRESS)
+            # Build prompt
+            PrettyOutput.print("Start generating modification plan...", OutputType.PROGRESS)
             
-            # 获取修改方案
+            # Get modification plan
             raw_plan = PlatformRegistry.get_global_platform_registry().get_thinking_platform().chat_until_success(prompt)
             structed_plan = self._extract_code(raw_plan)
             if not structed_plan:
-                PrettyOutput.print("修改方案生成失败，请重试", OutputType.ERROR)
-                tmp = get_multiline_input("请输入您的补充意见或建议（直接回车取消）:")
+                PrettyOutput.print("Modification plan generation failed, please try again", OutputType.ERROR)
+                tmp = get_multiline_input("Please enter your additional information or suggestions (press Enter to cancel):")
                 if tmp == "__interrupt__" or prompt == "":
                     return "", {}
                 additional_info += tmp + "\n"
                 continue
-            user_input = input("\n是否同意这个修改方案？(y/n) [y]: ").strip().lower() or 'y'
+            user_input = input("\nDo you agree with this modification plan? (y/n) [y]: ").strip().lower() or 'y'
             if user_input == 'y' or user_input == '':
                 return raw_plan, structed_plan
             elif user_input == 'n':
-                # 获取用户反馈
-                tmp = get_multiline_input("请输入您的补充意见或建议（直接回车取消）:")
+                # Get user feedback
+                tmp = get_multiline_input("Please enter your additional information or suggestions (press Enter to cancel):")
                 if prompt == "__interrupt__" or prompt == "":
                     return "", {}
                 additional_info += tmp + "\n"
@@ -87,13 +87,13 @@ class PlanGenerator:
 
     
     def _extract_code(self, response: str) -> Dict[str, str]:
-        """从响应中提取代码
+        """Extract code from response
         
         Args:
-            response: 模型响应内容
+            response: Model response content
             
         Returns:
-            Dict[str, List[str]]: 代码字典，key为文件路径，value为代码片段列表
+            Dict[str, List[str]]: Code dictionary, key is file path, value is code snippet list
         """
         code_dict = {}
         for match in re.finditer(r'<PLAN>\n> (.+?)\n(.*?)\n</PLAN>', response, re.DOTALL):

jarvis/jarvis_platform/main.py

@@ -2,26 +2,26 @@ from jarvis.models.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType, load_env_from_file, get_multiline_input
 
 def list_platforms():
-    """列出所有支持的平台和模型"""
+    """List all supported platforms and models"""
     registry = PlatformRegistry.get_global_platform_registry()
     platforms = registry.get_available_platforms()
     
-    PrettyOutput.section("支持的平台和模型", OutputType.SUCCESS)
+    PrettyOutput.section("Supported platforms and models", OutputType.SUCCESS)
     
     for platform_name in platforms:
-        # 创建平台实例
+        # Create platform instance
         platform = registry.create_platform(platform_name)
         if not platform:
             continue
             
-        # 获取平台支持的模型列表
+        # Get the list of models supported by the platform
         try:
             models = platform.get_model_list()
             
-            # 打印平台名称
+            # Print platform name
             PrettyOutput.section(f"{platform_name}", OutputType.SUCCESS)
             
-            # 打印模型列表
+            # Print model list
             if models:
                 for model_name, description in models:
                     if description:
@@ -29,95 +29,95 @@ def list_platforms():
                     else:
                         PrettyOutput.print(f"  • {model_name}", OutputType.SUCCESS)
             else:
-                PrettyOutput.print("  没有可用的模型信息", OutputType.WARNING)
+                PrettyOutput.print("  • No available model information", OutputType.WARNING)
                 
         except Exception as e:
-            PrettyOutput.print(f"获取 {platform_name} 平台模型列表失败: {str(e)}", OutputType.WARNING)
+            PrettyOutput.print(f"Failed to get model list for {platform_name}: {str(e)}", OutputType.WARNING)
 
 def chat_with_model(platform_name: str, model_name: str):
-    """与指定平台和模型进行对话"""
+    """Chat with specified platform and model"""
     registry = PlatformRegistry.get_global_platform_registry()
     
-    # 创建平台实例
+    # Create platform instance
     platform = registry.create_platform(platform_name)
     if not platform:
-        PrettyOutput.print(f"创建平台 {platform_name} 失败", OutputType.ERROR)
+        PrettyOutput.print(f"Failed to create platform {platform_name}", OutputType.ERROR)
         return
     
     try:
-        # 设置模型
+        # Set model
         platform.set_model_name(model_name)
-        PrettyOutput.print(f"已连接到 {platform_name} 平台的 {model_name} 模型", OutputType.SUCCESS)
+        PrettyOutput.print(f"Connected to {platform_name} platform {model_name} model", OutputType.SUCCESS)
         
-        # 开始对话循环
+        # Start conversation loop
         while True:
-            # 获取用户输入
+            # Get user input
             user_input = get_multiline_input("")
             
-            # 检查是否取消输入
+            # Check if input is cancelled
             if user_input == "__interrupt__" or user_input.strip() == "/bye":
-                PrettyOutput.print("再见！", OutputType.SUCCESS)
+                PrettyOutput.print("Bye!", OutputType.SUCCESS)
                 break
                 
-            # 检查是否为空输入
+            # Check if input is empty
             if not user_input.strip():
                 continue
                 
-            # 检查是否为清除会话命令
+            # Check if it is a clear session command
             if user_input.strip() == "/clear":
                 try:
                     platform.delete_chat()
-                    platform.set_model_name(model_name)  # 重新初始化会话
-                    PrettyOutput.print("会话已清除", OutputType.SUCCESS)
+                    platform.set_model_name(model_name)  # Reinitialize session
+                    PrettyOutput.print("Session cleared", OutputType.SUCCESS)
                 except Exception as e:
-                    PrettyOutput.print(f"清除会话失败: {str(e)}", OutputType.ERROR)
+                    PrettyOutput.print(f"Failed to clear session: {str(e)}", OutputType.ERROR)
                 continue
                 
             try:
-                # 发送到模型并获取回复
+                # Send to model and get reply
                 response = platform.chat_until_success(user_input)
                 if not response:
-                    PrettyOutput.print("未获得有效回复", OutputType.WARNING)
+                    PrettyOutput.print("No valid reply", OutputType.WARNING)
                     
             except Exception as e:
-                PrettyOutput.print(f"对话失败: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to chat: {str(e)}", OutputType.ERROR)
                 
     except Exception as e:
-        PrettyOutput.print(f"初始化对话失败: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Failed to initialize conversation: {str(e)}", OutputType.ERROR)
     finally:
-        # 清理资源
+        # Clean up resources
         try:
             platform.delete_chat()
         except:
             pass
 
 def info_command(args):
-    """处理 info 子命令"""
+    """Process info subcommand"""
     list_platforms()
 
 def chat_command(args):
-    """处理 chat 子命令"""
+    """Process chat subcommand"""
     if not args.platform or not args.model:
-        PrettyOutput.print("请指定平台和模型。使用 'jarvis info' 查看可用的平台和模型。", OutputType.ERROR)
+        PrettyOutput.print("Please specify platform and model. Use 'jarvis info' to view available platforms and models.", OutputType.ERROR)
         return
     chat_with_model(args.platform, args.model)
 
 def main():
-    """主函数"""
+    """Main function"""
     import argparse
 
     load_env_from_file()
     
     parser = argparse.ArgumentParser(description='Jarvis AI Platform')
-    subparsers = parser.add_subparsers(dest='command', help='可用的子命令')
+    subparsers = parser.add_subparsers(dest='command', help='Available subcommands')
     
-    # info 子命令
-    info_parser = subparsers.add_parser('info', help='显示支持的平台和模型信息')
+    # info subcommand
+    info_parser = subparsers.add_parser('info', help='Display supported platforms and models information')
     
-    # chat 子命令
-    chat_parser = subparsers.add_parser('chat', help='与指定的平台和模型进行对话')
-    chat_parser.add_argument('--platform', '-p', help='指定要使用的平台')
-    chat_parser.add_argument('--model', '-m', help='指定要使用的模型')
+    # chat subcommand
+    chat_parser = subparsers.add_parser('chat', help='Chat with specified platform and model')
+    chat_parser.add_argument('--platform', '-p', help='Specify the platform to use')
+    chat_parser.add_argument('--model', '-m', help='Specify the model to use')
     
     args = parser.parse_args()