@hupan56/wlkj 3.2.0 → 3.3.1

package/templates/qoder/scripts/capability/adapters/__init__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-nexus.adapters —— 各宿主/降级路径的 Cap 实现。
+capability.adapters —— 各宿主/降级路径的 Cap 实现。
 
 设计模式: Adapter + Bridge（Cap 抽象 × 宿主实现 正交）
 

package/templates/qoder/scripts/capability/adapters/mcp.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-from ..registry_mcp import McpRegistry
+from ..registry_mcp import McpRegistry, _load_servers
 from protocol.transports import ToolResult
 
 
@@ -42,7 +42,7 @@ class McpCap:
     """L1 MCP 能力统一入口 —— 复用已有 MCP server（禅道/知识图谱/MySQL/蓝湖）。
 
     工作流调用：
-        cap = nexus.resolve()
+        cap = resolve()
         result = cap.mcp.call("search_code", {"keyword": "保险"})
         # 自动路由：MCP 可用走 MCP，不可用走 wlkj.py（CLI 降级）
     """
@@ -54,8 +54,9 @@ class McpCap:
         # spawn 子进程, 不依赖宿主是否原生支持 MCP —— CLI / Codex / Claude 同样能起 server。
         # 故: 宿主未声明 mcp_servers 或声明为空 = "没有宿主原生限制, 用全部本地可起的"。
         if mcp_servers:  # 非空列表才过滤
-            from ..registry_mcp import SERVERS
-            filtered = {k: v for k, v in SERVERS.items() if k in mcp_servers}
+            # 用 _load_servers() 而非硬编码 SERVERS —— 这样 mcp_config.json 改配置才生效
+            all_servers = _load_servers()
+            filtered = {k: v for k, v in all_servers.items() if k in mcp_servers}
             self._registry = McpRegistry(servers=filtered)
         else:
             self._registry = _get_registry()
@@ -117,6 +118,12 @@ class McpCap:
         "search_wiki":       ("kg", ["wiki"]),
         "fill_prototype":    ("kg", ["fill-prototype"]),
         "get_design_system": ("kg", ["design-system"]),
+        # RAG/GraphRAG 降级映射（MCP 挂时走本地 wlkj.py kg search，语义降级为关键词）
+        "rag_search":        ("kg", ["search"]),
+        "ask_corpus":        ("kg", ["search"]),
+        # 学习工具降级（MCP 挂时本地无 learning 表，返回提示）
+        "learn":             ("noop", []),
+        "get_learnings":     ("noop", []),
         "list_tasks":        ("task", ["list"]),
         "create_task":       ("task", ["create"]),
         "start_task":        ("task", ["start"]),
@@ -129,10 +136,16 @@ class McpCap:
         if entry is None:
             return None
         cmd, base_args = entry
+        # noop 类工具（learn/get_learnings 等）：本地无等价 CLI，返回提示不崩
+        if cmd == "noop":
+            return json.dumps({"degraded": True, "message": "MCP不可用，该工具(learning)降级跳过"}, ensure_ascii=False)
         cli_args = list(base_args)
-        # 从 MCP args 构建命令行参数
-        if "keyword" in args:
-            cli_args.append(str(args["keyword"]))
+        # 从 MCP args 构建命令行参数。
+        # 参数名对齐: 平台 MCP search 工具入参是 query, 引擎命令文档用 keyword。
+        # 这里两边都取值, 确保无论上游传哪个都能落到 CLI 查询词上。
+        kw = args.get("keyword") or args.get("query")
+        if kw is not None:
+            cli_args.append(str(kw))
         if "platform" in args and args["platform"]:
             cli_args.extend(["--platform", str(args["platform"])])
         if "role" in args and args["role"]:
@@ -211,128 +224,91 @@ class McpCap:
 
 
 class McpMemoryProvider:
-    """memory 职责链的 MCP provider —— 接通 kg.duckdb learning_events 表。
+    """memory 职责链的 MCP provider —— 接通平台 PG.learning_patterns。
 
-    设计模式: Adapter（把 kg.duckdb 适配成 MemoryCap 契约）
+    设计模式: Adapter（把平台 MCP get_learnings/learn 适配成 MemoryCap 契约）
 
-    职责链位置: 链头优先（available=True），纯 CLI 环境也能用。
-    当 mem0/Zep MCP server 更成熟时，可替换为 MCP 版本，接口不变。
+    职责链位置: 链头优先。平台 MCP 可用（has_tool get_learnings）时抢占，
+    复用项目级学习表（PG.learning_patterns，按 token 解析 pid 隔离，跨会话积累）。
 
