acmer-coach 1.0.0

package/coach/coach-metrics.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""coach-metrics — 只报「真的能说明问题」的三个数（给小鲸用）
+
+为什么只有这三个：教育研究里能证伪「当堂会了」的只有**延迟复测**和**没练过的新题**。
+刷题数、在线时长那类叫 vanity metric —— 好看，但和水平只有弱相关，报它等于骗人。
+
+1. 保持率   —— 同一节点，相邻两次检测间隔 >= 7 天时，后一次的通过率
+2. 首通率   —— 按标签：第一次提交就 AC 的比例（他没练过的题才算数）
+3. 卡住标记 —— 检测连续没过、或「在学」放太久还没验的节点
+
+用法:
+    python ~/.dsh/scripts/coach-metrics.py             # 人读
+    python ~/.dsh/scripts/coach-metrics.py --json      # 机读
+    python ~/.dsh/scripts/coach-metrics.py --selftest  # 自检
+
+环境变量 COACH_DB / COACH_PROGRESS 可覆盖路径（与 acmer-coach 插件同一套约定）。
+"""
+import json
+import os
+import sqlite3
+import sys
+from datetime import date, datetime
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+HOME = os.path.expanduser("~")
+DB_PATH = os.environ.get("COACH_DB") or os.path.join(HOME, ".dsh", "data", "training.db")
+PROGRESS_PATH = os.environ.get("COACH_PROGRESS") or os.path.join(
+    HOME, ".dsh", "knowledge", "PROGRESS.yaml")
+
+# 训练库里的账号 handle。COACH_TRAINER 没给就去 users 里取第一条
+# —— 单用户是常态，没有理由写死某个 handle。
+TRAINER_HANDLES = tuple(
+    h for h in (os.environ.get("COACH_TRAINER"),) if h
+)
+RETENTION_GAP_DAYS = 7      # 「隔了 ≥7 天还做得出」才算保持
+STUCK_CHECK_FAILS = 2       # 检测连续没过几次就标记
+STUCK_IDLE_DAYS = 14        # 「在学」放多久还没验就标记
+MIN_TAG_SAMPLE = 5          # 标签题量不足这个数就不报（小样本会骗人）
+
+
+# ── 数据读取 ──────────────────────────────────────────────────────────
+
+def load_progress(path=PROGRESS_PATH):
+    import yaml
+    with open(path, encoding="utf-8") as f:
+        return yaml.safe_load(f) or {}
+
+
+def _as_date(v):
+    """PROGRESS 里的日期可能是 date，也可能是字符串（老数据/手改）。"""
+    if isinstance(v, datetime):
+        return v.date()
+    if isinstance(v, date):
+        return v
+    try:
+        return date.fromisoformat(str(v)[:10])
+    except Exception:
+        return None
+
+
+def trainer_id(db):
+    q = "SELECT id FROM users WHERE cf_handle = ? OR handle = ? LIMIT 1"
+    for h in TRAINER_HANDLES:
+        row = db.execute(q, (h, h)).fetchone()
+        if row:
+            return row[0]
+    row = db.execute("SELECT id FROM users ORDER BY id LIMIT 1").fetchone()
+    return row[0] if row else None
+
+
+# ── 指标 ─────────────────────────────────────────────────────────────
+
+def retention(progress):
+    """保持率：同节点相邻两次检测间隔 >=7 天，取后一次的通过情况。
+
+    样本不足时**如实说不足** —— 不要用 0 对样本算出一个看着像样的百分比。
+    """
+    pairs = []
+    for node, rec in (progress.get("nodes") or {}).items():
+        # 只拿**真做过**的检测配对。弃考（abandoned）不是一次测量 ——
+        # 把它算进分母，等于把"卷子作废"读成"他忘了"，那是两种完全不同的信号。
+        checks = sorted(
+            (c for c in (rec or {}).get("checks") or []
+             if _as_date(c.get("date")) and c.get("outcome") in ("passed", "failed")),
+            key=lambda c: _as_date(c["date"]))
+        for prev, cur in zip(checks, checks[1:]):
+            gap = (_as_date(cur["date"]) - _as_date(prev["date"])).days
+            if gap >= RETENTION_GAP_DAYS:
+                pairs.append({"node": node, "gapDays": gap,
+                              "from": str(_as_date(prev["date"])),
+                              "on": str(_as_date(cur["date"])),
+                              "outcome": cur.get("outcome")})
+    passed = sum(1 for p in pairs if p["outcome"] == "passed")
+    return {
+        "pairs": len(pairs),
+        "passed": passed,
+        "rate": (passed / len(pairs)) if pairs else None,
+        "detail": pairs[-5:],
+    }
+
+
+def first_attempt_by_tag(db, uid):
+    """首通率（按标签）：每题**最早一次提交**的结果，AC 才算通。"""
+    rows = db.execute(
+        """
+        SELECT s.platform, s.problem_id, s.verdict,
+               (SELECT verdict FROM unified_submissions x
+                 WHERE x.user_id = s.user_id AND x.platform = s.platform
+                   AND x.problem_id = s.problem_id
+                 ORDER BY x.submitted_at ASC LIMIT 1) AS first_verdict,
+               p.tags
+          FROM unified_submissions s
+          LEFT JOIN unified_problems p
+                 ON p.platform = s.platform AND p.problem_id = s.problem_id
+         WHERE s.user_id = ?
+        """, (uid,)).fetchall()
+
+    seen, per_tag = set(), {}
+    for platform, pid, _verdict, first_verdict, tags in rows:
+        key = (platform, pid)
+        if key in seen or first_verdict is None:
+            continue
+        seen.add(key)
+        for tag in (tags or "").split(","):
+            tag = tag.strip()
+            if not tag:
+                continue
+            bucket = per_tag.setdefault(tag, {"n": 0, "ac": 0})
+            bucket["n"] += 1
+            if first_verdict == "AC":
+                bucket["ac"] += 1
+
+    # 计数留着原样，别从取整后的比例反推 —— round 会吃掉一两道题
+    ranked = [{"tag": t, "n": v["n"], "ac": v["ac"], "cfa": v["ac"] / v["n"]}
+              for t, v in per_tag.items() if v["n"] >= MIN_TAG_SAMPLE]
+    ranked.sort(key=lambda r: (r["cfa"], -r["n"]))
+    total_n = sum(r["n"] for r in ranked)
+    total_ac = sum(r["ac"] for r in ranked)
+    return {
+        "problems": len(seen),
+        "overall": {"n": total_n, "cfa": (total_ac / total_n) if total_n else None},
+        "weakest": ranked[:5],
+        "strongest": ranked[-5:][::-1],
+    }
+
+
+def stuck(progress, today=None):
+    """卡住标记：**最近一次真做过的检测没过**，或「在学」放太久还没验。
+
+    ⚠️ 三条别踩的坑（前两条是真踩过的）：
+      1. **弃考（abandoned）不算没过** —— 那是卷子作废，信号在组卷那边，不在人身上。
+      2. **他后来过了就不算卡住** —— 二分那个节点就是：2 次没过 + 2 次作废，
+         但最后一次 4 分通过、状态已是 verified。只看"没过几次"会冤枉他。
+      3. 卡住是"最近一次没过"，不是"历史上错过"。
+    """
+    today = today or date.today()
+    out, cancelled = [], []
+    for node, rec in (progress.get("nodes") or {}).items():
+        rec = rec or {}
+        checks = rec.get("checks") or []
+        valid = [c for c in checks
+                 if c.get("outcome") in ("passed", "failed") and _as_date(c.get("date"))]
+        valid.sort(key=lambda c: _as_date(c["date"]))
+        fails = [c for c in valid if c.get("outcome") == "failed"]
+        drops = [c for c in checks if c.get("outcome") == "abandoned"]
+        status = rec.get("status")
+        at = _as_date(rec.get("at"))
+        idle = (today - at).days if at else None
+
+        why = []
+        last = valid[-1] if valid else None
+        if last is not None and last.get("outcome") == "failed" and len(fails) >= STUCK_CHECK_FAILS:
+            why.append(f"最近一次检测没过（累计没过 {len(fails)} 次）")
+        if status == "studying" and idle is not None and idle >= STUCK_IDLE_DAYS:
+            why.append(f"在学放了 {idle} 天还没验")
+        if why:
+            out.append({"node": node, "status": status, "idleDays": idle,
+                        "fails": len(fails), "why": "；".join(why),
+                        "lastFail": str(_as_date(fails[-1]["date"])) if fails else None})
+
+        # 弃考是**组卷质量的信号**：卷子作废多了，该看题库/标签，不是看人。
+        if len(drops) >= STUCK_CHECK_FAILS:
+            cancelled.append({
+                "node": node, "drops": len(drops),
+                "reasons": [str(d.get("reason") or "").strip()[:60] for d in drops][-2:],
+                "last": str(_as_date(drops[-1]["date"])) if _as_date(drops[-1].get("date")) else None,
+            })
+
+    out.sort(key=lambda r: (-r["fails"], -(r["idleDays"] or 0)))
+    cancelled.sort(key=lambda r: -r["drops"])
+    return {"stuck": out, "cancelled": cancelled}
+
+
+def survey(progress):
+    counts = {}
+    for rec in (progress.get("nodes") or {}).values():
+        s = (rec or {}).get("status") or "未学"
+        counts[s] = counts.get(s, 0) + 1
+    return counts
+
+
+# ── 输出 ─────────────────────────────────────────────────────────────
+
+def collect():
+    progress = load_progress()
+    db = sqlite3.connect(f"file:{DB_PATH}?mode=ro", uri=True)
+    try:
+        uid = trainer_id(db)
+        if uid is None:
+            return {"error": "训练库里 users 表是空的，找不到账号"}
+        return {
+            "userId": uid,
+            "survey": survey(progress),
+            "retention": retention(progress),
+            "cfa": first_attempt_by_tag(db, uid),
+            "stuck": stuck(progress),
+        }
+    finally:
+        db.close()
+
+
+def render(d):
+    if "error" in d:
+        return f"读取失败：{d['error']}"
+    L = []
+    s = d["survey"]
+    L.append("── 进度总览 " + " / ".join(f"{k} {v}" for k, v in sorted(s.items())))
+    r = d["retention"]
+    if r["rate"] is None:
+        L.append(f"── 保持率（隔 ≥{RETENTION_GAP_DAYS} 天还做得出）：**样本不足**"
+                 f"（现有 {r['pairs']} 对复测，不足 3 对就别下结论）")
+    else:
+        L.append(f"── 保持率（隔 ≥{RETENTION_GAP_DAYS} 天还做得出）："
+                 f"{r['passed']}/{r['pairs']} = {r['rate']:.0%}")
+    c = d["cfa"]
+    if c["overall"]["cfa"] is not None:
+        L.append(f"── 首通率（他第一次提交就 AC）：{c['overall']['cfa']:.0%}"
+                 f"（覆盖 {c['overall']['n']} 题·标签对）")
+    if c["weakest"]:
+        L.append("   最弱标签：" + "、".join(
+            f"{x['tag']} {x['cfa']:.0%}(n={x['n']})" for x in c["weakest"]))
+        L.append("   最强标签：" + "、".join(
+            f"{x['tag']} {x['cfa']:.0%}(n={x['n']})" for x in c["strongest"]))
+    if d["stuck"]["stuck"]:
+        L.append("── ⚠️ 卡住标记（换法子，别继续喂题）：")
+        for x in d["stuck"]["stuck"][:8]:
+            L.append(f"   · {x['node']} —— {x['why']}（最近失败 {x['lastFail']}）")
+    else:
+        L.append("── 卡住标记：无")
+    if d["stuck"]["cancelled"]:
+        L.append("── ⚠️ 卷子反复作废（**别算在他头上**，去看组卷）：")
+        for x in d["stuck"]["cancelled"][:5]:
+            r = "；".join(s for s in x["reasons"] if s)
+            L.append(f"   · {x['node']} —— 作废 {x['drops']} 次（最近 {x['last']}）"
+                     + (f"；原因：{r}" if r else ""))
+    return "\n".join(L)
+
+
+def selftest():
+    """最小自检：两个指标各喂一个手算得出的夹具，对不上就报错。"""
+    prog = {"nodes": {
+        "A": {"status": "verified", "checks": [
+            {"date": "2026-01-01", "outcome": "passed"},
+            {"date": "2026-01-12", "outcome": "passed"},
+            {"date": "2026-01-13", "outcome": "failed"},   # 间隔 1 天，不计入
+        ]},
+        "B": {"status": "studying", "at": date(2026, 1, 1), "checks": [
+            {"date": "2026-02-01", "outcome": "failed"},
+            {"date": "2026-02-02", "outcome": "failed"},
+        ]},
+        # C 是踩过的真形状：两次没过 + 两次作废，但**最后过了**。
+        # 只看"没过几次"会把这种判成卡住 —— 冤枉人。
+        "C": {"status": "verified", "checks": [
+            {"date": "2026-02-01", "outcome": "abandoned", "reason": "难度结构失衡"},
+            {"date": "2026-02-02", "outcome": "failed"},
+            {"date": "2026-02-03", "outcome": "failed"},
+            {"date": "2026-02-04", "outcome": "abandoned", "reason": "题已被 AC 过"},
+            {"date": "2026-02-05", "outcome": "passed"},
+        ]},
+    }}
+    r = retention(prog)
+    assert r["pairs"] == 1 and r["passed"] == 1, f"保持率算错: {r}"
+    st = stuck(prog, today=date(2026, 3, 1))
+    assert {x["node"] for x in st["stuck"]} == {"B"}, f"卡住标记算错: {st['stuck']}"
+    assert [x["node"] for x in st["cancelled"]] == ["C"], f"作废标记算错: {st['cancelled']}"
+    # 首通：同一题提交两次，只看最早那次
+    db = sqlite3.connect(":memory:")
+    db.executescript("""
+        CREATE TABLE unified_submissions (user_id,platform,problem_id,verdict,submitted_at);
+        CREATE TABLE unified_problems (platform,problem_id,tags);
+        INSERT INTO unified_problems VALUES ('cf','1A','math'),('cf','1B','math'),
+            ('cf','1C','math'),('cf','1D','math'),('cf','1E','math');
+        INSERT INTO unified_submissions VALUES
+            (1,'cf','1A','WA','2026-01-01'), (1,'cf','1A','AC','2026-01-02'),
+            (1,'cf','1B','AC','2026-01-01'), (1,'cf','1C','AC','2026-01-01'),
+            (1,'cf','1D','WA','2026-01-01'), (1,'cf','1E','AC','2026-01-01');
+    """)
+    c = first_attempt_by_tag(db, 1)
+    assert c["problems"] == 5, c
+    # 1A / 1D 的首交是 WA —— 后面补交的 AC 不算数，所以是 3/5 不是 4/5
+    assert abs(c["overall"]["cfa"] - 3 / 5) < 1e-9, c
+    print("selftest ok（保持率 / 卡住标记 / 首通率 三项都对得上）")
+
+
+if __name__ == "__main__":
+    if "--selftest" in sys.argv:
+        selftest()
+    elif "--json" in sys.argv:
+        print(json.dumps(collect(), ensure_ascii=False, indent=2, default=str))
+    else:
+        print(render(collect()))

package/coach/export_oiwiki_chunks.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""把旧版 langchain pickles 里的 OI Wiki 文本块导成 JSONL。
+
+为什么要这一步（两个理由，都不是洁癖）：
+
+1. **安全。** pickle 反序列化 = 任意代码执行。原版查询脚本用的是
+   `allow_dangerous_deserialization=True` —— 自己机器上跑无所谓，但把
+   `.pkl` 打包发给陌生人，等于**送他一个 RCE 面**。JSONL 没有这个问题。
+2. **可读。** JS 读不了 pickle。检索层要跑在 Node 里，格式必须能直接读。
+
+顺便把 metadata 里的绝对路径换成**相对路径** —— 原索引里存的是构建机器上的
+`~/.openclaw/skills/oi-wiki/OI-wiki/docs/...`，那个目录早就不在了，
+换台机器全部失效。
+
+用法: python export_oiwiki_chunks.py <index.pkl> <输出目录>
+产物: <输出目录>/chunks.jsonl   每行 {"i":序号,"src":相对路径,"text":正文}
+"""
+import json
+import os
+import pickletools
+import sys
+import unicodedata
+from io import BytesIO
+
+# ── 白名单反序列化 ────────────────────────────────────────────────────
+# 只放行 langchain 自己那两个类；别的一律抛。这是读**不可信 pickle** 的唯一
+# 正确姿势：宁可读不了，也不要执行里面的东西。
+ALLOWED = {
+    "langchain_community.docstore.in_memory",
+    "langchain_core.documents.base",
+    "langchain.docstore.document",
+}
+
+
+class SafeUnpickler(__import__("pickle").Unpickler):
+    def find_class(self, module, name):
+        if module not in ALLOWED:
+            raise pickle_unsafe(f"pickle 里引用了白名单外的类：{module}.{name}")
+        return super().find_class(module, name)
+
+
+class pickle_unsafe(Exception):
+    pass
+
+
+def audit(path):
+    """先用 pickletools 反汇编，确认只有已知的 GLOBAL —— 不解包就能判断。
+    （genops 产出 (opcode, arg, pos)，arg 可能是 None，别多取一层。）"""
+    with open(path, "rb") as f:
+        ops = list(pickletools.genops(f.read()))
+    return [str(arg) for op, arg, _ in ops if op.name in ("GLOBAL", "STACK_GLOBAL")]
+
+
+def main():
+    if len(sys.argv) < 3:
+        print(__doc__)
+        return 1
+    pkl, outdir = sys.argv[1], sys.argv[2]
+    os.makedirs(outdir, exist_ok=True)
+
+    print(f"· 反汇编审计 {os.path.basename(pkl)}")
+    for g in audit(pkl):
+        print(f"    GLOBAL {g}")
+
+    with open(pkl, "rb") as f:
+        store = SafeUnpickler(f).load()
+
+    # langchain 的 FAISS save_local 落两个东西：
+    #   index.pkl  = (InMemoryDocstore, index_to_docstore_id)
+    docstore, id_map = store
+    docs = docstore._dict
+    n = len(id_map)
+
+    # 找所有 source 的公共前缀 —— 那才是"文档根"，其余是相对路径
+    srcs = [d.metadata.get("source", "") for d in docs.values()]
+    root = os.path.commonpath([s for s in srcs if s]) if any(srcs) else ""
+
+    rows = []
+    for i in range(n):
+        doc = docs[id_map[i]]
+        src = doc.metadata.get("source", "")
+        rel = os.path.relpath(src, root).replace("\\", "/") if src and root else src
+        rows.append({"i": i, "src": rel, "text": doc.page_content})
+
+    dst = os.path.join(outdir, "chunks.jsonl")
+    with open(dst, "w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    chars = sum(len(r["text"]) for r in rows)
+    files = len({r["src"] for r in rows})
+    print(f"· 导出 {len(rows)} 块 / {files} 个源文件 / {chars} 字符")
+    print(f"  → {dst}")
+    print(f"  路径前缀（原构建机）: {root}")
+    print(f"  样例: {rows[0]['src']}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/coach/export_problem_pool.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""把题池导出成随包发的 JSONL.gz。
+
+**为什么要随包发**：`coach_pool` 挑候选时要满足「他没做过」这个条件。
+没有题池的话，候选只能从他做过的那几道里挑 —— 那个条件永远满足不了，
+教练就废了一半。
+
+**为什么是 gzip**：41k 道题的标签/标题是高度重复的文本，gzip 压到 1/5。
+不压的话包里多 4.8MB 纯文本。
+
+⚠️ **数据来源与风险**（见 assets/pool/LICENSE）：
+   · codeforces —— 官方公开 API（`problemset.problems`），可随时重新拉
+   · nowcoder   —— `ac.nowcoder.com/acm/problem/list/json`，公开接口但**非官方承诺**
+   · luogu      —— **爬取的**。洛谷的 ToS 不允许抓取，且已有账号因此被封的先例。
+                   这一部分的再分发**有风险**，用不用由使用者自己判断。
+
+用法:
+  python export_problem_pool.py <training.db> <输出目录>
+产物: <输出目录>/problems.jsonl.gz
+"""
+import gzip
+import json
+import os
+import sqlite3
+import sys
+
+
+def main():
+    if len(sys.argv) < 3:
+        print(__doc__)
+        return 1
+    db_path, outdir = sys.argv[1], sys.argv[2]
+    os.makedirs(outdir, exist_ok=True)
+
+    con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    rows = con.execute(
+        """SELECT platform, problem_id, title, difficulty, tags, url
+           FROM unified_problems
+           WHERE is_library = 1 AND problem_id IS NOT NULL AND problem_id != ''
+           ORDER BY platform, problem_id""").fetchall()
+    con.close()
+
+    dst = os.path.join(outdir, "problems.jsonl.gz")
+    n = 0
+    with gzip.open(dst, "wt", encoding="utf-8", compresslevel=9) as f:
+        for platform, pid, title, diff, tags, url in rows:
+            f.write(json.dumps({
+                "p": platform, "i": pid, "t": title or "",
+                "d": float(diff or 0), "g": tags or "", "u": url or "",
+            }, ensure_ascii=False, separators=(",", ":")) + "\n")
+            n += 1
+
+    size = os.path.getsize(dst) / 1024 / 1024
+    by = {}
+    for r in rows:
+        by[r[0]] = by.get(r[0], 0) + 1
+    print(f"· 导出 {n} 道 → {dst}  ({size:.2f} MB)")
+    for k, v in sorted(by.items()):
+        print(f"    {k:12} {v}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/coach/extract_oiwiki.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+extract_oiwiki.py — 从 OI-wiki 的 mkdocs.yml 导航提取完整算法树
+
+为什么要它有：地图的「完整性」不能靠我一个人想 —— OI-wiki 是社区维护的
+全量索引，拿它当兜底，我漏掉的东西（插头DP / 李超线段树 / Dancing Links …）
+就漏不掉。
+
+输出：JSON，结构 = [ {domain, path[], name, file} ]，path 是从学科到该条目的层级，
+file 是该条目对应的 markdown 文件（相对 docs/，导航里没挂文件的为 null）。
+
+⚠️ **file 是重点**：地图节点名和 OI-wiki 的导航标题是同一套词，所以
+`name → file` 就是一张**精确的「知识点 → 页面」表** —— 查资料不用靠模糊搜索去猜，
+直接查这张表。丢了它就只能对着一堆英文文件名（`seg.md`）猜哪个是线段树。
+
+只取算法相关的学科，跳过「简介/工具软件/语言基础/比赛相关」。
+
+用法: python extract_oiwiki.py [输出 json] [mkdocs.yml 路径]
+  不给路径就用 $OI_WIKI_DIR/OI-wiki/mkdocs.yml（默认 ~/.dsh/skills/oi-wiki）
+"""
+import json
+import os
+import sys
+
+for _s in (sys.stdout, sys.stderr):
+    if _s and hasattr(_s, "reconfigure"):
+        _s.reconfigure(encoding="utf-8", errors="replace")
+
+_DEFAULT_WIKI_DIR = os.environ.get("OI_WIKI_DIR") or os.path.join(
+    os.path.expanduser("~"), ".dsh", "skills", "oi-wiki")
+WIKI = sys.argv[2] if len(sys.argv) > 2 else os.path.join(
+    _DEFAULT_WIKI_DIR, "OI-wiki", "mkdocs.yml")
+OUT = sys.argv[1] if len(sys.argv) > 1 else os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "oiwiki_tree.json")
+
+# 取这些学科（算法相关）；其余是工具/语言/赛事，不进地图
+ALGO = ["算法基础", "搜索", "动态规划", "字符串", "数学",
+        "数据结构", "图论", "计算几何", "杂项", "专题"]
+# 章节导言页不是知识点
+SKIP_SUFFIX = ("部分简介", "简介")
+# 这些不是"知识点"而是写法/元信息
+SKIP_EXACT = {"学习路线", "学习资源", "常见错误", "常见技巧", "读入、输出优化",
+              "分段打表", "题型概述", "交互题", "出题", "技巧"}
+
+
+def parse_nav(path):
+    lines = open(path, encoding="utf-8").read().splitlines()
+    start = next(i for i, l in enumerate(lines) if l.startswith("nav:"))
+    end = start + 1
+    while end < len(lines) and (lines[end].startswith(" ") or not lines[end].strip()):
+        end += 1
+    tree, stack = [], []
+    for l in lines[start + 1:end]:
+        if not l.strip():
+            continue
+        ind = len(l) - len(l.lstrip())
+        s = l.strip()
+        if not s.startswith("- "):
+            continue
+        s = s[2:]
+        # 格式是 `- 标题: 路径.md`；只有标题的是分类节点（没有自己的页面）。
+        # **路径要留着** —— 它就是「知识点 → 文件」的映射，见文件头。
+        name, _, file = s.partition(":")
+        name = name.strip()
+        file = file.strip() or None
+        while stack and stack[-1][0] >= ind:
+            stack.pop()
+        node = {"name": name, "file": file, "kids": []}
+        (stack[-1][1]["kids"] if stack else tree).append(node)
+        stack.append((ind, node))
+    return tree
+
+
+def flatten(tree):
+    out = []
+    for domain in tree:
+        if domain["name"] not in ALGO:
+            continue
+        for l2 in domain["kids"]:
+            n2 = l2["name"]
+            if n2 not in SKIP_EXACT and not n2.endswith(SKIP_SUFFIX):
+                out.append({"domain": domain["name"], "path": [n2],
+                            "name": n2, "file": l2.get("file")})
+            for l3 in l2["kids"]:
+                n3 = l3["name"]
+                if n3 in SKIP_EXACT or n3.endswith(SKIP_SUFFIX):
+                    continue
+                out.append({"domain": domain["name"], "path": [n2, n3],
+                            "name": n3, "file": l3.get("file")})
+    return out
+
+
+def main():
+    tree = parse_nav(WIKI)
+    items = flatten(tree)
+    with open(OUT, "w", encoding="utf-8") as f:
+        json.dump(items, f, ensure_ascii=False, indent=1)
+
+    from collections import Counter
+    by_domain = Counter(i["domain"] for i in items)
+    by_depth = Counter(len(i["path"]) for i in items)
+    print(f"提取完成 → {OUT}")
+    print(f"  条目总数 {len(items)}")
+    print(f"  按学科: " + "  ".join(f"{k}={v}" for k, v in by_domain.most_common()))
+    print(f"  按层级: " + "  ".join(f"{k}级={v}" for k, v in sorted(by_depth.items())))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())