OoderA2UI 分级Skills脚本实现：构建确定性 LLM 代码生成体系

from abc import ABC, abstractmethod
from typing import Optional, Dict, Any, List

class NlpBaseUIComponent(ABC):
    def __init__(self):
        self.component_type: Optional[str] = None
        self.initialized: bool = False
        self.properties: Dict[str, Any] = {}
        self.events: Dict[str, Any] = {}
        self.children: list = []
        self.parent: Optional['NlpBaseUIComponent'] = None
    
    @abstractmethod
    def initialize_from_natural_language(self, natural_language: str) -> None:
        pass
    
    @abstractmethod
    def initialize_from_config(self, config: Dict[str, Any]) -> None:
        pass

from typing import Optional, Dict, Any, List

class ModuleUIComponent(NlpBaseUIComponent):
    def __init__(self):
        super().__init__()
        self.method_api_bean: Optional[Any] = None
        self.ui_module: Optional[Any] = None
        self.value_map: Dict[str, Any] = {}

class CustomModuleUIComponent(ModuleUIComponent):
    def __init__(self, ui_module: Optional[Any] = None, 
                 method_api_bean: Optional[Any] = None, 
                 value_map: Optional[Dict[str, Any]] = None):
        super().__init__()
        self.bridge_class: Optional[Any] = None
        self.parent_class: Optional[Any] = None
        self.field_list: List[Any] = []
        self.data_url: Optional[str] = None
        
        if method_api_bean is not None:
            self.method_api_bean = method_api_bean
            self.ui_module = ui_module
            self.value_map = value_map if value_map is not None else {}
            self.data_url = method_api_bean.get_property("url")
            self.bridge_class = method_api_bean.get_property("viewClass")
            self.parent_class = method_api_bean.get_property("sourceClass")

from typing import Optional, Dict, Any

class GridProperties:
    def __init__(self):
        self.alias: Optional[str] = None
        self.page_size: int = 20
        self.sortable: bool = True
        self.filterable: bool = True

class NlpGridUIComponent(CustomModuleUIComponent):
    def __init__(self, method_config: Optional[Any] = None):
        super().__init__()
        self.properties: GridProperties = GridProperties()
        
        if method_config is not None:
            view_bean = method_config.get_property("view")
            self.init(view_bean)
    
    def init(self, view_bean: Any) -> None:
        self.properties = GridProperties()
        self.set_property("alias", view_bean.get_property("name"))
    
    def set_property(self, key: str, value: Any) -> None:
        if hasattr(self.properties, key):
            setattr(self.properties, key, value)
        self.properties[key] = value

from abc import ABC, abstractmethod
from typing import Optional, List, Any

class CustomFieldMeta:
    def __init__(self):
        self.fieldname: Optional[str] = None
        self.caption: Optional[str] = None
        self.type: Optional[str] = None
        self.editable: bool = False

class Event:
    def __init__(self):
        self.eventEnum: Optional[str] = None
        self.description: Optional[str] = None
        self.actions: List[Dict[str, Any]] = []

class MenuItem:
    def __init__(self):
        self.id: Optional[str] = None
        self.name: Optional[str] = None
        self.imageClass: Optional[str] = None

class CustomViewMeta(ABC):
    def __init__(self):
        self.name: Optional[str] = None
        self.caption: Optional[str] = None
        self.desc: Optional[str] = None
        self.module_view_type: Optional[str] = None
        self.all_fields: List[CustomFieldMeta] = []
        self.fields: List[CustomFieldMeta] = []
        self.events: List[Event] = []
        self.menus: List[MenuItem] = []
    
    @abstractmethod
    def create_field_config(self) -> CustomFieldMeta:
        pass
    
    @abstractmethod
    def create_ui_item(self) -> Any:
        pass
    
    @abstractmethod
    def create_ui_component(self) -> Any:
        pass

from enum import Enum
from typing import Optional, Dict, Any

class ScenarioType(Enum):
    CREATE_BASE_COMPONENT = "create_base_component"
    CREATE_MODULE_COMPONENT = "create_module_component"
    CREATE_GRID_COMPONENT = "create_grid_component"
    CREATE_VIEW_METADATA = "create_view_metadata"
    # 其他场景枚举...

