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

@birthday8/doc-mcp 1.0.3 → 1.0.5

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

package/README.md +59 -19
package/package.json +1 -1
package/python/html_rules.py +82 -0
package/python/html_validator_strict.py +176 -174
package/python/sample/example.html +0 -14
package/python/sample/html_schema.py +76 -7
package/python/server.py +1 -1

package/README.md CHANGED Viewed

@@ -12,7 +12,6 @@ Doc Creator MCP Server - Generate Word documents from HTML with rich formatting
 - ✅ Tables with styles
 - ✅ Info/Warning/Success boxes
 - ✅ Code blocks
-- ✅ Blockquotes
 - ✅ Multi-column layout
 - ✅ Page breaks
@@ -66,6 +65,18 @@ Generate a Word document from HTML content.
 ### 3. get_html_constraints
 Get HTML format constraints example with all supported formats.
+### 4. get_html_schema
+Get structured HTML format constraints as JSON.
+### 5. validate_html
+Validate HTML content against format constraints.
+```json
+{
+  "html_content": "<h1>Title</h1><p>Content...</p>"
+}
+```
 ## HTML Conventions
 ### Basic Structure
@@ -75,12 +86,9 @@ Get HTML format constraints example with all supported formats.
 <head>
     <meta charset="UTF-8">
     <title>Document Title</title>
-    <style>
-        /* CSS styles */
-    </style>
 </head>
 <body>
-    <h1>Title</h1>
+    <h1 style="font-family: 黑体; font-size: 18pt; text-align: center;">Title</h1>
     <p>Content with <strong>bold</strong> and <em>italic</em>.</p>
 </body>
 </html>
@@ -92,8 +100,8 @@ Get HTML format constraints example with all supported formats.
 <em>Italic</em>
 <u>Underline</u>
 <s>Strikethrough</s>
-<span class="red">Red text</span>
-<span class="highlight">Highlighted</span>
+<span style="color: #FF0000;">Red text</span>
+<span style="background-color: #FFFF00;">Highlighted</span>
 ```
 ### Paragraph Indentation
@@ -110,17 +118,13 @@ Get HTML format constraints example with all supported formats.
 ### Tables
 ```html
-<table style="width: 100%; border-collapse: collapse;">
-    <thead>
-        <tr>
-            <th style="border: 1px solid #ddd; padding: 12px;">Header</th>
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td style="border: 1px solid #ddd; padding: 12px;">Cell</td>
-        </tr>
-    </tbody>
+<table>
+    <tr>
+        <th style="background-color: #E3F2FD;">Header</th>
+    </tr>
+    <tr>
+        <td>Cell</td>
+    </tr>
 </table>
 ```
@@ -130,8 +134,44 @@ Get HTML format constraints example with all supported formats.
     <p>Column 1 content...</p>
     <p>Column 2 content...</p>
 </div>
+<!-- 必须恢复单栏 -->
+<div class="columns" data-cols="1"></div>
+```
+## Important Notes
+### Style Usage
+- **Inline styles only**: Use `style="..."` attributes on elements
+- **No `<style>` tags**: CSS in `<style>` tags is not supported
+- **Supported styles**: color, background-color, font-family, font-size, text-align, line-height, margin-top, margin-bottom
+- **Color format**: Must use hex format `#RRGGBB` (e.g., `#FF0000`), NOT `red`, `rgb(255,0,0)`, etc.
+- **Font size format**: Must use `pt` units (e.g., `14pt`), NOT `px`, `em`, `rem`
+- **Margin format**: Must use `pt` units (e.g., `10pt`), NOT `px`, `em`, `rem`
+- **Line height format**: Must be numeric (e.g., `1.5`, `1.8`, `2.0`)
+### Class Names
+**Only 7 class names are supported**:
+- `center` - Center aligned paragraph
+- `right` - Right aligned paragraph
+- `left` - Left aligned paragraph
+- `info` - Info message box
+- `warning` - Warning message box
+- `success` - Success message box
+- `columns` - Multi-column layout
+All other styles must use inline `style` attributes.
+### Example with inline styles
+```html
+<h1 style="font-family: 黑体; font-size: 18pt; text-align: center;">Title</h1>
+<p style="color: #FF0000;">Red text</p>
+<span style="background-color: #FFFF00;">Highlighted</span>
+<!-- 不支持的类名示例 -->
+<!-- ❌ <span class="abstract-title">摘要</span> -->
+<!-- ✅ <span style="font-family: 黑体; font-size: 12pt; font-weight: bold;">摘要</span> -->
 ```
 ## License
