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

mpdt/dev/bridge_plugin/cleanup_handler.py

@@ -0,0 +1,65 @@
+"""
+DevBridge 清理事件处理器
+在程序停止时清理 DevBridge 插件和目标插件
+"""
+
+import shutil
+from pathlib import Path
+from typing import ClassVar
+
+from src.common.logger import get_logger
+from src.plugin_system.base import BaseEventHandler
+from src.plugin_system.base.component_types import EventType
+
+from .dev_config import TARGET_PLUGIN_NAME, TARGET_PLUGIN_PATH
+
+logger = get_logger("dev_bridge_cleanup")
+
+
+class CleanupHandler(BaseEventHandler):
+    """清理事件处理器 - 在程序停止时清理插件文件"""
+
+    handler_name = "dev_bridge_cleanup"
+    handler_description = "DevBridge 清理处理器"
+    weight = -100  # 负权重，确保最后执行
+    init_subscribe: ClassVar[list[EventType | str]] = [EventType.ON_STOP]
+
+    def __init__(self):
+        super().__init__()
+        self._target_plugin_name = TARGET_PLUGIN_NAME
+        self._target_plugin_path = TARGET_PLUGIN_PATH
+
+    async def execute(self, kwargs: dict | None) -> tuple[bool, bool, str | None]:
+        """程序停止时执行清理（同步删除）"""
+        logger.info("🛑 收到停止事件，准备清理 DevBridge...")
+
+        self._delete_plugins()
+
+        return True, True, None
+
+    def _delete_plugins(self):
+        """同步删除插件目录"""
+        plugin_dir = Path(__file__).parent
+        # 目标插件在 plugins 目录中的路径
+        plugins_dir = plugin_dir.parent  # plugins 目录
+        source_path = Path(self._target_plugin_path)
+        target_plugin_dir = plugins_dir / self._target_plugin_name if self._target_plugin_name else None
+
+        # 判断目标插件是否本来就在 plugins 目录下
+        is_in_plugins_dir = source_path.parent.resolve() == plugins_dir.resolve()
+
+        # 删除目标开发插件（仅当它是复制进来的时候）
+        if not is_in_plugins_dir and target_plugin_dir and target_plugin_dir.exists():
+            try:
+                shutil.rmtree(target_plugin_dir)
+                logger.info(f"🧹 目标插件已清理: {target_plugin_dir}")
+            except Exception as e:
+                logger.warning(f"⚠️ 清理目标插件失败: {e}")
+
+        # 删除 DevBridge 自己
+        try:
+            if plugin_dir.exists():
+                shutil.rmtree(plugin_dir)
+                print(f"[DevBridge] 🧹 DevBridge 插件已清理: {plugin_dir}")
+        except Exception as e:
+            print(f"[DevBridge] ⚠️ 清理 DevBridge 插件失败: {e}")

mpdt/dev/bridge_plugin/dev_config.py

@@ -0,0 +1,24 @@
+"""
+开发模式配置文件
+此文件在 mpdt dev 注入时会被修改，用于传递开发插件的配置信息
+"""
+
+# ==================== 开发目标插件配置 ====================
+# 以下常量会在 mpdt dev 注入时被自动修改
+
+# 目标插件的绝对路径
+TARGET_PLUGIN_PATH: str = ""
+
+# 目标插件名称
+TARGET_PLUGIN_NAME: str = ""
+
+# 是否启用文件监控
+ENABLE_FILE_WATCHER: bool = True
+
+# 文件监控防抖延迟（秒）
+DEBOUNCE_DELAY: float = 0.3
+
+# ==================== 其他配置 ====================
+
+# 发现服务器端口
+DISCOVERY_PORT: int = 12318

mpdt/dev/bridge_plugin/file_watcher.py

