@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/whitebox_kb/engine.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+"""whitebox_kb.engine — 白箱引擎的**进程内门面**。
+
+替代旧的「子进程 `python -m aeis.mcp.server`」调用路径：白箱知识库已随主仓
+自带，故直接进程内调用，不再需要外部 MCP 服务，也不再需要理论仓。
+
+对外两级接口
+------------
+· 业务级：`WhiteboxEngine.chat / remember / service_info`
+· 工具级：`WhiteboxEngine.call_tool(name, args)`（返回形状对齐 MCP `tools/call`
+  的 `{isError, text, data}`，供 `md_cg.whitebox.WhiteboxClient` 直接复用）
+
+路由语义（重要）
+----------------
+`_decide_route` 逐字迁自 `aeis/layered.py:185-247`——它是**纯逻辑、零 LLM 依赖**，
+决定「白箱能否自答」。刻意**不带入** LLM 续答层（`layered.route_reply` /
+`llm_complete`）：那需要外部大模型密钥，不属于白箱知识库。
+因此当判定为 `llm`（白箱把握不足，本该交给 LLM）时，本门面降级为
+`self_fallback` —— 与原著在 LLM 不可用时的行为**一致**，不谎称自答。
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import threading
+
+from . import DEFAULT_DB, KNOWLEDGE_DIR, SEED_DIR, WISDOM_DIR  # noqa: F401
+
+#: 可重入锁（RLock）。**勿改回 Lock**：`get_engine()` 是持锁构造引擎的，
+#: 而引擎首启播种（`_do_seed`）会经 `dex` 属性再次申请同一把锁；
+#: 普通 Lock 在同线程重入时即自死锁——表现为「全新库冷启动永久挂死」
+#: （已实测 >400s 不返回），而库已播种时因跳过播种而侥幸正常。
+#: RLock 允许同线程重入，跨线程互斥语义不变。
+_OPEN_LOCK = threading.RLock()
+
+
+# --------------------------------------------------------------------------
+# 图库定位与首启播种
+# --------------------------------------------------------------------------
+
+def resolve_db_path(db_path=None):
+    """白箱图库位置。
+
+    优先级：显式参数 > `WHITEBOX_DB` / `MDCG_WHITEBOX_DB` 环境变量 >
+    `MDCG_ROOT/data/whitebox/graph.db`（插件场景）>
+    `~/.md_cg/whitebox/graph.db`（独立场景，开箱可用）。
+
+    注意：**永不**把随包云库（`DEFAULT_DB`）当作可写工作库——它只作种子源，
+    避免写坏只读安装或污染种子。
+    """
+    if db_path:
+        return os.path.abspath(db_path)
+    env = os.environ.get("WHITEBOX_DB") or os.environ.get("MDCG_WHITEBOX_DB")
+    if env:
+        return os.path.abspath(env)
+    root = os.environ.get("MDCG_ROOT")
+    if root:
+        return os.path.join(os.path.abspath(root), "data", "whitebox", "graph.db")
+    return os.path.join(os.path.expanduser("~"), ".md_cg", "whitebox", "graph.db")
+
+
+def _ensure_db(path):
+    """确保图库文件存在。新建时以随包云库为底（137 卡），返回是否新建。"""
+    if os.path.exists(path):
+        return False
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    if os.path.abspath(path) != os.path.abspath(DEFAULT_DB) and os.path.exists(DEFAULT_DB):
+        shutil.copy2(DEFAULT_DB, path)
+    return True
+
+
+def _seed_cards(dex):
+    """从随包卡源（seed_knowledge/wisdom_cards/）播种知识卡。失败不阻断。"""
+    try:
+        from wisdom_cloud import _seed_cards as _seed
+        return _seed(dex)
+    except Exception:
+        return 0
+
+
+_SEED_META_KEY = "whitebox_seed_cards"
+
+
+def _seed_targets():
+    """卡源 .md 数量（0 表示无卡源，无需播种）。"""
+    try:
+        from wisdom_cloud import SEED_CARDS_DIR
+        return len([f for f in os.listdir(SEED_CARDS_DIR)
+                    if f.endswith(".md")])
+    except Exception:
+        return 0
+
+
+# --------------------------------------------------------------------------
+# 路由判定（逐字迁自 aeis/layered.py:185-247，勿改语义）
+# --------------------------------------------------------------------------
+
+def _decide_route(result, question=""):
+    """路由判定：chat() 结果 → self / llm。
+
+    自处理优先级：拦截 > 诚实边界闸门（完整回答）> 情感 > 闲聊 > 记忆 >
+    自省 > 转折 > 强命中知识。
+    强命中判定看 matched 质量而非只看分数（诊断依据）：
+      - 翻译规范词/学科路由命中（['氧化','化学']）→ 强 → self
+      - 纯神经语义（['语义']）→ neural ≥0.65 才 self（熵 0.69 self；
+        北京旅行 0.385 llm）
+      - 纯字面（['字面']）→ score ≥0.60 才 self（相对论争论 0.535 llm）
+    v1.23：question 参数供 fp 直答强制 self（考古卡确定性直答）。
+    """
+    if result.get("blocked"):
+        return "self"
+    if result.get("honest_kind"):
+        return "self"  # 诚实边界闸门（外星人/超光速/保证）已是完整回答
+    if result.get("emotion"):
+        return "self"
+    if result.get("chitchat") or result.get("memory_reply") \
+            or result.get("self_reflexive") or result.get("turn") \
+            or result.get("trace_reply"):
+        return "self"  # trace_reply（v1.16）：「依据是什么」→ 知识引用已是完整回答
+    # v1.23 考古直答强制 self（知识考古批次3·2026-08-21）：问题编码命中
+    # REVERSE_DAILY 完整概念名（≥4字）时，直答是确定性语义（「什么是内
+    # 稳态」「什么是STDP」），不走 LLM——否则 LLM 展开可能丢关键词或
+    # 输出英文（STDP→"The mathematical form"）。与 _assemble 的 fp 兜底
+    # 一致，这里保证 route 判定也为 self（LLM 路径不经过 _assemble）。
+    try:
+        import semantic_translate as _st
+        _qfp = _st.encode(question)
+        # v1.26（错题复测发现）：阈值 3→2——「涌现」「递归」等 2 字概念
+        # 在 REVERSE_DAILY 有确定性直答却被 3 字阈值滤掉（涌现 llm 讲偏、
+        # 递归依赖 llm 兜底）。REVERSE_DAILY 的 2 字键 46 个全是具体概念
+        # （涌现/递归/重力/原子/记忆…），无泛词，放宽安全。
+        _long = [t for t in _qfp if len(t) >= 2 and t in _st.REVERSE_DAILY]
+        if _long:
+            _pres = [t for t in _long if t in question]
+            _pool = _pres if _pres else _long
+            if _pool:
+                return "self"  # 确定性直答存在 → 白箱自答
+    except Exception:
+        pass
+    hits = result.get("hits") or []
+    if not hits:
+        return "llm"  # 无命中诚实边界 → 智慧之书没把握 → LLM
+    # v1.26（持续学习·三角形内角和）：strong 命中检查遍历全部 hits——
+    # top 卡可能是纯语义低置信（「三角形」matched=['语义'] neural 不够），
+    # 但第 2/3 卡有 strong 匹配（「小学数学」['三角形','字面'] 0.6489）→
+    # 应 self。之前只看 hits[0]，次强命中被漏判 → 无谓走 LLM。
+    for h in hits[:5]:
+        _matched = h.get("matched") or []
+        _strong = [m for m in _matched if m not in ("语义", "字面")]
+        if _strong and (h.get("score") or 0) >= 0.30:
+            return "self"  # 翻译/学科路由命中（生锈 0.757 / 1+1 0.781）
+    top = hits[0]
+    score = top.get("score") or 0
+    neural = top.get("neural_score") or 0
+    matched = top.get("matched") or []
+    if set(matched) == {"语义"} and neural >= 0.65 and score >= 0.25:
+        return "self"  # 神经高置信（熵 0.69）
+    if set(matched) == {"字面"} and score >= 0.60:
+        return "self"  # 纯字面高分数
+    return "llm"
+
+
+# --------------------------------------------------------------------------
+# 引擎
+# --------------------------------------------------------------------------
+
+class WhiteboxEngine:
+    """白箱知识引擎（进程内单例式使用；线程安全由调用方串行化）。"""
+
+    def __init__(self, db_path=None, identity="灵枢白箱", seed=True):
+        self.db_path = resolve_db_path(db_path)
+        self._created = _ensure_db(self.db_path)
+        self.identity = identity
+        self._dex = None
+        self._mem = None
+        self._seeded = None
+        if seed and self._needs_seed():
+            self._seeded = self._do_seed()
+
+    # -- 播种（幂等 · 可自愈） --------------------------------------------
+    def _needs_seed(self):
+        """是否需要播种。
+
+        判据用 engine_meta 标记，而非「文件是否存在」：首启中断会留下
+        **半成品库**（文件在、卡缺失），按文件判据会永久跳过播种，
+        静默少一批知识卡且永不自愈。
+        """
+        if self._created:
+            return True
+        if _seed_targets() <= 0:
+            return False
+        try:
+            got = self.dex.store.get_meta(_SEED_META_KEY) or {}
+        except Exception:
+            return False
+        return not got.get(_SEED_META_KEY)
+
+    def _do_seed(self):
+        added = _seed_cards(self.dex)
+        try:
+            self.dex.store.set_meta(_SEED_META_KEY, str(added))
+        except Exception:
+            pass
+        return added
+
+    # -- 惰性装配（避免仅探测连通性时加载全部图） --------------------------
+    @property
+    def dex(self):
+        if self._dex is None:
+            with _OPEN_LOCK:
+                if self._dex is None:
+                    from wisdom_book import ConditionDex
+                    self._dex = ConditionDex(db_path=self.db_path, fresh=False)
+        return self._dex
+
+    @property
+    def mem(self):
+        if self._mem is None:
+            with _OPEN_LOCK:
+                if self._mem is None:
+                    from aeis_core import SpacetimeMemoryEngine
+                    self._mem = SpacetimeMemoryEngine(db_path=self.db_path,
+                                                      identity=self.identity)
+        return self._mem
+
+    # -- 业务级 -----------------------------------------------------------
+    def chat(self, message, session_id="default"):
+        """白箱问答。返回含 route 的结果（route 已按无-LLM 情形降级）。"""
+        message = (message or "").strip()
+        if not message:
+            return {"reply": "", "hits": [], "route": "self_fallback",
+                    "engine": "whitebox_kb", "llm_available": False}
+        import chat_engine
+        res = dict(chat_engine.chat(self.dex, message, session_id=session_id) or {})
+        route = _decide_route(res, message)
+        res["route"] = route if route == "self" else "self_fallback"
+        res["engine"] = "whitebox_kb"
+        res["llm_available"] = False
+        res.setdefault("query", message)
+        res.setdefault("session_id", session_id)
+        return res
+
+    def remember(self, content, importance=0.5, tags=None, entities=None):
+        """白箱编码：把一条知识写入白箱图库（知识层）。"""
+        content = (content or "").strip()
+        if not content:
+            return {"ok": False, "error": "content 为空"}
+        node = self.mem.add_perception(
+            content, modality="text", importance=float(importance),
+            tags=list(tags or []), entities=list(entities or []) or None)
+        return {"ok": True, "node_id": getattr(node, "id", None),
+                "db": self.db_path}
+
+    def service_info(self):
+        """能力库自述（供连通性探测与报告）。"""
+        info = {"ok": True, "engine": "whitebox_kb", "identity": self.identity,
+                "db": self.db_path, "wisdom_dir": WISDOM_DIR,
+                "seed_dir": SEED_DIR, "knowledge_dir": KNOWLEDGE_DIR,
+                "seeded_on_open": self._seeded, "llm_available": False}
+        try:
+            from aeis_core import MemoryLayer
+            nodes = self.dex.store.query_nodes(layer=MemoryLayer.KNOWLEDGE,
+                                               limit=2000)
+            info["knowledge_nodes"] = len(nodes)
+        except Exception as exc:
+            info["knowledge_nodes"] = None
+            info["note"] = f"{type(exc).__name__}: {exc}"
+        return info
+
+    # -- 工具级（对齐 MCP tools/call 返回形状） ----------------------------
+    def call_tool(self, name, args):
+        """返回 {isError, text, data}，形状与 MCP 客户端一致。"""
+        import json
+        a = dict(args or {})
+        try:
+            if name == "wisdom_chat":
+                data = self.chat(a.get("message") or a.get("question") or "",
+                                 session_id=a.get("session_id") or "default")
+            elif name == "remember":
+                data = self.remember(a.get("content") or a.get("text") or "",
+                                     importance=a.get("importance", 0.5),
+                                     tags=a.get("tags"),
+                                     entities=a.get("entities"))
+            elif name in ("service_info", "mdcg_service_info", "info"):
+                data = self.service_info()
+            else:
+                return {"isError": True, "text": f"未知工具：{name}", "data": None}
+            return {"isError": False,
+                    "text": json.dumps(data, ensure_ascii=False, default=str),
+                    "data": data}
+        except Exception as exc:
+            return {"isError": True,
+                    "text": f"{type(exc).__name__}: {exc}", "data": None}
+
+    def close(self):
+        self._dex = None
+        self._mem = None
+
+
+_default_engine = None
+
+
+def get_engine(db_path=None, **kw):
+    """进程内默认引擎（懒加载单例）。"""
+    global _default_engine
+    if _default_engine is None:
+        with _OPEN_LOCK:
+            if _default_engine is None:
+                _default_engine = WhiteboxEngine(db_path=db_path, **kw)
+    return _default_engine