-MIT
+MIT

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@birthday8/doc-mcp",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Doc Creator MCP Server - Generate Word documents from HTML",
   "main": "index.js",
   "bin": {

package/python/html_rules.py CHANGED Viewed

@@ -339,6 +339,63 @@ class RuleEngine:
             description="元数据内容",
         )
+        # 通用属性
+        self.attr_rules["class"] = AttributeRule(
+            attr_name="class",
+            allowed=True,
+            applicable_tags={
+                "p",
+                "div",
+                "span",
+                "table",
+                "td",
+                "th",
+                "ul",
+                "ol",
+                "li",
+                "h1",
+                "h2",
+                "h3",
+                "h4",
+                "h5",
+                "h6",
+            },
+            description="CSS类名",
+        )
+        self.attr_rules["style"] = AttributeRule(
+            attr_name="style",
+            allowed=True,
+            applicable_tags={
+                "h1",
+                "h2",
+                "h3",
+                "h4",
+                "h5",
+                "h6",
+                "p",
+                "div",
+                "span",
+                "strong",
+                "em",
+                "u",
+                "s",
+                "sup",
+                "sub",
+                "code",
+                "table",
+                "tr",
+                "td",
+                "th",
+                "ul",
+                "ol",
+                "li",
+                "blockquote",
+                "pre",
+            },
+            description="内联样式",
+        )
     def _init_style_rules(self):
         """初始化样式规则"""
@@ -497,6 +554,31 @@ class RuleEngine:
             return False
         return rule.is_applicable_to(tag_name)
+    def is_nesting_allowed(self, parent_tag: str, child_tag: str) -> bool:
+        """检查嵌套是否允许"""
+        parent_rule = self.get_tag_rule(parent_tag)
+        child_rule = self.get_tag_rule(child_tag)
+        if not parent_rule or not child_rule:
+            return False
+        # 检查父标签是否允许包含子标签
+        if not parent_rule.can_contain(child_tag):
+            return False
+        # 检查子标签是否可以是父标签的子元素
+        if not child_rule.can_be_child_of(parent_tag):
+            return False
+        return True
+    def is_self_closing_tag(self, tag_name: str) -> bool:
+        """检查标签是否是自闭合标签"""
+        rule = self.get_tag_rule(tag_name)
+        if not rule:
+            return False
+        return rule.must_be_self_closing
     def get_disallowed_tags(self) -> List[Dict[str, str]]:
         """获取所有不允许的标签（用于文档说明）"""
         return [

package/python/html_validator_strict.py CHANGED Viewed

@@ -11,6 +11,17 @@ 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()
@@ -39,6 +50,9 @@ class StrictHTMLValidator:
             # 检查属性
             self._validate_attributes(soup, result, strict_mode)
+            # 检查类名
+            self._validate_classes(soup, result, strict_mode)
             # 检查样式
             self._validate_styles(soup, result, strict_mode)
@@ -48,14 +62,14 @@ class StrictHTMLValidator:
             # 检查自闭合标签
             self._validate_self_closing(soup, result, strict_mode)
-            # 收集统计信息
-            self._collect_stats(soup, result)
+            # 检查style标签
+            self._validate_style_tags(soup, result, strict_mode)
         except Exception as e:
             result.add_error(
-                code="PARSE_ERROR",
+                code="PARSING_ERROR",
                 message=f"HTML解析错误: {str(e)}",
-                details={"error": str(e)},
+                details={"exception": str(e)},
             )
         return result
@@ -154,85 +168,142 @@ class StrictHTMLValidator:
             tag_name = element.name
-            for attr_name, attr_value in element.attrs.items():
-                # 跳过特殊属性
-                if attr_name in ["class", "style"]:
-                    continue
+            # 检查属性是否允许
+            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,
-                            "attr": attr_name,
+                            "attribute": attr_name,
                             "value": str(attr_value)[:100],
-                            "allowed_attrs_for_tag": self._get_allowed_attrs_for_tag(
-                                tag_name
-                            ),
                         },
                     )
                     if strict_mode:
                         continue
