feat: implement workflow and dispatch rule registries with system workflows and rules

- Added WorkflowRegistry to manage workflow registration and loading
- Created DispatchRuleRegistry to handle dynamic dispatch rule management
- Implemented system workflows for games, chat, and system commands
- Added dispatch rules for various interaction types (prefix, keyword, regex)
- Created new workflow factories for game and system workflows
- Introduced new blocks for dice rolling, gacha simulation, and help generation
- Enhanced main.py with container initialization and workflow/rule loading

Author: lss233

data/dispatch_rules/chat.yaml

@@ -0,0 +1,26 @@
+# 聊天相关的调度规则
+# 每个规则包含:
+# - type: 规则类型 (prefix/keyword/regex)
+# - workflow: 要执行的工作流 (格式: groupId:workflowId)
+# - 其他特定类型的参数
+
+# 前缀匹配规则示例
+- type: prefix
+  workflow: chat:normal
+  prefix: "/chat"
+  description: "普通聊天，使用默认参数"
+
+# 关键词匹配规则示例
+- type: keyword
+  workflow: chat:creative
+  keywords: 
+    - "创意"
+    - "发散"
+    - "brainstorm"
+  description: "创意聊天，使用更高的温度参数"
+
+# 正则匹配规则示例
+- type: regex
+  workflow: chat:roleplay
+  pattern: "^扮演(.+?)[:：]"
+  description: "角色扮演聊天，自动提取角色设定" 

data/dispatch_rules/game.yaml

@@ -0,0 +1,17 @@
+# 游戏相关的调度规则
+# 这些规则用于处理各种游戏互动
+
+# 骰子
+- type: regex
+  workflow: game:dice
+  pattern: "^[.。]roll\\s*(\\d+)?d(\\d+)"
+  description: "骰子游戏，支持 XdY 格式"
+
+# 抽卡
+- type: keyword
+  workflow: game:gacha
+  keywords:
+    - "抽卡"
+    - "十连"
+    - "单抽"
+  description: "抽卡模拟器" 

data/dispatch_rules/system.yaml

@@ -0,0 +1,26 @@
+# 系统相关的调度规则
+# 这些规则主要用于系统管理和控制
+
+# 帮助命令
+- type: prefix
+  workflow: system:help
+  prefix: "/help"
+  description: "显示帮助信息"
+
+# 系统状态
+- type: prefix
+  workflow: system:status
+  prefix: "/status"
+  description: "显示系统状态"
+
+# 管理员命令
+- type: regex
+  workflow: system:admin
+  pattern: "^/(ban|unban|kick|mute) \\S+"
+  description: "管理员命令，需要管理员权限"
+
+# 系统设置
+- type: prefix
+  workflow: system:settings
+  prefix: "/settings"
+  description: "修改系统设置" 

framework/workflow_dispatcher/dispatch_rule.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Type
+from typing import Type, Callable
 from framework.im.message import IMMessage
 from framework.ioc.container import DependencyContainer
 from framework.workflow_executor.workflow import Workflow
@@ -10,12 +10,12 @@ class DispatchRule(ABC):
     用于定义如何根据消息内容选择合适的工作流进行处理。
     """
 
-    def __init__(self, workflow_factory):
+    def __init__(self, workflow_factory: Callable[[DependencyContainer], Workflow]):
         """
         初始化调度规则。
         
         Args:
-            workflow_factory: 用于构造工作流的工厂对象
+            workflow_factory: 用于构造工作流的工厂函数
         """
         self.workflow_factory = workflow_factory
 
@@ -39,7 +39,7 @@ def get_workflow(self, container: DependencyContainer) -> Workflow:
         Returns:
             Workflow: 工作流实例
         """
-        return self.workflow_factory.create_workflow(container)
+        return self.workflow_factory(container)
 
     def __str__(self) -> str:
         return self.__class__.__name__
@@ -48,7 +48,7 @@ def __str__(self) -> str:
 class PrefixMatchRule(DispatchRule):
     """根据消息前缀匹配的规则"""
 
-    def __init__(self, prefix: str, workflow_factory):
+    def __init__(self, prefix: str, workflow_factory: Callable[[DependencyContainer], Workflow]):
         super().__init__(workflow_factory)
         self.prefix = prefix
 
