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

jarvis/tools/methodology.py

@@ -5,7 +5,7 @@ from jarvis.utils import OutputType, PrettyOutput
 
 
 class MethodologyTool:
-    """经验管理工具"""
+    """Experience management tool"""
     
     name = "methodology"
     description = "Manage problem-solving methodologies, supporting add, update, and delete operations"
@@ -31,47 +31,47 @@ class MethodologyTool:
     }
     
     def __init__(self):
-        """初始化经验管理工具"""
+        """Initialize the experience management tool"""
         self.methodology_file = os.path.expanduser("~/.jarvis_methodology")
         self._ensure_file_exists()
             
     def _ensure_file_exists(self):
-        """确保方法论文件存在"""
+        """Ensure the methodology file exists"""
         if not os.path.exists(self.methodology_file):
             try:
                 with open(self.methodology_file, 'w', encoding='utf-8') as f:
                     yaml.safe_dump({}, f, allow_unicode=True)
             except Exception as e:
-                PrettyOutput.print(f"创建方法论文件失败: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to create methodology file: {str(e)}", OutputType.ERROR)
                 
     def _load_methodologies(self) -> Dict:
-        """加载所有方法论"""
+        """Load all methodologies"""
         try:
             with open(self.methodology_file, 'r', encoding='utf-8') as f:
                 return yaml.safe_load(f) or {}
         except Exception as e:
-            PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to load methodologies: {str(e)}", OutputType.ERROR)
             return {}
             
     def _save_methodologies(self, methodologies: Dict):
-        """保存所有方法论"""
+        """Save all methodologies"""
         try:
             with open(self.methodology_file, 'w', encoding='utf-8') as f:
                 yaml.safe_dump(methodologies, f, allow_unicode=True)
         except Exception as e:
-            PrettyOutput.print(f"保存方法论失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to save methodologies: {str(e)}", OutputType.ERROR)
             
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行方法论管理操作
+        """Execute the operation of managing methodologies
         
         Args:
-            args: 包含操作参数的字典
-                - operation: 操作类型 (delete/update/add)
-                - problem_type: 问题类型
-                - content: 方法论内容 (update/add 时必需)
+            args: A dictionary containing the operation parameters
+                - operation: The operation type (delete/update/add)
+                - problem_type: The problem type
+                - content: The methodology content (required for update/add)
             
         Returns:
-            Dict[str, Any]: 包含执行结果的字典
+            Dict[str, Any]: A dictionary containing the execution result
         """
         operation = args.get("operation")
         problem_type = args.get("problem_type")
@@ -80,7 +80,7 @@ class MethodologyTool:
         if not operation or not problem_type:
             return {
                 "success": False,
-                "error": "缺少必要参数: operation 和 problem_type"
+                "error": "Missing required parameters: operation and problem_type"
             }
             
         methodologies = self._load_methodologies()
@@ -92,50 +92,50 @@ class MethodologyTool:
                     self._save_methodologies(methodologies)
                     return {
                         "success": True,
-                        "stdout": f"已删除问题类型 '{problem_type}' 的方法论"
+                        "stdout": f"Deleted methodology for problem type '{problem_type}'"
                     }
                 else:
                     return {
                         "success": False,
-                        "error": f"未找到问题类型 '{problem_type}' 的方法论"
+                        "error": f"Methodology for problem type '{problem_type}' not found"
                     }
                     
             elif operation in ["update", "add"]:
                 if not content:
                     return {
                         "success": False,
-                        "error": "需要提供方法论内容"
+                        "error": "Need to provide methodology content"
                     }
                     
                 methodologies[problem_type] = content
                 self._save_methodologies(methodologies)
                 
-                action = "更新" if problem_type in methodologies else "添加"
+                action = "Update" if problem_type in methodologies else "Add"
                 return {
                     "success": True,
-                    "stdout": f"已{action}问题类型 '{problem_type}' 的方法论"
+                    "stdout": f"{action} methodology for problem type '{problem_type}'"
                 }
                 
             else:
                 return {
                     "success": False,
-                    "error": f"不支持的操作类型: {operation}"
+                    "error": f"Unsupported operation type: {operation}"
                 }
                 
         except Exception as e:
             return {
                 "success": False,
-                "error": f"执行失败: {str(e)}"
+                "error": f"Execution failed: {str(e)}"
             }
             
     def get_methodology(self, problem_type: str) -> Optional[str]:
-        """获取指定问题类型的方法论
+        """Get the methodology for a specific problem type
         
         Args:
-            problem_type: 问题类型
+            problem_type: The problem type
             
         Returns:
