jarvis-ai-assistant 0.1.125__py3-none-any.whl → 0.1.128__py3-none-any.whl

jarvis/jarvis_tools/base.py

@@ -7,7 +7,7 @@ class Tool:
         """
         初始化工具对象
         
-        Args:
+        参数:
             name (str): 工具名称
             description (str): 工具描述
             parameters (Dict): 工具参数定义
@@ -28,10 +28,10 @@ class Tool:
         """
         执行工具函数
         
-        Args:
+        参数:
             arguments (Dict): 工具执行所需的参数
             
-        Returns:
+        返回:
             Dict[str, Any]: 工具执行结果
         """
-        return self.func(arguments)
+        return self.func(arguments)

jarvis/jarvis_tools/chdir.py

@@ -3,80 +3,80 @@ import os
 
 class ChdirTool:
     name = "chdir"
-    description = "Change current working directory"
+    description = "更改当前工作目录"
     parameters = {
         "type": "object",
         "properties": {
             "path": {
                 "type": "string",
-                "description": "Directory path to switch to, supports both relative and absolute paths"
+                "description": "要切换到的目录路径，支持相对路径和绝对路径"
             }
         },
         "required": ["path"]
     }
     
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute directory change operation with comprehensive error handling.
+        """执行目录切换操作，并提供全面的错误处理。
         
-        Args:
-            args: Dictionary containing 'path' key with target directory path
+        参数:
+            args: 包含 'path' 键的字典，目标目录路径
             
-        Returns:
-            Dictionary containing:
-                - success: Boolean indicating operation status
-                - stdout: Success message or empty string
-                - stderr: Error message or empty string
+        返回:
+            字典，包含以下内容：
+                - success: 布尔值，表示操作状态
+                - stdout: 成功消息或空字符串
+                - stderr: 错误消息或空字符串
                 
