jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_tools/cli/main.py

@@ -1,178 +1,254 @@
-import sys
+import json
+from typing import Optional
+
+import typer
+from tabulate import tabulate
 
 from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 
+app = typer.Typer(help="Jarvis 工具系统命令行界面")
 
-def main() -> int:
-    """
-    命令行工具入口，提供工具列表查看和工具调用功能
-
-    功能:
-        1. 列出所有可用工具 (list命令)
-        2. 调用指定工具 (call命令)
-
-    参数:
-        通过命令行参数传递，包括:
-        - list: 列出工具
-            --json: 以JSON格式输出
-            --detailed: 显示详细信息
-        - call: 调用工具
-            tool_name: 工具名称
-            --args: 工具参数(JSON格式)
-            --args-file: 从文件加载工具参数
-
-    返回值:
-        int: 0表示成功，非0表示错误
-    """
-    import argparse
-    import json
-
-    init_env("欢迎使用 Jarvis-Tools，您的工具系统已准备就绪！")
-
-    parser = argparse.ArgumentParser(description="Jarvis 工具系统命令行界面")
-    subparsers = parser.add_subparsers(dest="command", help="命令")
-
-    # 列出工具子命令
-    list_parser = subparsers.add_parser("list", help="列出所有可用工具")
-    list_parser.add_argument("--json", action="store_true", help="以JSON格式输出")
-    list_parser.add_argument("--detailed", action="store_true", help="显示详细信息")
-
-    # 调用工具子命令
-    call_parser = subparsers.add_parser("call", help="调用指定工具")
-    call_parser.add_argument("tool_name", help="要调用的工具名称")
-    call_parser.add_argument("--args", type=str, help="工具参数 (JSON格式)")
-    call_parser.add_argument(
-        "--args-file", type=str, help="从文件加载工具参数 (JSON格式)"
-    )
-
-    # 统计子命令
-    stat_parser = subparsers.add_parser("stat", help="显示工具调用统计信息")
-    stat_parser.add_argument("--json", action="store_true", help="以JSON格式输出")
 
-    args = parser.parse_args()
 
-    # 初始化工具注册表
+@app.command("list")
+def list_tools(
+    as_json: bool = typer.Option(False, "--json", help="以JSON格式输出"),
+    detailed: bool = typer.Option(False, "--detailed", help="显示详细信息"),
+):
+    """列出所有可用工具"""
     registry = ToolRegistry()
+    tools = registry.get_all_tools()
 
-    if args.command == "list":
-        tools = registry.get_all_tools()  # 从注册表获取所有工具信息
-
-        if args.json:
-            if args.detailed:
-                print(
-                    json.dumps(tools, indent=2, ensure_ascii=False)
-                )  # 输出完整JSON格式
-            else:
-                simple_tools = [
-                    {"name": t["name"], "description": t["description"]} for t in tools
-                ]  # 简化工具信息
-                print(json.dumps(simple_tools, indent=2, ensure_ascii=False))
+    if as_json:
+        if detailed:
+            PrettyOutput.print(
+                json.dumps(tools, indent=2, ensure_ascii=False),
+                OutputType.CODE,
+                lang="json",
+            )
         else:
