mofox-plugin-dev-toolkit 0.2.1__py3-none-any.whl

mpdt/templates/chatter_template.py

@@ -0,0 +1,103 @@
+"""
+Chatter 组件模板
+"""
+
+CHATTER_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from src.common.data_models.message_manager_data_model import StreamContext
+from src.common.logger import get_logger
+from src.plugin_system import BaseChatter, ChatType
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BaseChatter):
+    """
+    {description}
+
+    Chatter 组件用于处理聊天流程，控制对话的整体逻辑。
+
+    使用场景：
+    - 自定义对话流程
+    - 特殊聊天模式处理
+    - 对话状态管理
+    - 多轮对话控制
+    """
+
+    # Chatter 元数据
+    chatter_name: str = "{chatter_name}"
+    chatter_description: str = "{description}"
+    chat_types: list[ChatType] = [ChatType.PRIVATE, ChatType.GROUP]  # 支持的聊天类型
+
+    async def execute(self, context: StreamContext) -> dict:
+        """
+        执行聊天处理逻辑
+
+        Args:
+            context: StreamContext对象，包含聊天上下文信息
+                - context.stream_id: 聊天流ID
+                - context.user_id: 用户ID
+                - context.user_name: 用户名
+                - context.message_content: 消息内容
+                - context.chat_type: 聊天类型
+                - 等等...
+
+        Returns:
+            处理结果字典，包含：
+                - success: 是否成功
+                - response: 响应内容（可选）
+                - next_action: 下一步动作（可选）
+        """
+        try:
+            logger.info(f"执行 Chatter: {{self.chatter_name}}")
+            logger.debug(f"聊天上下文: {{context}}")
+
+            # TODO: 实现聊天处理逻辑
+
+            # 示例：根据消息内容处理
+            message = context.message_content
+            user_name = context.user_name
+
+            # 可以使用 action_manager 调用 Action
+            # result = await self.action_manager.execute_action("action_name", {{}})
+
+            # 构建响应
+            response = self._generate_response(message, user_name)
+
+            return {{
+                "success": True,
+                "response": response,
+                "next_action": None
+            }}
+
+        except Exception as e:
+            logger.error(f"Chatter 执行失败: {{e}}")
+            return {{
+                "success": False,
+                "error": str(e)
+            }}
+
+    def _generate_response(self, message: str, user_name: str) -> str:
+        """
+        生成响应内容
+
+        Args:
+            message: 用户消息
+            user_name: 用户名
+
+        Returns:
+            响应文本
+        """
+        # TODO: 实现响应生成逻辑
+        return f"收到 {{user_name}} 的消息: {{message}}"
+'''
+
+
+def get_chatter_template() -> str:
+    """获取 Chatter 组件模板"""
+    return CHATTER_TEMPLATE

mpdt/templates/event_template.py

@@ -0,0 +1,116 @@
+"""
+Event Handler 组件模板
+"""
+
+EVENT_HANDLER_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from src.common.logger import get_logger
+from src.plugin_system import BaseEventHandler, HandlerResult
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BaseEventHandler):
+    """
+    {description}
+
+    Event Handler 组件用于处理系统事件。
+
+    处理的事件类型: {event_type}
+
+    使用场景：
+    - 监听消息事件
+    - 监听系统事件
+    - 实现事件驱动逻辑
+    - 在特定事件发生时执行操作
+    """
+
+    # Event Handler 元数据
+    handler_name: str = "{class_name}"
+    event_types: list[str] = ["{event_type}"]  # 监听的事件类型列表
+    weight: int = 100  # 权重：0-1000，数字越大优先级越高
+
+    async def execute(self, params: dict) -> HandlerResult:
+        """
+        处理事件
+
+        Args:
+            params: 事件参数字典，包含事件相关的所有信息
+
+        Returns:
+            HandlerResult: 处理结果
+                - success: 是否成功
+                - continue_process: 是否继续处理后续 handler
+                - message: 返回消息
+        """
+        try:
+            logger.info(f"处理事件: {{self.handler_name}}")
+            logger.debug(f"事件参数: {{params}}")
+
+            # 检查是否应该处理此事件
+            if not self._should_handle(params):
+                logger.debug("跳过此事件")
+                return HandlerResult(
+                    success=True,
+                    continue_process=True,
+                    message="已跳过",
+                    handler_name=self.handler_name
+                )
+
+            # TODO: 实现事件处理逻辑
+            result = await self._process_event(params)
+
+            logger.info("事件处理完成")
+            return HandlerResult(
+                success=True,
+                continue_process=True,  # 设为 False 可以阻止后续 handler 执行
+                message=result,
+                handler_name=self.handler_name
+            )
+
+        except Exception as e:
+            logger.error(f"事件处理失败: {{e}}")
+            return HandlerResult(
+                success=False,
+                continue_process=True,
+                message=str(e),
+                handler_name=self.handler_name
+            )
+
+    def _should_handle(self, params: dict) -> bool:
+        """
+        判断是否应该处理该事件
+
+        Args:
+            params: 事件参数
+
+        Returns:
+            是否处理
+        """
+        # TODO: 实现判断逻辑
+        # 示例: 检查事件类型、来源、条件等
+        return True
+
+    async def _process_event(self, params: dict) -> str:
+        """
+        处理事件的具体逻辑
+
+        Args:
+            params: 事件参数
+
+        Returns:
+            处理结果消息
+        """
+        # TODO: 实现具体的事件处理逻辑
+        return "处理成功"
+'''
+
+
+def get_event_handler_template() -> str:
+    """获取 Event Handler 组件模板"""
+    return EVENT_HANDLER_TEMPLATE

