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

jarvis/jarvis_platform_manager/main.py

@@ -3,33 +3,47 @@
 
 该模块提供了Jarvis平台管理器的主要入口点。
 """
-import argparse
 import os
+import sys
 from typing import Any, Dict, List, Optional
 
+import typer
+from jarvis.jarvis_utils.config import (
+    get_normal_platform_name,
+    get_normal_model_name,
+)
+
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.input import get_multiline_input, get_single_line_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 from jarvis.jarvis_platform_manager.service import start_service
+from jarvis.jarvis_utils.fzf import fzf_select
+
+app = typer.Typer(help="Jarvis AI 平台")
 
 
-def list_platforms() -> None:
-    """列出所有支持的平台和模型。"""
+@app.command("info")
+def list_platforms(
+    platform: Optional[str] = typer.Option(
+        None, "--platform", "-p", help="指定要查看的平台"
+    )
+) -> None:
+    """列出所有支持的平台和模型，或指定平台的详细信息。"""
     registry = PlatformRegistry.get_global_platform_registry()
-    platforms = registry.get_available_platforms()
+    platform_names = [platform] if platform else registry.get_available_platforms()
 
     PrettyOutput.section("Supported platforms and models", OutputType.SUCCESS)
 
-    for platform_name in platforms:
-        # Create platform instance
-        platform = registry.create_platform(platform_name)
-        if not platform:
-            continue
-
-        # Get the list of models supported by the platform
+    for platform_name in platform_names:
         try:
-            models = platform.get_model_list()
+            # Create platform instance
+            platform_instance = registry.create_platform(platform_name)
+            if not platform_instance:
+                continue
+
+            # Get the list of models supported by the platform
+            models = platform_instance.get_model_list()
 
             # Print platform name
             PrettyOutput.section(f"{platform_name}", OutputType.SUCCESS)
@@ -46,19 +60,29 @@ def list_platforms() -> None:
             else:
                 PrettyOutput.print("  • 没有可用的模型信息", OutputType.WARNING)
 
-        except Exception as exc:
-            PrettyOutput.print(
-                f"获取 {platform_name} 的模型列表失败: {str(exc)}", OutputType.WARNING
-            )
+        except Exception:
+            PrettyOutput.print(f"创建 {platform_name} 平台失败", OutputType.WARNING)
+
 
+def chat_with_model(
+    platform_name: str, model_name: str, system_prompt: str
+) -> None:
+    """与指定平台和模型进行对话。
 
