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

mpdt/validators/metadata_validator.py

@@ -0,0 +1,125 @@
+"""
+插件元数据验证器
+"""
+
+import ast
+
+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
+
+        # 读取并解析 __init__.py
+        try:
+            with open(init_file, encoding="utf-8") as f:
+                tree = ast.parse(f.read(), filename=str(init_file))
+        except SyntaxError as e:
+            self.result.add_error(
+                f"__init__.py 存在语法错误: {e.msg}",
+                file_path="__init__.py",
+                line_number=e.lineno,
+            )
+            return self.result
+        except Exception as e:
+            self.result.add_error(f"读取 __init__.py 失败: {e}")
+            return self.result
+
+        # 查找 __plugin_meta__ 变量赋值
+        metadata_found = False
+        metadata_node = None
+
+        for node in ast.walk(tree):
+            # 查找 __plugin_meta__ = PluginMetadata(...) 赋值
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name) and target.id == "__plugin_meta__":
+                        if isinstance(node.value, ast.Call):
+                            if isinstance(node.value.func, ast.Name) and node.value.func.id == "PluginMetadata":
+                                metadata_found = True
+                                metadata_node = node.value
+                                break
+
+        if not metadata_found:
+            self.result.add_error(
+                "未找到 __plugin_meta__ 变量或 PluginMetadata 实例",
+                file_path="__init__.py",
+                suggestion="请在 __init__.py 中定义: __plugin_meta__ = PluginMetadata(...)",
+            )
+            return self.result
+
+        # 提取元数据字段
+        metadata_fields = {}
+        if metadata_node:
+            # 处理关键字参数
+            for keyword in metadata_node.keywords:
+                if keyword.arg:
+                    # 尝试获取值
+                    value = self._extract_value(keyword.value)
+                    metadata_fields[keyword.arg] = value
+
+        # 检查必需字段
+        for field in self.REQUIRED_FIELDS:
+            if field not in metadata_fields:
+                self.result.add_error(
+                    f"PluginMetadata 缺少必需字段: {field}",
+                    file_path="__init__.py",
+                )
+            elif not metadata_fields[field]:
+                self.result.add_warning(
+                    f"PluginMetadata 字段 {field} 为空",
+                    file_path="__init__.py",
+                )
+
+        # 检查推荐字段
+        for field in self.RECOMMENDED_FIELDS:
+            if field not in metadata_fields:
+                self.result.add_warning(
+                    f"PluginMetadata 缺少推荐字段: {field}",
+                    file_path="__init__.py",
+                    suggestion=f"建议添加 {field} 字段",
+                )
+
+        return self.result
+
+    def _extract_value(self, node: ast.AST) -> str | None:
+        """提取 AST 节点的值"""
+        if isinstance(node, ast.Constant):
+            return str(node.value) if node.value else None
+        elif isinstance(node, ast.Str):  # Python 3.7 兼容
+            return str(node.s) if node.s else None
+        elif isinstance(node, ast.List):
+            return "[...]"  # 列表类型
+        elif isinstance(node, ast.Dict):
+            return "{...}"  # 字典类型
+        return None

mpdt/validators/structure_validator.py

@@ -0,0 +1,70 @@
+"""
+插件结构验证器
+"""
+
+from .base import BaseValidator, ValidationResult
+
+
+class StructureValidator(BaseValidator):
+    """插件结构验证器
+
+    检查插件的目录结构和必需文件
+    """
+
+    # 必需的文件
+    REQUIRED_FILES = ["__init__.py", "plugin.py"]
+
+    # 推荐的文件
+    RECOMMENDED_FILES = ["README.md", "pyproject.toml", "requirements.txt"]
+
+    # 推荐的目录
+    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
+            if not 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
+            if not 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,125 @@
+"""代码风格验证器
+
+使用 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, auto_fix: bool = False):
+        super().__init__(plugin_path)
+        self.auto_fix = auto_fix
+        
+    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
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+            
+    def _run_ruff_check(self) -> list[dict[str, Any]]:
+        """运行 ruff 检查
+        
+        Returns:
+            问题列表
+        """
+        issues = []
+        
+        try:
+            # 构建命令
+            cmd = ["ruff", "check"]
+            if self.auto_fix:
+                cmd.append("--fix")
+            cmd.extend(["--output-format", "json", str(self.plugin_path)])
+            
+            # 运行 ruff
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding='utf-8'
+            )
+            
+            # 解析输出
+            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 "可自动修复，使用 --auto-fix 选项"
+        return None

mpdt/validators/type_validator.py

@@ -0,0 +1,223 @@
+"""类型检查验证器
+
+使用 mypy 进行类型检查
+"""
+
+import re
+import subprocess
+from pathlib import Path
+
+from .base import BaseValidator, ValidationResult
+
+
+class TypeValidator(BaseValidator):
+    """类型检查验证器
+
+    使用 mypy 进行静态类型检查
+    """
+
+    def __init__(self, plugin_path: Path):
+        super().__init__(plugin_path)
+        # 尝试找到 MoFox 主项目路径
+        self.MoFox_root = self._find_mofox_root()
+
+    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")
+                    )
+        else:
+            result.add_info("类型检查通过，未发现类型问题")
+
+        return result
+
+    def _is_mypy_installed(self) -> bool:
+        """检查 mypy 是否安装"""
+        try:
+            subprocess.run(
+                ["mypy", "--version"],
+                capture_output=True,
+                check=True
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def _find_mofox_root(self) -> Path | None:
+        """尝试找到 MoFox 主项目根目录
+
+        从插件路径向上查找，直到找到包含 src/ 目录的父目录
+        """
+        current = self.plugin_path.parent
+
+        # 最多向上查找 5 层
+        for _ in range(5):
+            if not current or current == current.parent:
+                break
+
+            # 检查是否存在 src/ 目录且包含 plugin_system 等模块
+            src_dir = current / "src"
+            if src_dir.exists() and src_dir.is_dir():
+                # 验证是否是 MMC 项目
+                if (src_dir / "plugin_system").exists() or (src_dir / "common").exists():
+                    return current
+
+            current = current.parent
+
+        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",  # 避免包命名空间问题
+            ]
+
+            # 如果找到了 MMC 主项目，添加到 Python 路径
+            if self.MoFox_root:
+                cmd.extend(["--python-path", str(self.MoFox_root)])
+
+            # 运行 mypy
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True
+            )
+
+            # 解析输出
+            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