-        Raises:
-            Handles and returns appropriate error messages for:
-                - Non-existent paths
-                - Non-directory paths
-                - Permission errors
-                - Generic exceptions
+        异常处理:
+            处理并返回适当的错误消息：
+                - 不存在的路径
+                - 非目录路径
+                - 权限错误
+                - 其他通用异常
         """
-        # Main execution block with comprehensive error handling
+        # 主执行块，包含全面的错误处理
         try:
-            # Normalize and expand the input path (handles ~ and relative paths)
+            # 规范化并展开输入路径（处理 ~ 和相对路径）
             path = os.path.expanduser(args["path"].strip())
             path = os.path.abspath(path)
             
-            # Validate that the target path exists
+            # 验证目标路径是否存在
             if not os.path.exists(path):
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": f"Directory does not exist: {path}"
+                    "stderr": f"目录不存在: {path}"
                 }
                 
-            # Ensure the path points to a directory, not a file
+            # 确保路径指向的是目录，而不是文件
             if not os.path.isdir(path):
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": f"The path is not a directory: {path}"
+                    "stderr": f"路径不是目录: {path}"
                 }
                 
-            # Capture current directory and attempt to change to new path
+            # 获取当前目录并尝试切换到新路径
             old_path = os.getcwd()
             os.chdir(path)
             
             return {
                 "success": True,
-                "stdout": f"Changed working directory:\nFrom: {old_path}\nTo: {path}",
+                "stdout": f"成功切换工作目录:\n原目录: {old_path}\n新目录: {path}",
                 "stderr": ""
             }
             
-        # Handle cases where user lacks directory access permissions
+        # 处理用户没有目录访问权限的情况
         except PermissionError:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"No permission to access directory: {path}"
+                "stderr": f"无权限访问目录: {path}"
             }
-        # Catch-all for any other unexpected errors during directory change
+        # 捕获在目录切换过程中可能出现的其他意外错误
         except Exception as e:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"Failed to switch directory: {str(e)}"
+                "stderr": f"切换目录失败: {str(e)}"
             }

jarvis/jarvis_tools/code_review.py

@@ -1,5 +1,7 @@
 from typing import Dict, Any
 import subprocess
+
+from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_agent import Agent
@@ -10,27 +12,27 @@ from jarvis.jarvis_utils.utils import init_env
 
 class CodeReviewTool:
     name = "code_review"
-    description = "Autonomous code review agent for code changes analysis"
+    description = "自动代码审查工具，用于分析代码变更"
     parameters = {
         "type": "object",
         "properties": {
             "review_type": {
                 "type": "string",
-                "description": "Type of review: 'commit' for specific commit, 'current' for current changes, 'range' for commit range",
+                "description": "审查类型：'commit' 审查特定提交，'current' 审查当前变更，'range' 审查提交范围",
                 "enum": ["commit", "current", "range"],
                 "default": "current"
             },
             "commit_sha": {
                 "type": "string",
-                "description": "Target commit SHA to analyze (required for review_type='commit')"
+                "description": "要分析的提交SHA（review_type='commit'时必填）"
             },
             "start_commit": {
                 "type": "string",
-                "description": "Start commit SHA (required for review_type='range')"
+                "description": "起始提交SHA（review_type='range'时必填）"
             },
             "end_commit": {
                 "type": "string",
-                "description": "End commit SHA (required for review_type='range')"
+                "description": "结束提交SHA（review_type='range'时必填）"
             }
         },
         "required": []
@@ -41,44 +43,47 @@ class CodeReviewTool:
             review_type = args.get("review_type", "current").strip()
             
             # Build git diff command based on review type
-            if review_type == "commit":
-                if "commit_sha" not in args:
-                    return {
-                        "success": False,
-                        "stdout": {},
-                        "stderr": "commit_sha is required for commit review type"
-                    }
-                commit_sha = args["commit_sha"].strip()
-                diff_cmd = f"git show {commit_sha} | cat -"
-            elif review_type == "range":
-                if "start_commit" not in args or "end_commit" not in args:
-                    return {
-                        "success": False,
-                        "stdout": {},
-                        "stderr": "start_commit and end_commit are required for range review type"
-                    }
-                start_commit = args["start_commit"].strip()
-                end_commit = args["end_commit"].strip()
-                diff_cmd = f"git diff {start_commit}..{end_commit} | cat -"
-            else:  # current changes
-                diff_cmd = "git diff HEAD | cat -"
+            with yaspin(text="正在获取代码变更...", color="cyan") as spinner:
+                if review_type == "commit":
+                    if "commit_sha" not in args:
+                        return {
+                            "success": False,
+                            "stdout": {},
+                            "stderr": "commit_sha is required for commit review type"
+                        }
+                    commit_sha = args["commit_sha"].strip()
+                    diff_cmd = f"git show {commit_sha} | cat -"
+                elif review_type == "range":
+                    if "start_commit" not in args or "end_commit" not in args:
+                        return {
+                            "success": False,
+                            "stdout": {},
+                            "stderr": "start_commit and end_commit are required for range review type"
+                        }
+                    start_commit = args["start_commit"].strip()
+                    end_commit = args["end_commit"].strip()
+                    diff_cmd = f"git diff {start_commit}..{end_commit} | cat -"
+                else:  # current changes
+                    diff_cmd = "git diff HEAD | cat -"
             
-            # Execute git diff command
-            try:
-                diff_output = subprocess.check_output(diff_cmd, shell=True, text=True)
-                if not diff_output:
+                # Execute git diff command
+                try:
+                    diff_output = subprocess.check_output(diff_cmd, shell=True, text=True)
+                    if not diff_output:
+                        return {
+                            "success": False,
+                            "stdout": {},
+                            "stderr": "No changes to review"
+                        }
+                    PrettyOutput.print(diff_output, OutputType.CODE, lang="diff")
+                except subprocess.CalledProcessError as e:
                     return {
                         "success": False,
                         "stdout": {},
-                        "stderr": "No changes to review"
+                        "stderr": f"Failed to get diff: {str(e)}"
                     }
-                PrettyOutput.print(diff_output, OutputType.CODE, lang="diff")
-            except subprocess.CalledProcessError as e:
-                return {
-                    "success": False,
-                    "stdout": {},
-                    "stderr": f"Failed to get diff: {str(e)}"
-                }
+                spinner.text = "代码变更获取完成"
+                spinner.ok("✅")
 
             system_prompt = """You are an autonomous code review expert with a tragic past. Perform in-depth analysis with the vigilance born from painful experience:
 