@@ -0,0 +1,169 @@
+"""
+文件监控器模块
+负责监控目标插件的文件变化并触发重载
+"""
+
+import asyncio
+import time
+from collections.abc import Callable, Coroutine
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+if TYPE_CHECKING:
+    pass
+
+try:
+    from src.common.logger import get_logger
+    logger = get_logger("dev_watcher")
+except ImportError:
+    import logging
+    logger = logging.getLogger("dev_watcher")
+
+
+class PluginFileHandler(FileSystemEventHandler):
+    """插件文件变化处理器"""
+
+    def __init__(
+        self,
+        plugin_path: Path,
+        callback: Callable[[str], Coroutine[Any, Any, None] | None],
+        debounce_delay: float = 0.3
+    ):
+        self.plugin_path = plugin_path
+        self.callback = callback
+        self.debounce_delay = debounce_delay
+        self.last_modified: dict[str, float] = {}
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def set_event_loop(self, loop: asyncio.AbstractEventLoop):
+        """设置事件循环"""
+        self._loop = loop
+
+    def on_modified(self, event: FileSystemEvent):
+        if event.is_directory:
+            return
+        src_path = event.src_path
+        if isinstance(src_path, bytes):
+            src_path = src_path.decode()
+        self._handle_change(str(src_path))
+
+    def on_created(self, event: FileSystemEvent):
+        if event.is_directory:
+            return
+        src_path = event.src_path
+        if isinstance(src_path, bytes):
+            src_path = src_path.decode()
+        self._handle_change(str(src_path))
+
+    def _handle_change(self, src_path: str):
+        """处理文件变化"""
+        # 只监控 Python 文件
+        if not src_path.endswith(".py"):
+            return
+
+        # 防抖处理
+        now = time.time()
+        if src_path in self.last_modified:
+            if now - self.last_modified[src_path] < self.debounce_delay:
+                return
+
+        self.last_modified[src_path] = now
+
+        # 获取相对路径
+        try:
+            rel_path = Path(src_path).relative_to(self.plugin_path)
+        except ValueError:
+            rel_path = Path(src_path).name
+
+        logger.info(f"检测到文件变化: {rel_path}")
+
+        # 在事件循环中调度回调
+        if self._loop and self.callback:
+            asyncio.run_coroutine_threadsafe(
+                self._async_callback(str(rel_path)),
+                self._loop
+            )
+
+    async def _async_callback(self, rel_path: str):
+        """异步回调包装"""
+        try:
+            result = self.callback(rel_path)
+            if asyncio.iscoroutine(result):
+                await result
+        except Exception as e:
+            logger.error(f"文件变化回调执行失败: {e}")
+
+
+class FileWatcher:
+    """文件监控器"""
+
+    def __init__(
+        self,
+        plugin_path: str | Path,
+        on_change_callback: Callable[[str], Coroutine[Any, Any, None] | None],
+        debounce_delay: float = 0.3
+    ):
+        self.plugin_path = Path(plugin_path)
+        self.on_change_callback = on_change_callback
+        self.debounce_delay = debounce_delay
+        self._observer: Any = None
+        self._handler: PluginFileHandler | None = None
+        self._running = False
+
+    def start(self, loop: asyncio.AbstractEventLoop | None = None):
+        """启动文件监控"""
+        if self._running:
+            logger.warning("文件监控器已在运行")
+            return
+
+        if not self.plugin_path.exists():
+            logger.error(f"插件路径不存在: {self.plugin_path}")
+            return
+
+        # 创建处理器
+        self._handler = PluginFileHandler(
+            self.plugin_path,
+            self.on_change_callback,
+            self.debounce_delay
+        )
+
+        # 设置事件循环
+        if loop:
+            self._handler.set_event_loop(loop)
+        else:
+            try:
+                self._handler.set_event_loop(asyncio.get_running_loop())
+            except RuntimeError:
+                pass
+
+        # 创建并启动观察者
+        self._observer = Observer()
+        self._observer.schedule(
+            self._handler,
+            str(self.plugin_path),
+            recursive=True
+        )
+        self._observer.start()
+        self._running = True
+
+        logger.info(f"文件监控已启动: {self.plugin_path}")
+
+    def stop(self):
+        """停止文件监控"""
+        if not self._running:
+            return
+
+        if self._observer:
+            self._observer.stop()
+            self._observer.join(timeout=2)
+            self._observer = None
+
+        self._running = False
+        logger.info("文件监控已停止")
+
+    @property
+    def is_running(self) -> bool:
+        return self._running

mpdt/dev/bridge_plugin/plugin.py