mpdt/templates/plus_command_template.py

@@ -0,0 +1,150 @@
+"""
+PlusCommand 组件模板
+"""
+
+PLUS_COMMAND_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from src.common.logger import get_logger
+from src.plugin_system import BasePlusCommand
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BasePlusCommand):
+    """
+    {description}
+
+    PlusCommand 是增强型命令，支持：
+    - 复杂的参数解析
+    - 子命令系统
+    - 权限检查
+    - 更丰富的交互方式
+    """
+
+    # PlusCommand 元数据
+    command_name: str = "{command_name}"
+    command_description: str = "{description}"
+    command_aliases: list[str] = []  # 命令别名
+    usage: str = "{command_name} [子命令] [选项]"
+
+    async def execute(self, **kwargs) -> tuple[bool, str]:
+        """
+        执行命令
+
+        可以访问的参数：
+        - self.stream_context: 聊天流上下文
+        - self.raw_text: 原始命令文本
+        - self.command_args: 解析后的命令参数
+
+        Returns:
+            (是否成功, 结果消息)
+        """
+        try:
+            logger.info(f"执行 PlusCommand: {{self.command_name}}")
+
+            # 获取命令参数
+            args = self.command_args if hasattr(self, "command_args") else []
+
+            if not args:
+                return True, self._help_message()
+
+            subcommand = args[0]
+            subcommand_args = args[1:] if len(args) > 1 else []
+
+            # 执行子命令
+            if subcommand == "list":
+                return await self._list_command(subcommand_args)
+            elif subcommand == "add":
+                return await self._add_command(subcommand_args)
+            elif subcommand == "remove":
+                return await self._remove_command(subcommand_args)
+            elif subcommand == "help":
+                return True, self._help_message()
+            else:
+                return False, f"未知子命令: {{subcommand}}\\n{{self._help_message()}}"
+
+        except Exception as e:
+            logger.error(f"命令执行失败: {{e}}")
+            return False, f"执行失败: {{e}}"
+
+    async def _list_command(self, args: list[str]) -> tuple[bool, str]:
+        """
+        列表子命令
+
+        Args:
+            args: 参数列表
+
+        Returns:
+            (是否成功, 结果消息)
+        """
+        # TODO: 实现列表功能
+        return True, "列表功能"
+
+    async def _add_command(self, args: list[str]) -> tuple[bool, str]:
+        """
+        添加子命令
+
+        Args:
+            args: 参数列表
+
+        Returns:
+            (是否成功, 结果消息)
+        """
+        if not args:
+            return False, f"用法: {{self.command_name}} add <项目>"
+
+        item = " ".join(args)
+        # TODO: 实现添加功能
+        return True, f"已添加: {{item}}"
+
+    async def _remove_command(self, args: list[str]) -> tuple[bool, str]:
+        """
+        删除子命令
+
+        Args:
+            args: 参数列表
+
+        Returns:
+            (是否成功, 结果消息)
+        """
+        if not args:
+            return False, f"用法: {{self.command_name}} remove <项目>"
+
+        item = " ".join(args)
+        # TODO: 实现删除功能
+        return True, f"已删除: {{item}}"
+
+    def _help_message(self) -> str:
+        """
+        生成帮助信息
+
+        Returns:
+            帮助信息文本
+        """
+        return f"""
+命令: {{self.command_name}}
+描述: {{self.command_description}}
+用法: {{self.usage}}
+
+子命令:
+    list       列出所有项目
+    add        添加新项目
+    remove     删除项目
+    help       显示此帮助信息
+
+示例:
+    {{self.command_name}} list
+    {{self.command_name}} add item1
+    {{self.command_name}} remove item1
+"""
+'''
+
+
+def get_plus_command_template() -> str:
+    """获取 PlusCommand 组件模板"""
+    return PLUS_COMMAND_TEMPLATE

mpdt/templates/prompt_template.py

@@ -0,0 +1,92 @@
+"""
+Prompt 组件模板
+"""
+
+PROMPT_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from src.chat.utils.prompt_params import PromptParameters
+from src.common.logger import get_logger
+from src.plugin_system.base.component_types import InjectionRule
+logger = get_logger(__name__)
+
+
+class {class_name}(BasePrompt):
+    """
+    {description}
+
+    Prompt 组件用于向核心 Prompt 模板注入额外的上下文信息。
+
+    使用场景：
+    - 向系统提示词添加自定义指令
+    - 注入动态上下文信息
+    - 添加角色设定或行为规则
+    - 提供额外的背景知识
+    """
+
+    # Prompt 组件元数据
+    prompt_name: str = "{prompt_name}"
+    prompt_description: str = "{description}"
+
+    # 定义注入规则：指定要注入到哪个核心 Prompt，以什么方式注入
+    injection_rules = [
+        InjectionRule(
+            target_prompt="planner_prompt",  # 目标 Prompt 名称
+            injection_type=InjectionType.APPEND,  # 注入方式：APPEND(追加) 或 PREPEND(前置)
+            priority=50  # 优先级：0-100，数字越大优先级越高
+        )
+    ]
+
+    async def execute(self) -> str:
+        """
+        生成要注入的 Prompt 内容
+
+        可以访问 self.params 来获取上下文信息：
+        - self.params.user_id: 用户ID
+        - self.params.user_name: 用户名
+        - self.params.bot_name: 机器人名称
+        - self.params.recent_messages: 最近的消息列表
+        - self.params.chat_type: 聊天类型（私聊/群聊）
+        - 等等...
+
+        Returns:
+            要注入的文本内容
+        """
+        try:
+            logger.info(f"生成 Prompt: {{self.prompt_name}}")
+
+            # TODO: 根据 self.params 构建要注入的内容
+            # 示例：根据用户信息生成个性化提示词
+            user_name = self.params.user_name or "用户"
+
+            prompt_content = f"""
+# 特殊指令
+
+你正在与 {{user_name}} 对话。
+
+## 行为规则
+- 保持友好和专业的态度
+- 准确理解用户意图
+- 提供有价值的回答
+
+## 额外能力
+- 你可以执行特定的操作
+- 你有访问某些数据的权限
+"""
+
+            logger.debug(f"生成的内容: {{prompt_content[:100]}}...")
+            return prompt_content.strip()
+
+        except Exception as e:
+            logger.error(f"生成 Prompt 失败: {{e}}")
+            return ""
+'''
+
+
+def get_prompt_template() -> str:
+    """获取 Prompt 组件模板"""
+    return PROMPT_TEMPLATE