class QuickPathFactory:
    @staticmethod
    def create_component(scenario: str, config: Optional[Dict[str, Any]] = None) -> Any:
        scenario_map = {
            ScenarioType.CREATE_BASE_COMPONENT.value: QuickPathFactory._create_base_component,
            ScenarioType.CREATE_MODULE_COMPONENT.value: QuickPathFactory._create_module_component,
            ScenarioType.CREATE_GRID_COMPONENT.value: QuickPathFactory._create_grid_component,
            ScenarioType.CREATE_VIEW_METADATA.value: QuickPathFactory._create_view_metadata,
            # ... 更多场景
        }
        
        create_func = scenario_map.get(scenario)
        if create_func is None:
            raise ValueError(f"Unknown scenario: {scenario}")
        
        return create_func(config)
    
    @staticmethod
    def _create_base_component(config: Optional[Dict[str, Any]] = None) -> Any:
        # 实现基础组件创建逻辑
        from foundation_layer import NlpBaseUIComponent
        return NlpBaseUIComponent()
    
    @staticmethod
    def _create_module_component(config: Optional[Dict[str, Any]] = None) -> Any:
        # 实现模块组件创建逻辑
        from module_layer import CustomModuleUIComponent
        return CustomModuleUIComponent()
    
    @staticmethod
    def _create_grid_component(config: Optional[Dict[str, Any]] = None) -> Any:
        # 实现网格组件创建逻辑
        from component_layer import NlpGridUIComponent
        return NlpGridUIComponent(config)
    
    @staticmethod
    def _create_view_metadata(config: Optional[Dict[str, Any]] = None) -> Any:
        # 实现视图元数据创建逻辑
        from metadata_layer import CustomViewMeta
        view_meta = CustomViewMeta()
        if config:
            view_meta.name = config.get("name")
            view_meta.caption = config.get("caption")
            view_meta.module_view_type = config.get("moduleViewType")
        return view_meta

from typing import Dict, Any

class ScenarioOptimizer:
    @staticmethod
    def optimize_for_scenario(scenario: str, config: Dict[str, Any]) -> Dict[str, Any]:
        optimized_config = config.copy()
        
        if scenario == ScenarioType.CREATE_GRID_COMPONENT.value:
            optimized_config = ScenarioOptimizer._optimize_grid_config(optimized_config)
        elif scenario == ScenarioType.CREATE_TREE_GRID_COMPONENT.value:
            optimized_config = ScenarioOptimizer._optimize_tree_grid_config(optimized_config)
        
        return optimized_config
    
    @staticmethod
    def _optimize_grid_config(config: Dict[str, Any]) -> Dict[str, Any]:
        # 网格组件自动添加默认分页大小（20）
        if "pageSize" not in config:
            config["pageSize"] = 20
        # 自动开启排序功能
        if "sortable" not in config:
            config["sortable"] = True
        # 自动开启筛选功能
        if "filterable" not in config:
            config["filterable"] = True
        return config
    
    @staticmethod
    def _optimize_tree_grid_config(config: Dict[str, Any]) -> Dict[str, Any]:
        # 树网格组件自动设置默认树字段（parentId）
        if "treeField" not in config:
            config["treeField"] = "parentId"
        # 继承网格组件的优化配置
        config = ScenarioOptimizer._optimize_grid_config(config)
        return config

from typing import List, Optional
from metadata_layer import CustomViewMeta, CustomFieldMeta

class MetadataValidator:
    @staticmethod
    def validate_view_metadata(view_meta: CustomViewMeta) -> List[str]:
        errors = []
        
        if view_meta.name is None or view_meta.name.strip() == "":
            errors.append("视图名称不能为空")
        
        if view_meta.caption is None or view_meta.caption.strip() == "":
            errors.append("视图标题不能为空")
        
        if view_meta.module_view_type is None or view_meta.module_view_type.strip() == "":
            errors.append("模块视图类型不能为空")
        
        if len(view_meta.fields) == 0:
            errors.append("字段列表不能为空")
        else:
            # 验证每个字段的合法性
            for field in view_meta.fields:
                if field.fieldname is None or field.fieldname.strip() == "":
                    errors.append("字段名称不能为空")
                if field.caption is None or field.caption.strip() == "":
                    errors.append(f"字段 {field.fieldname} 的标题不能为空")
        
        return errors

