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

@birthday8/doc-mcp 1.0.2 → 1.0.3

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 (11) hide show

package/README.md +2 -2
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 +570 -0
package/python/html_validator.py +59 -274
package/python/html_validator_strict.py +428 -0
package/python/sample/html_schema.py +283 -0
package/python/server.py +112 -75
package/python/test_strict_validation.py +118 -0

package/python/html_validator.py CHANGED Viewed

@@ -6,101 +6,19 @@ HTML格式验证器
 import re
 from bs4 import BeautifulSoup
 from typing import Dict, List, Tuple
+from html_validator_strict import StrictHTMLValidator, strict_validator
 class HTMLValidator:
-    """HTML格式验证器"""
+    """HTML格式验证器（兼容旧接口）"""
     def __init__(self):
-        # 支持的标签
-        self.supported_tags = {
-            "h1",
-            "h2",
-            "h3",
-            "h4",
-            "h5",
-            "h6",
-            "p",
-            "strong",
-            "em",
-            "u",
-            "s",
-            "sup",
-            "sub",
-            "code",
-            "span",
-            "div",
-            "ul",
-            "ol",
-            "li",
-            "table",
-            "tr",
-            "td",
-            "th",
-            "img",
-            "br",
-            "hr",
-            "math",
-            "latex",
-        }
-        # 支持的class
-        self.supported_classes = {
-            "center",
-            "right",
-            "dialogue",
-            "quote",
-            "highlight",
-            "red",
-            "blue",
-            "green",
-            "purple",
-            "info",
-            "warning",
-            "success",
-            "chapter",
-            "ending",
-            "page-break",
-            "columns",
-        }
-        # 支持的style属性
-        self.supported_styles = {
-            "color",
-            "background-color",
-            "font-family",
-            "font-size",
-            "font-weight",
-            "font-style",
-            "text-decoration",
-            "text-align",
-            "line-height",
-            "margin-top",
-            "margin-bottom",
-            "margin-left",
-            "margin-right",
-            "padding-top",
-            "padding-bottom",
-            "padding-left",
-            "padding-right",
-        }
-        # 支持的属性
-        self.supported_attrs = {
-            "src",
-            "alt",
-            "width",
-            "height",
-            "align",
-            "data-indent",
-            "data-cols",
-            "colspan",
-            "rowspan",
-        }
+        # 使用严格验证器
+        self.strict_validator = strict_validator
     def validate(self, html_content: str) -> Dict:
         """
-        验证HTML内容
+        验证HTML内容（兼容旧接口）
         Returns:
             Dict: {
@@ -110,158 +28,31 @@ class HTMLValidator:
                 'stats': Dict
             }
         """
-        result = {"valid": True, "errors": [], "warnings": [], "stats": {}}
-        try:
-            soup = BeautifulSoup(html_content, "html.parser")
-            # 检查基本结构
-            self._validate_structure(soup, result)
-            # 检查标签
-            self._validate_tags(soup, result)
-            # 检查属性
-            self._validate_attributes(soup, result)
-            # 检查样式
-            self._validate_styles(soup, result)
-            # 检查嵌套
-            self._validate_nesting(soup, result)
-            # 统计信息
-            self._collect_stats(soup, result)
-        except Exception as e:
-            result["valid"] = False
-            result["errors"].append(f"解析错误: {str(e)}")
-        return result
-    def _validate_structure(self, soup: BeautifulSoup, result: Dict):
-        """验证HTML基本结构"""
-        html_tag = soup.find("html")
-        if not html_tag:
-            result["errors"].append("缺少 <html> 标签")
-            result["valid"] = False
-        head_tag = soup.find("head")
-        if not head_tag:
-            result["warnings"].append("缺少 <head> 标签")
-        body_tag = soup.find("body")
-        if not body_tag:
-            result["errors"].append("缺少 <body> 标签")
-            result["valid"] = False
-        # 检查编码
-        charset = soup.find("meta", {"charset": True})
-        if not charset or charset.get("charset") != "UTF-8":
-            result["warnings"].append("建议使用 UTF-8 编码")
-        # 检查语言
-        if html_tag and html_tag.get("lang") != "zh-CN":
-            result["warnings"].append("建议设置 lang='zh-CN'")
-    def _validate_tags(self, soup: BeautifulSoup, result: Dict):
-        """验证标签"""
-        all_tags = set(tag.name for tag in soup.find_all(True))
-        unsupported = all_tags - self.supported_tags
-        if unsupported:
-            result["errors"].append(f"不支持的标签: {', '.join(unsupported)}")
-            result["valid"] = False
-        # 检查自闭合标签
-        self_closing = ["img", "br", "hr"]
-        for tag_name in self_closing:
-            for tag in soup.find_all(tag_name):
-                if str(tag).startswith(f"<{tag_name}>") and not str(tag).endswith("/>"):
-                    result["warnings"].append(f"标签 <{tag_name}> 建议自闭合")
-    def _validate_attributes(self, soup: BeautifulSoup, result: Dict):
-        """验证属性"""
-        for tag in soup.find_all(True):
-            for attr in tag.attrs:
-                if attr in ["class", "style"]:
-                    continue
-                if attr not in self.supported_attrs:
-                    result["warnings"].append(
-                        f"标签 <{tag.name}> 包含不支持的属性: {attr}"
-                    )
-    def _validate_styles(self, soup: BeautifulSoup, result: Dict):
-        """验证样式"""
-        for tag in soup.find_all(style=True):
-            style_str = tag.get("style", "")
-            styles = self._parse_style(style_str)
-            for style_name in styles:
-                if style_name not in self.supported_styles:
-                    result["warnings"].append(f"不支持的样式: {style_name}")
-                # 验证颜色格式
-                if style_name in ["color", "background-color"]:
-                    color = styles[style_name]
-                    if color and not color.startswith("#"):
-                        result["warnings"].append(f"颜色格式建议使用十六进制: {color}")
-                    elif color and len(color) != 7:
-                        result["errors"].append(f"颜色格式错误: {color}")
-                        result["valid"] = False
-    def _validate_nesting(self, soup: BeautifulSoup, result: Dict):
-        """验证嵌套"""
-        # 检查段落嵌套
-        for p in soup.find_all("p"):
-            children = p.find_all(["p", "h1", "h2", "h3", "h4", "h5", "h6", "div"])
-            if children:
-                result["errors"].append(f"<p> 标签不能包含块级元素")
-                result["valid"] = False
-        # 检查表格嵌套
-        for table in soup.find_all("table"):
-            direct_content = [
-                c.name for c in table.children if c.name and c.name not in ["tr"]
-            ]
-            if direct_content:
-                result["errors"].append(f"<table> 只能包含 <tr> 标签")
-                result["valid"] = False
-        # 检查列表嵌套
-        for li in soup.find_all("li"):
-            direct_lists = li.find_all(["ul", "ol"], recursive=False)
-            if len(direct_lists) > 1:
-                result["warnings"].append(f"<li> 建议只包含一个列表")
-    def _collect_stats(self, soup: BeautifulSoup, result: Dict):
-        """收集统计信息"""
-        stats = {}
-        # 标签统计
-        for tag in self.supported_tags:
-            count = len(soup.find_all(tag))
-            if count > 0:
-                stats[tag] = count
+        # 使用严格验证器
+        result = self.strict_validator.validate(html_content, strict_mode=False)
+        # 转换为旧格式
+        old_format = {
+            "valid": result.is_valid,
+            "errors": [e["message"] for e in result.errors],
+            "warnings": [w["message"] for w in result.warnings],
+            "stats": getattr(result, "details", {}),
+        }
-        # 特殊统计
-        stats["total_tags"] = len(soup.find_all(True))
-        stats["text_length"] = len(soup.get_text())
+        return old_format
-        result["stats"] = stats
+    def validate_strict(self, html_content: str) -> Dict:
+        """
+        严格验证HTML内容（返回完整结构化结果）
-    def _parse_style(self, style_str: str) -> Dict:
-        """解析样式字符串"""
-        styles = {}
-        for item in style_str.split(";"):
-            if ":" in item:
-                key, value = item.split(":", 1)
-                styles[key.strip()] = value.strip()
-        return styles
+        Returns:
+            Dict: 完整的结构化验证结果
+        """
+        result = self.strict_validator.validate(html_content, strict_mode=False)
+        return result.to_json()
     def get_validation_report(self, result: Dict) -> str:
