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

jarvis/tools/search.py

@@ -58,26 +58,26 @@ def bing_search(query):
             return summaries
             
     except Exception as error:
-        PrettyOutput.print(f"搜索出错: {str(error)}", OutputType.ERROR)
+        PrettyOutput.print(f"Search error: {str(error)}", OutputType.ERROR)
         return None
 
 class SearchTool:
     name = "search"
-    description = "使用Bing搜索引擎搜索信息，并根据问题提取关键信息"
+    description = "Use Bing search engine to search for information, and extract key information based on the question"
     parameters = {
         "type": "object",
         "properties": {
             "query": {
                 "type": "string",
-                "description": "搜索关键词"
+                "description": "Search keywords"
             },
             "question": {
                 "type": "string",
-                "description": "需要回答的具体问题，用于从搜索结果中提取相关信息"
+                "description": "Specific question to answer, used to extract relevant information from search results"
             },
             "max_results": {
                 "type": "integer",
-                "description": "最大搜索结果数量",
+                "description": "Maximum number of search results",
                 "default": 3
             }
         },
@@ -85,12 +85,12 @@ class SearchTool:
     }
 
     def __init__(self):
-        """初始化搜索工具，需要传入语言模型用于信息提取"""
+        """Initialize the search tool, need to pass in the language model for information extraction"""
         self.model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
         self.webpage_tool = WebpageTool()
 
     def _search(self, query: str, max_results: int) -> List[Dict]:
-        """执行搜索请求"""
+        """Execute search request"""
         try:
             results = bing_search(query)
             if not results:
@@ -106,76 +106,76 @@ class SearchTool:
                 })
             return formatted_results
         except Exception as e:
-            PrettyOutput.print(f"搜索请求失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Search request failed: {str(e)}", OutputType.ERROR)
             return []
 
     def _extract_info(self, contents: List[str], question: str) -> str:
-        """使用语言模型从网页内容中提取关键信息"""
-        prompt = f"""请根据以下搜索结果内容，回答问题：{question}
+        """Use language model to extract key information from web content"""
+        prompt = f"""Please answer the question based on the following search results: {question}
 
-搜索结果内容：
+Search results content:
 {'-' * 40}
 {''.join(contents)}
 {'-' * 40}
 
-请提供一个简洁、准确的答案，重点关注与问题直接相关的信息。如果搜索结果中没有相关信息，请明确说明。
-回答时注意：
-1. 保持客观性，只基于搜索结果提供信息
-2. 如果不同来源有冲突，请指出差异
-3. 适当引用信息来源
-4. 如果信息不完整或不确定，请说明"""
+Please provide a concise and accurate answer, focusing on information directly related to the question. If there is no relevant information in the search results, please clearly state that.
+When answering, pay attention to:
+1. Maintain objectivity, providing information based solely on search results
+2. If there are conflicts between different sources, point out the differences
+3. Appropriately cite information sources
+4. If the information is incomplete or uncertain, please explain"""
 
         try:
-            response = self.model.chat(prompt)
+            response = self.model.chat_until_success(prompt)
             return response
         except Exception as e:
