fix: update check script

Author: hexqi

.agents/skills/tinyengine-dsl-generator/scripts/check_css.py

@@ -19,7 +19,25 @@
 import re
 import subprocess
 import sys
-from typing import Dict, List, Any
+from typing import Any, Dict, List
+
+
+def _extract_inner_dsl(dsl_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    解包外层包装结构，返回内层 DSL。
+
+    落盘的页面/区块文件是"外层包装 + 内层 DSL"：
+    - 页面 DSL 在 page_content 内
+    - 区块 DSL 在 content 内
+    仅当内层确实是含 componentName 的节点时才解包，避免误吞同名普通字段；
+    否则原样返回。
+    """
+    if isinstance(dsl_data, dict):
+        for key in ('page_content', 'content'):
+            inner = dsl_data.get(key)
+            if isinstance(inner, dict) and 'componentName' in inner:
+                return inner
+    return dsl_data
 
 
 class CSSChecker:
@@ -32,8 +50,9 @@ def __init__(self, dsl_data: Dict[str, Any]):
 
     def check(self) -> bool:
         """检查CSS语法"""
-        page_content = self.dsl.get('page_content', self.dsl)
-        css_string = page_content.get('css', '')
+        # 从外层包装(page_content/content)解包到内层 DSL 后再读取 css
+        inner = _extract_inner_dsl(self.dsl)
+        css_string = inner.get('css', '')
 
         if not css_string:
             self.warnings.append("No CSS field found")

.agents/skills/tinyengine-dsl-generator/scripts/check_event_bindings.py

@@ -8,7 +8,25 @@
 
 import json
 import sys
-from typing import Dict, List, Any
+from typing import Any, Dict, List
+
+
+def _extract_inner_dsl(dsl_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    解包外层包装结构，返回内层 DSL。
+
+    落盘的页面/区块文件是"外层包装 + 内层 DSL"：
+    - 页面 DSL 在 page_content 内
+    - 区块 DSL 在 content 内
+    仅当内层确实是含 componentName 的节点时才解包，避免误吞同名普通字段；
+    否则原样返回。
+    """
+    if isinstance(dsl_data, dict):
+        for key in ('page_content', 'content'):
+            inner = dsl_data.get(key)
+            if isinstance(inner, dict) and 'componentName' in inner:
+                return inner
+    return dsl_data
 
 
 class EventBindingChecker:
@@ -21,10 +39,10 @@ def __init__(self, dsl_data: Dict[str, Any]):
 
     def check(self) -> bool:
         """检查所有事件绑定"""
-        # 从page_content或直接检查
-        page_content = self.dsl.get('page_content', self.dsl)
+        # 从外层包装(page_content/content)解包到内层 DSL 后再检查
+        inner = _extract_inner_dsl(self.dsl)
 
-        self._check_node(page_content)
+        self._check_node(inner)
         return len(self.errors) == 0
 
     def _check_node(self, node: Any) -> None:

.agents/skills/tinyengine-dsl-generator/scripts/test_validate_dsl.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+TinyEngine DSL Validator 回归测试
+
+锁定 validate_dsl.py 对"外层包装 + 内层 DSL"结构（page_content / content）
+的识别与递归校验行为，防止文档推荐的一键校验命令对真实页面/区块文件误报失败。
+
+运行：
+    python3 test_validate_dsl.py
+"""
+
+import os
+import sys
+import unittest
+
+# 让本脚本能直接 import 同目录下的 validate_dsl 模块
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from validate_dsl import TinyEngineValidator  # noqa: E402
+
+REPO_ROOT = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), '..', '..', '..', '..')
+)
+PAGES_DIR = os.path.join(REPO_ROOT, 'mockServer', 'data', 'pages')
+BLOCKS_DIR = os.path.join(REPO_ROOT, 'mockServer', 'data', 'blocks')
+
+
+def _page_wrapper():
+    """外层包装页面（page_content 内才是真正的页面 DSL）"""
+    return {
+        "name": "Login",
+        "id": "5a3f8e1b9c4d2e7f",
+        "app": 1,
+        "route": "login",
+        "page_content": {
+            "componentName": "Page",
+            "fileName": "Login",
+            "props": {"className": "login-page"},
+            "css": ".login-page { padding: 40px; }",
+            "state": {},
+            "methods": {},
+            "lifeCycles": {},
+            "children": [],
+            "dataSource": {"list": []},
+        },
+        "isPage": True,
+        "group": "staticPages",
+        "occupier": None,
+        "isHome": False,
+    }
+
+
+def _block_wrapper():
+    """外层包装区块（content 内才是真正的区块 DSL）"""
+    return {
+        "id": "V85zd9sWEya25Kxh",
+        "label": "PortalBlock",
+        "framework": "Vue",
+        "path": "portal",
+        "content": {
+            "componentName": "Block",
+            "fileName": "PortalBlock",
+            "props": {},
+            "state": {},
+            "methods": {},
+            "children": [],
+            "schema": {"properties": [], "events": {}, "slots": {}},
+            "dataSource": {},
+        },
+        "occupier": None,
+        "is_published": True,
+    }
+
+
+def _raw_page_with_meta():
+    """原始（裸）页面 DSL，带 meta —— 协议要求的完整形态"""
+    return {
+        "componentName": "Page",
+        "fileName": "HomePage",
+        "meta": {
+            "id": 1,
+            "title": "首页",
+            "router": "home",
+            "creator": "admin",
+            "isHome": True,
+            "parentId": "0",
+            "rootElement": "div",
+        },
+        "children": [],
+    }
+
+
+class WrapperDetectionTests(unittest.TestCase):
+    """外层包装结构的识别与解包"""
+
+    def test_page_wrapper_detected_as_page_and_valid(self):
+        v = TinyEngineValidator(_page_wrapper())
+        self.assertEqual(v.schema_type, 'page')
+        self.assertTrue(v.validate(), msg=str(v.errors))
+        self.assertEqual(v.errors, [])
+
+    def test_block_wrapper_detected_as_block_and_valid(self):
+        v = TinyEngineValidator(_block_wrapper())
+        self.assertEqual(v.schema_type, 'block')
+        self.assertTrue(v.validate(), msg=str(v.errors))
+        self.assertEqual(v.errors, [])
+
+    def test_wrapper_does_not_require_meta(self):
+        """包装格式把 meta 上提到外层，内层 page_content 不应再强制要求 meta"""
+        v = TinyEngineValidator(_page_wrapper())
+        v.validate()
+        self.assertFalse(any('meta' in e.lower() for e in v.errors),
+                         f"不应因缺少 meta 报错: {v.errors}")
+
+    def test_unwrap_tracks_wrapper_flag(self):
+        wrapped, flag = TinyEngineValidator._unwrap(_page_wrapper())
+        self.assertTrue(flag)
+        self.assertEqual(wrapped['componentName'], 'Page')
+
+    def test_non_wrapper_returns_unchanged(self):
+        raw = _raw_page_with_meta()
+        inner, flag = TinyEngineValidator._unwrap(raw)
+        self.assertFalse(flag)
+        self.assertIs(inner, raw)
+
+
+class RawSchemaBackwardCompatTests(unittest.TestCase):
+    """原始（裸）DSL 的既有严格行为不应被破坏"""
+
+    def test_raw_page_with_meta_still_passes(self):
+        v = TinyEngineValidator(_raw_page_with_meta())
+        self.assertEqual(v.schema_type, 'page')
+        self.assertTrue(v.validate(), msg=str(v.errors))
+
+    def test_raw_page_without_meta_still_errors(self):
+        """裸页面仍必须带 meta（只有包装格式才豁免）"""
+        raw = {"componentName": "Page", "fileName": "HomePage", "children": []}
+        v = TinyEngineValidator(raw)
+        v.validate()
+        self.assertTrue(any('meta' in e.lower() for e in v.errors),
+                        "裸页面缺少 meta 应报错")
+
+    def test_unknown_schema_still_fails(self):
+        v = TinyEngineValidator({"foo": "bar"})
+        self.assertEqual(v.schema_type, 'unknown')
+        self.assertFalse(v.validate())
+
+
+class StringChildrenTests(unittest.TestCase):
+    """children 为字符串（文本子节点）是协议合法形态，不应误报"""
+
+    def test_string_children_not_flagged(self):
+        dsl = {
+            "componentName": "Page",
+            "fileName": "TextPage",
+            "meta": {
+                "id": 1, "title": "t", "router": "r", "creator": "a",
+                "isHome": False, "parentId": "0", "rootElement": "div",
+            },
+            "children": [
+                # a / h1 的 children 是字符串文本 —— 协议允许
+                {"componentName": "a", "id": "l1", "children": "链接文本"},
+                {"componentName": "h1", "id": "h1", "children": "标题文本"},
+            ],
+        }
+        v = TinyEngineValidator(dsl)
+        self.assertTrue(v.validate(), msg=str(v.errors))
+        self.assertFalse(
+            any('is not an object' in e for e in v.errors),
+            f"字符串子节点不应被判为非对象: {v.errors}",
+        )
+
+
+@unittest.skipUnless(
+    os.path.isdir(PAGES_DIR),
+    f"找不到真实页面目录: {PAGES_DIR}",
+)
+class RealFileTests(unittest.TestCase):
+    """对仓库内真实页面/区块文件跑端到端校验"""
+
+    def _validate_file(self, path):
+        import json
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        v = TinyEngineValidator(data)
+        return v
+
+    def test_real_login_page_passes(self):
+        path = os.path.join(PAGES_DIR, 'Login.json')
+        if not os.path.exists(path):
+            self.skipTest("Login.json 不存在")
+        v = self._validate_file(path)
+        self.assertEqual(v.schema_type, 'page')
+        self.assertTrue(v.validate(), msg=str(v.errors))
+
+    def test_real_block_passes(self):
+        path = os.path.join(BLOCKS_DIR, 'PortalBlock.json')
+        if not os.path.exists(path):
+            self.skipTest("PortalBlock.json 不存在")
+        v = self._validate_file(path)
+        self.assertEqual(v.schema_type, 'block')
+        self.assertTrue(v.validate(), msg=str(v.errors))
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

.agents/skills/tinyengine-dsl-generator/scripts/validate_dsl.py

@@ -24,7 +24,9 @@ def __init__(self, dsl_data: Dict[str, Any], schema_type: str = 'auto'):
             dsl_data: DSL数据
             schema_type: Schema类型 ('page', 'block', 'app', 'auto')
         """
-        self.dsl = dsl_data
+        self.original = dsl_data
+        # 落盘文件是"外层包装 + 内层 DSL"，这里解包到内层 DSL 再做协议校验。
+        self.dsl, self._from_wrapper = self._unwrap(dsl_data)
         self.schema_type = schema_type
         self.errors = []
         self.warnings = []
@@ -33,6 +35,24 @@ def __init__(self, dsl_data: Dict[str, Any], schema_type: str = 'auto'):
         if schema_type == 'auto':
             self.schema_type = self._detect_schema_type()
 
+    @staticmethod
+    def _unwrap(dsl_data: Any):
+        """
+        识别并解包外层包装结构。
+
+        TinyEngine 落盘的页面/区块文件是"外层包装 + 内层 DSL"结构：
+        - 页面：真正的页面 DSL 在 `page_content` 内
+        - 区块：真正的区块 DSL 在 `content` 内
+        返回 (内层DSL, 是否来自包装)。若不是包装结构，原样返回 (原数据, False)。
+        仅当内层确实是含 componentName 的节点时才解包，避免误吞同名普通字段。
+        """
+        if isinstance(dsl_data, dict):
+            for key in ('page_content', 'content'):
+                inner = dsl_data.get(key)
+                if isinstance(inner, dict) and 'componentName' in inner:
+                    return inner, True
+        return dsl_data, False
+
     def _detect_schema_type(self) -> str:
         """自动检测schema类型"""
         if 'componentName' in self.dsl:
@@ -59,7 +79,7 @@ def validate(self) -> bool:
 
     def _validate_page(self) -> bool:
         """验证页面Schema"""
-        required = ['componentName', 'fileName', 'meta']
+        required = ['componentName', 'fileName']
         for field in required:
             if field not in self.dsl:
                 self.errors.append(f"Missing required field: {field}")
@@ -68,8 +88,13 @@ def _validate_page(self) -> bool:
             self.errors.append(f"Page componentName must be 'Page', got: {self.dsl.get('componentName')}")
 
         # 验证meta
+        # 原始页面协议(IPageSchema)要求 meta；但外层包装格式把 meta 等元信息
+        # 上提到包装层(name/route/isHome/parentId/group...)，page_content 内不再含 meta。
+        # 因此仅在校验"裸"页面 DSL 时强制要求 meta；包装格式由外层字段承载。
         if 'meta' in self.dsl:
             self._validate_meta(self.dsl['meta'])
+        elif not self._from_wrapper:
+            self.errors.append("Missing required field: meta")
 
         # 验证children
         if 'children' in self.dsl and self.dsl['children']:
@@ -153,6 +178,10 @@ def _validate_block_schema(self, schema: Dict[str, Any]) -> None:
 
     def _validate_children(self, children: List[Any]) -> None:
         """验证子组件列表"""
+        # children 可以是字符串（文本子节点），按协议(IComponentSchema[] | string)
+        # 这是合法形态，无需逐项校验；递归调用遇到字符串时同样直接返回。
+        if isinstance(children, str):
+            return
         for i, child in enumerate(children):
             if not isinstance(child, dict):
                 self.errors.append(f"Child at index {i} is not an object")