-def chat_with_model(platform_name: str, model_name: str, system_prompt: str) -> None:
-    """与指定平台和模型进行对话。"""
+    参数:
+        platform_name: 平台名称
+        model_name: 模型名称
+        system_prompt: 系统提示语
+
+    """
     registry = PlatformRegistry.get_global_platform_registry()
     conversation_history: List[Dict[str, str]] = []  # 存储对话记录
 
     # Create platform instance
     platform = registry.create_platform(platform_name)
+    if platform:
+        platform.set_model_name(model_name)
+
     if not platform:
         PrettyOutput.print(f"创建平台 {platform_name} 失败", OutputType.WARNING)
         return
@@ -94,10 +118,16 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 PrettyOutput.print("检测到空输入，退出聊天", OutputType.INFO)
                 break
 
+            # Parse command and arguments
+            stripped_input = user_input.strip()
+            parts = stripped_input.split(None, 1)
+            command = parts[0] if parts else ""
+            args = parts[1] if len(parts) > 1 else ""
+
             # Check if it is a clear session command
-            if user_input.strip() == "/clear":
+            if command == "/clear":
                 try:
-                    platform.reset()
+                    platform.reset()  # type: ignore[no-untyped-call]  # type: ignore[no-untyped-call]  # type: ignore[no-untyped-call]
                     platform.set_model_name(model_name)  # Reinitialize session
                     conversation_history = []  # 重置对话记录
                     PrettyOutput.print("会话已清除", OutputType.SUCCESS)
@@ -106,9 +136,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is an upload command
-            if user_input.strip().startswith("/upload"):
+            if command == "/upload":
                 try:
-                    file_path = user_input.strip()[8:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             '请指定要上传的文件路径，例如: /upload /path/to/file 或 /upload "/path/with spaces/file"',
@@ -136,9 +166,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a save command
-            if user_input.strip().startswith("/save"):
+            if command == "/save":
                 try:
-                    file_path = user_input.strip()[5:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定保存文件名，例如: /save last_message.txt",
@@ -167,9 +197,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a saveall command
-            if user_input.strip().startswith("/saveall"):
+            if command == "/saveall":
                 try:
-                    file_path = user_input.strip()[8:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定保存文件名，例如: /saveall all_conversations.txt",
@@ -188,15 +218,19 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                         for entry in conversation_history:
                             file_obj.write(f"{entry['role']}: {entry['content']}\n\n")
 
-                    PrettyOutput.print(f"所有对话已保存到 {file_path}", OutputType.SUCCESS)
+                    PrettyOutput.print(
+                        f"所有对话已保存到 {file_path}", OutputType.SUCCESS
+                    )
                 except Exception as exc:
-                    PrettyOutput.print(f"保存所有对话失败: {str(exc)}", OutputType.ERROR)
+                    PrettyOutput.print(
+                        f"保存所有对话失败: {str(exc)}", OutputType.ERROR
+                    )
                 continue
 
             # Check if it is a save_session command
-            if user_input.strip().startswith("/save_session"):
+            if command == "/save_session":
                 try:
-                    file_path = user_input.strip()[14:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定保存会话的文件名，例如: /save_session session.json",
@@ -211,7 +245,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                         file_path = file_path[1:-1]
 
                     if platform.save(file_path):
-                        PrettyOutput.print(f"会话已保存到 {file_path}", OutputType.SUCCESS)
+                        PrettyOutput.print(
+                            f"会话已保存到 {file_path}", OutputType.SUCCESS
+                        )
                     else:
                         PrettyOutput.print("保存会话失败", OutputType.ERROR)
                 except Exception as exc:
@@ -219,9 +255,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a load_session command
-            if user_input.strip().startswith("/load_session"):
+            if command == "/load_session":
                 try:
-                    file_path = user_input.strip()[14:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定加载会话的文件名，例如: /load_session session.json",
@@ -237,7 +273,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
 
                     if platform.restore(file_path):
                         conversation_history = []  # Clear local history after loading
-                        PrettyOutput.print(f"会话已从 {file_path} 加载", OutputType.SUCCESS)
+                        PrettyOutput.print(
+                            f"会话已从 {file_path} 加载", OutputType.SUCCESS
+                        )
                     else:
                         PrettyOutput.print("加载会话失败", OutputType.ERROR)
                 except Exception as exc:
@@ -245,18 +283,18 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a shell command
-            if user_input.strip().startswith("/shell"):
+            if command == "/shell":
                 try:
-                    command = user_input.strip()[6:].strip()
-                    if not command:
+                    shell_command = args
+                    if not shell_command:
                         PrettyOutput.print(
                             "请指定要执行的shell命令，例如: /shell ls -l",
                             OutputType.WARNING,
                         )
                         continue
 
-                    PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
-                    return_code = os.system(command)
+                    PrettyOutput.print(f"执行命令: {shell_command}", OutputType.INFO)
+                    return_code = os.system(shell_command)
                     if return_code == 0:
                         PrettyOutput.print("命令执行完成", OutputType.SUCCESS)
                     else:
@@ -283,8 +321,11 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
             except Exception as exc:
                 PrettyOutput.print(f"聊天失败: {str(exc)}", OutputType.ERROR)
 
+    except typer.Exit:
+        raise
     except Exception as exc:
         PrettyOutput.print(f"初始化会话失败: {str(exc)}", OutputType.ERROR)
+        sys.exit(1)
     finally:
         # Clean up resources
         try:
@@ -293,16 +334,17 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
             pass
 
 
-def validate_platform_model(args: argparse.Namespace) -> bool:
+def validate_platform_model(platform: Optional[str], model: Optional[str]) -> bool:
     """验证平台和模型参数。
 
     参数:
