stigmergy 1.0.68 → 1.0.70

package/src/core/base_adapter.py

@@ -1,220 +0,0 @@
-"""
-BaseCrossCLIAdapter - 跨CLI适配器基类
-定义所有CLI适配器的统一接口和基础功能
-"""
-
-import abc
-import logging
-from typing import Dict, Any, Optional
-from datetime import datetime
-from dataclasses import dataclass, field
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class IntentResult:
-    """意图解析结果"""
-    is_cross_cli: bool = False
-    target_cli: Optional[str] = None
-    task: str = ""
-    confidence: float = 1.0
-
-
-class BaseCrossCLIAdapter(abc.ABC):
-    """
-    跨CLI适配器抽象基类
-    定义所有CLI适配器必须实现的接口和提供的基础功能
-    """
-
-    def __init__(self, cli_name: str):
-        """
-        初始化适配器
-
-        Args:
-            cli_name: CLI工具名称
-        """
-        self.cli_name = cli_name
-        self.version = "1.0.0"
-        self.initialized = False
-        self.initialization_time: Optional[datetime] = None
-        
-        # 统计信息
-        self.execution_count = 0
-        self.error_count = 0
-        self.successful_executions = 0
-        self.total_execution_time = 0.0
-        
-        # 错误记录
-        self.last_error: Optional[str] = None
-        self.last_error_time: Optional[datetime] = None
-
-    @abc.abstractmethod
-    async def execute_task(self, task: str, context: Dict[str, Any]) -> str:
-        """
-        执行跨CLI任务 - 抽象方法，必须由子类实现
-
-        Args:
-            task: 要执行的任务描述
-            context: 执行上下文信息
-
-        Returns:
-            str: 任务执行结果
-        """
-        pass
-
-    @abc.abstractmethod
-    def is_available(self) -> bool:
-        """
-        检查适配器是否可用 - 抽象方法，必须由子类实现
-
-        Returns:
-            bool: 是否可用
-        """
-        pass
-
-    async def initialize(self) -> bool:
-        """
-        初始化适配器 - 可由子类重写
-
-        Returns:
-            bool: 初始化是否成功
-        """
-        self.initialized = True
-        self.initialization_time = datetime.now()
-        logger.info(f"{self.cli_name} 适配器初始化完成")
-        return True
-
-    async def health_check(self) -> Dict[str, Any]:
-        """
-        健康检查
-
-        Returns:
-            Dict[str, Any]: 健康状态信息
-        """
-        return {
-            'cli_name': self.cli_name,
-            'version': self.version,
-            'initialized': self.initialized,
-            'available': self.is_available(),
-            'execution_count': self.execution_count,
-            'error_count': self.error_count,
-            'success_rate': self.get_success_rate(),
-            'last_error': self.last_error,
-            'last_error_time': self.last_error_time.isoformat() if self.last_error_time else None,
-            'initialization_time': self.initialization_time.isoformat() if self.initialization_time else None
-        }
-
-    def get_statistics(self) -> Dict[str, Any]:
-        """
-        获取适配器统计信息
-
-        Returns:
-            Dict[str, Any]: 统计信息
-        """
-        return {
-            'cli_name': self.cli_name,
-            'version': self.version,
-            'execution_count': self.execution_count,
-            'error_count': self.error_count,
-            'successful_executions': self.successful_executions,
-            'total_execution_time': self.total_execution_time,
-            'success_rate': self.get_success_rate(),
-            'average_execution_time': (
-                self.total_execution_time / self.successful_executions 
-                if self.successful_executions > 0 else 0
-            )
-        }
-
-    def get_success_rate(self) -> float:
-        """
-        计算成功率
-
-        Returns:
-            float: 成功率 (0.0 - 1.0)
-        """
-        if self.execution_count == 0:
-            return 1.0
-        return self.successful_executions / self.execution_count
-
-    def record_execution(self, execution_time: float, success: bool = True):
-        """
-        记录执行统计
-
-        Args:
-            execution_time: 执行时间（秒）
-            success: 是否执行成功
-        """
-        self.execution_count += 1
-        self.total_execution_time += execution_time
-        
-        if success:
-            self.successful_executions += 1
-        else:
-            self.error_count += 1
-
-    def record_error(self, error_message: Optional[str] = None):
-        """
-        记录错误
-
-        Args:
-            error_message: 错误信息
-        """
-        self.error_count += 1
-        self.last_error = error_message or "Unknown error"
-        self.last_error_time = datetime.now()
-
-    async def cleanup(self) -> bool:
-        """
-        清理适配器资源 - 可由子类重写
-
-        Returns:
-            bool: 清理是否成功
-        """
-        logger.info(f"{self.cli_name} 适配器清理完成")
-        return True
-
-    def __str__(self):
-        return f"{self.__class__.__name__}(cli_name='{self.cli_name}', version='{self.version}')"
-
-    def __repr__(self):
-        return self.__str__()
-
-
-# 全局适配器工厂
-_adapters_registry: Dict[str, BaseCrossCLIAdapter] = {}
-
-
-def register_adapter(cli_name: str, adapter: BaseCrossCLIAdapter):
-    """
-    注册适配器到全局注册表
-
-    Args:
-        cli_name: CLI工具名称
-        adapter: 适配器实例
-    """
-    _adapters_registry[cli_name] = adapter
-    logger.info(f"注册适配器: {cli_name}")
-
-
-def get_cross_cli_adapter(cli_name: str) -> Optional[BaseCrossCLIAdapter]:
-    """
-    获取跨CLI适配器
-
-    Args:
-        cli_name: CLI工具名称
-
-    Returns:
-        Optional[BaseCrossCLIAdapter]: 适配器实例
-    """
-    return _adapters_registry.get(cli_name)
-
-
-def get_all_adapters() -> Dict[str, BaseCrossCLIAdapter]:
-    """
-    获取所有注册的适配器
-
-    Returns:
-        Dict[str, BaseCrossCLIAdapter]: 所有适配器
-    """
-    return _adapters_registry.copy()

