@hupan56/wlkj 3.2.0 → 3.3.0

package/templates/qoder/commands/wl-test.md

@@ -1,6 +1,6 @@
 ---
 name: wl-test
-description: "测试: quick(意图式用例,默认) / browser(Playwright浏览器) / unit(单元) / coverage(覆盖矩阵)。"
+description: "测试: quick(意图式用例,默认) / browser(Playwright浏览器) / unit(单元) / coverage(测试覆盖矩阵)。"
 argument-hint: "[quick|browser|unit|coverage] <描述或任务>"
 auto-approve: false
 allowed-tools: [Read, Glob, Grep, Bash, Write, Edit]
@@ -91,6 +91,10 @@ $PY "$R/.qoder/scripts/orchestration/wlkj.py" test quick \
 $PY "$R/.qoder/scripts/orchestration/wlkj.py" test quick --record '{"Q-1":"pass","Q-2":"fail"}'
 ```
 
+### 下一步
+- 用例全过 → `/wl-commit <[#REQ-xxx] message>` 提交回流（双通飞轮：quick 测 → commit 回流 → `/wl-task finish <REQ-ID>` 收尾）
+- 有失败 → 列原因，修复后重跑 quick，再 commit
+
 ---
 
 ## browser 基于任务的浏览器测试（需先有任务）
@@ -124,6 +128,17 @@ python -c "import json; d=json.load(open('$R/data/index/test-pages.json')); prin
 输出：哪些功能/页面有测试用例（test-pages.json + test-assertions.json），哪些是空白。
 AI 据此建议"优先补 XX 功能的测试"。
 
+### 改动驱动的必跑测试（提交前门禁 · S4 覆盖推理）
+
+改完代码要确定"必跑哪些测试"时，用覆盖推理四件套（已注册 MCP）：
+```python
+cap.mcp.call("impact_coverage", {"entity_ids": ["<改动实体id1>", "<id2>"]})  # 改动集→必跑测试
+cap.mcp.call("find_tests_of", {"entity_id": "<某实体id>"})          # 查某实体的测试
+cap.mcp.call("find_coverage_of", {"req_id": "<REQ-ID>"})            # 查某需求的覆盖
+```
+- `impact_coverage` 拿"这次改动必须跑哪些测试"——提交前用它圈定回归范围，不漏不改崩。
+- 改动实体 id 从 `rag_search`/`search_code` 命中里取。
+
 ---
 
 ## unit 单元测试

package/templates/qoder/contracts/spec.md

@@ -50,12 +50,16 @@ module: policy
 endpoints: [POST /api/policy/amend, GET /api/policy/amend/{id}]
 status: draft
 zentao: task=1453 story=761
+zentao_id: 761
+platform_spec_id:
 -->
 ```
 
 **字段说明**：
 - `status`：状态机见下表，/wl-code spec gate 的判据。
 - `zentao`：禅道 task 来的必须填（task+story）；本地来的留空，待回填时补。回填 task 后 spec 摘要写入该 task 的 `desc`。
+- `zentao_id`：禅道 story 号（关联键，= zentao 的 story）。spec_upload 据此让平台反查 Requirement 挂载；缺失则上传暂存待产品推禅道后回填。
+- `platform_spec_id`：平台 spec id（幂等锚）。spec_upload 首次 create 后自动回写，**勿手填**；有值则下次上传走 update_spec（新增版本不重复建）。
 
 **`status` 状态机**（/wl-code spec gate 的判据）：
 

package/templates/qoder/hooks/post-tool-use.py

@@ -107,6 +107,42 @@ def _dev():
     return None
 
 
+def _auto_learn_from_prd(prd_path):
+    """PRD 写完后自动调 MCP learn 沉淀业务规则（宿主能力接入）。
+
+    读 PRD 标题 → 调工作台 MCP learn → 知识层自动积累。
+    失败静默（铁律：hook 崩溃不阻塞会话）。
+    """
+    try:
+        title = os.path.basename(prd_path).replace('.md', '')
+        # 读 mcp_config 拿 token
+        cfg_path = os.path.join(BASE, 'wlinkj-workflow', 'mcp_config.json')
+        if not os.path.isfile(cfg_path):
+            return
+        import json as _j
+        cfg = _j.load(open(cfg_path, encoding='utf-8'))
+        srv = cfg.get('mcpServers', {}).get('wlinkj-knowledge', {})
+        token = srv.get('token', '')
+        url = srv.get('url', '').replace('/mcp', '/mcp')  # 保持 /mcp
+        pid = srv.get('env', {}).get('WLKJ_PROJECT_ID', '')
+        if not token or not url or not pid:
+            return
+        # 调 MCP learn（POST /mcp JSON-RPC）
+        import urllib.request
+        rpc = {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
+               "params": {"name": "learn",
+                          "arguments": {"project_id": pid, "category": "decision",
+                                        "pattern": "PRD更新: " + title,
+                                        "source": "qoder-hook-auto"}}}
+        req = urllib.request.Request(
+            url, data=_j.dumps(rpc).encode(),
+            headers={"Content-Type": "application/json", "X-MCP-Token": token},
+            method="POST")
+        urllib.request.urlopen(req, timeout=5).read()  # 5s 超时，不阻塞
+    except Exception:
+        pass  # 铁律：静默
+
+
 def _append_event(event, data):
     """best-effort append 一条事件到当前 dev 的 feedback.jsonl。避开 learn import 断链, 直接写文件。"""
     try:
@@ -160,8 +196,13 @@ def main():
                 plow = p.lower().replace('\\', '/')
                 if 'prd' in os.path.basename(plow).lower() and plow.endswith('.md'):
                     _append_event('prd_written', {'prd': os.path.basename(p), 'tool': tool_name})
+                    # ★ 宿主能力接入：PRD 写完 → 自动调 MCP learn 沉淀业务规则
+                    _auto_learn_from_prd(p)
                 if plow.endswith('task.json'):
                     _append_event('task_touched', {'task_json': os.path.basename(os.path.dirname(p)), 'tool': tool_name})
+                # ★ 宿主能力接入：代码文件改完 → 自动记 code_changed（知识层下次检测过时用）
+                if any(plow.endswith(ext) for ext in ('.java', '.vue', '.ts', '.js', '.py')):
+                    _append_event('code_changed', {'file': os.path.basename(p), 'path': plow[:200]})
                 # v3.1 软提示: prototype HTML 写完但缺来源锚定 → stderr 提醒(不阻断)
                 if 'prototype' in os.path.basename(plow) and plow.endswith('.html'):
                     try:

package/templates/qoder/hooks/session-start.py

@@ -134,7 +134,7 @@ def get_index_info():
         pass
 
     lines.append('## Knowledge Graph')
-    lines.append('MCP工具 (QoderWork自动调用): search_code / get_impact / coverage_matrix / get_workflow 等17个')
+    lines.append('MCP工具 (Qoder/QoderWork自动调用): search_code / rag_search / get_impact / project_brief / graphrag_ask 等43个')
     lines.append('  python .qoder/scripts/orchestration/wlkj.py search <keyword> [--platform web|app]')
     lines.append('  python .qoder/scripts/orchestration/wlkj.py context <keyword>   # 一次打包全部上下文')
 
@@ -149,72 +149,40 @@ def get_index_info():
                     role = _line.split('=', 1)[1].strip()
     except Exception:
         pass
-    db_path = os.path.join(BASE, 'data', 'index', 'kg.duckdb')
-
-    if os.path.isfile(db_path):
-        import time as _time
-        db_mtime = os.path.getmtime(db_path)
-        db_age_hours = (_time.time() - db_mtime) / 3600
-
-        # 检查代码是否比 DuckDB 新 (采样几个文件)
-        code_dir = os.path.join(BASE, 'data', 'code')
-        code_newer = False
-        if os.path.isdir(code_dir):
-            for root, dirs, files in os.walk(code_dir):
-                dirs[:] = [d for d in dirs if d not in ('node_modules', '.git', 'dist', '__pycache__')]
-                depth = root[len(code_dir):].count(os.sep)
-                if depth >= 3:
-                    dirs[:] = []
-                    continue
-                for fn in files:
-                    if fn.endswith(('.vue', '.java', '.ts')):
-                        try:
-                            if os.path.getmtime(os.path.join(root, fn)) > db_mtime:
-                                code_newer = True
-                                break
-                        except OSError:
-                            pass
-                if code_newer:
-                    break
-
-        lines.append('  kg.duckdb: %.0f小时前构建' % db_age_hours)
-
-        if role in ('admin', 'dev'):
-            # 管理员/开发: 能构建
-            if code_newer or db_age_hours > 168:  # 7天 = 168小时
-                lines.append('  [WARN] 知识图谱过期! 代码有新变更.')
-                lines.append('  → 管理员请运行: python .qoder/scripts/kg/kg_build.py')
-                lines.append('  → 完成后: python .qoder/scripts/orchestration/wlkj.py sync push (共享给团队)')
-            else:
-                lines.append('  ✓ 知识图谱最新')
-        else:
-            # 非管理员: 只拉取
-            if code_newer or db_age_hours > 168:
-                lines.append('  [WARN] 知识图谱可能过期.')
-                lines.append('  → 运行: python .qoder/scripts/orchestration/wlkj.py sync pull (获取管理员最新构建)')
-            else:
-                lines.append('  ✓ 知识图谱最新')
-
-        # 检查是否有未标注的模块 (提示AI做语义标注)
-        try:
-            import subprocess as _sp
-            # v3.x: kg_semantic.py 已迁移到 domain/kg/graph/ (旧扁平路径不存在)
-            r = _sp.run([sys.executable, os.path.join(BASE, '.qoder', 'scripts', 'domain', 'kg', 'graph', 'kg_semantic.py'), '--check'],
-                        capture_output=True, text=True, encoding='utf-8', timeout=5)
-            if r.stdout and 'semantic_labeling_needed' in r.stdout:
-                import json as _json
-                data = _json.loads(r.stdout)
-                unlabeled = len(data.get('modules', []))
-                if unlabeled > 0:
-                    lines.append('  [提示] %d个模块未标注中文名, 运行 kg_semantic.py --check 查看' % unlabeled)
-        except Exception:
-            pass
+    # ★ 知识层健康检查：全迁 PG 后不再检查本地 kg.duckdb（已删除），改探活 MCP 知识层。
+    # 复用 wlinkj-workflow/mcp_config.json 的 token+url，调 get_knowledge_health 拿真实健康分。
+    # best-effort：任何失败都不阻塞会话启动（与其它 hook 铁律一致）。
+    kg_info = None
+    try:
+        import json as _json
+        import urllib.request as _url
+        cfg_path = os.path.join(BASE, 'wlinkj-workflow', 'mcp_config.json')
+        if os.path.isfile(cfg_path):
+            _cfg = _json.load(open(cfg_path, encoding='utf-8'))
+            _srv = _cfg.get('mcpServers', {}).get('wlinkj-knowledge', {})
+            _url_s = _srv.get('url', '')
+            _tok = _srv.get('token', '')
+            if _url_s and _tok and _url_s != 'WILL_BE_FILLED_BY_WL_INIT':
+                _rpc = {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
+                        "params": {"name": "get_knowledge_health", "arguments": {}}}
+                _req = _url.Request(_url_s, data=_json.dumps(_rpc).encode(),
+                                    headers={"Content-Type": "application/json",
+                                             "X-MCP-Token": _tok}, method="POST")
+                _resp = _url.urlopen(_req, timeout=4).read()
+                kg_info = _json.loads(_json.loads(_resp)["result"]["content"][0]["text"])
+    except Exception:
+        kg_info = None
+
+    if kg_info and isinstance(kg_info, dict) and "error" not in kg_info:
+        lines.append('  ✓ 知识层在线 (PG@5432): 健康分 %s / 覆盖 %s / 新鲜 %s / 完整 %s' % (
+            kg_info.get("score", "?"), kg_info.get("coverage", "?"),
+            kg_info.get("freshness", "?"), kg_info.get("completeness", "?")))
+        issues = kg_info.get("issues", []) or []
+        if issues and role in ('admin', 'dev'):
+            lines.append('  [提示] 健康问题: ' + '; '.join(str(i)[:60] for i in issues[:2]))
     else:
-        lines.append('  [MISSING] kg.duckdb 不存在!')
-        if role in ('admin', 'dev'):
-            lines.append('  → 运行: python .qoder/scripts/kg/kg_build.py')
-        else:
-            lines.append('  → 运行: python .qoder/scripts/orchestration/wlkj.py sync pull')
+        lines.append('  [WARN] 知识层未响应（MCP 后端未启动？）')
+        lines.append('  → 启动: cd wlinkj-workspace && start_pg.bat（后端 :10010）')
 
     return NL.join(lines)
 

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 []
+