stigmergy 1.0.68 → 1.0.70

package/src/adapters/copilot/mcp_server.py

@@ -1,168 +0,0 @@
-"""
-Copilot CLI MCP服务器实现
-
-为Copilot CLI提供跨CLI集成能力的MCP服务器
-支持工具调用、权限管理和异步执行
-"""
-
-import asyncio
-import json
-import logging
-import os
-import sys
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-
-# MCP相关导入（这里使用模拟实现，实际应该使用MCP SDK）
-try:
-    from mcp.server import Server
-    from mcp.types import Tool, TextContent
-except ImportError:
-    # 如果MCP SDK不可用，使用模拟实现
-    logging.warning("MCP SDK不可用，使用模拟实现")
-    Server = object
-    Tool = object
-    TextContent = object
-
-logger = logging.getLogger(__name__)
-
-
-class CopilotMCPServer:
-    """
-    Copilot CLI MCP服务器
-
-    提供以下工具:
-    1. cross_cli_execute - 执行跨CLI调用
-    2. get_available_clis - 获取可用的CLI工具列表
-    3. check_cli_status - 检查特定CLI工具状态
-    """
-
-    def __init__(self):
-        """初始化MCP服务器"""
-        self.server = Server("cross-cli-adapter")
-        self.adapter = None
-        self.setup_handlers()
-
-    def setup_handlers(self):
-        """设置MCP服务器处理器"""
-
-        @self.server.list_tools()
-        async def list_tools() -> List[Tool]:
-            """列出可用的工具"""
-            return [
-                Tool(
-                    name="cross_cli_execute",
-                    description="Execute tasks on other AI CLI tools through cross-CLI integration",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "target_cli": {
-                                "type": "string",
-                                "description": "Target CLI tool name (e.g., claude, gemini, qwencode)"
-                            },
-                            "task": {
-                                "type": "string",
-                                "description": "Task to execute on the target CLI"
-                            }
-                        },
-                        "required": ["target_cli", "task"]
-                    }
-                ),
-                Tool(
-                    name="get_available_clis",
-                    description="Get list of available AI CLI tools",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {}
-                    }
-                ),
-                Tool(
-                    name="check_cli_status",
-                    description="Check status and health of a specific CLI tool",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "cli_name": {
-                                "type": "string",
-                                "description": "CLI tool name to check"
-                            }
-                        },
-                        "required": ["cli_name"]
-                    }
-                )
-            ]
-
-        @self.server.call_tool()
-        async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
-            """处理工具调用"""
-            try:
-                result = await self.handle_tool_call(name, arguments)
-                return [TextContent(type="text", text=result)]
-            except Exception as e:
-                error_msg = f"Tool execution failed: {str(e)}"
-                logger.error(error_msg)
-                return [TextContent(type="text", text=error_msg)]
-
-    async def handle_tool_call(self, tool_name: str, arguments: Dict[str, Any]) -> str:
-        """处理工具调用的核心逻辑"""
-
-        # 延迟加载适配器
-        if self.adapter is None:
-            from .mcp_adapter import get_copilot_mcp_adapter
-            self.adapter = get_copilot_mcp_adapter()
-
-        # 创建模拟上下文
-        context = self._create_context()
-
-        if hasattr(self.adapter, 'on_mcp_tool_call'):
-            result = await self.adapter.on_mcp_tool_call(tool_name, arguments, context)
-            if result is not None:
-                return result
-
-        # 默认处理
-        return f"Tool {tool_name} executed with arguments: {json.dumps(arguments, indent=2)}"
-
-    def _create_context(self):
-        """创建MCP上下文"""
-        from .mcp_adapter import CopilotMCPContext
-
-        metadata = {
-            'session_id': os.getenv('COPILOT_SESSION_ID', 'unknown'),
-            'user_id': os.getenv('COPILOT_USER_ID', 'unknown'),
-            'tool_permissions': {}
-        }
-
-        return CopilotMCPContext(metadata=metadata)
-
-    async def run(self):
-        """运行MCP服务器"""
-        try:
-            logger.info("启动Copilot MCP服务器")
-            # 这里应该启动实际的MCP服务器
-            # 由于没有MCP SDK，我们使用模拟运行
-            await self._simulate_server_run()
-        except Exception as e:
-            logger.error(f"MCP服务器运行失败: {e}")
-            sys.exit(1)
-
-    async def _simulate_server_run(self):
-        """模拟服务器运行（用于演示）"""
-        logger.info("MCP服务器模拟运行中...")
-        # 在实际实现中，这里会启动真正的MCP服务器
-        await asyncio.sleep(1)  # 模拟运行
-        logger.info("MCP服务器模拟运行完成")
-
-
-async def main():
-    """主函数"""
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-
-    server = CopilotMCPServer()
-    await server.run()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