-                # 验证属性值
-                attr_rule = self.rule_engine.get_attribute_rule(attr_name)
-                if attr_rule and attr_rule.validator and attr_value:
-                    if not attr_rule.validator(str(attr_value)):
-                        result.add_error(
-                            code="INVALID_ATTR_VALUE",
-                            message=f"标签 <{tag_name}> 的属性 '{attr_name}' 值 '{attr_value}' 无效",
-                            details={
-                                "tag": tag_name,
-                                "attr": attr_name,
-                                "value": str(attr_value),
-                            },
-                        )
+    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(style=True):
+        for element in soup.find_all(True):
             if not isinstance(element, Tag):
                 continue
-            tag_name = element.name
-            style_str = element.get("style", "")
-            styles = self._parse_style(style_str)
+            style_attr = element.get("style")
+            if not style_attr:
+                continue
-            for style_name, style_value in styles.items():
-                # 检查样式是否允许
-                if not self.rule_engine.is_style_allowed(style_name, tag_name):
+            # 解析样式
+            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"标签 <{tag_name}> 的样式 '{style_name}' 不在允许列表中",
+                        message=f"样式属性 '{prop_name}' 不在允许列表中",
                         details={
-                            "tag": tag_name,
-                            "style": style_name,
-                            "value": style_value,
-                            "allowed_styles_for_tag": self._get_allowed_styles_for_tag(
-                                tag_name
-                            ),
+                            "style": prop_name,
+                            "value": prop_value,
+                            "element": element.name,
                         },
                     )
                     if strict_mode:
                         continue
-                # 验证样式值
-                style_rule = self.rule_engine.get_style_rule(style_name)
-                if style_rule and style_value:
-                    is_valid, error_msg = style_rule.validate_value(style_value)
-                    if not is_valid:
+                # 验证颜色格式
+                if prop_name in ["color", "background-color"]:
+                    if not self.rule_engine.is_valid_color(prop_value):
                         result.add_error(
-                            code="INVALID_STYLE_VALUE",
-                            message=f"标签 <{tag_name}> 的样式 '{style_name}' 值 '{style_value}' 无效: {error_msg}",
+                            code="INVALID_COLOR_FORMAT",
+                            message="颜色格式错误，必须使用十六进制格式 #RRGGBB",
                             details={
-                                "tag": tag_name,
-                                "style": style_name,
-                                "value": style_value,
-                                "error": error_msg,
+                                "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",
                             },
                         )
@@ -240,53 +311,27 @@ class StrictHTMLValidator:
         self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
     ):
         """验证嵌套规则"""
-        for element in soup.find_all(True):
-            if not isinstance(element, Tag):
+        for parent in soup.find_all(True):
+            if not isinstance(parent, Tag):
                 continue