@@ -62,7 +62,7 @@ def __str__(self) -> str:
 class KeywordMatchRule(DispatchRule):
     """根据关键词匹配的规则"""
 
-    def __init__(self, keywords: list[str], workflow_factory):
+    def __init__(self, keywords: list[str], workflow_factory: Callable[[DependencyContainer], Workflow]):
         super().__init__(workflow_factory)
         self.keywords = keywords
 
@@ -76,7 +76,7 @@ def __str__(self) -> str:
 class RegexMatchRule(DispatchRule):
     """根据正则表达式匹配的规则"""
 
-    def __init__(self, pattern: str, workflow_factory):
+    def __init__(self, pattern: str, workflow_factory: Callable[[DependencyContainer], Workflow]):
         super().__init__(workflow_factory)
         import re
         self.pattern = re.compile(pattern)
@@ -91,7 +91,7 @@ def __str__(self) -> str:
 class FallbackMatchRule(DispatchRule):
     """默认的兜底规则，总是匹配"""
 
-    def __init__(self, workflow_factory):
+    def __init__(self, workflow_factory: Callable[[DependencyContainer], Workflow]):
         super().__init__(workflow_factory)
 
     def match(self, message: IMMessage) -> bool:

framework/workflow_dispatcher/dispatch_rule_registry.py

@@ -0,0 +1,90 @@
+from typing import List
+from framework.workflow_dispatcher.dispatch_rule import DispatchRule, PrefixMatchRule, KeywordMatchRule, RegexMatchRule
+from framework.workflow_executor.workflow_registry import WorkflowRegistry
+from framework.ioc.container import DependencyContainer
+from framework.logger import get_logger
+import os
+from ruamel.yaml import YAML
+
+class DispatchRuleRegistry:
+    """调度规则注册表，管理调度规则的加载和注册"""
+    
+    def __init__(self, container: DependencyContainer):
+        self.container = container
+        self.workflow_registry = container.resolve(WorkflowRegistry)
+        self.rules: List[DispatchRule] = []
+        self.logger = get_logger("DispatchRuleRegistry")
+        
+
+    def register(self, rule: DispatchRule):
+        """注册一个调度规则"""
+        self.rules.append(rule)
+        self.logger.info(f"Registered dispatch rule: {rule}")
+        
+    def load_rules(self, container: DependencyContainer, rules_dir: str = "data/dispatch_rules"):
+        """从指定目录加载所有调度规则"""
+        if not os.path.exists(rules_dir):
+            os.makedirs(rules_dir)
+            
+        yaml = YAML(typ='safe')
+        
+        for file_name in os.listdir(rules_dir):
+            if not file_name.endswith('.yaml'):
+                continue
+                
+            file_path = os.path.join(rules_dir, file_name)
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    rules_data = yaml.load(f)
+                    
+                if not isinstance(rules_data, list):
+                    self.logger.warning(f"Invalid rules file {file_name}, expected list of rules")
+                    continue
+                    
+                for rule_data in rules_data:
+                    rule = self._create_rule(rule_data, container)
+                    if rule:
+                        self.register(rule)
+                        
+            except Exception as e:
+                self.logger.error(f"Failed to load rules from {file_path}: {str(e)}")
+                
+    def _create_rule(self, rule_data: dict) -> DispatchRule:
+        """从规则数据创建调度规则实例"""
+        rule_type = rule_data.get('type')
+        workflow_name = rule_data.get('workflow')
+        
+
+        if not rule_type or not workflow_name:
+            raise ValueError("Rule must specify 'type' and 'workflow'")
+            
+        # 获取工作流构建器
+        workflow_builder = self.workflow_registry.get(workflow_name)
+        if not workflow_builder:
+            raise ValueError(f"Workflow {workflow_name} not found")
+            
+        # 根据规则类型创建相应的规则实例
+        if rule_type == 'prefix':
+            prefix = rule_data.get('prefix')
+            if not prefix:
+                raise ValueError("Prefix rule must specify 'prefix'")
+            return PrefixMatchRule(prefix, workflow_builder)
+            
+        elif rule_type == 'keyword':
+            keywords = rule_data.get('keywords')
+            if not keywords or not isinstance(keywords, list):
+                raise ValueError("Keyword rule must specify 'keywords' as list")
+            return KeywordMatchRule(keywords, workflow_builder)
+            
+        elif rule_type == 'regex':
+            pattern = rule_data.get('pattern')
+            if not pattern:
+                raise ValueError("Regex rule must specify 'pattern'")
+            return RegexMatchRule(pattern, workflow_builder)
+            
+        else:
+            raise ValueError(f"Unknown rule type: {rule_type}")
+            
+    def get_rules(self) -> List[DispatchRule]:
+        """获取所有已注册的规则"""
+        return self.rules.copy() 

