jarvis-ai-assistant 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

jarvis/jarvis_smart_shell/main.py

@@ -1,15 +1,25 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-import argparse
 import os
 import sys
 from typing import Optional, Tuple
 
+import typer
+
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.config import get_shell_name, set_config
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.utils import init_env
 
+app = typer.Typer(
+    help="将自然语言要求转换为shell命令",
+    epilog="""
+Example:
+  jss request "Find all Python files in the current directory"
+  jss install
+""",
+)
+
 
 def execute_command(command: str, should_run: bool) -> None:
     """Print command without execution"""
@@ -48,15 +58,18 @@ def _get_markers() -> Tuple[str, str]:
     )
 
 
-def install_jss_completion() -> int:
-    """Install JSS fish shell command completion
+@app.command("install")
+def install_jss_completion(
+    shell: str = typer.Option("fish", help="指定shell类型(仅支持fish)"),
+) -> None:
+    """为fish shell安装'命令未找到'处理器，实现自然语言命令执行"""
+    if shell != "fish":
+        print(f"错误: 不支持的shell类型: {shell}, 仅支持fish")
+        raise typer.Exit(code=1)
 
-    Returns:
-        int: 0 if success, 1 if failed
-    """
     if not _check_fish_shell():
         print("当前不是fish shell，无需安装")
-        return 0
+        return
 
     config_file = _get_config_file()
     start_marker, end_marker = _get_markers()
@@ -64,13 +77,15 @@ def install_jss_completion() -> int:
     if not os.path.exists(config_file):
         print("未找到config.fish文件，将创建新文件")
         os.makedirs(os.path.dirname(config_file), exist_ok=True)
+        with open(config_file, "w") as f:
+            f.write("")
 
     with open(config_file, "r") as f:
         content = f.read()
 
     if start_marker in content:
         print("JSS fish completion已安装，请执行: source ~/.config/fish/config.fish")