-    数据源: kg.duckdb 的 learning_events 表（id, ts, dev, event, data）。
-    复用 learn_aggregate.py 的写入逻辑，保证 CLI 和 MCP 行为一致。
+    数据源: 平台 MCP 工具 get_learnings / learn（后端 services.knowledge.learn）。
     """
 
     def __init__(self):
-        self._available: bool | None = None  # 懒探测
+        self._registry = None  # 懒取 MCP 单例（避免 import 时即连后端）
+
+    def _reg(self):
+        """复用 McpCap 同款模块级单例（_get_registry），零重复 spawn。"""
+        if self._registry is None:
+            self._registry = _get_registry()
+        return self._registry
 
     @property
     def available(self) -> bool:
-        """kg.duckdb 存在且可读写即为可用。"""
-        if self._available is None:
-            try:
-                from foundation.protocol.duckdb_conn import get_db
-                con = get_db()
-                con.execute("""CREATE TABLE IF NOT EXISTS learning_events (
-                    id TEXT PRIMARY KEY, ts TEXT NOT NULL, dev TEXT NOT NULL,
-                    event TEXT NOT NULL, data JSON)""")
-                con.close()
-                self._available = True
-            except Exception:
-                self._available = False
-        return self._available
+        """平台 MCP 可用且 get_learnings 工具在索引中即为可用。
+        全迁 PG 后记忆走平台 get_learnings（PG.learning_patterns，按项目隔离）。
+        """
+        try:
+            return self._reg().has_tool("get_learnings")
+        except Exception:
+            return False
 
     def recall(self, query: str) -> list[dict]:
-        """语义检索记忆: 按 event 或 data 模糊匹配。"""
+        """检索记忆: 取平台学习记录，按 query 模糊过滤 pattern/category。"""
         if not self.available:
             return []
         try:
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            rows = con.execute(
-                """SELECT id, ts, dev, event, data FROM learning_events
-                   WHERE event LIKE '%' || ? || '%' OR data LIKE '%' || ? || '%'
-                   ORDER BY ts DESC LIMIT 20""",
-                [query, query],
-            ).fetchall()
-            con.close()
-            return [
-                {"id": r[0], "ts": r[1], "dev": r[2], "event": r[3], "data": r[4]}
-                for r in rows
-            ]
+            import json as _json
+            result = self._reg().call("get_learnings", {"limit": 50})
+            text = getattr(result, "text", "") or ""
+            data = _json.loads(text) if text else {}
+            items = data.get("items", []) if isinstance(data, dict) else []
+            q = (query or "").lower()
+            out = []
+            for it in items:
+                hay = "%s %s" % (it.get("category", ""), it.get("pattern", ""))
+                if not q or q in hay.lower():
+                    out.append({
+                        "event": it.get("category", ""),
+                        "data": it.get("pattern", ""),
+                        "ts": it.get("last_seen", ""),
+                        "dev": ",".join(it.get("source_devs", []) or []),
+                    })
+            return out[:20]
         except Exception:
             return []
 
     def remember(self, key: str, content: str) -> None:
-        """写入一条记忆: 插入 learning_events 表。"""
+        """写入一条记忆: 调平台 learn（PG.learning_patterns 累加）。"""
         if not self.available:
             return
         try:
-            import hashlib
-            import json
-            import time as _time
-            # ⚠ 不能 import init_schema! duckdb_conn 故意不导出它 (领域 DDL 留在各域)。
-            # 旧版 from ...duckdb_conn import init_schema → ImportError → 被下面 except 吞掉
-            # → INSERT 永不执行 → remember() 静默丢全部写入。
-            # learning_events 表已由 self.available 的 CREATE TABLE IF NOT EXISTS 保证存在,
-            # 这里直接 INSERT 即可。
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            eid = hashlib.md5(("%s:%s:%s" % (key, content, _time.time())).encode()).hexdigest()[:16]
-            ts = _time.strftime("%Y-%m-%dT%H:%M:%S")
-            data = json.dumps({"content": content}, ensure_ascii=False)
-            con.execute(
-                "INSERT OR IGNORE INTO learning_events(id, ts, dev, event, data) VALUES (?,?,?,?,?)",
-                [eid, ts, "", key, data],
-            )
-            con.close()
+            self._reg().call("learn", {
+                "category": "rule",
+                "pattern": "%s: %s" % (key, content[:500]),
+                "source": "engine/memory",
+            })
         except Exception:
-            pass
+            pass  # 写入失败不阻塞
 
     def get_fact(self, key: str) -> str | None:
-        """按 event 精确查找，返回 data 字段（JSON 字符串）。"""
-        if not self.available:
-            return None
-        try:
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            row = con.execute(
-                "SELECT data FROM learning_events WHERE event = ? ORDER BY ts DESC LIMIT 1",
-                [key],
-            ).fetchone()
-            con.close()
-            if not row:
-                return None
-            data = row[0]
-            if isinstance(data, str):
-                return data
-            import json as _json
-            return _json.dumps(data, ensure_ascii=False) if data else None
-        except Exception:
-            return None
+        """按 key 取一条事实，无则 None。"""
+        results = self.recall(key)
+        return results[0].get("data") if results else None
 
     def list_recent(self, limit: int = 10) -> list[dict]:
-        """最近 N 条记忆。"""
+        """最近 N 条记忆（平台按 frequency 倒序返回）。"""
         if not self.available:
             return []
         try:
             import json as _json
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            rows = con.execute(
-                "SELECT id, ts, dev, event, data FROM learning_events ORDER BY ts DESC LIMIT ?",
-                [limit],
-            ).fetchall()
-            con.close()
-            results = []
-            for r in rows:
-                data = r[4]
-                # DuckDB JSON 列可能返回字符串，需解析
-                if isinstance(data, str):
-                    try:
-                        data = _json.loads(data)
-                    except (_json.JSONDecodeError, TypeError):
-                        data = {"raw": data}
-                results.append({"id": r[0], "ts": r[1], "dev": r[2], "event": r[3], "data": data or {}})
-            return results
+            result = self._reg().call("get_learnings", {"limit": limit})
+            text = getattr(result, "text", "") or ""
+            data = _json.loads(text) if text else {}
+            items = data.get("items", []) if isinstance(data, dict) else []
+            return [{"event": it.get("category", ""), "data": it.get("pattern", ""),
+                     "ts": it.get("last_seen", ""), "dev": ",".join(it.get("source_devs", []) or [])}
+                    for it in items[:limit]]
         except Exception:
             return []
+