-            return f"信息提取失败: {str(e)}"
+            return f"Information extraction failed: {str(e)}"
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行搜索并提取信息"""
+        """Execute search and extract information"""
         try:
             query = args["query"]
             question = args["question"]
             max_results = args.get("max_results", 3)
             
-            # 打印搜索信息
-            PrettyOutput.print(f"搜索查询: {query}", OutputType.INFO)
-            PrettyOutput.print(f"相关问题: {question}", OutputType.INFO)
+            # Print search information
+            PrettyOutput.print(f"Search query: {query}", OutputType.INFO)
+            PrettyOutput.print(f"Related question: {question}", OutputType.INFO)
             
             # 获取搜索结果
             results = self._search(query, max_results)
             if not results:
                 return {
                     "success": False,
-                    "error": "未能获取任何搜索结果"
+                    "error": "No search results found"
                 }
             
             # 收集网页内容
             contents = []
             for i, result in enumerate(results, 1):
                 try:
-                    PrettyOutput.print(f"正在读取第 {i}/{len(results)} 个结果... {result['title']} - {result['href']}", OutputType.PROGRESS)
+                    PrettyOutput.print(f"Reading result {i}/{len(results)}... {result['title']} - {result['href']}", OutputType.PROGRESS)
                     webpage_result = self.webpage_tool.execute({"url": result["href"]})
                     if webpage_result["success"]:
-                        contents.append(f"\n来源 {i}：{result['href']}\n")
+                        contents.append(f"\nSource {i}: {result['href']}\n")
                         contents.append(webpage_result["stdout"])
                 except Exception as e:
-                    PrettyOutput.print(f"读取结果 {i} 失败: {str(e)}", OutputType.WARNING)
+                    PrettyOutput.print(f"Failed to read result {i}: {str(e)}", OutputType.WARNING)
                     continue
             
             if not contents:
                 return {
                     "success": False,
-                    "error": "未能获取任何有效的搜索结果"
+                    "error": "No valid search results found"
                 }
             
-            # 提取信息
-            PrettyOutput.print("正在分析搜索结果...", OutputType.PROGRESS)
+            # Extract information
+            PrettyOutput.print("Analyzing search results...", OutputType.PROGRESS)
             analysis = self._extract_info(contents, question)
             
             return {
                 "success": True,
-                "stdout": f"搜索分析结果：\n\n{analysis}",
+                "stdout": f"Search analysis results:\n\n{analysis}",
                 "stderr": ""
             }
 
@@ -190,22 +190,22 @@ def main():
     import argparse
     import sys
     
-    parser = argparse.ArgumentParser(description='Bing搜索工具')
-    parser.add_argument('query', help='搜索关键词')
-    parser.add_argument('--max', type=int, default=5, help='最大结果数量(默认5)')
-    parser.add_argument('--url-only', action='store_true', help='只显示URL')
+    parser = argparse.ArgumentParser(description='Bing search tool')
+    parser.add_argument('query', help='Search keywords')
+    parser.add_argument('--max', type=int, default=5, help='Maximum number of results (default 5)')
+    parser.add_argument('--url-only', action='store_true', help='Only display URL')
     args = parser.parse_args()
     
     try:
-        PrettyOutput.print(f"正在搜索: {args.query}", OutputType.INFO)
+        PrettyOutput.print(f"Searching: {args.query}", OutputType.INFO)
         
         results = bing_search(args.query)
         
         if not results:
-            PrettyOutput.print("未找到搜索结果", OutputType.WARNING)
+            PrettyOutput.print("No search results found", OutputType.WARNING)
             sys.exit(1)
             
-        PrettyOutput.print(f"\n找到 {len(results)} 条结果:", OutputType.INFO)
+        PrettyOutput.print(f"\nFound {len(results)} results:", OutputType.INFO)
         
         for i, result in enumerate(results[:args.max], 1):
             PrettyOutput.print(f"\n{'-'*50}", OutputType.INFO)
@@ -213,15 +213,15 @@ def main():
                 PrettyOutput.print(f"{i}. {result['href']}", OutputType.INFO)
             else:
                 PrettyOutput.print(f"{i}. {result['title']}", OutputType.INFO)
-                PrettyOutput.print(f"链接: {result['href']}", OutputType.INFO)
+                PrettyOutput.print(f"Link: {result['href']}", OutputType.INFO)
                 if result['abstract']:
-                    PrettyOutput.print(f"摘要: {result['abstract']}", OutputType.INFO)
+                    PrettyOutput.print(f"Abstract: {result['abstract']}", OutputType.INFO)
                     
     except KeyboardInterrupt:
-        PrettyOutput.print("\n搜索已取消", OutputType.WARNING)
+        PrettyOutput.print("\nSearch cancelled", OutputType.WARNING)
         sys.exit(1)
     except Exception as e:
-        PrettyOutput.print(f"执行出错: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Execution error: {str(e)}", OutputType.ERROR)
         sys.exit(1)
 
 if __name__ == "__main__":

jarvis/tools/shell.py

@@ -8,7 +8,7 @@ from jarvis.utils import OutputType, PrettyOutput
 
 class ShellTool:
     name = "execute_shell"
-    description = """执行shell命令并返回结果"""
+    description = """Execute shell command and return result"""
 
     parameters = {
         "type": "object",
@@ -23,41 +23,41 @@ class ShellTool:
 
 
     def _escape_command(self, cmd: str) -> str:
-        """转义命令中的特殊字符"""
+        """Escape special characters in command"""
         return cmd.replace("'", "'\"'\"'")
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行shell命令"""
+        """Execute shell command"""
         try:
             command = args["command"]
             
