@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/whitebox_kb/wisdom/multilang_ir.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""multilang_ir.py · 多语言代码理解（第五阶段·统一 IR 跨语言）
+Python（ast 完整）+ JavaScript/Rust（轻量正则提取）→ 统一 IR
+→ 复用 codegraph_white 调用图/影响分析（codegraph 38 语言矩阵的白箱零依赖版）。
+诚实边界：JS/Rust 为轻量提取（light=True），非完整 AST。
+"""
+import sys
+import re
+sys.stdout.reconfigure(encoding='utf-8')
+try:
+    from codegraph_white import extract_code_ir
+except ImportError:
+    from .codegraph_white import extract_code_ir
+
+
+def detect_language(source="", filename=""):
+    """语言检测：扩展名优先，语法特征兜底"""
+    if filename.endswith(".py"):
+        return "python"
+    if filename.endswith(".js") or filename.endswith(".mjs") or filename.endswith(".jsx"):
+        return "javascript"
+    if filename.endswith(".rs"):
+        return "rust"
+    if "fn " in source and "->" in source and "impl " in source:
+        return "rust"
+    if "function " in source or "=>" in source or "import " in source:
+        return "javascript"
+    if "def " in source:
+        return "python"
+    return "unknown"
+
+
+# ============ JS/Rust 轻量提取（正则结构化，诚实标注） ============
+_JS_KW = {"function", "if", "for", "while", "switch", "return", "const", "let",
+          "var", "new", "typeof", "console", "import", "export", "from", "require",
+          "async", "await", "class", "extends", "throw", "try", "catch", "else",
+          "break", "continue", "do", "in", "of", "this", "super", "delete", "void"}
+_RUST_KW = {"fn", "if", "for", "while", "match", "return", "let", "mut", "impl",
+            "struct", "use", "println", "print", "vec", "String", "str", "Box",
+            "Some", "None", "Ok", "Err", "self", "Self", "pub", "mod", "enum",
+            "trait", "where", "loop", "break", "continue", "async", "await",
+            "move", "ref", "static", "unsafe", "extern", "type", "const"}
+
+
+def _calls_from(src, kws):
+    """调用提取：\b(\w+)\( 匹配 → 过滤关键字（轻量，允许误抓）"""
+    calls = [m.group(1) for m in re.finditer(r"\b([A-Za-z_]\w*)\s*\(", src)]
+    return sorted({c for c in calls if c not in kws})
+
+
+def _extract_js(source, file_path):
+    """JavaScript 轻量提取：function/箭头函数/class/import + 调用"""
+    ir = {"file": file_path, "functions": [], "classes": [], "imports": [],
+          "light": True}
+    # 函数：function name( / const name = (args) => / name = function(
+    for m in re.finditer(r"\bfunction\s+([A-Za-z_]\w*)\s*\(([^)]*)\)", source):
+        body = source[m.end():m.end() + 600]
+        ir["functions"].append({"name": m.group(1),
+                                "params": [p.strip() for p in m.group(2).split(",") if p.strip()],
+                                "calls": _calls_from(body, _JS_KW), "class_owner": None})
+    for m in re.finditer(r"\bconst\s+([A-Za-z_]\w*)\s*=\s*\(([^)]*)\)\s*=>", source):
+        body = source[m.end():m.end() + 600]
+        ir["functions"].append({"name": m.group(1),
+                                "params": [p.strip() for p in m.group(2).split(",") if p.strip()],
+                                "calls": _calls_from(body, _JS_KW), "class_owner": None})
+    for m in re.finditer(r"\bclass\s+([A-Za-z_]\w*)", source):
+        ir["classes"].append({"name": m.group(1), "methods": [], "bases": []})
+    for m in re.finditer(r"\bimport\s+(?:{[^}]*}\s+from\s+)?['\"]([^'\"]+)['\"]", source):
+        ir["imports"].append({"module": m.group(1).split("/")[-1].replace(".js", ""),
+                              "names": []})
+    return ir
+
+
+def _extract_rust(source, file_path):
+    """Rust 轻量提取：fn/struct/impl/use + 调用"""
+    ir = {"file": file_path, "functions": [], "classes": [], "imports": [],
+          "light": True}
+    for m in re.finditer(r"\bfn\s+([A-Za-z_]\w*)\s*\(([^)]*)\)", source):
+        body = source[m.end():m.end() + 600]
+        ir["functions"].append({"name": m.group(1),
+                                "params": [p.strip().split(":")[0] for p in m.group(2).split(",") if p.strip()],
+                                "calls": _calls_from(body, _RUST_KW), "class_owner": None})
+    for m in re.finditer(r"\bstruct\s+([A-Za-z_]\w*)", source):
+        ir["classes"].append({"name": m.group(1), "methods": [], "bases": []})
+    for m in re.finditer(r"\buse\s+([A-Za-z_:]+)", source):
+        ir["imports"].append({"module": m.group(1).split("::")[0], "names": []})
+    return ir
+
+
+def extract_ir(source, filename):
+    """多语言 → 统一 IR（与 codegraph_white.extract_code_ir 同结构）"""
+    lang = detect_language(source, filename)
+    if lang == "python":
+        ir = extract_code_ir(source, filename)
+        ir["lang"] = "python"
+        return ir
+    if lang == "javascript":
+        ir = _extract_js(source, filename)
+        ir["lang"] = "javascript"
+        return ir
+    if lang == "rust":
+        ir = _extract_rust(source, filename)
+        ir["lang"] = "rust"
+        return ir
+    return {"file": filename, "functions": [], "classes": [], "imports": [],
+            "lang": lang, "light": True}
+
+
+if __name__ == "__main__":
+    print("=== 多语言代码理解：统一 IR 跨语言（零 LLM）===\n")
+    samples = {
+        "sample.py": "def parse(data):\n    return split(data)\n\ndef split(d):\n    return d.split(',')\n",
+        "sample.js": "import { fs } from 'fs'\n\nfunction parse(data) {\n    return split(data);\n}\n\nconst split = (d) => d.split(',');\n",
+        "sample.rs": "use std::collections::HashMap;\n\nfn parse(data: &str) -> Vec<&str> {\n    split(data)\n}\n\nfn split(d: &str) -> Vec<&str> {\n    d.split(',').collect()\n}\n",
+    }
+    ok_all = True
+    for fname, src in samples.items():
+        ir = extract_ir(src, fname)
+        fns = [f["name"] for f in ir["functions"]]
+        print(f"[{fname}] lang={ir['lang']} light={ir.get('light', False)} "
+              f"函数={fns} 导入={[i['module'] for i in ir['imports']]}")
+        if "parse" not in fns:
+            ok_all = False
+    print(f"\n=== 判定 ===\n统一 IR 跨语言: {'✔ 三语言函数提取成立' if ok_all else '✘'}")

package/md_cg/whitebox_kb/wisdom/navigate.py

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+"""navigate.py · CSPRE 导航递归（《导航递归CSPRE_实现文档_v0.1》落地）
+
+核心：条件空间导航递归——graph_retrieve 命中复合知识后，进入其内部
+的条件路由继续导航（知识描述知识 = 条件路由图的子递归），直到原子知识
+或深度上限（≤3，超出 = structural_blindspot，复用 core.py 递归约束模式）。
+
+单源纪律：
+- 复合/原子判定：state_attributes.knowledge_type 缺省 atomic（读时缺省，
+  不物理写死 2846 条——避免无意义整图指纹扰动）
+- 子路由索引复用 KCCS 注释索引（card_route），不新建体系
+- 深度边界复用 core.py 递归约束模式（depth >= max_depth → structural_blindspot）
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+
+
+def get_knowledge_type(state_attributes) -> str:
+    """复合/原子判定：读取时缺省 atomic。"""
+    return state_attributes.get("knowledge_type", "atomic") \
+        if isinstance(state_attributes, dict) else "atomic"
+
+
+def get_sub_route(state_attributes) -> str:
+    """复合节点的子路由条件空间词（仅 composite 有效）。"""
+    return state_attributes.get("sub_route", "") \
+        if isinstance(state_attributes, dict) else ""
+
+
+# ============ L1 混合门控（T7 · 2026-08-28） ============
+# 证据裁决（csre_alignment_bench 18 问）：CSRE 词向量对骨架域可靠、
+# 对措辞变体盲（完整短语字面匹配）——故 L1 只做先验不裁决：
+# 非零且 score≥τ → 域先验；零向量/低分/引擎异常 → None 回退全扫。
+_CSRE_CACHE: dict = {}
+
+
+def _l1_domain_prior(dex, question: str) -> str | None:
+    """CSRE 域先验（混合门控）：非零且 top 分 ≥0.5 返回域串，否则 None。"""
+    try:
+        db_path = getattr(dex, "db_path", None) or \
+            getattr(getattr(dex, "store", None), "db_path", None) or \
+            getattr(getattr(dex, "engine", None), "db_path", None)
+        if not db_path:
+            return None
+        key = str(db_path)
+        if key not in _CSRE_CACHE:
+            from csre import Csre
+            _c = Csre(str(db_path))
+            _c.ensure_loaded()
+            _CSRE_CACHE[key] = _c
+        doms = _CSRE_CACHE[key].rank_domains(question, top_k=1)
+        if doms and doms[0].get("score", 0) >= 0.5:
+            return doms[0].get("domain") or None
+    except Exception:
+        return None
+    return None
+
+
+def _dom_match(cand_dom: str, prior_dom: str) -> bool:
+    """域族一致判定：互为子串（自造域串与骨架域串同构场景）。"""
+    if not cand_dom or not prior_dom:
+        return True   # 域缺失不降权（只对明确不一致降权）
+    return cand_dom in prior_dom or prior_dom in cand_dom
+
+
+def _canonical(obj) -> str:
+    """导航链规范化：字符串去空白、字典按键排序递归处理，保证指纹计算稳定。"""
+    def norm(x):
+        if isinstance(x, str):
+            return x.strip()
+        if isinstance(x, dict):
+            return {k: norm(v) for k, v in sorted(x.items())}
+        return x
+    return json.dumps(norm(obj), ensure_ascii=False, sort_keys=True,
+                      separators=(",", ":"))
+
+
+def chain_fingerprint(chain: list) -> str:
+    """导航链指纹（对接指纹化 L3：每次导航的可核对章）。"""
+    payload = [{"depth": c.get("depth"), "condition_space": c.get("condition_space"),
+                "rule": c.get("rule"), "node_id": c.get("node_id")}
+               for c in chain]
+    return hashlib.sha256(_canonical(payload).encode("utf-8")).hexdigest()
+
+
+def refine_question(question: str, parent_sa: dict) -> str:
+    """子问题条件收窄：拼入父节点子路由词，令子路由索引聚焦该条件空间
+    （实现文档 §3.3——防子路由重新发散）。"""
+    sub = get_sub_route(parent_sa)
+    return f"{question} {sub}" if sub else question
+
+
+def _load_state(dex, node_id):
+    """从 dex 或其 engine 链上定位 store，读取节点 state_attributes（缺失返回空表）。"""
+    if not node_id:
+        return {}
+    store = getattr(dex, "store", None)
+    if store is None:
+        engine = getattr(dex, "engine", None)
+        store = getattr(engine, "store", None)
+    n = store.get_node(node_id) if store is not None else None
+    return getattr(n, "state_attributes", {}) or {}
+
+
+def _result(status: str, chain: list, **extra) -> dict:
+    """组装导航返回结构：状态、导航链文本、chain 指纹、实际深度，并合并扩展字段。"""
+    out = {"status": status,
+           "navigation": "→".join(c["rule"] for c in chain),
+           "chain": chain,
+           "fingerprint": chain_fingerprint(chain),
+           "depth_used": len(chain)}
+    out.update(extra)
+    return out
+
+
+MIN_ACCEPT_SCORE = 5   # M1.2 四态边界：低于此分的候选不授予执行资格
+                       # （BLINDSPOT 优于强行 ACCEPT——对抗负条件防线）。
+                       # 校准：正例 6-10 / 域外 1-4，阈值取 5 最大化间隔
+SEED_MIN_ACCEPT_SCORE = 3  # 导航种子/常识播种卡：T8 复查实证分数 3-4
+                           # （2026-08-30：TCP/理财/复合赋值等正例被一刀切误杀）
+
+
+def _accept_by_score(name: str, domain: str, score, coverage) -> bool:
+    """M1.2 门槛按域分级 + 覆盖双维校准（T8 24 题，2026-08-30）。
+
+    口径溯源：coverage 即钉死批条款 1 的 dist_C 离散实现（dist_C := 1-cov），
+    连续条件偏序留 v2——见 docs/概念钉死批_GPT四点评审_v0.1.md 钉死 1。
+
+    背景：一刀切 MIN_ACCEPT_SCORE=5 误杀正例——导航种子卡分数普遍 3-4
+    （理财/宠物/拖延），计算机知识卡正例也有 3-4（TCP/复合赋值/print）。
+    数据驱动规则（24 题校准：正例 22 全过、答非所问 2 + 域外 1 全拒）：
+      - 导航种子（人工校准的确定性直答）：score≥3 且 coverage≥0.15
+      - 知识卡：score≥4 直接过；score=3 需 coverage≥0.22（分离
+        TCP/UDP=0.23、复合赋值=0.43 正例与狭义相对论域外=0.21）
+      - 域外强行命中（score 3 且 cov 低）仍拒——对抗防线不破坏
+    """
+    if not isinstance(score, (int, float)) or not isinstance(coverage, (int, float)):
+        return False
+    text = f"{name} {domain}"
+    if "导航种子" in text:
+        return score >= SEED_MIN_ACCEPT_SCORE and coverage >= 0.15
+    if score >= MIN_ACCEPT_SCORE:
+        return True
+    if score >= 4:
+        return True
+    return score == 3 and coverage >= 0.22
+
+
+def navigate_retrieve(dex, question: str, *, max_depth: int = 3,
+                      chain: list | None = None,
+                      seen: set | None = None) -> dict:
+    """条件空间导航递归主入口（CSPRE v0.1 · 实现文档 §3.2）。
+
+    定位器分层：第 0 层 = graph_retrieve（四路融合）；
+    第 ≥1 层 = card_route（KCCS 注释索引，子条件空间内收敛）。
+    """
+    from semantic_translate import graph_retrieve, card_route
+
+    chain = list(chain or [])
+    seen = set(seen or [])
+
+    # 0. 深度边界（超出 = structural_blindspot）
+    if len(chain) >= max_depth:
+        return _result("structural_blindspot", chain,
+                       note=f"递归深度已达上限 {max_depth}（3.12 运行约束）")
+
+    # 1. 当前层定位：KCCS 注释索引（card_route）是纯条件核对层——
+    #    实测它对「婆媳矛盾」命中复合根 raw=7 第一名，而 graph_retrieve
+    #    四路融合会引入计算机卡 bigram 噪声（地基审计实证）。故各层统一
+    #    用 card_route；空时才回退 graph_retrieve（诚实边界保底）。
+    structured_rank = []
+    mode = "kccs_index"
+    raw = card_route(dex, question, limit=10) or []
+    structured_rank = [h for h in raw if isinstance(h, dict)]
+    if not structured_rank:
+        hits = graph_retrieve(dex, question, limit=5) or []
+        structured_rank = list(hits)
+        mode = "graph_fallback"
+    if not structured_rank:
+        return _result("no_route", chain,
+                       reason="条件路由图无命中（诚实边界：未覆盖）",
+                       mode=mode)
+
+    # 复合优先 + 已访问过滤（地图式收敛）：
+    #   同层命中里若有未访问的 composite 节点 → 优先进入其子条件空间
+    #   （先进城市再找街道）；否则取未访问的最高分 atomic 直答。
+    #   已访问的规则跳过——防止同一入口反复入栈（循环防护）。
+    # L1 混合门控（T7）：CSRE 域先验存在时，域明确不一致的 composite
+    #   降级为 deferred（先找域一致者，找不到才用）——降权不排除。
+    prior_dom = _l1_domain_prior(dex, question)
+    entry = None
+    atomic_fallback = None
+    deferred_composite = None
+    for h in structured_rank:
+        nid = h.get("id")
+        sa_h = _load_state(dex, nid)
+        rule_key = f'{h.get("domain_group") or h.get("domain") or "-"}|{h.get("name") or ""}'
+        if rule_key in seen:
+            continue
+        sa_h = dict(sa_h)
+        sa_h.setdefault("sub_route", "")
+        ktype = get_knowledge_type(sa_h)
+        cand = {"depth": len(chain),
+                "condition_space": h.get("domain_group") or h.get("domain") or "-",
+                "rule": h.get("name") or "",
+                "confidence": h.get("score"),
+                "node_id": nid,
+                "knowledge_type": ktype,
+                "_sa": sa_h}
+        if ktype == "composite":
+            if prior_dom and not _dom_match(cand["condition_space"], prior_dom):
+                deferred_composite = deferred_composite or cand
+                continue
+            entry = cand
+            break
+        if atomic_fallback is None:
+            score = h.get("score")
+            cov = h.get("_coverage") or 0.0
+            ok = _accept_by_score(h.get("name") or "", h.get("domain") or "", score, cov)
+            if ok:
+                atomic_fallback = cand  # M1.2 按域分级+覆盖：仅达标候选作兜底（防域外强行 ACCEPT）
+    if entry is None:
+        entry = deferred_composite or atomic_fallback
+    if entry is None:
+        return _result("structural_blindspot", chain,
+                       note="全部候选均已导航过（循环耗尽）")
+    chain.append(entry)
+    seen.add(f'{entry["condition_space"]}|{entry["rule"]}')
+    sa = entry["_sa"]
+
+    # 3. 原子 → 终答；复合 → 收窄后进入子路由
+    if entry["knowledge_type"] != "composite":
+        return _result("resolved", chain,
+                       answer="",
+                       direct_answer=sa.get("comment", {}).get("执行", "")
+                       if isinstance(sa.get("comment"), dict) else "",
+                       verdict="ACCEPT")
+
+    # composite：条件收窄（refine_question 用 entry 的 sub_route）
+    sub_q = refine_question(question, sa)
+    return navigate_retrieve(dex, sub_q, max_depth=max_depth,
+                             chain=chain, seen=seen)
+
+
+__all__ = ["get_knowledge_type", "get_sub_route", "refine_question",
+           "navigate_retrieve", "chain_fingerprint"]