ErisPulse 2.1.12__py3-none-any.whl → 2.1.13rc1__py3-none-any.whl

ErisPulse/__main__.py

@@ -1,3 +1,10 @@
+#!/usr/bin/env python3
+"""
+ErisPulse SDK 命令行工具
+
+一个功能强大的模块化系统管理工具，用于管理ErisPulse生态系统中的模块、适配器和扩展。
+"""
+
 import argparse
 import importlib.metadata
 import subprocess
@@ -7,7 +14,7 @@ import time
 import json
 import asyncio
 from urllib.parse import urlparse
-from typing import List, Dict, Tuple, Optional
+from typing import List, Dict, Tuple, Optional, Callable, Any
 from importlib.metadata import version, PackageNotFoundError
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
@@ -24,114 +31,127 @@ from rich.style import Style
 from rich.theme import Theme
 from rich.layout import Layout
 from rich.live import Live
+from rich.markdown import Markdown
+from rich.highlighter import RegexHighlighter
+from rich.logging import RichHandler
 
 # 确保在Windows上启用颜色
-import sys
 if sys.platform == "win32":
     from colorama import init
     init()
 
+# 自定义高亮器
+class CommandHighlighter(RegexHighlighter):
+    """高亮CLI命令和参数"""
+    highlights = [
+        r"(?P<switch>\-\-?\w+)",
+        r"(?P<option>\[\w+\])",
+        r"(?P<command>\b\w+\b)",
+    ]
+
+# 主题配置
 theme = Theme({
-    "info": "cyan",
-    "success": "green",
-    "warning": "yellow",
-    "error": "red",
-    "title": "magenta",
+    "info": "dim cyan",
+    "success": "bold green",
+    "warning": "bold yellow",
+    "error": "bold red",
+    "title": "bold magenta",
     "default": "default",
     "progress": "green",
     "progress.remaining": "white",
+    "cmd": "bold blue",
+    "param": "italic cyan",
+    "switch": "bold yellow",
+    "module": "bold green",
+    "adapter": "bold yellow",
+    "cli": "bold magenta",
 })
 
-console = Console(theme=theme, color_system="auto", force_terminal=True)
+# 全局控制台实例
+console = Console(
+    theme=theme, 
+    color_system="auto", 
+    force_terminal=True,
+    highlighter=CommandHighlighter()
+)
 
-class PyPIManager:
+class PackageManager:
     """
-    PyPI包管理器
+    ErisPulse包管理器
     
-    负责与PyPI交互，包括搜索、安装、卸载和升级ErisPulse模块/适配器
+    负责与包仓库交互，包括搜索、安装、卸载和升级ErisPulse组件
     """
     REMOTE_SOURCES = [
         "https://erisdev.com/packages.json",
         "https://raw.githubusercontent.com/ErisPulse/ErisPulse-ModuleRepo/main/packages.json"
     ]
     
-    @staticmethod
-    async def get_remote_packages() -> dict:
-        """
-        获取远程包列表
+    CACHE_EXPIRY = 3600  # 1小时缓存
+    
+    def __init__(self):
+        self._cache = {}
+        self._cache_time = {}
         
-        从配置的远程源获取所有可用的ErisPulse模块和适配器
-
-        :return: 
-            Dict[str, Dict]: 包含模块和适配器的字典
-                - modules: 模块字典 {模块名: 模块信息}
-                - adapters: 适配器字典 {适配器名: 适配器信息}
-                
-        :raises ClientError: 当网络请求失败时抛出
-        :raises asyncio.TimeoutError: 当请求超时时抛出
-        """
+    async def _fetch_remote_packages(self, url: str) -> Optional[dict]:
+        """从指定URL获取远程包数据"""
         import aiohttp
         from aiohttp import ClientError, ClientTimeout
         
-        timeout = ClientTimeout(total=5)
-        last_error = None
-        
+        timeout = ClientTimeout(total=10)
         try:
             async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get(PyPIManager.REMOTE_SOURCES[0]) as response:
+                async with session.get(url) as response:
                     if response.status == 200:
                         data = await response.text()
-                        data = json.loads(data)
-                        return {
-                            "modules": data.get("modules", {}),
-                            "adapters": data.get("adapters", {})
-                        }
-        except (ClientError, asyncio.TimeoutError) as e:
-            last_error = e
-            console.print(Panel(
-                f"官方源请求失败，尝试备用源: {e}",
-                title="警告",
-                style="warning"
-            ))
+                        return json.loads(data)
+        except (ClientError, asyncio.TimeoutError, json.JSONDecodeError) as e:
+            console.print(f"[warning]获取远程包数据失败 ({url}): {e}[/]")
+            return None
+    
+    async def get_remote_packages(self, force_refresh: bool = False) -> dict:
+        """
+        获取远程包列表，带缓存机制
         
-        try:
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get(PyPIManager.REMOTE_SOURCES[1]) as response:
-                    if response.status == 200:
-                        data = await response.text()
-                        data = json.loads(data)
-                        return {
-                            "modules": data.get("modules", {}),
-                            "adapters": data.get("adapters", {})
-                        }
-        except (ClientError, asyncio.TimeoutError) as e:
-            last_error = e
-            
-        if last_error:
-            console.print(Panel(
-                f"获取远程模块列表失败: {last_error}",
-                title="错误",
-                style="error"
-            ))
-        return {"modules": {}, "adapters": {}}
+        :param force_refresh: 是否强制刷新缓存
+        :return: 包含模块和适配器的字典
+        """
+        # 检查缓存
+        cache_key = "remote_packages"
+        if not force_refresh and cache_key in self._cache:
+            if time.time() - self._cache_time[cache_key] < self.CACHE_EXPIRY:
+                return self._cache[cache_key]
+        
+        last_error = None
+        result = {"modules": {}, "adapters": {}, "cli_extensions": {}}
+        
+        for url in self.REMOTE_SOURCES:
+            data = await self._fetch_remote_packages(url)
+            if data:
+                result["modules"].update(data.get("modules", {}))
+                result["adapters"].update(data.get("adapters", {}))
+                result["cli_extensions"].update(data.get("cli_extensions", {}))
+                break
+        
+        # 更新缓存
+        self._cache[cache_key] = result
+        self._cache_time[cache_key] = time.time()
+        
+        return result
     
-    @staticmethod
-    def get_installed_packages() -> Dict[str, Dict[str, str]]:
+    def get_installed_packages(self) -> Dict[str, Dict[str, Dict[str, str]]]:
         """
         获取已安装的包信息
         
-        :return: 
-            Dict[str, Dict[str, Dict[str, str]]]: 已安装包字典
-                - modules: 已安装模块 {模块名: 模块信息}
-                - adapters: 已安装适配器 {适配器名: 适配器信息}
+        :return: 已安装包字典，包含模块、适配器和CLI扩展
         """
         packages = {
             "modules": {},
-            "adapters": {}
+            "adapters": {},
+            "cli_extensions": {}
         }
         
         try:
-            # 查找模块
+            # 查找模块和适配器
             for dist in importlib.metadata.distributions():
                 if "ErisPulse-" in dist.metadata["Name"]:
                     entry_points = dist.entry_points
@@ -140,7 +160,8 @@ class PyPIManager:
                             packages["modules"][ep.name] = {
                                 "package": dist.metadata["Name"],
                                 "version": dist.version,
-                                "summary": dist.metadata["Summary"]
+                                "summary": dist.metadata["Summary"],
+                                "enabled": self._is_module_enabled(ep.name)
                             }
                         elif ep.group == "erispulse.adapter":
                             packages["adapters"][ep.name] = {
@@ -148,576 +169,765 @@ class PyPIManager:
                                 "version": dist.version,
                                 "summary": dist.metadata["Summary"]
                             }
+            
+            # 查找CLI扩展
+            entry_points = importlib.metadata.entry_points()
+            if hasattr(entry_points, 'select'):
+                cli_entries = entry_points.select(group='erispulse.cli')
+            else:
+                cli_entries = entry_points.get('erispulse.cli', [])
+            
+            for entry in cli_entries:
+                dist = entry.dist
+                packages["cli_extensions"][entry.name] = {
+                    "package": dist.metadata["Name"],
+                    "version": dist.version,
+                    "summary": dist.metadata["Summary"]
+                }
+                
         except Exception as e:
-            console.print(Panel(
-                f"获取已安装包信息失败: {e}",
-                title="错误",
-                style="error"
-            ))
+            console.print(f"[error]获取已安装包信息失败: {e}[/]")
+            import traceback
+            console.print(traceback.format_exc())
         
         return packages
     
-    @staticmethod
-    def uv_install_package(package_name: str, upgrade: bool = False) -> bool:
-        """
-        优先使用uv安装包
-        
-        :param package_name: str 要安装的包名
-        :param upgrade: bool 是否升级已安装的包 (默认: False)
-        :return: bool 安装是否成功
-        """
+    def _is_module_enabled(self, module_name: str) -> bool:
+        """检查模块是否启用"""
         try:
-            # 检查uv是否可用
-            uv_check = subprocess.run(["uv", "--version"], capture_output=True)
-            if uv_check.returncode != 0:
-                return False  # uv不可用
-            
-            cmd = ["uv", "pip", "install"]
-            if upgrade:
-                cmd.append("--upgrade")
-            cmd.append(package_name)
-            
-            with console.status(f"使用uv安装 {package_name}..."):
-                result = subprocess.run(cmd, check=True)
-                return result.returncode == 0
-        except (subprocess.CalledProcessError, FileNotFoundError):
+            from ErisPulse.Core import mods
+            return mods.get_module_status(module_name)
+        except ImportError:
+            return True
+        except Exception:
             return False
     
-    @staticmethod
-    def install_package(package_name: str, upgrade: bool = False) -> bool:
+    def _run_pip_command(self, args: List[str], description: str) -> bool:
+        """运行pip命令并显示进度"""
+        with Progress(
+            TextColumn(f"[progress.description]{description}"),
+            BarColumn(complete_style="progress.download"),
+            transient=True
+        ) as progress:
+            task = progress.add_task("", total=100)
+            
+            try:
+                process = subprocess.Popen(
+                    [sys.executable, "-m", "pip"] + args,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    universal_newlines=True
+                )
+                
+                while True:
+                    output = process.stdout.readline()
+                    if output == '' and process.poll() is not None:
+                        break
+                    if output:
+                        progress.update(task, advance=1)
+                        
+                return process.returncode == 0
+            except subprocess.CalledProcessError as e:
+                console.print(f"[error]命令执行失败: {e}[/]")
+                return False
+    
+    def install_package(self, package_name: str, upgrade: bool = False) -> bool:
         """
-        安装指定包 (修改后优先尝试uv)
+        安装指定包
         
-        :param package_name: str 要安装的包名
-        :param upgrade: bool 是否升级已安装的包 (默认: False)
-        :return: bool 安装是否成功
+        :param package_name: 要安装的包名
+        :param upgrade: 是否升级已安装的包
+        :return: 安装是否成功
         """
-        # 优先尝试uv安装
-        if PyPIManager.uv_install_package(package_name, upgrade):
-            console.print(Panel(
-                f"包 {package_name} 安装成功 (使用uv)",
-                title="成功",
-                style="success"
-            ))
-            return True
+        cmd = ["install"]
+        if upgrade:
+            cmd.append("--upgrade")
+        cmd.append(package_name)
+        
+        success = self._run_pip_command(cmd, f"安装 {package_name}")
+        
+        if success:
+            console.print(f"[success]包 {package_name} 安装成功[/]")
+        else:
+            console.print(f"[error]包 {package_name} 安装失败[/]")
             
-        # 回退到pip安装
-        try:
-            cmd = [sys.executable, "-m", "pip", "install"]
-            if upgrade:
-                cmd.append("--upgrade")
-            cmd.append(package_name)
-            
-            with console.status(f"使用pip安装 {package_name}..."):
-                result = subprocess.run(cmd, check=True)
-                if result.returncode == 0:
-                    console.print(Panel(
-                        f"包 {package_name} 安装成功",
-                        title="成功",
-                        style="success"
-                    ))
-                    return True
-                return False
-        except subprocess.CalledProcessError as e:
-            console.print(Panel(
-                f"安装包 {package_name} 失败: {e}",
-                title="错误",
-                style="error"
-            ))
-            return False
+        return success
     
-    @staticmethod
-    def uninstall_package(package_name: str) -> bool:
+    def uninstall_package(self, package_name: str) -> bool:
         """
         卸载指定包
         
-        :param package_name: str 要卸载的包名
-        :return: bool 卸载是否成功
+        :param package_name: 要卸载的包名
+        :return: 卸载是否成功
         """
-        try:
-            with console.status(f"正在卸载 {package_name}..."):
-                result = subprocess.run(
-                    [sys.executable, "-m", "pip", "uninstall", "-y", package_name],
-                    check=True
-                )
-                if result.returncode == 0:
-                    console.print(Panel(
-                        f"包 {package_name} 卸载成功",
-                        title="成功",
-                        style="success"
-                    ))
-                    return True
-                return False
-        except subprocess.CalledProcessError as e:
-            console.print(Panel(
-                f"卸载包 {package_name} 失败: {e}",
-                title="错误",
-                style="error"
-            ))
-            return False
+        success = self._run_pip_command(
+            ["uninstall", "-y", package_name],
+            f"卸载 {package_name}"
+        )
+        
+        if success:
+            console.print(f"[success]包 {package_name} 卸载成功[/]")
+        else:
+            console.print(f"[error]包 {package_name} 卸载失败[/]")
+            
+        return success
     
-    @staticmethod
-    def upgrade_all() -> bool:
+    def upgrade_all(self) -> bool:
         """
         升级所有已安装的ErisPulse包
         
-        :return: bool 升级是否成功
+        :return: 升级是否成功
         """
-        try:
-            installed = PyPIManager.get_installed_packages()
-            all_packages = set()
-            
-            for pkg_type in ["modules", "adapters"]:
-                for pkg_info in installed[pkg_type].values():
-                    all_packages.add(pkg_info["package"])
-            
-            if not all_packages:
-                console.print(Panel(
-                    "没有找到可升级的ErisPulse包",
-                    title="提示",
-                    style="info"
-                ))
-                return False
-                
-            console.print(Panel(
-                f"找到 {len(all_packages)} 个可升级的包:\n" + 
-                "\n".join(f"  - {pkg}" for pkg in all_packages),
-                title="升级列表",
-                style="info"
-            ))
+        installed = self.get_installed_packages()
+        all_packages = set()
+        
+        for pkg_type in ["modules", "adapters", "cli_extensions"]:
+            for pkg_info in installed[pkg_type].values():
+                all_packages.add(pkg_info["package"])
+        
+        if not all_packages:
+            console.print("[info]没有找到可升级的ErisPulse包[/]")
+            return False
             
-            if not Confirm.ask("确认升级所有包吗？", default=False):
-                return False
-                
-            for pkg in all_packages:
-                PyPIManager.install_package(pkg, upgrade=True)
-                
-            return True
-        except Exception as e:
+        console.print(Panel(
+            f"找到 [bold]{len(all_packages)}[/] 个可升级的包:\n" + 
+            "\n".join(f"  - [package]{pkg}[/]" for pkg in sorted(all_packages)),
+            title="升级列表"
+        ))
+        
+        if not Confirm.ask("确认升级所有包吗？", default=False):
+            return False
+            
+        results = {}
+        for pkg in sorted(all_packages):
+            results[pkg] = self.install_package(pkg, upgrade=True)
+            
+        failed = [pkg for pkg, success in results.items() if not success]
+        if failed:
             console.print(Panel(
-                f"升级包失败: {e}",
-                title="错误",
-                style="error"
+                f"以下包升级失败:\n" + "\n".join(f"  - [error]{pkg}[/]" for pkg in failed),
+                title="警告",
+                style="warning"
             ))
             return False
+            
+        return True
 
 class ReloadHandler(FileSystemEventHandler):
     """
     热重载处理器
     
-    监控文件变化并自动重启脚本
+    监控文件变化并自动重启入口
     """
-    def __init__(self, script_path, reload_mode=False, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.script_path = script_path
+    def __init__(self, script_path: str, reload_mode: bool = False):
+        super().__init__()
+        self.script_path = os.path.abspath(script_path)
         self.process = None
         self.last_reload = time.time()
         self.reload_mode = reload_mode
         self.start_process()
+        self.watched_files = set()
 
     def start_process(self):
-        """
-        启动/重启被监控的进程
-        """
+        """启动/重启被监控的进程"""
         if self.process:
+            self._terminate_process()
+            
+        console.print(f"[bold]启动进程: [path]{self.script_path}[/][/]")
+        try:
+            self.process = subprocess.Popen(
+                [sys.executable, self.script_path],
+                stdin=sys.stdin,
+                stdout=sys.stdout,
+                stderr=sys.stderr
+            )
+            self.last_reload = time.time()
+        except Exception as e:
+            console.print(f"[error]启动进程失败: {e}[/]")
+            raise
+
+    def _terminate_process(self):
+        """安全终止当前进程"""
+        try:
             self.process.terminate()
+            # 等待最多2秒让进程正常退出
+            self.process.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            console.print("[warning]进程未正常退出，强制终止...[/]")
+            self.process.kill()
             self.process.wait()
-            
-        console.print(f"[bold green]启动进程:[/] {self.script_path}")
-        self.process = subprocess.Popen([sys.executable, self.script_path])
-        self.last_reload = time.time()
+        except Exception as e:
+            console.print(f"[error]终止进程时出错: {e}[/]")
 
     def on_modified(self, event):
-        """
-        文件修改事件处理
-        
-        :param event: FileSystemEvent 文件系统事件对象
-        """
+        """文件修改事件处理"""
         now = time.time()
-        if now - self.last_reload < 1.0:
+        if now - self.last_reload < 1.0:  # 防抖
             return
             
         if event.src_path.endswith(".py") and self.reload_mode:
-            console.print(f"\n[cyan][热重载] 文件发生变动: {event.src_path}[/]")
-            self.start_process()
-        elif event.src_path.endswith("config.toml"):
-            console.print(f"\n[cyan][热重载] 配置发生变动: {event.src_path}[/]")
-            self.start_process()
+            self._handle_reload(event, "文件变动")
+        elif event.src_path.endswith(("config.toml", ".env")):
+            self._handle_reload(event, "配置变动")
 
-def start_reloader(script_path, reload_mode=False):
-    """
-    启动热重载监控
-    
-    :param script_path: str 要监控的脚本路径
-    :param reload_mode: bool 是否启用完整重载模式 (默认: False)
-    """
-    if not os.path.exists(script_path):
-        console.print(Panel(
-            f"找不到指定文件: {script_path}",
-            title="错误",
-            style="error"
-        ))
-        return
-    watch_dirs = [
-        os.path.dirname(os.path.abspath(script_path)),
-    ]
-
-    handler = ReloadHandler(script_path, reload_mode)
-    observer = Observer()
-
-    for d in watch_dirs:
-        if os.path.exists(d):
-            if reload_mode:
-                # 完整重载模式：监控所有.py文件
-                observer.schedule(handler, d, recursive=True)
-            else:
-                # 普通模式：只监控config.toml
-                observer.schedule(handler, d, recursive=False)
-
-    observer.start()
-    console.print("\n[bold green][热重载] 已启动[/]")
-    mode_desc = "开发重载模式" if reload_mode else "配置监控模式"
-    console.print(f"[dim]模式: {mode_desc}\n监控目录: {', '.join(watch_dirs)}[/]\n")
-    try:
-        first_interrupt = True
-        while True:
-            time.sleep(1)
-    except KeyboardInterrupt:
-        if first_interrupt:
-            first_interrupt = False
-            console.print("\n[bold green]正在安全关闭热重载...[/]")
-            console.print("[bold red]再次按下Ctrl+C以强制关闭[/]")
-            try:
-                observer.stop()
-                if handler.process:
-                    handler.process.terminate()
-                observer.join()
-            except KeyboardInterrupt:
-                console.print("[bold red]强制关闭热重载[/]")
-                raise
-        else:
-            console.print(Panel("[bold red]强制关闭热重载[/]"))
-            raise
-
-def get_erispulse_version():
-    """
-    获取当前安装的ErisPulse版本
-    
-    :return: str ErisPulse版本号或"unknown version"
-    """
-    try:
-        return version("ErisPulse")
-    except PackageNotFoundError:
-        return "unknown version"
+    def _handle_reload(self, event, reason: str):
+        """处理重载逻辑"""
+        console.print(f"\n[reload]{reason}: [path]{event.src_path}[/][/]")
+        self._terminate_process()
+        self.start_process()
 
-def main():
-    """
-    CLI主入口
+class CLI:
+    """主CLI应用程序"""
     
-    解析命令行参数并执行相应命令
-    """
+    def __init__(self):
+        self.parser = self._create_parser()
+        self.package_manager = PackageManager()
+        self.observer = None
+        self.handler = None
+        
+    def _create_parser(self) -> argparse.ArgumentParser:
+        """创建参数解析器"""
+        parser = argparse.ArgumentParser(
+            prog="epsdk",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            description="ErisPulse SDK 命令行工具\n\n一个功能强大的模块化系统管理工具，用于管理ErisPulse生态系统中的模块、适配器和扩展。",
+        )
+        parser._positionals.title = "命令"
+        parser._optionals.title = "选项"
+        
+        # 全局选项
+        parser.add_argument(
+            "--version", "-V",
+            action="store_true",
+            help="显示版本信息"
+        )
+        parser.add_argument(
+            "--verbose", "-v",
+            action="count",
+            default=0,
+            help="增加输出详细程度 (-v, -vv, -vvv)"
+        )
+        
+        # 子命令
+        subparsers = parser.add_subparsers(
+            dest='command',
+            metavar="<命令>",
+            help="要执行的操作"
+        )
+        
+        # 安装命令
+        install_parser = subparsers.add_parser(
+            'install',
+            help='安装模块/适配器包'
+        )
+        install_parser.add_argument(
+            'package',
+            help='要安装的包名或模块/适配器简称'
+        )
+        install_parser.add_argument(
+            '--upgrade', '-U',
+            action='store_true',
+            help='升级已安装的包'
+        )
+        install_parser.add_argument(
+            '--pre',
+            action='store_true',
+            help='包含预发布版本'
+        )
+        
+        # 卸载命令
+        uninstall_parser = subparsers.add_parser(
+            'uninstall',
+            help='卸载模块/适配器包'
+        )
+        uninstall_parser.add_argument(
+            'package',
+            help='要卸载的包名'
+        )
+        
+        # 模块管理命令
+        module_parser = subparsers.add_parser(
+            'module',
+            help='模块管理'
+        )
+        module_subparsers = module_parser.add_subparsers(
+            dest='module_command',
+            metavar="<子命令>"
+        )
+        
+        # 启用模块
+        enable_parser = module_subparsers.add_parser(
+            'enable',
+            help='启用模块'
+        )
+        enable_parser.add_argument(
+            'module',
+            help='要启用的模块名'
+        )
+        
+        # 禁用模块
+        disable_parser = module_subparsers.add_parser(
+            'disable',
+            help='禁用模块'
+        )
+        disable_parser.add_argument(
+            'module',
+            help='要禁用的模块名'
+        )
+        
+        # 列表命令
+        list_parser = subparsers.add_parser(
+            'list',
+            help='列出已安装的组件'
+        )
+        list_parser.add_argument(
+            '--type', '-t',
+            choices=['modules', 'adapters', 'cli', 'all'],
+            default='all',
+            help='列出类型 (默认: all)'
+        )
+        list_parser.add_argument(
+            '--outdated', '-o',
+            action='store_true',
+            help='仅显示可升级的包'
+        )
+        
+        # 远程列表命令
+        list_remote_parser = subparsers.add_parser(
+            'list-remote',
+            help='列出远程可用的组件'
+        )
+        list_remote_parser.add_argument(
+            '--type', '-t',
+            choices=['modules', 'adapters', 'cli', 'all'],
+            default='all',
+            help='列出类型 (默认: all)'
+        )
+        list_remote_parser.add_argument(
+            '--refresh', '-r',
+            action='store_true',
+            help='强制刷新远程包列表'
+        )
+        
+        # 升级命令
+        upgrade_parser = subparsers.add_parser(
+            'upgrade',
+            help='升级组件'
+        )
+        upgrade_parser.add_argument(
+            'package',
+            nargs='?',
+            help='要升级的包名 (可选，不指定则升级所有)'
+        )
+        upgrade_parser.add_argument(
+            '--force', '-f',
+            action='store_true',
+            help='跳过确认直接升级'
+        )
+        
+        # 运行命令
+        run_parser = subparsers.add_parser(
+            'run',
+            help='运行主程序'
+        )
+        run_parser.add_argument(
+            'script',
+            nargs='?',
+            help='要运行的主程序路径 (默认: main.py)'
+        )
+        run_parser.add_argument(
+            '--reload',
+            action='store_true',
+            help='启用热重载模式'
+        )
+        run_parser.add_argument(
+            '--no-reload',
+            action='store_true',
+            help='禁用热重载模式'
+        )
+        
+        # 初始化命令
+        init_parser = subparsers.add_parser(
+            'init',
+            help='初始化ErisPulse项目'
+        )
+        init_parser.add_argument(
+            '--force', '-f',
+            action='store_true',
+            help='强制覆盖现有配置'
+        )
+        
+        # 加载第三方命令
+        self._load_external_commands(subparsers)
+        
+        return parser
     
-    parser = argparse.ArgumentParser(
-        prog="epsdk",
-        formatter_class=argparse.RawTextHelpFormatter,
-        description=f"ErisPulse SDK 命令行工具 {get_erispulse_version()}"
-    )
-    parser._positionals.title = "基本"
-    parser._optionals.title = "可选"
+    def _load_external_commands(self, subparsers):
+        """加载第三方CLI命令"""
+        try:
+            entry_points = importlib.metadata.entry_points()
+            if hasattr(entry_points, 'select'):
+                cli_entries = entry_points.select(group='erispulse.cli')
+            else:
+                cli_entries = entry_points.get('erispulse.cli', [])
+            
+            for entry in cli_entries:
+                try:
+                    cli_func = entry.load()
+                    if callable(cli_func):
+                        cli_func(subparsers, console)
+                    else:
+                        console.print(f"[warning]模块 {entry.name} 的入口点不是可调用对象[/]")
+                except Exception as e:
+                    console.print(f"[error]加载第三方命令 {entry.name} 失败: {e}[/]")
+        except Exception as e:
+            console.print(f"[warning]加载第三方CLI命令失败: {e}[/]")
     
-    parser.add_argument("--version", action="store_true", help="显示版本信息")
+    def _print_version(self):
+        """打印版本信息"""
+        from ErisPulse import __version__
+        console.print(Panel(
+            f"[title]ErisPulse SDK[/] 版本: [bold]{__version__}[/]",
+            subtitle=f"Python {sys.version.split()[0]}",
+            style="title"
+        ))
     
-    subparsers = parser.add_subparsers(
-        dest='command', 
-        metavar="<命令>",
-    )
-
-    # 在main()函数中修改第三方命令加载部分
-    try:
-        entry_points = importlib.metadata.entry_points()
-        if hasattr(entry_points, 'select'):
-            cli_entries = entry_points.select(group='erispulse.cli')
-        else:
-            cli_entries = entry_points.get('erispulse.cli', [])
+    def _print_installed_packages(self, pkg_type: str, outdated_only: bool = False):
+        """打印已安装的包列表"""
+        installed = self.package_manager.get_installed_packages()
         
-        for entry in cli_entries:
-            try:
-                cli_func = entry.load()
-                if callable(cli_func):
-                    # 直接调用函数并传入subparsers和console
-                    cli_func(subparsers, console)
-                else:
-                    console.print(f"[yellow]模块 {entry.name} 的入口点不是可调用对象[/]")
-            except Exception as e:
-                console.print(f"[red]加载第三方命令 {entry.name} 失败: {e}[/]")
-                import traceback
-                console.print(traceback.format_exc())
-    except Exception as e:
-        console.print(f"[yellow]加载第三方CLI命令失败: {e}[/]", style="warning")
-
-    # 安装命令
-    install_parser = subparsers.add_parser('install', help='安装模块/适配器包')
-    install_parser.add_argument('package', type=str, help='要安装的包名')
-    install_parser.add_argument('--upgrade', '-U', action='store_true', help='升级已安装的包')
+        if pkg_type == "modules" and installed["modules"]:
+            table = Table(
+                title="已安装模块",
+                box=SIMPLE,
+                header_style="module"
+            )
+            table.add_column("模块名", style="module")
+            table.add_column("包名")
+            table.add_column("版本")
+            table.add_column("状态")
+            table.add_column("描述")
+            
+            for name, info in installed["modules"].items():
+                if outdated_only and not self._is_package_outdated(info["package"], info["version"]):
+                    continue
+                    
+                status = "[green]已启用[/]" if info.get("enabled", True) else "[yellow]已禁用[/]"
+                table.add_row(
+                    name,
+                    info["package"],
+                    info["version"],
+                    status,
+                    info["summary"]
+                )
+            
+            console.print(table)
+            
+        if pkg_type == "adapters" and installed["adapters"]:
+            table = Table(
+                title="已安装适配器",
+                box=SIMPLE,
+                header_style="adapter"
+            )
+            table.add_column("适配器名", style="adapter")
+            table.add_column("包名")
+            table.add_column("版本")
+            table.add_column("描述")
+            
+            for name, info in installed["adapters"].items():
+                if outdated_only and not self._is_package_outdated(info["package"], info["version"]):
+                    continue
+                    
+                table.add_row(
+                    name,
+                    info["package"],
+                    info["version"],
+                    info["summary"]
+                )
+            
+            console.print(table)
+            
+        if pkg_type == "cli" and installed["cli_extensions"]:
+            table = Table(
+                title="已安装CLI扩展",
+                box=SIMPLE,
+                header_style="cli"
+            )
+            table.add_column("命令名", style="cli")
+            table.add_column("包名")
+            table.add_column("版本")
+            table.add_column("描述")
+            
+            for name, info in installed["cli_extensions"].items():
+                if outdated_only and not self._is_package_outdated(info["package"], info["version"]):
+                    continue
+                    
+                table.add_row(
+                    name,
+                    info["package"],
+                    info["version"],
+                    info["summary"]
+                )
+            
+            console.print(table)
     
-    # 卸载命令
-    uninstall_parser = subparsers.add_parser('uninstall', help='卸载模块/适配器包')
-    uninstall_parser.add_argument('package', type=str, help='要卸载的包名')
+    def _print_remote_packages(self, pkg_type: str):
+        """打印远程包列表"""
+        remote_packages = asyncio.run(self.package_manager.get_remote_packages())
+        
+        if pkg_type == "modules" and remote_packages["modules"]:
+            table = Table(
+                title="远程模块",
+                box=SIMPLE,
+                header_style="module"
+            )
+            table.add_column("模块名", style="module")
+            table.add_column("包名")
+            table.add_column("最新版本")
+            table.add_column("描述")
+            
+            for name, info in remote_packages["modules"].items():
+                table.add_row(
+                    name,
+                    info["package"],
+                    info["version"],
+                    info["description"]
+                )
+            
+            console.print(table)
+            
+        if pkg_type == "adapters" and remote_packages["adapters"]:
+            table = Table(
+                title="远程适配器",
+                box=SIMPLE,
+                header_style="adapter"
+            )
+            table.add_column("适配器名", style="adapter")
+            table.add_column("包名")
+            table.add_column("最新版本")
+            table.add_column("描述")
+            
+            for name, info in remote_packages["adapters"].items():
+                table.add_row(
+                    name,
+                    info["package"],
+                    info["version"],
+                    info["description"]
+                )
+            
+            console.print(table)
+            
+        if pkg_type == "cli" and remote_packages.get("cli_extensions"):
+            table = Table(
+                title="远程CLI扩展",
+                box=SIMPLE,
+                header_style="cli"
+            )
+            table.add_column("命令名", style="cli")
+            table.add_column("包名")
+            table.add_column("最新版本")
+            table.add_column("描述")
+            
+            for name, info in remote_packages["cli_extensions"].items():
+                table.add_row(
+                    name,
+                    info["package"],
+                    info["version"],
+                    info["description"]
+                )
+            
+            console.print(table)
     
-    # 启用命令
-    enable_parser = subparsers.add_parser('enable', help='启用模块')
-    enable_parser.add_argument('module', type=str, help='要启用的模块名')
-
-    # 禁用命令
-    disable_parser = subparsers.add_parser('disable', help='禁用模块')
-    disable_parser.add_argument('module', type=str, help='要禁用的模块名')
-
-    # 列表命令
-    list_parser = subparsers.add_parser('list', help='列出已安装的模块/适配器')
-    list_parser.add_argument('--type', '-t', choices=['modules', 'adapters', 'cli', 'all'], default='all', 
-                           help='列出类型 (modules: 仅模块, adapters: 仅适配器, cli: 仅CLI扩展, all: 全部)')
+    def _is_package_outdated(self, package_name: str, current_version: str) -> bool:
+        """检查包是否有更新"""
+        remote_packages = asyncio.run(self.package_manager.get_remote_packages())
+        
+        # 检查模块
+        for module_info in remote_packages["modules"].values():
+            if module_info["package"] == package_name:
+                return module_info["version"] != current_version
+                
+        # 检查适配器
+        for adapter_info in remote_packages["adapters"].values():
+            if adapter_info["package"] == package_name:
+                return adapter_info["version"] != current_version
+                
+        # 检查CLI扩展
+        for cli_info in remote_packages.get("cli_extensions", {}).values():
+            if cli_info["package"] == package_name:
+                return cli_info["version"] != current_version
+                
+        return False
     
-    # 远程列表命令
-    list_remote_parser = subparsers.add_parser('list-remote', help='列出远程可用的模块和适配器')
-    list_remote_parser.add_argument('--type', '-t', choices=['modules', 'adapters', 'cli', 'all'], default='all',
-                                  help='列出类型 (modules: 仅模块, adapters: 仅适配器, cli: 仅CLI扩展, all: 全部)')
-    # 升级命令
-    upgrade_parser = subparsers.add_parser('upgrade', help='升级所有模块/适配器')
-    upgrade_parser.add_argument('--force', '-f', action='store_true', help='跳过确认直接升级')
+    def _resolve_package_name(self, short_name: str) -> Optional[str]:
+        """解析模块/适配器简称到完整包名"""
+        remote_packages = asyncio.run(self.package_manager.get_remote_packages())
+        
+        # 检查模块
+        if short_name in remote_packages["modules"]:
+            return remote_packages["modules"][short_name]["package"]
+            
+        # 检查适配器
+        if short_name in remote_packages["adapters"]:
+            return remote_packages["adapters"][short_name]["package"]
+            
+        return None
     
-    # 运行命令
-    run_parser = subparsers.add_parser('run', help='运行指定主程序(默认为main.py)')
-    run_parser.add_argument('script', type=str, nargs='?', help='要运行的主程序路径(可选，默认为main.py)')
-    run_parser.add_argument('--reload', action='store_true', help='启用热重载模式')
+    def _setup_watchdog(self, script_path: str, reload_mode: bool):
+        """设置文件监控"""
+        watch_dirs = [
+            os.path.dirname(os.path.abspath(script_path)),
+        ]
+        
+        # 添加配置目录
+        config_dir = os.path.abspath(os.getcwd())
+        if config_dir not in watch_dirs:
+            watch_dirs.append(config_dir)
+        
+        self.handler = ReloadHandler(script_path, reload_mode)
+        self.observer = Observer()
+        
+        for d in watch_dirs:
+            if os.path.exists(d):
+                self.observer.schedule(
+                    self.handler, 
+                    d, 
+                    recursive=reload_mode
+                )
+                console.print(f"[dim]监控目录: [path]{d}[/][/]")
+        
+        self.observer.start()
+        
+        mode_desc = "[bold]开发重载模式[/]" if reload_mode else "[bold]配置监控模式[/]"
+        console.print(Panel(
+            f"{mode_desc}\n监控目录: [path]{', '.join(watch_dirs)}[/]",
+            title="热重载已启动",
+            border_style="info"
+        ))
     
-    args = parser.parse_args()
+    def _cleanup(self):
+        """清理资源"""
+        if self.observer:
+            self.observer.stop()
+            if self.handler and self.handler.process:
+                self.handler._terminate_process()
+            self.observer.join()
     
-    if args.version:
-        console.print(f"[green]ErisPulse {get_erispulse_version()}[/]")
-        return
+    def run(self):
+        """运行CLI应用程序"""
+        args = self.parser.parse_args()
         
-    if not args.command:
-        parser.print_help()
-    
-    try:
-        if hasattr(args, 'func'):
-            args.func(args)
-        if args.command == "install":
-            import asyncio
-            # 首先检查是否是远程模块/适配器的简称
-            remote_packages = asyncio.run(PyPIManager.get_remote_packages())
-            full_package_name = None
-            
-            # 检查模块
-            if args.package in remote_packages["modules"]:
-                full_package_name = remote_packages["modules"][args.package]["package"]
-            # 检查适配器
-            elif args.package in remote_packages["adapters"]:
-                full_package_name = remote_packages["adapters"][args.package]["package"]
-            
-            # 如果找到远程包，使用完整包名安装
-            if full_package_name:
-                console.print(Panel(
-                    f"找到远程包: [bold]{args.package}[/] → [blue]{full_package_name}[/]",
-                    title="信息",
-                    style="info"
-                ))
-                PyPIManager.install_package(full_package_name, args.upgrade)
-            else:
-                # 否则按原样安装
-                PyPIManager.install_package(args.package, args.upgrade)
+        # 设置日志级别
+        if args.verbose >= 3:
+            import logging
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(message)s",
+                handlers=[RichHandler(console=console)]
+            )
+        
+        if args.version:
+            self._print_version()
+            return
             
-        elif args.command == "uninstall":
-            PyPIManager.uninstall_package(args.package)
-
-        elif args.command == "enable":
-            from ErisPulse.Core import mods
-            installed = PyPIManager.get_installed_packages()
-            if args.module not in installed["modules"]:
-                console.print(Panel(
-                    f"模块 [red]{args.module}[/] 不存在或未安装",
-                    title="错误",
-                    style="error"
-                ))
-            else:
-                mods.set_module_status(args.module, True)
-                console.print(Panel(
-                    f"模块 [green]{args.module}[/] 已启用",
-                    title="成功",
-                    style="success"
-                ))
-                
-        elif args.command == "disable":
-            from ErisPulse.Core import mods
-            installed = PyPIManager.get_installed_packages()
-            if args.module not in installed["modules"]:
-                console.print(Panel(
-                    f"模块 [red]{args.module}[/] 不存在或未安装",
-                    title="错误",
-                    style="error"
-                ))
-            else:
-                mods.set_module_status(args.module, False)
-                console.print(Panel(
-                    f"模块 [yellow]{args.module}[/] 已禁用",
-                    title="成功",
-                    style="warning"
-                ))
-                
-        elif args.command == "list":
-            installed = PyPIManager.get_installed_packages()
+        if not args.command:
+            self.parser.print_help()
+            return
             
-            # 获取已安装的CLI扩展
-            cli_extensions = {}
-            try:
-                entry_points = importlib.metadata.entry_points()
-                if hasattr(entry_points, 'select'):
-                    cli_entries = entry_points.select(group='erispulse.cli')
+        try:
+            if args.command == "install":
+                full_package = self._resolve_package_name(args.package)
+                if full_package:
+                    console.print(f"[info]找到远程包: [bold]{args.package}[/] → [package]{full_package}[/][/]")
+                    self.package_manager.install_package(full_package, args.upgrade)
                 else:
-                    cli_entries = entry_points.get('erispulse.cli', [])
-                
-                for entry in cli_entries:
-                    dist = entry.dist
-                    cli_extensions[entry.name] = {
-                        "package": dist.metadata["Name"],
-                        "version": dist.version,
-                        "summary": dist.metadata["Summary"]
-                    }
-            except Exception as e:
-                console.print(f"[yellow]获取CLI扩展信息失败: {e}[/]", style="warning")
-            
-            if args.type in ["modules", "all"] and installed["modules"]:
-                table = Table(title="已安装模块", box=SIMPLE)
-                table.add_column("模块名", style="green")
-                table.add_column("包名", style="blue")
-                table.add_column("版本")
-                table.add_column("描述")
-                
-                for name, info in installed["modules"].items():
-                    table.add_row(name, info["package"], info["version"], info["summary"])
-                
-                console.print(table)
-                
-            if args.type in ["adapters", "all"] and installed["adapters"]:
-                table = Table(title="已安装适配器", box=SIMPLE)
-                table.add_column("适配器名", style="yellow")
-                table.add_column("包名", style="blue")
-                table.add_column("版本")
-                table.add_column("描述")
-                
-                for name, info in installed["adapters"].items():
-                    table.add_row(name, info["package"], info["version"], info["summary"])
-                
-                console.print(table)
-                
-                if cli_extensions and args.type in ["cli", "all"]:
-                    table = Table(title="已安装CLI扩展", box=SIMPLE)
-                    table.add_column("命令名", style="magenta")
-                    table.add_column("包名", style="blue")
-                    table.add_column("版本")
-                    table.add_column("描述")
+                    self.package_manager.install_package(args.package, args.upgrade)
                     
-                    for name, info in cli_extensions.items():
-                        table.add_row(name, info["package"], info["version"], info["summary"])
-                console.print(table)
+            elif args.command == "uninstall":
+                self.package_manager.uninstall_package(args.package)
                 
-            if not installed["modules"] and not installed["adapters"] and not cli_extensions:
-                console.print(Panel(
-                    "没有安装任何ErisPulse模块、适配器或CLI扩展",
-                    title="提示",
-                    style="info"
-                ))
+            elif args.command == "module":
+                from ErisPulse.Core import mods
+                installed = self.package_manager.get_installed_packages()
                 
-        elif args.command == "upgrade":
-            if args.force or Confirm.ask("确定要升级所有ErisPulse模块和适配器吗？", default=False):
-                PyPIManager.upgrade_all()
-                
-        elif args.command == "run":
-            if not hasattr(args, 'script') or not args.script:
-                if not os.path.exists("config.toml") or not os.path.isfile("main.py"):
-                    from ErisPulse import sdk
-                    sdk.init()
-                args.script = "main.py"
-                console.print(Panel(
-                    "未指定主程序，运行入口点为 [bold]main.py[/]",
-                    title="提示",
-                    style="info"
-                ))
-            start_reloader(args.script, args.reload)
-        elif args.command == "list-remote":
-            import asyncio
-            try:
-                remote_packages = asyncio.run(PyPIManager.get_remote_packages())
-                
-                if args.type in ["modules", "all"] and remote_packages["modules"]:
-                    table = Table(title="远程模块", box=SIMPLE)
-                    table.add_column("模块名", style="green")
-                    table.add_column("包名", style="blue")
-                    table.add_column("版本")
-                    table.add_column("描述")
-                    
-                    for name, info in remote_packages["modules"].items():
-                        table.add_row(name, info["package"], info["version"], info["description"])
+                if args.module_command == "enable":
+                    if args.module not in installed["modules"]:
+                        console.print(f"[error]模块 [bold]{args.module}[/] 不存在或未安装[/]")
+                    else:
+                        mods.set_module_status(args.module, True)
+                        console.print(f"[success]模块 [bold]{args.module}[/] 已启用[/]")
+                        
+                elif args.module_command == "disable":
+                    if args.module not in installed["modules"]:
+                        console.print(f"[error]模块 [bold]{args.module}[/] 不存在或未安装[/]")
+                    else:
+                        mods.set_module_status(args.module, False)
+                        console.print(f"[warning]模块 [bold]{args.module}[/] 已禁用[/]")
+                else:
+                    self.parser.parse_args(["module", "--help"])
                     
-                    console.print(table)
+            elif args.command == "list":
+                pkg_type = args.type
+                if pkg_type == "all":
+                    self._print_installed_packages("modules", args.outdated)
+                    self._print_installed_packages("adapters", args.outdated)
+                    self._print_installed_packages("cli", args.outdated)
+                else:
+                    self._print_installed_packages(pkg_type, args.outdated)
                     
-                if args.type in ["adapters", "all"] and remote_packages["adapters"]:
-                    table = Table(title="远程适配器", box=SIMPLE)
-                    table.add_column("适配器名", style="yellow")
-                    table.add_column("包名", style="blue")
-                    table.add_column("版本")
-                    table.add_column("描述")
+            elif args.command == "list-remote":
+                pkg_type = args.type
+                if pkg_type == "all":
+                    self._print_remote_packages("modules")
+                    self._print_remote_packages("adapters")
+                    self._print_remote_packages("cli")
+                else:
+                    self._print_remote_packages(pkg_type)
                     
-                    for name, info in remote_packages["adapters"].items():
-                        table.add_row(name, info["package"], info["version"], info["description"])
+            elif args.command == "upgrade":
+                if args.package:
+                    self.package_manager.install_package(args.package, upgrade=True)
+                else:
+                    if args.force or Confirm.ask("确定要升级所有ErisPulse组件吗？"):
+                        self.package_manager.upgrade_all()
+                        
+            elif args.command == "run":
+                script = args.script or "main.py"
+                if not os.path.exists(script):
+                    console.print(f"[error]找不到指定文件: [path]{script}[/][/]")
+                    return
                     
-                    console.print(table)
+                reload_mode = args.reload and not args.no_reload
+                self._setup_watchdog(script, reload_mode)
                 
-                # 展示远程CLI扩展
-                if "cli_extensions" in remote_packages and args.type in ["cli", "all"] and remote_packages["cli_extensions"]:
-                    table = Table(title="远程CLI扩展", box=SIMPLE)
-                    table.add_column("命令名", style="magenta")
-                    table.add_column("包名", style="blue")
-                    table.add_column("版本")
-                    table.add_column("描述")
-                    
-                    for name, info in remote_packages["cli_extensions"].items():
-                        commands = info.get("command", [])
-                        command_str = ", ".join(commands) if isinstance(commands, list) else str(commands)
-                        table.add_row(command_str, info["package"], info["version"], info["description"])
-                    
-                    console.print(table)
-                    
-                if not remote_packages["modules"] and not remote_packages["adapters"] and \
-                   (not "cli_extensions" in remote_packages or not remote_packages["cli_extensions"]):
-                    console.print(Panel(
-                        "没有找到远程模块、适配器或CLI扩展",
-                        title="提示",
-                        style="info"
-                    ))
+                try:
+                    while True:
+                        time.sleep(1)
+                except KeyboardInterrupt:
+                    console.print("\n[info]正在安全关闭...[/]")
+                    self._cleanup()
+                    console.print("[success]已安全退出[/]")
                     
-            except Exception as e:
-                console.print(Panel(
-                    f"获取远程列表失败: {e}",
-                    title="错误",
-                    style="error"
-                ))
-        elif args.command == "init":
-            from ErisPulse import sdk
-            sdk.init()
-            console.print(Panel(
-                "初始化完成",
-                title="成功",
-                style="success"
-            ))
-    except KeyboardInterrupt as e:
-        pass
-    except Exception as e:
-        console.print(Panel(
-            f"执行命令时出错: {e}",
-            title="错误",
-            style="error"
-        ))
+            elif args.command == "init":
+                from ErisPulse import sdk
+                sdk.init(force=args.force)
+                console.print("[success]ErisPulse项目初始化完成[/]")
+                
+        except KeyboardInterrupt:
+            console.print("\n[warning]操作被用户中断[/]")
+            self._cleanup()
+        except Exception as e:
+            console.print(f"[error]执行命令时出错: {e}[/]")
+            if args.verbose >= 1:
+                import traceback
+                console.print(traceback.format_exc())
+            self._cleanup()
+            sys.exit(1)
+
+def main():
+    """主入口"""
+    cli = CLI()
+    cli.run()
 
 if __name__ == "__main__":
     main()