-            # 生成临时文件名
+            # Generate temporary file name
             output_file = os.path.join(tempfile.gettempdir(), f"jarvis_shell_{os.getpid()}.log")
             
-            # 转义命令中的特殊字符
+            # Escape special characters in command
             escaped_command = self._escape_command(command)
             
-            # 修改命令以使用script
+            # Modify command to use script
             tee_command = f"script -q -c '{escaped_command}' {output_file}"
             
-            PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
+            PrettyOutput.print(f"Execute command: {command}", OutputType.INFO)
             
-            # 执行命令
+            # Execute command
             return_code = os.system(tee_command)
             
-            # 读取输出文件
+            # Read output file
             try:
                 with open(output_file, 'r', encoding='utf-8', errors='replace') as f:
                     output = f.read()
-                    # 移除script命令添加的头尾
+                    # Remove header and footer added by script
                     if output:
                         lines = output.splitlines()
                         if len(lines) > 2:
                             output = "\n".join(lines[1:-1])
             except Exception as e:
-                output = f"读取输出文件失败: {str(e)}"
+                output = f"Failed to read output file: {str(e)}"
             finally:
-                # 清理临时文件
+                # Clean up temporary file
                 Path(output_file).unlink(missing_ok=True)
             
             return {
@@ -68,7 +68,7 @@ class ShellTool:
             }
                 
         except Exception as e:
-            # 确保清理临时文件
+            # Ensure temporary file is cleaned up
             if 'output_file' in locals():
                 Path(output_file).unlink(missing_ok=True)
             PrettyOutput.print(str(e), OutputType.ERROR)

jarvis/tools/sub_agent.py

@@ -7,32 +7,32 @@ from jarvis.utils import OutputType, PrettyOutput
 
 class SubAgentTool:
     name = "create_sub_agent"
-    description = "创建一个子代理来处理特定任务，子代理会生成任务总结报告"
+    description = "Create a sub-agent to handle specific tasks, the sub-agent will generate a task summary report"
     parameters = {
         "type": "object",
         "properties": {
             "agent_name": {
                 "type": "string",
-                "description": "子代理的名称"
+                "description": "Sub-agent name"
             },
             "task": {
                 "type": "string",
-                "description": "需要完成的具体任务"
+                "description": "Specific task to complete"
             },
             "context": {
                 "type": "string",
-                "description": "任务相关的上下文信息",
+                "description": "Context information related to the task",
                 "default": ""
             },
             "goal": {
                 "type": "string",
-                "description": "任务的完成目标",
+                "description": "Completion goal of the task",
                 "default": ""
             },
             "files": {
                 "type": "array",
                 "items": {"type": "string"},
-                "description": "相关文件路径列表，用于文件问答和处理",
+                "description": "Related file path list, used for file question answering and processing",
                 "default": []
             }
         },
@@ -41,7 +41,7 @@ class SubAgentTool:
 
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """创建并运行子代理"""
+        """Create and run sub-agent"""
         try:
             agent_name = args["agent_name"]
             task = args["task"]
@@ -49,28 +49,28 @@ class SubAgentTool:
             goal = args.get("goal", "")
             files = args.get("files", [])
 
-            PrettyOutput.print(f"创建子代理: {agent_name}", OutputType.INFO)
+            PrettyOutput.print(f"Create sub-agent: {agent_name}", OutputType.INFO)
 
-            # 构建任务描述
+            # Build task description
             task_description = task
             if context:
-                task_description = f"上下文信息:\n{context}\n\n任务:\n{task}"
+                task_description = f"Context information:\n{context}\n\nTask:\n{task}"
             if goal:
-                task_description += f"\n\n完成目标:\n{goal}"
+                task_description += f"\n\nCompletion goal:\n{goal}"
 
-            # 创建子代理
+            # Create sub-agent
             sub_agent = Agent(
                 name=agent_name,
                 is_sub_agent=True
             )
 
-            # 运行子代理，传入文件列表
-            PrettyOutput.print("子代理开始执行任务...", OutputType.INFO)
+            # Run sub-agent, pass file list
+            PrettyOutput.print("Sub-agent starts executing task...", OutputType.INFO)
             result = sub_agent.run(task_description, file_list=files)
 
             return {
                 "success": True,
-                "stdout": f"子代理任务完成\n\n{result}",
+                "stdout": f"Sub-agent task completed\n\n{result}",
                 "stderr": ""
             }
 
@@ -78,5 +78,5 @@ class SubAgentTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"子代理执行失败: {str(e)}"
+                "error": f"Sub-agent execution failed: {str(e)}"
             } 