-            tag_name = element.name
-            parent = element.parent
-            if parent and isinstance(parent, Tag):
-                parent_name = parent.name
-                # 检查是否可以是父元素的子元素
-                tag_rule = self.rule_engine.get_tag_rule(tag_name)
-                parent_rule = self.rule_engine.get_tag_rule(parent_name)
+            for child in parent.find_all(True, recursive=False):
+                if not isinstance(child, Tag):
+                    continue
-                if tag_rule and not tag_rule.can_be_child_of(parent_name):
+                if not self.rule_engine.is_nesting_allowed(parent.name, child.name):
                     result.add_error(
                         code="INVALID_NESTING",
-                        message=f"标签 <{tag_name}> 不能作为 <{parent_name}> 的子元素",
+                        message=f"标签 <{child.name}> 不能嵌套在 <{parent.name}> 中",
                         details={
-                            "child_tag": tag_name,
-                            "parent_tag": parent_name,
-                            "allowed_parents": (
-                                list(tag_rule.allowed_parents)
-                                if tag_rule.allowed_parents
-                                else ["任意"]
-                            ),
+                            "parent": parent.name,
+                            "child": child.name,
+                            "context": str(parent)[:100],
                         },
                     )
                     if strict_mode:
                         continue
-                # 检查父元素是否可以包含此元素
-                if parent_rule and not parent_rule.can_contain(tag_name):
-                    result.add_error(
-                        code="INVALID_CONTAINMENT",
-                        message=f"标签 <{parent_name}> 不能包含 <{tag_name}>",
-                        details={
-                            "parent_tag": parent_name,
-                            "child_tag": tag_name,
-                            "allowed_children": (
-                                list(parent_rule.allowed_children)
-                                if parent_rule.allowed_children
-                                else ["任意"]
-                            ),
-                        },
-                    )
     def _validate_self_closing(
         self, soup: BeautifulSoup, result: ValidationResult, strict_mode: bool
     ):
@@ -296,64 +341,51 @@ class StrictHTMLValidator:
                 continue
             tag_name = element.name
-            tag_rule = self.rule_engine.get_tag_rule(tag_name)
-            if tag_rule and tag_rule.must_be_self_closing:
+            # 检查空标签是否自闭合
+            if self.rule_engine.is_self_closing_tag(tag_name):
                 # 检查是否有内容
                 if element.contents and not all(
-                    isinstance(c, NavigableString) and not c.strip()
+                    isinstance(c, NavigableString) and not str(c).strip()
                     for c in element.contents
                 ):
                     result.add_warning(
-                        code="SELF_CLOSING_WARNING",
-                        message=f"标签 <{tag_name}> 应该是自闭合标签，但包含内容",
-                        details={"tag": tag_name, "content": str(element)[:100]},
+                        code="NON_EMPTY_SELF_CLOSING_TAG",
+                        message=f"标签 <{tag_name}> 应该是自闭合的，但包含内容",
+                        details={"tag": tag_name},
                     )
-    def _collect_stats(self, soup: BeautifulSoup, result: ValidationResult):
-        """收集统计信息"""
-        stats = {}
+    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>',
+                },
+            )
-        # 标签统计
-        tag_counts = {}
-        for element in soup.find_all(True):
-            if isinstance(element, Tag):
-                tag_counts[element.name] = tag_counts.get(element.name, 0) + 1
+    def _parse_style_string(self, style_str: str) -> Dict[str, str]:
+        """解析style字符串为字典"""
+        styles = {}
+        if not style_str:
+            return styles
-        stats["tag_counts"] = tag_counts
-        stats["total_tags"] = sum(tag_counts.values())
-        stats["text_length"] = len(soup.get_text())
-        stats["total_errors"] = len(result.errors)
-        stats["total_warnings"] = len(result.warnings)
+        for item in style_str.split(";"):
+            item = item.strip()
+            if not item or ":" not in item:
+                continue
-        # 添加到结果中
-        result.details = stats
+            key, value = item.split(":", 1)
+            styles[key.strip()] = value.strip()
-    def _parse_style(self, style_str: str) -> Dict[str, str]:
-        """解析样式字符串"""
-        styles = {}
-        for item in style_str.split(";"):
-            if ":" in item:
-                key, value = item.split(":", 1)
-                styles[key.strip()] = value.strip()
         return styles
