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

jarvis/tools/registry.py

@@ -10,67 +10,103 @@ from jarvis.tools.base import Tool
 from jarvis.utils import OutputType, PrettyOutput, get_max_context_length
 
 
+
+def load_tools() -> str:
+    """Load tools"""
+    PrettyOutput.section("Available tools", OutputType.PLANNING)
+    tools = ToolRegistry.get_global_tool_registry().get_all_tools()
+    if tools:
+        tools_prompt = "Available tools:\n"
+        for tool in tools:
+            PrettyOutput.print(f"{tool['name']}: {tool['description']}", OutputType.INFO)
+            tools_prompt += f"- Name: {tool['name']}\n"
+            tools_prompt += f"  Description: {tool['description']}\n"
+            tools_prompt += f"  Parameters: {tool['parameters']}\n"
+            tools_prompt += f"  Usage Format: <TOOL_CALL>\n"
+        tools_prompt += """
+Tool Usage Format:
+
+<TOOL_CALL>
+name: tool_name
+arguments:
+    param1: value1
+    param2: value2
+</TOOL_CALL>
+---------------------------------------------
+"""
+        return tools_prompt
+    return ""
+
 class ToolRegistry:
     global_tool_registry = None # type: ignore
     def __init__(self):
-        """初始化工具注册器
-        """
+        """Initialize tool registry"""
         self.tools: Dict[str, Tool] = {}
-        # 加载内置工具和外部工具
+        # Load built-in tools and external tools
         self._load_builtin_tools()
         self._load_external_tools()
-        # 确保 max_context_length 是整数
+        # Ensure max_context_length is an integer
         self.max_context_length = int(get_max_context_length() * 0.8)
 
+    def use_tools(self, name: List[str]):
+        """Use specified tools"""
+        missing_tools = [tool_name for tool_name in name if tool_name not in self.tools]
+        if missing_tools:
+            PrettyOutput.print(f"Tools {missing_tools} do not exist, available tools: {', '.join(self.tools.keys())}", OutputType.WARNING)
+        self.tools = {tool_name: self.tools[tool_name] for tool_name in name}
+
+    def dont_use_tools(self, names: List[str]):
+        """Remove specified tools from the registry"""
+        self.tools = {name: tool for name, tool in self.tools.items() if name not in names}
     @staticmethod
     def get_global_tool_registry():
-        """获取全局工具注册器"""
+        """Get the global tool registry"""
         if ToolRegistry.global_tool_registry is None:
             ToolRegistry.global_tool_registry = ToolRegistry()
         return ToolRegistry.global_tool_registry
 
     def _load_builtin_tools(self):
-        """从内置tools目录加载工具"""
+        """Load tools from the built-in tools directory"""
         tools_dir = Path(__file__).parent
         
-        # 遍历目录下的所有.py文件
+        # Iterate through all .py files in the directory
         for file_path in tools_dir.glob("*.py"):
-            # 跳过基础文件和__init__.py
+            # Skip base.py and __init__.py
             if file_path.name in ["base.py", "__init__.py", "registry.py"]:
                 continue
                 
             self.register_tool_by_file(str(file_path))
 
     def _load_external_tools(self):
-        """从~/.jarvis_tools加载外部工具"""
-        external_tools_dir = Path.home() / '.jarvis_tools'
+        """Load external tools from ~/.jarvis/tools"""
+        external_tools_dir = Path.home() / '.jarvis/tools'
         if not external_tools_dir.exists():
             return
             
-        # 遍历目录下的所有.py文件
+        # Iterate through all .py files in the directory
         for file_path in external_tools_dir.glob("*.py"):
-            # 跳过__init__.py
+            # Skip __init__.py
             if file_path.name == "__init__.py":
                 continue
                 
             self.register_tool_by_file(str(file_path))
 
     def register_tool_by_file(self, file_path: str):
-        """从指定文件加载并注册工具
+        """Load and register tools from a specified file
         
         Args:
-            file_path: 工具文件的路径
+            file_path: The path of the tool file
             
         Returns:
-            bool: 是否成功加载工具
+            bool: Whether the tool is loaded successfully
         """
         try:
-            p_file_path = Path(file_path).resolve()  # 获取绝对路径
+            p_file_path = Path(file_path).resolve()  # Get the absolute path
             if not p_file_path.exists() or not p_file_path.is_file():
                 PrettyOutput.print(f"File does not exist: {p_file_path}", OutputType.ERROR)
                 return False
                 
-            # 动态导入模块
+            # Dynamically import the module
             module_name = p_file_path.stem
             spec = importlib.util.spec_from_file_location(module_name, p_file_path) # type: ignore
             if not spec or not spec.loader:
@@ -78,30 +114,29 @@ class ToolRegistry:
                 return False
                 
             module = importlib.util.module_from_spec(spec) # type: ignore
-            sys.modules[module_name] = module  # 添加到 sys.modules 以支持相对导入
+            sys.modules[module_name] = module  # Add to sys.modules to support relative imports
             spec.loader.exec_module(module)
             
-            # 查找模块中的工具类
+            # Find the tool class in the module
             tool_found = False
             for item_name in dir(module):
                 item = getattr(module, item_name)
-                # 检查是否是类，并且有必要的属性
+                # Check if it is a class and has the necessary attributes
                 if (isinstance(item, type) and 
                     hasattr(item, 'name') and 
                     hasattr(item, 'description') and 
                     hasattr(item, 'parameters')):
                     
-                    # 实例化工具类，传入模型和输出处理器
+                    # Instantiate the tool class, passing in the model and output processor
                     tool_instance = item()
                     
-                    # 注册工具
+                    # Register the tool
                     self.register_tool(
                         name=tool_instance.name,
                         description=tool_instance.description,
                         parameters=tool_instance.parameters,
                         func=tool_instance.execute
                     )
-                    PrettyOutput.print(f"Loaded tool from {p_file_path}: {tool_instance.name}: {tool_instance.description}", OutputType.SUCCESS)
                     tool_found = True
                     break
                     
@@ -116,43 +151,54 @@ class ToolRegistry:
             return False
 
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
-        """注册新工具"""
+        """Register a new tool"""
         self.tools[name] = Tool(name, description, parameters, func)
 
     def get_tool(self, name: str) -> Optional[Tool]:
-        """获取工具"""
+        """Get a tool"""
         return self.tools.get(name)
 
     def get_all_tools(self) -> List[Dict]:
-        """获取所有工具的Ollama格式定义"""
+        """Get all tools in Ollama format definition"""
         return [tool.to_dict() for tool in self.tools.values()]
 
     def execute_tool(self, name: str, arguments: Dict) -> Dict[str, Any]:
-        """执行指定工具"""
+        """Execute a specified tool"""
         tool = self.get_tool(name)
         if tool is None:
-            return {"success": False, "error": f"Tool {name} does not exist"}
+            return {"success": False, "stderr": f"Tool {name} does not exist, available tools: {', '.join(self.tools.keys())}", "stdout": ""}
         return tool.execute(arguments)
 
     def handle_tool_calls(self, tool_calls: List[Dict]) -> str:
-        """处理工具调用，只处理第一个工具"""
+        """Handle tool calls, only process the first tool"""
         try:
             if not tool_calls:
                 return ""
                 
-            # 只处理第一个工具调用
+            # Only process the first tool call
             tool_call = tool_calls[0]
             name = tool_call["name"]
             args = tool_call["arguments"]
+
+            tool_call_help = """
+Tool Usage Format:
+
+<TOOL_CALL>
+name: tool_name
+arguments:
+    param1: value1
+    param2: value2
+</TOOL_CALL>
+"""
             
             if isinstance(args, str):
                 try:
                     args = json.loads(args)
                 except json.JSONDecodeError:
-                    PrettyOutput.print(f"Invalid tool parameters format: {name}", OutputType.ERROR)
+                    PrettyOutput.print(f"Invalid tool parameters format: {name} {tool_call_help}", OutputType.ERROR)
                     return ""
 
-            # 显示工具调用信息
+            # Display tool call information
             PrettyOutput.section(f"Executing tool: {name}", OutputType.TOOL)
             if isinstance(args, dict):
                 for key, value in args.items():
@@ -160,29 +206,31 @@ class ToolRegistry:
             else:
                 PrettyOutput.print(f"Parameter: {args}", OutputType.DEBUG)
             
-            # 执行工具调用
+            # Execute tool call
             result = self.execute_tool(name, args)
+
+            stdout = result["stdout"]
+            stderr = result.get("stderr", "")
+            output_parts = []
+            if stdout:
+                output_parts.append(f"Output:\n{stdout}")
+            if stderr:
+                output_parts.append(f"Error:\n{stderr}")
+            output = "\n\n".join(output_parts)
+            output = "no output and error" if not output else output
             
-            # 处理结果
+            # Process the result
             if result["success"]:
-                stdout = result["stdout"]
-                stderr = result.get("stderr", "")
-                output_parts = []
-                if stdout:
-                    output_parts.append(f"Output:\n{stdout}")
-                if stderr:
-                    output_parts.append(f"Error:\n{stderr}")
-                output = "\n\n".join(output_parts)
-                output = "No output and error" if not output else output
+                
                 PrettyOutput.section("Execution successful", OutputType.SUCCESS)
                 
-                # 如果输出超过4k字符，使用大模型总结
+                # If the output exceeds 4k characters, use a large model to summarize
                 if len(output) > self.max_context_length:
                     try:
                         PrettyOutput.print("Output is too long, summarizing...", OutputType.PROGRESS)
                         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
                         
-                        # 如果输出超过最大上下文长度，只取最后部分
+                        # If the output exceeds the maximum context length, only take the last part
                         max_len = self.max_context_length
                         if len(output) > max_len:
                             output_to_summarize = output[-max_len:]
@@ -215,9 +263,7 @@ Please provide a summary:"""
                         output = f"Output is too long ({len(output)} characters), it is recommended to view the original output.\nPreview of the first 300 characters:\n{output[:300]}..."
             
             else:
-                error_msg = result["error"]
-                output = f"Execution failed: {error_msg}"
-                PrettyOutput.section("Execution failed", OutputType.ERROR)
+                PrettyOutput.section("Execution failed", OutputType.WARNING)
                 
             return output
             

jarvis/tools/search.py

@@ -1,39 +1,39 @@
 from typing import Dict, Any, List
 from jarvis.models.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType
-from jarvis.tools.webpage import WebpageTool
+from jarvis.tools.read_webpage import WebpageTool
 from playwright.sync_api import sync_playwright
 from urllib.parse import quote
 
 def bing_search(query):
     try:
         with sync_playwright() as p:
-            # 启动浏览器时设置参数
+            # Set parameters when starting the browser
             browser = p.chromium.launch(
-                headless=True,  # 无头模式
+                headless=True,  # Headless mode
                 args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
             )
             
-            # 创建新页面并设置超时
+            # Create a new page and set timeout
             page = browser.new_page(
                 user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
                 viewport={'width': 1920, 'height': 1080}
             )
             
-            # 设置页面超时
+            # Set page timeout
             page.set_default_timeout(60000)
             
-            # 访问搜索页面
+            # Visit search page
             url = f"https://www.bing.com/search?q={quote(query)}&form=QBLH&sp=-1"
             page.goto(url, wait_until="networkidle")
             
-            # 等待搜索结果加载
+            # Wait for search results to load
             page.wait_for_selector("#b_results", state="visible", timeout=30000)
             
-            # 等待一下以确保结果完全加载
+            # Wait for a moment to ensure the results are fully loaded
             page.wait_for_timeout(1000)
             