@@ -243,4 +248,4 @@ def main():
         PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
 if __name__ == "__main__":
-    main()
+    main()

jarvis/jarvis_tools/create_code_agent.py

@@ -6,12 +6,12 @@ from jarvis.jarvis_utils.git_utils import get_latest_commit_hash, has_uncommitte
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class CreateCodeAgentTool:
-    """Tool for managing the code development workflow."""
+    """用于管理代码开发工作流的工具"""
     
     name = "create_code_agent"
-    description = "Technical code implementation and development process management"
+    description = "技术代码实现和开发过程管理工具"
     parameters = {
-        "requirement": "Technical specifications for code implementation"
+        "requirement": "代码实现的技术规范"
     }
     
     
@@ -109,4 +109,4 @@ def main():
         PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
 if __name__ == "__main__":
-    main()
+    main()

jarvis/jarvis_tools/create_sub_agent.py

@@ -8,32 +8,32 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class SubAgentTool:
     name = "create_sub_agent"
-    description = "Create a sub-agent to handle specific tasks, the sub-agent will generate a task summary report"
+    description = "创建子代理以处理特定任务，子代理将生成任务总结报告"
     parameters = {
         "type": "object",
         "properties": {
             "agent_name": {
                 "type": "string",
-                "description": "Sub-agent name"
+                "description": "子代理名称"
             },
             "task": {
                 "type": "string",
-                "description": "Specific task to complete"
+                "description": "要完成的特定任务"
             },
             "context": {
                 "type": "string",
-                "description": "Context information related to the task",
+                "description": "与任务相关的上下文信息",
                 "default": ""
             },
             "goal": {
                 "type": "string",
-                "description": "Completion goal of the task",
+                "description": "任务的完成目标",
                 "default": ""
             },
             "files": {
                 "type": "array",
                 "items": {"type": "string"},
-                "description": "Related file path list, used for file question answering and processing",
+                "description": "相关文件路径列表，用于文件问答和处理",
                 "default": []
             }
         },
@@ -83,4 +83,4 @@ class SubAgentTool:
                 "success": False,
                 "stdout": "",
                 "stderr": f"Sub-agent execution failed: {str(e)}"
-            } 
+            }

jarvis/jarvis_tools/execute_shell.py

@@ -1,57 +1,86 @@
+# Shell command execution module
+# 
+# Provides functionality to execute shell commands safely with:
+# - Command escaping
+# - Output capturing
+# - Temporary file management
+# - Error handling
 from typing import Dict, Any
 import os
 import tempfile
 from pathlib import Path
-
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-
-
-
 class ShellTool:
+    """Shell command execution tool
+    
+    Attributes:
+        name: Tool identifier used in API
+        description: Tool description for API documentation
+        parameters: JSON schema for command parameters
+    """
     name = "execute_shell"
-    description = """Execute shell command and return result"""
-
+    description = "执行Shell命令并返回结果"
     parameters = {
         "type": "object",
         "properties": {
             "command": {
                 "type": "string",
-                "description": "Shell command to execute"
+                "description": "要执行的Shell命令"
             }
         },
         "required": ["command"]
     }
-
-
     def _escape_command(self, cmd: str) -> str:
-        """Escape special characters in command"""
+        """Escape special characters in command to prevent shell injection
+        
+        Args:
+            cmd: Raw command string
+            
+        Returns:
+            Escaped command string with single quotes properly handled
+        """
         return cmd.replace("'", "'\"'\"'")
-
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """Execute shell command"""
+        """Execute shell command and capture output
+        
+        Steps:
+        1. Validate and clean input command
+        2. Create temporary file for output capture
+        3. Execute command with output redirection
+        4. Read and process output file
+        5. Clean up temporary resources
+        6. Return structured results
+        
+        Args:
+            args: Dictionary containing 'command' parameter
+            
+        Returns:
+            Dictionary with:
+            - success: Boolean indicating command execution status
+            - stdout: Command output
+            - stderr: Error message if execution failed
+        """
         try:
