mofox-plugin-dev-toolkit 0.2.1__py3-none-any.whl

mpdt/templates/tool_template.py

@@ -0,0 +1,98 @@
+"""
+Tool 组件模板
+"""
+
+TOOL_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from typing import Any
+
+from src.common.logger import get_logger
+from src.plugin_system import BaseTool, ToolParamType
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BaseTool):
+    """
+    {description}
+
+    Tool 组件可以被 LLM 调用来执行特定功能。
+    """
+
+    # Tool 元数据
+    name: str = "{tool_name}"
+    description: str = "{description}"
+    available_for_llm: bool = True  # 是否可供 LLM 使用
+
+    # 定义工具参数
+    # 格式: [("参数名", 参数类型, "参数描述", 是否必填, 枚举值列表)]
+    parameters = [
+        ("query", ToolParamType.STRING, "查询内容", True, None),
+        ("limit", ToolParamType.INTEGER, "返回结果数量限制", False, None),
+        ("format", ToolParamType.STRING, "输出格式", False, ["json", "text", "markdown"]),
+    ]
+
+    # 缓存配置（可选）
+    enable_cache: bool = False  # 是否启用缓存
+    cache_ttl: int = 3600  # 缓存过期时间（秒）
+
+    async def execute(self, function_args: dict[str, Any]) -> dict[str, Any]:
+        """
+        执行工具功能（供 LLM 调用）
+
+        Args:
+            function_args: LLM 传入的参数，格式符合 parameters 定义
+
+        Returns:
+            执行结果字典
+        """
+        try:
+            logger.info(f"执行 Tool: {{self.name}}")
+            logger.debug(f"参数: {{function_args}}")
+
+            # 获取参数
+            query = function_args.get("query")
+            limit = function_args.get("limit", 10)
+            output_format = function_args.get("format", "text")
+
+            # TODO: 实现工具的核心逻辑
+            result_data = self._process_query(query, limit)
+
+            # 格式化返回结果
+            return {{
+                "status": "success",
+                "data": result_data,
+                "message": "执行成功"
+            }}
+
+        except Exception as e:
+            logger.error(f"Tool 执行失败: {{e}}")
+            return {{
+                "status": "error",
+                "message": str(e)
+            }}
+
+    def _process_query(self, query: str, limit: int) -> Any:
+        """
+        处理查询的核心逻辑
+
+        Args:
+            query: 查询内容
+            limit: 结果数量限制
+
+        Returns:
+            处理结果
+        """
+        # TODO: 实现具体的处理逻辑
+        return {{"query": query, "count": limit}}
+'''
+
+
+def get_tool_template() -> str:
+    """获取 Tool 组件模板"""
+    return TOOL_TEMPLATE

mpdt/utils/__init__.py

@@ -0,0 +1,10 @@
+"""
+工具函数模块
+"""
+
+__all__ = [
+    "file_ops",
+    "template_engine",
+    "color_printer",
+    "config_loader",
+]

mpdt/utils/color_printer.py

@@ -0,0 +1,99 @@
+"""
+彩色输出工具
+"""
+
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from rich.tree import Tree
+
+console = Console()
+
+
+def print_success(message: str) -> None:
+    """打印成功消息"""
+    console.print(f"[bold green]✅ {message}[/bold green]")
+
+
+def print_error(message: str) -> None:
+    """打印错误消息"""
+    console.print(f"[bold red]❌ {message}[/bold red]")
+
+
+def print_warning(message: str) -> None:
+    """打印警告消息"""
+    console.print(f"[bold yellow]⚠️  {message}[/bold yellow]")
+
+
+def print_info(message: str) -> None:
+    """打印信息消息"""
+    console.print(f"[bold blue]ℹ️  {message}[/bold blue]")
+
+
+def print_step(message: str) -> None:
+    """打印步骤消息"""
+    console.print(f"[bold cyan]🔸 {message}[/bold cyan]")
+
+
+def print_panel(title: str, content: str, style: str = "green") -> None:
+    """打印面板"""
+    console.print(Panel(content, title=title, style=style))
+
+
+def print_table(title: str, columns: list[str], rows: list[list[str]]) -> None:
+    """打印表格"""
+    table = Table(title=title)
+
+    for col in columns:
+        table.add_column(col, style="cyan")
+
+    for row in rows:
+        table.add_row(*row)
+
+    console.print(table)
+
+
+def print_tree(root_label: str, tree_data: dict[str, Any]) -> None:
+    """
+    打印树形结构
+    
+    Args:
+        root_label: 根节点标签
+        tree_data: 树形数据（字典或列表）
+    """
+    tree = Tree(f"[bold blue]{root_label}[/bold blue]")
+
+    def add_branch(parent: Tree, data: Any) -> None:
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if isinstance(value, (dict, list)):
+                    branch = parent.add(f"[cyan]{key}/[/cyan]")
+                    add_branch(branch, value)
+                else:
+                    parent.add(f"[green]{key}[/green]")
+        elif isinstance(data, list):
+            for item in data:
+                if isinstance(item, str):
+                    parent.add(f"[green]{item}[/green]")
+                else:
+                    add_branch(parent, item)
+
+    add_branch(tree, tree_data)
+    console.print(tree)
+
+
+def create_progress() -> Progress:
+    """创建进度条"""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    )
+
+
+def print_divider(char: str = "━", length: int = 80) -> None:
+    """打印分割线"""
+    console.print(char * length, style="dim")

mpdt/utils/config_loader.py

@@ -0,0 +1,171 @@
+"""
+配置加载器
+"""
+
+from pathlib import Path
+from typing import Any
+
+import toml
+
+
+class ConfigLoader:
+    """配置加载器"""
+
+    def __init__(self, config_path: Path | str | None = None):
+        """
+        初始化配置加载器
+        
+        Args:
+            config_path: 配置文件路径
+        """
+        self.config_path = Path(config_path) if config_path else None
+        self.config: dict[str, Any] = {}
+
+        if self.config_path and self.config_path.exists():
+            self.load()
+
+    def load(self) -> dict[str, Any]:
+        """
+        加载配置文件
+        
+        Returns:
+            配置字典
+        """
+        if not self.config_path or not self.config_path.exists():
+            return {}
+
+        self.config = toml.load(str(self.config_path))
+        return self.config
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        获取配置项
+        
+        支持点号分隔的嵌套键，例如: "mpdt.check.level"
+        
+        Args:
+            key: 配置键
+            default: 默认值
+            
+        Returns:
+            配置值
+        """
+        keys = key.split(".")
+        value = self.config
+
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """
+        设置配置项
+        
+        Args:
+            key: 配置键
+            value: 配置值
+        """
+        keys = key.split(".")
+        config = self.config
+
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+
+        config[keys[-1]] = value
+
+    def save(self, path: Path | str | None = None) -> None:
+        """
+        保存配置到文件
+        
+        Args:
+            path: 保存路径，如果为 None 则使用初始化时的路径
+        """
+        save_path = Path(path) if path else self.config_path
+
+        if not save_path:
+            raise ValueError("未指定配置文件路径")
+
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(save_path, "w", encoding="utf-8") as f:
+            toml.dump(self.config, f)
+
+
+def load_mpdt_config(project_dir: Path | str = ".") -> ConfigLoader:
+    """
+    加载 MPDT 配置文件
+    
+    优先级:
+    1. .mpdtrc.toml
+    2. pyproject.toml 中的 [tool.mpdt] 部分
+    
+    Args:
+        project_dir: 项目目录
+        
+    Returns:
+        ConfigLoader 对象
+    """
+    project_dir = Path(project_dir)
+
+    # 首先尝试加载 .mpdtrc.toml
+    mpdtrc_path = project_dir / ".mpdtrc.toml"
+    if mpdtrc_path.exists():
+        return ConfigLoader(mpdtrc_path)
+
+    # 然后尝试从 pyproject.toml 加载
+    pyproject_path = project_dir / "pyproject.toml"
+    if pyproject_path.exists():
+        config = toml.load(str(pyproject_path))
+        if "tool" in config and "mpdt" in config["tool"]:
+            loader = ConfigLoader()
+            loader.config = config["tool"]["mpdt"]
+            return loader
+
+    # 返回空配置
+    return ConfigLoader()
+
+
+def get_default_config() -> dict[str, Any]:
+    """
+    获取默认配置
+    
+    Returns:
+        默认配置字典
+    """
+    return {
+        "mpdt": {
+            "version": "0.1.2",
+        },
+        "check": {
+            "level": "warning",
+            "auto_fix": False,
+            "ignore_patterns": ["tests/*", "*.pyc", "__pycache__/*"],
+        },
+        "test": {
+            "coverage_threshold": 80,
+            "pytest_args": ["-v", "--tb=short"],
+        },
+        "build": {
+            "output_dir": "dist",
+            "include_docs": True,
+            "include_tests": False,
+            "format": "zip",
+        },
+        "dev": {
+            "port": 8080,
+            "host": "127.0.0.1",
+            "reload": True,
+            "check_on_save": True,
+        },
+        "templates": {
+            "author": "",
+            "license": "GPL-v3.0",
+            "python_version": "^3.11",
+        },
+    }

mpdt/utils/config_manager.py

@@ -0,0 +1,297 @@
+"""
+MPDT 配置管理器
+管理 mmc 路径、虚拟环境等配置信息
+"""
+
+import os
+from pathlib import Path
+from typing import Literal, Optional
+
+try:
+    import tomli
+    import tomli_w
+except ImportError:
+    # 如果没有安装 tomli，使用 toml
+    try:
+        import toml as tomli
+        import toml as tomli_w
+    except ImportError:
+        tomli = None
+        tomli_w = None
+
+VenvType = Literal["venv", "uv", "conda", "poetry", "none"]
+
+
+class MPDTConfig:
+    """MPDT 配置管理器"""
+    
+    def __init__(self, config_path: Path | None = None):
+        """初始化配置管理器
+        
+        Args:
+            config_path: 配置文件路径，默认为 ~/.mpdt/config.toml
+        """
+        if config_path is None:
+            config_path = Path.home() / ".mpdt" / "config.toml"
+        
+        self.config_path = config_path
+        self._config: dict = {}
+        
+        # 加载配置
+        if self.config_path.exists():
+            self.load()
+    
+    def load(self) -> None:
+        """加载配置文件"""
+        if not self.config_path.exists():
+            self._config = {}
+            return
+        
+        if tomli is None:
+            raise ImportError("需要安装 tomli 库来读取配置文件")
+        
+        with open(self.config_path, "rb") as f:
+            self._config = tomli.load(f)
+    
+    def save(self) -> None:
+        """保存配置文件"""
+        if tomli_w is None:
+            raise ImportError("需要安装 tomli-w 库来写入配置文件")
+        
+        # 确保目录存在
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(self.config_path, "wb") as f:
+            tomli_w.dump(self._config, f)
+    
+    @property
+    def mmc_path(self) -> Path | None:
+        """获取 mmc 主程序路径"""
+        path_str = self._config.get("mmc", {}).get("path")
+        return Path(path_str) if path_str else None
+    
+    @mmc_path.setter
+    def mmc_path(self, path: Path | str) -> None:
+        """设置 mmc 主程序路径"""
+        if "mmc" not in self._config:
+            self._config["mmc"] = {}
+        self._config["mmc"]["path"] = str(Path(path).absolute())
+    
+    @property
+    def venv_path(self) -> Path | None:
+        """获取虚拟环境路径"""
+        path_str = self._config.get("mmc", {}).get("venv_path")
+        return Path(path_str) if path_str else None
+    
+    @venv_path.setter
+    def venv_path(self, path: Path | str | None) -> None:
+        """设置虚拟环境路径"""
+        if "mmc" not in self._config:
+            self._config["mmc"] = {}
+        if path is None:
+            self._config["mmc"]["venv_path"] = None
+        else:
+            self._config["mmc"]["venv_path"] = str(Path(path).absolute())
+    
+    @property
+    def venv_type(self) -> VenvType:
+        """获取虚拟环境类型"""
+        return self._config.get("mmc", {}).get("venv_type", "venv")
+    
+    @venv_type.setter
+    def venv_type(self, venv_type: VenvType) -> None:
+        """设置虚拟环境类型"""
+        if "mmc" not in self._config:
+            self._config["mmc"] = {}
+        self._config["mmc"]["venv_type"] = venv_type
+    
+    @property
+    def auto_reload(self) -> bool:
+        """是否自动重载"""
+        return self._config.get("dev", {}).get("auto_reload", True)
+    
+    @auto_reload.setter
+    def auto_reload(self, value: bool) -> None:
+        """设置是否自动重载"""
+        if "dev" not in self._config:
+            self._config["dev"] = {}
+        self._config["dev"]["auto_reload"] = value
+    
+    @property
+    def reload_delay(self) -> float:
+        """重载延迟（秒）"""
+        return self._config.get("dev", {}).get("reload_delay", 0.3)
+    
+    @reload_delay.setter
+    def reload_delay(self, value: float) -> None:
+        """设置重载延迟"""
+        if "dev" not in self._config:
+            self._config["dev"] = {}
+        self._config["dev"]["reload_delay"] = value
+    
+    def get_python_command(self) -> list[str]:
+        """获取 Python 启动命令
+        
+        Returns:
+            Python 命令列表，例如:
+            - ["E:/venv/Scripts/python.exe"]
+            - ["conda", "run", "-p", "E:/conda_env", "python"]
+            - ["poetry", "run", "python"]
+        """
+        venv_type = self.venv_type
+        venv_path = self.venv_path
+        
+        if venv_type == "none" or not venv_path:
+            return ["python"]
+        
+        if venv_type == "venv" or venv_type == "uv":
+            # venv 和 uv 使用相同的结构
+            if os.name == "nt":  # Windows
+                python_exe = venv_path / "Scripts" / "python.exe"
+            else:  # Unix-like
+                python_exe = venv_path / "bin" / "python"
+            
+            if python_exe.exists():
+                return [str(python_exe)]
+            else:
+                # 降级到系统 Python
+                return ["python"]
+        
+        elif venv_type == "conda":
+            return ["conda", "run", "-p", str(venv_path), "python"]
+        
+        elif venv_type == "poetry":
+            # poetry 需要在 mmc 目录中执行
+            return ["poetry", "run", "python"]
+        
+        else:
+            return ["python"]
+    
+    def validate(self) -> tuple[bool, list[str]]:
+        """验证配置
+        
+        Returns:
+            (是否有效, 错误消息列表)
+        """
+        errors = []
+        
+        # 检查 mmc 路径
+        if not self.mmc_path:
+            errors.append("未配置 mmc 主程序路径")
+        elif not self.mmc_path.exists():
+            errors.append(f"mmc 路径不存在: {self.mmc_path}")
+        else:
+            # 检查是否有 bot.py
+            bot_file = self.mmc_path / "bot.py"
+            if not bot_file.exists():
+                errors.append(f"未找到 bot.py: {bot_file}")
+        
+        # 检查虚拟环境
+        if self.venv_type != "none" and self.venv_path:
+            if not self.venv_path.exists():
+                errors.append(f"虚拟环境路径不存在: {self.venv_path}")
+            else:
+                # 检查 Python 可执行文件
+                python_cmd = self.get_python_command()
+                if self.venv_type in ["venv", "uv"]:
+                    python_path = Path(python_cmd[0])
+                    if not python_path.exists():
+                        errors.append(f"Python 可执行文件不存在: {python_path}")
+        
+        return len(errors) == 0, errors
+    
+    def is_configured(self) -> bool:
+        """检查是否已配置"""
+        return self.mmc_path is not None
+
+
+def get_default_config() -> MPDTConfig:
+    """获取默认配置实例"""
+    return MPDTConfig()
+
+
+def interactive_config() -> MPDTConfig:
+    """交互式配置向导
+    
+    Returns:
+        配置好的 MPDTConfig 实例
+    """
+    from rich.console import Console
+    from rich.prompt import Prompt, Confirm
+    from rich.panel import Panel
+    
+    console = Console()
+    config = MPDTConfig()
+    
+    console.print(Panel.fit(
+        "[bold cyan]MPDT 配置向导[/bold cyan]\n\n"
+        "让我们配置 MoFox 主程序的路径和虚拟环境"
+    ))
+    
+    # 配置 mmc 路径
+    while True:
+        mmc_path_str = Prompt.ask(
+            "\n[bold]请输入 mmc 主程序路径[/bold]",
+            default=str(Path.cwd().parent / "mmc") if Path.cwd().parent.name != "mmc" else str(Path.cwd())
+        )
+        mmc_path = Path(mmc_path_str).expanduser().absolute()
+        
+        if not mmc_path.exists():
+            console.print(f"[red]路径不存在: {mmc_path}[/red]")
+            if not Confirm.ask("重新输入?", default=True):
+                break
+            continue
+        
+        bot_file = mmc_path / "bot.py"
+        if not bot_file.exists():
+            console.print(f"[yellow]警告: 未找到 bot.py[/yellow]")
+            if not Confirm.ask("仍然使用此路径?", default=False):
+                continue
+        
+        config.mmc_path = mmc_path
+        console.print(f"[green]✓ mmc 路径已设置: {mmc_path}[/green]")
+        break
+    
+    # 配置虚拟环境
+    console.print("\n[bold]虚拟环境配置[/bold]")
+    venv_type_choice = Prompt.ask(
+        "请选择虚拟环境类型",
+        choices=["venv", "uv", "conda", "poetry", "none"],
+        default="venv"
+    )
+    config.venv_type = venv_type_choice
+    
+    if venv_type_choice != "none":
+        if venv_type_choice == "poetry":
+            console.print("[cyan]使用 poetry，将在 mmc 目录中执行命令[/cyan]")
+            config.venv_path = config.mmc_path
+        else:
+            default_venv_path = str(config.mmc_path.parent / "venv")
+            if venv_type_choice == "uv":
+                default_venv_path = str(config.mmc_path.parent / ".venv")
+            elif venv_type_choice == "conda":
+                default_venv_path = str(config.mmc_path.parent / "conda_env")
+            
+            venv_path_str = Prompt.ask(
+                f"请输入 {venv_type_choice} 虚拟环境路径",
+                default=default_venv_path
+            )
+            venv_path = Path(venv_path_str).expanduser().absolute()
+            
+            if not venv_path.exists():
+                console.print(f"[yellow]警告: 虚拟环境路径不存在: {venv_path}[/yellow]")
+                if not Confirm.ask("仍然使用此路径?", default=True):
+                    config.venv_type = "none"
+                else:
+                    config.venv_path = venv_path
+            else:
+                config.venv_path = venv_path
+                console.print(f"[green]✓ 虚拟环境路径已设置: {venv_path}[/green]")
+    else:
+        console.print("[cyan]将使用系统 Python[/cyan]")
+    
+    # 保存配置
+    config.save()
+    console.print(f"\n[bold green]✓ 配置已保存: {config.config_path}[/bold green]")
+    
+    return config