jarvis-ai-assistant 0.1.101__py3-none-any.whl → 0.1.103__py3-none-any.whl

jarvis/tools/registry.py

@@ -1,6 +1,4 @@
-import importlib
 import json
-import os
 from pathlib import Path
 import sys
 from typing import Any, Callable, Dict, List, Optional
@@ -10,21 +8,7 @@ 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_help = """Tool Usage Format:
 
 <TOOL_CALL>
 name: tool_name
@@ -32,13 +16,48 @@ arguments:
     param1: value1
     param2: value2
 </TOOL_CALL>
----------------------------------------------
+
+Strict Rules:
+- Execute only one tool at a time
+- Tool execution must strictly follow the tool usage format
+- Wait for user to provide execution results
+- Don't assume or imagine results
+- Don't create fake dialogues
+- If current information is insufficient, you may ask the user for more information
+- Not all problem-solving steps are mandatory, skip as appropriate
+- Request user guidance when multiple iterations show no progress
+- ALWAYS use | syntax for string parameters to prevent parsing errors
+    Example:
+    <TOOL_CALL>
+    name: execute_shell
+    arguments:
+        command: |
+            git status --porcelain
+    </TOOL_CALL>
+    <TOOL_CALL>
+    name: execute_shell
+    arguments:
+        command: |
+            git commit -m "fix bug"
+    </TOOL_CALL>
+    
+- If you can start executing the task, please start directly without asking the user if you can begin.
 """
-        return tools_prompt
-    return ""
 
 class ToolRegistry:
-    global_tool_registry = None # type: ignore
+    def load_tools(self) -> str:
+        """Load tools"""
+        tools = self.get_all_tools()
+        if tools:
+            tools_prompt = "Available tools:\n"
+            for tool in tools:
+                tools_prompt += f"- Name: {tool['name']}\n"
+                tools_prompt += f"  Description: {tool['description']}\n"
+                tools_prompt += f"  Parameters: {tool['parameters']}\n"
+            tools_prompt += tool_call_help
+            return tools_prompt
+        return ""
+
     def __init__(self):
         """Initialize tool registry"""
         self.tools: Dict[str, Tool] = {}
@@ -58,12 +77,6 @@ class ToolRegistry:
     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):
         """Load tools from the built-in tools directory"""
@@ -106,48 +119,53 @@ class ToolRegistry:
                 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:
-                PrettyOutput.print(f"Failed to load module: {p_file_path}", OutputType.ERROR)
-                return False
-                
-            module = importlib.util.module_from_spec(spec) # type: ignore
-            sys.modules[module_name] = module  # Add to sys.modules to support relative imports
-            spec.loader.exec_module(module)
+            # Add the parent directory to sys.path temporarily
+            parent_dir = str(p_file_path.parent)
+            sys.path.insert(0, parent_dir)
             
-            # 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
-                    )
-                    tool_found = True
-                    break
+            try:
+                # Import the module using standard import mechanism
+                module_name = p_file_path.stem
+                module = __import__(module_name)
+                
+                # 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')):
+
+                        if hasattr(item, "check"):
+                            if not item.check():
+                                continue
+                        
+                        # Instantiate the tool class
+                        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
+                        )
+                        tool_found = True
+                        break
+                        
+                if not tool_found:
+                    return False
                     
-            if not tool_found:
-                PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.WARNING)
-                return False
+                return True
+                
+            finally:
+                # Remove the directory from sys.path
+                sys.path.remove(parent_dir)
                 
-            return True
-            
         except Exception as e:
-            PrettyOutput.print(f"Failed to load tool from {p_file_path.name}: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to load tool from {Path(file_path).name}: {str(e)}", OutputType.ERROR)
             return False
 
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
@@ -200,11 +218,14 @@ arguments:
 
             # Display tool call information
             PrettyOutput.section(f"Executing tool: {name}", OutputType.TOOL)
+            params = "Parameters:\n"
             if isinstance(args, dict):
                 for key, value in args.items():
-                    PrettyOutput.print(f"Parameter: {key} = {value}", OutputType.DEBUG)
+                    params += f"{key} = {value}\n"
             else:
-                PrettyOutput.print(f"Parameter: {args}", OutputType.DEBUG)
+                params += f"{args}"
+
+            PrettyOutput.print(params, OutputType.INFO)
             
             # Execute tool call
             result = self.execute_tool(name, args)
@@ -264,7 +285,10 @@ Please provide a summary:"""
             
             else:
                 PrettyOutput.section("Execution failed", OutputType.WARNING)
-                
+                PrettyOutput.print(result["stderr"], OutputType.WARNING)
+            
+            if len(tool_calls) > 1:
+                output += f"\n\n--- Only one tool can be executed at a time, the following tools were not executed\n{str(tool_calls[1:])} ---"
             return output
             
         except Exception as e:

jarvis/tools/search.py

@@ -211,17 +211,19 @@ def main():
         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)
+            output = []
+            output.append(f"\n{'-'*50}")
             if args.url_only:
-                PrettyOutput.print(f"{i}. {result['href']}", OutputType.INFO)
+                output.append(f"{i}. {result['href']}")
             else:
-                PrettyOutput.print(f"{i}. {result['title']}", OutputType.INFO)
-                PrettyOutput.print(f"Link: {result['href']}", OutputType.INFO)
+                output.append(f"{i}. {result['title']}")
+                output.append(f"Link: {result['href']}")
                 if result['abstract']:
-                    PrettyOutput.print(f"Abstract: {result['abstract']}", OutputType.INFO)
+                    output.append(f"Abstract: {result['abstract']}")
+            PrettyOutput.print("\n".join(output), OutputType.INFO)
                     
     except KeyboardInterrupt:
-        PrettyOutput.print("\nSearch cancelled", OutputType.WARNING)
+        PrettyOutput.print("Search cancelled", OutputType.WARNING)
         sys.exit(1)
     except Exception as e:
         PrettyOutput.print(f"Execution error: {str(e)}", OutputType.ERROR)

jarvis/tools/select_code_files.py

@@ -1,7 +1,7 @@
-from typing import Dict, Any, List
+from typing import Dict, Any
 
 from jarvis.utils import OutputType, PrettyOutput
-from jarvis.jarvis_coder.file_select import select_files
+from jarvis.jarvis_code_agent.file_select import select_files
 
 
 class CodeFileSelecterTool:
@@ -30,8 +30,8 @@ class CodeFileSelecterTool:
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Execute interactive file selection"""
         try:
-            related_files = args["related_files"]
-            root_dir = args.get("root_dir", ".")
+            related_files = args.get("related_files", [])
+            root_dir = args.get("root_dir", ".").strip()
 
             PrettyOutput.print("Starting interactive file selection...", OutputType.INFO)