from typing import List
from metadata_layer import CustomViewMeta, CustomFieldMeta, Event

class CodeGenerator:
    @staticmethod
    def generate_view_code(view_meta: CustomViewMeta) -> str:
        field_code = CodeGenerator._generate_field_code(view_meta.fields)
        event_code = CodeGenerator._generate_event_code(view_meta.events)
        
        code = f"""
public class {view_meta.name} extends CustomModuleUIComponent {{
    
    public {view_meta.name}() {{
        super();
        this.initialize();
    }}
    
    private void initialize() {{
        this.caption = "{view_meta.caption}";
        this.moduleViewType = "{view_meta.module_view_type}";
        
        // 初始化字段
        {field_code}
        
        // 初始化事件
        {event_code}
    }}
}}
"""
        return code.strip()
    
    @staticmethod
    def _generate_field_code(fields: List[CustomFieldMeta]) -> str:
        field_lines = []
        for field in fields:
            field_line = f"this.addField(\"{field.fieldname}\", \"{field.caption}\", \"{field.type}\", {field.editable});"
            field_lines.append(field_line)
        return "\n        ".join(field_lines)
    
    @staticmethod
    def _generate_event_code(events: List[Event]) -> str:
        event_lines = []
        for event in events:
            event_line = f"this.addEvent(\"{event.eventEnum}\", \"{event.description}\");"
            event_lines.append(event_line)
        return "\n        ".join(event_lines)

from typing import List, Optional
from metadata_layer import CustomViewMeta
from dataclasses import dataclass

@dataclass
class CodeGenResult:
    phase: str
    success: bool
    message: str
    errors: List[str] = None
    warnings: List[str] = None
    generated_code: Optional[str] = None
    compiled_code: Optional[Any] = None

class ProgressiveCodeGen:
    def __init__(self):
        self.results: List[CodeGenResult] = []
    
    def execute_full_process(self, view_meta: CustomViewMeta) -> List[CodeGenResult]:
        self.results = []
        
        # 阶段 1：元数据准备
        result1 = self.execute_phase_1_metadata_preparation(view_meta)
        if not result1.success:
            return self.results
        
        # 阶段 2：代码生成
        result2 = self.execute_phase_2_code_generation(view_meta)
        if not result2.success:
            return self.results
        
        # 阶段 3：编译和绑定
        result3 = self.execute_phase_3_compilation_and_binding(result2.generated_code)
        if not result3.success:
            return self.results
        
        # 阶段 4：持久化和部署
        result4 = self.execute_phase_4_persistence_and_deployment(view_meta, result3.compiled_code)
        
        return self.results
    
    def execute_phase_1_metadata_preparation(self, view_meta: CustomViewMeta) -> CodeGenResult:
        try:
            errors = MetadataValidator.validate_view_metadata(view_meta)
            if errors:
                return CodeGenResult(
                    phase="元数据准备",
                    success=False,
                    message="元数据验证失败",
                    errors=errors
                )
            
            return CodeGenResult(
                phase="元数据准备",
                success=True,
                message="元数据验证通过",
                warnings=[]
            )
        except Exception as e:
            return CodeGenResult(
                phase="元数据准备",
                success=False,
                message=f"元数据处理异常：{str(e)}",
                errors=[str(e)]
            )
    
    def execute_phase_2_code_generation(self, view_meta: CustomViewMeta) -> CodeGenResult:
        try:
            generated_code = CodeGenerator.generate_view_code(view_meta)
            return CodeGenResult(
                phase="代码生成",
                success=True,
                message="代码生成成功",
                generated_code=generated_code
            )
        except Exception as e:
            return CodeGenResult(
                phase="代码生成",
                success=False,
                message=f"代码生成异常：{str(e)}",
                errors=[str(e)]
            )
    
    def execute_phase_3_compilation_and_binding(self, generated_code: str) -> CodeGenResult:
        try:
            # 模拟编译和绑定逻辑
            compiled_code = f"Compiled: {generated_code[:100]}..."
            return CodeGenResult(
                phase="编译和绑定",
                success=True,
                message="编译和绑定成功",
                compiled_code=compiled_code
            )
        except Exception as e:
            return CodeGenResult(
                phase="编译和绑定",
                success=False,
                message=f"编译和绑定异常：{str(e)}",
                errors=[str(e)]
            )
    
    def execute_phase_4_persistence_and_deployment(self, view_meta: CustomViewMeta, compiled_code: Any) -> CodeGenResult:
        try:
            # 模拟持久化和部署逻辑
            return CodeGenResult(
                phase="持久化和部署",
                success=True,
                message="持久化和部署成功"
            )
        except Exception as e:
            return CodeGenResult(
                phase="持久化和部署",
                success=False,
                message=f"持久化和部署异常：{str(e)}",
                errors=[str(e)]
            )

