jarvis-ai-assistant 0.1.138__py3-none-any.whl → 0.1.141__py3-none-any.whl

jarvis/jarvis_tools/ask_user.py

@@ -1,11 +1,16 @@
+# 导入所需的类型注解模块
 from typing import Dict, Any
 
+# 导入多行输入工具和输出工具
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+# 定义AskUserTool类，用于向用户提问
 class AskUserTool:
     name="ask_user"
     description="""当完成任务所需的信息缺失或关键决策信息不足时，向用户提问。用户可以输入多行文本，以空行结束。使用场景：1. 需要用户提供更多信息以完成任务；2. 需要用户做出关键决策；3. 需要用户确认重要操作；4. 需要用户提供额外信息"""
+    labels=['user', 'interaction', 'input']  # 工具标签
+    # 定义参数结构，指定必须包含的问题字段
     parameters={
         "type": "object",
         "properties": {
@@ -19,23 +24,29 @@ class AskUserTool:
 
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute the operation of asking the user
+        """执行向用户提问的操作
 
         Args:
-            args: A dictionary containing the question
+            args: 一个包含问题的字典
 
         Returns:
-            Dict: A dictionary containing the user's response
+            Dict: 一个包含用户响应的字典
         """
         try:
+            # 从参数中获取问题
             question = args["question"]
 
-            # Display the question
+            # 获取agent对象并重置工具调用计数
+            agent = args["agent"]
+            agent.reset_tool_call_count()
+
+            # 显示问题给用户
             PrettyOutput.print(f"问题: {question}", OutputType.SYSTEM)
 
-            # Get user input
+            # 获取用户输入
             user_response = get_multiline_input("请输入您的答案 (输入空行结束)")
 
+            # 返回成功响应，包含用户输入的内容
             return {
                 "success": True,
                 "stdout": user_response,
@@ -43,6 +54,7 @@ class AskUserTool:
             }
 
         except Exception as e:
+            # 如果发生异常，返回失败响应，包含错误信息
             return {
                 "success": False,
                 "stdout": "",

jarvis/jarvis_tools/base.py

@@ -17,12 +17,14 @@ class Tool:
         self.description = description
         self.parameters = parameters
         self.func = func
+        self.labels = []  # 默认空标签列表
     def to_dict(self) -> Dict:
         """将工具对象转换为字典格式，主要用于序列化"""
         return {
             "name": self.name,
             "description": self.description,
-            "parameters": json.dumps(self.parameters, ensure_ascii=False)
+            "parameters": json.dumps(self.parameters, ensure_ascii=False),
+            "labels": self.labels
         }
     def execute(self, arguments: Dict) -> Dict[str, Any]:
         """

jarvis/jarvis_tools/chdir.py

@@ -4,6 +4,7 @@ import os
 class ChdirTool:
     name = "chdir"
     description = "更改当前工作目录"
+    labels = ['file', 'system', 'directory']
     parameters = {
         "type": "object",
         "properties": {

jarvis/jarvis_tools/create_code_agent.py

@@ -1,8 +1,8 @@
 from typing import Dict, Any
 import os
 from jarvis.jarvis_code_agent.code_agent import CodeAgent
-from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.code_review import CodeReviewTool, extract_code_report
+from jarvis.jarvis_git_utils.git_commiter import GitCommitTool
+from jarvis.jarvis_code_analysis.code_review import CodeReviewTool, extract_code_report
 from jarvis.jarvis_utils.git_utils import get_latest_commit_hash, has_uncommitted_changes
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -10,7 +10,8 @@ class CreateCodeAgentTool:
     """用于管理代码开发工作流的工具"""
 
     name = "create_code_agent"
-    description = "技术代码实现和开发过程管理工具"
+    description = "技术代码实现和开发过程管理工具，当需要修改代码时使用，如果只是简单文件修改，使用文件操作或者脚本即可"
+    labels = ['code', 'development', 'automation']
     parameters = {
         "requirement": """代码实现的技术规范，必须包含以下完整信息：
 1. 项目代码目录 - 项目根目录的绝对路径

jarvis/jarvis_tools/create_sub_agent.py

@@ -10,6 +10,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 class SubAgentTool:
     name = "create_sub_agent"
     description = "创建子代理以处理特定任务，子代理将生成任务总结报告"
+    labels = ['agent', 'automation', 'task']
     parameters = {
         "type": "object",
         "properties": {

jarvis/jarvis_tools/execute_script.py

@@ -0,0 +1,170 @@
+from typing import Dict, Any
+import os
+import tempfile
+from pathlib import Path
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class ScriptTool:
+    """Combined script execution tool
+    
+    Executes scripts with any interpreter with a unified interface.
+    """
+    name = "execute_script"
+    description = "执行脚本并返回结果，支持任意解释器。注意：由于模型上下文长度限制，请避免在脚本中输出大量信息，应该使用rg过滤输出"
+    labels = ['system', 'shell', 'python', 'execution', 'script']
+    parameters = {
+        "type": "object",
+        "properties": {
+            "interpreter": {
+                "type": "string",
+                "description": "脚本解释器: 如bash, python3, expect, perl, ruby等任意解释器。如需直接执行shell命令, 可使用bash作为解释器"
+            },
+            "script_type": {
+                "type": "string",
+                "enum": ["shell_command", "shell_script", "python_script"],
+                "description": "已废弃，请使用interpreter参数。脚本类型: shell_command (Shell命令), shell_script (Shell脚本), python_script (Python脚本)"
+            },
+            "script_content": {
+                "type": "string",
+                "description": "要执行的脚本内容"
+            }
+        },
+        "required": ["script_content"]
+    }
+
+    # Map of common file extensions for interpreters (can be extended as needed)
+    INTERPRETER_EXTENSIONS = {
+        "bash": "sh",
+        "sh": "sh",
+        "python": "py",
+        "python2": "py",
+        "python3": "py",
+        "perl": "pl",
+        "ruby": "rb",
+        "node": "js",
+        "nodejs": "js",
+        "php": "php",
+        "powershell": "ps1",
+        "pwsh": "ps1",
+        "R": "r",
+        "Rscript": "r",
+        "julia": "jl",
+        "lua": "lua",
+        "go": "go",
+        "awk": "awk",
+        "kotlin": "kt",
+        "java": "java",
+        "javac": "java",
+        "scala": "scala",
+        "swift": "swift",
+        "gcc": "c",
+        "g++": "cpp",
+    }
+
+    def _execute_script_with_interpreter(self, interpreter: str, script_content: str) -> Dict[str, Any]:
+        """Execute a script with the specified interpreter
+        
+        Args:
+            interpreter: The interpreter to use (any valid interpreter command)
+            script_content: Content of the script
+            
+        Returns:
+            Dictionary with execution results
+        """
+        try:
+            # Get file extension for the interpreter
+            extension = self.INTERPRETER_EXTENSIONS.get(interpreter, "script")
+            
+            # Create temporary script file
+            script_path = os.path.join(tempfile.gettempdir(), f"jarvis_{interpreter.replace('/', '_')}_{os.getpid()}.{extension}")
+            output_file = os.path.join(tempfile.gettempdir(), f"jarvis_output_{os.getpid()}.log")
+            try:
+                with open(script_path, 'w', encoding='utf-8', errors="ignore") as f:
+                    f.write(script_content)
+                
+                # Use script command to capture both stdout and stderr
+                tee_command = f"script -q -c '{interpreter} {script_path}' {output_file}"
+                
+                # Execute command and capture return code
+                os.system(tee_command)
+                
+                # Read and process output file
+                try:
+                    with open(output_file, 'r', encoding='utf-8', errors='ignore') as f:
+                        output = f.read()
+                        # Remove header and footer added by script command (if any)
+                        if output:
+                            lines = output.splitlines()
+                            if len(lines) > 2:
+                                output = "\n".join(lines[1:-1])
+                except Exception as e:
+                    output = f"读取输出文件失败: {str(e)}"
+                    
+                # Return successful result
+                return {
+                    "success": True,
+                    "stdout": output,
+                    "stderr": "",
+                }
+                
+            finally:
+                # Clean up temporary files
+                Path(script_path).unlink(missing_ok=True)
+                Path(output_file).unlink(missing_ok=True)
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": str(e)
+            }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute script based on interpreter and content
+        
+        Args:
+            args: Dictionary containing interpreter (or script_type) and script_content
+            
+        Returns:
+            Dictionary with execution results
+        """
+        try:
+            script_content = args.get("script_content", "").strip()
+            if not script_content:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Missing or empty script_content parameter"
+                }
+            
+            # Get interpreter, with fallback to script_type for backward compatibility
+            interpreter = args.get("interpreter")
+            script_type = args.get("script_type")
+            
+            # Handle backward compatibility
+            if interpreter is None and script_type is not None:
+                if script_type == "shell_command":
+                    # For direct shell commands, use bash -c
+                    return self._execute_script_with_interpreter("bash -c", script_content)
+                elif script_type == "shell_script":
+                    interpreter = "bash"
+                elif script_type == "python_script":
+                    interpreter = "python"
+            
+            # Default to bash if nothing specified
+            if interpreter is None:
+                interpreter = "bash"
+                
+            # Execute the script with the specified interpreter
+            return self._execute_script_with_interpreter(interpreter, script_content)
+                
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": str(e)
+            } 

jarvis/jarvis_tools/file_analyzer.py

@@ -1,282 +1,133 @@
-from typing import Dict, Any
+from typing import Dict, Any, List
 import os
-import pathlib
 
-from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
+from yaspin import yaspin
+from yaspin.spinners import Spinners
 
 class FileAnalyzerTool:
-    """
-    单文件分析工具
-    使用agent深入分析单个文件的结构、实现细节和代码质量
-    """
-
     name = "file_analyzer"
-    description = "深入分析单个文件的结构、实现细节和代码质量"
+    description = """分析文件内容并提取关键信息。支持的文件：文本文件、word文档、pdf文件、图片"""
+    labels = ['file', 'analysis', 'code']
     parameters = {
         "type": "object",
         "properties": {
-            "file_path": {
-                "type": "string",
-                "description": "要分析的文件路径"
+            "file_paths": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "要分析的文件路径列表"
             },
-            "root_dir": {
+            "prompt": {
                 "type": "string",
-                "description": "项目根目录路径（可选）",
-                "default": "."
-            },
-            "objective": {
-                "type": "string",
-                "description": "描述本次文件分析的目标和用途，例如'准备重构该文件'或'理解该文件在项目中的作用'",
-                "default": ""
+                "description": "分析文件的提示词，指导模型提取什么样的信息"
             }
         },
-        "required": ["file_path"]
+        "required": ["file_paths", "prompt"]
     }
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        执行单文件分析工具
+        """执行文件分析操作
 
         Args:
-            args: 包含参数的字典
+            args: 包含文件路径列表和提示词的字典
 
         Returns:
-            包含执行结果的字典
+            Dict: 包含分析结果的字典
         """
-        # 存储原始目录
-        original_dir = os.getcwd()
-
         try:
-            # 解析参数
-            file_path = args.get("file_path", "")
-            root_dir = args.get("root_dir", ".")
-            objective = args.get("objective", "")
-
-            # 验证参数
-            if not file_path:
+            file_paths = args["file_paths"]
+            prompt = args["prompt"]
+            
+            agent = args["agent"]
+            agent.reset_tool_call_count()
+
+            # 验证文件路径
+            valid_files = []
+            for file_path in file_paths:
+                if os.path.exists(file_path):
+                    valid_files.append(file_path)
+                else:
+                    PrettyOutput.print(f"文件不存在: {file_path}", OutputType.WARNING)
+            
+            if not valid_files:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "必须提供文件路径"
+                    "stderr": "没有找到有效的文件"
                 }
 
-            # 确保文件路径是相对于root_dir的，如果是绝对路径则转换为相对路径
-            abs_file_path = os.path.abspath(file_path)
-            abs_root_dir = os.path.abspath(root_dir)
-
-            if abs_file_path.startswith(abs_root_dir):
-                rel_file_path = os.path.relpath(abs_file_path, abs_root_dir)
-            else:
-                rel_file_path = file_path
-
-            # 获取文件扩展名和文件名
-            file_ext = pathlib.Path(file_path).suffix
-            file_name = os.path.basename(file_path)
-
-            # 创建agent的system prompt
-            system_prompt = self._create_system_prompt(
-                rel_file_path, file_name, file_ext, root_dir, objective
-            )
-
-            # 创建agent的summary prompt
-            summary_prompt = self._create_summary_prompt(rel_file_path, file_name)
-
-            # 切换到根目录
-            os.chdir(root_dir)
-
-            # 检查文件是否存在
-            if not os.path.isfile(rel_file_path):
+            # 创建thinking平台实例
+            platform_registry = PlatformRegistry.get_global_platform_registry()
+            platform = platform_registry.get_thinking_platform()
+            
+            if not platform:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": f"文件不存在: {rel_file_path}"
+                    "stderr": "无法创建thinking平台实例"
                 }
-
-            # 构建使用的工具
-            from jarvis.jarvis_tools.registry import ToolRegistry
-            tool_registry = ToolRegistry()
-            tool_registry.use_tools([
-                "execute_shell",
-                "read_code",
-                "find_symbol",
-                "function_analyzer",
-                "find_caller"
-            ])
-
-            # 创建并运行agent
-            analyzer_agent = Agent(
-                system_prompt=system_prompt,
-                name=f"FileAnalyzer-{file_name}",
-                description=f"分析 {file_name} 文件的结构和实现",
-                summary_prompt=summary_prompt,
-                platform=PlatformRegistry().get_normal_platform(),
-                output_handler=[tool_registry],
-                execute_tool_confirm=False,
-                auto_complete=True
-            )
-
-            # 运行agent并获取结果
-            task_input = f"深入分析文件 {rel_file_path} 的结构、实现细节和代码质量"
-            result = analyzer_agent.run(task_input)
-
+            
+            # 设置系统消息
+            system_message = """你是一个文件分析助手。你的任务是分析提供的文件内容，并根据用户的提示提取关键信息。
+请保持客观，只关注文件中实际存在的内容。如果无法确定某些信息，请明确指出。
+请以结构化的方式组织你的回答，使用标题、列表和代码块等格式来提高可读性。"""
+            platform.set_system_message(system_message)
+            
+            # 上传文件
+            with yaspin(Spinners.dots, text="正在上传文件...") as spinner:
+                try:
+                    upload_result = platform.upload_files(valid_files)
+                    if not upload_result:
+                        spinner.text = "文件上传失败"
+                        spinner.fail("❌")
+                        return {
+                            "success": False,
+                            "stdout": "",
+                            "stderr": "文件上传失败"
+                        }
+                    spinner.ok("✅")
+                except Exception as e:
+                    spinner.text = "文件上传失败"
+                    spinner.fail("❌")
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": f"文件上传失败: {str(e)}"
+                    }
+                
+            prompt = f"""我上传了文件，收到请回复“已接收到文件”"""
+            platform.chat_until_success(prompt)
+
+            platform.set_suppress_output(False)
+            
+            # 构建分析请求
+            analysis_request = f"""
+请根据以下提示分析这些文件。
+{prompt}
+
+请提供详细的分析结果和理由。"""
+
+            # 发送请求并获取分析结果
+            with yaspin(Spinners.dots, text="正在分析文件...") as spinner:
+                analysis_result = platform.chat_until_success(analysis_request)
+                spinner.text = "分析完成"
+                spinner.ok("✅")
+            
+            # 清理会话
+            platform.delete_chat()
+            
             return {
                 "success": True,
-                "stdout": result,
+                "stdout": analysis_result,
                 "stderr": ""
             }
 
         except Exception as e:
-            PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
                 "stdout": "",
                 "stderr": f"文件分析失败: {str(e)}"
             }
-        finally:
-            # 恢复原始目录
-            os.chdir(original_dir)
-
-    def _create_system_prompt(self, file_path: str, file_name: str, file_ext: str,
-                             root_dir: str, objective: str) -> str:
-        """
-        创建Agent的system prompt
-
-        Args:
-            file_path: 文件路径
-            file_name: 文件名
-            file_ext: 文件扩展名
-            root_dir: 代码库根目录
-            objective: 分析目标
-
-        Returns:
-            系统提示文本
-        """
-        objective_text = f"\n\n## 分析目标\n{objective}" if objective else ""
-
-        return f"""# 文件分析专家
-
-## 任务描述
-分析文件 `{file_path}` 的结构、实现细节和代码质量，专注于分析目标所需的内容，生成有针对性、深入且有洞察力的文件分析报告。{objective_text}
-
-## 工具使用优先级
-1. **优先使用 read_code**: 直接读取文件内容是分析文件的首选方式
-2. **优先使用 execute_shell**:
-   - 使用 rg 搜索文件内容: `rg "pattern" {file_path}`
-   - 使用 loc 统计代码: `loc {file_path}`
-3. **仅在必要时使用其他分析工具**
-
-## 文件信息
-- 文件路径: `{file_path}`
-- 文件名称: `{file_name}`
-- 文件类型: `{file_ext}`
-- 项目根目录: `{root_dir}`
-
-## 分析策略
-1. 首先使用read_code直接读取整个文件内容或分段读取
-2. 使用rg命令搜索文件中的特定模式和结构
-3. 使用loc命令获取文件统计信息
-4. 根据文件类型和分析目标确定重点关注的方面
-5. 保证分析的完整性，收集充分的信息后再得出结论
-
-## 分析步骤
-以下步骤应根据具体分析目标灵活应用:
-
-1. **文件基本信息分析**:
-   - 使用 `loc {file_path}` 获取代码统计
-   - 使用 read_code 读取文件头部注释和文档
-   - 确定文件的编程语言和主要功能
-
-2. **结构分析**:
-   - 使用 read_code 阅读完整文件
-   - 对于大文件，可分段读取主要部分
-   - 识别文件的主要组成部分:
-     - 类定义: `rg "class\\s+" {file_path}`
-     - 函数定义: `rg "def\\s+|function\\s+" {file_path}`
-     - 重要变量: `rg "const\\s+|var\\s+|let\\s+" {file_path}`
-
-3. **核心组件分析**:
-   - 识别文件中的关键接口、类和函数
-   - 使用 rg 搜索重要的代码模式
-   - 分析组件间的交互和依赖关系
-
-4. **实现细节分析**:
-   - 读取并分析关键函数的实现
-   - 关注异常处理: `rg "try|catch|except" {file_path}`
-   - 检查资源管理: `rg "open|close|with" {file_path}`
-
-5. **引用分析**:
-   - 找出引用的外部依赖: `rg "import|require|include" {file_path}`
-   - 分析与其他模块的交互
-
-## 分析工具使用指南
-
-### read_code
-- **首选工具**: 用于读取和分析文件内容
-- **用法指南**:
-  - 读取整个文件: 直接指定文件路径
-  - 读取部分内容: 指定文件路径和行范围
-  - 读取头部或关键部分: 根据目的选择合适的行范围
-
-### execute_shell
-- **用途**: 执行辅助命令进行分析
-- **推荐命令**:
-  - `rg "pattern" {file_path}`: 在文件中搜索模式
-  - `loc {file_path}`: 获取文件代码统计
-  - `rg -n "class|def|function" {file_path}`: 查找结构元素
-
-### 其他专业工具
-- **使用时机**: 仅当read_code和execute_shell不足以完成分析时
-- **使用前提**: 必须先尝试使用基本工具解决问题
-- **选择原则**: 根据实际需要选择最简洁有效的工具
-
-## 分析框架适应
-根据文件类型和编程范式调整分析重点:
-
-### 不同编程范式
-- 面向对象: 类层次、继承、封装、接口实现
-- 函数式: 函数组合、不可变性、纯函数
-- 过程式: 流程控制、状态管理、数据处理
-- 声明式: 规则定义、约束表达、模式匹配
-
-### 不同文件类型
-- 源代码文件: 实现逻辑、算法、接口设计
-- 配置文件: 参数设置、环境变量、系统选项
-- 模板文件: 渲染逻辑、变量占位符、条件分支
-- 数据文件: 结构组织、关系定义、索引设计
-
-## 输出要求
-- 直接回应分析目标的关键问题
-- 提供与目标相关的深入洞察
-- 分析内容应直接服务于分析目标
-- 避免与目标无关的冗余信息
-- 使用具体代码片段支持分析结论
-- 提供针对分析目标的具体建议
-- 保证全面分析相关信息后再得出结论"""
-
-    def _create_summary_prompt(self, file_path: str, file_name: str) -> str:
-        """
-        创建Agent的summary prompt
-
-        Args:
-            file_path: 文件路径
-            file_name: 文件名
-
-        Returns:
-            总结提示文本
-        """
-        return f"""# 文件分析报告: `{file_name}`
-
-## 报告要求
-生成一份完全以分析目标为导向的文件分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
-
-- 专注回答分析目标提出的问题
-- 只包含与分析目标直接相关的发现和洞察
-- 完全跳过与分析目标无关的内容，无需做全面分析
-- 分析深度应与目标的具体需求匹配
-- 使用具体的代码片段和实例支持你的观点
-- 以清晰的Markdown格式呈现，简洁明了
-
-在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的文件概览，而是直接解决分析目标中提出的具体问题。"""