-            PrettyOutput.section("可用工具列表", OutputType.SYSTEM)  # 使用美化输出
-            for tool in tools:
-                print(f"\n✅ {tool['name']}")
-                print(f"   描述: {tool['description']}")
-                if args.detailed:
-                    print(f"   参数:")
-                    print(tool["parameters"])  # 显示详细参数信息
-
-    elif args.command == "stat":
-        from tabulate import tabulate
-
+            simple_tools = [
+                {"name": t["name"], "description": t["description"]} for t in tools
+            ]
+            PrettyOutput.print(
+                json.dumps(simple_tools, indent=2, ensure_ascii=False),
+                OutputType.CODE,
+                lang="json",
+            )
+    else:
+        PrettyOutput.section("可用工具列表", OutputType.SYSTEM)
+        # 为避免 PrettyOutput 对每行加框造成信息稀疏，先拼接字符串再统一打印
+        lines = []
+        import json as _json  # local import to ensure available
+        for tool in tools:
+            lines.append(f"\n{tool['name']}")
+            lines.append(f"   描述: {tool['description']}")
+            if detailed:
+                lines.append("   参数:")
+                # 使用 Markdown 代码块统一展示参数
+                lines.append("```json")
+                try:
+                    lines.append(_json.dumps(tool["parameters"], ensure_ascii=False, indent=2))
+                except Exception:
+                    lines.append(str(tool.get("parameters")))
+                lines.append("```")
+        PrettyOutput.print("\n".join(lines), OutputType.INFO, lang="markdown")
+
+
+@app.command("stat")
+def stat_tools(
+    as_json: bool = typer.Option(False, "--json", help="以JSON格式输出"),
+    last_days: Optional[int] = typer.Option(
+        None, "--days", help="显示最近N天的统计（默认显示所有历史数据）"
+    ),
+    format: str = typer.Option(
+        "table", "--format", help="显示格式: table, chart, summary"
+    ),
+):
+    """显示工具调用统计信息"""
+    from jarvis.jarvis_stats.stats import StatsManager
+
+    if format == "table":
+        registry = ToolRegistry()
         stats = registry._get_tool_stats()
         tools = registry.get_all_tools()
 
-        # 构建统计表格数据
         table_data = []
         for tool in tools:
             name = tool["name"]
             count = stats.get(name, 0)
-            table_data.append([name, count])
+            if count > 0:  # 只显示有调用记录的工具
+                table_data.append([name, count])
 
-        # 按调用次数降序排序
         table_data.sort(key=lambda x: x[1], reverse=True)
 