-        return 0
+        return
 
     with open(config_file, "a") as f:
         f.write(
@@ -90,32 +105,34 @@ end
 """
         )
     print("JSS fish completion已安装，请执行: source ~/.config/fish/config.fish")
-    return 0
 
 
-def uninstall_jss_completion() -> int:
-    """Uninstall JSS fish shell command completion
+@app.command("uninstall")
+def uninstall_jss_completion(
+    shell: str = typer.Option("fish", help="指定shell类型(仅支持fish)"),
+) -> None:
+    """卸载JSS fish shell'命令未找到'处理器"""
+    if shell != "fish":
+        print(f"错误: 不支持的shell类型: {shell}, 仅支持fish")
+        raise typer.Exit(code=1)
 
-    Returns:
-        int: 0 if success, 1 if failed
-    """
     if not _check_fish_shell():
         print("当前不是fish shell，无需卸载")
-        return 0
+        return
 
     config_file = _get_config_file()
     start_marker, end_marker = _get_markers()
 
     if not os.path.exists(config_file):
         print("未找到JSS fish completion配置，无需卸载")
-        return 0
+        return
 
     with open(config_file, "r") as f:
         content = f.read()
 
     if start_marker not in content:
         print("未找到JSS fish completion配置，无需卸载")
-        return 0
+        return
 
     new_content = content.split(start_marker)[0] + content.split(end_marker)[-1]
 
@@ -123,7 +140,6 @@ def uninstall_jss_completion() -> int:
         f.write(new_content)
 
     print("JSS fish completion已卸载，请执行: source ~/.config/fish/config.fish")
-    return 0
 
 
 def process_request(request: str) -> Optional[str]:
@@ -175,85 +191,40 @@ def process_request(request: str) -> Optional[str]:
         return None
 
 
-def main() -> int:
-    # 创建参数解析器
-    init_env("")
-
-    set_config("JARVIS_PRINT_PROMPT", "false")
-
-    parser = argparse.ArgumentParser(
-        description="将自然语言要求转换为shell命令",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Example:
-  %(prog)s request "Find all Python files in the current directory"
-  %(prog)s install
-""",
+@app.command("request")
+def request_command(
+    request: Optional[str] = typer.Argument(
+        None, help="描述您想要执行的操作（用自然语言描述），如果未提供则从标准输入读取"
     )
-
-    # 创建子命令解析器
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    # request子命令
-    request_parser = subparsers.add_parser(
-        "request", help="描述您想要执行的操作（用自然语言描述）"
-    )
-    request_parser.add_argument(
-        "request",
-        nargs="?",  # 设置为可选参数
-        help="描述您想要执行的操作（用自然语言描述），如果未提供则从标准输入读取",
-    )
-
-    # install子命令
-    install_parser = subparsers.add_parser(
-        "install", help="安装JSS fish shell命令补全功能"
-    )
-    install_parser.add_argument(
-        "--shell", choices=["fish"], default="fish", help="指定shell类型(仅支持fish)"
-    )
-
-    # 添加uninstall子命令
-    uninstall_parser = subparsers.add_parser(
-        "uninstall", help="卸载JSS fish shell命令补全功能"
-    )
-    uninstall_parser.add_argument(
-        "--shell", choices=["fish"], default="fish", help="指定shell类型(仅支持fish)"
-    )
-
-    # 解析参数
-    args = parser.parse_args()
-
+):
+    """描述您想要执行的操作（用自然语言描述）"""
     should_run = False
-
-    # 处理install命令
-    if args.command == "install":
-        if args.shell != "fish":
-            print(f"错误: 不支持的shell类型: {args.shell}, 仅支持fish")
-            return 1
-        return install_jss_completion()
-
-    # 处理uninstall命令
-    if args.command == "uninstall":
-        if args.shell != "fish":
-            print(f"错误: 不支持的shell类型: {args.shell}, 仅支持fish")
-            return 1
-        return uninstall_jss_completion()
-
-    # 处理request命令
-    if not args.request:
+    if not request:
         # 检查是否在交互式终端中运行
-        args.request = get_multiline_input(tip="请输入您要执行的功能：")
+        request = get_multiline_input(tip="请输入您要执行的功能：")
         should_run = True
+
     # 处理请求
-    command = process_request(args.request)
+    command = process_request(request)
 
     # 输出结果
     if command:
         execute_command(command, should_run)  # 显示并执行命令
-        return 0
     else:
-        return 1
+        raise typer.Exit(code=1)
+
+
+def cli():
+    """Typer application entry point"""
+    init_env("")
+    set_config("JARVIS_PRINT_PROMPT", "false")
+    app()
+
+
+def main():
+    """Main entry point for the script"""
+    cli()
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()

jarvis/jarvis_tools/cli/main.py

@@ -1,178 +1,145 @@
 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:
+            print(json.dumps(tools, indent=2, ensure_ascii=False))
         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
-
-        stats = registry._get_tool_stats()
-        tools = registry.get_all_tools()
-
-        # 构建统计表格数据
-        table_data = []
+            simple_tools = [
+                {"name": t["name"], "description": t["description"]} for t in tools
+            ]
+            print(json.dumps(simple_tools, indent=2, ensure_ascii=False))
+    else:
+        PrettyOutput.section("可用工具列表", OutputType.SYSTEM)
         for tool in tools:
-            name = tool["name"]
-            count = stats.get(name, 0)
-            table_data.append([name, count])
+            print(f"\n✅ {tool['name']}")
+            print(f"   描述: {tool['description']}")
+            if detailed:
+                print("   参数:")
+                print(tool["parameters"])
 
-        # 按调用次数降序排序
-        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")
-            )
+@app.command("stat")
+def stat_tools(as_json: bool = typer.Option(False, "--json", help="以JSON格式输出")):
+    """显示工具调用统计信息"""
+    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])
 
-        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:
-                PrettyOutput.print(
-                    f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR
-                )
-                return 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:
+    table_data.sort(key=lambda x: x[1], reverse=True)
+
+    if as_json:
+        print(json.dumps(dict(table_data), indent=2))
+    else:
+        PrettyOutput.section("工具调用统计", OutputType.SYSTEM)
+        print(tabulate(table_data, headers=["工具名称", "调用次数"], tablefmt="grid"))
+
+
+@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()])
+        print(f"可用工具: {available_tools}")
+        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"错误: 缺少必需参数: {', '.join(missing_params)}", OutputType.ERROR
+                f"错误: 无法从文件加载参数: {str(e)}", 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)
+            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:
+        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}")
+        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)
 
-        if result.get("stdout"):
-            print("\n输出:")
-            print(result["stdout"])
+    if result.get("stdout"):
+        print("\n输出:")
+        print(result["stdout"])
 
-        if result.get("stderr"):
-            PrettyOutput.print("\n错误:", OutputType.ERROR)
-            print(result["stderr"])
+    if result.get("stderr"):
+        PrettyOutput.print("\n错误:", OutputType.ERROR)
+        print(result["stderr"])
 
-        return 0 if result["success"] else 1
+    if not result["success"]:
+        raise typer.Exit(code=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/registry.py

@@ -15,6 +15,7 @@ from jarvis.jarvis_mcp.stdio_mcp_client import StdioMcpClient
 from jarvis.jarvis_mcp.streamable_mcp_client import StreamableMcpClient
 from jarvis.jarvis_tools.base import Tool
 from jarvis.jarvis_utils.config import get_data_dir, get_tool_load_dirs
+from jarvis.jarvis_utils.input import user_confirm
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import is_context_overflow, daily_check_git_updates
@@ -106,14 +107,20 @@ arguments:
 
 
 class OutputHandlerProtocol(Protocol):
-    def name(self) -> str: ...
-    def can_handle(self, response: str) -> bool: ...
-    def prompt(self) -> str: ...
-    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]: ...
+    def name(self) -> str:
+        ...
 
