@hupan56/wlkj 3.3.13 → 3.3.14

package/templates/qoder/scripts/validation/eval/bf2_content_fidelity.py

@@ -1,110 +0,0 @@
-"""bf2_content_fidelity.py — FW10 BF2 PRD 内容保真（生成PRD正文 vs 真实 ICS PRD 语义相似）。
-
-BF2 = 生成 PRD 正文 → rag_search(kind='prd') 找最近真 PRD chunk → 相似度。
-高=生成内容是真业务域(车辆/保险等,贴近真PRD正文)；低=泛泛/编造(不贴近真PRD)。
-bare(无接地) vs +schema接地。复用 rag_search 打分。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/bf2_content_fidelity.py
-"""
-import os
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from app.routers import mcp_handlers as H  # noqa: E402
-try:
-    H._init_handlers()
-except Exception:
-    pass
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODEL = "qwen-turbo"
-FEATURES = [("车辆保险管理", "保险"), ("异常记录管理", "异常"), ("合同维护", "合同")]
-
-
-def chat(prompt, max_tokens=800, timeout=90):
-    body = json.dumps({"model": MODEL, "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.2, "max_tokens": max_tokens}).encode()
-    for a in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if a < 2: time.sleep(1.0*(a+1))
-            else: return ""
-
-
-def content_fidelity(prd_text):
-    """生成 PRD 正文 → rag_search(kind=prd) 最近真 PRD chunk 平均分。"""
-    if not prd_text or len(prd_text) < 20:
-        return 0.0, 0
-    # 用 PRD 正文做语义查询（截断前 500 字，避免过长）
-    q = prd_text[:500].replace("\n", " ")
-    r = H.dispatch("rag_search", {"query": q, "kind": "prd", "top_k": 3}) or {}
-    items = r.get("items") or []
-    scores = [float(it.get("score", 0)) for it in items if it.get("score") is not None]
-    avg = round(sum(scores) / len(scores), 3) if scores else 0.0
-    return avg, len(items)
-
-
-def real_prd_template(theme):
-    """取一条真 ICS PRD 正文 chunk 做 house-style 写作范本（BF2 杠杆）。"""
-    r = H.dispatch("rag_search", {"query": theme, "kind": "prd", "top_k": 1}) or {}
-    items = r.get("items") or []
-    if items:
-        return (items[0].get("text") or "")[:600]
-    return ""
-
-
-def run():
-    rep = {"features": []}
-    for feat, theme in FEATURES:
-        tpl = real_prd_template(theme)
-        bare = chat(f"你是产品经理。为「{feat}」写一份 PRD 需求文档（含背景/功能/字段/流程）。直接输出正文。")
-        # BF2 杠杆：喂真 PRD 正文做写作范本（学 ICS house style/系统级深度，非泛产品文）
-        scaff = chat(f"你是 ICS(车辆物联网)产品经理。为「{feat}」写 PRD。\n"
-                     f"【写作范本接地】以下是真实 ICS PRD 的正文（学它的写法/系统级字段级深度/业务术语，"
-                     f"不要泛泛产品宣传文）：\n{tpl}\n\n参考这个 house style 为「{feat}」写 PRD，"
-                     f"字段/流程贴合 {theme} 真业务。直接输出正文。") if tpl else chat(
-            f"为「{feat}」写 PRD，贴合 {theme} 真业务。直接输出。")
-        b_score, b_n = content_fidelity(bare)
-        s_score, s_n = content_fidelity(scaff)
-        rep["features"].append({"feature": feat, "bare_score": b_score, "scaffold_score": s_score,
-                                "bare_hits": b_n, "scaffold_hits": s_n, "has_template": bool(tpl)})
-        print("  %s: 内容保真 bare=%.3f → +真PRD范本=%.3f (范本%d字)" % (
-            feat, b_score, s_score, len(tpl)))
-    n = len(FEATURES) or 1
-    rep["agg"] = {"bare": round(sum(f["bare_score"] for f in rep["features"])/n, 3),
-                  "scaffold": round(sum(f["scaffold_score"] for f in rep["features"])/n, 3)}
-    return rep
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    a = r["agg"]
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    print("\n## FW10 BF2 PRD 内容保真（生成PRD正文 vs 真实ICS PRD 语义相似度）")
-    print("| 模式 | 内容保真(语义cos,越接近真PRD越高) |")
-    print("|---|---|")
-    print("| bare(无业务接地) | %.3f |" % a["bare"])
-    print("| +真业务接地 | %.3f |" % a["scaffold"])
-    print("\n注：分数是 rag_search(kind=prd) 的 top-3 平均相似度（0-1）。"
-          "高=生成内容贴近真实 ICS PRD 正文（真业务域）；低=泛泛/偏离。")
-
-
-if __name__ == "__main__":
-    main()

package/templates/qoder/scripts/validation/eval/bf2_llmjudge.py

@@ -1,104 +0,0 @@
-"""bf2_llmjudge.py — FW10 BF2 换度量：LLM-judge 量 PRD 内容业务保真（余弦不分好坏，换强模型裁判）。
-
-BF2 余弦~0.03 不分好坏→换 LLM-judge：qwen-max 对照真 ICS PRD 范本，给生成 PRD 的【业务保真度】
-打 1-5 分（5=完全 ICS 业务写法 系统级/字段级/真流程；1=通用产品宣传文）。能区分 bare(泛) vs +范本(ICS)。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/bf2_llmjudge.py
-"""
-import os
-import re
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from app.routers import mcp_handlers as H  # noqa: E402
-try:
-    H._init_handlers()
-except Exception:
-    pass
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-GEN_MODEL = "qwen-turbo"   # 生成（弱模型，卖点）
-JUDGE_MODEL = "qwen-max"   # 裁判（强模型）
-FEATURES = [("车辆保险管理", "保险"), ("异常记录管理", "异常"), ("合同维护", "合同")]
-
-
-def chat(model, prompt, max_tokens=800, timeout=90):
-    body = json.dumps({"model": model, "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.0 if model == JUDGE_MODEL else 0.2, "max_tokens": max_tokens}).encode()
-    for a in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if a < 2: time.sleep(1.0*(a+1))
-            else: return ""
-
-
-def real_prd(theme):
-    r = H.dispatch("rag_search", {"query": theme, "kind": "prd", "top_k": 1}) or {}
-    items = r.get("items") or []
-    return (items[0].get("text") or "")[:600] if items else ""
-
-
-def judge(prd, ref, feat):
-    """qwen-max 打业务保真分 1-5。"""
-    p = ("你是 ICS（车辆物联网系统）资深产品专家。对照下面【真实 ICS PRD 范本】，给这份【生成 PRD】"
-         "的业务保真度打分 1-5：\n"
-         "5=完全 ICS 业务写法（系统级/字段级深度、真实业务流程、车辆物联网术语）\n"
-         "3=部分 ICS（有业务要素但有泛化）\n"
-         "1=通用产品宣传文（泛泛、非 ICS 真业务）\n\n"
-         f"【真实 ICS PRD 范本】：\n{ref}\n\n"
-         f"【生成 PRD（{feat}）】：\n{prd[:1000]}\n\n"
-         f"只输出一个整数分（1-5），不要解释。")
-    out = chat(JUDGE_MODEL, p, max_tokens=10)
-    m = re.search(r"[1-5]", out)
-    return int(m.group()) if m else 0
-
-
-def run():
-    rep = {"features": []}
-    for feat, theme in FEATURES:
-        ref = real_prd(theme)
-        bare = chat(GEN_MODEL, f"你是产品经理。为「{feat}」写一份 PRD 需求文档。直接输出正文。")
-        scaff = (chat(GEN_MODEL, f"你是 ICS 产品经理。为「{feat}」写 PRD。\n"
-                     f"【写作范本】真 ICS PRD 正文（学其系统级/字段级写法，勿泛产品文）：\n{ref}\n直接输出 PRD 正文。")
-                 if ref else bare)
-        b = judge(bare, ref, feat)
-        s = judge(scaff, ref, feat)
-        rep["features"].append({"feature": feat, "bare_score": b, "scaffold_score": s})
-        print("  %s: 业务保真分 bare=%d/5 → +真PRD范本=%d/5" % (feat, b, s))
-    n = len(FEATURES) or 1
-    rep["agg"] = {"bare": round(sum(f["bare_score"] for f in rep["features"])/n, 2),
-                  "scaffold": round(sum(f["scaffold_score"] for f in rep["features"])/n, 2)}
-    return rep
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    a = r["agg"]
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    print("\n## FW10 BF2（换 LLM-judge 度量）PRD 内容业务保真")
-    print("| 模式 | 业务保真分(/5, qwen-max 裁判 vs 真 PRD) |")
-    print("|---|---|")
-    print("| bare(通用) | %.2f |" % a["bare"])
-    print("| +真PRD范本(ICS house style) | %.2f |" % a["scaffold"])
-    print("\n目标≥4/5。LLM-judge 能区分（余弦不能）：bare 通用文低分，+范本 ICS 写法高分。")
-
-
-if __name__ == "__main__":
-    main()

package/templates/qoder/scripts/validation/eval/bf_score.py

@@ -1,218 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""bf_score.py - 业务保真(BF)统一打分器：吃【真命令产物文件】打 BF 分。
-
-把 FW9-11 的 BF 尺子从"代理生成+打分"改成"读真产物文件+打分"。
-宿主真跑 /wl-prd /wl-design /wl-code /wl-search 出的真产物 → 本工具打 BF 分（对真 ICS 业务数据）。
-
-用法:
-  python bf_score.py prd   <PRD.md>   [--feature 保险]   # BF1 schema保真 + BF2 内容保真(LLM-judge)
-  python bf_score.py proto <原型.html>                    # BF3 组件保真 + BF4 颜色保真
-  python bf_score.py code  <实体列表.txt|diff> --feature 保险  # BF5 feature精准
-  python bf_score.py search <结果.json或txt> --feature 保险     # BF6 feature相关率
-
-跑法（容器内，接真业务数据）:
-  docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/bf_score.py prd /path/REQ.md --feature 保险
-"""
-import os
-import re
-import sys
-import json
-import colorsys
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from sqlalchemy import text  # noqa: E402
-from app.db import SessionLocal  # noqa: E402
-
-_H = None  # lazy: 避免与 mcp_handlers 循环 import
-
-
-def _hub():
-    """惰性取 mcp_handlers（dispatch rag_search/get_design_system），避免循环 import。"""
-    global _H
-    if _H is None:
-        from app.routers import mcp_handlers as _h
-        try:
-            _h._init_handlers()
-        except Exception:
-            pass
-        _H = _h
-    return _H
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-JUDGE_MODEL = "qwen-max"
-_NEUTRAL = {(255, 255, 255), (0, 0, 0), (51, 51, 51), (102, 102, 102), (153, 153, 153),
-            (240, 240, 240), (250, 250, 250), (217, 217, 217), (232, 232, 232), (245, 245, 245)}
-_TABLE_RE = re.compile(r'\b(t_[a-z_]+|tb_[a-z_]+|report_[a-z_]+|salary_[a-z_]+|[a-z]+_[a-z_]+_table)\b', re.IGNORECASE)
-
-
-def _read(path):
-    try:
-        with open(path, encoding="utf-8", errors="replace") as f:
-            return f.read()
-    except Exception as e:
-        return ""
-
-
-def _q(s, sql, p=None):
-    try:
-        return s.execute(text(sql), p or {}).fetchall()
-    except Exception:
-        try:
-            s.rollback()
-        except Exception:
-            pass
-        return []
-
-
-def chat(model, prompt, max_tokens=10, timeout=60):
-    body = json.dumps({"model": model, "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.0, "max_tokens": max_tokens}).encode()
-    for a in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
-        except Exception:
-            if a < 2:
-                import time
-                time.sleep(1.0 * (a + 1))
-            else:
-                return ""
-
-
-# ── BF1: PRD schema 保真 ──
-def bf1_schema(prd_text):
-    mentioned = set(m.lower() for m in _TABLE_RE.findall(prd_text))
-    if not mentioned:
-        return {"score": 0.0, "mentioned": 0, "note": "PRD 未提表名"}
-    s = SessionLocal()
-    all_tabs = set(r[0].lower() for r in _q(s, "SELECT table_name FROM db_tables"))
-    s.close()
-    real = mentioned & all_tabs
-    return {"score": round(len(real) / len(mentioned), 3), "mentioned": len(mentioned), "real": len(real)}
-
-
-# ── BF2: PRD 内容保真（LLM-judge） ──
-def bf2_content(prd_text, feature):
-    r = _hub().dispatch("rag_search", {"query": feature, "kind": "prd", "top_k": 1}) or {}
-    items = r.get("items") or []
-    ref = (items[0].get("text") or "")[:600] if items else ""
-    if not ref:
-        return {"score": 0, "note": "无真 PRD 范本"}
-    p = ("你是 ICS（车辆物联网系统）资深产品专家。对照【真实 ICS PRD 范本】，给【生成 PRD】业务保真度打分 1-5：\n"
-         "5=完全 ICS 业务写法(系统级/字段级/真业务流程)；3=部分；1=通用产品宣传文。\n"
-         f"【真 ICS PRD 范本】：\n{ref}\n\n【待评 PRD】：\n{prd_text[:1000]}\n\n只输出一个整数(1-5)。")
-    out = chat(JUDGE_MODEL, p)
-    m = re.search(r"[1-5]", out)
-    return {"score": int(m.group()) if m else 0, "ref_len": len(ref)}
-
-
-# ── BF3/4: 原型保真 ──
-def _design():
-    r = _hub().dispatch("get_design_system", {}) or {}
-    proj = next((p for p in r.get("projects", []) if p.get("project") == "fywl-ui"), {})
-    colors = proj.get("colors", {}) or {}
-    palette = set()
-    for v in colors.values():
-        if isinstance(v, str) and v.startswith("hsl"):
-            m = re.match(r"hsl\(\s*([\d.]+)[,\s]+([\d.]+)%[,\s]+([\d.]+)%", v)
-            if m:
-                h, s_, l = float(m.group(1)) / 360, float(m.group(2)) / 100, float(m.group(3)) / 100
-                r_, g_, b_ = colorsys.hls_to_rgb(h, l, s_)
-                palette.add((round(r_ * 255), round(g_ * 255), round(b_ * 255)))
-    comps = set()
-    for d in (proj.get("commonComponents", {}), proj.get("formComponents", {})):
-        if isinstance(d, dict):
-            comps.update(k.lower() for k in d)
-    return palette, comps
-
-
-def _extract_colors(html):
-    out = set()
-    for m in re.findall(r"#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b", html):
-        h = m if len(m) == 6 else m * 2
-        out.add((int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)))
-    for m in re.findall(r"hsl\(\s*([\d.]+)[,\s]+([\d.]+)%[,\s]+([\d.]+)%", html):
-        h, s_, l = float(m[0]) / 360, float(m[1]) / 100, float(m[2]) / 100
-        r_, g_, b_ = colorsys.hls_to_rgb(h, l, s_)
-        out.add((round(r_ * 255), round(g_ * 255), round(b_ * 255)))
-    for m in re.findall(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)", html):
-        out.add((int(m[0]), int(m[1]), int(m[2])))
-    return out
-
-
-def _color_real(c, palette):
-    if c in _NEUTRAL:
-        return True
-    return any(all(abs(a - b) <= 40 for a, b in zip(c, p)) for p in palette)
-
-
-def bf34_proto(html):
-    palette, comps = _design()
-    cols = _extract_colors(html)
-    color_score = (sum(1 for c in cols if _color_real(c, palette)) / len(cols)) if cols else 0.0
-    used = set(m.lower() for m in re.findall(r"<(?:el|van|a|n)-([\w-]+)", html))
-    comp_score = (sum(1 for c in used if c in comps) / len(used)) if used and comps else (1.0 if not comps else 0.0)
-    return {"bf3_component": round(comp_score, 3), "bf4_color": round(color_score, 3),
-            "colors": len(cols), "components": len(used)}
-
-
-# ── BF5/6: feature 实体精准/相关率 ──
-def _feature_gold(feature):
-    s = SessionLocal()
-    rows = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) "
-                "AND type IN ('CONTROLLER','SERVICE','TABLE','COLUMN','FUNCTION') LIMIT 30", {"p": f"%{feature}%"})
-    s.close()
-    return set(c for c, _ in rows if c)
-
-
-def bf56_entities(text, feature):
-    gold = _feature_gold(feature)
-    cands = set(re.findall(r"[A-Za-z_][\w]{2,}", text))
-    if not cands:
-        return {"score": 0.0, "candidates": 0, "gold": len(gold)}
-    hit = sum(1 for c in cands if c in gold)
-    return {"score": round(hit / len(cands), 3), "candidates": len(cands), "gold_hit": hit, "gold": len(gold)}
-
-
-def main():
-    if len(sys.argv) < 3:
-        sys.stderr.write(__doc__)
-        return 1
-    kind, path = sys.argv[1], sys.argv[2]
-    feature = None
-    if "--feature" in sys.argv:
-        feature = sys.argv[sys.argv.index("--feature") + 1]
-    text = _read(path)
-    if not text:
-        sys.stderr.write("读不到文件: %s\n" % path)
-        return 1
-    out = {"file": os.path.basename(path), "kind": kind}
-    if kind == "prd":
-        out["BF1_schema"] = bf1_schema(text)
-        if feature:
-            out["BF2_content"] = bf2_content(text, feature)
-    elif kind == "proto":
-        out.update(bf34_proto(text))
-    elif kind in ("code", "search"):
-        if not feature:
-            sys.stderr.write("code/search 需 --feature\n")
-            return 1
-        bf = bf56_entities(text, feature)
-        out["BF5_code" if kind == "code" else "BF6_search"] = bf
-    else:
-        sys.stderr.write("未知 kind: %s (prd/proto/code/search)\n" % kind)
-        return 1
-    print(json.dumps(out, ensure_ascii=False, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/templates/qoder/scripts/validation/eval/code_flywheel.py

@@ -1,150 +0,0 @@
-"""code_flywheel.py — FW3 wl-code 变更类精准度飞轮（改对实体 / 误改率）。
-
-变更类维度(SPEC §1.1)：正确性(过测试)/安全(gate_check)/精准(改对文件-误改率)。
-本尺子量【精准】：给功能加改动，模型列"该改的代码实体"，量
-  - 精准 P = 列出的实体 ∈ KG 真实体的比例（bare 编造→低 P=误改率高；scaffold 接地→高 P）
-  - 召回 R = gold 实体被列出比例
-bare vs +get_impact grounding scaffold。安全(gate)/正确性(过测试)是执行流→🖥️。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/code_flywheel.py
-"""
-import os
-import re
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from sqlalchemy import text  # noqa: E402
-from app.db import SessionLocal  # noqa: E402
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODEL = "qwen-turbo"
-FEATURES = [("车辆保养提醒", "车辆"), ("考勤异常导出", "考勤"), ("保险续保预警", "保险")]
-_LINE_CLEAN = re.compile(r"^[\-\*\d\.\)、\s]+")
-_CODE_TOK = re.compile(r"[A-Za-z_][\w./\-:]{2,}")
-
-
-def chat(prompt, max_tokens=500, timeout=80):
-    body = json.dumps({"model": MODEL,
-        "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.0, "max_tokens": max_tokens}).encode()
-    for attempt in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if attempt < 2:
-                time.sleep(1.0 * (attempt + 1))
-            else:
-                return f"[ERR {repr(e)[:60]}]"
-
-
-def _q(s, sql, params=None):
-    try:
-        return s.execute(text(sql), params or {}).fetchall()
-    except Exception:
-        try:
-            s.rollback()
-        except Exception:
-            pass
-        return []
-
-
-def load_universe_and_gold():
-    """UNI=所有真实体名(canonical+cn, 精度校验); GOLD=每主题的真实体(召回校验)。"""
-    s = SessionLocal()
-    rows = _q(s, "SELECT canonical, cn FROM entities WHERE canonical IS NOT NULL")
-    UNI = set()
-    for c, n in rows:
-        if c:
-            UNI.add(c.strip())
-        if n:
-            UNI.add(n.strip())
-    GOLD = {}
-    for feat, theme in FEATURES:
-        rs = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) "
-                   "AND type IN ('CONTROLLER','SERVICE','FUNCTION','COLUMN','TABLE') LIMIT 20", {"p": f"%{theme}%"})
-        GOLD[feat] = [(c, n) for c, n in rs if c]
-    s.close()
-    return UNI, GOLD
-
-
-def extract_names(ans):
-    cands = set()
-    for line in ans.splitlines():
-        line = _LINE_CLEAN.sub("", line).strip()
-        if line and len(line) <= 60:
-            m = _CODE_TOK.findall(line)
-            if m:
-                cands.add(m[0])
-    return cands
-
-
-def score(ans, gold, UNI):
-    cands = extract_names(ans)
-    real = {x for x in cands if x in UNI}
-    precision = (len(real) / len(cands)) if cands else 0.0
-    hit = 0
-    for c, n in gold:
-        if (c and c in ans) or (n and n in ans):
-            hit += 1
-    recall = (hit / len(gold)) if gold else 0.0
-    return round(precision, 3), round(recall, 3), len(cands)
-
-
-def run():
-    UNI, GOLD = load_universe_and_gold()
-    rep = {"features": []}
-    for feat, theme in FEATURES:
-        gold = GOLD[feat]
-        gold_ctx = "\n".join("%s (%s)" % (c, n) for c, n in gold) or "(无)"
-        bare = chat("你是开发。要在车辆物联网系统(ICS)给「%s」加功能。\n"
-                    "逐行列出【需要修改的代码文件/Java类/方法名】，每行一个，只列确信真实存在的，不要编造。" % feat)
-        scaff = chat("你是开发。要在车辆物联网系统(ICS)给「%s」加功能。\n"
-                     "get_impact 检索到该功能相关的真实代码实体（均真实存在）：\n%s\n\n"
-                     "请把以上检索结果里的实体【尽量全部逐行列出】，每行一个，直接用检索结果里的名称，"
-                     "不要自行筛选/合并/省略，不要编造。检索到几个就列几个。" % (feat, gold_ctx))
-        bP, bR, bN = score(bare, gold, UNI)
-        sP, sR, sN = score(scaff, gold, UNI)
-        rep["features"].append({"feature": feat, "gold_n": len(gold),
-                                "bare_P": bP, "bare_R": bR, "scaffold_P": sP, "scaffold_R": sR})
-        print("  %s: gold=%d | bare P=%.2f R=%.2f | scaffold P=%.2f R=%.2f" % (
-            feat, len(gold), bP, bR, sP, sR))
-    n = len(FEATURES) or 1
-    rep["agg"] = {
-        "bare_P": round(sum(f["bare_P"] for f in rep["features"]) / n, 3),
-        "scaffold_P": round(sum(f["scaffold_P"] for f in rep["features"]) / n, 3),
-        "bare_R": round(sum(f["bare_R"] for f in rep["features"]) / n, 3),
-        "scaffold_R": round(sum(f["scaffold_R"] for f in rep["features"]) / n, 3),
-    }
-    return rep
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    a = r["agg"]
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    print("\n## FW3 wl-code 变更类精准飞轮（改对实体 P / 召回 R）")
-    print("| 维度 | bare(弱模型裸) | +get_impact scaffold |")
-    print("|---|---|---|")
-    print("| 精准 P(改对·反误改) | %.1f%% | %.1f%% |" % (a["bare_P"] * 100, a["scaffold_P"] * 100))
-    print("| 召回 R(改全) | %.1f%% | %.1f%% |" % (a["bare_R"] * 100, a["scaffold_R"] * 100))
-    print("\n安全(gate_check 前置)/正确性(过测试) = 执行流维度 → 🖥️ 宿主 wl-code 真跑")
-
-
-if __name__ == "__main__":
-    main()