-        if args.json:
-            print(json.dumps(dict(table_data), indent=2))
-        else:
-            PrettyOutput.section("工具调用统计", OutputType.SYSTEM)
-            print(
-                tabulate(table_data, headers=["工具名称", "调用次数"], tablefmt="grid")
+        if as_json:
+            PrettyOutput.print(
+                json.dumps(dict(table_data), indent=2), OutputType.CODE, lang="json"
             )
-
-        return 0
-
-    elif args.command == "call":
-        tool_name = args.tool_name
-        tool_obj = registry.get_tool(tool_name)
-
-        if not tool_obj:
-            PrettyOutput.print(f"错误: 工具 '{tool_name}' 不存在", OutputType.ERROR)
-            available_tools = ", ".join([t["name"] for t in registry.get_all_tools()])
-            print(f"可用工具: {available_tools}")
-            return 1
-
-        # 获取参数: 支持从命令行直接传入或从文件加载
-        tool_args = {}
-        if args.args:
-            try:
-                tool_args = json.loads(args.args)  # 解析JSON格式参数
-            except json.JSONDecodeError:
-                PrettyOutput.print("错误: 参数必须是有效的JSON格式", OutputType.ERROR)
-                return 1
-
-        elif args.args_file:
-            try:
-                with open(args.args_file, "r", encoding="utf-8") as f:
-                    tool_args = json.load(f)  # 从文件加载JSON参数
-            except (json.JSONDecodeError, FileNotFoundError) as e:
+        else:
+            time_desc = f"最近{last_days}天" if last_days else "所有历史"
+            PrettyOutput.section(f"工具调用统计 ({time_desc})", OutputType.SYSTEM)
+            if table_data:
+                PrettyOutput.print(
+                    tabulate(
+                        table_data, headers=["工具名称", "调用次数"], tablefmt="grid"
+                    ),
+                    OutputType.CODE,
+                    lang="text",
+                )
                 PrettyOutput.print(
-                    f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR
+                    f"\n总计: {len(table_data)} 个工具被使用，共 {sum(x[1] for x in table_data)} 次调用",
+                    OutputType.INFO,
                 )
-                return 1
+            else:
+                PrettyOutput.print("暂无工具调用记录", OutputType.INFO)
+    else:
+        # 使用 stats 系统的高级功能
+        PrettyOutput.section("工具组统计", OutputType.SYSTEM)
+        # 显示所有标记为 tool 组的指标
+        metrics = StatsManager.list_metrics()
+        tool_metrics = []
+
+        for metric in metrics:
+            # 检查是否是工具组的指标
+            if last_days:
+                stats_data = StatsManager.get_stats(
+                    metric_name=metric, last_days=last_days, tags={"group": "tool"}
+                )
+            else:
+                # 获取所有历史数据
+                from datetime import datetime
+
+                stats_data = StatsManager.get_stats(
+                    metric_name=metric,
+                    start_time=datetime(2000, 1, 1),
+                    end_time=datetime.now(),
+                    tags={"group": "tool"},
+                )
+            if stats_data and stats_data.get("records"):
+                tool_metrics.append(metric)
+
+        if tool_metrics:
+            for metric in tool_metrics:
+                if format == "chart":
+                    if last_days:
+                        StatsManager.plot(
+                            metric, last_days=last_days, tags={"group": "tool"}
+                        )
+                    else:
+                        from datetime import datetime
+
+                        StatsManager.plot(
+                            metric,
+                            start_time=datetime(2000, 1, 1),
+                            end_time=datetime.now(),
+                            tags={"group": "tool"},
+                        )
+                elif format == "summary":
+                    if last_days:
+                        StatsManager.show(
+                            metric,
+                            last_days=last_days,
+                            format="summary",
+                            tags={"group": "tool"},
+                        )
+                    else:
+                        from datetime import datetime
+
+                        StatsManager.show(
+                            metric,
+                            start_time=datetime(2000, 1, 1),
+                            end_time=datetime.now(),
+                            format="summary",
+                            tags={"group": "tool"},
+                        )
+        else:
+            PrettyOutput.print("暂无工具调用记录", OutputType.INFO)
+
+
+@app.command("call")
+def call_tool(
+    tool_name: str = typer.Argument(..., help="要调用的工具名称"),
+    args: Optional[str] = typer.Option(None, "--args", help="工具参数 (JSON格式)"),
+    args_file: Optional[str] = typer.Option(
+        None, "--args-file", help="从文件加载工具参数 (JSON格式)"
+    ),
+):
+    """调用指定工具"""
+    registry = ToolRegistry()
+    tool_obj = registry.get_tool(tool_name)
+
+    if not tool_obj:
+        PrettyOutput.print(f"错误: 工具 '{tool_name}' 不存在", OutputType.ERROR)
+        available_tools = ", ".join([t["name"] for t in registry.get_all_tools()])
+        PrettyOutput.print(f"可用工具: {available_tools}", OutputType.INFO)
+        raise typer.Exit(code=1)
+
+    tool_args = {}
+    if args:
+        try:
+            tool_args = json.loads(args)
+        except json.JSONDecodeError:
+            PrettyOutput.print("错误: 参数必须是有效的JSON格式", OutputType.ERROR)
+            raise typer.Exit(code=1)
+    elif args_file:
+        try:
+            with open(args_file, "r", encoding="utf-8") as f:
+                tool_args = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            PrettyOutput.print(f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+
+    required_params = tool_obj.parameters.get("required", [])
+    missing_params = [p for p in required_params if p not in tool_args]
+
+    if missing_params:
+        # 先拼接提示与参数说明，再统一打印，避免循环中逐条打印
+        params = tool_obj.parameters.get("properties", {})
+        lines = [
+            f"错误: 缺少必需参数: {', '.join(missing_params)}",
+            "",
+            "参数说明:",
+        ]
+        for param_name in required_params:
+            param_info = params.get(param_name, {})
+            desc = param_info.get("description", "无描述")
+            lines.append(f"  - {param_name}: {desc}")
+        PrettyOutput.print("\n".join(lines), OutputType.ERROR)
+        raise typer.Exit(code=1)
+
+    result = registry.execute_tool(tool_name, tool_args)
+
+    if result["success"]:
+        PrettyOutput.section(f"工具 {tool_name} 执行成功", OutputType.SUCCESS)
+    else:
+        PrettyOutput.section(f"工具 {tool_name} 执行失败", OutputType.ERROR)
 
-        # 检查必需参数是否完整
-        required_params = tool_obj.parameters.get("required", [])
-        missing_params = [p for p in required_params if p not in tool_args]
+    if result.get("stdout"):
+        PrettyOutput.print("\n输出:", OutputType.INFO)
+        PrettyOutput.print(result["stdout"], OutputType.CODE, lang="text")
 
-        if missing_params:
-            PrettyOutput.print(
-                f"错误: 缺少必需参数: {', '.join(missing_params)}", OutputType.ERROR
-            )
-            print("\n参数说明:")
-            params = tool_obj.parameters.get("properties", {})
-            for param_name in required_params:
-                param_info = params.get(param_name, {})
-                desc = param_info.get("description", "无描述")
-                print(f"  - {param_name}: {desc}")
-            return 1
-
-        # 执行工具并处理结果
-        result = registry.execute_tool(tool_name, tool_args)
-
-        # 显示执行结果
-        if result["success"]:
-            PrettyOutput.section(f"工具 {tool_name} 执行成功", OutputType.SUCCESS)
-        else:
-            PrettyOutput.section(f"工具 {tool_name} 执行失败", OutputType.ERROR)
+    if result.get("stderr"):
+        PrettyOutput.print("\n错误:", OutputType.ERROR)
+        PrettyOutput.print(result["stderr"], OutputType.ERROR, lang="text")
 
-        if result.get("stdout"):
-            print("\n输出:")
-            print(result["stdout"])
+    if not result["success"]:
+        raise typer.Exit(code=1)
 
-        if result.get("stderr"):
-            PrettyOutput.print("\n错误:", OutputType.ERROR)
-            print(result["stderr"])
 
-        return 0 if result["success"] else 1
+def cli():
+    """Typer application entry point"""
+    init_env("欢迎使用 Jarvis-Tools，您的工具系统已准备就绪！")
+    app()
 
-    else:
-        parser.print_help()
 
-    return 0
+def main():
+    """Main entry point for the script"""
+    cli()
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()

jarvis/jarvis_tools/execute_script.py

@@ -2,7 +2,7 @@
 import os
 import tempfile
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, List
 
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -19,6 +19,7 @@ class ScriptTool:
         + "注意：由于模型上下文长度限制，请避免在脚本中输出大量信息，应该使用rg过滤输出。"
         + "与virtual_tty不同，此工具会创建一个临时的脚本文件，并使用脚本命令执行脚本，不具备交互式操作的能力，"
         + "适用于需要执行脚本并获取结果的场景。不适合需要交互式操作的场景（如：ssh连接、sftp传输、gdb/dlv调试等）。"
+        + "在非交互模式（JARVIS_NON_INTERACTIVE=true）下：脚本执行时间限制为5分钟，超时将被终止并返回超时信息；用户无法与命令交互，请不要执行需要交互的命令。"
     )
     parameters = {
         "type": "object",
@@ -74,8 +75,7 @@ class ScriptTool:
         stream.feed(data)
 
         # 清理每行右侧空格，并过滤空行
-        cleaned = []
-        cleaned = []
+        cleaned: List[str] = []
         for y in range(screen.lines):
             line = screen.buffer[y]
             stripped = "".join(char.data for char in line.values()).rstrip()
@@ -116,8 +116,37 @@ class ScriptTool:
                     f"script -q -c '{interpreter} {script_path}' {output_file}"
                 )
 
-                # Execute command and capture return code
-                os.system(tee_command)
+                # Execute command with optional timeout in non-interactive mode
+                from jarvis.jarvis_utils.config import get_script_execution_timeout, is_non_interactive
+                import subprocess
+
+                timed_out = False
+                if is_non_interactive():
+                    try:
+                        proc = subprocess.Popen(tee_command, shell=True)
+                        try:
+                            proc.wait(timeout=get_script_execution_timeout())
+                        except subprocess.TimeoutExpired:
+                            timed_out = True
+                            try:
+                                proc.kill()
+                            except Exception:
+                                pass
+                    except Exception as e:
+                        PrettyOutput.print(str(e), OutputType.ERROR)
+                        # Attempt to read any partial output if available
+                        try:
+                            output = self.get_display_output(output_file)
+                        except Exception as ee:
+                            output = f"读取输出文件失败: {str(ee)}"
+                        return {
+                            "success": False,
+                            "stdout": output,
+                            "stderr": f"执行脚本失败: {str(e)}",
+                        }
+                else:
+                    # Execute command and capture return code
+                    os.system(tee_command)
 
                 # Read and process output file
                 try:
@@ -126,12 +155,19 @@ class ScriptTool:
                 except Exception as e:
                     output = f"读取输出文件失败: {str(e)}"
 
-                # Return successful result
-                return {
-                    "success": True,
-                    "stdout": output,
-                    "stderr": "",
-                }
+                # Return result (handle timeout in non-interactive mode)
+                if is_non_interactive() and timed_out:
+                    return {
+                        "success": False,
+                        "stdout": output,
+                        "stderr": f"执行超时（超过{get_script_execution_timeout()}秒），进程已被终止（非交互模式）。",
+                    }
+                else:
+                    return {
+                        "success": True,
+                        "stdout": output,
+                        "stderr": "",
+                    }
 
             finally:
                 # Clean up temporary files
@@ -173,4 +209,8 @@ class ScriptTool:
 
 if __name__ == "__main__":
     script_tool = ScriptTool()
-    print(script_tool.get_display_output("/home/wangmaobin/code/Jarvis/a.txt"))
+    PrettyOutput.print(
+        script_tool.get_display_output("/path/to/a.txt"),
+        OutputType.CODE,
+        lang="text",
+    )

jarvis/jarvis_tools/file_analyzer.py

@@ -30,7 +30,7 @@ class FileAnalyzerTool:
 
     @staticmethod
     def check() -> bool:
-        return PlatformRegistry().get_thinking_platform().support_upload_files()
+        return PlatformRegistry().get_normal_platform().support_upload_files()
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行文件分析操作
@@ -45,25 +45,31 @@ class FileAnalyzerTool:
             file_paths = args["file_paths"]
             prompt = args["prompt"]
 
-            # 验证文件路径
+            # 验证文件路径（先收集不存在的文件，统一打印一次）
             valid_files = []
+            missing_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)
+                    missing_files.append(file_path)
+            if missing_files:
+                PrettyOutput.print(
+                    "以下文件不存在:\n" + "\n".join(f"  - {p}" for p in missing_files),
+                    OutputType.WARNING,
+                )
 
             if not valid_files:
                 return {"success": False, "stdout": "", "stderr": "没有找到有效的文件"}
 