package/src/adapters/copilot/standalone_copilot_adapter.py

@@ -1,114 +0,0 @@
-"""
-独立 Copilot CLI 适配器 - 完全无抽象层
-
-基于 Copilot CLI 官方 MCP (Model Context Protocol) 系统的原生集成：
-- 使用 Copilot CLI 官方 MCP 机制
-- 无任何抽象基类或 Factory 系统
-- 不改变 CLI 启动和使用方式
-- 纯粹的原生扩展实现
-"""
-
-import os
-import json
-import logging
-import asyncio
-import re
-from typing import Dict, Any, Optional, List
-from datetime import datetime
-
-logger = logging.getLogger(__name__)
-
-
-class StandaloneCopilotAdapter:
-    """
-    独立的 Copilot CLI MCP 适配器
-
-    直接基于 Copilot CLI 官方 MCP 系统，无任何抽象层：
-    - MCP 服务器集成
-    - 直接工具调用
-    - 原生协议支持
-    """
-
-    def __init__(self):
-        """初始化 - 纯实现，无抽象"""
-        self.cli_name = "copilot"
-        self.version = "1.0.0"
-
-        # MCP 配置
-        self.mcp_config_file = os.path.expanduser("~/.config/copilot/mcp_servers.json")
-        self.mcp_registered = False
-
-        # 统计信息
-        self.execution_count = 0
-        self.error_count = 0
-        self.mcp_calls_count = 0
-        self.cross_cli_calls_count = 0
-        self.last_execution: Optional[datetime] = None
-
-        # 直接跨CLI处理器 - 无Factory
-        self._cli_handlers = {}
-        self._init_cli_handlers()
-
-        logger.info("独立 Copilot CLI MCP 适配器初始化完成")
-
-    def _init_cli_handlers(self):
-        """初始化跨CLI处理器 - 直接导入，无Factory"""
-        try:
-            logger.info("跨CLI处理器初始化完成")
-        except Exception as e:
-            logger.warning(f"跨CLI处理器初始化失败: {e}")
-
-    def is_available(self) -> bool:
-        """检查是否可用 - 直接检查 Copilot CLI"""
-        try:
-            import subprocess
-            result = subprocess.run(['copilot', '--version'], capture_output=True, text=True, timeout=10)
-            return result.returncode == 0
-        except Exception:
-            return False
-
-    async def execute_task(self, task: str, context: Dict[str, Any] = None) -> str:
-        """执行任务 - 纯实现，无抽象层"""
-        if context is None:
-            context = {}
-
-        try:
-            self.execution_count += 1
-            self.last_execution = datetime.now()
-
-            # 检测跨CLI调用
-            cross_cli_intent = self._detect_cross_cli_intent(task)
-            if cross_cli_intent:
-                return await self._handle_cross_cli_call(cross_cli_intent, context)
-
-            # 本地 Copilot 处理
-            return f"[Copilot CLI 本地处理] {task}"
-
-        except Exception as e:
-            self.error_count += 1
-            logger.error(f"任务执行失败: {task}, 错误: {e}")
-            return f"[错误] {task} 执行失败: {str(e)}"
-
-    def _detect_cross_cli_intent(self, text: str) -> Optional[str]:
-        """检测跨CLI调用意图"""
-        # 简化实现
-        return None
-
-    async def _handle_cross_cli_call(self, command: str, context: Dict[str, Any]) -> str:
-        """处理跨CLI调用 - 直接实现，无抽象层"""
-        self.cross_cli_calls_count += 1
-        return f"[跨CLI调用] {command}"
-
-    def get_statistics(self) -> Dict[str, Any]:
-        """获取统计信息 - 直接实现"""
-        return {
-            'cli_name': self.cli_name,
-            'version': self.version,
-            'design': 'standalone_mcp_native',
-            'no_abstraction': True
-        }
-
-
-def get_standalone_copilot_adapter() -> StandaloneCopilotAdapter:
-    """获取独立的 Copilot CLI 适配器实例"""
-    return StandaloneCopilotAdapter()

package/src/adapters/gemini/__init__.py

@@ -1,13 +0,0 @@
-"""
-Gemini CLI 适配器包
-
-基于 Gemini CLI 官方 Extension 系统的原生集成
-完全无抽象层设计
-"""
-
-from .standalone_gemini_adapter import get_standalone_gemini_adapter, StandaloneGeminiAdapter
-
-# 向后兼容的别名
-GeminiExtensionAdapter = StandaloneGeminiAdapter
-
-__all__ = ['StandaloneGeminiAdapter', 'get_standalone_gemini_adapter', 'GeminiExtensionAdapter']