ErisPulse 1.1.8__py3-none-any.whl → 1.1.11__py3-none-any.whl

ErisPulse/__main__.py

@@ -1,6 +1,7 @@
 import argparse
 import os
 import sys
+import time
 import shutil
 import aiohttp
 import zipfile
@@ -10,53 +11,166 @@ import subprocess
 import json
 from .db import env
 from .mods import mods
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
 
-def print_panel(msg, title=None, border_style=None):
-    print("=" * 60)
-    if title:
-        print(f"[{title}]")
-    print(msg)
-    print("=" * 60)
-
-def print_table(headers, rows, title=None):
-    if title:
-        print(f"== {title} ==")
-    col_widths = [len(h) for h in headers]
-    for row in rows:
-        for i, cell in enumerate(row):
-            col_widths[i] = max(col_widths[i], len(str(cell)))
-    fmt = " | ".join("{:<" + str(w) + "}" for w in col_widths)
-    print(fmt.format(*headers))
-    print("-" * (sum(col_widths) + 3 * (len(headers) - 1)))
-    for row in rows:
-        print(fmt.format(*row))
-
-def confirm(msg, default=False):
-    yes = {'y', 'yes', ''}
-    no = {'n', 'no'}
-    prompt = f"{msg} [{'Y/n' if default else 'y/N'}]: "
-    while True:
-        ans = input(prompt).strip().lower()
-        if not ans:
-            return default
-        if ans in yes:
-            return True
-        if ans in no:
-            return False
+class Shell_Printer:
+    # ANSI 颜色代码
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    RED = "\033[91m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    BLUE = "\033[94m"
+    MAGENTA = "\033[95m"
+    CYAN = "\033[96m"
+    WHITE = "\033[97m"
+    DIM = "\033[2m"
+    UNDERLINE = "\033[4m"
+    BG_BLUE = "\033[44m"
+    BG_GREEN = "\033[42m"
+    BG_YELLOW = "\033[43m"
+    BG_RED = "\033[41m"
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def _get_color(cls, level):
+        """根据消息级别返回颜色"""
+        return {
+            "info": cls.CYAN,
+            "success": cls.GREEN,
+            "warning": cls.YELLOW,
+            "error": cls.RED,
+            "title": cls.MAGENTA,
+            "default": cls.RESET,
+        }.get(level, cls.RESET)
+
+    @classmethod
+    def panel(cls, msg: str, title: str = None, level: str = "info") -> None:
+        """带标题和边框的面板，支持颜色编码"""
+        color = cls._get_color(level)
+        border_char = "═" * 60
+        
+        # 标题行
+        title_line = ""
+        if title:
+            title = f" {title.upper()} "
+            title_padding = (60 - len(title) - 4) // 2
+            left_pad = " " * title_padding
+            right_pad = " " * (60 - len(title) - title_padding - 4)
+            title_line = f"{cls.DIM}╔{left_pad}{cls.BOLD}{color}{title}{cls.RESET}{cls.DIM}{right_pad}╗{cls.RESET}\n"
+        
+        # 内容行
+        lines = []
+        for line in msg.split("\n"):
+            padding = (60 - len(line) - 4) // 2
+            left_pad = " " * padding
+            right_pad = " " * (60 - len(line) - padding - 4)
+            lines.append(f"{cls.DIM}║{cls.RESET}{left_pad}{line}{right_pad}{cls.DIM}║{cls.RESET}")
+        
+        # 底部边框
+        bottom_border = f"{cls.DIM}╚{border_char}╝{cls.RESET}"
+        
+        # 组合所有部分
+        panel = f"{title_line}{border_char}\n"
+        panel += "\n".join(lines) + "\n"
+        panel += f"{border_char}\n{bottom_border}\n"
+        
+        print(panel)
 
-def ask(msg, choices=None, default=None):
-    prompt = f"{msg}"
-    if choices:
-        prompt += f" ({'/'.join(choices)})"
-    if default:
-        prompt += f" [default: {default}]"
-    prompt += ": "
-    while True:
-        ans = input(prompt).strip()
-        if not ans and default:
-            return default
-        if not choices or ans in choices:
-            return ans
+    @classmethod
+    def table(cls, headers, rows, title=None, level="info") -> None:
+        """改进的表格输出，带有颜色和分隔线"""
+        color = cls._get_color(level)
+        if title:
+            print(f"{cls.BOLD}{color}== {title} =={cls.RESET}")
+        
+        # 计算列宽
+        col_widths = [len(h) for h in headers]
+        for row in rows:
+            for i, cell in enumerate(row):
+                col_widths[i] = max(col_widths[i], len(str(cell)))
+        
+        # 构建标题格式
+        fmt = "│".join(f" {{:<{w}}} " for w in col_widths)
+        
+        # 顶部边框
+        top_border = "┌" + "┬".join("─" * (w+2) for w in col_widths) + "┐"
+        print(f"{cls.DIM}{top_border}{cls.RESET}")
+        
+        # 表头
+        header_line = fmt.format(*headers)
+        print(f"{cls.BOLD}{color}│{header_line}│{cls.RESET}")
+        
+        # 表头分隔线
+        separator = "├" + "┼".join("─" * (w+2) for w in col_widths) + "┤"
+        print(f"{cls.DIM}{separator}{cls.RESET}")
+        
+        # 表格内容
+        for row in rows:
+            row_line = fmt.format(*row)
+            print(f"│{row_line}│")
+        
+        # 底部边框
+        bottom_border = "└" + "┴".join("─" * (w+2) for w in col_widths) + "┘"
+        print(f"{cls.DIM}{bottom_border}{cls.RESET}")
+
+    @classmethod
+    def progress_bar(cls, current, total, prefix="", suffix="", length=50):
+        """显示进度条"""
+        filled_length = int(length * current // total)
+        percent = min(100.0, 100 * (current / float(total)))
+        bar = f"{cls.GREEN}{'█' * filled_length}{cls.WHITE}{'░' * (length - filled_length)}{cls.RESET}"
+        sys.stdout.write(f"\r{cls.BOLD}{prefix}{cls.RESET} {bar} {cls.BOLD}{percent:.1f}%{cls.RESET} {suffix}")
+        sys.stdout.flush()
+        if current == total:
+            print()
+
+    @classmethod
+    def confirm(cls, msg, default=False) -> bool:
+        """带颜色和默认选择的确认对话框"""
+        yes_options = {'y', 'yes'}
+        no_options = {'n', 'no'}
+        default_str = "Y/n" if default else "y/N"
+        prompt = f"{cls.BOLD}{msg}{cls.RESET} [{cls.CYAN}{default_str}{cls.RESET}]: "
+        
+        while True:
+            ans = input(prompt).strip().lower()
+            if not ans:
+                return default
+            if ans in yes_options:
+                return True
+            if ans in no_options:
+                return False
+            print(f"{cls.YELLOW}请输入 'y' 或 'n'{cls.RESET}")
+
+    @classmethod
+    def ask(cls, msg, choices=None, default=None) -> str | None:
+        """带颜色和选择的提问"""
+        prompt = f"{cls.BOLD}{msg}{cls.RESET}"
+        if choices:
+            prompt += f" ({cls.CYAN}{'/'.join(choices)}{cls.RESET})"
+        if default:
+            prompt += f" [{cls.BLUE}默认: {default}{cls.RESET}]"
+        prompt += ": "
+        
+        while True:
+            ans = input(prompt).strip()
+            if not ans and default:
+                return default
+            if not choices or ans in choices:
+                return ans
+            print(f"{cls.YELLOW}请输入有效选项: {', '.join(choices)}{cls.RESET}")
+
+    @classmethod
+    def status(cls, msg, success=True):
+        """显示状态指示器"""
+        symbol = f"{cls.GREEN}✓" if success else f"{cls.RED}✗"
+        print(f"\r{symbol}{cls.RESET} {msg}")
+
+shellprint = Shell_Printer()
 
 class SourceManager:
     def __init__(self):
@@ -68,7 +182,7 @@ class SourceManager:
 
     async def _validate_url(self, url):
         if not url.startswith(('http://', 'https://')):
-            protocol = ask("未指定协议，请输入使用的协议", choices=['http', 'https'], default="https")
+            protocol = shellprint.confirm("未指定协议，请输入使用的协议", choices=['http', 'https'], default="https")
             url = f"{protocol}://{url}"
         if not url.endswith('.json'):
             url = f"{url}/map.json"
@@ -79,38 +193,41 @@ class SourceManager:
                     if response.headers.get('Content-Type', '').startswith('application/json'):
                         return url
                     else:
-                        print_panel(f"源 {url} 返回的内容不是有效的 JSON 格式", "错误")
+                        shellprint.panel(f"源 {url} 返回的内容不是有效的 JSON 格式", "错误", "error")
                         return None
         except Exception as e:
-            print_panel(f"访问源 {url} 失败: {e}", "错误")
+            shellprint.panel(f"访问源 {url} 失败: {e}", "错误", "error")
             return None
 
     def add_source(self, value):
+        shellprint.status(f"验证源: {value}")
         validated_url = asyncio.run(self._validate_url(value))
         if not validated_url:
-            print_panel("提供的源不是一个有效源，请检查后重试", "错误")
+            shellprint.panel("提供的源不是一个有效源，请检查后重试", "错误", "error")
             return False
+            
         origins = env.get('origins')
         if validated_url not in origins:
             origins.append(validated_url)
             env.set('origins', origins)
-            print_panel(f"源 {validated_url} 已成功添加", "成功")
+            shellprint.panel(f"源 {validated_url} 已成功添加", "成功", "success")
             return True
         else:
-            print_panel(f"源 {validated_url} 已存在，无需重复添加", "提示")
+            shellprint.panel(f"源 {validated_url} 已存在，无需重复添加", "提示", "info")
             return False
 
     def update_sources(self):
+        shellprint.status("更新模块源...")
         origins = env.get('origins')
         providers = {}
         modules = {}
         module_alias = {}
         table_rows = []
         async def fetch_source_data():
-            async with aiohttp.ClientSession() as session:
-                for origin in origins:
-                    print(f"正在获取 {origin}...")
-                    try:
+            for i, origin in enumerate(origins):
+                shellprint.status(f"获取源数据 ({i+1}/{len(origins)}): {origin}")
+                try:
+                    async with aiohttp.ClientSession() as session:
                         async with session.get(origin) as response:
                             response.raise_for_status()
                             if response.headers.get('Content-Type', '').startswith('application/json'):
@@ -128,74 +245,176 @@ class SourceManager:
                                         f"{providers[content['name']]}{module_origin_name}"
                                     ])
                             else:
