jarvis-ai-assistant 0.2.1__py3-none-any.whl → 0.2.3__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/generate_new_tool.py

@@ -12,7 +12,9 @@ class generate_new_tool:
     生成并注册新的Jarvis工具。该工具会在用户数据目录下创建新的工具文件，
     并自动注册到当前的工具注册表中。适用场景：1. 需要创建新的自定义工具；
     2. 扩展Jarvis功能；3. 自动化重复性操作；4. 封装特定领域的功能。
-    重要提示：在编写工具代码时，应尽量将工具执行的过程和结果打印出来，方便追踪工具的执行状态。
+    重要提示：
+    1. `tool_name` 参数必须与 `tool_code` 中定义的 `name` 属性完全一致。
+    2. 在编写工具代码时，应尽量将工具执行的过程和结果打印出来，方便追踪工具的执行状态。
     """
 
     parameters = {
@@ -75,6 +77,25 @@ class generate_new_tool:
                     "stderr": f"工具名称 '{tool_name}' 不是有效的Python标识符",
                 }
 
+            # 验证工具代码中的名称是否与tool_name一致
+            import re
+
+            match = re.search(r"^\s*name\s*=\s*[\"'](.+?)[\"']", tool_code, re.MULTILINE)
+            if not match:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "无法在工具代码中找到 'name' 属性。请确保工具类中包含 'name = \"your_tool_name\"'。",
+                }
+
+            code_name = match.group(1)
+            if tool_name != code_name:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"工具名称不一致：参数 'tool_name' ('{tool_name}') 与代码中的 'name' 属性 ('{code_name}') 必须相同。",
+                }
+
             # 准备工具目录
             tools_dir = Path(get_data_dir()) / "tools"
             tools_dir.mkdir(parents=True, exist_ok=True)

jarvis/jarvis_tools/registry.py

@@ -594,13 +594,7 @@ class ToolRegistry(OutputHandlerProtocol):
                             OutputType.INFO,
                         )
                         PrettyOutput.print(fixed_content, OutputType.TOOL)
-                        if user_confirm("这是纠正后的，是否需要执行?", default=True):
-                            data = temp_data
-                        else:
-                            return (
-                                {},
-                                f"只有{ot('TOOL_CALL')}标签，未找到{ct('TOOL_CALL')}标签，调用格式错误，请检查工具调用格式。\n{tool_call_help}",
-                            )
+                        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.

jarvis/jarvis_tools/search_web.py

@@ -2,9 +2,13 @@
 """A tool for searching the web."""
 from typing import Any, Dict
 
-import httpx
-from markdownify import markdownify as md
-from ddgs import DDGS
+import requests
+from markdownify import markdownify as md  # type: ignore
+
+# pylint: disable=import-error,missing-module-docstring
+# fmt: off
+from ddgs import DDGS  # type: ignore[import-not-found]
+# fmt: on
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -53,18 +57,18 @@ class SearchWebTool:
                         f"📄 ({visited_count + 1}/10) 正在抓取: {title} ({url})",
                         OutputType.INFO,
                     )
-                    response = http_get(url, timeout=10.0, follow_redirects=True)
-                    content = md(response.text, strip=['script', 'style'])
+                    response = http_get(url, timeout=10.0, allow_redirects=True)
+                    content = md(response.text, strip=["script", "style"])
                     if content:
                         full_content += content + "\n\n"
                         visited_urls.append(url)
                         visited_count += 1
-                except httpx.HTTPStatusError as e:
+                except requests.exceptions.HTTPError as e:
                     PrettyOutput.print(
                         f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}",
                         OutputType.WARNING,
                     )
-                except httpx.RequestError as e:
+                except requests.exceptions.RequestException as e:
                     PrettyOutput.print(f"⚠️ 请求错误: {e}", OutputType.WARNING)
 
             if not full_content.strip():
@@ -75,9 +79,7 @@ class SearchWebTool:
                 }
 
             url_list_str = "\n".join(f"  - {u}" for u in visited_urls)
-            PrettyOutput.print(
-                f"🔍 已成功访问并处理以下URL:\n{url_list_str}", OutputType.INFO
-            )
+            PrettyOutput.print(f"🔍 已成功访问并处理以下URL:\n{url_list_str}", OutputType.INFO)
 
             PrettyOutput.print("🧠 正在总结内容...", OutputType.INFO)
             summary_prompt = f"请为查询“{query}”总结以下内容：\n\n{full_content}"