erlangshen 0.1.0

package/src/mcp/market.py

@@ -0,0 +1,331 @@
+"""
+MCP 工具 - 市场行情数据
+使用真实数据库数据
+"""
+
+import sys
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
+
+# 导入投资系统数据库连接
+sys.path.insert(0, '/Users/wanghui/.openclaw-agent-06/workspace/investment-strategy')
+from backend.core.database import execute_remote_query
+
+
+class MarketMCP:
+    """
+    行情数据 MCP
+
+    提供股票、指数、期货等行情数据接口
+    数据来源：远程数据库 (193.112.183.130)
+    """
+
+    def __init__(self):
+        self.name = "market"
+
+    async def get_stock_price(self, symbol: str) -> Dict[str, Any]:
+        """
+        获取股票实时价格
+
+        Args:
+            symbol: 股票代码，如 "000001", "600519"
+
+        Returns:
+            价格数据字典
+        """
+        try:
+            sql = """
+            SELECT 日期, 代码, 开盘, 收盘, 最高, 最低, 成交量, 成交额, 涨跌幅, 涨跌额, 换手率
+            FROM A股历史行情表
+            WHERE 代码 = %s
+            ORDER BY 日期 DESC
+            LIMIT 1
+            """
+            rows = execute_remote_query('stock', sql, (symbol,))
+            if rows:
+                r = rows[0]
+                return {
+                    "symbol": r['代码'],
+                    "date": str(r['日期']),
+                    "price": float(r['收盘']) if r['收盘'] else None,
+                    "open": float(r['开盘']) if r['开盘'] else None,
+                    "high": float(r['最高']) if r['最高'] else None,
+                    "low": float(r['最低']) if r['最低'] else None,
+                    "change": float(r['涨跌额']) if r['涨跌额'] else 0.0,
+                    "change_pct": float(r['涨跌幅']) if r['涨跌幅'] else 0.0,
+                    "volume": float(r['成交量']) if r['成交量'] else 0,
+                    "amount": float(r['成交额']) if r['成交额'] else 0.0,
+                    "turnover": float(r['换手率']) if r['换手率'] else None,
+                    "source": "remote_db"
+                }
+            return {"error": f"未找到股票 {symbol} 的数据", "symbol": symbol}
+        except Exception as e:
+            logger.error(f"获取股票 {symbol} 价格失败: {e}")
+            return {"error": f"数据库查询失败: {str(e)}", "symbol": symbol}
+
+    async def get_stock_history(
+        self,
+        symbol: str,
+        days: int = 30,
+        end_date: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        获取股票历史行情
+
+        Args:
+            symbol: 股票代码
+            days: 历史天数
+            end_date: 结束日期 (YYYY-MM-DD)
+
+        Returns:
+            历史行情列表
+        """
+        try:
+            sql = """
+            SELECT 日期, 代码, 开盘, 收盘, 最高, 最低, 成交量, 成交额, 涨跌幅, 涨跌额
+            FROM A股历史行情表
+            WHERE 代码 = %s
+            ORDER BY 日期 DESC
+            LIMIT %s
+            """
+            rows = execute_remote_query('stock', sql, (symbol, days))
+            if rows:
+                return [
+                    {
+                        "date": str(r['日期']),
+                        "symbol": r['代码'],
+                        "open": float(r['开盘']) if r['开盘'] else None,
+                        "close": float(r['收盘']) if r['收盘'] else None,
+                        "high": float(r['最高']) if r['最高'] else None,
+                        "low": float(r['最低']) if r['最低'] else None,
+                        "volume": float(r['成交量']) if r['成交量'] else 0,
+                        "amount": float(r['成交额']) if r['成交额'] else 0.0,
+                        "change_pct": float(r['涨跌幅']) if r['涨跌幅'] else 0.0,
+                        "change": float(r['涨跌额']) if r['涨跌额'] else 0.0,
+                        "source": "remote_db"
+                    }
+                    for r in rows
+                ]
+            return [{"error": f"未找到股票 {symbol} 的历史数据"}]
+        except Exception as e:
+            logger.error(f"获取股票 {symbol} 历史失败: {e}")
+            return [{"error": f"数据库查询失败: {str(e)}"}]
+
+    async def get_index_quote(self, index_name: str) -> Dict[str, Any]:
+        """
+        获取指数行情
+
+        Args:
+            index_name: 指数名称，如 "上证指数", "沪深300", "创业板指"
+
+        Returns:
+            指数行情数据
+        """
+        index_names = {
+            "上证指数": "000001",
+            "深证成指": "399001",
+            "创业板指": "399006",
+            "沪深300": "000300",
+            "上证50": "000016",
+            "中证500": "000905",
+            "科创50": "科创50",
+        }
+        try:
+            sql = """
+            SELECT 指数名称, 日期, 开盘价, 最高价, 最低价, 收盘价, 成交量, 成交额, 涨跌幅, 涨跌额
+            FROM 国内宽基指数行情表
+            WHERE 指数名称 = %s
+            ORDER BY 日期 DESC
+            LIMIT 1
+            """
+            rows = execute_remote_query('index', sql, (index_name,))
+            if rows:
+                r = rows[0]
+                return {
+                    "index_name": r['指数名称'],
+                    "date": str(r['日期']),
+                    "price": float(r['收盘价']) if r['收盘价'] else None,
+                    "open": float(r['开盘价']) if r['开盘价'] else None,
+                    "high": float(r['最高价']) if r['最高价'] else None,
+                    "low": float(r['最低价']) if r['最低价'] else None,
+                    "change": float(r['涨跌额']) if r['涨跌额'] else 0.0,
+                    "change_pct": float(r['涨跌幅']) if r['涨跌幅'] else 0.0,
+                    "volume": float(r['成交量']) if r['成交量'] else 0,
+                    "amount": float(r['成交额']) if r['成交额'] else 0.0,
+                    "source": "remote_db"
+                }
+            return {"error": f"未找到指数 {index_name} 的数据", "index_name": index_name}
+        except Exception as e:
+            logger.error(f"获取指数 {index_name} 行情失败: {e}")
+            return {"error": f"数据库查询失败: {str(e)}", "index_name": index_name}
+
+    async def get_index_history(
+        self,
+        index_name: str,
+        days: int = 30
+    ) -> List[Dict[str, Any]]:
+        """
+        获取指数历史行情
+
+        Args:
+            index_name: 指数名称
+            days: 历史天数
+
+        Returns:
+            历史行情列表
+        """
+        try:
+            sql = """
+            SELECT 指数名称, 日期, 开盘价, 最高价, 最低价, 收盘价, 成交量, 成交额, 涨跌幅, 涨跌额
+            FROM 国内宽基指数行情表
+            WHERE 指数名称 = %s
+            ORDER BY 日期 DESC
+            LIMIT %s
+            """
+            rows = execute_remote_query('index', sql, (index_name, days))
+            if rows:
+                return [
+                    {
+                        "index_name": r['指数名称'],
+                        "date": str(r['日期']),
+                        "open": float(r['开盘价']) if r['开盘价'] else None,
+                        "high": float(r['最高价']) if r['最高价'] else None,
+                        "low": float(r['最低价']) if r['最低价'] else None,
+                        "close": float(r['收盘价']) if r['收盘价'] else None,
+                        "volume": float(r['成交量']) if r['成交量'] else 0,
+                        "amount": float(r['成交额']) if r['成交额'] else 0.0,
+                        "change_pct": float(r['涨跌幅']) if r['涨跌幅'] else 0.0,
+                        "change": float(r['涨跌额']) if r['涨跌额'] else 0.0,
+                        "source": "remote_db"
+                    }
+                    for r in rows
+                ]
+            return [{"error": f"未找到指数 {index_name} 的历史数据"}]
+        except Exception as e:
+            logger.error(f"获取指数 {index_name} 历史失败: {e}")
+            return [{"error": f"数据库查询失败: {str(e)}"}]
+
+    async def get_futures_price(self, contract: str) -> Dict[str, Any]:
+        """
+        获取期货价格
+
+        Args:
+            contract: 期货合约名称
+
+        Returns:
+            期货行情数据
+        """
+        try:
+            sql = """
+            SELECT contract_code, trade_date, open, high, low, close, volume, open_interest
+            FROM 全部期货合约历史行情
+            WHERE contract_code = %s
+            ORDER BY trade_date DESC
+            LIMIT 1
+            """
+            rows = execute_remote_query('futures', sql, (contract,))
+            if rows:
+                r = rows[0]
+                return {
+                    "contract": r['contract_code'],
+                    "date": str(r['trade_date']),
+                    "price": float(r['close']),
+                    "open": float(r['open']) if r['open'] else None,
+                    "high": float(r['high']) if r['high'] else None,
+                    "low": float(r['low']) if r['low'] else None,
+                    "volume": int(r['volume']) if r['volume'] else 0,
+                    "open_interest": int(r['open_interest']) if r['open_interest'] else 0,
+                    "source": "remote_db"
+                }
+            return {"error": f"未找到期货合约 {contract} 的数据", "contract": contract}
+        except Exception as e:
+            logger.error(f"获取期货 {contract} 价格失败: {e}")
+            return {"error": f"数据库查询失败: {str(e)}", "contract": contract}
+
+    async def get_etf_quote(self, symbol: str) -> Dict[str, Any]:
+        """
+        获取ETF行情 (暂无独立ETF表，暂用股票表)
+
+        Args:
+            symbol: ETF代码
+
+        Returns:
+            ETF行情数据
+        """
+        return await self.get_stock_price(symbol)
+
+    async def get_realtime_quotes(self, symbols: List[str]) -> List[Dict[str, Any]]:
+        """
+        批量获取实时行情
+
+        Args:
+            symbols: 股票代码列表
+
+        Returns:
+            行情列表
+        """
+        results = []
+        for symbol in symbols:
+            quote = await self.get_stock_price(symbol)
+            results.append(quote)
+        return results
+
+    def list_tools(self) -> List[Dict[str, Any]]:
+        """列出所有可用工具"""
+        return [
+            {
+                "name": "get_stock_price",
+                "description": "获取股票实时价格",
+                "parameters": {
+                    "symbol": "股票代码，如 000001, 600519"
+                }
+            },
+            {
+                "name": "get_stock_history",
+                "description": "获取股票历史行情",
+                "parameters": {
+                    "symbol": "股票代码",
+                    "days": "历史天数 (默认30)",
+                    "end_date": "结束日期 (YYYY-MM-DD)"
+                }
+            },
+            {
+                "name": "get_index_quote",
+                "description": "获取指数行情",
+                "parameters": {
+                    "index_name": "指数名称，如 上证指数, 沪深300, 创业板指"
+                }
+            },
+            {
+                "name": "get_index_history",
+                "description": "获取指数历史行情",
+                "parameters": {
+                    "index_name": "指数名称",
+                    "days": "历史天数"
+                }
+            },
+            {
+                "name": "get_futures_price",
+                "description": "获取期货价格",
+                "parameters": {
+                    "contract": "期货合约代码"
+                }
+            },
+            {
+                "name": "get_etf_quote",
+                "description": "获取ETF行情",
+                "parameters": {
+                    "symbol": "ETF代码"
+                }
+            },
+            {
+                "name": "get_realtime_quotes",
+                "description": "批量获取实时行情",
+                "parameters": {
+                    "symbols": "股票代码列表"
+                }
+            },
+        ]

package/src/mcp/registry.py

@@ -0,0 +1,168 @@
+"""
+MCP 注册表 - 统一管理所有MCP工具
+"""
+
+from typing import Dict, Any, List, Optional, Callable, Awaitable
+from dataclasses import dataclass
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MCPTool:
+    """MCP 工具定义"""
+    name: str
+    description: str
+    mcp_name: str
+    handler: Callable[..., Awaitable[Any]]
+    parameters: Dict[str, Any]
+
+
+class MCPRegistry:
+    """
+    MCP 注册表
+    
+    统一管理所有 MCP 工具的注册和调用
+    """
+    
+    def __init__(self):
+        self._mcps: Dict[str, Any] = {}
+        self._tools: Dict[str, MCPTool] = {}
+        self._register_default_mcps()
+    
+    def _register_default_mcps(self):
+        """注册默认 MCP"""
+        # Market MCP
+        try:
+            from src.mcp.market import MarketMCP
+            self.register_mcp("market", MarketMCP())
+        except Exception as e:
+            logger.warning(f"Market MCP 注册失败: {e}")
+        
+        # Macro MCP
+        try:
+            from src.mcp.macro import MacroMCP
+            self.register_mcp("macro", MacroMCP())
+        except Exception as e:
+            logger.warning(f"Macro MCP 注册失败: {e}")
+        
+        # Feishu MCP
+        try:
+            from src.mcp.feishu import FeishuMCP
+            self.register_mcp("feishu", FeishuMCP())
+        except Exception as e:
+            logger.warning(f"Feishu MCP 注册失败: {e}")
+        
+        # Fund MCP
+        try:
+            from src.mcp.fund_tools import FundMCP
+            self.register_mcp("fund", FundMCP())
+        except Exception as e:
+            logger.warning(f"Fund MCP 注册失败: {e}")
+    
+    def register_mcp(self, name: str, mcp_instance: Any):
+        """
+        注册 MCP 实例
+        
+        Args:
+            name: MCP 名称
+            mcp_instance: MCP 实例
+        """
+        self._mcps[name] = mcp_instance
+        
+        # 自动注册 MCP 的工具
+        if hasattr(mcp_instance, "list_tools"):
+            for tool in mcp_instance.list_tools():
+                tool_name = tool["name"]
+                handler = getattr(mcp_instance, tool_name, None)
+                
+                if handler and callable(handler):
+                    self._tools[tool_name] = MCPTool(
+                        name=tool_name,
+                        description=tool["description"],
+                        mcp_name=name,
+                        handler=handler,
+                        parameters=tool.get("parameters", {})
+                    )
+        
+        logger.info(f"MCP '{name}' 已注册，包含 {len([t for t in self._tools.values() if t.mcp_name == name])} 个工具")
+    
+    def get_mcp(self, name: str) -> Optional[Any]:
+        """
+        获取 MCP 实例
+        
+        Args:
+            name: MCP 名称
+        
+        Returns:
+            MCP 实例
+        """
+        return self._mcps.get(name)
+    
+    def list_mcps(self) -> List[Dict[str, Any]]:
+        """列出所有已注册的 MCP"""
+        return [
+            {
+                "name": name,
+                "tools": len([t for t in self._tools.values() if t.mcp_name == name])
+            }
+            for name, mcp in self._mcps.items()
+        ]
+    
+    def list_tools(self) -> List[Dict[str, Any]]:
+        """列出所有可用工具"""
+        return [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "mcp": tool.mcp_name,
+                "parameters": tool.parameters
+            }
+            for tool in self._tools.values()
+        ]
+    
+    async def call_tool(self, tool_name: str, **kwargs) -> Any:
+        """
+        调用 MCP 工具
+        
+        Args:
+            tool_name: 工具名称
+            **kwargs: 工具参数
+        
+        Returns:
+            工具执行结果
+        """
+        tool = self._tools.get(tool_name)
+        
+        if not tool:
+            return {
+                "success": False,
+                "error": f"未知工具: {tool_name}",
+                "available_tools": list(self._tools.keys())
+            }
+        
+        try:
+            result = await tool.handler(**kwargs)
+            return result
+        except Exception as e:
+            logger.error(f"工具 {tool_name} 执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "tool": tool_name
+            }
+    
+    def get_tool_info(self, tool_name: str) -> Optional[Dict[str, Any]]:
+        """获取工具信息"""
+        tool = self._tools.get(tool_name)
+        
+        if not tool:
+            return None
+        
+        return {
+            "name": tool.name,
+            "description": tool.description,
+            "mcp": tool.mcp_name,
+            "parameters": tool.parameters
+        }

package/src/network/__init__.py

@@ -0,0 +1,15 @@
+"""
+网络自适应模块
+根据目标自动选择最优网络路径（直连/代理）
+"""
+
+from .proxy import ProxyManager, ProxyConfig
+from .detector import NetworkDetector
+from .router import NetworkRouter
+
+__all__ = [
+    "ProxyManager",
+    "ProxyConfig", 
+    "NetworkDetector",
+    "NetworkRouter",
+]

package/src/network/detector.py

@@ -0,0 +1,125 @@
+"""
+网络环境检测
+检测当前是否使用VPN、直连等
+"""
+
+import asyncio
+import socket
+import os
+from typing import Dict, Optional
+
+
+class NetworkDetector:
+    """网络环境检测器"""
+    
+    # 中国测试主机
+    CHINA_TEST_HOSTS = [
+        ("www.baidu.com", 80),
+        ("www.aliyun.com", 80),
+        ("api.binance.com", 443),  # Binance中国可直连
+        ("api.okx.com", 443),      # OKX中国可直连
+    ]
+    
+    # 国际测试主机
+    GLOBAL_TEST_HOSTS = [
+        ("www.google.com", 443),
+        ("www.cloudflare.com", 443),
+        ("api.coingecko.com", 443),
+        ("api.openai.com", 443),
+    ]
+    
+    async def detect_environment(self) -> Dict[str, bool]:
+        """
+        检测网络环境
+        返回: {
+            "china_reachable": True,  # 中国网络是否可达
+            "global_reachable": True,  # 全球网络是否可达
+            "vpn_active": False,      # VPN是否激活
+            "proxy_active": False,    # 代理是否激活
+        }
+        """
+        results = {
+            "china_reachable": False,
+            "global_reachable": False,
+            "vpn_active": False,
+            "proxy_active": False,
+        }
+        
+        # 并发检测中国和国际网络
+        china_task = self._test_hosts(self.CHINA_TEST_HOSTS)
+        global_task = self._test_hosts(self.GLOBAL_TEST_HOSTS)
+        
+        china_results, global_results = await asyncio.gather(china_task, global_task)
+        
+        results["china_reachable"] = any(china_results)
+        results["global_reachable"] = any(global_results)
+        
+        # 检测VPN
+        results["vpn_active"] = await self._detect_vpn()
+        
+        # 检测代理环境变量
+        results["proxy_active"] = self._detect_proxy_env()
+        
+        return results
+    
+    async def _test_hosts(self, hosts: list) -> list:
+        """测试一组主机是否可达"""
+        tasks = [self._test_host(host, port) for host, port in hosts]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        return [r for r in results if r is True]
+    
+    async def _test_host(self, host: str, port: int, timeout: float = 3.0) -> bool:
+        """测试单个主机"""
+        try:
+            reader, writer = await asyncio.wait_for(
+                asyncio.open_connection(host, port),
+                timeout=timeout
+            )
+            writer.close()
+            await writer.wait_closed()
+            return True
+        except Exception:
+            return False
+    
+    async def _detect_vpn(self) -> bool:
+        """检测VPN是否激活"""
+        import subprocess
+        try:
+            # macOS检测VPN接口
+            result = subprocess.run(
+                ["networksetup", "-listallnetworkservices"],
+                capture_output=True, text=True, timeout=5
+            )
+            # 检查是否有VPN相关的网络服务
+            return "VPN" in result.stdout or "utun" in result.stdout
+        except Exception:
+            return False
+    
+    def _detect_proxy_env(self) -> bool:
+        """检测代理环境变量"""
+        proxy_vars = [
+            "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY",
+            "http_proxy", "https_proxy", "all_proxy",
+            "SOCKS_PROXY", "socks_proxy"
+        ]
+        for var in proxy_vars:
+            if os.environ.get(var):
+                return True
+        return False
+    
+    def get_recommended_mode(self) -> str:
+        """获取推荐的代理模式"""
+        env = asyncio.run(self.detect_environment())
+        
+        if env["vpn_active"] and env["global_reachable"]:
+            return "vpn"
+        elif env["china_reachable"] and not env["global_reachable"]:
+            return "china_only"
+        elif env["global_reachable"] and env["china_reachable"]:
+            return "auto"
+        else:
+            return "direct"
+    
+    async def quick_test(self, host: str = "www.baidu.com", port: int = 80) -> bool:
+        """快速网络测试"""
+        return await self._test_host(host, port, timeout=2.0)