-                                print_panel(f"源 {origin} 返回的内容不是有效的 JSON 格式", "错误")
-                    except Exception as e:
-                        print_panel(f"获取 {origin} 时出错: {e}", "错误")
+                                shellprint.panel(f"源 {origin} 返回的内容不是有效的 JSON 格式", "错误", "error")
+                except Exception as e:
+                    shellprint.panel(f"获取 {origin} 时出错: {e}", "错误", "error")
+                    
         asyncio.run(fetch_source_data())
-        print_table(["源", "模块", "地址"], table_rows, "源更新状态")
+        shellprint.table(["源", "模块", "地址"], table_rows, "源更新状态", "success")
         from datetime import datetime
         env.set('providers', providers)
         env.set('modules', modules)
         env.set('module_alias', module_alias)
         env.set('last_origin_update_time', datetime.now().isoformat())
-        print_panel("源更新完成", "成功")
+        shellprint.panel("源更新完成", "成功", "success")
 
     def list_sources(self):
         origins = env.get('origins')
         if not origins:
-            print_panel("当前没有配置任何源", "提示")
+            shellprint.panel("当前没有配置任何源", "提示", "info")
             return
+            
         rows = [[str(idx), origin] for idx, origin in enumerate(origins, 1)]
-        print_table(["序号", "源地址"], rows, "已配置的源")
+        shellprint.table(["序号", "源地址"], rows, "已配置的源", "info")
 
     def del_source(self, value):
         origins = env.get('origins')
         if value in origins:
             origins.remove(value)
             env.set('origins', origins)
-            print_panel(f"源 {value} 已成功删除", "成功")
+            shellprint.panel(f"源 {value} 已成功删除", "成功", "success")
         else:
-            print_panel(f"源 {value} 不存在", "错误")
+            shellprint.panel(f"源 {value} 不存在", "错误", "error")
+
+source_manager = SourceManager()
+
+class ReloadHandler(FileSystemEventHandler):
+    def __init__(self, script_path, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.script_path = script_path
+        self.process = None
+        self.last_reload = time.time()
+        self.start_process()
+
+    def start_process(self):
+        if self.process:
+            self.process.terminate()
+            self.process.wait()
+            
+        shellprint.status(f"启动进程: {self.script_path}")
+        self.process = subprocess.Popen([sys.executable, self.script_path])
+        self.last_reload = time.time()
+
+    def on_modified(self, event):
+        now = time.time()
+        # 1秒后再次触发
+        if now - self.last_reload < 1.0:
+            return
+            
+        if event.src_path.endswith(".py"):
+            print(f"\n{Shell_Printer.CYAN}[热重载] 检测到文件变动: {event.src_path}{Shell_Printer.RESET}")
+            self.start_process()
+
+def start_reloader(script_path):
+    project_root = os.path.dirname(os.path.abspath(__file__))
+    watch_dirs = [
+        os.path.dirname(os.path.abspath(script_path)),
+        os.path.join(project_root, "modules")
+    ]
+
+    handler = ReloadHandler(script_path)
+    observer = Observer()
+
+    for d in watch_dirs:
+        if os.path.exists(d):
+            observer.schedule(handler, d, recursive=True)
+
+    observer.start()
+    print(f"\n{Shell_Printer.GREEN}{Shell_Printer.BOLD}[热重载] 已启动{Shell_Printer.RESET}")
+    print(f"{Shell_Printer.DIM}监控目录: {', '.join(watch_dirs)}{Shell_Printer.RESET}\n")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+        if handler.process:
+            handler.process.terminate()
+    observer.join()
 
 def enable_module(module_name):
+    shellprint.status(f"启用模块: {module_name}")
     module_info = mods.get_module(module_name)
     if module_info:
         mods.set_module_status(module_name, True)
-        print_panel(f"✓ 模块 {module_name} 已成功启用", "成功")
+        shellprint.panel(f"模块 {module_name} 已成功启用", "成功", "success")
     else:
-        print_panel(f"模块 {module_name} 不存在", "错误")
+        shellprint.panel(f"模块 {module_name} 不存在", "错误", "error")
 
 def disable_module(module_name):
+    shellprint.status(f"禁用模块: {module_name}")
     module_info = mods.get_module(module_name)
     if module_info:
         mods.set_module_status(module_name, False)
-        print_panel(f"✓ 模块 {module_name} 已成功禁用", "成功")
+        shellprint.panel(f"模块 {module_name} 已成功禁用", "成功", "success")
     else:
-        print_panel(f"模块 {module_name} 不存在", "错误")
+        shellprint.panel(f"模块 {module_name} 不存在", "错误", "error")
 
-async def fetch_url(session, url):
+async def fetch_url(session, url, progress_callback=None):
     try:
         async with session.get(url) as response:
             response.raise_for_status()
-            return await response.read()
+            total_size = int(response.headers.get('Content-Length', 0))
+            downloaded = 0
+            data = b''
+            
+            async for chunk in response.content.iter_any():
+                data += chunk
+                downloaded += len(chunk)
+                if total_size and progress_callback:
+                    progress_callback(downloaded, total_size)
+                    
+            return data
     except Exception as e:
         print(f"请求失败: {e}")
         return None
 
 def extract_and_setup_module(module_name, module_url, zip_path, module_dir):
     try:
-        print(f"正在从 {module_url} 下载模块...")
+        print(f"正在下载模块: {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}")
+        current_downloaded = [0]
+        total_size = [0]
+        
+        def progress_callback(downloaded, total):
+            if total > 0 and total_size[0] == 0:
+                total_size[0] = total
+            if downloaded > current_downloaded[0]:
+                current_downloaded[0] = downloaded
+                prefix = f"{Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET} {Shell_Printer.DIM}下载中{Shell_Printer.RESET}"
+                suffix = f"{downloaded/1024:.1f}KB/{total/1024:.1f}KB" if total > 0 else f"{downloaded/1024:.1f}KB"
+                shellprint.progress_bar(downloaded, total or downloaded, prefix, suffix, 40)
+                
         async def download_module():
             async with aiohttp.ClientSession() as session:
-                content = await fetch_url(session, module_url)
+                content = await fetch_url(session, module_url, progress_callback)
                 if content is None:
                     return False
+                    
                 with open(zip_path, 'wb') as zip_file:
                     zip_file.write(content)
+                    
+                if total_size[0] > 0:
+                    shellprint.progress_bar(total_size[0], total_size[0], 
+                                         f"{Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}",
+                                         "下载完成", 40)
+                    
                 if not os.path.exists(module_dir):
                     os.makedirs(module_dir)
+                    
+                shellprint.status(f"解压模块: {module_name}")
                 with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-                    zip_ref.extractall(module_dir)
+                    file_list = zip_ref.namelist()
+                    for i, file in enumerate(file_list):
+                        zip_ref.extract(file, module_dir)
+                        if len(file_list) > 10 and i % (len(file_list) // 10) == 0:
+                            shellprint.progress_bar(i, len(file_list), 
+                                                 f"{Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}",
+                                                 "解压中", 30)
+                    if len(file_list) > 10:
+                        shellprint.progress_bar(len(file_list), len(file_list), 
+                                             f"{Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}",
+                                             "解压完成", 30)
+                print()
+                
                 init_file_path = os.path.join(module_dir, '__init__.py')
                 if not os.path.exists(init_file_path):
                     sub_module_dir = os.path.join(module_dir, module_name)
@@ -211,9 +430,10 @@ def extract_and_setup_module(module_name, module_url, zip_path, module_dir):
                             os.rmdir(sub_dir)
                 print(f"模块 {module_name} 文件已成功解压并设置")
                 return True
+                
         return asyncio.run(download_module())
     except Exception as e:
-        print_panel(f"处理模块 {module_name} 文件失败: {e}", "错误")
+        shellprint.panel(f"处理模块 {module_name} 文件失败: {e}", "错误", "error")
         if os.path.exists(zip_path):
             try:
                 os.remove(zip_path)
@@ -230,45 +450,60 @@ def extract_and_setup_module(module_name, module_url, zip_path, module_dir):
 def install_pip_dependencies(dependencies):
     if not dependencies:
         return True
-    print("正在安装pip依赖...")
+        
+    print(f"{Shell_Printer.CYAN}正在安装pip依赖: {', '.join(dependencies)}{Shell_Printer.RESET}")
     try:
-        result = subprocess.run(
+        # 使用子进程获取安装进度
+        process = subprocess.Popen(
             [sys.executable, "-m", "pip", "install"] + dependencies,
-            check=True,
             stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
+            stderr=subprocess.STDOUT,
+            universal_newlines=True
         )
-        print(result.stdout.decode())
-        return True
+        
+        # 实时输出安装过程
+        while True:
+            output = process.stdout.readline()
+            if output == '' and process.poll() is not None:
+                break
+            if output:
+                print(f"{Shell_Printer.DIM}{output.strip()}{Shell_Printer.RESET}")
+                
+        return process.returncode == 0
+        
     except subprocess.CalledProcessError as e:
-        print_panel(f"安装pip依赖失败: {e.stderr.decode()}", "错误")
+        shellprint.panel(f"安装pip依赖失败: {e.stderr}", "错误", "error")
         return False
 
 def install_module(module_name, force=False):
-    print_panel(f"准备安装模块: {module_name}", "安装摘要")
+    shellprint.panel(f"准备安装模块: {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}", "安装摘要", "info")
     last_update_time = env.get('last_origin_update_time', None)
     if last_update_time:
         from datetime import datetime, timedelta
         last_update = datetime.fromisoformat(last_update_time)
         if datetime.now() - last_update > timedelta(hours=720):
-            print_panel("距离上次源更新已超过30天，源内可能有新模块或更新。", "提示")
-            if confirm("是否在安装模块前更新源？", default=True):
-                SourceManager().update_sources()
+            shellprint.panel("距离上次源更新已超过30天，源内可能有新模块或更新。", "提示", "warning")
+            if shellprint.confirm("是否在安装模块前更新源？", default=True):
+                source_manager.update_sources()
                 env.set('last_origin_update_time', datetime.now().isoformat())
-                print("✓ 源更新完成")
+                shellprint.status("源更新完成")
+    
     module_info = mods.get_module(module_name)
     if module_info and not force:
         meta = module_info.get('info', {}).get('meta', {})
-        print_panel(
-            f"模块 {module_name} 已存在\n版本: {meta.get('version', '未知')}\n描述: {meta.get('description', '无描述')}",
-            "模块已存在"
+        shellprint.panel(
+            f"{Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}\n版本: {meta.get('version', '未知')}\n描述: {meta.get('description', '无描述')}",
+            "模块已存在",
+            "info"
         )
-        if not confirm("是否要强制重新安装？", default=False):
+        if not shellprint.confirm("是否要强制重新安装？", default=False):
             return
+            
     providers = env.get('providers', {})
     if isinstance(providers, str):
         providers = json.loads(providers)
     module_info_list = []
+    
     for provider, url in providers.items():
         module_key = f"{module_name}@{provider}"
         modules_data = env.get('modules', {})
@@ -289,43 +524,57 @@ def install_module(module_name, force=False):
                 'optional_dependencies': depsinfo.get("optional", []),
                 'pip_dependencies': depsinfo.get("pip", [])
             })
+            
     if not module_info_list:
-        print_panel(f"未找到模块 {module_name}", "错误")
+        shellprint.panel(f"未找到模块 {module_name}", "错误", "error")
         if providers:
-            print("当前可用源:")
+            print(f"{Shell_Printer.BOLD}当前可用源:{Shell_Printer.RESET}")
             for provider in providers:
-                print(f"  - {provider}")
+                print(f"  {Shell_Printer.CYAN}- {provider}{Shell_Printer.RESET}")
         return
+        
     if len(module_info_list) > 1:
-        print(f"找到 {len(module_info_list)} 个源的 {module_name} 模块：")
+        print(f"找到 {Shell_Printer.BOLD}{len(module_info_list)}{Shell_Printer.RESET} 个源的 {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET} 模块：")
         rows = []
         for i, info in enumerate(module_info_list):
             rows.append([
-                str(i+1), info['provider'], info['version'], info['description'], info['author']
+                f"{Shell_Printer.CYAN}{i+1}{Shell_Printer.RESET}", 
+                info['provider'], 
+                info['version'], 
+                info['description'], 
+                info['author']
             ])
-        print_table(["编号", "源", "版本", "描述", "作者"], rows, "可选模块源")
+        shellprint.table(["编号", "源", "版本", "描述", "作者"], rows, "可选模块源", "info")
+        
         while True:
-            choice = ask("请选择要安装的源 (输入编号)", default="1")
-            if choice.isdigit() and 1 <= int(choice) <= len(module_info_list):
+            choice = shellprint.ask("请选择要安装的源 (输入编号)", [str(i) for i in range(1, len(module_info_list)+1)])
+            if choice and 1 <= int(choice) <= len(module_info_list):
                 selected_module = module_info_list[int(choice)-1]
                 break
             else:
-                print("输入无效，请重新选择")
+                print(f"{Shell_Printer.YELLOW}输入无效，请重新选择{Shell_Printer.RESET}")
     else:
         selected_module = module_info_list[0]
+        
+    # 安装依赖
     for dep in selected_module['dependencies']:
-        print(f"正在安装依赖模块 {dep}...")
+        print(f"\n{Shell_Printer.BOLD}处理依赖: {dep}{Shell_Printer.RESET}")
         install_module(dep)
+        
+    # 安装pip依赖
     third_party_deps = selected_module.get('pip_dependencies', [])
     if third_party_deps:
-        print(f"模块 {module_name} 需要以下pip依赖: {', '.join(third_party_deps)}")
+        print(f"{Shell_Printer.YELLOW}模块 {module_name} 需要以下pip依赖: {', '.join(third_party_deps)}{Shell_Printer.RESET}")
         if not install_pip_dependencies(third_party_deps):
-            print(f"无法安装模块 {module_name} 的pip依赖，安装终止")
+            print(f"{Shell_Printer.RED}无法安装模块 {module_name} 的pip依赖，安装终止{Shell_Printer.RESET}")
             return
+            
+    # 下载并安装模块
     module_url = selected_module['url'] + selected_module['path']
     script_dir = os.path.dirname(os.path.abspath(__file__))
     module_dir = os.path.join(script_dir, 'modules', module_name)
     zip_path = os.path.join(script_dir, f"{module_name}.zip")
+    
     if not extract_and_setup_module(
         module_name=module_name,
         module_url=module_url,
@@ -333,6 +582,8 @@ def install_module(module_name, force=False):
         module_dir=module_dir
     ):
         return
+        
+    # 注册模块信息
     mods.set_module(module_name, {
         'status': True,
         'info': {
@@ -349,39 +600,50 @@ def install_module(module_name, force=False):
             }
         }
     })
-    print(f"模块 {module_name} 安装成功")
+    
+    shellprint.panel(f"模块 {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET} 安装成功", "成功", "success")
 
 def uninstall_module(module_name):
-    print_panel(f"准备卸载模块: {module_name}", "卸载摘要")
+    shellprint.panel(f"准备卸载模块: {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}", "卸载摘要", "warning")
     module_info = mods.get_module(module_name)
     if not module_info:
-        print_panel(f"模块 {module_name} 不存在", "错误")
+        shellprint.panel(f"模块 {module_name} 不存在", "错误", "error")
         return
+        
     meta = module_info.get('info', {}).get('meta', {})
     depsinfo = module_info.get('info', {}).get('dependencies', {})
-    print_panel(
-        f"版本: {meta.get('version', '未知')}\n描述: {meta.get('description', '无描述')}\npip依赖: {', '.join(depsinfo.get('pip', [])) or '无'}",
-        "模块信息"
+    shellprint.panel(
+        f"版本: {Shell_Printer.BOLD}{meta.get('version', '未知')}{Shell_Printer.RESET}\n"
+        f"描述: {meta.get('description', '无描述')}\n"
+        f"pip依赖: {Shell_Printer.YELLOW}{', '.join(depsinfo.get('pip', [])) or '无'}{Shell_Printer.RESET}",
+        "模块信息",
+        "info"
     )
-    if not confirm("确认要卸载此模块吗？", default=False):
-        print("卸载已取消")
+    
+    if not shellprint.confirm("确认要卸载此模块吗？", default=False):
+        print(f"{Shell_Printer.BLUE}卸载已取消{Shell_Printer.RESET}")
         return
+        
     script_dir = os.path.dirname(os.path.abspath(__file__))
     module_path = os.path.join(script_dir, 'modules', module_name)
     module_file_path = module_path + '.py'
+    
     if os.path.exists(module_file_path):
         try:
+            shellprint.status(f"删除模块文件: {module_name}.py")
             os.remove(module_file_path)
         except Exception as e:
-            print_panel(f"删除模块文件 {module_name} 时出错: {e}", "错误")
+            shellprint.panel(f"删除模块文件 {module_name} 时出错: {e}", "错误", "error")
     elif os.path.exists(module_path) and os.path.isdir(module_path):
         try:
+            shellprint.status(f"删除模块目录: {module_name}")
             shutil.rmtree(module_path)
         except Exception as e:
-            print_panel(f"删除模块目录 {module_name} 时出错: {e}", "错误")
+            shellprint.panel(f"删除模块目录 {module_name} 时出错: {e}", "错误", "error")
     else:
-        print_panel(f"模块 {module_name} 不存在", "错误")
+        shellprint.panel(f"模块 {module_name} 文件不存在", "错误", "error")
         return
+        
     pip_dependencies = depsinfo.get('pip', [])
     if pip_dependencies:
         all_modules = mods.get_all_modules()
@@ -389,55 +651,66 @@ def uninstall_module(module_name):
         essential_packages = {'aiohttp'}
         for dep in pip_dependencies:
             if dep in essential_packages:
-                print(f"跳过必要模块 {dep} 的卸载")
+                print(f"{Shell_Printer.CYAN}跳过必要模块 {dep} 的卸载{Shell_Printer.RESET}")
                 continue
+                
             is_dependency_used = False
             for name, info in all_modules.items():
                 if name != module_name and dep in info.get('info', {}).get('dependencies', {}).get('pip', []):
                     is_dependency_used = True
                     break
+                    
             if not is_dependency_used:
                 unused_pip_dependencies.append(dep)
+                
         if unused_pip_dependencies:
-            print_panel(
-                f"以下 pip 依赖不再被其他模块使用:\n{', '.join(unused_pip_dependencies)}",
-                "可卸载依赖"
+            shellprint.panel(
+                f"以下 pip 依赖不再被其他模块使用:\n{Shell_Printer.YELLOW}{', '.join(unused_pip_dependencies)}{Shell_Printer.RESET}",
+                "可卸载依赖",
+                "info"
             )
-            if confirm("是否卸载这些 pip 依赖？", default=False):
+            if shellprint.confirm("是否卸载这些 pip 依赖？", default=False):
                 try:
+                    shellprint.status(f"卸载pip依赖: {', '.join(unused_pip_dependencies)}")
                     subprocess.run(
                         [sys.executable, "-m", "pip", "uninstall", "-y"] + unused_pip_dependencies,
                         check=True,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE
                     )
-                    print_panel(
+                    shellprint.panel(
                         f"成功卸载 pip 依赖: {', '.join(unused_pip_dependencies)}",
-                        "成功"
+                        "成功",
+                        "success"
                     )
                 except subprocess.CalledProcessError as e:
-                    print_panel(
+                    shellprint.panel(
                         f"卸载 pip 依赖失败: {e.stderr.decode()}",
-                        "错误"
+                        "错误",
+                        "error"
                     )
+                    
     if mods.remove_module(module_name):
-        print_panel(f"✓ 模块 {module_name} 已成功卸载", "成功")
+        shellprint.panel(f"模块 {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET} 已成功卸载", "成功", "success")
     else:
-        print_panel(f"模块 {module_name} 不存在", "错误")
+        shellprint.panel(f"模块 {module_name} 不存在", "错误", "error")
 
 def upgrade_all_modules(force=False):
     all_modules = mods.get_all_modules()
     if not all_modules:
-        print("未找到任何模块，无法更新")
+        print(f"{Shell_Printer.YELLOW}未找到任何模块，无法更新{Shell_Printer.RESET}")
         return
+        
     providers = env.get('providers', {})
     if isinstance(providers, str):
         providers = json.loads(providers)
     modules_data = env.get('modules', {})
     if isinstance(modules_data, str):
         modules_data = json.loads(modules_data)
+        
     updates_available = []
     for module_name, module_info in all_modules.items():
+        shellprint.status(f"检查更新: {module_name}")
         local_version = module_info.get('info', {}).get('meta', {}).get('version', '0.0.0')
         for provider, url in providers.items():
             module_key = f"{module_name}@{provider}"
@@ -453,24 +726,39 @@ def upgrade_all_modules(force=False):
                         'url': url,
                         'path': remote_module.get('path', ''),
                     })
+                    
     if not updates_available:
-        print("所有模块已是最新版本，无需更新")
+        print(f"{Shell_Printer.GREEN}所有模块已是最新版本，无需更新{Shell_Printer.RESET}")
         return
-    print("\n以下模块有可用更新：")
+        
+    print(f"\n{Shell_Printer.BOLD}以下模块有可用更新：{Shell_Printer.RESET}")
     rows = []
     for update in updates_available:
-        rows.append([update['name'], update['local_version'], update['remote_version'], update['provider']])
-    print_table(["模块", "当前版本", "最新版本", "源"], rows, "可用更新")
+        rows.append([
+            update['name'], 
+            update['local_version'], 
+            f"{Shell_Printer.GREEN}{update['remote_version']}{Shell_Printer.RESET}", 
+            update['provider']
+        ])
+    shellprint.table(["模块", "当前版本", "最新版本", "源"], rows, "可用更新", "info")
+    
     if not force:
-        if not confirm("警告：更新模块可能会导致兼容性问题，请在更新前查看插件作者的相关声明。\n是否继续？", default=False):
-            print("更新已取消")
+        warning_msg = (
+            f"{Shell_Printer.BOLD}{Shell_Printer.RED}警告:{Shell_Printer.RESET} "
+            "更新模块可能会导致兼容性问题，请在更新前查看插件作者的相关声明。\n"
+            "是否继续？"
+        )
+        if not shellprint.confirm(warning_msg, default=False):
+            print(f"{Shell_Printer.BLUE}更新已取消{Shell_Printer.RESET}")
             return
-    for update in updates_available:
-        print(f"正在更新模块 {update['name']}...")
+            
+    for i, update in enumerate(updates_available, 1):
+        print(f"\n{Shell_Printer.BOLD}[{i}/{len(updates_available)}]{Shell_Printer.RESET} 更新模块 {Shell_Printer.BOLD}{update['name']}{Shell_Printer.RESET}")
         module_url = update['url'] + update['path']
         script_dir = os.path.dirname(os.path.abspath(__file__))
         module_dir = os.path.join(script_dir, 'modules', update['name'])
         zip_path = os.path.join(script_dir, f"{update['name']}.zip")
+        
         if not extract_and_setup_module(
             module_name=update['name'],
             module_url=module_url,
@@ -478,27 +766,37 @@ def upgrade_all_modules(force=False):
             module_dir=module_dir
         ):
             continue
+            
         all_modules[update['name']]['info']['version'] = update['remote_version']
         mods.set_all_modules(all_modules)
-        print(f"模块 {update['name']} 已更新至版本 {update['remote_version']}")
+        print(f"{Shell_Printer.GREEN}模块 {update['name']} 已更新至版本 {update['remote_version']}{Shell_Printer.RESET}")
+        
+    shellprint.panel("所有可用更新已处理完成", "完成", "success")
 
 def list_modules(module_name=None):
     all_modules = mods.get_all_modules()
     if not all_modules:
-        print_panel("未在数据库中发现注册模块,正在初始化模块列表...", "提示")
+        shellprint.panel("未在数据库中发现注册模块,正在初始化模块列表...", "提示", "info")
         from . import init as init_module
         init_module()
         all_modules = mods.get_all_modules()
+        
     if not all_modules:
-        print_panel("未找到任何模块", "错误")
+        shellprint.panel("未找到任何模块", "错误", "error")
         return
-    print_panel(f"找到 {len(all_modules)} 个模块", "统计")
+        
+    shellprint.panel(f"找到 {Shell_Printer.BOLD}{len(all_modules)}{Shell_Printer.RESET} 个模块", "统计", "info")
+    
     rows = []
     for name, info in all_modules.items():
-        status = "✓" if info.get("status", True) else "✗"
+        # 根据状态设置颜色
+        status_color = Shell_Printer.GREEN if info.get("status", True) else Shell_Printer.RED
+        status = f"{status_color}✓" if info.get("status", True) else f"{Shell_Printer.RED}✗"
+        
         meta = info.get('info', {}).get('meta', {})
         depsinfo = info.get('info', {}).get('dependencies', {})
         optional_deps = depsinfo.get('optional', [])
+        
         available_optional_deps = []
         missing_optional_deps = []
         if optional_deps:
@@ -513,183 +811,287 @@ def list_modules(module_name=None):
                     available_optional_deps.append(dep)
                 else:
                     missing_optional_deps.append(dep)
+                    
             if missing_optional_deps:
-                optional_dependencies = f"可用: {', '.join(available_optional_deps)} 缺失: {', '.join(missing_optional_deps)}"
+                optional_dependencies = f"可用: {', '.join(available_optional_deps)} 缺失: {Shell_Printer.RED}{', '.join(missing_optional_deps)}{Shell_Printer.RESET}"
             else:
                 optional_dependencies = ', '.join(available_optional_deps) or '无'
         else:
             optional_dependencies = '无'
-        dependencies = ', '.join(depsinfo.get('requires', [])) or '无'
-        pip_dependencies = ', '.join(depsinfo.get('pip', [])) or '无'
+            
+        # 依赖项使用不同颜色标识
+        dependencies = Shell_Printer.YELLOW + ', '.join(depsinfo.get('requires', [])) + Shell_Printer.RESET or '无'
+        pip_dependencies = Shell_Printer.CYAN + ', '.join(depsinfo.get('pip', [])) + Shell_Printer.RESET or '无'
+        
         rows.append([
-            name, status, meta.get('version', '未知'), meta.get('description', '无描述'),
-            dependencies, optional_dependencies, pip_dependencies
+            Shell_Printer.BOLD + name + Shell_Printer.RESET, 
+            status, 
+            Shell_Printer.BLUE + meta.get('version', '未知') + Shell_Printer.RESET, 
+            meta.get('description', '无描述'),
+            dependencies, 
+            optional_dependencies, 
+            pip_dependencies
         ])
-    print_table(
+        
+    shellprint.table(
         ["模块名称", "状态", "版本", "描述", "依赖", "可选依赖", "pip依赖"],
         rows,
-        "模块列表"
+        "模块列表",
+        "info"
     )
+    
     enabled_count = sum(1 for m in all_modules.values() if m.get("status", True))
     disabled_count = len(all_modules) - enabled_count
-    print_panel(f"已启用: {enabled_count}  已禁用: {disabled_count}", "模块状态统计")
+    shellprint.panel(
+        f"{Shell_Printer.GREEN}已启用: {enabled_count}{Shell_Printer.RESET}  "
+        f"{Shell_Printer.RED}已禁用: {disabled_count}{Shell_Printer.RESET}",
+        "模块状态统计",
+        "info"
+    )
 
 def main():
     parser = argparse.ArgumentParser(
-        description="ErisPulse 命令行工具",
-        prog="ep"
+        
+        prog="epsdk",
+        formatter_class=argparse.RawTextHelpFormatter
     )
-    subparsers = parser.add_subparsers(dest='command', help='可用命令')
-    enable_parser = subparsers.add_parser('enable', help='启用指定模块')
-    enable_parser.add_argument('module_names', nargs='+', help='要启用的模块名称（支持多个模块，用空格分隔）')
-    enable_parser.add_argument('--init', action='store_true', help='在启用模块前初始化模块数据库')
-    disable_parser = subparsers.add_parser('disable', help='禁用指定模块')
-    disable_parser.add_argument('module_names', nargs='+', help='要禁用的模块名称（支持多个模块，用空格分隔）')
-    disable_parser.add_argument('--init', action='store_true', help='在禁用模块前初始化模块数据库')
+    parser._positionals.title = f"{Shell_Printer.BOLD}{Shell_Printer.CYAN}基本命令{Shell_Printer.RESET}"
+    parser._optionals.title = f"{Shell_Printer.BOLD}{Shell_Printer.MAGENTA}可选参数{Shell_Printer.RESET}"
+    
+    subparsers = parser.add_subparsers(
+        dest='command', 
+        title='可用的命令',
+        metavar=f"{Shell_Printer.GREEN}<命令>{Shell_Printer.RESET}",
+        help='具体命令的帮助信息'
+    )
+    
+    command_help = {
+        'enable': '启用指定模块',
+        'disable': '禁用指定模块',
+        'list': '列出所有模块信息',
+        'update': '更新模块列表',
+        'upgrade': '升级所有可用模块',
+        'uninstall': '删除指定模块',
+        'install': '安装指定模块',
+        'origin': '管理模块源',
+        'run': '运行指定主程序'
+    }
+    
+    # 模块管理
+    def add_module_command(name, help_text):
+        cmd = subparsers.add_parser(name, help=help_text, description=help_text)
+        cmd.add_argument('module_names', nargs='+', help='模块名称')
+        if name in ['enable', 'disable', 'install']:
+            cmd.add_argument('--init', action='store_true', help='在操作前初始化模块数据库')
+        if name in ['install']:
+            cmd.add_argument('--force', action='store_true', help='强制重新安装模块')
+        return cmd
+    
+    enable_parser = add_module_command('enable', '启用指定模块')
+    disable_parser = add_module_command('disable', '禁用指定模块')
+    uninstall_parser = add_module_command('uninstall', '删除指定模块')
+    install_parser = add_module_command('install', '安装指定模块')
+    
+    # 其他命令
     list_parser = subparsers.add_parser('list', help='列出所有模块信息')
     list_parser.add_argument('--module', '-m', type=str, help='指定要展示的模块名称')
+    
     update_parser = subparsers.add_parser('update', help='更新模块列表')
+    
     upgrade_parser = subparsers.add_parser('upgrade', help='升级模块列表')
     upgrade_parser.add_argument('--force', action='store_true', help='跳过二次确认，强制更新')
-    uninstall_parser = subparsers.add_parser('uninstall', help='删除指定模块')
-    uninstall_parser.add_argument('module_names', nargs='+', help='要卸载的模块名称（支持多个模块，用空格分隔）')
-    install_parser = subparsers.add_parser('install', help='安装指定模块（支持多个模块，用空格分隔）')
-    install_parser.add_argument('module_name', nargs='+', help='要安装的模块名称（支持多个模块，用空格分隔）')
-    install_parser.add_argument('--force', action='store_true', help='强制重新安装模块')
-    install_parser.add_argument('--init', action='store_true', help='在安装模块前初始化模块数据库')
+    
     origin_parser = subparsers.add_parser('origin', help='管理模块源')
-    origin_subparsers = origin_parser.add_subparsers(dest='origin_command', help='源管理命令')
+    origin_subparsers = origin_parser.add_subparsers(
+        dest='origin_command', 
+        title='源管理命令',
+        metavar=f"{Shell_Printer.CYAN}<子命令>{Shell_Printer.RESET}"
+    )
+    
     add_origin_parser = origin_subparsers.add_parser('add', help='添加模块源')
     add_origin_parser.add_argument('url', type=str, help='要添加的模块源URL')
+    
     list_origin_parser = origin_subparsers.add_parser('list', help='列出所有模块源')
+    
     del_origin_parser = origin_subparsers.add_parser('del', help='删除模块源')
     del_origin_parser.add_argument('url', type=str, help='要删除的模块源URL')
+
+    run_parser = subparsers.add_parser('run', help='运行指定主程序')
+    run_parser.add_argument('script', type=str, help='要运行的主程序路径')
+    run_parser.add_argument('--reload', action='store_true', help='启用热重载模式，自动检测代码变动并重启')
+    
     args = parser.parse_args()
-    source_manager = SourceManager()
+    
     if hasattr(args, 'init') and args.init:
-        print("正在初始化模块列表...")
+        print(f"{Shell_Printer.GREEN}正在初始化模块列表...{Shell_Printer.RESET}")
         from . import init as init_module
         init_module()
+        print(f"{Shell_Printer.GREEN}模块列表初始化完成{Shell_Printer.RESET}")
+    
+    # 处理命令
     if args.command == 'enable':
         for module_name in args.module_names:
             module_name = module_name.strip()
             if not module_name:
                 continue
+                
             if '*' in module_name or '?' in module_name:
-                print(f"正在匹配模块模式: {module_name}...")
+                shellprint.status(f"匹配模块模式: {module_name}")
                 all_modules = mods.get_all_modules()
                 if not all_modules:
-                    print_panel("未找到任何模块，请先更新源或检查配置", "错误")
+                    shellprint.panel("未找到任何模块，请先更新源或检查配置", "错误", "error")
                     continue
+                    
                 matched_modules = [name for name in all_modules.keys() if fnmatch.fnmatch(name, module_name)]
                 if not matched_modules:
-                    print_panel(f"未找到匹配模块模式 {module_name} 的模块", "错误")
+                    shellprint.panel(f"未找到匹配模块模式 {module_name} 的模块", "错误", "error")
                     continue
-                print(f"找到 {len(matched_modules)} 个匹配模块:")
+                    
+                print(f"{Shell_Printer.GREEN}找到 {len(matched_modules)} 个匹配模块:{Shell_Printer.RESET}")
                 for i, matched_module in enumerate(matched_modules, start=1):
-                    print(f"  {i}. {matched_module}")
-                if not confirm("是否启用所有匹配模块？", default=True):
-                    print("操作已取消")
+                    print(f"  {Shell_Printer.CYAN}{i}. {matched_module}{Shell_Printer.RESET}")
+                    
+                if not shellprint.confirm("是否启用所有匹配模块？", default=True):
+                    print(f"{Shell_Printer.BLUE}操作已取消{Shell_Printer.RESET}")
                     continue
+                    
                 for matched_module in matched_modules:
                     enable_module(matched_module)
             else:
                 enable_module(module_name)
+                
     elif args.command == 'disable':
         for module_name in args.module_names:
             module_name = module_name.strip()
             if not module_name:
                 continue
+                
             if '*' in module_name or '?' in module_name:
-                print(f"正在匹配模块模式: {module_name}...")
+                shellprint.status(f"匹配模块模式: {module_name}")
                 all_modules = mods.get_all_modules()
                 if not all_modules:
-                    print_panel("未找到任何模块，请先更新源或检查配置", "错误")
+                    shellprint.panel("未找到任何模块，请先更新源或检查配置", "错误", "error")
                     continue
+                    
                 matched_modules = [name for name in all_modules.keys() if fnmatch.fnmatch(name, module_name)]
                 if not matched_modules:
-                    print_panel(f"未找到匹配模块模式 {module_name} 的模块", "错误")
+                    shellprint.panel(f"未找到匹配模块模式 {module_name} 的模块", "错误", "error")
                     continue
-                print(f"找到 {len(matched_modules)} 个匹配模块:")
+                    
+                print(f"{Shell_Printer.GREEN}找到 {len(matched_modules)} 个匹配模块:{Shell_Printer.RESET}")
                 for i, matched_module in enumerate(matched_modules, start=1):
-                    print(f"  {i}. {matched_module}")
-                if not confirm("是否禁用所有匹配模块？", default=True):
-                    print("操作已取消")
+                    print(f"  {Shell_Printer.CYAN}{i}. {matched_module}{Shell_Printer.RESET}")
+                    
+                if not shellprint.confirm("是否禁用所有匹配模块？", default=True):
+                    print(f"{Shell_Printer.BLUE}操作已取消{Shell_Printer.RESET}")
                     continue
+                    
                 for matched_module in matched_modules:
                     disable_module(matched_module)
             else:
                 disable_module(module_name)
+                
     elif args.command == 'list':
         list_modules(args.module)
+        
     elif args.command == 'uninstall':
         for module_name in args.module_names:
             module_name = module_name.strip()
             if not module_name:
                 continue
+                
             if '*' in module_name or '?' in module_name:
-                print(f"正在匹配模块模式: {module_name}...")
+                shellprint.status(f"匹配模块模式: {module_name}")
                 all_modules = mods.get_all_modules()
                 if not all_modules:
-                    print_panel("未找到任何模块，请先更新源或检查配置", "错误")
+                    shellprint.panel("未找到任何模块，请先更新源或检查配置", "错误", "error")
                     continue
+                    
                 matched_modules = [name for name in all_modules.keys() if fnmatch.fnmatch(name, module_name)]
                 if not matched_modules:
-                    print_panel(f"未找到匹配模块模式 {module_name} 的模块", "错误")
+                    shellprint.panel(f"未找到匹配模块模式 {module_name} 的模块", "错误", "error")
                     continue
-                print(f"找到 {len(matched_modules)} 个匹配模块:")
+                    
+                print(f"{Shell_Printer.GREEN}找到 {len(matched_modules)} 个匹配模块:{Shell_Printer.RESET}")
                 for i, matched_module in enumerate(matched_modules, start=1):
-                    print(f"  {i}. {matched_module}")
-                if not confirm("是否卸载所有匹配模块？", default=True):
-                    print("操作已取消")
+                    print(f"  {Shell_Printer.CYAN}{i}. {matched_module}{Shell_Printer.RESET}")
+                    
+                if not shellprint.confirm("是否卸载所有匹配模块？", default=True):
+                    print(f"{Shell_Printer.BLUE}操作已取消{Shell_Printer.RESET}")
                     continue
+                    
                 for matched_module in matched_modules:
                     uninstall_module(matched_module)
             else:
                 uninstall_module(module_name)
+                
     elif args.command == 'install':
-        for module_name in args.module_name:
+        for module_name in args.module_names:
             module_name = module_name.strip()
             if not module_name:
                 continue
+                
             if '*' in module_name or '?' in module_name:
-                print(f"正在匹配模块模式: {module_name}...")
+                shellprint.status(f"匹配模块模式: {module_name}")
                 all_modules = mods.get_all_modules()
                 if not all_modules:
-                    print_panel("未找到任何模块，请先更新源或检查配置", "错误")
+                    shellprint.panel("未找到任何模块，请先更新源或检查配置", "错误", "error")
                     continue
+                    
                 matched_modules = [name for name in all_modules.keys() if fnmatch.fnmatch(name, module_name)]
                 if not matched_modules:
-                    print_panel(f"未找到匹配模块模式 {module_name} 的模块", "错误")
+                    shellprint.panel(f"未找到匹配模块模式 {module_name} 的模块", "错误", "error")
                     continue
-                print(f"找到 {len(matched_modules)} 个匹配模块:")
+                    
+                print(f"{Shell_Printer.GREEN}找到 {len(matched_modules)} 个匹配模块:{Shell_Printer.RESET}")
                 for i, matched_module in enumerate(matched_modules, start=1):
-                    print(f"  {i}. {matched_module}")
-                if not confirm("是否安装所有匹配模块？", default=True):
-                    print("安装已取消")
+                    print(f"  {Shell_Printer.CYAN}{i}. {matched_module}{Shell_Printer.RESET}")
+                    
+                if not shellprint.confirm("是否安装所有匹配模块？", default=True):
+                    print(f"{Shell_Printer.BLUE}安装已取消{Shell_Printer.RESET}")
                     continue
+                    
                 for matched_module in matched_modules:
                     install_module(matched_module, args.force)
             else:
                 install_module(module_name, args.force)
+                
     elif args.command == 'update':
-        SourceManager().update_sources()
+        source_manager.update_sources()
+        
     elif args.command == 'upgrade':
         upgrade_all_modules(args.force)
+        
+    elif args.command == 'run':
+        script_path = args.script
+        if not os.path.exists(script_path):
+            shellprint.panel(f"找不到指定文件: {script_path}", "错误", "error")
+            return
+
+        if args.reload:
+            start_reloader(script_path)
+        else:
+            shellprint.panel(f"运行脚本: {Shell_Printer.BOLD}{script_path}{Shell_Printer.RESET}", "执行", "info")
+            import runpy
+            runpy.run_path(script_path, run_name="__main__")
+            
     elif args.command == 'origin':
         if args.origin_command == 'add':
             success = source_manager.add_source(args.url)
-            if success:
-                if confirm("源已添加，是否立即更新源以获取最新模块信息？", default=True):
-                    source_manager.update_sources()
+            if success and shellprint.confirm("源已添加，是否立即更新源以获取最新模块信息？", default=True):
+                source_manager.update_sources()
+                
         elif args.origin_command == 'list':
             source_manager.list_sources()
+            
         elif args.origin_command == 'del':
             source_manager.del_source(args.url)
+            
         else:
             origin_parser.print_help()
     else:
+        # 如果没有提供命令，显示帮助信息
         parser.print_help()
 
 if __name__ == "__main__":
-    main()
+    main()