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

jarvis/jarvis_coder/patch_handler.py

@@ -1,10 +1,13 @@
 import re
 import os
 from typing import List, Tuple, Dict
+import yaml
+from pathlib import Path
 
+from jarvis.jarvis_coder.git_utils import generate_commit_message, init_git_repo, save_edit_record
 from jarvis.models.base import BasePlatform
 from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, while_success
+from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, get_single_line_input, while_success
 
 class Patch:
     def __init__(self, old_code: str, new_code: str):
@@ -12,16 +15,41 @@ class Patch:
         self.new_code = new_code
 
 class PatchHandler:
+    def __init__(self):
+        self.prompt_file = Path.home() / ".jarvis-coder-patch-prompt"
+        self.additional_info = self._load_additional_info()
+        self.root_dir = init_git_repo(os.getcwd())
+        self.record_dir = os.path.join(self.root_dir, ".jarvis-coder", "record")
+        if not os.path.exists(self.record_dir):
+            os.makedirs(self.record_dir)
+    def _load_additional_info(self) -> str:
+        """Load saved additional info from prompt file"""
+        if not self.prompt_file.exists():
+            return ""
+        try:
+            with open(self.prompt_file, 'r') as f:
+                data = yaml.safe_load(f)
+                return data.get('additional_info', '') if data else ''
+        except Exception as e:
+            PrettyOutput.print(f"Failed to load additional info: {e}", OutputType.WARNING)
+            return ""
 
+    def _save_additional_info(self, info: str):
+        """Save additional info to prompt file"""
+        try:
+            with open(self.prompt_file, 'w') as f:
+                yaml.dump({'additional_info': info}, f)
+        except Exception as e:
+            PrettyOutput.print(f"Failed to save additional info: {e}", OutputType.WARNING)
 
     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 +60,53 @@ 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 = get_single_line_input(f"Accept {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 _finalize_changes(self) -> None:
+        """Complete changes and commit"""
+        PrettyOutput.print("Modification confirmed, committing...", OutputType.INFO)
+
+        # Add only modified files under git control
+        os.system("git add -u")
+        
+        # Then get git diff
+        git_diff = os.popen("git diff --cached").read()
+        
+        # Automatically generate commit information, pass in feature
+        commit_message = generate_commit_message(git_diff)
+        
+        # Display and confirm commit information
+        PrettyOutput.print(f"Automatically generated commit information: {commit_message}", OutputType.INFO)
+        user_confirm = get_single_line_input("Use this commit information? (y/n) [y]").lower() or "y"
+        
+        if user_confirm.lower() != "y":
+            commit_message = get_single_line_input("Please enter a new commit information")
+        
+        # No need to git add again, it has already been added
+        os.system(f"git commit -m '{commit_message}'")
+        save_edit_record(self.record_dir, commit_message, git_diff)
+
+    def _revert_changes(self) -> None:
+        """Revert all changes"""
+        PrettyOutput.print("Modification cancelled, reverting changes", OutputType.INFO)
+        os.system(f"git reset --hard")
+        os.system(f"git clean -df")
 
     
     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 +114,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,28 +135,36 @@ 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]:
+        choice = get_single_line_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("请输入补充说明和要求:")
+            
+        feedback = get_multiline_input("Please enter additional information and requirements:")
+        if feedback:
+            save_prompt = get_single_line_input("Would you like to save this as general feedback for future patches? (y/n) [n]: ").lower() or "n"
+            if save_prompt == "y":
+                self._save_additional_info(feedback)
+                PrettyOutput.print("Feedback saved for future use", OutputType.SUCCESS)
+            
+        return "continue", feedback
 
-    def apply_patch(self, feature: str, raw_plan: str, structed_plan: Dict[str, str]) -> Tuple[bool, str]:
-        """应用补丁（主入口）"""
+    def apply_patch(self, feature: str, structed_plan: Dict[str, str]) -> bool:
+        """Apply patch (main entry)"""
         for file_path, current_plan in structed_plan.items():
-            additional_info = ""            
+            additional_info = self.additional_info  # Initialize with saved info
             while True:
                 
                 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
@@ -114,16 +182,17 @@ class PatchHandler:
                         2. old_code will be replaced with new_code, pay attention to context continuity
                         3. Avoid breaking existing code logic when generating patches, e.g., don't insert function definitions inside existing function bodies
                         4. Include sufficient context to avoid ambiguity