-            # 提取搜索结果
+            # Extract search results
             summaries = page.evaluate("""() => {
                 const results = [];
                 const elements = document.querySelectorAll("#b_results > .b_algo");
@@ -96,7 +96,7 @@ class SearchTool:
             if not results:
                 return []
             
-            # 格式化搜索结果
+            # Format search results
             formatted_results = []
             for result in results[:max_results]:
                 formatted_results.append({
@@ -142,15 +142,16 @@ When answering, pay attention to:
             PrettyOutput.print(f"Search query: {query}", OutputType.INFO)
             PrettyOutput.print(f"Related question: {question}", OutputType.INFO)
             
-            # 获取搜索结果
+            # Get search results
             results = self._search(query, max_results)
             if not results:
                 return {
                     "success": False,
-                    "error": "No search results found"
+                    "stdout": "",
+                    "stderr": "No search results found"
                 }
             
-            # 收集网页内容
+            # Collect webpage content
             contents = []
             for i, result in enumerate(results, 1):
                 try:
@@ -166,7 +167,8 @@ When answering, pay attention to:
             if not contents:
                 return {
                     "success": False,
-                    "error": "No valid search results found"
+                    "stdout": "",
+                    "stderr": "No valid search results found"
                 }
             
             # Extract information
@@ -182,11 +184,12 @@ When answering, pay attention to:
         except Exception as e:
             return {
                 "success": False,
-                "error": f"搜索失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"Search failed: {str(e)}"
             }
 
 def main():
-    """命令行直接运行搜索工具"""
+    """Command line directly run search tool"""
     import argparse
     import sys
     

jarvis/tools/select_code_files.py

@@ -0,0 +1,61 @@
+from typing import Dict, Any, List
+
+from jarvis.utils import OutputType, PrettyOutput
+from jarvis.jarvis_coder.file_select import select_files
+
+
+class CodeFileSelecterTool:
+    name = "select_code_files"
+    description = "Select and manage code files for modification with interactive file selection"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "related_files": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                },
+                "description": "List of initially related files",
+                "default": []
+            },
+            "root_dir": {
+                "type": "string",
+                "description": "Root directory of the codebase",
+                "default": "."
+            }
+        },
+        "required": ["related_files"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute interactive file selection"""
+        try:
+            related_files = args["related_files"]
+            root_dir = args.get("root_dir", ".")
+
+            PrettyOutput.print("Starting interactive file selection...", OutputType.INFO)
+
+            # Use file_select module to handle file selection
+            selected_files = select_files(
+                related_files=related_files,
+                root_dir=root_dir
+            )
+
+            # Format output for display
+            output = "Selected files:\n"
+            for file in selected_files:
+                output += f"- {file}\n"
+
+            return {
+                "success": True,
+                "stdout": output,
+                "stderr": ""
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": str(e)
+            }

jarvis/tools/thinker.py

@@ -1,5 +1,5 @@
 from typing import Dict, Any
-from jarvis.utils import OutputType, PrettyOutput, load_env_from_file
+from jarvis.utils import OutputType, PrettyOutput, init_env
 from jarvis.models.registry import PlatformRegistry
 
 class ThinkerTool:
@@ -104,7 +104,8 @@ Related context:
             if not response:
                 return {
                     "success": False,
-                    "error": "Failed to obtain valid analysis results"
+                    "stdout": "",
+                    "stderr": "Failed to obtain valid analysis results"
                 }
                 
             return {
@@ -117,14 +118,15 @@ Related context:
             PrettyOutput.print(f"Thinking analysis failed: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Execution failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
             }
 
 def main():
     """Run tool directly from command line"""
     import argparse
 
-    load_env_from_file()
+    init_env()
     
     parser = argparse.ArgumentParser(description='Deep thinking analysis tool')
     parser.add_argument('--question', required=True, help='The problem to analyze')
@@ -143,7 +145,7 @@ def main():
         PrettyOutput.print("\nAnalysis results:", OutputType.INFO)
         PrettyOutput.print(result["stdout"], OutputType.INFO)
     else:
-        PrettyOutput.print(result["error"], OutputType.ERROR)
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
 
 if __name__ == "__main__":
     main()