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

jarvis/jarvis_coder/plan_generator.py

@@ -1,49 +1,54 @@
-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:
     """修改方案生成器"""
     
-    def __init__(self):
-        """初始化
-        
-        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:
+    def _build_prompt(self, feature: str, related_files: List[Dict], additional_info: str) -> str:
         """构建提示词
         
         Args:
             feature: 功能描述
             related_files: 相关文件列表
-            user_feedback: 用户反馈信息
+            additional_info: 用户补充信息
             
         Returns:
             str: 完整的提示词
         """
-        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]]:
         """生成修改方案
         
         Args:
@@ -51,25 +56,48 @@ class PlanGenerator:
             related_files: 相关文件列表
             
         Returns:
-            str: 修改方案，如果用户取消则返回 None
+            Tuple[str, Dict[str,str]]: 修改方案，如果用户取消则返回 None
         """
-        prompt = self._build_prompt(feature, related_files)
+        additional_info = ""
         while True:
+            prompt = self._build_prompt(feature, related_files, additional_info)
             # 构建提示词
             PrettyOutput.print("开始生成修改方案...", OutputType.PROGRESS)
             
             # 获取修改方案
-            plan = while_success(lambda: self.thinking_model.chat(prompt), 5)
-            
-            user_input = input("\n是否同意这个修改方案？(y/n/f) [y]: ").strip().lower() or 'y'
-            if user_input == 'y':
-                return 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("请输入您的补充意见或建议（直接回车取消）:")
+                if tmp == "__interrupt__" or prompt == "":
+                    return "", {}
+                additional_info += tmp + "\n"
+                continue
+            user_input = input("\n是否同意这个修改方案？(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 
+                tmp = get_multiline_input("请输入您的补充意见或建议（直接回车取消）:")
+                if prompt == "__interrupt__" or prompt == "":
+                    return "", {}
+                additional_info += tmp + "\n"
+                continue 
+
+    
+    def _extract_code(self, response: str) -> Dict[str, str]:
+        """从响应中提取代码
+        
+        Args:
+            response: 模型响应内容
+            
+        Returns:
+            Dict[str, List[str]]: 代码字典，key为文件路径，value为代码片段列表
+        """
+        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

@@ -75,7 +75,7 @@ def chat_with_model(platform_name: str, model_name: str):
                 
             try:
                 # 发送到模型并获取回复
-                response = platform.chat(user_input)
+                response = platform.chat_until_success(user_input)
                 if not response:
                     PrettyOutput.print("未获得有效回复", OutputType.WARNING)
                     

jarvis/jarvis_rag/main.py

@@ -744,7 +744,7 @@ class RAGTool:
             
             # 获取模型实例并生成回答
             model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-            response = model.chat(prompt)
+            response = model.chat_until_success(prompt)
             
             return response
             

jarvis/jarvis_smart_shell/main.py

@@ -46,34 +46,34 @@ def process_request(request: str) -> Optional[str]:
         current_path = os.getcwd()
         
         # 设置系统提示
-        system_message = f"""你是一个 shell 命令生成助手。
+        system_message = f"""You are a shell command generation assistant.
 
-你的唯一任务是将用户的自然语言需求转换为对应的shell命令。
+Your only task is to convert user's natural language requirements into corresponding shell commands.
 
-严格要求：
-1. 只返回shell命令本身
-2. 不要添加任何标记（如```、/**/、//等）
-3. 不要添加任何解释或说明
-4. 不要添加任何换行或额外空格
-5. 如果需要多个命令，使用 && 连接
+Strict requirements:
+1. Only return the shell command itself
+2. Do not add any markers (like ```, /**/, // etc.)
+3. Do not add any explanations or descriptions
+4. Do not add any line breaks or extra spaces
+5. If multiple commands are needed, connect them with &&
 
-示例输入：
-"查找当前目录下的所有Python文件"
+Example input:
+"Find all Python files in the current directory"
 
-示例输出：
+Example output:
 find . -name "*.py"
 
-记住：只返回命令本身，不要有任何额外的内容。
+Remember: Only return the command itself, without any additional content.
 """
         model.set_system_message(system_message)
 
-        prefix = f"当前路径: {current_path}\n"
-        prefix += f"当前shell: {shell}\n"
+        prefix = f"Current path: {current_path}\n"
+        prefix += f"Current shell: {shell}\n"
         
         # 使用yaspin显示Thinking状态
         with yaspin(Spinners.dots, text="Thinking", color="yellow") as spinner:
             # 处理请求