+            # Get and clean command input
             command = args["command"].strip()
             
-            # Generate temporary file name
+            # Generate temporary file name using process ID for uniqueness
             output_file = os.path.join(tempfile.gettempdir(), f"jarvis_shell_{os.getpid()}.log")
             
-            # Escape special characters in command
+            # Escape special characters in command to prevent injection
             escaped_command = self._escape_command(command)
             
-            # Modify command to use script
+            # Use script command to capture both stdout and stderr
             tee_command = f"script -q -c '{escaped_command}' {output_file}"
             
-            PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
-            
-            # Execute command
+            # Execute command and capture return code
             return_code = os.system(tee_command)
             
-            # Read output file
+            # Read and process output file
             try:
                 with open(output_file, 'r', encoding='utf-8', errors='replace') as f:
                     output = f.read()
-                    # Remove header and footer added by script
+                    # Remove header and footer added by script command
                     if output:
                         lines = output.splitlines()
                         if len(lines) > 2:
@@ -62,6 +91,7 @@ class ShellTool:
                 # Clean up temporary file
                 Path(output_file).unlink(missing_ok=True)
             
+            # Return successful result
             return {
                 "success": True,
                 "stdout": output,
@@ -69,7 +99,7 @@ class ShellTool:
             }
                 
         except Exception as e:
-            # Ensure temporary file is cleaned up
+            # Ensure temporary file is cleaned up even if error occurs
             if 'output_file' in locals():
                 Path(output_file).unlink(missing_ok=True)
             PrettyOutput.print(str(e), OutputType.ERROR)
@@ -77,4 +107,4 @@ class ShellTool:
                 "success": False,
                 "stdout": "",
                 "stderr": str(e)
-            } 
+            }

jarvis/jarvis_tools/execute_shell_script.py

@@ -8,13 +8,13 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class ShellScriptTool:
     name = "execute_shell_script"
-    description = """Execute shell script file and return result"""
+    description = "执行Shell脚本文件并返回结果"
     parameters = {
         "type": "object",
         "properties": {
             "script_content": {
                 "type": "string",
-                "description": "Content of the shell script to execute"
+                "description": "要执行的Shell脚本内容"
             }
         },
         "required": ["script_content"]
@@ -55,4 +55,4 @@ class ShellScriptTool:
                 "success": False,
                 "stdout": "",
                 "stderr": str(e)
-            }
+            }

jarvis/jarvis_tools/file_operation.py

@@ -1,20 +1,22 @@
 from typing import Dict, Any
 import os
 
+from yaspin import yaspin
+
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 
 class FileOperationTool:
     name = "file_operation"
-    description = "File operations for reading and writing multiple files"
+    description = "用于读写多个文件的操作工具"
     parameters = {
         "type": "object",
         "properties": {
             "operation": {
                 "type": "string",
                 "enum": ["read", "write"],
-                "description": "Type of file operation to perform (read or write multiple files)"
+                "description": "要执行的文件操作类型（读取或写入多个文件）"
             },
             "files": {
                 "type": "array",
@@ -26,56 +28,77 @@ class FileOperationTool:
                     },
                     "required": ["path"]
                 },
-                "description": "List of files to operate on"
+                "description": "要操作的文件列表"
             }
         },
         "required": ["operation", "files"]
     }
 
-    def _handle_single_file(self, operation: str, filepath: str, content: str = "") -> Dict[str, Any]:
+    def _handle_single_file(self, operation: str, filepath: str, content: str = "", 
+                          start_line: int = 1, end_line: int = -1) -> Dict[str, Any]:
         """Handle operations for a single file"""
         try:
             abs_path = os.path.abspath(filepath)
-            PrettyOutput.print(f"文件操作: {operation} - {abs_path}", OutputType.INFO)
-            
             if operation == "read":