-    def _get_allowed_attrs_for_tag(self, tag_name: str) -> List[str]:
-        """获取标签允许的属性列表"""
-        allowed = []
-        for attr_name, attr_rule in self.rule_engine.attr_rules.items():
-            if attr_rule.allowed and attr_rule.is_applicable_to(tag_name):
-                allowed.append(attr_name)
-        return allowed
-    def _get_allowed_styles_for_tag(self, tag_name: str) -> List[str]:
-        """获取标签允许的样式列表"""
-        allowed = []
-        for style_name, style_rule in self.rule_engine.style_rules.items():
-            if style_rule.allowed and style_rule.is_applicable_to(tag_name):
-                allowed.append(style_name)
-        return allowed
     def get_validation_report(self, result: ValidationResult) -> str:
         """生成验证报告"""
         report = []
@@ -362,33 +394,30 @@ class StrictHTMLValidator:
         # 验证结果
         status = "✅ 通过" if result.is_valid else "❌ 失败"
-        report.append(f"验证状态: {status}")
-        report.append(f"错误数: {len(result.errors)}")
-        report.append(f"警告数: {len(result.warnings)}\n")
+        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"\n{i}. [{error['code']}] {error['message']}")
+                report.append(f"  {i}. [{error['code']}] {error['message']}")
                 if error.get("details"):
-                    report.append(f"   详情: {error['details']}")
+                    report.append(f"     详情: {error['details']}")
             report.append("")
         # 警告
         if result.warnings:
             report.append("⚠️  警告:")
             for i, warning in enumerate(result.warnings, 1):
-                report.append(f"\n{i}. [{warning['code']}] {warning['message']}")
+                report.append(f"  {i}. [{warning['code']}] {warning['message']}")
                 if warning.get("details"):
-                    report.append(f"   详情: {warning['details']}")
-            report.append("")
-        # 统计信息
-        if hasattr(result, "details") and result.details:
-            report.append("📊 统计信息:")
-            for key, value in result.details.items():
-                report.append(f"  - {key}: {value}")
+                    report.append(f"     详情: {warning['details']}")
             report.append("")
         if not result.errors and not result.warnings:
@@ -397,32 +426,5 @@ class StrictHTMLValidator:
         return "\n".join(report)
-class ValidationError(Exception):
-    """验证错误异常"""
-    def __init__(self, result: ValidationResult):
-        self.result = result
-        message = (
-            f"HTML验证失败: {len(result.errors)} 个错误, {len(result.warnings)} 个警告"
-        )
-        super().__init__(message)
-    def to_dict(self) -> Dict[str, Any]:
-        """转换为字典"""
-        return self.result.to_json()
-# 延迟创建全局实例
-_strict_validator_instance = None
-def get_strict_validator():
-    """获取严格验证器单例"""
-    global _strict_validator_instance
-    if _strict_validator_instance is None:
-        _strict_validator_instance = StrictHTMLValidator()
-    return _strict_validator_instance
-# 向后兼容的全局实例
-strict_validator = get_strict_validator()
+# 全局实例
+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>

package/python/sample/html_schema.py CHANGED Viewed

@@ -145,6 +145,44 @@ HTML_SCHEMA = {
         }
     },