mpdt/templates/router_template.py

@@ -0,0 +1,175 @@
+"""
+Router 组件模板
+"""
+
+ROUTER_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from fastapi import APIRouter, HTTPException
+from src.common.logger import get_logger
+from src.plugin_system import BaseRouterComponent
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BaseRouterComponent):
+    """
+    {description}
+
+    Router 组件用于对外暴露 HTTP 接口。
+
+    使用场景：
+    - 提供 RESTful API
+    - Webhook 接收端点
+    - 自定义 HTTP 服务
+    - 与外部系统集成
+    """
+
+    # Router 元数据
+    component_name: str = "{router_name}"
+    component_description: str = "{description}"
+    component_version: str = "1.0.0"
+
+    def register_endpoints(self) -> None:
+        """
+        注册 HTTP 端点
+
+        使用 self.router 来添加路由:
+        - @self.router.get("/path")
+        - @self.router.post("/path")
+        - @self.router.put("/path")
+        - @self.router.delete("/path")
+        """
+
+        @self.router.get("/hello")
+        async def hello():
+            """
+            示例 GET 端点
+            """
+            return {{"message": "Hello from {{self.component_name}}"}}
+
+        @self.router.get("/status")
+        async def get_status():
+            """
+            获取状态
+            """
+            try:
+                # TODO: 实现状态检查逻辑
+                return {{
+                    "status": "ok",
+                    "component": self.component_name,
+                    "version": self.component_version
+                }}
+            except Exception as e:
+                logger.error(f"获取状态失败: {{e}}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.router.post("/webhook")
+        async def webhook(data: dict):
+            """
+            Webhook 接收端点
+
+            Args:
+                data: 接收的数据
+            """
+            try:
+                logger.info(f"收到 webhook 数据: {{data}}")
+
+                # TODO: 处理 webhook 数据
+                result = await self._process_webhook(data)
+
+                return {{
+                    "success": True,
+                    "result": result
+                }}
+            except Exception as e:
+                logger.error(f"处理 webhook 失败: {{e}}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.router.get("/data/{{item_id}}")
+        async def get_item(item_id: str):
+            """
+            获取指定项目
+
+            Args:
+                item_id: 项目ID
+            """
+            try:
+                # TODO: 实现获取逻辑
+                item = await self._get_item(item_id)
+                if not item:
+                    raise HTTPException(status_code=404, detail="Item not found")
+                return item
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.error(f"获取项目失败: {{e}}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.router.post("/data")
+        async def create_item(data: dict):
+            """
+            创建新项目
+
+            Args:
+                data: 项目数据
+            """
+            try:
+                # TODO: 实现创建逻辑
+                result = await self._create_item(data)
+                return {{
+                    "success": True,
+                    "item_id": result
+                }}
+            except Exception as e:
+                logger.error(f"创建项目失败: {{e}}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+    async def _process_webhook(self, data: dict) -> dict:
+        """
+        处理 webhook 数据
+
+        Args:
+            data: webhook 数据
+
+        Returns:
+            处理结果
+        """
+        # TODO: 实现 webhook 处理逻辑
+        return {{"processed": True}}
+
+    async def _get_item(self, item_id: str) -> dict | None:
+        """
+        获取项目
+
+        Args:
+            item_id: 项目ID
+
+        Returns:
+            项目数据或 None
+        """
+        # TODO: 实现获取逻辑
+        return {{"id": item_id, "name": "示例项目"}}
+
+    async def _create_item(self, data: dict) -> str:
+        """
+        创建项目
+
+        Args:
+            data: 项目数据
+
+        Returns:
+            新项目ID
+        """
+        # TODO: 实现创建逻辑
+        return "new_item_id"
+'''
+
+
+def get_router_template() -> str:
+    """获取 Router 组件模板"""
+    return ROUTER_TEMPLATE