-                        5. Patches will be merged using file_content.replace(patch.old_code, patch.new_code, 1), so old_code and new_code need to match exactly, including empty lines, line breaks, whitespace, tabs, and comments
+                        5. Patches will be merged using file_content.replace(patch.old_code, patch.new_code, 1), so old_code and new_code need to match exactly, including EMPTY LINES, LINE BREAKS, WHITESPACE, TABS, and COMMENTS
                         6. Ensure generated code has correct format (syntax, indentation, line breaks)
                         7. Ensure new_code's indentation and format matches old_code
                         8. Ensure code is inserted in appropriate locations, e.g., code using variables should be after declarations/definitions
                         9. Provide at least 3 lines of context before and after modified code for location
+                        10. Each patch should be no more than 20 lines of code, if it is more than 20 lines, split it into multiple patches
+                        11. old code's line breaks should be consistent with the original code
 
 
                         """
                 prompt += f"""# Original requirement: {feature}
-                    # Complete modification plan: {raw_plan}
                     # Current file path: {file_path}
                     # Current file content:
                     <CONTENT>
@@ -135,57 +204,58 @@ 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)
-                        return False, msg
+                        PrettyOutput.print("Terminate patch application", OutputType.WARNING)
+                        return False
                     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"
                         continue
                 else:
+                    self._finalize_changes()
                     break
         
-        return True, ""
+        return True
 
 
 
-    def handle_patch_application(self, feature: str, raw_plan: str, structed_plan: Dict[str,str]) -> bool:
-        """处理补丁应用流程
+    def handle_patch_application(self, feature: 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. 应用补丁
-        success, error_msg = self.apply_patch(feature, raw_plan, structed_plan)
+            PrettyOutput.print(f"\nFile: {file_path}", OutputType.INFO)
+            PrettyOutput.print(f"Modification plan: \n{patches_code}", OutputType.INFO)
+        # 3. Apply patches
+        success = self.apply_patch(feature, 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 = get_single_line_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

@@ -1,21 +1,21 @@
 import re
 from typing import Dict, List, Tuple
 from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType, get_multiline_input
+from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, get_single_line_input, is_long_context
 
 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"
@@ -48,52 +48,94 @@ class PlanGenerator:
         return prompt
     
     
-    def generate_plan(self, feature: str, related_files: List[Dict]) -> Tuple[str, Dict[str,str]]:
-        """生成修改方案
+    @staticmethod
+    def get_key_code(files: List[str], feature: str)->List[Dict[str, List[str]]]:
+        """Extract relevant key code snippets from files"""
+        ret = []
+        for file in files:
+            PrettyOutput.print(f"Analyzing file: {file}", OutputType.INFO)
+            model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
+            model.set_suppress_output(True)
+            file_path = file
+            content = open(file_path, "r", encoding="utf-8").read()
+
+            try:
+                prompt = f"""You are a code analysis expert who can extract relevant snippets from code.
+Please return in the following format:
+<PART>
+content
+</PART>
+
+Multiple snippets can be returned. If the file content is not relevant to the requirement, return empty.
+
+Requirement: {feature}
+File path: {file_path}
+Code content:
+{content}
+"""
+
+                # 调用大模型进行分析
+                response = model.chat_until_success(prompt)
+
+                parts = re.findall(r'<PART>\n(.*?)\n</PART>', response, re.DOTALL)
+                ret.append({"file_path": file, "parts": parts})
+            except Exception as e:
+                PrettyOutput.print(f"Failed to analyze file: {str(e)}", OutputType.ERROR)
+        return ret
+    
+    def generate_plan(self, feature: str, related_files: List[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 = ""
+        file_info = []
+        if is_long_context(related_files):
+            file_info =  PlanGenerator.get_key_code(related_files, feature)
+        else:
+            for file in related_files:
+                file_info.append({"file_path": file, "parts": [open(file, "r", encoding="utf-8").read()]})
+
         while True:
-            prompt = self._build_prompt(feature, related_files, additional_info)
-            # 构建提示词
-            PrettyOutput.print("开始生成修改方案...", OutputType.PROGRESS)
+            prompt = self._build_prompt(feature, file_info, additional_info)
+            # 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 "", {}
+                    return {}
                 additional_info += tmp + "\n"
                 continue
-            user_input = input("\n是否同意这个修改方案？(y/n) [y]: ").strip().lower() or 'y'
+            user_input = get_single_line_input("Do 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
+                return 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 "", {}
+                    return {}
                 additional_info += tmp + "\n"
                 continue 
 
     
     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()