jarvis/tools/thinker.py

@@ -4,22 +4,22 @@ from jarvis.models.registry import PlatformRegistry
 
 class ThinkerTool:
     name = "thinker"
-    description = "使用思维链推理方式分析复杂问题，适用于需要多步推理、逻辑分析或创造性思考的场景"
+    description = "Use chain of thought reasoning to analyze complex problems, suitable for scenarios that require multi-step reasoning, logical analysis, or creative thinking"
     parameters = {
         "type": "object",
         "properties": {
             "question": {
                 "type": "string",
-                "description": "需要分析的问题或任务"
+                "description": "The problem or task to analyze"
             },
             "context": {
                 "type": "string",
-                "description": "问题相关的上下文信息或背景知识",
+                "description": "Context information or background knowledge related to the problem",
                 "default": ""
             },
             "goal": {
                 "type": "string",
-                "description": "期望达成的具体目标或结果",
+                "description": "The specific goal or result to achieve",
                 "default": ""
             }
         },
@@ -27,63 +27,63 @@ class ThinkerTool:
     }
 
     def __init__(self):
-        """初始化思考工具"""
+        """Initialize thinker tool"""
         self.model = PlatformRegistry.get_global_platform_registry().get_thinking_platform()
 
     def _generate_prompt(self, question: str, context: str, goal: str) -> str:
-        """生成提示词
+        """Generate prompt
         
         Args:
-            question: 问题
-            context: 上下文
-            goal: 期望目标
+            question: problem
+            context: context
+            goal: goal
             
         Returns:
-            str: 完整的提示词
+            str: complete prompt
         """
         # 基础提示词
-        prompt = f"""你是一个擅长深度思考和逻辑推理的助手。请帮助分析问题并给出解决方案。
+        prompt = f"""You are a helpful assistant that is good at deep thinking and logical reasoning. Please help analyze the problem and provide a solution.
 
-请按以下方式思考：
-1. 仔细理解问题和目标
-2. 进行系统性分析和推理
-3. 考虑多个可能的解决方案
-4. 给出最佳建议和具体行动步骤
+Please think as follows:
+1. Carefully understand the problem and goal
+2. Conduct a systematic analysis and reasoning
+3. Consider multiple possible solutions
+4. Provide the best suggestions and specific action steps
 
-问题：
+Problem:
 {question}
 """
         # 如果有目标，添加到提示词中
         if goal:
             prompt += f"""
-期望目标：
+Goal:
 {goal}
 """
 
         # 如果有上下文，添加到提示词中
         if context:
             prompt += f"""
-相关上下文：
+Related context:
 {context}
 """
 
-        prompt += "\n请开始分析："
+        prompt += "\nPlease start analyzing:"
         return prompt
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行思考分析
+        """Execute thinking analysis
         
         Args:
-            args: 包含参数的字典
-                - question: 问题
-                - context: 上下文（可选）
-                - goal: 期望目标（可选）
+            args: dictionary containing parameters
+                - question: problem
+                - context: context (optional)
+                - goal: goal (optional)
                 
         Returns:
-            Dict[str, Any]: 执行结果
+            Dict[str, Any]: execution result
         """
         try:
-            # 获取参数
+            # Get parameters
             question = args["question"]
             context = args.get("context", "")
             goal = args.get("goal", "")
@@ -91,20 +91,20 @@ class ThinkerTool:
             # 生成提示词
             prompt = self._generate_prompt(question, context, goal)
             
-            # 记录开始分析
-            PrettyOutput.print(f"开始分析问题: {question}", OutputType.INFO)
+            # Record start analysis
+            PrettyOutput.print(f"Start analyzing problem: {question}", OutputType.INFO)
             if context:
-                PrettyOutput.print("包含上下文信息", OutputType.INFO)
+                PrettyOutput.print("Contains context information", OutputType.INFO)
             if goal:
-                PrettyOutput.print(f"目标: {goal}", OutputType.INFO)
+                PrettyOutput.print(f"Goal: {goal}", OutputType.INFO)
             
             # 调用模型进行分析
-            response = self.model.chat(prompt)
+            response = self.model.chat_until_success(prompt)
             
             if not response:
                 return {
                     "success": False,
-                    "error": "未能获得有效的分析结果"
+                    "error": "Failed to obtain valid analysis results"
                 }
                 
             return {
@@ -114,22 +114,22 @@ class ThinkerTool:
             }
             
         except Exception as e:
-            PrettyOutput.print(f"思考分析失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Thinking analysis failed: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"执行失败: {str(e)}"
+                "error": f"Execution failed: {str(e)}"
             }
 
 def main():
-    """命令行直接运行工具"""
+    """Run tool directly from command line"""
     import argparse
 
     load_env_from_file()
     
-    parser = argparse.ArgumentParser(description='深度思考分析工具')
-    parser.add_argument('--question', required=True, help='需要分析的问题')
-    parser.add_argument('--context', help='问题相关的上下文信息')
-    parser.add_argument('--goal', help='期望达成的具体目标或结果')
+    parser = argparse.ArgumentParser(description='Deep thinking analysis tool')
+    parser.add_argument('--question', required=True, help='The problem to analyze')
+    parser.add_argument('--context', help='Context information related to the problem')
+    parser.add_argument('--goal', help='Specific goal or result to achieve')
     args = parser.parse_args()
     
     tool = ThinkerTool()
@@ -140,7 +140,7 @@ def main():
     })
     
     if result["success"]:
-        PrettyOutput.print("\n分析结果:", OutputType.INFO)
+        PrettyOutput.print("\nAnalysis results:", OutputType.INFO)
         PrettyOutput.print(result["stdout"], OutputType.INFO)
     else:
         PrettyOutput.print(result["error"], OutputType.ERROR)

jarvis/tools/webpage.py

@@ -5,56 +5,56 @@ from jarvis.utils import PrettyOutput, OutputType
 
 class WebpageTool:
     name = "read_webpage"
-    description = "读取网页内容，提取标题和正文文本"
+    description = "Read webpage content, extract title and text"
     parameters = {
         "type": "object",
         "properties": {
             "url": {
                 "type": "string",
-                "description": "需要读取的网页URL"
+                "description": "The URL of the webpage to read"
             }
         },
         "required": ["url"]
     }
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """读取网页内容"""
+        """Read webpage content"""
         try:
             url = args["url"]
             
-            # 设置请求头
+            # Set request headers
             headers = {
                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
             }
             
-            # 发送请求
-            PrettyOutput.print(f"正在读取网页: {url}", OutputType.INFO)
+            # Send request
+            PrettyOutput.print(f"Reading webpage: {url}", OutputType.INFO)
             response = requests.get(url, headers=headers, timeout=10)
             response.raise_for_status()
             
-            # 使用正确的编码
+            # Use correct encoding
             response.encoding = response.apparent_encoding
             
-            # 解析HTML
+            # Parse HTML
             soup = BeautifulSoup(response.text, 'html.parser')
             
-            # 移除script和style标签
+            # Remove script and style tags
             for script in soup(["script", "style"]):
                 script.decompose()
             
-            # 提取标题
+            # Extract title
             title = soup.title.string if soup.title else ""
-            title = title.strip() if title else "无标题"
+            title = title.strip() if title else "No title"
             
-            # 提取正文
+            # Extract text
             text = soup.get_text(separator='\n', strip=True)
             lines = [line.strip() for line in text.splitlines() if line.strip()]
             
-            # 构建输出
+            # Build output
             output = [
-                f"标题: {title}",
+                f"Title: {title}",
                 "",
-                "正文内容:",
+                "Text content:",
                 "\n".join(lines)
             ]
             
@@ -67,10 +67,10 @@ class WebpageTool:
         except requests.RequestException as e:
             return {
                 "success": False,
-                "error": f"网页请求失败: {str(e)}"
+                "error": f"Webpage request failed: {str(e)}"
             }
         except Exception as e:
             return {
                 "success": False,
-                "error": f"解析网页失败: {str(e)}"
+                "error": f"Failed to parse webpage: {str(e)}"
             }