-        """生成验证报告"""
+        """生成验证报告（兼容旧接口）"""
         report = []
         report.append("=== HTML 验证报告 ===\n")
@@ -271,27 +62,27 @@ class HTMLValidator:
         report.append(f"验证状态: {status}\n")
         # 统计信息
-        if result["stats"]:
+        if result.get("stats"):
             report.append("📊 统计信息:")
             for key, value in result["stats"].items():
                 report.append(f"  - {key}: {value}")
             report.append("")
         # 错误
-        if result["errors"]:
+        if result.get("errors"):
             report.append("❌ 错误:")
             for error in result["errors"]:
                 report.append(f"  - {error}")
             report.append("")
         # 警告
-        if result["warnings"]:
+        if result.get("warnings"):
             report.append("⚠️  警告:")
             for warning in result["warnings"]:
                 report.append(f"  - {warning}")
             report.append("")
-        if not result["errors"] and not result["warnings"]:
+        if not result.get("errors") and not result.get("warnings"):
             report.append("🎉 完美！没有发现任何问题。")
         return "\n".join(report)
@@ -301,42 +92,32 @@ class HTMLTemplateGenerator:
     """HTML模板生成器"""
     def __init__(self):
-        self.base_template = """<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{title}</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; }}
-        p {{ margin: 6pt 0; }}
-        .center {{ text-align: center; }}
-        .right {{ text-align: right; }}
-        .highlight {{ background-color: #FFFF00; }}
-        .red {{ color: #FF0000; }}
-        .blue {{ color: #0000FF; }}
-        .green {{ color: #008000; }}
-        .purple {{ color: #800080; }}
-    </style>
-</head>
-<body>
-{content}
-</body>
-</html>"""
-    def generate_template(self, title: str = "文档", content: str = "") -> str:
-        """生成HTML模板"""
-        return self.base_template.format(title=title, content=content)
+        # 加载schema
+        import os
+        import sys
+        schema_path = os.path.join(
+            os.path.dirname(__file__), "sample", "html_schema.py"
+        )
+        if os.path.exists(schema_path):
+            sys.path.insert(0, os.path.dirname(schema_path))
+            from html_schema import get_schema
+            self.schema = get_schema()
+        else:
+            self.schema = {}
+        # 加载example.html作为约束示例
+        example_path = os.path.join(os.path.dirname(__file__), "sample", "example.html")
+        if os.path.exists(example_path):
+            with open(example_path, "r", encoding="utf-8") as f:
+                self.constraint_example = f.read()
+        else:
+            self.constraint_example = ""
+    def get_constraint_example(self) -> str:
+        """获取HTML约束示例（从example.html加载）"""
+        return self.constraint_example
     def get_element_examples(self) -> Dict:
         """获取元素示例"""
@@ -383,6 +164,10 @@ class HTMLTemplateGenerator:
             "formula": "<math>E = mc^2</math>",
         }
+    def get_schema(self) -> dict:
+        """获取HTML格式约束schema"""
+        return self.schema
 # 全局实例
 validator = HTMLValidator()