@hupan56/wlkj 3.3.1 → 3.3.3

package/templates/qoder/scripts/capability/registry_mcp.py

@@ -1,312 +1,312 @@
-# -*- coding: utf-8 -*-
-"""
-capability.registry_mcp —— MCP 工具路由（tool → server → transport）。
-
-设计模式: Registry + Strategy（配合 transports 层）
-
-职责：
-    1. 声明现有 MCP server 清单及其默认 transport（配置驱动，留远程化扩展点）。
-    2. 维护 server → Transport 实例池（复用子进程/连接）。
-    3. 构建 tool 名 → server 名 的反向索引（懒加载，首次需要时遍历 tools/list）。
-    4. resolve_tool(tool_name) → 该 tool 所在 server 的 Transport。
-
-扩展点（配置驱动远程化）：
-    未来知识图谱上服务器，把 SERVERS["qoder-knowledge-graph"]["kind"] 改成 "http"
-    + 填 url，工作流 (cap.mcp.call) 零改动。
-    这是"满足现在同时留扩展给未来"的核心机制。
-"""
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import Optional
-
-from protocol.transports import get_transport, Transport, NoOpTransport, ToolResult
-
-
-# =============================================================================
-# SERVERS —— MCP server 清单 + 默认 transport 配置（单一事实源）
-# -----------------------------------------------------------------------------
-# 每个条目：
-#   kind:   传输方式 ("stdio"|"cli"|"http")
-#   launcher_arg: mcp_launcher 接受的子名（多数同 key）
-#   url:    http 时的远程 endpoint（stdio/cli 不用）
-# 未来改这里即可切换部署形态，工作流零改动。
-# =============================================================================
-
-# =============================================================================
-# mcp_config.json 消费 —— 让配置文件真正生效（单一事实源）
-# -----------------------------------------------------------------------------
-# 历史 bug: mcp_config.json / registry_mcp_config.json 是"死配置"（全仓 0 读取），
-# registry 用硬编码 SERVERS。改配置文件不生效。
-# 现在: 优先读 .qoder/mcp_config.json 的 mcpServers，读不到才 fallback。
-# =============================================================================
-# 配置文件中知识层 server 的别名映射（统一命名，两边都支持）：
-#   mcp_config.json 里叫 "wlinkj-knowledge"，本地硬编码叫 "qoder-knowledge-graph"。
-#   让 _load_servers 把 config 的 server 也注册成 "qoder-knowledge-graph" 别名，
-#   这样反向索引 / 显式 server 调用两边名字都能命中。
-_KNOWLEDGE_SERVER_ALIASES = ["wlinkj-knowledge", "qoder-knowledge-graph"]
-
-# 硬编码 fallback（配置文件读不到时兜底，保证引擎不崩）
-SERVERS: dict[str, dict] = {
-    "qoder-knowledge-graph": {
-        "kind": "http",
-        "url": os.environ.get("WLKJ_BASE_URL", "http://10.89.7.120") + "/mcp",
-        "note": "知识图谱。已改为 http 模式，指向资产平台 MCP 服务（POST /mcp JSON-RPC）",
-    },
-    "qoder-zentao": {
-        "kind": "stdio",
-        "launcher_arg": "zentao",
-        "note": "禅道任务/Bug/需求",
-    },
-    "qoder-mysql": {
-        "kind": "stdio",
-        "launcher_arg": "mysql",
-        "note": "只读 MySQL 结构/数据",
-    },
-    "lanhu": {
-        "kind": "stdio",
-        "launcher_arg": "lanhu",
-        "note": "蓝湖设计稿",
-    },
-}
-
-
-def _mcp_config_path() -> Path:
-    """定位 mcp_config.json（在仓库根/宿主下）。"""
-    repo = _get_repo_root()
-    # registry_mcp.py 在 .../scripts/capability/, mcp_config.json 在宿主根（.qoder）。
-    for cand in [
-        repo / "mcp_config.json",
-        repo / "registry_mcp_config.json",
-    ]:
-        if cand.is_file():
-            return cand
-    return repo / "mcp_config.json"
-
-
-def _load_servers() -> dict[str, dict]:
-    """从 mcp_config.json 加载 mcpServers，合并到硬编码 SERVERS 上。
-
-    配置文件优先（改配置真生效），硬编码兜底（配置缺失也不崩）。
-    同时把知识层 server 注册多个别名（wlinkj-knowledge / qoder-knowledge-graph），
-    让引擎用任一名字都能调到。
-    """
-    import json as _json
-
-    merged: dict[str, dict] = {k: dict(v) for k, v in SERVERS.items()}
-    try:
-        cfg_path = _mcp_config_path()
-        if not cfg_path.is_file():
-            return merged
-        with open(cfg_path, encoding="utf-8") as f:
-            cfg = _json.load(f)
-        mcp_servers = cfg.get("mcpServers") or {}
-        for name, spec in mcp_servers.items():
-            if not isinstance(spec, dict):
-                continue
-            # 剥离 _comment / _usage 等说明字段，只留 kind/url/token/env/launcher_arg/note
-            clean = {k: v for k, v in spec.items() if not k.startswith("_")}
-            # 知识层 server: 注册全部别名，都指向同一份配置
-            if name in _KNOWLEDGE_SERVER_ALIASES:
-                for alias in _KNOWLEDGE_SERVER_ALIASES:
-                    merged[alias] = clean
-            else:
-                merged[name] = clean
-    except Exception:
-        # 读配置失败绝不能让引擎崩 —— 退回硬编码
-        pass
-    return merged
-
-
-def _get_repo_root() -> Path:
-    """从 common.paths 获取仓库根（复用既有工具，不重复造轮子）。"""
-    try:
-        from foundation.core.paths import get_repo_root
-        return get_repo_root()
-    except Exception:
-        return Path(__file__).resolve().parent.parent.parent.parent
-
-
-class McpRegistry:
-    """MCP 工具路由 + Transport 实例池。
-
-    线程安全说明：实例池按 server 名缓存 Transport，每个 Transport 自带锁。
-    反向索引构建期间对多 server 并发（线程池），构建后只读。
-    """
-
-    def __init__(self, repo_root: Optional[Path] = None, servers: Optional[dict] = None):
-        self._repo = repo_root or _get_repo_root()
-        # 默认从 mcp_config.json 加载（改配置真生效），显式传 servers 时覆盖
-        self._servers = servers if servers is not None else _load_servers()
-        self._pool: dict[str, Transport] = {}
-        self._tool_to_server: Optional[dict[str, str]] = None  # 懒构建
-        self._index_lock_built = False
-
-    # ------------------------------------------------------------------
-    # Transport 实例池
-    # ------------------------------------------------------------------
-
-    def _get_or_create(self, server_name: str) -> Transport:
-        """按 server 名取/建 Transport 实例（复用）。"""
-        if server_name not in self._pool:
-            cfg = self._servers.get(server_name, {})
-            kind = cfg.get("kind", "stdio")
-            launcher_arg = cfg.get("launcher_arg", server_name)
-            if kind == "stdio":
-                self._pool[server_name] = get_transport(
-                    launcher_arg, kind="stdio", repo_root=self._repo,
-                )
-            elif kind == "http":
-                self._pool[server_name] = get_transport(
-                    server_name, kind="http",
-                    url=cfg.get("url", ""), token=cfg.get("token"),
-                )
-            else:
-                self._pool[server_name] = get_transport(
-                    server_name, kind=kind, repo_root=self._repo, **cfg,
-                )
-        return self._pool[server_name]
-
-    # ------------------------------------------------------------------
-    # 反向索引（tool 名 → server 名）
-    # ------------------------------------------------------------------
-
-    def _build_index(self) -> None:
-        """对所有 server 发 tools/list，建 tool→server 反向索引。
-
-        并发构建（各 server 独立 transport，互不干扰）。
-        不可用的 server 跳过（其 tool 不进索引）。
-        """
-        import concurrent.futures
-
-        index: dict[str, str] = {}
-
-        def _probe(server_name: str) -> tuple[str, list[dict]]:
-            try:
-                t = self._get_or_create(server_name)
-                tools = t.list_tools()
-                return server_name, tools
-            except Exception:
-                return server_name, []
-
-        with concurrent.futures.ThreadPoolExecutor(max_workers=len(self._servers) or 1) as ex:
-            for server_name, tools in ex.map(_probe, list(self._servers.keys())):
-                for tool in tools:
-                    tname = tool.get("name", "")
-                    if tname:
-                        index[tname] = server_name
-
-        self._tool_to_server = index
-        # ★ 修复: 全空索引不标记为"已建好"。
-        # 原版无论结果如何都设 _index_lock_built=True + 赋空 dict,
-        # 导致 _ensure_index (判 is None) 永不重建 → 一次冷启动竞态失败就永久 0 工具。
-        # 现改为: 空 = 视为未建, 下次调用会重试 (并发冷启动是间歇性的, 重试通常成功)。
-        if index:
-            self._index_lock_built = True
-        else:
-            # 保留 None, 下次 _ensure_index 会重 _build_index
-            self._tool_to_server = None
-
-    def _ensure_index(self) -> None:
-        if self._tool_to_server is None:
-            self._build_index()
-
-    # ------------------------------------------------------------------
-    # 公共 API
-    # ------------------------------------------------------------------
-
-    def resolve_tool(self, tool_name: str) -> Optional[Transport]:
-        """按 tool 名解析其所在 server 的 Transport。未知返回 None。"""
-        self._ensure_index()
-        server = (self._tool_to_server or {}).get(tool_name)
-        if not server:
-            return None
-        return self._get_or_create(server)
-
-    def has_tool(self, tool_name: str) -> bool:
-        """某 tool 是否可用（先查反向索引；未命中尝试解析）。"""
-        self._ensure_index()
-        if tool_name in (self._tool_to_server or {}):
-            return True
-        t = self.resolve_tool(tool_name)
-        if t is None:
-            return False
-        try:
-            return t.has_tool(tool_name)
-        except Exception:
-            return False
-
-    def call(self, tool_name: str, args: Optional[dict] = None,
-             server: Optional[str] = None) -> ToolResult:
-        """调用工具。
-
-        Args:
-            tool_name: 工具名（如 list_execution_tasks）。
-            args: 工具参数。
-            server: 显式指定 server 名（跳过反向索引，避免首次开销）。
-        Returns:
-            ToolResult。未知工具/不可用返回 is_error=True 的空结果，不抛异常。
-        """
-        transport: Transport
-        if server:
-            if server not in self._servers:
-                return ToolResult(text="未知 server: %s" % server, is_error=True)
-            transport = self._get_or_create(server)
-        else:
-            transport = self.resolve_tool(tool_name) or NoOpTransport()
-        if not transport.available:
-            return ToolResult(
-                text="transport 不可用 (server=%s, tool=%s)" % (server or "?", tool_name),
-                is_error=True,
-            )
-        return transport.call_tool(tool_name, args or {})
-
-    def available(self) -> bool:
-        """任一 server 可用即为 True。"""
-        self._ensure_index()
-        return bool(self._tool_to_server)
-
-    def describe(self) -> dict:
-        """诊断：各 server 的 transport 状态 + 已索引工具数 + 延迟 + PID。"""
-        import time as _time
-        self._ensure_index()
-        servers_status = {}
-        for name in self._servers:
-            t = self._pool.get(name)
-            indexed = [tn for tn, sn in (self._tool_to_server or {}).items() if sn == name]
-
-            # latency: 测量 list_tools 的首次延迟（已在 _build_index 期间完成，此处重新测）
-            latency_ms = None
-            if t and t.available:
-                try:
-                    t0 = _time.monotonic()
-                    t.list_tools()  # 有缓存，很快
-                    latency_ms = round((_time.monotonic() - t0) * 1000, 1)
-                except Exception:
-                    pass
-
-            # spawn_pid: stdio transport 的子进程 PID
-            spawn_pid = None
-            if t and hasattr(t, "_proc") and t._proc is not None:
-                spawn_pid = getattr(t._proc, "pid", None)
-
-            servers_status[name] = {
-                "kind": self._servers[name].get("kind", "stdio"),
-                "available": bool(t and t.available),
-                "tools_indexed": len(indexed),
-                "latency_ms": latency_ms,
-                "spawn_pid": spawn_pid,
-            }
-        return {"servers": servers_status, "total_tools": len(self._tool_to_server or {})}
-
-    def close_all(self) -> None:
-        """关闭所有 Transport（进程退出/连接释放）。"""
-        for t in self._pool.values():
-            try:
-                t.close()
-            except Exception:
-                pass
-        self._pool.clear()
-        self._tool_to_server = None
-        self._index_lock_built = False
+# -*- coding: utf-8 -*-
+"""
+capability.registry_mcp —— MCP 工具路由（tool → server → transport）。
+
+设计模式: Registry + Strategy（配合 transports 层）
+
+职责：
+    1. 声明现有 MCP server 清单及其默认 transport（配置驱动，留远程化扩展点）。
+    2. 维护 server → Transport 实例池（复用子进程/连接）。
+    3. 构建 tool 名 → server 名 的反向索引（懒加载，首次需要时遍历 tools/list）。
+    4. resolve_tool(tool_name) → 该 tool 所在 server 的 Transport。
+
+扩展点（配置驱动远程化）：
+    未来知识图谱上服务器，把 SERVERS["qoder-knowledge-graph"]["kind"] 改成 "http"
+    + 填 url，工作流 (cap.mcp.call) 零改动。
+    这是"满足现在同时留扩展给未来"的核心机制。
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from protocol.transports import get_transport, Transport, NoOpTransport, ToolResult
+
+
+# =============================================================================
+# SERVERS —— MCP server 清单 + 默认 transport 配置（单一事实源）
+# -----------------------------------------------------------------------------
+# 每个条目：
+#   kind:   传输方式 ("stdio"|"cli"|"http")
+#   launcher_arg: mcp_launcher 接受的子名（多数同 key）
+#   url:    http 时的远程 endpoint（stdio/cli 不用）
+# 未来改这里即可切换部署形态，工作流零改动。
+# =============================================================================
+
+# =============================================================================
+# mcp_config.json 消费 —— 让配置文件真正生效（单一事实源）
+# -----------------------------------------------------------------------------
+# 历史 bug: mcp_config.json / registry_mcp_config.json 是"死配置"（全仓 0 读取），
+# registry 用硬编码 SERVERS。改配置文件不生效。
+# 现在: 优先读 .qoder/mcp_config.json 的 mcpServers，读不到才 fallback。
+# =============================================================================
+# 配置文件中知识层 server 的别名映射（统一命名，两边都支持）：
+#   mcp_config.json 里叫 "wlinkj-knowledge"，本地硬编码叫 "qoder-knowledge-graph"。
+#   让 _load_servers 把 config 的 server 也注册成 "qoder-knowledge-graph" 别名，
+#   这样反向索引 / 显式 server 调用两边名字都能命中。
+_KNOWLEDGE_SERVER_ALIASES = ["wlinkj-knowledge", "qoder-knowledge-graph"]
+
+# 硬编码 fallback（配置文件读不到时兜底，保证引擎不崩）
+SERVERS: dict[str, dict] = {
+    "qoder-knowledge-graph": {
+        "kind": "http",
+        "url": os.environ.get("WLKJ_BASE_URL", "http://10.89.7.120") + "/mcp",
+        "note": "知识图谱。已改为 http 模式，指向资产平台 MCP 服务（POST /mcp JSON-RPC）",
+    },
+    "qoder-zentao": {
+        "kind": "stdio",
+        "launcher_arg": "zentao",
+        "note": "禅道任务/Bug/需求",
+    },
+    "qoder-mysql": {
+        "kind": "stdio",
+        "launcher_arg": "mysql",
+        "note": "只读 MySQL 结构/数据",
+    },
+    "lanhu": {
+        "kind": "stdio",
+        "launcher_arg": "lanhu",
+        "note": "蓝湖设计稿",
+    },
+}
+
+
+def _mcp_config_path() -> Path:
+    """定位 mcp_config.json（在仓库根/宿主下）。"""
+    repo = _get_repo_root()
+    # registry_mcp.py 在 .../scripts/capability/, mcp_config.json 在宿主根（.qoder）。
+    for cand in [
+        repo / "mcp_config.json",
+        repo / "registry_mcp_config.json",
+    ]:
+        if cand.is_file():
+            return cand
+    return repo / "mcp_config.json"
+
+
+def _load_servers() -> dict[str, dict]:
+    """从 mcp_config.json 加载 mcpServers，合并到硬编码 SERVERS 上。
+
+    配置文件优先（改配置真生效），硬编码兜底（配置缺失也不崩）。
+    同时把知识层 server 注册多个别名（wlinkj-knowledge / qoder-knowledge-graph），
+    让引擎用任一名字都能调到。
+    """
+    import json as _json
+
+    merged: dict[str, dict] = {k: dict(v) for k, v in SERVERS.items()}
+    try:
+        cfg_path = _mcp_config_path()
+        if not cfg_path.is_file():
+            return merged
+        with open(cfg_path, encoding="utf-8") as f:
+            cfg = _json.load(f)
+        mcp_servers = cfg.get("mcpServers") or {}
+        for name, spec in mcp_servers.items():
+            if not isinstance(spec, dict):
+                continue
+            # 剥离 _comment / _usage 等说明字段，只留 kind/url/token/env/launcher_arg/note
+            clean = {k: v for k, v in spec.items() if not k.startswith("_")}
+            # 知识层 server: 注册全部别名，都指向同一份配置
+            if name in _KNOWLEDGE_SERVER_ALIASES:
+                for alias in _KNOWLEDGE_SERVER_ALIASES:
+                    merged[alias] = clean
+            else:
+                merged[name] = clean
+    except Exception:
+        # 读配置失败绝不能让引擎崩 —— 退回硬编码
+        pass
+    return merged
+
+
+def _get_repo_root() -> Path:
+    """从 common.paths 获取仓库根（复用既有工具，不重复造轮子）。"""
+    try:
+        from foundation.core.paths import get_repo_root
+        return get_repo_root()
+    except Exception:
+        return Path(__file__).resolve().parent.parent.parent.parent
+
+
+class McpRegistry:
+    """MCP 工具路由 + Transport 实例池。
+
+    线程安全说明：实例池按 server 名缓存 Transport，每个 Transport 自带锁。
+    反向索引构建期间对多 server 并发（线程池），构建后只读。
+    """
+
+    def __init__(self, repo_root: Optional[Path] = None, servers: Optional[dict] = None):
+        self._repo = repo_root or _get_repo_root()
+        # 默认从 mcp_config.json 加载（改配置真生效），显式传 servers 时覆盖
+        self._servers = servers if servers is not None else _load_servers()
+        self._pool: dict[str, Transport] = {}
+        self._tool_to_server: Optional[dict[str, str]] = None  # 懒构建
+        self._index_lock_built = False
+
+    # ------------------------------------------------------------------
+    # Transport 实例池
+    # ------------------------------------------------------------------
+
+    def _get_or_create(self, server_name: str) -> Transport:
+        """按 server 名取/建 Transport 实例（复用）。"""
+        if server_name not in self._pool:
+            cfg = self._servers.get(server_name, {})
+            kind = cfg.get("kind", "stdio")
+            launcher_arg = cfg.get("launcher_arg", server_name)
+            if kind == "stdio":
+                self._pool[server_name] = get_transport(
+                    launcher_arg, kind="stdio", repo_root=self._repo,
+                )
+            elif kind == "http":
+                self._pool[server_name] = get_transport(
+                    server_name, kind="http",
+                    url=cfg.get("url", ""), token=cfg.get("token"),
+                )
+            else:
+                self._pool[server_name] = get_transport(
+                    server_name, kind=kind, repo_root=self._repo, **cfg,
+                )
+        return self._pool[server_name]
+
+    # ------------------------------------------------------------------
+    # 反向索引（tool 名 → server 名）
+    # ------------------------------------------------------------------
+
+    def _build_index(self) -> None:
+        """对所有 server 发 tools/list，建 tool→server 反向索引。
+
+        并发构建（各 server 独立 transport，互不干扰）。
+        不可用的 server 跳过（其 tool 不进索引）。
+        """
+        import concurrent.futures
+
+        index: dict[str, str] = {}
+
+        def _probe(server_name: str) -> tuple[str, list[dict]]:
+            try:
+                t = self._get_or_create(server_name)
+                tools = t.list_tools()
+                return server_name, tools
+            except Exception:
+                return server_name, []
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=len(self._servers) or 1) as ex:
+            for server_name, tools in ex.map(_probe, list(self._servers.keys())):
+                for tool in tools:
+                    tname = tool.get("name", "")
+                    if tname:
+                        index[tname] = server_name
+
+        self._tool_to_server = index
+        # ★ 修复: 全空索引不标记为"已建好"。
+        # 原版无论结果如何都设 _index_lock_built=True + 赋空 dict,
+        # 导致 _ensure_index (判 is None) 永不重建 → 一次冷启动竞态失败就永久 0 工具。
+        # 现改为: 空 = 视为未建, 下次调用会重试 (并发冷启动是间歇性的, 重试通常成功)。
+        if index:
+            self._index_lock_built = True
+        else:
+            # 保留 None, 下次 _ensure_index 会重 _build_index
+            self._tool_to_server = None
+
+    def _ensure_index(self) -> None:
+        if self._tool_to_server is None:
+            self._build_index()
+
+    # ------------------------------------------------------------------
+    # 公共 API
+    # ------------------------------------------------------------------
+
+    def resolve_tool(self, tool_name: str) -> Optional[Transport]:
+        """按 tool 名解析其所在 server 的 Transport。未知返回 None。"""
+        self._ensure_index()
+        server = (self._tool_to_server or {}).get(tool_name)
+        if not server:
+            return None
+        return self._get_or_create(server)
+
+    def has_tool(self, tool_name: str) -> bool:
+        """某 tool 是否可用（先查反向索引；未命中尝试解析）。"""
+        self._ensure_index()
+        if tool_name in (self._tool_to_server or {}):
+            return True
+        t = self.resolve_tool(tool_name)
+        if t is None:
+            return False
+        try:
+            return t.has_tool(tool_name)
+        except Exception:
+            return False
+
+    def call(self, tool_name: str, args: Optional[dict] = None,
+             server: Optional[str] = None) -> ToolResult:
+        """调用工具。
+
+        Args:
+            tool_name: 工具名（如 list_execution_tasks）。
+            args: 工具参数。
+            server: 显式指定 server 名（跳过反向索引，避免首次开销）。
+        Returns:
+            ToolResult。未知工具/不可用返回 is_error=True 的空结果，不抛异常。
+        """
+        transport: Transport
+        if server:
+            if server not in self._servers:
+                return ToolResult(text="未知 server: %s" % server, is_error=True)
+            transport = self._get_or_create(server)
+        else:
+            transport = self.resolve_tool(tool_name) or NoOpTransport()
+        if not transport.available:
+            return ToolResult(
+                text="transport 不可用 (server=%s, tool=%s)" % (server or "?", tool_name),
+                is_error=True,
+            )
+        return transport.call_tool(tool_name, args or {})
+
+    def available(self) -> bool:
+        """任一 server 可用即为 True。"""
+        self._ensure_index()
+        return bool(self._tool_to_server)
+
+    def describe(self) -> dict:
+        """诊断：各 server 的 transport 状态 + 已索引工具数 + 延迟 + PID。"""
+        import time as _time
+        self._ensure_index()
+        servers_status = {}
+        for name in self._servers:
+            t = self._pool.get(name)
+            indexed = [tn for tn, sn in (self._tool_to_server or {}).items() if sn == name]
+
+            # latency: 测量 list_tools 的首次延迟（已在 _build_index 期间完成，此处重新测）
+            latency_ms = None
+            if t and t.available:
+                try:
+                    t0 = _time.monotonic()
+                    t.list_tools()  # 有缓存，很快
+                    latency_ms = round((_time.monotonic() - t0) * 1000, 1)
+                except Exception:
+                    pass
+
+            # spawn_pid: stdio transport 的子进程 PID
+            spawn_pid = None
+            if t and hasattr(t, "_proc") and t._proc is not None:
+                spawn_pid = getattr(t._proc, "pid", None)
+
+            servers_status[name] = {
+                "kind": self._servers[name].get("kind", "stdio"),
+                "available": bool(t and t.available),
+                "tools_indexed": len(indexed),
+                "latency_ms": latency_ms,
+                "spawn_pid": spawn_pid,
+            }
+        return {"servers": servers_status, "total_tools": len(self._tool_to_server or {})}
+
+    def close_all(self) -> None:
+        """关闭所有 Transport（进程退出/连接释放）。"""
+        for t in self._pool.values():
+            try:
+                t.close()
+            except Exception:
+                pass
+        self._pool.clear()
+        self._tool_to_server = None
+        self._index_lock_built = False

package/templates/qoder/scripts/deployment/setup/init_doctor.py

@@ -834,6 +834,7 @@ def check_lanhu():
 def main():
     args = [a for a in sys.argv[1:]]
     fix = '--fix' in args
+    skip_code = '--skip-code' in args or '--cloud' in args
     pos = [a for a in args if not a.startswith('--')]
     name = pos[0] if pos else None
     role = pos[1] if len(pos) > 1 else None
@@ -848,8 +849,11 @@ def main():
     check_dependencies(fix)
     check_developer(fix, name, role)
     check_team_sync(fix)
-    check_source_repos(fix, config)
-    check_index(fix)
+    if skip_code:
+        print('\n--- 4. 源码/索引: 云模式跳过（KG 在云平台，引擎调云 MCP）---')
+    else:
+        check_source_repos(fix, config)
+        check_index(fix)
     check_style(fix)
     check_prd_templates()
     check_weekly(fix)