-            result = model.chat(prefix + request)
+            result = model.chat_until_success(prefix + request)
             
             # 提取命令
             if result and isinstance(result, str):

jarvis/main.py

@@ -10,7 +10,7 @@ from prompt_toolkit import prompt
 
 from jarvis.models.registry import PlatformRegistry
 
-# 添加父目录到Python路径以支持导入
+# Add parent directory to Python path to support imports    
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from jarvis.agent import Agent
@@ -22,7 +22,7 @@ def load_tasks() -> dict:
     """Load tasks from .jarvis files in user home and current directory."""
     tasks = {}
     
-    # 检查用户目录下的 .jarvis
+    # Check .jarvis in user directory
     user_jarvis = os.path.expanduser("~/.jarvis")
     if os.path.exists(user_jarvis):
         try:
@@ -30,39 +30,39 @@ def load_tasks() -> dict:
                 user_tasks = yaml.safe_load(f)
                 
             if isinstance(user_tasks, dict):
-                # 验证并添加用户目录的任务
+                # Validate and add user directory tasks
                 for name, desc in user_tasks.items():
-                    if desc:  # 确保描述不为空
+                    if desc:  # Ensure description is not empty
                         tasks[str(name)] = str(desc)
             else:
                 PrettyOutput.print("Warning: ~/.jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
         except Exception as e:
             PrettyOutput.print(f"Error loading ~/.jarvis file: {str(e)}", OutputType.ERROR)
     
-    # 检查当前目录下的 .jarvis
+    # Check .jarvis in current directory
     if os.path.exists(".jarvis"):
         try:
             with open(".jarvis", "r", encoding="utf-8") as f:
                 local_tasks = yaml.safe_load(f)
                 
             if isinstance(local_tasks, dict):
-                # 验证并添加当前目录的任务，如果有重名则覆盖用户目录的任务
+                # Validate and add current directory tasks, overwrite user directory tasks if there is a name conflict
                 for name, desc in local_tasks.items():
-                    if desc:  # 确保描述不为空
+                    if desc:  # Ensure description is not empty
                         tasks[str(name)] = str(desc)
             else:
                 PrettyOutput.print("Warning: .jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
         except Exception as e:
             PrettyOutput.print(f"Error loading .jarvis file: {str(e)}", OutputType.ERROR)
 
-    # 读取方法论
+    # Read methodology
     method_path = os.path.expanduser("~/.jarvis_methodology")
     if os.path.exists(method_path):
         with open(method_path, "r", encoding="utf-8") as f:
             methodology = yaml.safe_load(f)
         if isinstance(methodology, dict):
             for name, desc in methodology.items():
-                tasks[f"执行方法论：{str(name)}\n {str(desc)}" ] = str(desc)
+                tasks[f"Run Methodology: {str(name)}\n {str(desc)}" ] = str(desc)
     
     return tasks
 
@@ -77,13 +77,13 @@ def select_task(tasks: dict) -> str:
     PrettyOutput.print("\nAvailable tasks:", OutputType.INFO)
     for i, name in enumerate(task_names, 1):
         PrettyOutput.print(f"[{i}] {name}", OutputType.INFO)
-    PrettyOutput.print("[0] 跳过预定义任务", OutputType.INFO)
+    PrettyOutput.print("[0] Skip predefined tasks", OutputType.INFO)
     
     
     while True:
         try:
             choice = prompt(
-                "\n请选择一个任务编号(0跳过): ",
+                "\nPlease select a task number (0 to skip): ",
             ).strip()
             
             if not choice:
@@ -103,16 +103,16 @@ def select_task(tasks: dict) -> str:
         except EOFError:
             return ""  # Return empty on Ctrl+D
         except Exception as e:
-            PrettyOutput.print(f"选择失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to select task: {str(e)}", OutputType.ERROR)
             continue
 
 def main():
-    """Jarvis 的主入口点"""
-    # 添加参数解析器
+    """Jarvis main entry point"""
+    # Add argument parser
     load_env_from_file()
-    parser = argparse.ArgumentParser(description='Jarvis AI 助手')
-    parser.add_argument('-f', '--files', nargs='*', help='要处理的文件列表')
-    parser.add_argument('--keep-history', action='store_true', help='保持聊天历史(不删除会话)')
+    parser = argparse.ArgumentParser(description='Jarvis AI assistant')
+    parser.add_argument('-f', '--files', nargs='*', help='List of files to process')
+    parser.add_argument('--keep-history', action='store_true', help='Keep chat history (do not delete session)')
     args = parser.parse_args()
 
     try:
@@ -121,32 +121,32 @@ def main():
 
         # 如果用户传入了模型参数，则更换当前模型为用户指定的模型
 
-        # 欢迎信息
-        PrettyOutput.print(f"Jarvis 已初始化 - With {agent.model.name()}", OutputType.SYSTEM)
+        # Welcome information
+        PrettyOutput.print(f"Jarvis initialized - With {agent.model.name()}", OutputType.SYSTEM)
         if args.keep_history:
-            PrettyOutput.print("已启用历史保留模式", OutputType.INFO)
+            PrettyOutput.print("History preservation mode enabled", OutputType.INFO)
         
         # 加载预定义任务
         tasks = load_tasks()
         if tasks:
             selected_task = select_task(tasks)
             if selected_task:
-                PrettyOutput.print(f"\n执行任务: {selected_task}", OutputType.INFO)
+                PrettyOutput.print(f"\nExecute task: {selected_task}", OutputType.INFO)
                 agent.run(selected_task, args.files)
                 return 0
         
         # 如果没有选择预定义任务，进入交互模式
         while True:
             try:
-                user_input = get_multiline_input("请输入您的任务(输入空行退出):")
+                user_input = get_multiline_input("Please enter your task (input empty line to exit):")
                 if not user_input or user_input == "__interrupt__":
                     break
                 agent.run(user_input, args.files)
             except Exception as e:
-                PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Error: {str(e)}", OutputType.ERROR)
 
     except Exception as e:
-        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Initialization error: {str(e)}", OutputType.ERROR)
         return 1
 
     return 0

jarvis/models/ai8.py

@@ -26,16 +26,16 @@ class AI8Model(BasePlatform):
 
         self.token = os.getenv("AI8_API_KEY")
         if not self.token:
-            PrettyOutput.print("AI8_API_KEY未设置", OutputType.WARNING)
+            PrettyOutput.print("AI8_API_KEY is not set", OutputType.WARNING)
         
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
         if self.model_name not in self.get_available_models():
-            PrettyOutput.print(f"警告: 当前选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING)
+            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
         
 
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
 
         self.model_name = model_name
             
@@ -59,12 +59,12 @@ class AI8Model(BasePlatform):
             )
             
             if response.status_code != 200:
-                PrettyOutput.print(f"创建会话失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to create session: {response.status_code}", OutputType.ERROR)
                 return False
             
             data = response.json()
             if data['code'] != 0:
-                PrettyOutput.print(f"创建会话失败: {data.get('msg', '未知错误')}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to create session: {data.get('msg', 'Unknown error')}", OutputType.ERROR)
                 return False
             
             self.conversation = data['data']
@@ -92,14 +92,14 @@ class AI8Model(BasePlatform):
                     self.conversation = data['data']
                     return True
                 else:
-                    PrettyOutput.print(f"更新会话设置失败: {data.get('msg', '未知错误')}", OutputType.ERROR)
+                    PrettyOutput.print(f"Failed to update session settings: {data.get('msg', 'Unknown error')}", OutputType.ERROR)
                     return False
             else:
-                PrettyOutput.print(f"更新会话设置失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to update session settings: {response.status_code}", OutputType.ERROR)
                 return False
             
         except Exception as e:
-            PrettyOutput.print(f"创建会话异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to create session: {str(e)}", OutputType.ERROR)
             return False
         
     def upload_files(self, file_list: List[str]) -> List[Dict]:
@@ -119,7 +119,7 @@ class AI8Model(BasePlatform):
         self.system_message = message
         
     def chat(self, message: str) -> str:
-        """执行对话"""
+        """Execute conversation"""
         try:
             
             # 确保有会话ID
@@ -160,7 +160,7 @@ class AI8Model(BasePlatform):
             )
             
             if response.status_code != 200:
-                error_msg = f"聊天请求失败: {response.status_code}"
+                error_msg = f"Failed to chat: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 raise Exception(error_msg)
             
@@ -188,7 +188,7 @@ class AI8Model(BasePlatform):
             return full_response
             
         except Exception as e:
-            PrettyOutput.print(f"聊天异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Chat exception: {str(e)}", OutputType.ERROR)
             raise e
             
     def name(self) -> str:
@@ -227,23 +227,23 @@ class AI8Model(BasePlatform):
                     self.reset()
                     return True
                 else:
-                    error_msg = f"删除会话失败: {data.get('msg', '未知错误')}"
+                    error_msg = f"Failed to delete session: {data.get('msg', 'Unknown error')}"
                     PrettyOutput.print(error_msg, OutputType.ERROR)
                     return False
             else:
-                error_msg = f"删除会话请求失败: {response.status_code}"
+                error_msg = f"Failed to delete session request: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 return False
             
         except Exception as e:
-            PrettyOutput.print(f"删除会话异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to delete session: {str(e)}", OutputType.ERROR)
             return False
         
     def get_available_models(self) -> List[str]:
-        """获取可用的模型列表
+        """Get available model list
         
         Returns:
-            List[str]: 可用模型名称列表
+            List[str]: Available model name list
         """
         try:
             if self.models:
@@ -264,12 +264,12 @@ class AI8Model(BasePlatform):
             )
             
             if response.status_code != 200:
-                PrettyOutput.print(f"获取模型列表失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to get model list: {response.status_code}", OutputType.ERROR)
                 return []
             
             data = response.json()
             if data['code'] != 0:
-                PrettyOutput.print(f"获取模型列表失败: {data.get('msg', '未知错误')}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to get model list: {data.get('msg', 'Unknown error')}", OutputType.ERROR)
                 return []
             
             # 保存模型信息
@@ -292,11 +292,11 @@ class AI8Model(BasePlatform):
                 # 添加特性标记
                 features = []
                 if model['attr'].get('multimodal'):
-                    features.append("多模态")
+                    features.append("Multimodal")
                 if model['attr'].get('plugin'):
-                    features.append("插件支持")
+                    features.append("Plugin support")
                 if model['attr'].get('onlyImg'):
-                    features.append("图像支持")
+                    features.append("Image support")
                 if features:
                     model_str += f" [{'|'.join(features)}]"
                     
@@ -308,6 +308,6 @@ class AI8Model(BasePlatform):
             return list(self.models.keys())
             
         except Exception as e:
-            PrettyOutput.print(f"获取模型列表异常: {str(e)}", OutputType.WARNING)
+            PrettyOutput.print(f"Failed to get model list: {str(e)}", OutputType.WARNING)
             return []
         

jarvis/models/base.py

@@ -1,59 +1,63 @@
 from abc import ABC, abstractmethod
 from typing import Dict, List, Tuple
 
+from jarvis.utils import OutputType, PrettyOutput, while_success, while_true
+
 
 class BasePlatform(ABC):
-    """大语言模型基类"""
+    """Base class for large language models"""
     
     def __init__(self):
-        """初始化模型"""
+        """Initialize model"""
         self.suppress_output = False  # 添加输出控制标志
-        pass
 
     def __del__(self):
-        """销毁模型"""
+        """Destroy model"""
         self.delete_chat()
 
     @abstractmethod
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
         raise NotImplementedError("set_model_name is not implemented")
         
     @abstractmethod
     def chat(self, message: str) -> str:
-        """执行对话"""
+        """Execute conversation"""
         raise NotImplementedError("chat is not implemented")
 
+    def chat_until_success(self, message: str) -> str:
+        return while_true(lambda: while_success(lambda: self.chat(message), 5), 5)
+
     @abstractmethod
     def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """上传文件"""
+        """Upload files"""
         raise NotImplementedError("upload_files is not implemented")
 
     @abstractmethod
     def reset(self):
-        """重置模型"""
+        """Reset model"""
         raise NotImplementedError("reset is not implemented")
         
     @abstractmethod
     def name(self) -> str:
-        """模型名称"""
+        """Model name"""
         raise NotImplementedError("name is not implemented")
     
     @abstractmethod
     def delete_chat(self)->bool:
-        """删除对话"""
+        """Delete chat"""
         raise NotImplementedError("delete_chat is not implemented")
     
     @abstractmethod
     def set_system_message(self, message: str):
-        """设置系统消息"""
+        """Set system message"""
         raise NotImplementedError("set_system_message is not implemented")
     
     @abstractmethod
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """获取模型列表"""
+        """Get model list"""
         raise NotImplementedError("get_model_list is not implemented")
 
     def set_suppress_output(self, suppress: bool):
-        """设置是否屏蔽输出"""
+        """Set whether to suppress output"""
         self.suppress_output = suppress