framework/workflow_dispatcher/workflow_dispatcher.py

@@ -5,38 +5,46 @@
 from framework.logger import get_logger
 from framework.workflow_dispatcher.dispatch_rule import DispatchRule, FallbackMatchRule
 from framework.workflow_executor.executor import WorkflowExecutor
+from framework.workflow_executor.workflow_registry import WorkflowRegistry
+from framework.workflow_dispatcher.dispatch_rule_registry import DispatchRuleRegistry
+from framework.workflow_executor.system_workflows import register_system_workflows
 
 
 class WorkflowDispatcher:
+    """工作流调度器"""
     def __init__(self, container: DependencyContainer):
         self.container = container
         self.logger = get_logger("WorkflowDispatcher")
-        self.dispatch_rules: List[DispatchRule] = []
+        
+        # 从容器获取注册表
+        self.workflow_registry = container.resolve(WorkflowRegistry)
+        self.dispatch_registry = container.resolve(DispatchRuleRegistry)
+        
+        # 初始化默认的兜底规则
         self.__init_fallback()
 
     def __init_fallback(self):
         """初始化默认的兜底规则"""
         from framework.workflows.default.factory import DefaultWorkflowFactory
         fallback_factory = DefaultWorkflowFactory()
-        self.dispatch_rules.append(FallbackMatchRule(fallback_factory))
+        self.dispatch_registry.register(FallbackMatchRule(fallback_factory.create_workflow))
         self.logger.info("Registered fallback dispatch rule")
 
     def register_rule(self, rule: DispatchRule):
         """注册一个调度规则"""
-        self.dispatch_rules.append(rule)
+        self.dispatch_registry.register(rule)
         self.logger.info(f"Registered dispatch rule: {rule}")
 
     async def dispatch(self, source: IMAdapter, message: IMMessage):
         """
         根据消息内容选择第一个匹配的规则进行处理
         """
-        for rule in self.dispatch_rules:
+        for rule in self.dispatch_registry.get_rules():
             if rule.match(message):
                 self.logger.debug(f"Matched rule {rule}, executing workflow")
                 with self.container.scoped() as scoped_container:
                     scoped_container.register(IMAdapter, source)
                     scoped_container.register(IMMessage, message)
-                    # 此处构造出实际的 workflow 对象，使用的容器是注入了当前上下文的 container
                     workflow = rule.get_workflow(scoped_container)
                     executor = WorkflowExecutor(workflow)
                     return await executor.run()

framework/workflow_executor/system_blocks.py

@@ -8,6 +8,9 @@
     LLMToMessage,
     StoreMemory
 )
+from framework.workflows.blocks.game.dice import DiceRoll
+from framework.workflows.blocks.game.gacha import GachaSimulator
+from framework.workflows.blocks.system.help import GenerateHelp
 
 def register_system_blocks(registry: BlockRegistry):
     """注册系统自带的 block"""
@@ -21,4 +24,11 @@ def register_system_blocks(registry: BlockRegistry):
     registry.register("construct_llm_message", "internal", ConstructLLMMessage)
     registry.register("llm_chat", "internal", LLMChat)
     registry.register("llm_to_message", "internal", LLMToMessage)
-    registry.register("store_memory", "internal", StoreMemory) 
+    registry.register("store_memory", "internal", StoreMemory)
+    
+    # 游戏相关 blocks
+    registry.register("dice_roll", "game", DiceRoll)
+    registry.register("gacha_simulator", "game", GachaSimulator)
+    
+    # 系统相关 blocks
+    registry.register("generate_help", "system", GenerateHelp) 