-        args: 命令行参数。
+        platform: 平台名称。
+        model: 模型名称。
 
     返回:
         bool: 如果平台和模型有效返回True，否则返回False。
     """
-    if not args.platform or not args.model:
+    if not platform or not model:
         PrettyOutput.print(
             "请指定平台和模型。使用 'jarvis info' 查看可用平台和模型。",
             OutputType.WARNING,
@@ -311,38 +353,43 @@ def validate_platform_model(args: argparse.Namespace) -> bool:
     return True
 
 
-def chat_command(args: argparse.Namespace) -> None:
-    """处理聊天子命令。
-
-    参数:
-        args: 命令行参数。
-    """
-    if not validate_platform_model(args):
-        return
-    chat_with_model(args.platform, args.model, "")
-
+@app.command("chat")
+def chat_command(
+    platform: Optional[str] = typer.Option(
+        None, "--platform", "-p", help="指定要使用的平台"
+    ),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="指定要使用的模型"),
 
-def info_command(args: argparse.Namespace) -> None:
-    """处理信息子命令。
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
+) -> None:
+    """与指定平台和模型聊天。"""
+    # 如果未提供平台或模型参数，则从config获取默认值
+    platform = platform or get_normal_platform_name(llm_group)
+    model = model or get_normal_model_name(llm_group)
 