-                if not os.path.exists(abs_path):
-                    PrettyOutput.print(f"文件不存在: {abs_path}", OutputType.WARNING)
-                    return {
-                        "success": False,
-                        "stdout": "",
-                        "stderr": f"文件不存在: {abs_path}"
-                    }
+                with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
+                    if not os.path.exists(abs_path):
+                        return {
+                            "success": False,
+                            "stdout": "",
+                            "stderr": f"文件不存在: {abs_path}"
+                        }
+                        
+                    if os.path.getsize(abs_path) > 10 * 1024 * 1024:  # 10MB
+                        return {
+                            "success": False,
+                            "stdout": "",
+                            "stderr": "File too large (>10MB)"
+                        }
+                        
+                    with open(abs_path, 'r', encoding='utf-8') as f:
+                        lines = f.readlines()
+                    
                     
-                if os.path.getsize(abs_path) > 10 * 1024 * 1024:  # 10MB
-                    PrettyOutput.print(f"文件太大: {abs_path}", OutputType.WARNING)
+                    total_lines = len(lines)
+                    start_line = start_line if start_line >= 0 else total_lines + start_line + 1
+                    end_line = end_line if end_line >= 0 else total_lines + end_line + 1
+                    start_line = max(1, min(start_line, total_lines))
+                    end_line = max(1, min(end_line, total_lines))
+                    if end_line == -1:
+                        end_line = total_lines
+                    
+                    if start_line > end_line:
+                        spinner.text = "无效的行范围"
+                        spinner.fail("❌")
+                        error_msg = f"无效的行范围 [{start_line, end_line}] (文件总行数: {total_lines})"
+                        return {
+                            "success": False,
+                            "stdout": "",
+                            "stderr": error_msg
+                        }
+                    
+                    content = "".join(lines[start_line - 1:end_line])
+                    output = f"\n文件: {abs_path}\n行: [{start_line}-{end_line}]\n{content}" + "\n\n" + "="*80 + "\n\n"
+                    
+                    spinner.text = f"文件读取完成: {abs_path}"
+                    spinner.ok("✅")
                     return {
-                        "success": False,
-                        "stdout": "",
-                        "stderr": "File too large (>10MB)"
+                        "success": True,
+                        "stdout": output,
+                        "stderr": ""
                     }
-                    
-                content = open(abs_path, 'r', encoding='utf-8').read()
-                output = f"File: {abs_path}\n{content}"
-                
-                return {
-                    "success": True,
-                    "stdout": output,
-                    "stderr": ""
-                }
-                
             elif operation == "write":
-                os.makedirs(os.path.dirname(os.path.abspath(abs_path)), exist_ok=True)
-                with open(abs_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                
-                PrettyOutput.print(f"写入文件: {abs_path}", OutputType.INFO)
-                return {
-                    "success": True,
-                    "stdout": f"Successfully wrote content to {abs_path}",
-                    "stderr": ""
-                }
-            PrettyOutput.print(f"未知操作: {operation}", OutputType.WARNING)
+                with yaspin(text=f"正在写入文件: {abs_path}...", color="cyan") as spinner:
+                    os.makedirs(os.path.dirname(os.path.abspath(abs_path)), exist_ok=True)
+                    with open(abs_path, 'w', encoding='utf-8') as f:
+                        f.write(content)
+                    spinner.text = f"文件写入完成: {abs_path}"
+                    spinner.ok("✅")
+                    return {
+                        "success": True,
+                        "stdout": f"Successfully wrote content to {abs_path}",
+                        "stderr": ""
+                    }
             return {
                 "success": False,
                 "stdout": "",
@@ -120,7 +143,13 @@ class FileOperationTool:
                     continue
                 
                 content = file_info.get("content", "") if operation == "write" else ""
-                result = self._handle_single_file(operation, file_info["path"].strip(), content)
+                result = self._handle_single_file(
+                    operation,
+                    file_info["path"].strip(),
+                    content,
+                    file_info.get("start_line", 1),
+                    file_info.get("end_line", -1)
+                )
                 
                 if result["success"]:
                     all_outputs.append(result["stdout"])
@@ -143,4 +172,4 @@ class FileOperationTool:
                 "success": False,
                 "stdout": "",
                 "stderr": f"File operation failed: {str(e)}"
-            } 
+            }