jarvis-ai-assistant 0.1.102__py3-none-any.whl → 0.1.104__py3-none-any.whl

jarvis/tools/methodology.py

@@ -73,9 +73,9 @@ class MethodologyTool:
         Returns:
             Dict[str, Any]: A dictionary containing the execution result
         """
-        operation = args.get("operation")
-        problem_type = args.get("problem_type")
-        content = args.get("content")
+        operation = args.get("operation", "").strip()
+        problem_type = args.get("problem_type", "").strip()
+        content = args.get("content", "").strip()
         
         if not operation or not problem_type:
             return {

jarvis/tools/rag.py

@@ -0,0 +1,141 @@
+from typing import Dict, Any
+import os
+from jarvis.utils import OutputType, PrettyOutput, dont_use_local_model
+from jarvis.jarvis_rag.main import RAGTool as RAGCore
+
+class RAGTool:
+    name = "rag"
+    description = "Ask questions based on a document directory, supporting multiple document formats (txt, pdf, docx, etc.)"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "dir": {
+                "type": "string",
+                "description": "Document directory path, supports both relative and absolute paths"
+            },
+            "question": {
+                "type": "string",
+                "description": "The question to ask"
+            },
+            "rebuild_index": {
+                "type": "boolean",
+                "description": "Whether to rebuild the index",
+                "default": False
+            }
+        },
+        "required": ["dir", "question"]
+    }
+
+    @staticmethod
+    def check() -> bool:
+        return not dont_use_local_model()
+
+    def __init__(self):
+        """Initialize RAG tool"""
+        self.rag_instances = {}  # Cache RAG instances for different directories
+
+    def _get_rag_instance(self, dir_path: str) -> RAGCore:
+        """Get or create RAG instance
+        
+        Args:
+            dir_path: The absolute path of the document directory
+            
+        Returns:
+            RAGCore: RAG instance
+        """
+        if dir_path not in self.rag_instances:
+            self.rag_instances[dir_path] = RAGCore(dir_path)
+        return self.rag_instances[dir_path]
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute document question and answer
+        
+        Args:
+            args: A dictionary containing parameters
+                - dir: The document directory path
+                - question: The question to ask
+                - rebuild_index: Whether to rebuild the index
+                
+        Returns:
+            Dict[str, Any]: The execution result
+        """
+        try:
+            # Get parameters
+            dir_path = os.path.expanduser(args["dir"])  # Expand ~ paths
+            dir_path = os.path.abspath(dir_path)  # Convert to absolute path
+            question = args["question"]
+            rebuild_index = args.get("rebuild_index", False)
+            
+            # Check if the directory exists
+            if not os.path.exists(dir_path):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"Directory does not exist: {dir_path}"
+                }
+                
+            # Check if it is a directory
+            if not os.path.isdir(dir_path):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"The path is not a directory: {dir_path}"
+                }
+                
+            # Get RAG instance
+            rag = self._get_rag_instance(dir_path)
+            
+            # If you need to rebuild the index or the index does not exist
+            if rebuild_index or not rag.is_index_built():
+                PrettyOutput.print("Building document index...", OutputType.INFO)
+                rag.build_index(dir_path)
+            
+            # Execute question and answer
+            PrettyOutput.print(f"Question: {question}", OutputType.INFO)
+            response = rag.ask(question)
+            
+            if response is None:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Failed to get answer, possibly no relevant documents found"
+                }
+                
+            return {
+                "success": True,
+                "stdout": response,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            PrettyOutput.print(f"Document question and answer failed: {str(e)}", OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
+            }
+
+def main():
+    """Run the tool directly from the command line"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Document question and answer tool')
+    parser.add_argument('--dir', required=True, help='Document directory path')
+    parser.add_argument('--question', required=True, help='The question to ask')
+    parser.add_argument('--rebuild', action='store_true', help='Rebuild index')
+    args = parser.parse_args()
+    
+    tool = RAGTool()
+    result = tool.execute({
+        "dir": args.dir,
+        "question": args.question,
+        "rebuild_index": args.rebuild
+    })
+    
+    if result["success"]:
+        PrettyOutput.print(f"{result['stdout']}", OutputType.INFO, lang="markdown")
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+
+if __name__ == "__main__":
+    main() 

jarvis/tools/read_code.py

@@ -0,0 +1,116 @@
+from typing import Dict, Any
+import os
+from jarvis.utils import OutputType, PrettyOutput
+
+
+class ReadCodeTool:
+    """Read code file with line numbers"""
+    
+    name = "read_code"
+    description = "Read code file with line numbers"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "filepath": {
+                "type": "string",
+                "description": "Absolute or relative path to the file"
+            },
+            "start_line": {
+                "type": "integer",
+                "description": "Start line number (0-based, inclusive)",
+                "default": 0
+            },
+            "end_line": {
+                "type": "integer",
+                "description": "End line number (0-based, exclusive). -1 means read to end",
+                "default": -1
+            }
+        },
+        "required": ["filepath"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute code reading with line numbers
+        
+        Args:
+            args: Dictionary containing:
+                - filepath: Path to the file
+                - start_line: Start line number (optional)
+                - end_line: End line number (optional)
+                
+        Returns:
+            Dict containing:
+                - success: Boolean indicating success
+                - stdout: File content with line numbers
+                - stderr: Error message if any
+        """
+        try:
+            filepath = args["filepath"].strip()
+            start_line = args.get("start_line", 0)
+            end_line = args.get("end_line", -1)
+            
+            # Record the operation and the full path
+            abs_path = os.path.abspath(filepath)
+            PrettyOutput.print(f"Reading code file: {abs_path}", OutputType.INFO)
+            
+            # Check if file exists
+            if not os.path.exists(filepath):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"File does not exist: {filepath}"
+                }
+                
+            # Check file size
+            if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "File too large (>10MB)"
+                }
+                
+            # Read file content
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+            except UnicodeDecodeError:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Failed to decode file with UTF-8 encoding"
+                }
+                
+            # Validate line range
+            if start_line < 0:
+                start_line = 0
+            if end_line == -1 or end_line > len(lines):
+                end_line = len(lines)
+            if start_line >= end_line:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"Invalid line range: [{start_line}, {end_line})"
+                }
+                
+            # Format lines with hexadecimal line numbers
+            formatted_lines = []
+            for i, line in enumerate(lines[start_line:end_line]):
+                line_num = start_line + i
+                formatted_lines.append(f"{line_num:>5}:{line}")
+                
+            content = "".join(formatted_lines)
+
+            PrettyOutput.print(f"File: {filepath}\nLines: [{start_line}, {end_line})\n{content}", OutputType.CODE)
+            
+            return {
+                "success": True,
+                "stdout": content,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Failed to read code: {str(e)}"
+            }

jarvis/tools/read_webpage.py

@@ -20,7 +20,7 @@ class WebpageTool:
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Read webpage content"""
         try:
-            url = args["url"]
+            url = args["url"].strip()   
             
             # Set request headers
             headers = {

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,20 +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 += """
-Tool Usage Format:
+tool_call_help = """Tool Usage Format:
 
 <TOOL_CALL>
 name: tool_name
@@ -31,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] = {}
@@ -57,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"""
@@ -126,7 +140,6 @@ class ToolRegistry:
 
                         if hasattr(item, "check"):
                             if not item.check():
-                                PrettyOutput.print(f"Tool {item.name} check failed, skipping", OutputType.INFO)
                                 continue
                         
                         # Instantiate the tool class
@@ -143,7 +156,6 @@ class ToolRegistry:
                         break
                         
                 if not tool_found:
-                    PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.INFO)
                     return False
                     
                 return True
@@ -206,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)
@@ -270,9 +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--- 一次只能执行一个工具, 因此以下工具未执行\n{str(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)