-            # 创建thinking平台实例
-            platform = PlatformRegistry().get_thinking_platform()
+            # 创建平台实例
+            platform = PlatformRegistry().get_normal_platform()
 
             if not platform:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "无法创建thinking平台实例",
+                    "stderr": "无法创建平台实例",
                 }
 
             # 设置系统消息
@@ -73,19 +79,19 @@ class FileAnalyzerTool:
             platform.set_system_prompt(system_message)
 
             # 上传文件
-            print(f"📤 正在上传文件...")
+
             try:
                 upload_result = platform.upload_files(valid_files)
                 if not upload_result:
-                    print(f"❌ 文件上传失败")
+                    PrettyOutput.print("文件上传失败", OutputType.ERROR)
                     return {
                         "success": False,
                         "stdout": "",
                         "stderr": "文件上传失败",
                     }
-                print(f"✅ 文件上传成功")
+
             except Exception as e:
-                print(f"❌ 文件上传失败: {str(e)}")
+                PrettyOutput.print(f"文件上传失败: {str(e)}", OutputType.ERROR)
                 return {
                     "success": False,
                     "stdout": "",
@@ -102,9 +108,8 @@ class FileAnalyzerTool:
 请提供详细的分析结果和理由。"""
 
             # 发送请求并获取分析结果
-            print(f"🔍 正在分析文件...")
+
             analysis_result = platform.chat_until_success(analysis_request)
-            print(f"✅ 分析完成")
 
             # 清理会话
             platform.delete_chat()