from typing import List, Dict, Any
from dataclasses import dataclass

@dataclass
class TermDefinition:
    term: str
    english: str
    category: str
    definition: str
    version: Optional[str] = None

@dataclass
class TermSeverity:
    INFO = "INFO"
    WARNING = "WARNING"
    ERROR = "ERROR"

@dataclass
class TermCheckResult:
    term: str
    category: str
    severity: str
    message: str
    suggestion: str
    line_number: int
    column_number: int

class TermChecker:
    def __init__(self):
        self.terms: Dict[str, TermDefinition] = {}
        self._initialize_core_terms()
        self._initialize_flow_terms()
        self._initialize_usage_terms()
    
    def _initialize_core_terms(self):
        # 初始化核心术语
        core_terms = [
            TermDefinition("基础层", "Foundation Layer", "核心术语", "NlpBaseUIComponent，所有NLP组件的抽象基类"),
            TermDefinition("模块层", "Module Layer", "核心术语", "ModuleUIComponent 和 CustomModuleUIComponent，管理模块生命周期"),
            # 其他核心术语...
        ]
        for term in core_terms:
            self.terms[term.term] = term
    
    def _initialize_flow_terms(self):
        # 初始化流程术语
        flow_terms = [
            TermDefinition("完整构建", "Full Build", "流程术语", "生成所有层次的代码并编译"),
            TermDefinition("增量构建", "Incremental Build", "流程术语", "只生成变更的部分并重新绑定"),
            # 其他流程术语...
        ]
        for term in flow_terms:
            self.terms[term.term] = term
    
    def _initialize_usage_terms(self):
        # 初始化使用规范术语
        usage_terms = [
            TermDefinition("术语一致性", "Term Consistency", "使用规范", "在整个项目中保持术语的一致性"),
            # 其他使用规范术语...
        ]
        for term in usage_terms:
            self.terms[term.term] = term
    
    def check_term_usage(self, text: str) -> List[TermCheckResult]:
        results = []
        lines = text.split('\n')
        
        for line_num, line in enumerate(lines, 1):
            for term, definition in self.terms.items():
                if term in line:
                    result = TermCheckResult(
                        term=term,
                        category=definition.category,
                        severity=TermSeverity.INFO,
                        message=f"发现术语: {term}",
                        suggestion=f"建议使用标准术语: {term} ({definition.english})",
                        line_number=line_num,
                        column_number=line.find(term) + 1
                    )
                    results.append(result)
        
        return results

from typing import List, Dict, Optional
from dataclasses import dataclass

class TermVersionManager:
    def __init__(self):
        self.versions: Dict[str, List[TermDefinition]] = {}
        self.current_version: str = "1.0"
    
    def add_term_version(self, term: str, definition: TermDefinition, version: str) -> None:
        if term not in self.versions:
            self.versions[term] = []
        
        definition.version = version
        self.versions[term].append(definition)
    
    def get_term_version(self, term: str, version: Optional[str] = None) -> Optional[TermDefinition]:
        if term not in self.versions:
            return None
        
        if version is None:
            return self.versions[term][-1]
        
        for definition in self.versions[term]:
            if definition.version == version:
                return definition
        
        return None
    
    def list_term_versions(self, term: str) -> List[TermDefinition]:
        return self.versions.get(term, [])

from typing import Dict, Any, List

class ScenarioType:
    CREATE_VIEW_METADATA = "create_view_metadata"

