npm - @birthday8/doc-mcp - Versions diffs - 1.0.2 → 1.0.4 - Mend

@birthday8/doc-mcp 1.0.2 → 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +61 -21
package/index.js +61 -56
package/install.js +45 -35
package/package.json +1 -1
package/python/docx_converter.py +15 -83
package/python/html_rules.py +652 -0
package/python/html_validator.py +59 -274
package/python/html_validator_strict.py +430 -0
package/python/sample/example.html +0 -14
package/python/sample/html_schema.py +352 -0
package/python/server.py +112 -75
package/python/test_strict_validation.py +118 -0

package/python/html_validator_strict.py ADDED Viewed

@@ -0,0 +1,430 @@
+"""
+严格HTML验证器
+基于规则引擎的严格验证，提供结构化JSON输出
+"""
+from bs4 import BeautifulSoup, Tag, NavigableString
+from typing import Dict, List, Set, Optional, Any
+from html_rules import RuleEngine, ValidationResult
+class StrictHTMLValidator:
+    """严格HTML验证器"""
+    # 支持的类名列表
+    SUPPORTED_CLASSES = {
+        "center",
+        "right",
+        "left",
+        "info",
+        "warning",
+        "success",
+        "columns",
+    }
+    def __init__(self, rule_engine: RuleEngine = None):
+        self.rule_engine = rule_engine or RuleEngine()
+    def validate(self, html_content: str, strict_mode: bool = True) -> ValidationResult:
+        """
+        验证HTML内容
+        Args:
+            html_content: HTML内容
+            strict_mode: 严格模式，True时遇到错误立即返回，False时收集所有错误
+        Returns:
+            ValidationResult: 验证结果
+        """
+        result = ValidationResult(is_valid=True)
+        try:
+            soup = BeautifulSoup(html_content, "html.parser")
+            # 检查基本结构
+            self._validate_structure(soup, result, strict_mode)
+            # 检查标签
+            self._validate_tags(soup, result, strict_mode)
+            # 检查属性
+            self._validate_attributes(soup, result, strict_mode)
+            # 检查类名
+            self._validate_classes(soup, result, strict_mode)
+            # 检查样式
+            self._validate_styles(soup, result, strict_mode)
+            # 检查嵌套
+            self._validate_nesting(soup, result, strict_mode)
+            # 检查自闭合标签
+            self._validate_self_closing(soup, result, strict_mode)
+            # 检查style标签
+            self._validate_style_tags(soup, result, strict_mode)
+        except Exception as e:
+            result.add_error(
+                code="PARSING_ERROR",
+                message=f"HTML解析错误: {str(e)}",
+                details={"exception": str(e)},
+            )
+        return result
+    def _validate_structure(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证HTML基本结构"""
+        html_tag = soup.find("html")
+        if not html_tag:
+            result.add_error(
+                code="MISSING_HTML_TAG",
+                message="缺少 <html> 根标签",
+                details={"tag": "html"},
+            )
+            if strict_mode:
+                return
+        head_tag = soup.find("head")
+        if not head_tag:
+            result.add_warning(code="MISSING_HEAD_TAG", message="缺少 <head> 标签")
+        body_tag = soup.find("body")
+        if not body_tag:
+            result.add_error(
+                code="MISSING_BODY_TAG",
+                message="缺少 <body> 标签",
+                details={"tag": "body"},
+            )
+            if strict_mode:
+                return
+        # 检查编码
+        charset = soup.find("meta", {"charset": True})
+        if not charset or charset.get("charset") != "UTF-8":
+            result.add_warning(
+                code="CHARSET_WARNING",
+                message="建议使用 UTF-8 编码",
+                details={"current": charset.get("charset") if charset else "None"},
+            )
+        # 检查语言
+        if html_tag and html_tag.get("lang") != "zh-CN":
+            result.add_warning(
+                code="LANG_WARNING",
+                message="建议设置 lang='zh-CN'",
+                details={"current": html_tag.get("lang", "None")},
+            )
+    def _validate_tags(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证标签"""
+        for element in soup.find_all(True):
+            if not isinstance(element, Tag):
+                continue
+            tag_name = element.name
+            # 检查标签是否允许
+            if not self.rule_engine.is_tag_allowed(tag_name):
+                result.add_error(
+                    code="DISALLOWED_TAG",
+                    message=f"标签 <{tag_name}> 不在允许列表中",
+                    details={
+                        "tag": tag_name,
+                        "position": str(element)[:100],
+                        "allowed_tags": list(self.rule_engine.tag_rules.keys()),
+                    },
+                )
+                if strict_mode:
+                    continue
+            # 检查必需属性
+            tag_rule = self.rule_engine.get_tag_rule(tag_name)
+            if tag_rule and tag_rule.required_attrs:
+                for required_attr in tag_rule.required_attrs:
+                    if required_attr not in element.attrs:
+                        result.add_error(
+                            code="MISSING_REQUIRED_ATTR",
+                            message=f"标签 <{tag_name}> 缺少必需属性 '{required_attr}'",
+                            details={
+                                "tag": tag_name,
+                                "missing_attr": required_attr,
+                                "required_attrs": list(tag_rule.required_attrs),
+                            },
+                        )
+    def _validate_attributes(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证属性"""
+        for element in soup.find_all(True):
+            if not isinstance(element, Tag):
+                continue
+            tag_name = element.name
+            # 检查属性是否允许
+            tag_rule = self.rule_engine.get_tag_rule(tag_name)
+            if not tag_rule:
+                continue
+            for attr_name, attr_value in element.attrs.items():
+                if not self.rule_engine.is_attribute_allowed(attr_name, tag_name):
+                    result.add_error(
+                        code="DISALLOWED_ATTR",
+                        message=f"标签 <{tag_name}> 的属性 '{attr_name}' 不在允许列表中",
+                        details={
+                            "tag": tag_name,
+                            "attribute": attr_name,
+                            "value": str(attr_value)[:100],
+                        },
+                    )
+                    if strict_mode:
+                        continue
+    def _validate_classes(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证类名是否支持"""
+        for element in soup.find_all(True):
+            if not isinstance(element, Tag):
+                continue
+            class_attr = element.get("class")
+            if not class_attr:
+                continue
+            # 处理类名列表
+            if isinstance(class_attr, list):
+                classes = class_attr
+            else:
+                classes = class_attr.split()
+            unsupported_classes = []
+            for cls in classes:
+                if cls not in self.SUPPORTED_CLASSES:
+                    unsupported_classes.append(cls)
+            if unsupported_classes:
+                result.add_error(
+                    code="UNSUPPORTED_CLASS",
+                    message=f"类名 '{', '.join(unsupported_classes)}' 不在支持列表中，请使用内联 style 属性代替",
+                    details={
+                        "unsupported_classes": unsupported_classes,
+                        "supported_classes": list(self.SUPPORTED_CLASSES),
+                        "element": element.name,
+                        "note": "只支持：center, right, left, info, warning, success, columns",
+                    },
+                )
+                if strict_mode:
+                    continue
+    def _validate_styles(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证样式"""
+        for element in soup.find_all(True):
+            if not isinstance(element, Tag):
+                continue
+            style_attr = element.get("style")
+            if not style_attr:
+                continue
+            # 解析样式
+            styles = self._parse_style_string(style_attr)
+            for prop_name, prop_value in styles.items():
+                if not self.rule_engine.is_style_allowed(prop_name, element.name):
+                    result.add_error(
+                        code="DISALLOWED_STYLE",
+                        message=f"样式属性 '{prop_name}' 不在允许列表中",
+                        details={
+                            "style": prop_name,
+                            "value": prop_value,
+                            "element": element.name,
+                        },
+                    )
+                    if strict_mode:
+                        continue
+                # 验证颜色格式
+                if prop_name in ["color", "background-color"]:
+                    if not self.rule_engine.is_valid_color(prop_value):
+                        result.add_error(
+                            code="INVALID_COLOR_FORMAT",
+                            message="颜色格式错误，必须使用十六进制格式 #RRGGBB",
+                            details={
+                                "style": prop_name,
+                                "value": prop_value,
+                                "correct_format": "#RRGGBB",
+                            },
+                        )
+                # 验证字号格式
+                if prop_name == "font-size":
+                    if not prop_value.endswith("pt"):
+                        result.add_error(
+                            code="INVALID_FONT_SIZE_FORMAT",
+                            message="字号格式错误，必须使用 pt 单位",
+                            details={
+                                "style": prop_name,
+                                "value": prop_value,
+                                "correct_format": "14pt, 16pt, 18pt",
+                            },
+                        )
+                # 验证行距格式
+                if prop_name == "line-height":
+                    try:
+                        float(prop_value)
+                    except ValueError:
+                        result.add_error(
+                            code="INVALID_LINE_HEIGHT_FORMAT",
+                            message="行距格式错误，必须是数字或小数",
+                            details={
+                                "style": prop_name,
+                                "value": prop_value,
+                                "correct_format": "1.5, 1.8, 2.0",
+                            },
+                        )
+                # 验证边距格式
+                if prop_name in ["margin-top", "margin-bottom"]:
+                    if not prop_value.endswith("pt"):
+                        result.add_error(
+                            code="INVALID_MARGIN_FORMAT",
+                            message="边距格式错误，必须使用 pt 单位",
+                            details={
+                                "style": prop_name,
+                                "value": prop_value,
+                                "correct_format": "10pt, 12pt, 15pt",
+                            },
+                        )
+    def _validate_nesting(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证嵌套规则"""
+        for parent in soup.find_all(True):
+            if not isinstance(parent, Tag):
+                continue
+            for child in parent.find_all(True, recursive=False):
+                if not isinstance(child, Tag):
+                    continue
+                if not self.rule_engine.is_nesting_allowed(parent.name, child.name):
+                    result.add_error(
+                        code="INVALID_NESTING",
+                        message=f"标签 <{child.name}> 不能嵌套在 <{parent.name}> 中",
+                        details={
+                            "parent": parent.name,
+                            "child": child.name,
+                            "context": str(parent)[:100],
+                        },
+                    )
+                    if strict_mode:
+                        continue
+    def _validate_self_closing(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证自闭合标签"""
+        for element in soup.find_all(True):
+            if not isinstance(element, Tag):
+                continue
+            tag_name = element.name
+            # 检查空标签是否自闭合
+            if self.rule_engine.is_self_closing_tag(tag_name):
+                # 检查是否有内容
+                if element.contents and not all(
+                    isinstance(c, NavigableString) and not str(c).strip()
+                    for c in element.contents
+                ):
+                    result.add_warning(
+                        code="NON_EMPTY_SELF_CLOSING_TAG",
+                        message=f"标签 <{tag_name}> 应该是自闭合的，但包含内容",
+                        details={"tag": tag_name},
+                    )
+    def _validate_style_tags(
+        self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
+    ):
+        """验证style标签（检测并警告）"""
+        style_tags = soup.find_all("style")
+        if style_tags:
+            result.add_warning(
+                code="STYLE_TAG_DETECTED",
+                message=f"检测到 <style> 标签，其中的 CSS 规则不会被转换。请使用内联 style 属性代替。",
+                details={
+                    "count": len(style_tags),
+                    "note": '例如：将 <style>h1 { font-size: 18pt; }</style> 改为 <h1 style="font-size: 18pt;">标题</h1>',
+                },
+            )
+    def _parse_style_string(self, style_str: str) -> Dict[str, str]:
+        """解析style字符串为字典"""
+        styles = {}
+        if not style_str:
+            return styles
+        for item in style_str.split(";"):
+            item = item.strip()
+            if not item or ":" not in item:
+                continue
+            key, value = item.split(":", 1)
+            styles[key.strip()] = value.strip()
+        return styles
+    def get_validation_report(self, result: ValidationResult) -> str:
+        """生成验证报告"""
+        report = []
+        report.append("=== HTML 验证报告 ===\n")
+        # 验证结果
+        status = "✅ 通过" if result.is_valid else "❌ 失败"
+        report.append(f"验证状态: {status}\n")
+        # 统计信息
+        report.append("📊 统计信息:")
+        report.append(f"  - 错误数量: {len(result.errors)}")
+        report.append(f"  - 警告数量: {len(result.warnings)}")
+        report.append("")
+        # 错误
+        if result.errors:
+            report.append("❌ 错误:")
+            for i, error in enumerate(result.errors, 1):
+                report.append(f"  {i}. [{error['code']}] {error['message']}")
+                if error.get("details"):
+                    report.append(f"     详情: {error['details']}")
+            report.append("")
+        # 警告
+        if result.warnings:
+            report.append("⚠️  警告:")
+            for i, warning in enumerate(result.warnings, 1):
+                report.append(f"  {i}. [{warning['code']}] {warning['message']}")
+                if warning.get("details"):
+                    report.append(f"     详情: {warning['details']}")
+            report.append("")
+        if not result.errors and not result.warnings:
+            report.append("🎉 完美！没有发现任何问题。")
+        return "\n".join(report)
+# 全局实例
+strict_validator = StrictHTMLValidator()

package/python/sample/example.html CHANGED Viewed

@@ -2,21 +2,7 @@
 <html lang="zh-CN">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>MCP复杂格式测试</title>
-    <style>
-        body {
-            font-family: '微软雅黑';
-            font-size: 12pt;
-            line-height: 1.8;
-            padding: 20px;
-            max-width: 800px;
-            margin: 0 auto;
-        }
-        h1 { font-family: '微软雅黑'; font-size: 18pt; text-align: center; color: #333; }
-        h2 { font-family: '微软雅黑'; font-size: 16pt; color: #4a3f6b; border-bottom: 2px solid #667eea; padding-bottom: 10px; }
-        h3 { font-family: '微软雅黑'; font-size: 14pt; color: #5b4e8c; }
-    </style>
 </head>
 <body>
     <h1>MCP复杂格式测试文档</h1>