@hupan56/wlkj 3.0.0 → 3.1.2

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

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+"""
+adapters.cli —— 纯文件降级 Adapter。
+
+设计模式: Adapter（纯 Python 文件实现，无任何宿主依赖）
+
+核心能力的兜底实现，保证纯 CLI / 任意宿主环境也能跑。
+这是"外挂式"的底牌：即便宿主什么能力都不给，工作流仍可用。
+
+实现:
+    - FileRepoCap:     向上找含 .qoder/scripts/ 的目录（复用 common.paths）
+    - FileIdentityCap: 读 .developer（复用 common.paths.get_developer）
+    - FileContextCap:  读配置/偏好文件
+    - FileMemoryCap:   journal 文件记忆（纯文本追加，无语义检索）
+"""
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def _import_paths():
+    """延迟导入 common.paths，避免循环依赖与硬失败。
+
+    Returns:
+        (get_repo_root, get_developer, get_developer_journal_dir) 元组，
+        任一不可用则对应位为 None。
+    """
+    try:
+        from foundation.core.paths import (
+            get_repo_root,
+            get_developer,
+            get_developer_journal_dir,
+        )
+        return get_repo_root, get_developer, get_developer_journal_dir
+    except ImportError:
+        return None, None, None
+
+
+class FileRepoCap:
+    """仓库根发现 —— 向上找含 .qoder/scripts/ 的目录。无 ~/.qoderwork/ 依赖。"""
+
+    available = True  # 核心能力，永远可用
+
+    def root(self) -> Path:
+        get_repo_root, _, _ = _import_paths()
+        if get_repo_root:
+            try:
+                return get_repo_root()
+            except Exception:
+                pass
+        # 兜底：__file__ 向上找
+        current = Path(__file__).resolve()
+        for _ in range(10):
+            if (current / ".qoder" / "scripts").is_dir():
+                return current
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+        return Path.cwd()
+
+
+class FileIdentityCap:
+    """身份 —— 读 .developer 文件。"""
+
+    available = True
+
+    def who(self) -> str | None:
+        _, get_developer, _ = _import_paths()
+        if get_developer:
+            try:
+                dev = get_developer()
+                if dev:
+                    return dev
+            except Exception:
+                pass
+        # 兜底：直接读 .developer
+        dev_file = FileRepoCap().root() / ".developer"
+        if dev_file.is_file():
+            return dev_file.read_text(encoding="utf-8").strip() or None
+        return None
+
+    def role(self) -> str | None:
+        """从 member.json 读取角色（pm/dev/qa/test/admin）。"""
+        try:
+            from foundation.identity.identity import get_role
+            return get_role(self.who())
+        except Exception:
+            return None
+
+    def zentao_account(self) -> str | None:
+        """从 member.json 读取禅道账号映射。"""
+        try:
+            from foundation.identity.identity import get_member
+            member = get_member(self.who() or "")
+            if member:
+                return member.get("zentao_account") or None
+        except Exception:
+            pass
+        return None
+
+
+class FileContextCap:
+    """上下文 —— 读配置/偏好文件。"""
+
+    available = True
+
+    def preferences(self) -> dict:
+        """读 .qoder/settings.json 或 .qoder/config.yaml 中的偏好。"""
+        try:
+            repo = FileRepoCap().root()
+            import json as _json
+            # settings.json 优先
+            sf = repo / ".qoder" / "settings.json"
+            if sf.is_file():
+                with open(sf, encoding="utf-8") as f:
+                    return _json.load(f)
+            # config.yaml 降级
+            import yaml
+            cf = repo / ".qoder" / "config.yaml"
+            if cf.is_file():
+                with open(cf, encoding="utf-8") as f:
+                    return yaml.safe_load(f) or {}
+        except Exception:
+            pass
+        return {}
+
+    def recent_learnings(self, limit: int = 5) -> list[dict]:
+        """读当前开发者的 feedback.jsonl 最近 N 条学习事件。"""
+        try:
+            _, get_developer, get_journal = _import_paths()
+            if not (get_developer and get_journal):
+                return []
+            dev = get_developer()
+            if not dev:
+                return []
+            fb = get_journal(dev) / "feedback.jsonl"
+            if not fb.is_file():
+                return []
+            import json as _json
+            with open(fb, encoding="utf-8") as f:
+                lines = [l.strip() for l in f if l.strip()]
+            results = []
+            for line in reversed(lines[-limit:]):
+                try:
+                    results.append(_json.loads(line))
+                except _json.JSONDecodeError:
+                    continue
+            return results
+        except Exception:
+            return []
+
+
+class FileMemoryCap:
+    """记忆 —— journal 文件降级（feedback.jsonl + memory.md）。
+
+    存储位置: workspace/members/{dev}/journal/（复用 common.paths）。
+    available 探测到 journal 目录可写时为 True。
+
+    实现:
+        - remember: 追加到 memory.md（带 key 标题）
+        - recall:   扫 memory.md + feedback.jsonl 关键词匹配（非语义，纯子串）
+        - get_fact: 精确匹配 memory.md 的 key 标题块
+        - list_recent: 返回最近 N 条（memory.md 最新 + feedback.jsonl 最新）
+    """
+
+    def __init__(self):
+        self._available = self._probe()
+
+    def _probe(self) -> bool:
+        try:
+            _, get_developer, get_journal = _import_paths()
+            if not (get_developer and get_journal):
+                return False
+            dev = get_developer()
+            if not dev:
+                return False
+            journal_dir = get_journal(dev)
+            journal_dir.mkdir(parents=True, exist_ok=True)
+            return journal_dir.is_dir()
+        except Exception:
+            return False
+
+    def _journal_dir(self):
+        _, get_developer, get_journal = _import_paths()
+        if not (get_developer and get_journal):
+            return None
+        try:
+            dev = get_developer()
+            if not dev:
+                return None
+            return get_journal(dev)
+        except Exception:
+            return None
+
+    @property
+    def available(self) -> bool:
+        return self._available
+
+    def recall(self, query: str) -> list[dict]:
+        """关键词检索：扫 memory.md + feedback.jsonl，返回含 query 的条目。"""
+        if not self._available or not query:
+            return []
+        jdir = self._journal_dir()
+        if jdir is None:
+            return []
+        results = []
+
+        # 1) memory.md 关键词匹配
+        mem_file = jdir / "memory.md"
+        if mem_file.is_file():
+            try:
+                content = mem_file.read_text(encoding="utf-8")
+                for block in content.split("\n## "):
+                    if query.lower() in block.lower():
+                        results.append({"source": "memory.md", "text": block.strip()})
+            except Exception:
+                pass
+
+        # 2) feedback.jsonl 关键词匹配
+        fb_file = jdir / "feedback.jsonl"
+        if fb_file.is_file():
+            import json as _json
+            try:
+                with open(fb_file, encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            entry = _json.loads(line)
+                            text = _json.dumps(entry, ensure_ascii=False)
+                            if query.lower() in text.lower():
+                                results.append({"source": "feedback.jsonl", "data": entry})
+                        except _json.JSONDecodeError:
+                            continue
+            except Exception:
+                pass
+
+        return results[:20]  # 限制返回数
+
+    def remember(self, key: str, content: str) -> None:
+        if not self._available:
+            return
+        _, get_developer, get_journal = _import_paths()
+        if not (get_developer and get_journal):
+            return
+        try:
+            dev = get_developer()
+            journal_dir = get_journal(dev)
+            ts = datetime.now().strftime("%Y-%m-%d %H:%M")
+            entry = f"\n## [{ts}] {key}\n{content}\n"
+            with open(journal_dir / "memory.md", "a", encoding="utf-8") as f:
+                f.write(entry)
+        except Exception:
+            pass
+
+    def get_fact(self, key: str) -> str | None:
+        """精确匹配 memory.md 中以 key 为标题的块。"""
+        if not self._available or not key:
+            return None
+        jdir = self._journal_dir()
+        if jdir is None:
+            return None
+        mem_file = jdir / "memory.md"
+        if not mem_file.is_file():
+            return None
+        try:
+            content = mem_file.read_text(encoding="utf-8")
+            for block in content.split("\n## "):
+                # 块标题形如 "[2026-06-18 12:30] 某key"
+                if "] " + key in block or block.strip().endswith(key):
+                    return block.strip()
+        except Exception:
+            pass
+        return None
+
+    def list_recent(self, limit: int = 10) -> list[dict]:
+        """返回最近 N 条记忆（memory.md 倒序 + feedback.jsonl 倒序）。"""
+        if not self._available:
+            return []
+        jdir = self._journal_dir()
+        if jdir is None:
+            return []
+        results = []
+
+        # memory.md 块倒序
+        mem_file = jdir / "memory.md"
+        if mem_file.is_file():
+            try:
+                content = mem_file.read_text(encoding="utf-8")
+                blocks = [b.strip() for b in content.split("\n## ") if b.strip()]
+                for b in reversed(blocks[-limit:]):
+                    results.append({"source": "memory.md", "text": b})
+            except Exception:
+                pass
+
+        # feedback.jsonl 最后 N 条
+        fb_file = jdir / "feedback.jsonl"
+        if fb_file.is_file():
+            import json as _json
+            try:
+                with open(fb_file, encoding="utf-8") as f:
+                    lines = [l.strip() for l in f if l.strip()]
+                for line in reversed(lines[-limit:]):
+                    try:
+                        entry = _json.loads(line)
+                        results.append({"source": "feedback.jsonl", "data": entry})
+                    except _json.JSONDecodeError:
+                        continue
+            except Exception:
+                pass
+
+        return results[:limit]

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

@@ -0,0 +1,334 @@
+# -*- coding: utf-8 -*-
+"""
+adapters.mcp —— L1 MCP 能力统一入口（已接通 transport 层）。
+
+设计模式: Adapter + Facade
+
+职责：
+    把 McpRegistry（tool→server→transport 路由）适配成 McpCap 的
+    has_tool/call/list_tools 接口，供 Nexus Facade 统一暴露。
+
+L1 能力定位：禅道/知识图谱/MySQL/蓝湖/playwright 已 MCP 化，
+    通过本入口跨宿主统一调用，复用已有 MCP 资产，绝不重写它们。
+
+跨宿主行为：
+    - QoderWork / 任意宿主：通过 mcp_launcher spawn 本地 MCP server（stdio transport）
+    - 未来服务器：改 McpRegistry.SERVERS 配置 kind=http + url，工作流零改动
+    - 无可用 server：available=False，has_tool 返回 False（静默回退）
+
+McpMemoryProvider：memory 职责链的 MCP provider，接通 kg.duckdb learning_events 表。
+    当 mem0/Zep MCP server 更成熟时可替换为 MCP 版本，接口不变。
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from ..registry_mcp import McpRegistry
+from protocol.transports import ToolResult
+
+
+# 单例 Registry（同一进程复用进程池，避免重复 spawn）
+_REGISTRY: Optional[McpRegistry] = None
+
+
+def _get_registry() -> McpRegistry:
+    global _REGISTRY
+    if _REGISTRY is None:
+        _REGISTRY = McpRegistry()
+    return _REGISTRY
+
+
+class McpCap:
+    """L1 MCP 能力统一入口 —— 复用已有 MCP server（禅道/知识图谱/MySQL/蓝湖）。
+
+    工作流调用：
+        cap = nexus.resolve()
+        result = cap.mcp.call("search_code", {"keyword": "保险"})
+        # 自动路由：MCP 可用走 MCP，不可用走 wlkj.py（CLI 降级）
+    """
+
+    def __init__(self, mcp_servers=None):
+        # ★ 空 mcp_servers (= [] 或 None) 视为"不限制 = 用全部本地 server"。
+        # 原版: mcp_servers=[] (空列表, is not None) → filtered 成空 → _servers={} → 0 工具,
+        # 整个 cap.mcp 自废武功。但本地 stdio transport (StdioTransport) 通过 mcp_launcher
+        # 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}
+            self._registry = McpRegistry(servers=filtered)
+        else:
+            self._registry = _get_registry()
+
+    @property
+    def available(self) -> bool:
+        """是否有任一 MCP server 可用。"""
+        try:
+            return self._registry.available()
+        except Exception:
+            return False
+
+    # ------------------------------------------------------------------
+    # McpCap 接口
+    # ------------------------------------------------------------------
+
+    def has_tool(self, name: str) -> bool:
+        """某 MCP 工具是否可用（跨所有已配置 server 查找）。"""
+        try:
+            return self._registry.has_tool(name)
+        except Exception:
+            return False
+
+    def call(self, name: str, args: Optional[dict] = None,
+             server: Optional[str] = None) -> ToolResult:
+        """调用 MCP 工具（自动 CLI 降级）。
+
+        优先走 MCP；MCP 不可用时自动降级到 wlkj.py CLI 脚本。
+        工作流永远写 cap.mcp.call("tool_name", args)，零宿主感知。
+        """
+        # 1. MCP 可用 → 走 MCP
+        result = self._registry.call(name, args, server=server)
+        if not result.is_error:
+            return result
+        # 2. CLI 降级（MCP 不可用或调用失败）
+        cli_text = self._cli_fallback(name, args or {})
+        if cli_text is not None:
+            return ToolResult(text=cli_text)
+        return result  # 无降级映射，返回原始错误
+
+    # ------------------------------------------------------------------
+    # CLI 降级（MCP 不可用时走 wlkj.py）
+    # ------------------------------------------------------------------
+
+    # MCP 工具名 → (wlkj 命令, 基础参数) 映射
+    # 只映射有 wlkj.py 对应的知识图谱/任务工具。
+    # MySQL/禅道/蓝湖等 MCP 专属工具不映射（MCP 不可用时返回错误提示）。
+    _TOOL_TO_WLKJ = {
+        "search_code":       ("kg", ["search"]),
+        "search_api":        ("kg", ["api"]),
+        "search_prd":        ("kg", ["prd"]),
+        "context_pack":      ("kg", ["context"]),
+        "get_impact":        ("kg", ["impact"]),
+        "context_360":       ("kg", ["context360"]),
+        "coverage_matrix":   ("kg", ["coverage"]),
+        "feature_overview":  ("kg", ["feature"]),
+        "get_workflow":      ("kg", ["workflow"]),
+        "multi_hop":         ("kg", ["hop"]),
+        "search_wiki":       ("kg", ["wiki"]),
+        "fill_prototype":    ("kg", ["fill-prototype"]),
+        "get_design_system": ("kg", ["design-system"]),
+        "list_tasks":        ("task", ["list"]),
+        "create_task":       ("task", ["create"]),
+        "start_task":        ("task", ["start"]),
+        "finish_task":       ("task", ["finish"]),
+    }
+
+    def _cli_fallback(self, tool_name: str, args: dict) -> Optional[str]:
+        """MCP 工具名 → wlkj.py 执行。无映射返回 None。"""
+        entry = self._TOOL_TO_WLKJ.get(tool_name)
+        if entry is None:
+            return None
+        cmd, base_args = entry
+        cli_args = list(base_args)
+        # 从 MCP args 构建命令行参数
+        if "keyword" in args:
+            cli_args.append(str(args["keyword"]))
+        if "platform" in args and args["platform"]:
+            cli_args.extend(["--platform", str(args["platform"])])
+        if "role" in args and args["role"]:
+            cli_args.extend(["--role", str(args["role"])])
+        if "endpoint" in args:
+            cli_args.append(str(args["endpoint"]))
+        if "symbol" in args:
+            cli_args.append(str(args["symbol"]))
+        if "depth" in args:
+            cli_args.extend(["--depth", str(args["depth"])])
+        if "feature" in args:
+            cli_args.append(str(args["feature"]))
+        if "module" in args:
+            cli_args.append(str(args["module"]))
+        if "title" in args:
+            cli_args.append(str(args["title"]))
+        if "table" in args:
+            cli_args.append(str(args["table"]))
+        if "column" in args:
+            cli_args.append(str(args["column"]))
+        if "db" in args and args["db"]:
+            cli_args.extend(["--db", str(args["db"])])
+        if "env" in args and args["env"]:
+            cli_args.extend(["--env", str(args["env"])])
+        return self._run_wlkj(cmd, cli_args)
+
+    @staticmethod
+    def _run_wlkj(cmd: str, args: list) -> str:
+        """调 wlkj.py 执行，返回 stdout。"""
+        import subprocess, sys, os
+        try:
+            from foundation.core.paths import get_repo_root
+            repo = str(get_repo_root())
+        except Exception:
+            repo = os.getcwd()
+        wlkj = os.path.join(repo, ".qoder", "scripts", "orchestration", "wlkj.py")
+        try:
+            r = subprocess.run(
+                [sys.executable, wlkj, cmd] + args,
+                capture_output=True, text=True, timeout=60,
+                encoding="utf-8", errors="replace",
+            )
+            if r.returncode == 0:
+                return r.stdout.strip()
+            return "[cli-fallback error] %s" % (r.stderr or r.stdout)[:200]
+        except subprocess.TimeoutExpired:
+            return "[cli-fallback error] timeout (60s)"
+        except Exception as e:
+            return "[cli-fallback error] %s" % str(e)[:100]
+
+    def list_tools(self, keyword: str = "") -> list[dict]:
+        """枚举可用 MCP 工具（可选按 keyword 过滤）。"""
+        try:
+            self._registry._ensure_index()
+            tools = []
+            for server_name in self._registry._servers:
+                t = self._registry._pool.get(server_name)
+                if t is None:
+                    continue
+                for tool in (t._tools_cache or []):
+                    if keyword and keyword not in tool.get("name", ""):
+                        continue
+                    tool_copy = dict(tool)
+                    tool_copy["_server"] = server_name
+                    tools.append(tool_copy)
+            return tools
+        except Exception:
+            return []
+
+    def describe(self) -> dict:
+        """诊断：各 server 状态。"""
+        try:
+            return self._registry.describe()
+        except Exception as e:
+            return {"error": str(e)[:120]}
+
+
+class McpMemoryProvider:
+    """memory 职责链的 MCP provider —— 接通 kg.duckdb learning_events 表。
+
+    设计模式: Adapter（把 kg.duckdb 适配成 MemoryCap 契约）
+
+    职责链位置: 链头优先（available=True），纯 CLI 环境也能用。
+    当 mem0/Zep MCP server 更成熟时，可替换为 MCP 版本，接口不变。
+
+    数据源: kg.duckdb 的 learning_events 表（id, ts, dev, event, data）。
+    复用 learn_aggregate.py 的写入逻辑，保证 CLI 和 MCP 行为一致。
+    """
+
+    def __init__(self):
+        self._available: bool | None = None  # 懒探测
+
+    @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
+
+    def recall(self, query: str) -> list[dict]:
+        """语义检索记忆: 按 event 或 data 模糊匹配。"""
+        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
+            ]
+        except Exception:
+            return []
+
+    def remember(self, key: str, content: str) -> None:
+        """写入一条记忆: 插入 learning_events 表。"""
+        if not self.available:
+            return
+        try:
+            import hashlib
+            import json
+            import time as _time
+            from foundation.protocol.duckdb_conn import get_db, init_schema
+            con = get_db()
+            init_schema(con)
+            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()
+        except Exception:
+            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
+
+    def list_recent(self, limit: int = 10) -> list[dict]:
+        """最近 N 条记忆。"""
+        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
+        except Exception:
+            return []