framework/workflow_executor/system_workflows.py

@@ -0,0 +1,22 @@
+from framework.workflow_executor.workflow_registry import WorkflowRegistry
+from framework.workflows.game.factory import GameWorkflowFactory
+from framework.workflows.system.factory import SystemWorkflowFactory
+from framework.workflows.default.factory import DefaultWorkflowFactory
+
+def register_system_workflows(registry: WorkflowRegistry):
+    """注册系统自带的工作流"""
+    
+    # 游戏相关工作流
+    registry.register("game", "dice", GameWorkflowFactory.create_dice_workflow)
+    registry.register("game", "gacha", GameWorkflowFactory.create_gacha_workflow)
+    
+    # 系统相关工作流
+    registry.register("system", "help", SystemWorkflowFactory.create_help_workflow)
+    registry.register("system", "admin", SystemWorkflowFactory.create_help_workflow)  # 暂时用help代替
+    registry.register("system", "status", SystemWorkflowFactory.create_help_workflow)  # 暂时用help代替
+    registry.register("system", "settings", SystemWorkflowFactory.create_help_workflow)  # 暂时用help代替
+    
+    # 聊天相关工作流
+    registry.register("chat", "normal", DefaultWorkflowFactory.create_workflow)
+    registry.register("chat", "creative", DefaultWorkflowFactory.create_workflow)  # 暂时用默认的
+    registry.register("chat", "roleplay", DefaultWorkflowFactory.create_workflow)  # 暂时用默认的 

framework/workflow_executor/workflow_registry.py

@@ -0,0 +1,59 @@
+from typing import Dict, Type, Optional
+from framework.workflow_executor.workflow import Workflow
+from framework.workflow_executor.builder import WorkflowBuilder
+from framework.ioc.container import DependencyContainer
+from framework.logger import get_logger
+import os
+
+class WorkflowRegistry:
+    """工作流注册表，管理工作流的注册和获取"""
+    
+    def __init__(self, container: DependencyContainer):
+        self._workflows: Dict[str, Type[WorkflowBuilder]] = {}
+        self.logger = get_logger("WorkflowRegistry")
+        self.container = container
+        
+
+    def register(self, group_id: str, workflow_id: str, workflow_builder: Type[WorkflowBuilder]):
+        """注册一个工作流"""
+        full_name = f"{group_id}:{workflow_id}"
+        if full_name in self._workflows:
+            self.logger.warning(f"Workflow {full_name} already registered, overwriting")
+        self._workflows[full_name] = workflow_builder
+        self.logger.info(f"Registered workflow: {full_name}")
+        
+    def get(self, name: str) -> Optional[Type[WorkflowBuilder]]:
+        """获取工作流构建器"""
+        return self._workflows.get(name)
+        
+    def load_workflows(self, workflows_dir: str = "data/workflows"):
+        """从指定目录加载所有工作流定义"""
+        if not os.path.exists(workflows_dir):
+            os.makedirs(workflows_dir)
+                    
+        for file_name in os.listdir(workflows_dir):
+            if not file_name.endswith('.yaml'):
+                continue
+                
+            file_path = os.path.join(workflows_dir, file_name)
+            try:
+                workflow = WorkflowBuilder.load_from_yaml(file_path, self.container)
+                # 从文件名解析 group_id 和 workflow_id
+                name_without_ext = os.path.splitext(file_name)[0]
+                if ':' not in name_without_ext:
+                    self.logger.warning(f"Invalid workflow file name {file_name}, skipping")
+                    continue
+                    
+                group_id, workflow_id = name_without_ext.split(':', 1)
+                self.register(group_id, workflow_id, workflow)
+                
+            except Exception as e:
+                self.logger.error(f"Failed to load workflow from {file_path}: {str(e)}")
+                
+    def create_workflow(self, name: str) -> Optional[Workflow]:
+        """创建工作流实例"""
+        builder = self.get(name)
+        if not builder:
+            return None
+            
+        return builder.build()