+    def can_handle(self, response: str) -> bool:
+        ...
 
-class ToolRegistry(OutputHandlerProtocol):
+    def prompt(self) -> str:
+        ...
 
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
+        ...
+
+
+class ToolRegistry(OutputHandlerProtocol):
     def name(self) -> str:
         return "TOOL_CALL"
 
@@ -124,14 +131,16 @@ class ToolRegistry(OutputHandlerProtocol):
         """加载工具"""
         tools = self.get_all_tools()
         if tools:
-            tools_prompt = f"{tool_call_help}\n<tools_section>\n"
+            tools_prompt = f"<tools_section>\n"
             tools_prompt += "  <header>## 可用工具:</header>\n"
             tools_prompt += "  <tools_list>\n"
             for tool in tools:
                 try:
                     tools_prompt += "    <tool>\n"
                     tools_prompt += f"      <name>名称: {tool['name']}</name>\n"
-                    tools_prompt += f"      <description>描述: {tool['description']}</description>\n"
+                    tools_prompt += (
+                        f"      <description>描述: {tool['description']}</description>\n"
+                    )
                     tools_prompt += "      <parameters>\n"
                     tools_prompt += "        <yaml>|\n"
 
@@ -197,9 +206,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 with open(stats_file, "r", encoding="utf-8") as f:
                     return yaml.safe_load(f) or {}
             except Exception as e:
-                PrettyOutput.print(
-                    f"加载工具调用统计失败: {str(e)}", OutputType.WARNING
-                )
+                PrettyOutput.print(f"加载工具调用统计失败: {str(e)}", OutputType.WARNING)
         return {}
 
     def _update_tool_stats(self, name: str) -> None:
@@ -269,9 +276,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 config = yaml.safe_load(open(file_path, "r", encoding="utf-8"))
                 self.register_mcp_tool_by_config(config)
             except Exception as e:
-                PrettyOutput.print(
-                    f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING
-                )
+                PrettyOutput.print(f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING)
 
     def _load_builtin_tools(self) -> None:
         """从内置工具目录加载工具"""
@@ -508,7 +513,6 @@ class ToolRegistry(OutputHandlerProtocol):
                         and hasattr(item, "execute")
                         and item.name == module_name
                     ):
-
                         if hasattr(item, "check"):
                             if not item.check():
                                 continue
@@ -567,10 +571,40 @@ class ToolRegistry(OutputHandlerProtocol):
             ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"), content, re.DOTALL
         )
         if not data:
-            return (
-                {},
-                f"只有{ot('TOOL_CALL')}标签，未找到{ct('TOOL_CALL')}标签，调用格式错误，请检查工具调用格式。\n{tool_call_help}",
-            )
+            # can_handle 确保 ot("TOOL_CALL") 在内容中。
+            # 如果数据为空，则表示 ct("TOOL_CALL") 可能丢失。
+            if ot("TOOL_CALL") in content and ct("TOOL_CALL") not in content:
+                # 尝试通过附加结束标签来修复它
+                fixed_content = content.strip() + f"\n{ct('TOOL_CALL')}"
+
+                # 再次提取，并检查YAML是否有效
+                temp_data = re.findall(
+                    ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"),
+                    fixed_content,
+                    re.DOTALL,
+                )
+
+                if temp_data:
+                    try:
+                        yaml.safe_load(temp_data[0])  # Check if valid YAML
+
+                        # Ask user for confirmation
+                        PrettyOutput.print(
+                            f"检测到缺失的 {ct('TOOL_CALL')} 标签，已自动修复。修复后的内容如下:",
+                            OutputType.INFO,
+                        )
+                        PrettyOutput.print(fixed_content, OutputType.TOOL)
+                        data = temp_data
+                    except (yaml.YAMLError, EOFError, KeyboardInterrupt):
+                        # Even after fixing, it's not valid YAML, or user cancelled.
+                        # Fall through to the original error.
+                        pass
+
+            if not data:
+                return (
+                    {},
+                    f"只有{ot('TOOL_CALL')}标签，未找到{ct('TOOL_CALL')}标签，调用格式错误，请检查工具调用格式。\n{tool_call_help}",
+                )
         ret = []
         for item in data:
             try:
@@ -685,9 +719,7 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         if len(output.splitlines()) > 60:
             lines = output.splitlines()
-            return "\n".join(
-                lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:]
-            )
+            return "\n".join(lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:])
         return output
 
     def handle_tool_calls(self, tool_call: Dict[str, Any], agent: Any) -> str: