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

mpdt/validators/config_validator.py

@@ -0,0 +1,119 @@
+"""
+配置文件验证器
+"""
+
+from ..utils.code_parser import CodeParser
+from .base import BaseValidator, ValidationResult
+
+
+class ConfigValidator(BaseValidator):
+    """配置文件验证器
+
+    仅检查插件类中定义的 config_schema 是否正确
+    不验证 config.toml 文件（因为它会在运行时自动生成）
+    """
+
+    def validate(self) -> ValidationResult:
+        """执行配置验证
+
+        Returns:
+            ValidationResult: 验证结果
+        """
+        # 获取插件名称
+        plugin_name = self._get_plugin_name()
+        if not plugin_name:
+            self.result.add_error("无法确定插件名称")
+            return self.result
+
+        plugin_file = self.plugin_path / "plugin.py"
+
+        if not plugin_file.exists():
+            self.result.add_error("插件文件不存在: plugin.py")
+            return self.result
+
+        # 解析 plugin.py 查找 config_schema
+        config_schema = self._extract_config_schema(plugin_file, plugin_name)
+
+        if config_schema is None:
+            # 没有定义 config_schema，这是正常的
+            self.result.add_warning(
+                "插件未定义配置 schema",
+                file_path="plugin.py",
+                suggestion="最好定义config_schema启用插件配置系统",
+            )
+            return self.result
+
+        # 验证 config_schema 的结构
+        if not config_schema:
+            self.result.add_warning(
+                "config_schema 已定义但为空",
+                file_path="plugin.py",
+                suggestion="最好往里面加入一些配置项",
+            )
+            return self.result
+
+        # 检查是否定义了 config_file_name
+        has_config_file_name = self._check_config_file_name(plugin_file, plugin_name)
+        if not has_config_file_name:
+            self.result.add_warning(
+                "定义了 config_schema 但未定义 config_file_name",
+                file_path="plugin.py",
+                suggestion="请在插件类中添加: config_file_name = 'config.toml'",
+            )
+
+        # 验证每个配置节
+        for section_name, section_content in config_schema.items():
+            if not section_name:
+                self.result.add_error(
+                    "config_schema 中存在空的配置节名",
+                    file_path="plugin.py",
+                )
+            elif not isinstance(section_content, dict):
+                self.result.add_warning(
+                    f"config_schema 中的 [{section_name}] 节格式不正确",
+                    file_path="plugin.py",
+                    suggestion="每个配置节应该是一个字典，包含 ConfigField 定义",
+                )
+
+        self.result.add_info(f"config_schema 定义了 {len(config_schema)} 个配置节")
+        return self.result
+
+    def _check_config_file_name(self, plugin_file, plugin_name: str) -> bool:
+        """检查是否定义了 config_file_name
+
+        Args:
+            plugin_file: plugin.py 文件路径
+            plugin_name: 插件名称
+
+        Returns:
+            是否定义了 config_file_name
+        """
+        try:
+            parser = CodeParser.from_file(plugin_file)
+            return parser.has_class_attribute(
+                attribute_name="config_file_name",
+                base_class="BasePlugin"
+            )
+        except Exception:
+            return False
+
+    def _extract_config_schema(self, plugin_file, plugin_name: str) -> dict | None:
+        """从 plugin.py 中提取 config_schema 定义
+
+        Args:
+            plugin_file: plugin.py 文件路径
+            plugin_name: 插件名称
+
+        Returns:
+            config_schema 字典，如果未定义返回 None
+        """
+        try:
+            parser = CodeParser.from_file(plugin_file)
+            config_schema = parser.find_class_attribute(
+                base_class="BasePlugin",
+                attribute_name="config_schema"
+            )
+            return config_schema
+        except Exception as e:
+            self.result.add_error(f"解析 plugin.py 失败: {e}")
+            return None

mpdt/validators/metadata_validator.py

@@ -0,0 +1,107 @@
+"""
+插件元数据验证器
+"""
+
+from ..utils.code_parser import CodeParser
+from .base import BaseValidator, ValidationResult
+
+
+class MetadataValidator(BaseValidator):
+    """插件元数据验证器
+
+    检查 plugin.py 中的 PluginMetadata 是否完整
+    """
+
+    # 必需的元数据字段
+    REQUIRED_FIELDS = ["name", "description", "usage"]
+
+    # 推荐的元数据字段
+    RECOMMENDED_FIELDS = ["version", "author", "license"]
+
+    def validate(self) -> ValidationResult:
+        """执行元数据验证
+
+        Returns:
+            ValidationResult: 验证结果
+        """
+        # 获取插件名称
+        plugin_name = self._get_plugin_name()
+        if not plugin_name:
+            self.result.add_error("无法确定插件名称")
+            return self.result
+
+        # 元数据在 __init__.py 中
+        init_file = self.plugin_path / "__init__.py"
+        if not init_file.exists():
+            self.result.add_error(
+                "__init__.py 文件不存在",
+                suggestion="请创建 __init__.py 文件并定义 __plugin_meta__",
+            )
+            return self.result
+
+        # 使用 CodeParser 解析
+        try:
+            parser = CodeParser.from_file(init_file)
+        except SyntaxError as e:
+            self.result.add_error(
+                f"__init__.py 存在语法错误: {e.msg}",
+                file_path="__init__.py",
+                line_number=e.lineno if hasattr(e, "lineno") else None,
+            )
+            return self.result
+        except Exception as e:
+            self.result.add_error(f"读取 __init__.py 失败: {e}")
+            return self.result
+
+        # 查找 __plugin_meta__ 赋值
+        metadata_values = parser.find_assignments("__plugin_meta__")
+
+        if not metadata_values:
+            self.result.add_error(
+                "未找到 __plugin_meta__ 变量或 PluginMetadata 实例",
+                file_path="__init__.py",
+                suggestion="请在 __init__.py 中定义: __plugin_meta__ = PluginMetadata(...) | 可运行 'mpdt check --fix' 自动修复",
+            )
+            return self.result
+
+        # 使用增强的 CodeParser 解析 PluginMetadata 的参数
+        metadata_args = parser.find_call_arguments("__plugin_meta__", "PluginMetadata")
+
+        if metadata_args is None:
+            self.result.add_error(
+                "未找到 __plugin_meta__ 的 PluginMetadata 调用",
+                file_path="__init__.py",
+                suggestion="请使用 PluginMetadata(...) 构造 __plugin_meta__ | 可运行 'mpdt check --fix' 自动修复",
+            )
+            return self.result
+
+        self.result.add_info("找到 __plugin_meta__ 定义")
+
+        # 检查必需字段
+        missing_required = parser.get_missing_call_arguments("__plugin_meta__", self.REQUIRED_FIELDS, "PluginMetadata")
+
+        if missing_required:
+            for field in missing_required:
+                self.result.add_error(
+                    f"PluginMetadata 缺少必需字段: {field}",
+                    file_path="__init__.py",
+                    suggestion=f'请在 PluginMetadata 中添加 {field}="..." 参数 | 可运行 \'mpdt check --fix\' 自动修复',
+                )
+        else:
+            self.result.add_info("所有必需的元数据字段都已提供")
+
+        # 检查推荐字段
+        missing_recommended = []
+        for field in self.RECOMMENDED_FIELDS:
+            if field not in metadata_args or not metadata_args[field]:
+                missing_recommended.append(field)
+
+        if missing_recommended:
+            fields_str = ", ".join(f'{f}="..."' for f in missing_recommended)
+            self.result.add_warning(
+                f"建议添加以下元数据字段: {', '.join(missing_recommended)}",
+                file_path="__init__.py",
+                suggestion=f"在 PluginMetadata 中添加: {fields_str}",
+            )
+
+        return self.result

mpdt/validators/structure_validator.py

@@ -0,0 +1,72 @@
+"""
+插件结构验证器
+"""
+
+from .base import BaseValidator, ValidationResult
+
+
+class StructureValidator(BaseValidator):
+    """插件结构验证器
+
+    检查插件的目录结构和必需文件
+    """
+
+    # 必需的文件
+    REQUIRED_FILES = ["__init__.py", "plugin.py"]
+
+    # 推荐的文件
+    RECOMMENDED_FILES = ["README.md"]
+
+    # 推荐的目录
+    RECOMMENDED_DIRS = ["tests", "docs"]
+
+    def validate(self) -> ValidationResult:
+        """执行结构验证
+
+        Returns:
+            ValidationResult: 验证结果
+        """
+        # 获取插件名称
+        plugin_name = self._get_plugin_name()
+        if not plugin_name:
+            self.result.add_error(
+                "无法确定插件名称，请确保插件目录结构正确",
+                suggestion="插件应该有 plugin.py 文件",
+            )
+            return self.result
+
+        # 插件代码目录就是根目录
+        plugin_code_dir = self.plugin_path
+
+        # 检查必需的文件
+        for file_name in self.REQUIRED_FILES:
+            file_path = plugin_code_dir / file_name
+            if not file_path.exists():
+                self.result.add_error(
+                    f"缺少必需文件: {file_name}",
+                    file_path=str(file_path.relative_to(self.plugin_path)),
+                )
+
+        # 检查推荐的文件
+        for file_name in self.RECOMMENDED_FILES:
+            file_path = self.plugin_path / file_name
+            parent_file_path = self.plugin_path.parent / file_name
+            if not file_path.exists() and not parent_file_path.exists():
+                self.result.add_warning(
+                    f"缺少推荐文件: {file_name}",
+                    file_path=file_name,
+                    suggestion=f"建议添加 {file_name} 以提供更好的文档或依赖管理",
+                )
+
+        # 检查推荐的目录
+        for dir_name in self.RECOMMENDED_DIRS:
+            dir_path = self.plugin_path / dir_name
+            parent_dir_path = self.plugin_path.parent / dir_name
+            if not dir_path.exists() and not parent_dir_path.exists():
+                self.result.add_warning(
+                    f"缺少推荐目录: {dir_name}/",
+                    file_path=dir_name,
+                    suggestion=f"建议添加 {dir_name}/ 目录",
+                )
+
+        return self.result