-    参数:
-        args: 命令行参数。
-    """
-    list_platforms()
-
-
-def service_command(args: argparse.Namespace) -> None:
-    """处理服务子命令 - 启动OpenAI兼容的API服务。
-
-    参数:
-        args: 命令行参数。
-    """
-    start_service(
-        host=args.host,
-        port=args.port,
-        default_platform=args.platform,
-        default_model=args.model,
-    )
+    if not validate_platform_model(platform, model):
+        return
+    chat_with_model(platform, model, "")
+
+
+@app.command("service")
+def service_command(
+    host: str = typer.Option("127.0.0.1", help="服务主机地址 (默认: 127.0.0.1)"),
+    port: int = typer.Option(8000, help="服务端口 (默认: 8000)"),
+    platform: Optional[str] = typer.Option(
+        None, "-p", "--platform", help="指定默认平台，当客户端未指定平台时使用"
+    ),
+    model: Optional[str] = typer.Option(
+        None, "-m", "--model", help="指定默认模型，当客户端未指定平台时使用"
+    ),
+) -> None:
+    """启动OpenAI兼容的API服务。"""
+    # 如果未提供平台或模型参数，则从config获取默认值
+    platform = platform or get_normal_platform_name()
+    model = model or get_normal_model_name()
+    start_service(host=host, port=port, default_platform=platform, default_model=model)
 
 
 def load_role_config(config_path: str) -> Dict[str, Any]:
@@ -369,13 +416,28 @@ def load_role_config(config_path: str) -> Dict[str, Any]:
             return {}
 
 
-def role_command(args: argparse.Namespace) -> None:
-    """Process role subcommand - load role config and start chat.
-
-    Args:
-        args: Command line arguments.
-    """
-    config = load_role_config(args.config)
+@app.command("role")
+def role_command(
+    config_file: str = typer.Option(
+        "~/.jarvis/roles.yaml",
+        "--config",
+        "-c",
+        help="角色配置文件路径(YAML格式，默认: ~/.jarvis/roles.yaml)",
+    ),
+    platform: Optional[str] = typer.Option(
+        None, "--platform", "-p", help="指定要使用的平台，覆盖角色配置"
+    ),
+    model: Optional[str] = typer.Option(
+        None, "--model", "-m", help="指定要使用的模型，覆盖角色配置"
+    ),
+
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
+) -> None:
+    """加载角色配置文件并开始对话。"""
+    config_path = os.path.expanduser(config_file)
+    config = load_role_config(config_path)
     if not config or "roles" not in config:
         PrettyOutput.print("无效的角色配置文件", OutputType.ERROR)
         return
@@ -390,17 +452,60 @@ def role_command(args: argparse.Namespace) -> None:
     )
     PrettyOutput.print(output_str, OutputType.INFO)
 
-    # 让用户选择角色
-    try:
-        choice = int(get_single_line_input("请选择角色(输入编号): "))
-        selected_role = config["roles"][choice - 1]
-    except (ValueError, IndexError):
-        PrettyOutput.print("无效的选择", OutputType.ERROR)
-        return
+    # 让用户选择角色（优先 fzf，回退编号输入）
+    selected_role = None  # type: ignore[var-annotated]
+    fzf_options = [
+        f"{i:>3} | {role['name']} - {role.get('description', '')}"
+        for i, role in enumerate(config["roles"], 1)
+    ]
+    selected_str = fzf_select(fzf_options, prompt="选择角色编号 (Enter退出) > ")
+    if selected_str:
+        try:
+            num_part = selected_str.split("|", 1)[0].strip()
+            idx = int(num_part)
+            if 1 <= idx <= len(config["roles"]):
+                selected_role = config["roles"][idx - 1]
+        except Exception:
+            selected_role = None
+
+    if selected_role is None:
+        raw_choice = get_single_line_input("请选择角色(输入编号，直接回车退出): ")
+        if not raw_choice.strip():
+            PrettyOutput.print("已取消，退出程序", OutputType.INFO)
+            raise typer.Exit(code=0)
+        try:
+            choice = int(raw_choice)
+            selected_role = config["roles"][choice - 1]
+        except (ValueError, IndexError):
+            PrettyOutput.print("无效的选择", OutputType.ERROR)
+            return
+
+
 
     # 初始化平台和模型
-    platform_name = args.platform or selected_role["platform"]
-    model_name = args.model or selected_role["model"]
+    # 如果提供了platform或model参数，优先使用命令行参数
+    # 否则，如果提供了 llm_group，则从配置中获取
+    # 最后才使用角色配置中的platform和model
+    if platform:
+        platform_name = platform
+    elif llm_group:
+        platform_name = get_normal_platform_name(llm_group)
+    else:
+        platform_name = selected_role.get("platform")
+        if not platform_name:
+            # 如果角色配置中没有platform，使用默认配置
+            platform_name = get_normal_platform_name()
+
+    if model:
+        model_name = model
+    elif llm_group:
+        model_name = get_normal_model_name(llm_group)
+    else:
+        model_name = selected_role.get("model")
+        if not model_name:
+            # 如果角色配置中没有model，使用默认配置
+            model_name = get_normal_model_name()
+
     system_prompt = selected_role.get("system_prompt", "")
 
     # 开始对话
@@ -411,50 +516,7 @@ def role_command(args: argparse.Namespace) -> None:
 def main() -> None:
     """Jarvis平台管理器的主入口点。"""
     init_env("欢迎使用 Jarvis-PlatformManager，您的平台管理助手已准备就绪！")
-
-    parser = argparse.ArgumentParser(description="Jarvis AI 平台")
-    subparsers = parser.add_subparsers(dest="command", help="可用子命令")
-
-    # info subcommand
-    info_parser = subparsers.add_parser("info", help="显示支持的平台和模型信息")
-    info_parser.set_defaults(func=info_command)
-
-    # chat subcommand
-    chat_parser = subparsers.add_parser("chat", help="与指定平台和模型聊天")
-    chat_parser.add_argument("--platform", "-p", help="指定要使用的平台")
-    chat_parser.add_argument("--model", "-m", help="指定要使用的模型")
-    chat_parser.set_defaults(func=chat_command)
-
-    # service subcommand
-    service_parser = subparsers.add_parser("service", help="启动OpenAI兼容的API服务")
-    service_parser.add_argument(
-        "--host", default="127.0.0.1", help="服务主机地址 (默认: 127.0.0.1)"
-    )
-    service_parser.add_argument(
-        "--port", type=int, default=8000, help="服务端口 (默认: 8000)"
-    )
-    service_parser.add_argument("--platform", "-p", help="指定默认平台，当客户端未指定平台时使用")
-    service_parser.add_argument("--model", "-m", help="指定默认模型，当客户端未指定平台时使用")
-    service_parser.set_defaults(func=service_command)
-
-    # role subcommand
-    role_parser = subparsers.add_parser("role", help="加载角色配置文件并开始对话")
-    role_parser.add_argument(
-        "--config",
-        "-c",
-        default="~/.jarvis/roles.yaml",
-        help="角色配置文件路径(YAML格式，默认: ~/.jarvis/roles.yaml)",
-    )
-    role_parser.add_argument("--platform", "-p", help="指定要使用的平台，覆盖角色配置")
-    role_parser.add_argument("--model", "-m", help="指定要使用的模型，覆盖角色配置")
-    role_parser.set_defaults(func=role_command)
-
-    args = parser.parse_args()
-
-    if hasattr(args, "func"):
-        args.func(args)
-    else:
-        parser.print_help()
+    app()
 
 
 if __name__ == "__main__":