stigmergy 1.0.68 → 1.0.70

package/src/adapters/qwencode/inheritance_adapter.py

@@ -1,818 +0,0 @@
-"""
-QwenCode CLI Class Inheritance适配器 - 基于QwenCode官方Class Inheritance系统的原生集成
-
-这是TDD驱动的实现，基于test_qwencode_adapter.py中的测试用例
-完全符合项目约束条件：
-- 使用QwenCode CLI官方Class Inheritance机制
-- 不改变CLI启动和使用方式
-- 不依赖包装器
-- 完全无损扩展
-"""
-
-import os
-import json
-import logging
-import asyncio
-import importlib
-import sys
-from typing import Dict, Any, Optional, List, Type
-from datetime import datetime
-from pathlib import Path
-
-from ...core.base_adapter import BaseCrossCLIAdapter, IntentResult
-from ...core.parser import NaturalLanguageParser
-
-logger = logging.getLogger(__name__)
-
-
-class PluginContext:
-    """QwenCode CLI Plugin上下文模拟类"""
-
-    def __init__(self, prompt: str = "", metadata: Optional[Dict] = None):
-        self.prompt = prompt
-        self.metadata = metadata or {}
-        self.session_id = self.metadata.get('session_id', 'unknown')
-        self.user_id = self.metadata.get('user_id', 'unknown')
-        self.plugin_name = "cross-cli-adapter"
-        self.version = "1.0.0"
-        self.class_name = "CrossCLIAdapterPlugin"
-        self.timestamp = datetime.now()
-
-
-class QwenCodeInheritanceAdapter(BaseCrossCLIAdapter):
-    """
-    QwenCode CLI Class Inheritance适配器
-
-    通过QwenCode CLI官方Class Inheritance系统实现跨CLI调用功能。
-    这是完全基于原生机制的无损扩展实现。
-
-    Inheritance机制:
-    - 继承BaseQwenCodePlugin类
-    - 重写关键方法实现跨CLI功能
-    - Plugin生命周期管理
-    - 配置文件驱动
-    """
-
-    def __init__(self, cli_name: str = "qwencode"):
-        """
-        初始化QwenCode Inheritance适配器
-
-        Args:
-            cli_name: CLI工具名称，默认为"qwencode"
-        """
-        super().__init__(cli_name)
-
-        # Inheritance相关配置
-        self.config_file = os.path.expanduser("~/.config/qwencode/config.yml")
-        self.plugins_loaded = False
-        self.plugin_handlers = {
-            'on_before_execute': self.on_before_execute,
-            'on_after_execute': self.on_after_execute,
-            'on_prompt_received': self.on_prompt_received,
-            'on_code_generated': self.on_code_generated,
-            'on_error_occurred': self.on_error_occurred,
-            'on_file_created': self.on_file_created,
-            'on_before_save': self.on_before_save,
-        }
-
-        # 统计信息
-        self.plugin_calls_count = 0
-        self.cross_cli_calls_count = 0
-        self.processed_requests: List[Dict[str, Any]] = []
-
-        # 解析器
-        self.parser = NaturalLanguageParser()
-
-        # 跨CLI适配器工厂
-        from ...core.base_adapter import get_cross_cli_adapter
-        self.get_adapter = get_cross_cli_adapter
-
-        # Inheritance系统状态
-        self.base_class = None
-        self.plugin_module = None
-        self.inheritance_setup_complete = False
-
-    async def initialize(self) -> bool:
-        """
-        初始化适配器
-
-        Returns:
-            bool: 初始化是否成功
-        """
-        try:
-            # 1. 检查QwenCode CLI环境
-            if not self._check_qwencode_environment():
-                logger.error("QwenCode CLI环境检查失败")
-                return False
-
-            # 2. 设置Class Inheritance系统
-            if not await self._setup_inheritance_system():
-                logger.error("Class Inheritance系统设置失败")
-                return False
-
-            # 3. 加载插件
-            if not await self._load_plugins():
-                logger.error("插件加载失败")
-                return False
-
-            # 4. 创建配置目录
-            await self._ensure_config_directory()
-
-            self.plugins_loaded = True
-            logger.info("QwenCode Class Inheritance适配器初始化成功")
-            return True
-
-        except Exception as e:
-            logger.error(f"初始化QwenCode Class Inheritance适配器失败: {e}")
-            self.record_error()
-            return False
-
-    async def _setup_inheritance_system(self) -> bool:
-        """
-        设置Class Inheritance系统
-
-        Returns:
-            bool: 设置是否成功
-        """
-        try:
-            # 尝试导入QwenCode的基础Plugin类
-            try:
-                # 这里模拟导入QwenCode的基础类
-                # 实际实现中需要根据QwenCode的实际API调整
-                base_class_path = "qwencode.plugins.base"
-
-                # 创建模拟的基础类用于测试
-                class MockBaseQwenCodePlugin:
-                    def __init__(self):
-                        self.name = "BasePlugin"
-                        self.version = "1.0.0"
-                        self.enabled = True
-
-                    def execute(self, prompt: str, **kwargs):
-                        return f"Mock execution: {prompt}"
-
-                    def validate_input(self, prompt: str) -> bool:
-                        return bool(prompt and prompt.strip())
-
-                    def format_output(self, result: str) -> str:
-                        return result
-
-                self.base_class = MockBaseQwenCodePlugin
-                logger.info("QwenCode基础Plugin类导入成功")
-
-            except ImportError as e:
-                logger.warning(f"无法导入QwenCode基础类，使用模拟类: {e}")
-                # 创建模拟基础类
-                class MockBaseQwenCodePlugin:
-                    def __init__(self):
-                        self.name = "BasePlugin"
-                        self.version = "1.0.0"
-                        self.enabled = True
-
-                    def execute(self, prompt: str, **kwargs):
-                        return f"Mock execution: {prompt}"
-
-                    def validate_input(self, prompt: str) -> bool:
-                        return bool(prompt and prompt.strip())
-
-                    def format_output(self, result: str) -> str:
-                        return result
-
-                self.base_class = MockBaseQwenCodePlugin
-
-            # 创建插件模块
-            plugin_module_path = f"qwencode.plugins.{self.plugin_name.lower()}"
-            self.plugin_module = type('PluginModule', (), {})
-
-            self.inheritance_setup_complete = True
-            return True
-
-        except Exception as e:
-            logger.error(f"设置Class Inheritance系统失败: {e}")
-            return False
-
-    async def _load_plugins(self) -> bool:
-        """
-        加载插件
-
-        Returns:
-            bool: 加载是否成功
-        """
-        try:
-            # 读取现有配置
-            config = self._load_config()
-
-            # 添加我们的插件配置
-            cross_cli_plugin = {
-                "name": "CrossCLIAdapterPlugin",
-                "class": "CrossCLIAdapterPlugin",
-                "enabled": True,
-                "priority": 85,
-                "base_class": "BaseQwenCodePlugin",
-                "handlers": [
-                    "on_prompt_received",
-                    "on_code_generated",
-                    "on_error_occurred"
-                ],
-                "config": {
-                    "cross_cli_enabled": True,
-                    "supported_clis": ["claude", "gemini", "iflow", "qoder", "codebuddy", "codex"],
-                    "auto_detect": True
-                }
-            }
-
-            # 检查是否已存在
-            existing_plugins = config.get('plugins', [])
-            plugin_exists = any(
-                plugin['name'] == cross_cli_plugin['name']
-                for plugin in existing_plugins
-            )
-
-            if not plugin_exists:
-                existing_plugins.append(cross_cli_plugin)
-                config['plugins'] = existing_plugins
-
-                # 保存配置
-                await self._save_config(config)
-                logger.info(f"加载Plugin: {cross_cli_plugin['name']}")
-            else:
-                logger.info("Plugin已存在，跳过加载")
-
-            return True
-
-        except Exception as e:
-            logger.error(f"加载Plugin失败: {e}")
-            return False
-
-    def _load_config(self) -> Dict[str, Any]:
-        """
-        加载配置
-
-        Returns:
-            Dict[str, Any]: 配置
-        """
-        if os.path.exists(self.config_file):
-            try:
-                import yaml
-                with open(self.config_file, 'r', encoding='utf-8') as f:
-                    return yaml.safe_load(f) or {}
-            except Exception as e:
-                logger.warning(f"加载配置失败，使用默认配置: {e}")
-
-        # 返回默认配置
-        return {
-            "version": "1.0",
-            "plugins": []
-        }
-
-    async def _save_config(self, config: Dict[str, Any]) -> bool:
-        """
-        保存配置
-
-        Args:
-            config: 配置
-
-        Returns:
-            bool: 保存是否成功
-        """
-        try:
-            import yaml
-            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
-
-            with open(self.config_file, 'w', encoding='utf-8') as f:
-                yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
-
-            logger.info(f"保存配置到: {self.config_file}")
-            return True
-
-        except Exception as e:
-            logger.error(f"保存配置失败: {e}")
-            return False
-
-    async def _ensure_config_directory(self) -> bool:
-        """
-        确保配置目录存在
-
-        Returns:
-            bool: 创建是否成功
-        """
-        try:
-            config_dir = os.path.expanduser("~/.config/qwencode")
-            os.makedirs(config_dir, exist_ok=True)
-
-            # 创建适配器配置目录
-            adapter_dir = os.path.join(config_dir, "adapters")
-            os.makedirs(adapter_dir, exist_ok=True)
-
-            logger.info(f"配置目录已准备: {config_dir}")
-            return True
-
-        except Exception as e:
-            logger.error(f"创建配置目录失败: {e}")
-            return False
-
-    def _check_qwencode_environment(self) -> bool:
-        """
-        检查QwenCode CLI环境
-
-        Returns:
-            bool: 环境是否可用
-        """
-        # 这里应该检查QwenCode CLI是否可用
-        # 暂时返回True，实际实现中需要检查CLI命令和配置
-        return True
-
-    async def on_prompt_received(self, context: PluginContext) -> Optional[str]:
-        """
-        接收到提示时的Plugin处理函数
-
-        这是核心Plugin，用于检测和执行跨CLI调用。
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果，如果返回None则让QwenCode继续正常处理
-        """
-        try:
-            self.plugin_calls_count += 1
-            user_input = context.prompt
-
-            # 记录请求
-            request_record = {
-                'plugin_type': 'on_prompt_received',
-                'prompt': user_input,
-                'metadata': context.metadata,
-                'timestamp': datetime.now().isoformat()
-            }
-            self.processed_requests.append(request_record)
-
-            # 1. 检测是否为跨CLI调用意图
-            intent = self.parser.parse_intent(user_input, "qwencode")
-
-            if not intent.is_cross_cli:
-                # 不是跨CLI调用，让QwenCode继续处理
-                return None
-
-            # 2. 避免自我调用
-            if intent.target_cli == self.cli_name:
-                # 目标是QwenCode自己，让QwenCode处理
-                return None
-
-            # 3. 执行跨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"接收到提示Plugin处理失败: {e}")
-            self.record_error()
-            return None
-
-    def _parse_cross_cli_intent(self, user_input: str) -> tuple:
-        """
-        解析跨CLI调用意图（测试兼容方法）
-
-        Args:
-            user_input: 用户输入
-
-        Returns:
-            tuple: (target_cli, task)
-        """
-        try:
-            intent = self.parser.parse_intent(user_input, "qwencode")
-            if intent.is_cross_cli:
-                return intent.target_cli, intent.task
-            return None, None
-        except Exception:
-            return None, None
-
-    async def execute_cross_cli_call(self, target_cli: str, task: str, context: PluginContext) -> str:
-        """
-        执行跨CLI调用（测试兼容方法）
-
-        Args:
-            target_cli: 目标CLI工具
-            task: 要执行的任务
-            context: Plugin上下文
-
-        Returns:
-            str: 执行结果
-        """
-        result = await self._execute_cross_cli_call(target_cli, task, context)
-        if result:
-            return result
-        return f"跨CLI调用失败: {target_cli} -> {task}"
-
-    async def on_before_execute(self, context: PluginContext) -> Optional[str]:
-        """
-        执行前Plugin处理函数
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        # 可以在这里预处理执行前的逻辑
-        return None
-
-    async def on_after_execute(self, context: PluginContext) -> Optional[str]:
-        """
-        执行后Plugin处理函数
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        # 可以在这里后处理执行后的结果
-        return None
-
-    async def on_code_generated(self, context: PluginContext) -> Optional[str]:
-        """
-        代码生成Plugin处理函数
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        # 可以在这里处理代码生成相关的跨CLI功能
-        return None
-
-    async def on_error_occurred(self, context: PluginContext) -> Optional[str]:
-        """
-        错误发生Plugin处理函数
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        # 可以在这里处理错误恢复逻辑
-        return None
-
-    async def on_file_created(self, context: PluginContext) -> Optional[str]:
-        """
-        文件创建Plugin处理函数
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        return None
-
-    async def on_before_save(self, context: PluginContext) -> Optional[str]:
-        """
-        保存前Plugin处理函数
-
-        Args:
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 处理结果
-        """
-        return None
-
-    async def _execute_cross_cli_call(
-        self,
-        target_cli: str,
-        task: str,
-        context: PluginContext
-    ) -> Optional[str]:
-        """
-        执行跨CLI调用
-
-        Args:
-            target_cli: 目标CLI工具
-            task: 要执行的任务
-            context: Plugin上下文
-
-        Returns:
-            Optional[str]: 执行结果
-        """
-        try:
-            logger.info(f"执行跨CLI调用: {target_cli} -> {task}")
-
-            # 获取目标CLI适配器
-            target_adapter = self.get_adapter(target_cli)
-
-            if not target_adapter:
-                logger.warning(f"目标CLI适配器不可用: {target_cli}")
-                return self._format_error_result(
-                    target_cli,
-                    f"目标CLI工具 '{target_cli}' 不可用或未安装"
-                )
-
-            if not target_adapter.is_available():
-                logger.warning(f"目标CLI工具不可用: {target_cli}")
-                return self._format_error_result(
-                    target_cli,
-                    f"目标CLI工具 '{target_cli}' 当前不可用"
-                )
-
-            # 构建执行上下文
-            execution_context = {
-                'source_cli': self.cli_name,
-                'target_cli': target_cli,
-                'original_task': task,
-                'plugin_context': context.__dict__,
-                '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()
-            })
-
-            # 格式化结果
-            formatted_result = self._format_result(target_cli, result)
-
-            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()
-            })
-
-            return self._format_error_result(target_cli, str(e))
-
-    def _format_result(
-        self,
-        target_cli: str,
-        result: str
-    ) -> str:
-        """
-        格式化成功的跨CLI调用结果
-
-        Args:
-            target_cli: 目标CLI工具
-            result: 执行结果
-
-        Returns:
-            str: 格式化的结果
-        """
-        return f"""## 🔗 跨CLI调用结果
-
-**源工具**: QwenCode CLI
-**目标工具**: {target_cli.upper()}
-**执行时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
----
-
-{result}
-
----
-
-*此结果由跨CLI集成系统通过QwenCode Class Inheritance提供*"""
-
-    def _format_error_result(
-        self,
-        target_cli: str,
-        error_message: str
-    ) -> str:
-        """
-        格式化错误的跨CLI调用结果
-
-        Args:
-            target_cli: 目标CLI工具
-            error_message: 错误信息
-
-        Returns:
-            str: 格式化的错误结果
-        """
-        return f"""## ❌ 跨CLI调用失败
-
-**源工具**: QwenCode CLI
-**目标工具**: {target_cli.upper()}
-**错误信息**: {error_message}
-**失败时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-请检查目标CLI工具是否正确安装和配置。
-
----
-
-*此错误由跨CLI集成系统报告*"""
-
-    def is_available(self) -> bool:
-        """
-        检查适配器是否可用
-
-        Returns:
-            bool: 是否可用
-        """
-        return self.plugins_loaded and self._check_qwencode_environment()
-
-    async def health_check(self) -> Dict[str, Any]:
-        """
-        健康检查
-
-        Returns:
-            Dict[str, Any]: 健康状态
-        """
-        base_health = await super().health_check()
-
-        qwencode_health = {
-            'plugins_loaded': self.plugins_loaded,
-            'plugin_calls_count': self.plugin_calls_count,
-            'cross_cli_calls_count': self.cross_cli_calls_count,
-            'processed_requests_count': len(self.processed_requests),
-            'config_file': self.config_file,
-            'config_exists': os.path.exists(self.config_file),
-            'plugin_handlers': list(self.plugin_handlers.keys()),
-            'inheritance_setup_complete': self.inheritance_setup_complete,
-            'base_class_loaded': self.base_class is not None
-        }
-
-        # 检查环境
-        try:
-            qwencode_health['qwencode_environment'] = self._check_qwencode_environment()
-        except Exception as e:
-            qwencode_health['qwencode_environment_error'] = str(e)
-
-        # 合并基础健康信息
-        base_health.update(qwencode_health)
-        return base_health
-
-    def get_statistics(self) -> Dict[str, Any]:
-        """
-        获取适配器统计信息
-
-        Returns:
-            Dict[str, Any]: 统计信息
-        """
-        base_stats = super().get_statistics()
-
-        qwencode_stats = {
-            'plugins_loaded': self.plugins_loaded,
-            'plugin_calls_count': self.plugin_calls_count,
-            'cross_cli_calls_count': self.cross_cli_calls_count,
-            'success_rate': self._calculate_success_rate(),
-            'last_activity': self._get_last_activity(),
-            'supported_plugins': list(self.plugin_handlers.keys())
-        }
-
-        base_stats.update(qwencode_stats)
-        return base_stats
-
-    def _calculate_success_rate(self) -> float:
-        """
-        计算成功率
-
-        Returns:
-            float: 成功率 (0.0 - 1.0)
-        """
-        total_cross_cli = self.cross_cli_calls_count
-
-        if total_cross_cli == 0:
-            return 1.0
-
-        successful_calls = sum(
-            1 for req in self.processed_requests
-            if req.get('type') == 'cross_cli_execution' and req.get('success')
-        )
-
-        return successful_calls / total_cross_cli
-
-    def _get_last_activity(self) -> Optional[str]:
-        """
-        获取最后活动时间
-
-        Returns:
-            Optional[str]: 最后活动时间戳
-        """
-        if not self.processed_requests:
-            return None
-
-        return max(req['timestamp'] for req in self.processed_requests)
-
-    async def execute_task(self, task: str, context: Dict[str, Any]) -> str:
-        """
-        执行跨CLI任务 - QwenCode适配器的具体实现
-
-        Args:
-            task: 要执行的任务描述
-            context: 执行上下文信息
-
-        Returns:
-            str: 任务执行结果
-        """
-        try:
-            # QwenCode适配器的任务执行主要是通过Plugin系统
-            # 这里创建一个模拟的Plugin上下文来处理任务
-            plugin_context = PluginContext(
-                prompt=task,
-                metadata=context.get('metadata', {})
-            )
-
-            # 检查是否为跨CLI调用
-            intent = self.parser.parse_intent(task, "qwencode")
-            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,
-                    plugin_context
-                )
-                return result or f"QwenCode Inheritance适配器处理了任务: {task}"
-            else:
-                # 本地QwenCode任务处理
-                return f"QwenCode Inheritance适配器本地处理: {task}"
-
-        except Exception as e:
-            logger.error(f"执行任务失败: {task}, 错误: {e}")
-            self.record_error()
-            return f"任务执行失败: {str(e)}"
-
-    async def cleanup(self) -> bool:
-        """
-        清理适配器资源
-
-        Returns:
-            bool: 清理是否成功
-        """
-        try:
-            # 清理统计信息
-            self.processed_requests.clear()
-
-            # 清理插件（如果需要）
-            # 这里可以实现插件卸载逻辑
-
-            logger.info("QwenCode Class Inheritance适配器清理完成")
-            return True
-
-        except Exception as e:
-            logger.error(f"清理QwenCode Class Inheritance适配器失败: {e}")
-            return False
-
-
-# 创建全局适配器实例
-_global_adapter: Optional[QwenCodeInheritanceAdapter] = None
-
-
-def get_qwencode_inheritance_adapter() -> QwenCodeInheritanceAdapter:
-    """
-    获取QwenCode Inheritance适配器实例
-
-    Returns:
-        QwenCodeInheritanceAdapter: 适配器实例
-    """
-    global _global_adapter
-    if _global_adapter is None:
-        _global_adapter = QwenCodeInheritanceAdapter()
-        # 异步初始化需要在调用时进行
-    return _global_adapter
-
-
-# 便捷函数
-async def initialize_qwencode_adapter() -> bool:
-    """
-    初始化QwenCode Inheritance适配器
-
-    Returns:
-        bool: 初始化是否成功
-    """
-    adapter = get_qwencode_inheritance_adapter()
-    return await adapter.initialize()
-
-
-def is_qwencode_adapter_available() -> bool:
-    """
-    检查QwenCode Inheritance适配器是否可用
-
-    Returns:
-        bool: 是否可用
-    """
-    adapter = get_qwencode_inheritance_adapter()
-    return adapter.is_available()