mpdt/validators/style_validator.py

@@ -0,0 +1,117 @@
+"""代码风格验证器
+
+使用 ruff 检查代码风格问题
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from .base import BaseValidator, ValidationResult
+
+
+class StyleValidator(BaseValidator):
+    """代码风格验证器
+
+    使用 ruff 检查代码风格和代码质量问题
+    """
+
+    def __init__(self, plugin_path: Path):
+        super().__init__(plugin_path)
+
+    def validate(self) -> ValidationResult:
+        """执行代码风格检查"""
+        result = ValidationResult(
+            validator_name="StyleValidator",
+            success=True
+        )
+
+        plugin_name = self._get_plugin_name()
+        if not plugin_name:
+            result.add_error("无法确定插件名称")
+            return result
+
+        # 检查 ruff 是否安装
+        if not self._is_ruff_installed():
+            result.add_warning("未安装 ruff，跳过代码风格检查", suggestion="运行 'pip install ruff' 安装")
+            return result
+
+        # 运行 ruff check
+        issues = self._run_ruff_check()
+
+        if issues:
+            for issue in issues:
+                result.add_warning(
+                    issue["message"],
+                    file_path=issue.get("file"),
+                    line_number=issue.get("line"),
+                    suggestion=issue.get("suggestion"),
+                )
+        else:
+            result.add_info("代码风格检查通过，未发现问题")
+
+        return result
+
+    def _is_ruff_installed(self) -> bool:
+        """检查 ruff 是否安装"""
+        try:
+            subprocess.run(["ruff", "--version"], capture_output=True, check=True, encoding='utf-8', errors='ignore')
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def _run_ruff_check(self) -> list[dict[str, Any]]:
+        """运行 ruff 检查
+
+        Returns:
+            问题列表
+        """
+        issues = []
+
+        try:
+            # 构建命令
+            cmd = ["ruff", "check", "--output-format", "json", str(self.plugin_path)]
+
+            # 运行 ruff
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding='utf-8',
+                errors='ignore'
+            )
+
+            # 解析输出
+            if result.stdout.strip():
+                try:
+                    ruff_output = json.loads(result.stdout)
+                    for item in ruff_output:
+                        issues.append(
+                            {
+                                "file": str(Path(item["filename"]).relative_to(self.plugin_path)),
+                                "line": item["location"]["row"],
+                                "message": f"{item['code']}: {item['message']}",
+                                "suggestion": self._get_fix_suggestion(item),
+                            }
+                        )
+                except json.JSONDecodeError:
+                    # 如果不是 JSON 格式，尝试解析纯文本
+                    pass
+
+        except Exception as e:
+            # 不抛出异常，只记录问题
+            issues.append({
+                "file": None,
+                "line": None,
+                "message": f"运行 ruff 时出错: {e}",
+                "suggestion": None
+            })
+
+        return issues
+
+    def _get_fix_suggestion(self, item: dict) -> str | None:
+        """获取修复建议"""
+        if item.get("fix"):
+            return "可自动修复，使用 --fix 选项"
+        return None

mpdt/validators/type_validator.py

@@ -0,0 +1,206 @@
+"""类型检查验证器
+
+使用 mypy 进行类型检查
+"""
+
+import re
+import subprocess
+from pathlib import Path
+
+from mpdt.utils.config_manager import MPDTConfig
+
+from .base import BaseValidator, ValidationResult
+
+
+class TypeValidator(BaseValidator):
+    """类型检查验证器
+
+    使用 mypy 进行静态类型检查
+    """
+
+    def __init__(self, plugin_path: Path):
+        super().__init__(plugin_path)
+        # 尝试找到 MoFox 主项目路径
+        self.MoFox_root = MPDTConfig().mofox_path
+
+    def validate(self) -> ValidationResult:
+        """执行类型检查"""
+        result = ValidationResult(
+            validator_name="TypeValidator",
+            success=True
+        )
+
+        plugin_name = self._get_plugin_name()
+        if not plugin_name:
+            result.add_error("无法确定插件名称")
+            return result
+
+        # 检查 mypy 是否安装
+        if not self._is_mypy_installed():
+            result.add_warning(
+                "未安装 mypy，跳过类型检查",
+                suggestion="运行 'pip install mypy' 安装"
+            )
+            return result
+
+        # 运行 mypy
+        issues = self._run_mypy_check()
+
+        if issues:
+            for issue in issues:
+                # 根据严重程度决定是错误还是警告
+                if issue.get("severity") == "error":
+                    result.add_error(
+                        issue["message"],
+                        file_path=issue.get("file"),
+                        line_number=issue.get("line"),
+                        suggestion=issue.get("suggestion")
+                    )
+                else:
+                    result.add_warning(
+                        issue["message"],
+                        file_path=issue.get("file"),
+                        line_number=issue.get("line"),
+                        suggestion=issue.get("suggestion")
+                    )
+
+        return result
+
+    def _is_mypy_installed(self) -> bool:
+        """检查 mypy 是否安装"""
+        try:
+            subprocess.run(
+                ["mypy", "--version"],
+                capture_output=True,
+                check=True,
+                encoding='utf-8',
+                errors='ignore'
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+        return None
+
+    def _run_mypy_check(self) -> list[dict]:
+        """运行 mypy 检查
+
+        Returns:
+            问题列表
+        """
+        issues = []
+
+        try:
+            # 构建命令
+            cmd = [
+                "mypy",
+                str(self.plugin_path),
+                "--no-error-summary",
+                "--show-column-numbers",
+                "--show-error-codes",
+                "--no-namespace-packages",  # 避免包命名空间问题
+            ]
+
+            # 如果找到了 MoFox-Bot 主项目，添加到 Python 路径
+            if self.MoFox_root:
+                cmd.extend(["--python-path", str(self.MoFox_root)])
+
+            # 运行 mypy
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding='utf-8',
+                errors='ignore'
+            )
+
+            # 解析输出
+            if result.stdout.strip():
+                for line in result.stdout.strip().split('\n'):
+                    issue = self._parse_mypy_line(line)
+                    if issue:
+                        # 如果找不到 MoFox 根目录，过滤掉所有 src.* 模块的导入错误
+                        if not self.MoFox_root:
+                            # 检查是否是 src.* 模块的导入错误
+                            if "Cannot find implementation" in issue["message"] and '"src.' in issue["message"]:
+                                continue  # 跳过这个错误
+                            # 检查是否是因为基类是 Any 导致的错误（因为导入失败）
+                            if "has type \"Any\"" in issue["message"]:
+                                continue  # 跳过这个错误
+                        issues.append(issue)
+
+        except Exception as e:
+            issues.append({
+                "file": None,
+                "line": None,
+                "message": f"运行 mypy 时出错: {e}",
+                "severity": "error",
+                "suggestion": None
+            })
+
+        return issues
+
+    def _parse_mypy_line(self, line: str) -> dict | None:
+        """解析 mypy 输出的一行
+
+        格式: file.py:123:45: error: Message [error-code]
+
+        Args:
+            line: mypy 输出的一行
+
+        Returns:
+            解析后的问题字典，如果解析失败返回 None
+        """
+        # 匹配 mypy 输出格式
+        pattern = r'^(.+?):(\d+):(?:\d+:)?\s+(error|warning|note):\s+(.+?)(?:\s+\[(.+?)\])?$'
+        match = re.match(pattern, line)
+
+        if not match:
+            return None
+
+        file_path, line_num, severity, message, error_code = match.groups()
+
+        try:
+            # 转换为相对路径
+            rel_path = str(Path(file_path).relative_to(self.plugin_path))
+        except ValueError:
+            rel_path = file_path
+
+        issue = {
+            "file": rel_path,
+            "line": int(line_num),
+            "message": message.strip(),
+            "severity": severity,
+            "suggestion": None
+        }
+
+        # 添加错误代码到消息中
+        if error_code:
+            issue["message"] = f"[{error_code}] {issue['message']}"
+
+        # 根据常见错误提供建议
+        issue["suggestion"] = self._get_type_hint_suggestion(message, error_code)
+
+        return issue
+
+    def _get_type_hint_suggestion(self, message: str, error_code: str | None) -> str | None:
+        """根据错误消息提供类型提示建议"""
+        if not error_code:
+            return None
+
+        suggestions = {
+            "no-untyped-def": "为函数添加类型注解",
+            "no-untyped-call": "被调用的函数缺少类型注解",
+            "assignment": "检查赋值的类型是否匹配",
+            "return-value": "检查返回值类型是否与声明一致",
+            "arg-type": "检查参数类型是否正确",
+            "attr-defined": "检查属性是否存在",
+            "name-defined": "检查名称是否定义",
+            "import": "检查导入是否正确"
+        }
+
+        for code, suggestion in suggestions.items():
+            if code in error_code:
+                return suggestion
+
+        return None