-            Optional[str]: 方法论内容，如果不存在则返回 None
+            Optional[str]: The methodology content, or None if it does not exist
         """
         methodologies = self._load_methodologies()
         return methodologies.get(problem_type) 

jarvis/tools/rag.py

@@ -27,71 +27,71 @@ class RAGTool:
     }
 
     def __init__(self):
-        """初始化 RAG 工具"""
-        self.rag_instances = {}  # 缓存不同目录的 RAG 实例
+        """Initialize RAG tool"""
+        self.rag_instances = {}  # Cache RAG instances for different directories
 
     def _get_rag_instance(self, dir_path: str) -> RAGCore:
-        """获取或创建 RAG 实例
+        """Get or create RAG instance
         
         Args:
-            dir_path: 文档目录的绝对路径
+            dir_path: The absolute path of the document directory
             
         Returns:
-            RAGCore: RAG 实例
+            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: 包含参数的字典
-                - dir: 文档目录路径
-                - question: 要询问的问题
-                - rebuild_index: 是否重建索引
+            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]: 执行结果
+            Dict[str, Any]: The execution result
         """
         try:
-            # 获取参数
-            dir_path = os.path.expanduser(args["dir"])  # 展开 ~ 等路径
-            dir_path = os.path.abspath(dir_path)  # 转换为绝对路径
+            # 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,
-                    "error": f"目录不存在: {dir_path}"
+                    "error": f"Directory does not exist: {dir_path}"
                 }
                 
-            # 检查是否是目录
+            # Check if it is a directory
             if not os.path.isdir(dir_path):
                 return {
                     "success": False,
-                    "error": f"路径不是目录: {dir_path}"
+                    "error": f"The path is not a directory: {dir_path}"
                 }
                 
-            # 获取 RAG 实例
+            # 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("正在构建文档索引...", OutputType.INFO)
+                PrettyOutput.print("Building document index...", OutputType.INFO)
                 rag.build_index(dir_path)
             
-            # 执行问答
-            PrettyOutput.print(f"问题: {question}", OutputType.INFO)
+            # Execute question and answer
+            PrettyOutput.print(f"Question: {question}", OutputType.INFO)
             response = rag.ask(question)
             
             if response is None:
                 return {
                     "success": False,
-                    "error": "未能获取答案，可能是没有找到相关文档"
+                    "error": "Failed to get answer, possibly no relevant documents found"
                 }
                 
             return {
@@ -101,20 +101,20 @@ class RAGTool:
             }
             
         except Exception as e:
-            PrettyOutput.print(f"文档问答失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Document question and answer failed: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"执行失败: {str(e)}"
+                "error": f"Execution failed: {str(e)}"
             }
 
 def main():
-    """命令行直接运行工具"""
+    """Run the tool directly from the command line"""
     import argparse
     
-    parser = argparse.ArgumentParser(description='文档问答工具')
-    parser.add_argument('--dir', required=True, help='文档目录路径')
-    parser.add_argument('--question', required=True, help='要询问的问题')
-    parser.add_argument('--rebuild', action='store_true', help='重建索引')
+    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()
@@ -125,7 +125,7 @@ def main():
     })
     
     if result["success"]:
-        PrettyOutput.print("\n回答:", OutputType.INFO)
+        PrettyOutput.print("\nAnswer:", OutputType.INFO)
         PrettyOutput.print(result["stdout"], OutputType.INFO)
     else:
         PrettyOutput.print(result["error"], OutputType.ERROR)

jarvis/tools/registry.py

@@ -10,67 +10,93 @@ 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)
 
     @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加载外部工具"""
+        """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 +104,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 +141,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, "error": f"Tool {name} does not exist, available tools: {', '.join(self.tools.keys())}"}
         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,10 +196,10 @@ class ToolRegistry:
             else:
                 PrettyOutput.print(f"Parameter: {args}", OutputType.DEBUG)
             
-            # 执行工具调用
+            # Execute tool call
             result = self.execute_tool(name, args)
             
-            # 处理结果
+            # Process the result
             if result["success"]:
                 stdout = result["stdout"]
                 stderr = result.get("stderr", "")
@@ -173,16 +209,16 @@ class ToolRegistry:
                 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
+                output = "Tool execution successful, 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:]

jarvis/tools/search.py

@@ -1,7 +1,7 @@
 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
 

jarvis/tools/select_code_files.py

@@ -0,0 +1,64 @@
+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": "",
+                "selected_files": selected_files  # Return the selected files for other tools to use
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": f"Failed to select files: {str(e)}",
+                "stdout": "",
+                "stderr": str(e),
+                "selected_files": []  # Return empty list on error
+            }