@@ -0,0 +1,219 @@
+"""
+DevBridge 插件 - 完整的开发模式插件
+负责文件监控、插件重载等所有开发操作
+配置通过 dev_config.py 中的常量传递（mpdt dev 注入时动态修改）
+"""
+
+import asyncio
+from pathlib import Path
+from typing import ClassVar
+
+from src.common.logger import get_logger
+from src.plugin_system import (
+    BasePlugin,
+    register_plugin,
+)
+
+# 导入配置（由 mpdt dev 注入时修改）
+from .dev_config import (
+    DEBOUNCE_DELAY,
+    ENABLE_FILE_WATCHER,
+    TARGET_PLUGIN_NAME,
+    TARGET_PLUGIN_PATH,
+)
+
+logger = get_logger("dev_bridge")
+
+
+@register_plugin
+class DevBridgePlugin(BasePlugin):
+    """开发模式桥接插件
+
+    这是一个完整的开发模式插件，负责：
+    1. 监控目标插件的文件变化
+    2. 自动重载目标插件
+
+    配置通过 dev_config.py 传递，mpdt dev 在注入时会修改这些常量。
+    """
+
+    plugin_name = "dev_bridge"
+    enable_plugin = True
+    config_file_name = "config.toml"
+    dependencies: ClassVar = []
+    python_dependencies: ClassVar = []
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._file_watcher = None
+        self._target_plugin_name = TARGET_PLUGIN_NAME
+        self._target_plugin_path = TARGET_PLUGIN_PATH
+
+    def get_plugin_components(self) -> list:
+        """注册清理事件处理器"""
+        from .cleanup_handler import CleanupHandler
+
+        return [(CleanupHandler.get_handler_info(), CleanupHandler)]
+
+    async def on_plugin_loaded(self):
+        """插件加载完成后启动文件监控"""
+        from .file_watcher import FileWatcher
+
+        logger.info("=" * 60)
+        logger.info("🚀 DevBridge 开发模式插件已加载")
+        logger.info(f"📦 目标插件: {self._target_plugin_name}")
+        logger.info(f"📂 目标路径: {self._target_plugin_path}")
+        logger.info("=" * 60)
+
+        # 检查目标插件是否成功加载
+        await self._check_target_plugin_loaded()
+
+        # 启动文件监控
+        if ENABLE_FILE_WATCHER and self._target_plugin_path:
+            plugin_path = Path(self._target_plugin_path)
+            if plugin_path.exists():
+                self._file_watcher = FileWatcher(plugin_path, self._on_file_changed, DEBOUNCE_DELAY)
+                # 获取当前事件循环并启动监控
+                try:
+                    loop = asyncio.get_running_loop()
+                    self._file_watcher.start(loop)
+                    logger.info("👀 文件监控已启动")
+                    logger.info("📝 修改 Python 文件将自动重载插件")
+                except Exception as e:
+                    logger.error(f"启动文件监控失败: {e}")
+            else:
+                logger.warning(f"目标插件路径不存在: {plugin_path}")
+        else:
+            logger.info("文件监控已禁用或未配置目标路径")
+
+    async def _check_target_plugin_loaded(self):
+        """检查目标插件是否成功加载，未加载则报错提示"""
+        if not self._target_plugin_name:
+            logger.error("❌ 未配置目标插件名称")
+            return
+
+        try:
+            from src.plugin_system.apis import plugin_manage_api
+
+            is_loaded = plugin_manage_api.is_plugin_loaded(self._target_plugin_name)
+            is_enabled = plugin_manage_api.is_plugin_enabled(self._target_plugin_name)
+
+            if not is_loaded:
+                logger.error("=" * 60)
+                logger.error(f"❌ 目标插件 {self._target_plugin_name} 未加载！")
+                logger.error("")
+                if not is_enabled:
+                    logger.error("📋 原因: 插件已被禁用")
+                    logger.error("")
+                    logger.error("🔧 解决方案:")
+                    logger.error("   1. 检查插件的 config.toml 中 [plugin] enabled = true")
+                    logger.error("   2. 或在 plugin.py 中设置 enable_plugin = True")
+                    logger.error("   3. 或直接删除 enable_plugin 行（默认启用）")
+                else:
+                    logger.error("📋 原因: 插件加载失败，请检查插件代码是否有错误")
+                logger.error("=" * 60)
+            else:
+                logger.info(f"✅ 目标插件 {self._target_plugin_name} 已成功加载")
+
+        except ValueError:
+            logger.error(f"❌ 目标插件 {self._target_plugin_name} 未注册")
+        except Exception as e:
+            logger.error(f"❌ 检查目标插件状态时出错: {e}")
+
+    async def _on_file_changed(self, rel_path: str):
+        """文件变化回调 - 同步文件并重载目标插件"""
+        if not self._target_plugin_name:
+            logger.warning("未配置目标插件名称，跳过重载")
+            return
+
+        logger.info(f"📝 检测到文件变化: {rel_path}")
+
+        # 先同步文件到 plugins 目录
+        try:
+            self._sync_plugin_files()
+            logger.info("📦 文件已同步到 plugins 目录")
+        except Exception as e:
+            logger.error(f"❌ 同步文件失败: {e}")
+            return
+
+        try:
+            from src.plugin_system.apis import plugin_manage_api
+
+            plugin_name = self._target_plugin_name
+            is_loaded = plugin_manage_api.is_plugin_loaded(plugin_name)
+            is_enabled = plugin_manage_api.is_plugin_enabled(plugin_name)
+
+            if is_loaded:
+                # 插件已加载，检查是否被禁用
+                if not is_enabled:
+                    logger.info(f"🔓 插件 {plugin_name} 已禁用，正在启用...")
+                    await plugin_manage_api.enable_plugin(plugin_name)
+
+                # 重载插件
+                logger.info(f"🔄 正在重载插件: {plugin_name}...")
+                success = await plugin_manage_api.reload_plugin(plugin_name)
+                if success:
+                    logger.info(f"✅ 插件 {plugin_name} 重载成功")
+                else:
+                    logger.error(f"❌ 插件 {plugin_name} 重载失败")
+            else:
+                # 插件未加载，使用 enable_plugin 来加载并启用
+                # enable_plugin 会同时处理加载和启用，即使插件之前被禁用
+                logger.info(f"📦 插件 {plugin_name} 未加载，正在启用并加载...")
+                success = await plugin_manage_api.enable_plugin(plugin_name)
+                if success:
+                    logger.info(f"✅ 插件 {plugin_name} 启用并加载成功")
+                else:
+                    logger.error(f"❌ 插件 {plugin_name} 启用/加载失败")
+
+        except ValueError as e:
+            # 插件未注册，尝试扫描并加载
+            logger.warning(f"⚠️ 插件未注册: {e}")
+            logger.info("🔍 正在扫描插件目录...")
+            try:
+                from src.plugin_system.apis import plugin_manage_api
+
+                plugin_manage_api.rescan_and_register_plugins(load_after_register=True)
+                if plugin_manage_api.is_plugin_loaded(self._target_plugin_name):
+                    logger.info(f"✅ 插件 {self._target_plugin_name} 扫描并加载成功")
+                else:
+                    logger.error(f"❌ 插件 {self._target_plugin_name} 扫描后仍未加载")
+            except Exception as scan_e:
+                logger.error(f"❌ 扫描插件目录失败: {scan_e}")
+        except Exception as e:
+            logger.error(f"❌ 操作插件时出错: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    def _sync_plugin_files(self):
+        """将源插件目录同步到 plugins 目录"""
+        import shutil
+
+        source_path = Path(self._target_plugin_path)
+        # plugins 目录是 dev_bridge 所在目录的父目录
+        plugins_dir = Path(__file__).parent.parent
+        target_path = plugins_dir / self._target_plugin_name
+
+        # 如果源插件已经在 plugins 目录下，不需要同步
+        if source_path.parent.resolve() == plugins_dir.resolve():
+            return
+
+        if not source_path.exists():
+            raise FileNotFoundError(f"源插件目录不存在: {source_path}")
+
+        # 删除旧的目标目录
+        if target_path.exists():
+            shutil.rmtree(target_path)
+
+        # 复制新文件
+        shutil.copytree(source_path, target_path)
+
+    async def on_plugin_unload(self):
+        """插件卸载时停止文件监控"""
+        # 停止文件监控
+        if self._file_watcher:
+            self._file_watcher.stop()
+            self._file_watcher = None
+            logger.info("文件监控已停止")
+
+        logger.info("DevBridge 插件已卸载")

mpdt/templates/__init__.py

@@ -0,0 +1,165 @@
+"""
+组件模板索引
+
+此模块导出所有组件模板的获取函数。
+"""
+
+from datetime import datetime
+
+from mpdt.templates.action_template import get_action_template
+from mpdt.templates.adapter_template import get_adapter_template
+from mpdt.templates.chatter_template import get_chatter_template
+from mpdt.templates.event_template import get_event_handler_template
+from mpdt.templates.plus_command_template import get_plus_command_template
+from mpdt.templates.prompt_template import get_prompt_template
+from mpdt.templates.router_template import get_router_template
+from mpdt.templates.tool_template import get_tool_template
+
+# 导出所有模板获取函数
+__all__ = [
+    "get_action_template",
+    "get_tool_template",
+    "get_event_handler_template",
+    "get_adapter_template",
+    "get_prompt_template",
+    "get_plus_command_template",
+    "get_chatter_template",
+    "get_router_template",
+    "get_component_template",
+    "prepare_component_context",
+]
+
+
+def get_component_template(component_type: str) -> str:
+    """
+    根据组件类型获取对应的模板
+
+    Args:
+        component_type: 组件类型 (action, tool, event, adapter, prompt, plus_command, chatter, router)
+
+    Returns:
+        模板字符串
+
+    Raises:
+        ValueError: 不支持的组件类型
+    """
+    template_map = {
+        "action": get_action_template,
+        "tool": get_tool_template,
+        "event": get_event_handler_template,
+        "adapter": get_adapter_template,
+        "prompt": get_prompt_template,
+        "plus_command": get_plus_command_template,
+        "chatter": get_chatter_template,
+        "router": get_router_template,
+    }
+
+    if component_type not in template_map:
+        raise ValueError(
+            f"不支持的组件类型: {component_type}. "
+            f"支持的类型: {', '.join(template_map.keys())}"
+        )
+
+    return template_map[component_type]()
+
+
+def prepare_component_context(
+    component_type: str,
+    component_name: str,
+    plugin_name: str,
+    author: str = "",
+    description: str = "",
+    is_async: bool = False,
+) -> dict[str, str]:
+    """
+    准备组件模板上下文
+
+    Args:
+        component_type: 组件类型 (action, tool, event, adapter, prompt, plus_command,router,chatter)
+        component_name: 组件名称 (snake_case)
+        plugin_name: 插件名称
+        author: 作者
+        description: 描述
+        is_async: 是否异步
+
+    Returns:
+        模板上下文字典
+    """
+    from mpdt.utils.file_ops import to_pascal_case
+
+    # 转换为 PascalCase 并添加类型后缀
+    class_name = to_pascal_case(component_name)
+
+    # 根据组件类型添加合适的后缀
+    suffix_map = {
+        "action": "Action",
+        "tool": "Tool",
+        "event": "EventHandler",
+        "adapter": "Adapter",
+        "prompt": "Prompt",
+        "plus_command": "PlusCommand",
+        "chatter": "Chatter",
+        "router": "Router",
+    }
+
+    suffix = suffix_map.get(component_type, "")
+    if suffix and not class_name.endswith(suffix):
+        class_name = f"{class_name}{suffix}"
+
+    date = datetime.now().strftime("%Y-%m-%d")
+
+    # 基础上下文
+    context = {
+        "component_name": component_name,
+        "class_name": class_name,
+        "plugin_name": plugin_name,
+        "author": author,
+        "description": description or f"{class_name} 组件",
+        "date": date,
+        "async_keyword": "async " if is_async else "",
+        "await_keyword": "await " if is_async else "",
+        "component_type": component_type + "s",  # actions, tools, etc.
+        "module_name": component_name,
+        "method_name": _get_method_name(component_type),
+    }
+
+    # 特定组件类型的额外字段
+    if component_type == "plus_command":
+        context["command_name"] = component_name
+    elif component_type == "tool":
+        context["tool_name"] = component_name
+    elif component_type == "event":
+        context["event_type"] = component_name.replace("_handler", "").replace("_event", "")
+    elif component_type == "adapter":
+        context["adapter_name"] = component_name
+    elif component_type == "prompt":
+        context["prompt_name"] = component_name
+    elif component_type == "chatter":
+        context["chatter_name"] = component_name
+    elif component_type == "router":
+        context["router_name"] = component_name
+
+    return context
+
+
+def _get_method_name(component_type: str) -> str:
+    """
+    根据组件类型获取主要方法名
+
+    Args:
+        component_type: 组件类型
+
+    Returns:
+        方法名
+    """
+    method_map = {
+        "action": "execute",
+        "plus_command": "execute",
+        "tool": "run",
+        "event": "handle",
+        "adapter": "connect",
+        "prompt": "build",
+        "chatter": "chat",
+        "router": "route",
+    }
+    return method_map.get(component_type, "execute")