+    "supportedClasses": [
+        {
+            "name": "center",
+            "description": "居中对齐段落",
+            "note": "用于<p class=\"center\">"
+        },
+        {
+            "name": "right",
+            "description": "右对齐段落",
+            "note": "用于<p class=\"right\">"
+        },
+        {
+            "name": "left",
+            "description": "左对齐段落",
+            "note": "用于<p class=\"left\">"
+        },
+        {
+            "name": "info",
+            "description": "信息提示框",
+            "note": "用于<div class=\"info\">"
+        },
+        {
+            "name": "warning",
+            "description": "警告提示框",
+            "note": "用于<div class=\"warning\">"
+        },
+        {
+            "name": "success",
+            "description": "成功提示框",
+            "note": "用于<div class=\"success\">"
+        },
+        {
+            "name": "columns",
+            "description": "多栏布局",
+            "note": "用于<div class=\"columns\" data-cols=\"2\">"
+        }
+    ],
     "colorFormatRules": {
         "required": "hex",
         "pattern": "#[0-9A-Fa-f]{6}",
@@ -237,6 +275,30 @@ HTML_SCHEMA = {
             "example": "<span style=\"color: rgb(255,0,0);\">红色</span>",
             "correct": "<span style=\"color: #FF0000;\">红色</span>",
             "note": "不支持rgb()和rgba()格式，必须使用十六进制"
+        },
+        {
+            "error": "使用style标签",
+            "example": "<style>h1 { font-size: 18pt; }</style>",
+            "correct": "<h1 style=\"font-size: 18pt;\">标题</h1>",
+            "note": "不支持<style>标签中的CSS规则，只支持内联style属性"
+        },
+        {
+            "error": "不支持的类名",
+            "example": "<span class=\"abstract-title\">摘要</span>",
+            "correct": "<span style=\"font-family: 黑体; font-size: 12pt; font-weight: bold;\">摘要</span>",
+            "note": "只支持：center, right, left, info, warning, success, columns"
+        },
+        {
+            "error": "字号格式错误",
+            "example": "<span style=\"font-size: 14px;\">14号字</span>",
+            "correct": "<span style=\"font-size: 14pt;\">14号字</span>",
+            "note": "字号单位必须是pt（磅），不支持px、em、rem等单位"
+        },
+        {
+            "error": "边距格式错误",
+            "example": "<p style=\"margin-bottom: 10px;\">段落</p>",
+            "correct": "<p style=\"margin-bottom: 10pt;\">段落</p>",
+            "note": "边距单位必须是pt（磅），不支持px、em、rem等单位"
         }
     ],
@@ -252,18 +314,25 @@ HTML_SCHEMA = {
         "表格单元格使用 th（表头）和 td（数据）区分",
         "行内元素（strong、em、u、s、sup、sub、code、span）可以嵌套在块级元素（p、div）内",
         "块级元素（p、div、table、ul、ol）不能嵌套在行内元素内",
-        "行距可以是数字或小数（如 1.5、1.8、2.0）"
+        "行距可以是数字或小数（如 1.5、1.8、2.0）",
+        "不要使用<style>标签中的CSS，只使用内联style属性（如 style=\"font-size: 14pt;\"）",
+        "只支持特定类名：center, right, left, info, warning, success, columns，其他样式请用内联style"
     ],
     "validationWorkflow": [
         "1. 检查HTML基本结构（DOCTYPE, html, head, body）",
         "2. 验证所有标签是否在允许列表中",
         "3. 检查所有属性是否被支持",
-        "4. 验证所有样式是否符合规范（特别是颜色格式）",
-        "5. 检查颜色格式是否为十六进制 #RRGGBB",
-        "6. 验证标签嵌套是否正确",
-        "7. 确认自闭合标签格式正确",
-        "8. 检查多栏布局是否恢复单栏"
+        "4. 验证类名是否在支持列表中（只支持：center, right, left, info, warning, success, columns）",
+        "5. 验证所有样式是否符合规范（特别是颜色格式）",
+        "6. 检查颜色格式是否为十六进制 #RRGGBB",
+        "7. 检查字号格式是否为pt单位",
+        "8. 检查行距格式是否为数字或小数",
+        "9. 检查边距格式是否为pt单位",
+        "10. 验证标签嵌套是否正确",
+        "11. 确认自闭合标签格式正确",
+        "12. 检查多栏布局是否恢复单栏",
+        "13. 检查是否使用了<style>标签（警告）"
     ]
 }
@@ -280,4 +349,4 @@ def get_schema_json():
 if __name__ == "__main__":
-    print(get_schema_json())
+    print(get_schema_json())

package/python/server.py CHANGED Viewed

@@ -16,7 +16,7 @@ from mcp.types import TextContent, Tool
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from docx_converter import convert_html_to_docx as docx_convert
 from html_validator import validator, template_generator
-from html_validator_strict import StrictHTMLValidator, ValidationError, strict_validator
+from html_validator_strict import StrictHTMLValidator, strict_validator
 from html_fixer import HTMLFixer
 # Create MCP server