package/src/core/cli_hook_integration.py

@@ -1,406 +0,0 @@
-"""
-CLI Hook Integration - CLI工具钩子集成模块
-将增强的 /init 指令集成到各个CLI工具的钩子系统
-"""
-import os
-import asyncio
-from pathlib import Path
-from typing import Optional, Dict, Any
-import logging
-
-from .enhanced_init_processor import EnhancedInitProcessor
-
-logger = logging.getLogger(__name__)
-
-
-class CLIHookIntegration:
-    """CLI工具钩子集成 - 统一处理各CLI工具的钩子集成"""
-
-    def __init__(self):
-        self.processors = {}  # 缓存不同CLI的处理器实例
-
-    async def handle_init_command(self, current_cli: str, project_path: str = None) -> str:
-        """统一处理 /init 斜杠指令"""
-        try:
-            logger.info(f"处理 {current_cli} 的 /init 指令")
-
-            # 获取项目路径
-            if not project_path:
-                project_path = os.getcwd()
-
-            # 获取或创建处理器实例
-            processor = self._get_processor(current_cli)
-
-            # 处理初始化命令
-            result = await processor.process_init_command(project_path)
-
-            # 生成用户友好的响应消息
-            response_message = self._generate_response_message(result, current_cli)
-
-            return response_message
-
-        except Exception as e:
-            logger.error(f"处理 /init 指令失败: {e}")
-            return f"❌ 处理失败: {str(e)}"
-
-    def _get_processor(self, current_cli: str) -> EnhancedInitProcessor:
-        """获取或创建处理器实例"""
-        if current_cli not in self.processors:
-            self.processors[current_cli] = EnhancedInitProcessor(current_cli)
-        return self.processors[current_cli]
-
-    def _generate_response_message(self, result, current_cli: str) -> str:
-        """生成用户友好的响应消息"""
-        try:
-            if not result.ai_environment:
-                return result.message
-
-            env = result.ai_environment
-            available_tools = len(env.available_clis)
-
-            base_message = f"""
-🎯 **AI CLI Router - 项目初始化完成**
-
-📊 **项目状态**: {result.project_type}
-🤖 **可用AI工具**: {available_tools} 个
-⏱️ **处理时间**: {result.processing_time:.2f} 秒
-
-**详细结果**:
-{result.message}
-"""
-
-            # 添加工具状态信息
-            if result.project_type == "existing_project":
-                enhanced_count = len(result.enhanced_documents)
-                base_message += f"""
-📝 **增强的文档**: {enhanced_count} 个
-"""
-                if enhanced_count > 0:
-                    base_message += "\n✅ 以下文档已添加协作感知:\n"
-                    for doc_name in result.enhanced_documents.keys():
-                        base_message += f"   - `{doc_name}.md`\n"
-
-            else:  # new_project
-                generated_count = len(result.generated_documents)
-                base_message += f"""
-🆕 **生成的文档**: {generated_count} 个
-"""
-                if generated_count > 0:
-                    base_message += "\n📄 以下文档已生成:\n"
-                    for doc_name in result.generated_documents.keys():
-                        base_message += f"   - `{doc_name}.md`\n"
-
-            # 添加可用工具列表
-            base_message += f"""
-🔧 **可用AI工具**:
-"""
-            for tool_name, tool_info in env.available_clis.items():
-                status_icon = "✅" if tool_info.status.value == "available" else "❌"
-                base_message += f"   {status_icon} **{tool_info.display_name}** v{tool_info.version}\n"
-
-            # 添加快速开始指南
-            base_message += f"""
-🚀 **快速开始**:
-
-现在您可以使用跨AI工具协作指令:
-
-**中文示例**:
-- `请用{self._get_other_tool(env.available_clis, current_cli)}帮我生成代码`
-- `调用{self._get_other_tool(env.available_clis, current_cli)}分析性能问题`
-- `用{self._get_other_tool(env.available_clis, current_cli)}审查代码质量`
-
-**英文示例**:
-- `use {self._get_other_tool(env.available_clis, current_cli)} to generate tests`
-- `call {self._get_other_tool(env.available_clis, current_cli)} for code review`
-- `ask {self._get_other_tool(env.available_clis, current_cli)} to optimize performance`
-
-💡 **提示**:
-- 查看生成的 `.md` 文件获取详细的协作指南
-- 使用 `/init` 命令重新扫描AI环境
-- 项目配置保存在 `.ai-cli-project/` 目录中
-
-🔗 **相关命令**:
-- `ai-cli-router status` - 查看所有工具状态
-- `ai-cli-router scan` - 重新扫描AI环境
-"""
-
-            return base_message
-
-        except Exception as e:
-            logger.error(f"生成响应消息失败: {e}")
-            return result.message
-
-    def _get_other_tool(self, available_clis: Dict[str, Any], current_cli: str) -> str:
-        """获取另一个可用的工具名称"""
-        for tool_name in available_clis.keys():
-            if tool_name != current_cli:
-                return tool_name
-        return "其他工具"
-
-
-# 各CLI工具的具体钩子集成实现
-
-class ClaudeHookIntegration:
-    """Claude CLI 钩子集成"""
-
-    @staticmethod
-    async def on_user_prompt_submit(context: Dict[str, Any]) -> Optional[str]:
-        """处理用户提示词提交钩子"""
-        try:
-            user_input = context.get("prompt", "").strip()
-
-            # 检测 /init 指令
-            if user_input == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("claude")
-
-            # 检测其他相关指令（可以扩展）
-            elif user_input.startswith("/ai-cli"):
-                # 处理其他AI CLI Router指令
-                return await ClaudeHookIntegration._handle_ai_cli_commands(user_input)
-
-            return None
-
-        except Exception as e:
-            logger.error(f"Claude钩子处理失败: {e}")
-            return None
-
-    @staticmethod
-    async def _handle_ai_cli_commands(command: str) -> str:
-        """处理AI CLI Router相关命令"""
-        try:
-            parts = command.split()
-            if len(parts) < 2:
-                return "❌ 无效的AI CLI Router命令"
-
-            sub_command = parts[1]
-            hook_integration = CLIHookIntegration()
-
-            if sub_command == "status":
-                # 检查状态
-                return await hook_integration.handle_init_command("claude")
-            elif sub_command == "scan":
-                # 重新扫描
-                return await hook_integration.handle_init_command("claude")
-            else:
-                return f"❌ 未知命令: {sub_command}"
-
-        except Exception as e:
-            return f"❌ 命令执行失败: {str(e)}"
-
-
-class GeminiExtensionIntegration:
-    """Gemini CLI 扩展集成"""
-
-    @staticmethod
-    async def on_prompt_submit(context: Dict[str, Any]) -> Optional[str]:
-        """处理提示词提交扩展"""
-        try:
-            prompt = context.get("prompt", "").strip()
-
-            if prompt == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("gemini")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"Gemini扩展处理失败: {e}")
-            return None
-
-
-class QwenCodeInheritanceIntegration:
-    """QwenCode CLI 继承集成"""
-
-    @staticmethod
-    async def on_prompt_received(context: Dict[str, Any]) -> Optional[str]:
-        """处理提示词接收"""
-        try:
-            prompt = context.get("prompt", "").strip()
-
-            if prompt == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("qwen")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"QwenCode继承处理失败: {e}")
-            return None
-
-
-class IFlowWorkflowIntegration:
-    """iFlow CLI 工作流集成"""
-
-    @staticmethod
-    async def on_workflow_start(context: Dict[str, Any]) -> Optional[str]:
-        """处理工作流开始"""
-        try:
-            workflow_config = context.get("workflow_config", {})
-            command = workflow_config.get("command", "").strip()
-
-            if command == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("iflow")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"iFlow工作流处理失败: {e}")
-            return None
-
-    @staticmethod
-    async def on_user_prompt_submit(context: Dict[str, Any]) -> Optional[str]:
-        """处理用户提示词提交（备用）"""
-        try:
-            user_input = context.get("prompt", "").strip()
-
-            if user_input == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("iflow")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"iFlow钩子处理失败: {e}")
-            return None
-
-
-class QoderNotificationIntegration:
-    """Qoder CLI 通知集成"""
-
-    @staticmethod
-    async def on_command_execution(context: Dict[str, Any]) -> Optional[str]:
-        """处理命令执行"""
-        try:
-            command = context.get("command", "").strip()
-
-            if command == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("qoder")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"Qoder通知处理失败: {e}")
-            return None
-
-
-class CodeBuddySkillsIntegration:
-    """CodeBuddy CLI 技能集成"""
-
-    @staticmethod
-    async def on_skill_activation(context: Dict[str, Any]) -> Optional[str]:
-        """处理技能激活"""
-        try:
-            skill_name = context.get("skill_name", "")
-
-            if skill_name == "ai_cli_init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("codebuddy")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"CodeBuddy技能处理失败: {e}")
-            return None
-
-    @staticmethod
-    async def on_user_command(context: Dict[str, Any]) -> Optional[str]:
-        """处理用户命令（备用）"""
-        try:
-            command = context.get("command", "").strip()
-
-            if command == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("codebuddy")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"CodeBuddy命令处理失败: {e}")
-            return None
-
-
-class CopilotMCPIntegration:
-    """Copilot CLI MCP集成"""
-
-    @staticmethod
-    async def on_agent_execution(context: Dict[str, Any]) -> Optional[str]:
-        """处理代理执行"""
-        try:
-            agent_request = context.get("request", "")
-
-            if agent_request.strip() == "/init":
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("copilot")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"Copilot MCP处理失败: {e}")
-            return None
-
-
-class CodexSlashIntegration:
-    """Codex CLI 斜杠命令集成"""
-
-    @staticmethod
-    async def on_slash_command(context: Dict[str, Any]) -> Optional[str]:
-        """处理斜杠命令"""
-        try:
-            command = context.get("command", "")
-            args = context.get("args", [])
-
-            if command == "init" and not args:
-                hook_integration = CLIHookIntegration()
-                return await hook_integration.handle_init_command("codex")
-
-            return None
-
-        except Exception as e:
-            logger.error(f"Codex斜杠命令处理失败: {e}")
-            return None
-
-
-# 集成映射表
-CLI_INTEGRATIONS = {
-    "claude": ClaudeHookIntegration,
-    "gemini": GeminiExtensionIntegration,
-    "qwen": QwenCodeInheritanceIntegration,
-    "iflow": IFlowWorkflowIntegration,
-    "qoder": QoderNotificationIntegration,
-    "codebuddy": CodeBuddySkillsIntegration,
-    "copilot": CopilotMCPIntegration,
-    "codex": CodexSlashIntegration
-}
-
-
-def get_cli_integration(cli_name: str):
-    """获取CLI工具的集成类"""
-    return CLI_INTEGRATIONS.get(cli_name)
-
-
-# 通用钩子处理器（用于适配器集成）
-async def universal_init_handler(current_cli: str, context: Dict[str, Any]) -> Optional[str]:
-    """通用的 /init 处理器，适用于所有CLI工具"""
-    try:
-        # 从上下文中提取用户输入
-        user_input = ""
-
-        # 尝试从不同的上下文字段中获取用户输入
-        for field in ["prompt", "command", "request", "user_input"]:
-            if field in context:
-                user_input = str(context[field]).strip()
-                break
-
-        # 检查是否为 /init 指令
-        if user_input == "/init":
-            hook_integration = CLIHookIntegration()
-            return await hook_integration.handle_init_command(current_cli, context.get("project_path"))
-
-        return None
-
-    except Exception as e:
-        logger.error(f"通用 /init 处理器失败: {e}")
-        return None