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

jarvis/jarvis_coder/plan_generator.py

@@ -1,75 +1,103 @@
-from typing import Dict, List, Optional
+import re
+from typing import Dict, List, Tuple
 from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, while_success
-from jarvis.models.base import BasePlatform
+from jarvis.utils import PrettyOutput, OutputType, get_multiline_input
 
 class PlanGenerator:
-    """修改方案生成器"""
+    """Modification plan generator"""   
     
-    def __init__(self):
-        """初始化
+    def _build_prompt(self, feature: str, related_files: List[Dict], additional_info: str) -> str:
+        """Build prompt
         
         Args:
-            thinking_model: 用于思考的大模型
-        """
-        self.thinking_model = PlatformRegistry.get_global_platform_registry().get_thinking_platform()
-    
-    def _build_prompt(self, feature: str, related_files: List[Dict]) -> str:
-        """构建提示词
-        
-        Args:
-            feature: 功能描述
-            related_files: 相关文件列表
-            user_feedback: 用户反馈信息
+            feature: Feature description
+            related_files: Related files list
+            additional_info: User supplement information
             
         Returns:
-            str: 完整的提示词
+            str: Complete prompt
         """
-        prompt = "我需要你帮我分析如何实现以下功能:\n\n"
+        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"
                 
-        prompt += "以下是相关的代码文件片段:\n\n"
+        prompt += "Here are the relevant code file snippets:\n\n"
         
         for file in related_files:
-            prompt += f"文件: {file['file_path']}\n"
+            prompt += f"File: {file['file_path']}\n"
             for part in file["parts"]:
                 prompt += f"<PART>\n{part}\n</PART>\n"
         
-        prompt += "\n请详细说明需要做哪些修改来实现这个功能。包括:\n"
-        prompt += "1. 需要修改哪些文件\n"
-        prompt += "2. 每个文件需要做什么修改\n"
-        prompt += "3. 修改的主要逻辑和原因\n"
-        prompt += "4. 不要生成具体的代码，只需要生成修改方案\n"
+        prompt += "\nPlease provide detailed modifications needed to implement this feature. Include:\n"
+        prompt += "1. Which files need to be modified\n"
+        prompt += "2. How to modify each file, no explanation needed\n"
+        prompt += "3. Don't assume other files or code exist, only generate modification plans based on provided file contents and description\n"
+        prompt += "4. Don't implement features outside the requirement\n"
+        prompt += "5. Output only one modification plan per file (can be multiple lines)\n"
+        prompt += "6. Output format as follows:\n"
+        prompt += "<PLAN>\n"
+        prompt += "> path/to/file1\n"
+        prompt += "modification plan\n"
+        prompt += "</PLAN>\n"
+        prompt += "<PLAN>\n"
+        prompt += "> path/to/file2\n"
+        prompt += "modification plan\n"
+        prompt += "</PLAN>\n"
+        if additional_info:
+            prompt += f"# Additional information:\n{additional_info}\n"
         
         return prompt
     
-    def generate_plan(self, feature: str, related_files: List[Dict]) -> str:
-        """生成修改方案
+    
+    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:
-            str: 修改方案，如果用户取消则返回 None
+            Tuple[str, Dict[str,str]]: Modification plan, return None if user cancels
         """
-        prompt = self._build_prompt(feature, related_files)
+        additional_info = ""
         while True:
-            # 构建提示词
-            PrettyOutput.print("开始生成修改方案...", OutputType.PROGRESS)
-            
-            # 获取修改方案
-            plan = while_success(lambda: self.thinking_model.chat(prompt), 5)
+            prompt = self._build_prompt(feature, related_files, additional_info)
+            # Build prompt
+            PrettyOutput.print("Start generating modification plan...", OutputType.PROGRESS)
             
-            user_input = input("\n是否同意这个修改方案？(y/n/f) [y]: ").strip().lower() or 'y'
-            if user_input == 'y':
-                return plan
+            # 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("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("\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':
-                return ""
-            else:  # 'f' - feedback
-                # 获取用户反馈
-                prompt = get_multiline_input("请输入您的补充意见或建议:")
-                if prompt == "__interrupt__":
-                    return ""
-                prompt = f"用户补充反馈：\n{prompt}\n\n请重新生成完整方案"
-                continue 
+                # 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"
+                continue 
+
+    
+    def _extract_code(self, response: str) -> Dict[str, str]:
+        """Extract code from response
+        
+        Args:
+            response: Model response content
+            
+        Returns:
+            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):
+            file_path = match.group(1)
+            code_part = match.group(2)
+            code_dict[file_path] = code_part
+        return code_dict

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:
-                # 发送到模型并获取回复
-                response = platform.chat(user_input)
+                # 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()