stigmergy 1.0.68 → 1.0.70

package/src/adapters/iflow/hook_adapter.py

@@ -1,1038 +0,0 @@
-"""
-iFlow CLI Hook适配器 - 基于iFlow CLI官方Hook系统的原生集成
-
-这是TDD驱动的实现，基于test_iflow_adapter.py中的测试用例
-完全符合项目约束条件：
-- 使用iFlow CLI官方Hook机制
-- 不改变CLI启动和使用方式
-- 不依赖包装器
-- 完全无损扩展
-"""
-
-import os
-import json
-import logging
-import asyncio
-import yaml
-from typing import Dict, Any, Optional, List, Callable
-from datetime import datetime
-from pathlib import Path
-from dataclasses import dataclass
-
-from ...core.base_adapter import BaseCrossCLIAdapter, IntentResult
-from ...core.parser import NaturalLanguageParser
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class IFlowHookContext:
-    """iFlow CLI Hook上下文"""
-    command: str = ""
-    args: List[str] = None
-    kwargs: Dict[str, Any] = None
-    user_input: str = ""
-    pipeline_name: str = ""
-    workflow_id: str = ""
-    stage_name: str = ""
-    metadata: Dict[str, Any] = None
-    timestamp: datetime = None
-
-    def __post_init__(self):
-        if self.args is None:
-            self.args = []
-        if self.kwargs is None:
-            self.kwargs = {}
-        if self.metadata is None:
-            self.metadata = {}
-        if self.timestamp is None:
-            self.timestamp = datetime.now()
-
-
-@dataclass
-class IFlowEvent:
-    """iFlow事件对象"""
-    event_type: str
-    data: Dict[str, Any]
-    source: str
-    timestamp: datetime
-    context: Optional[IFlowHookContext] = None
-
-
-class IFlowHookAdapter(BaseCrossCLIAdapter):
-    """
-    iFlow CLI Hook适配器
-
-    通过iFlow CLI官方Hook系统实现跨CLI调用功能。
-    这是完全基于原生机制的无损扩展实现。
-
-    Hook机制:
-    - on_command_start: 命令开始执行时触发
-    - on_command_end: 命令执行完成时触发
-    - on_user_input: 用户输入时触发
-    - on_workflow_stage: 工作流阶段执行时触发
-    - on_pipeline_execute: 流水线执行时触发
-    - on_error: 错误发生时触发
-    """
-
-    def __init__(self, cli_name: str = "iflow"):
-        """
-        初始化iFlow Hook适配器
-
-        Args:
-            cli_name: CLI工具名称，默认为"iflow"
-        """
-        super().__init__(cli_name)
-
-        # Hook相关配置
-        self.hooks_config_file = os.path.expanduser("~/.config/iflow/hooks.yml")
-        self.iflow_config_dir = os.path.expanduser("~/.config/iflow")
-        self.hooks_registered = False
-        self.hook_handlers = {
-            'on_command_start': self.on_command_start,
-            'on_command_end': self.on_command_end,
-            'on_user_input': self.on_user_input,
-            'on_workflow_stage': self.on_workflow_stage,
-            'on_pipeline_execute': self.on_pipeline_execute,
-            'on_error': self.on_error,
-            'on_output_render': self.on_output_render,
-        }
-
-        # 统计信息
-        self.hook_calls_count = 0
-        self.cross_cli_calls_count = 0
-        self.processed_events: List[IFlowEvent] = []
-        self.command_interceptions: List[Dict[str, Any]] = []
-
-        # 配置
-        self.hook_config: Dict[str, Any] = {}
-        self.iflow_version = "unknown"
-
-        # 组件
-        self.parser = NaturalLanguageParser()
-
-        # 事件总线
-        self.event_listeners: Dict[str, List[Callable]] = {}
-
-        # 协作状态
-        self.collaboration_enabled = True
-        self.active_workflows: Dict[str, Dict] = {}
-
-        logger.info("iFlow Hook适配器初始化完成")
-
-    async def initialize(self) -> bool:
-        """
-        初始化适配器
-
-        Returns:
-            bool: 初始化是否成功
-        """
-        try:
-            logger.info("开始初始化iFlow Hook适配器...")
-
-            # 1. 检查iFlow CLI环境
-            if not self._check_iflow_environment():
-                logger.error("iFlow CLI环境检查失败")
-                return False
-
-            # 2. 加载Hook配置
-            if not await self._load_hook_config():
-                logger.error("Hook配置加载失败")
-                return False
-
-            # 3. 注册Hook
-            if not await self._register_iflow_hooks():
-                logger.error("Hook注册失败")
-                return False
-
-            # 4. 初始化事件总线
-            if not await self._initialize_event_bus():
-                logger.error("事件总线初始化失败")
-                return False
-
-            # 5. 创建配置目录
-            await self._ensure_config_directory()
-
-            # 6. 初始化协作系统
-            await self._initialize_collaboration_system()
-
-            self.hooks_registered = True
-            logger.info("iFlow Hook适配器初始化成功")
-            return True
-
-        except Exception as e:
-            logger.error(f"初始化iFlow Hook适配器失败: {e}")
-            self.record_error()
-            return False
-
-    def _check_iflow_environment(self) -> bool:
-        """
-        检查iFlow CLI环境
-
-        Returns:
-            bool: 环境是否可用
-        """
-        try:
-            # 检查iFlow CLI命令是否可用
-            import subprocess
-            result = subprocess.run(
-                ['iflow', '--version'],
-                capture_output=True,
-                text=True,
-                timeout=5
-            )
-
-            if result.returncode == 0:
-                self.iflow_version = result.stdout.strip()
-                logger.info(f"检测到iFlow CLI版本: {self.iflow_version}")
-                return True
-            else:
-                logger.warning("iFlow CLI命令不可用")
-                return False
-
-        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
-            logger.warning(f"iFlow CLI环境检查失败: {e}")
-            # 在开发环境中，即使没有真实的iFlow CLI也返回True
-            return True
-
-    async def _load_hook_config(self) -> bool:
-        """
-        加载Hook配置
-
-        Returns:
-            bool: 加载是否成功
-        """
-        try:
-            # 读取adapter配置
-            config_path = Path(__file__).parent / "config.json"
-            if config_path.exists():
-                with open(config_path, 'r', encoding='utf-8') as f:
-                    adapter_config = json.load(f)
-                self.hook_config = adapter_config.get('hook_config', {})
-
-            # 读取iFlow hooks配置
-            if os.path.exists(self.hooks_config_file):
-                with open(self.hooks_config_file, 'r', encoding='utf-8') as f:
-                    hooks_config = yaml.safe_load(f) or {}
-            else:
-                hooks_config = self._get_default_hook_config()
-                await self._save_hook_config(hooks_config)
-
-            logger.info("Hook配置加载成功")
-            return True
-
-        except Exception as e:
-            logger.error(f"加载Hook配置失败: {e}")
-            return False
-
-    def _get_default_hook_config(self) -> Dict[str, Any]:
-        """获取默认Hook配置"""
-        return {
-            "version": "1.0",
-            "hooks": [],
-            "plugins": [
-                {
-                    "name": "cross-cli-adapter",
-                    "module": "src.adapters.iflow.hook_adapter",
-                    "class": "IFlowHookAdapter",
-                    "enabled": True,
-                    "priority": 100,
-                    "hooks": [
-                        "on_user_input",
-                        "on_command_start",
-                        "on_workflow_stage",
-                        "on_pipeline_execute",
-                        "on_command_end"
-                    ],
-                    "config": {
-                        "cross_cli_enabled": True,
-                        "collaboration_mode": "active",
-                        "timeout": 30,
-                        "error_handling": "continue"
-                    }
-                }
-            ]
-        }
-
-    async def _save_hook_config(self, config: Dict[str, Any]) -> bool:
-        """
-        保存Hook配置
-
-        Args:
-            config: Hook配置
-
-        Returns:
-            bool: 保存是否成功
-        """
-        try:
-            os.makedirs(os.path.dirname(self.hooks_config_file), exist_ok=True)
-
-            with open(self.hooks_config_file, 'w', encoding='utf-8') as f:
-                yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
-
-            logger.info(f"保存Hook配置到: {self.hooks_config_file}")
-            return True
-
-        except Exception as e:
-            logger.error(f"保存Hook配置失败: {e}")
-            return False
-
-    async def _register_iflow_hooks(self) -> bool:
-        """
-        注册Hook到iFlow CLI
-
-        Returns:
-            bool: 注册是否成功
-        """
-        try:
-            # 读取现有hooks配置
-            hooks_config = self._get_default_hook_config()
-            if os.path.exists(self.hooks_config_file):
-                with open(self.hooks_config_file, 'r', encoding='utf-8') as f:
-                    hooks_config = yaml.safe_load(f) or {}
-
-            # 添加我们的Hook插件
-            cross_cli_hook = {
-                "name": "cross-cli-adapter",
-                "module": "src.adapters.iflow.hook_adapter",
-                "class": "IFlowHookAdapter",
-                "enabled": True,
-                "priority": 100,
-                "hooks": list(self.hook_handlers.keys()),
-                "config": self.hook_config
-            }
-
-            # 检查是否已存在
-            plugins = hooks_config.get('plugins', [])
-            hook_exists = any(
-                plugin.get('name') == cross_cli_hook['name']
-                for plugin in plugins
-            )
-
-            if not hook_exists:
-                plugins.append(cross_cli_hook)
-                hooks_config['plugins'] = plugins
-
-                # 保存配置
-                await self._save_hook_config(hooks_config)
-                logger.info(f"注册Hook插件: {cross_cli_hook['name']}")
-            else:
-                logger.info("Hook插件已存在，跳过注册")
-
-            return True
-
-        except Exception as e:
-            logger.error(f"注册Hook失败: {e}")
-            return False
-
-    async def _initialize_event_bus(self) -> bool:
-        """
-        初始化事件总线
-
-        Returns:
-            bool: 初始化是否成功
-        """
-        try:
-            # 初始化事件监听器
-            self.event_listeners = {
-                'cross_cli_detected': [],
-                'workflow_started': [],
-                'workflow_completed': [],
-                'error_occurred': []
-            }
-
-            logger.info("事件总线初始化成功")
-            return True
-
-        except Exception as e:
-            logger.error(f"初始化事件总线失败: {e}")
-            return False
-
-    async def _ensure_config_directory(self) -> None:
-        """确保配置目录存在"""
-        config_dirs = [
-            self.iflow_config_dir,
-            os.path.join(self.iflow_config_dir, "adapters"),
-            os.path.join(self.iflow_config_dir, "hooks"),
-            os.path.join(self.iflow_config_dir, "workflows"),
-            os.path.join(self.iflow_config_dir, "logs")
-        ]
-
-        for config_dir in config_dirs:
-            os.makedirs(config_dir, exist_ok=True)
-
-    async def _initialize_collaboration_system(self) -> None:
-        """初始化协作系统"""
-        self.collaboration_enabled = True
-        self.active_workflows = {}
-        logger.info("协作系统初始化完成")
-
-    # ==================== Hook处理器 ====================
-
-    async def on_user_input(self, context: IFlowHookContext) -> Optional[str]:
-        """
-        用户输入Hook处理函数
-
-        这是核心Hook，用于检测和执行跨CLI调用。
-
-        Args:
-            context: Hook上下文
-
-        Returns:
-            Optional[str]: 处理结果，如果返回None则让iFlow继续正常处理
-        """
-        try:
-            self.hook_calls_count += 1
-            user_input = context.user_input or context.command
-
-            if not user_input:
-                return None
-
-            # 记录事件
-            event = IFlowEvent(
-                event_type="user_input",
-                data={"input": user_input, "metadata": context.metadata},
-                source="iflow_hook_adapter",
-                timestamp=datetime.now(),
-                context=context
-            )
-            self.processed_events.append(event)
-
-            # 1. 检测是否为跨CLI调用意图
-            intent = self.parser.parse_intent(user_input, "iflow")
-
-            if not intent.is_cross_cli:
-                # 不是跨CLI调用，让iFlow继续处理
-                return None
-
-            # 2. 避免自我调用
-            if intent.target_cli == self.cli_name:
-                # 目标是iFlow自己，让iFlow处理
-                return None
-
-            # 3. 触发跨CLI检测事件
-            await self._emit_event("cross_cli_detected", {
-                "intent": intent,
-                "context": context
-            })
-
-            # 4. 执行跨CLI调用
-            result = await self._execute_cross_cli_call(
-                intent.target_cli,
-                intent.task,
-                context
-            )
-
-            if result:
-                self.cross_cli_calls_count += 1
-                return result
-
-            return None
-
-        except Exception as e:
-            logger.error(f"用户输入Hook处理失败: {e}")
-            self.record_error()
-            return None
-
-    async def on_command_start(self, context: IFlowHookContext) -> Optional[str]:
-        """
-        命令开始Hook处理函数
-
-        Args:
-            context: Hook上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        try:
-            self.hook_calls_count += 1
-
-            # 记录命令拦截
-            interception = {
-                'type': 'command_start',
-                'command': context.command,
-                'args': context.args,
-                'timestamp': datetime.now().isoformat()
-            }
-            self.command_interceptions.append(interception)
-
-            logger.debug(f"命令开始: {context.command}")
-            return None
-
-        except Exception as e:
-            logger.error(f"命令开始Hook处理失败: {e}")
-            return None
-
-    async def on_command_end(self, context: IFlowHookContext, result: Any) -> Optional[str]:
-        """
-        命令结束Hook处理函数
-
-        Args:
-            context: Hook上下文
-            result: 命令执行结果
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        try:
-            self.hook_calls_count += 1
-
-            # 记录命令完成
-            completion = {
-                'type': 'command_end',
-                'command': context.command,
-                'result_length': len(str(result)) if result else 0,
-                'timestamp': datetime.now().isoformat()
-            }
-            self.command_interceptions.append(completion)
-
-            logger.debug(f"命令结束: {context.command}")
-            return None
-
-        except Exception as e:
-            logger.error(f"命令结束Hook处理失败: {e}")
-            return None
-
-    async def on_workflow_stage(self, context: IFlowHookContext, stage_data: Dict[str, Any]) -> Optional[str]:
-        """
-        工作流阶段Hook处理函数
-
-        Args:
-            context: Hook上下文
-            stage_data: 阶段数据
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        try:
-            self.hook_calls_count += 1
-
-            # 更新活动工作流状态
-            if context.workflow_id:
-                self.active_workflows[context.workflow_id] = {
-                    'stage': context.stage_name,
-                    'timestamp': datetime.now().isoformat(),
-                    'data': stage_data
-                }
-
-            # 检测跨CLI协作机会
-            collaboration_result = await self._check_collaboration_opportunity(context, stage_data)
-            if collaboration_result:
-                return collaboration_result
-
-            logger.debug(f"工作流阶段: {context.stage_name}")
-            return None
-
-        except Exception as e:
-            logger.error(f"工作流阶段Hook处理失败: {e}")
-            return None
-
-    async def on_pipeline_execute(self, context: IFlowHookContext, pipeline_config: Dict[str, Any]) -> Optional[str]:
-        """
-        流水线执行Hook处理函数
-
-        Args:
-            context: Hook上下文
-            pipeline_config: 流水线配置
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        try:
-            self.hook_calls_count += 1
-
-            # 触发流水线执行事件
-            await self._emit_event("pipeline_executing", {
-                "context": context,
-                "pipeline_config": pipeline_config
-            })
-
-            logger.debug(f"流水线执行: {context.pipeline_name}")
-            return None
-
-        except Exception as e:
-            logger.error(f"流水线执行Hook处理失败: {e}")
-            return None
-
-    async def on_error(self, context: IFlowHookContext, error: Exception) -> Optional[str]:
-        """
-        错误Hook处理函数
-
-        Args:
-            context: Hook上下文
-            error: 错误信息
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        try:
-            self.hook_calls_count += 1
-
-            # 记录错误事件
-            error_event = IFlowEvent(
-                event_type="error",
-                data={
-                    "error": str(error),
-                    "error_type": type(error).__name__,
-                    "context": context.__dict__
-                },
-                source="iflow_hook_adapter",
-                timestamp=datetime.now()
-            )
-            self.processed_events.append(error_event)
-
-            # 触发错误事件
-            await self._emit_event("error_occurred", {
-                "context": context,
-                "error": error
-            })
-
-            logger.error(f"iFlow Hook错误: {error}")
-            return None
-
-        except Exception as e:
-            logger.error(f"错误Hook处理失败: {e}")
-            return None
-
-    async def on_output_render(self, context: IFlowHookContext, output: str) -> Optional[str]:
-        """
-        输出渲染Hook处理函数
-
-        Args:
-            context: Hook上下文
-            output: 原始输出
-
-        Returns:
-            Optional[str]: 处理后的输出
-        """
-        try:
-            self.hook_calls_count += 1
-
-            # 可以在这里对输出进行后处理
-            # 例如添加跨CLI调用的元信息
-
-            return output
-
-        except Exception as e:
-            logger.error(f"输出渲染Hook处理失败: {e}")
-            return output
-
-    # ==================== 跨CLI功能 ====================
-
-    async def _execute_cross_cli_call(
-        self,
-        target_cli: str,
-        task: str,
-        context: IFlowHookContext
-    ) -> Optional[str]:
-        """
-        执行跨CLI调用
-
-        Args:
-            target_cli: 目标CLI工具
-            task: 要执行的任务
-            context: Hook上下文
-
-        Returns:
-            Optional[str]: 执行结果
-        """
-        try:
-            logger.info(f"执行跨CLI调用: {target_cli} -> {task}")
-
-            # 获取目标CLI适配器
-            from ...core.base_adapter import get_cross_cli_adapter
-            target_adapter = get_cross_cli_adapter(target_cli)
-
-            if not target_adapter:
-                logger.warning(f"目标CLI适配器不可用: {target_cli}")
-                return self._format_error_result(
-                    target_cli,
-                    task,
-                    f"目标CLI工具 '{target_cli}' 不可用或未安装"
-                )
-
-            if not target_adapter.is_available():
-                logger.warning(f"目标CLI工具不可用: {target_cli}")
-                return self._format_error_result(
-                    target_cli,
-                    task,
-                    f"目标CLI工具 '{target_cli}' 当前不可用"
-                )
-
-            # 构建执行上下文
-            execution_context = {
-                'source_cli': self.cli_name,
-                'target_cli': target_cli,
-                'original_task': task,
-                'hook_context': context.__dict__,
-                'iflow_context': {
-                    'command': context.command,
-                    'args': context.args,
-                    'pipeline_name': context.pipeline_name,
-                    'workflow_id': context.workflow_id
-                },
-                'timestamp': datetime.now().isoformat()
-            }
-
-            # 执行任务
-            result = await target_adapter.execute_task(task, execution_context)
-
-            # 记录成功的跨CLI调用
-            self.processed_requests.append({
-                'type': 'cross_cli_execution',
-                'target_cli': target_cli,
-                'task': task,
-                'success': True,
-                'result_length': len(result),
-                'timestamp': datetime.now().isoformat(),
-                'iflow_workflow_id': context.workflow_id
-            })
-
-            # 格式化结果
-            formatted_result = self._format_success_result(target_cli, task, result, context)
-
-            logger.info(f"跨CLI调用成功: {target_cli}")
-            return formatted_result
-
-        except Exception as e:
-            logger.error(f"跨CLI调用失败: {target_cli}, {e}")
-            self.record_error()
-
-            self.processed_requests.append({
-                'type': 'cross_cli_execution',
-                'target_cli': target_cli,
-                'task': task,
-                'success': False,
-                'error': str(e),
-                'timestamp': datetime.now().isoformat(),
-                'iflow_workflow_id': context.workflow_id
-            })
-
-            return self._format_error_result(target_cli, task, str(e))
-
-    async def _check_collaboration_opportunity(
-        self,
-        context: IFlowHookContext,
-        stage_data: Dict[str, Any]
-    ) -> Optional[str]:
-        """
-        检查协作机会
-
-        Args:
-            context: Hook上下文
-            stage_data: 阶段数据
-
-        Returns:
-            Optional[str]: 协作结果
-        """
-        try:
-            if not self.collaboration_enabled:
-                return None
-
-            # 检查是否有协作机会
-            # 这里可以基于PROJECT_SPEC.json或其他协作机制
-
-            # 简单示例：如果阶段数据包含特定标识，触发协作
-            if stage_data.get('collaboration_request'):
-                target_cli = stage_data.get('target_cli')
-                collaboration_task = stage_data.get('task', '')
-
-                if target_cli and target_cli != self.cli_name:
-                    return await self._execute_cross_cli_call(
-                        target_cli,
-                        collaboration_task,
-                        context
-                    )
-
-            return None
-
-        except Exception as e:
-            logger.error(f"检查协作机会失败: {e}")
-            return None
-
-    # ==================== 事件系统 ====================
-
-    async def _emit_event(self, event_type: str, data: Dict[str, Any]) -> None:
-        """
-        触发事件
-
-        Args:
-            event_type: 事件类型
-            data: 事件数据
-        """
-        try:
-            listeners = self.event_listeners.get(event_type, [])
-
-            for listener in listeners:
-                try:
-                    if asyncio.iscoroutinefunction(listener):
-                        await listener(data)
-                    else:
-                        listener(data)
-                except Exception as e:
-                    logger.error(f"事件监听器执行失败: {e}")
-
-        except Exception as e:
-            logger.error(f"触发事件失败: {e}")
-
-    def add_event_listener(self, event_type: str, listener: Callable) -> None:
-        """
-        添加事件监听器
-
-        Args:
-            event_type: 事件类型
-            listener: 监听器函数
-        """
-        if event_type not in self.event_listeners:
-            self.event_listeners[event_type] = []
-        self.event_listeners[event_type].append(listener)
-
-    # ==================== 结果格式化 ====================
-
-    def _format_success_result(
-        self,
-        target_cli: str,
-        task: str,
-        result: str,
-        context: IFlowHookContext
-    ) -> str:
-        """
-        格式化成功的跨CLI调用结果
-
-        Args:
-            target_cli: 目标CLI工具
-            task: 原始任务
-            result: 执行结果
-            context: Hook上下文
-
-        Returns:
-            str: 格式化的结果
-        """
-        workflow_info = ""
-        if context.workflow_id:
-            workflow_info = f"\n**工作流ID**: {context.workflow_id}"
-        if context.stage_name:
-            workflow_info += f"\n**当前阶段**: {context.stage_name}"
-
-        return f"""## 🔗 跨CLI调用结果 (iFlow Hook)
-
-**源工具**: iFlow CLI
-**目标工具**: {target_cli.upper()}
-**原始任务**: {task}{workflow_info}
-**执行时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
----
-
-{result}
-
----
-
-*此结果由跨CLI集成系统通过iFlow CLI Hook提供*"""
-
-    def _format_error_result(
-        self,
-        target_cli: str,
-        task: str,
-        error_message: str
-    ) -> str:
-        """
-        格式化错误的跨CLI调用结果
-
-        Args:
-            target_cli: 目标CLI工具
-            task: 原始任务
-            error_message: 错误信息
-
-        Returns:
-            str: 格式化的错误结果
-        """
-        return f"""## ❌ 跨CLI调用失败
-
-**源工具**: iFlow CLI
-**目标工具**: {target_cli.upper()}
-**原始任务**: {task}
-**错误信息**: {error_message}
-**失败时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-请检查目标CLI工具是否正确安装和配置。
-
----
-
-*此错误由跨CLI集成系统报告*"""
-
-    # ==================== 基础接口实现 ====================
-
-    def is_available(self) -> bool:
-        """
-        检查适配器是否可用
-
-        Returns:
-            bool: 是否可用
-        """
-        return (
-            self.hooks_registered and
-            self._check_iflow_environment() and
-            len(self.hook_handlers) > 0
-        )
-
-    async def execute_task(self, task: str, context: Dict[str, Any]) -> str:
-        """
-        执行跨CLI任务 - iFlow适配器的具体实现
-
-        Args:
-            task: 要执行的任务描述
-            context: 执行上下文信息
-
-        Returns:
-            str: 任务执行结果
-        """
-        try:
-            # 创建Hook上下文
-            hook_context = IFlowHookContext(
-                command=task,
-                user_input=task,
-                metadata=context.get('metadata', {}),
-                workflow_id=context.get('workflow_id', ''),
-                stage_name=context.get('stage_name', 'execution')
-            )
-
-            # 检查是否为跨CLI调用
-            intent = self.parser.parse_intent(task, "iflow")
-            if intent.is_cross_cli and intent.target_cli != self.cli_name:
-                # 执行跨CLI调用
-                result = await self._execute_cross_cli_call(
-                    intent.target_cli,
-                    intent.task,
-                    hook_context
-                )
-                return result or f"iFlow Hook适配器处理了跨CLI任务: {task}"
-            else:
-                # 本地iFlow任务处理
-                return f"iFlow Hook适配器本地处理: {task}"
-
-        except Exception as e:
-            logger.error(f"执行任务失败: {task}, 错误: {e}")
-            self.record_error()
-            return f"任务执行失败: {str(e)}"
-
-    async def health_check(self) -> Dict[str, Any]:
-        """
-        健康检查
-
-        Returns:
-            Dict[str, Any]: 健康状态
-        """
-        base_health = await super().health_check()
-
-        iflow_health = {
-            'hooks_registered': self.hooks_registered,
-            'hook_calls_count': self.hook_calls_count,
-            'cross_cli_calls_count': self.cross_cli_calls_count,
-            'processed_events_count': len(self.processed_events),
-            'command_interceptions_count': len(self.command_interceptions),
-            'active_workflows_count': len(self.active_workflows),
-            'hooks_config_file': self.hooks_config_file,
-            'hooks_config_exists': os.path.exists(self.hooks_config_file),
-            'iflow_version': self.iflow_version,
-            'collaboration_enabled': self.collaboration_enabled,
-            'event_listeners_count': sum(len(listeners) for listeners in self.event_listeners.values())
-        }
-
-        # 检查环境
-        try:
-            iflow_health['iflow_environment'] = self._check_iflow_environment()
-        except Exception as e:
-            iflow_health['iflow_environment_error'] = str(e)
-
-        # 合并基础健康信息
-        base_health.update(iflow_health)
-        return base_health
-
-    def get_statistics(self) -> Dict[str, Any]:
-        """
-        获取适配器统计信息
-
-        Returns:
-            Dict[str, Any]: 统计信息
-        """
-        base_stats = super().get_statistics()
-
-        iflow_stats = {
-            'hooks_registered': self.hooks_registered,
-            'hook_calls_count': self.hook_calls_count,
-            'cross_cli_calls_count': self.cross_cli_calls_count,
-            'processed_events_count': len(self.processed_events),
-            'command_interceptions_count': len(self.command_interceptions),
-            'active_workflows_count': len(self.active_workflows),
-            'supported_hooks': list(self.hook_handlers.keys()),
-            'event_types': list(self.event_listeners.keys()),
-            'collaboration_enabled': self.collaboration_enabled,
-            'iflow_version': self.iflow_version
-        }
-
-        base_stats.update(iflow_stats)
-        return base_stats
-
-    async def cleanup(self) -> bool:
-        """
-        清理适配器资源
-
-        Returns:
-            bool: 清理是否成功
-        """
-        try:
-            # 清理统计信息
-            self.processed_events.clear()
-            self.command_interceptions.clear()
-            self.active_workflows.clear()
-
-            # 清理事件监听器
-            self.event_listeners.clear()
-
-            logger.info("iFlow Hook适配器清理完成")
-            return True
-
-        except Exception as e:
-            logger.error(f"清理iFlow Hook适配器失败: {e}")
-            return False
-
-
-# 创建全局适配器实例
-_global_adapter: Optional[IFlowHookAdapter] = None
-
-
-def get_iflow_hook_adapter() -> IFlowHookAdapter:
-    """
-    获取iFlow Hook适配器实例
-
-    Returns:
-        IFlowHookAdapter: 适配器实例
-    """
-    global _global_adapter
-    if _global_adapter is None:
-        _global_adapter = IFlowHookAdapter()
-        # 异步初始化需要在调用时进行
-    return _global_adapter
-
-
-# 便捷函数
-async def initialize_iflow_adapter() -> bool:
-    """
-    初始化iFlow Hook适配器
-
-    Returns:
-        bool: 初始化是否成功
-    """
-    adapter = get_iflow_hook_adapter()
-    return await adapter.initialize()
-
-
-def is_iflow_adapter_available() -> bool:
-    """
-    检查iFlow Hook适配器是否可用
-
-    Returns:
-        bool: 是否可用
-    """
-    adapter = get_iflow_hook_adapter()
-    return adapter.is_available()