class QuickPathFactory:
    @staticmethod
    def create_component(scenario: str, config: Optional[Dict[str, Any]] = None) -> Any:
        if scenario == ScenarioType.CREATE_VIEW_METADATA:
            return QuickPathFactory._create_view_metadata(config)
        raise ValueError(f"Unknown scenario: {scenario}")
    
    @staticmethod
    def _create_view_metadata(config: Optional[Dict[str, Any]] = None) -> Any:
        class ViewMeta:
            def __init__(self, config: Dict[str, Any]):
                self.name = config.get("name")
                self.caption = config.get("caption")
                self.module_view_type = config.get("moduleViewType")
                self.fields = config.get("fields", [])
                self.events = config.get("events", [])
                self.menus = config.get("menus", [])
        
        return ViewMeta(config or {})

view_config = {
    "name": "UserTableView",
    "caption": "用户表格视图",
    "moduleViewType": "GRIDCONFIG",
    "fields": [
        {"fieldname": "id", "caption": "ID", "type": "input", "editable": False},
        {"fieldname": "name", "caption": "姓名", "type": "input", "editable": True},
        {"fieldname": "email", "caption": "邮箱", "type": "input", "editable": True},
        {"fieldname": "phone", "caption": "电话", "type": "input", "editable": True}
    ],
    "events": [
        {"eventEnum": "RELOAD", "description": "刷新数据", "actions": [{"target": "reloadAPI", "eventKey": "onclick"}]},
        {"eventEnum": "SAVE", "description": "保存数据", "actions": [{"target": "saveAPI", "eventKey": "onclick"}]}
    ],
    "menus": [
        {"id": "ADD", "name": "添加", "imageClass": "ri-add-line"},
        {"id": "EDIT", "name": "编辑", "imageClass": "ri-edit-line"},
        {"id": "DELETE", "name": "删除", "imageClass": "ri-delete-line"}
    ]
}

view_meta = QuickPathFactory.create_component(
    ScenarioType.CREATE_VIEW_METADATA,
    view_config
)

# 假设已导入 ProgressiveCodeGen 类
code_gen = ProgressiveCodeGen()
results = code_gen.execute_full_process(view_meta)

for i, result in enumerate(results, 1):
    print(f"阶段 {i}: {result.phase}")
    print(f"状态: {'成功' if result.success else '失败'}")
    print(f"消息: {result.message}")
    if result.errors:
        print(f"错误: {result.errors}")
    if result.warnings:
        print(f"警告: {result.warnings}")
    print("-" * 50)

try:
    # 创建视图元数据
    view_meta = QuickPathFactory.create_component(
        ScenarioType.CREATE_VIEW_METADATA,
        view_config
    )
    
    # 基础验证
    if not hasattr(view_meta, 'name') or view_meta.name is None:
        raise ValueError("视图名称不能为空")
    
    # 执行渐进式代码生成
    code_gen = ProgressiveCodeGen()
    results = code_gen.execute_full_process(view_meta)
    
    # 处理执行结果
    for result in results:
        if not result.success:
            print(f"阶段 {result.phase} 失败: {result.message}")
            if result.errors:
                print(f"错误详情: {', '.join(result.errors)}")
        
except ValueError as e:
    print(f"验证错误: {e}")
    print("建议：检查视图元数据配置，确保必填字段完整")
except Exception as e:
    print(f"未知错误: {e}")
    print("建议：联系技术支持，提供完整的错误日志")

{
  "name": "UserTableView",
  "caption": "用户表格视图",
  "moduleViewType": "GRIDCONFIG",
  "fields": [
    {"fieldname": "id", "caption": "ID", "type": "input", "editable": false},
    {"fieldname": "name", "caption": "姓名", "type": "input", "editable": true}
  ],
  "events": [
    {"eventEnum": "RELOAD", "description": "刷新数据"}
  ]
}

@CustomClass
public class UserBridge {
    @CustomMenuItem(name = "用户列表", imageClass = "ri-user-line")
    public UserTableView userListView() {
        return new UserTableView();
    }
}

// 框架自动生成的 BridgeCode
public class UserTableView extends CustomModuleUIComponent {
    public UserTableView() {
        super();
        this.initialize();
    }
    
    private void initialize() {
        // 框架自动生成的初始化代码
        // 包含字段、事件、菜单的初始化
        this.caption = "用户表格视图";
        this.moduleViewType = "GRIDCONFIG";
    }
}