mirror of
https://github.com/xr843/Master-skill.git
synced 2026-05-10 13:26:25 +00:00
xianren
366 lines
14 KiB
Python
366 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Cross-Reference — find connections between teachers using FoJin KG.
|
|
|
|
Usage:
|
|
python3 tools/cross_reference.py lineage "印光" "蕅益"
|
|
python3 tools/cross_reference.py concept "空性" --teachers xuanzang,kumarajiva
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
# Allow running from project root or tools/
|
|
PROJECT_ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(PROJECT_ROOT / "tools"))
|
|
|
|
from fojin_bridge import FojinBridge, create_bridge
|
|
|
|
|
|
# ── Teacher registry ────────────────────────────────────────────
|
|
|
|
PREBUILT_DIR = PROJECT_ROOT / "prebuilt"
|
|
|
|
|
|
def load_teacher_meta(slug: str) -> dict:
|
|
"""Load a teacher's meta.json by slug."""
|
|
meta_path = PREBUILT_DIR / slug / "meta.json"
|
|
if not meta_path.exists():
|
|
raise FileNotFoundError(f"Teacher not found: {slug}")
|
|
with open(meta_path, "r", encoding="utf-8") as f:
|
|
return json.load(f)
|
|
|
|
|
|
def list_teachers() -> list[str]:
|
|
"""Return all available teacher slugs."""
|
|
return sorted(
|
|
d.name for d in PREBUILT_DIR.iterdir()
|
|
if d.is_dir() and (d / "meta.json").exists()
|
|
)
|
|
|
|
|
|
def find_teacher_by_name(name: str) -> Optional[dict]:
|
|
"""Find a teacher by Chinese name, English name, or slug."""
|
|
for slug in list_teachers():
|
|
meta = load_teacher_meta(slug)
|
|
if name in (
|
|
meta.get("name"),
|
|
meta.get("name_en"),
|
|
meta.get("name_sa"),
|
|
meta.get("name_bo"),
|
|
meta.get("slug"),
|
|
slug,
|
|
):
|
|
return meta
|
|
return None
|
|
|
|
|
|
# ── Lineage subcommand ──────────────────────────────────────────
|
|
|
|
def cmd_lineage(bridge: FojinBridge, person_a: str, person_b: str) -> str:
|
|
"""
|
|
Search the KG for relationship paths between two people.
|
|
|
|
Returns formatted text describing the lineage connection.
|
|
"""
|
|
lines: list[str] = []
|
|
lines.append(f"## 师承关系查询: {person_a} <-> {person_b}")
|
|
lines.append("")
|
|
|
|
# Search for both entities in the KG
|
|
result_a = bridge.search_kg_entities(person_a, entity_type="person", limit=5)
|
|
result_b = bridge.search_kg_entities(person_b, entity_type="person", limit=5)
|
|
|
|
entities_a = result_a.get("data", result_a.get("results", []))
|
|
entities_b = result_b.get("data", result_b.get("results", []))
|
|
|
|
if not entities_a:
|
|
lines.append(f"- 未在知识图谱中找到: {person_a}")
|
|
if not entities_b:
|
|
lines.append(f"- 未在知识图谱中找到: {person_b}")
|
|
|
|
if not entities_a or not entities_b:
|
|
lines.append("")
|
|
lines.append("### 建议")
|
|
lines.append("- 尝试使用不同的名称（法号、别名等）")
|
|
lines.append("- 查看 prebuilt/ 目录下已有的法师配置")
|
|
return "\n".join(lines)
|
|
|
|
entity_a = entities_a[0]
|
|
entity_b = entities_b[0]
|
|
id_a = entity_a.get("id")
|
|
id_b = entity_b.get("id")
|
|
|
|
lines.append(f"### {person_a}")
|
|
lines.append(f"- KG实体: {entity_a.get('name', person_a)} (ID: {id_a})")
|
|
lines.append("")
|
|
|
|
lines.append(f"### {person_b}")
|
|
lines.append(f"- KG实体: {entity_b.get('name', person_b)} (ID: {id_b})")
|
|
lines.append("")
|
|
|
|
# Fetch relationship graphs for both, looking for teacher-student predicates
|
|
lines.append("### 关系图谱")
|
|
lines.append("")
|
|
|
|
graph_a = bridge.get_kg_graph(
|
|
id_a, depth=3, max_nodes=100,
|
|
predicates="teacher_of,student_of,disciple_of,master_of"
|
|
)
|
|
|
|
nodes = {n["id"]: n for n in graph_a.get("nodes", [])}
|
|
edges = graph_a.get("edges", graph_a.get("links", []))
|
|
|
|
# Check if person_b appears in person_a's graph
|
|
found_connection = False
|
|
for node in nodes.values():
|
|
node_name = node.get("name", "")
|
|
if person_b in node_name or node.get("id") == id_b:
|
|
found_connection = True
|
|
break
|
|
|
|
if found_connection:
|
|
lines.append(f"在 {person_a} 的关系图谱中找到 {person_b}:")
|
|
lines.append("")
|
|
for edge in edges:
|
|
src = nodes.get(edge.get("source"), {}).get("name", str(edge.get("source")))
|
|
tgt = nodes.get(edge.get("target"), {}).get("name", str(edge.get("target")))
|
|
pred = edge.get("predicate", edge.get("label", "related_to"))
|
|
lines.append(f" {src} --[{pred}]--> {tgt}")
|
|
else:
|
|
lines.append(f"在3层关系内未找到 {person_a} 与 {person_b} 的直接师承路径。")
|
|
lines.append("")
|
|
|
|
# Show each person's immediate relations for context
|
|
lines.append(f"#### {person_a} 的师承关系:")
|
|
for edge in edges[:10]:
|
|
src = nodes.get(edge.get("source"), {}).get("name", str(edge.get("source")))
|
|
tgt = nodes.get(edge.get("target"), {}).get("name", str(edge.get("target")))
|
|
pred = edge.get("predicate", edge.get("label", "related_to"))
|
|
lines.append(f" {src} --[{pred}]--> {tgt}")
|
|
|
|
graph_b = bridge.get_kg_graph(
|
|
id_b, depth=2, max_nodes=50,
|
|
predicates="teacher_of,student_of,disciple_of,master_of"
|
|
)
|
|
nodes_b = {n["id"]: n for n in graph_b.get("nodes", [])}
|
|
edges_b = graph_b.get("edges", graph_b.get("links", []))
|
|
|
|
lines.append("")
|
|
lines.append(f"#### {person_b} 的师承关系:")
|
|
for edge in edges_b[:10]:
|
|
src = nodes_b.get(edge.get("source"), {}).get("name", str(edge.get("source")))
|
|
tgt = nodes_b.get(edge.get("target"), {}).get("name", str(edge.get("target")))
|
|
pred = edge.get("predicate", edge.get("label", "related_to"))
|
|
lines.append(f" {src} --[{pred}]--> {tgt}")
|
|
|
|
# Check if both are prebuilt teachers and note shared traditions
|
|
lines.append("")
|
|
lines.append("### 传承交集分析")
|
|
meta_a = find_teacher_by_name(person_a)
|
|
meta_b = find_teacher_by_name(person_b)
|
|
if meta_a and meta_b:
|
|
scope_a = meta_a.get("search_scope", {})
|
|
scope_b = meta_b.get("search_scope", {})
|
|
shared_traditions = set(scope_a.get("traditions", [])) & set(scope_b.get("traditions", []))
|
|
shared_keywords = set(scope_a.get("keywords", [])) & set(scope_b.get("keywords", []))
|
|
|
|
if shared_traditions:
|
|
lines.append(f"- 共同传承: {', '.join(shared_traditions)}")
|
|
if shared_keywords:
|
|
lines.append(f"- 共同关键词: {', '.join(shared_keywords)}")
|
|
if not shared_traditions and not shared_keywords:
|
|
lines.append("- 两位法师属于不同传承，无直接交集")
|
|
else:
|
|
lines.append("- 部分法师不在预置列表中，无法进行本地交集分析")
|
|
|
|
return "\n".join(lines)
|
|
|
|
|
|
# ── Concept subcommand ──────────────────────────────────────────
|
|
|
|
def cmd_concept(bridge: FojinBridge, concept: str, teacher_slugs: list[str]) -> str:
|
|
"""
|
|
Search the same concept across multiple teachers' primary sources.
|
|
|
|
Returns formatted text comparing how different teachers discuss the concept.
|
|
"""
|
|
lines: list[str] = []
|
|
lines.append(f"## 跨传承概念对比: {concept}")
|
|
lines.append("")
|
|
|
|
# Dictionary lookup first
|
|
lines.append("### 辞典释义")
|
|
try:
|
|
dict_result = bridge.search_dictionary_grouped(concept)
|
|
entries = dict_result.get("data", dict_result.get("results", []))
|
|
if entries:
|
|
for group in entries[:3]:
|
|
source = group.get("source", "unknown")
|
|
items = group.get("entries", group.get("items", []))
|
|
if items:
|
|
entry = items[0]
|
|
term = entry.get("term", entry.get("headword", concept))
|
|
definition = entry.get("definition", entry.get("content", ""))
|
|
# Truncate long definitions
|
|
if len(definition) > 200:
|
|
definition = definition[:200] + "..."
|
|
lines.append(f"- **{source}** [{term}]: {definition}")
|
|
else:
|
|
lines.append(f"- 未找到「{concept}」的辞典条目")
|
|
except Exception as e:
|
|
lines.append(f"- 辞典查询失败: {e}")
|
|
|
|
lines.append("")
|
|
|
|
# For each teacher, search their primary sources
|
|
for slug in teacher_slugs:
|
|
try:
|
|
meta = load_teacher_meta(slug)
|
|
except FileNotFoundError:
|
|
lines.append(f"### {slug} (未找到)")
|
|
lines.append(f"- 法师 '{slug}' 不在预置列表中")
|
|
lines.append("")
|
|
continue
|
|
|
|
name = meta.get("name", slug)
|
|
scope = meta.get("search_scope", {})
|
|
traditions = scope.get("traditions", [])
|
|
|
|
lines.append(f"### {name} ({', '.join(traditions)})")
|
|
|
|
# Build source filter from primary CBETA/SuttaCentral IDs
|
|
primary_ids = scope.get("primary_cbeta_ids", []) + scope.get("primary_suttacentral_ids", [])
|
|
source_filter = ",".join(primary_ids) if primary_ids else None
|
|
|
|
# Search in teacher's primary texts
|
|
try:
|
|
results = bridge.search_content(concept, sources=source_filter, size=5)
|
|
hits = results.get("data", results.get("results", []))
|
|
if hits:
|
|
for hit in hits[:3]:
|
|
title = hit.get("title", hit.get("text_title", ""))
|
|
highlight = hit.get("highlight", hit.get("snippet", ""))
|
|
if isinstance(highlight, dict):
|
|
highlight = highlight.get("content", [""])[0]
|
|
if isinstance(highlight, list):
|
|
highlight = highlight[0] if highlight else ""
|
|
# Truncate
|
|
if len(highlight) > 150:
|
|
highlight = highlight[:150] + "..."
|
|
lines.append(f"- 《{title}》: {highlight}")
|
|
else:
|
|
lines.append(f"- 在主要典籍中未搜到「{concept}」的直接引用")
|
|
except Exception as e:
|
|
lines.append(f"- 搜索失败: {e}")
|
|
|
|
# Also search dictionary with teacher-specific sources
|
|
dict_sources = scope.get("dictionary_sources", [])
|
|
if dict_sources:
|
|
try:
|
|
for ds in dict_sources[:2]:
|
|
dict_res = bridge.search_dictionary(concept, source=ds, size=1)
|
|
entries = dict_res.get("data", dict_res.get("results", []))
|
|
if entries:
|
|
entry = entries[0]
|
|
definition = entry.get("definition", entry.get("content", ""))
|
|
if len(definition) > 100:
|
|
definition = definition[:100] + "..."
|
|
lines.append(f"- [{ds}辞典]: {definition}")
|
|
except Exception:
|
|
pass # Dictionary lookup is best-effort
|
|
|
|
lines.append("")
|
|
|
|
# Cross-tradition comparison summary
|
|
lines.append("### 传承视角对比")
|
|
tradition_map: dict[str, list[str]] = {}
|
|
for slug in teacher_slugs:
|
|
try:
|
|
meta = load_teacher_meta(slug)
|
|
scope = meta.get("search_scope", {})
|
|
for t in scope.get("traditions", []):
|
|
tradition_map.setdefault(t, []).append(meta.get("name", slug))
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
for tradition, teachers in tradition_map.items():
|
|
lines.append(f"- **{tradition}**: {', '.join(teachers)}")
|
|
|
|
if len(tradition_map) > 1:
|
|
lines.append("")
|
|
lines.append(
|
|
f"共涉及 {len(tradition_map)} 个传承，"
|
|
f"建议对比各传承对「{concept}」的不同诠释角度。"
|
|
)
|
|
|
|
return "\n".join(lines)
|
|
|
|
|
|
# ── CLI ─────────────────────────────────────────────────────────
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="Cross-reference Buddhist masters and concepts via FoJin KG",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog="""Examples:
|
|
%(prog)s lineage "印光" "蕅益"
|
|
%(prog)s concept "空性" --teachers xuanzang,kumarajiva
|
|
%(prog)s concept "止观" --teachers zhiyi,ouyi,xuyun
|
|
%(prog)s list
|
|
""",
|
|
)
|
|
sub = parser.add_subparsers(dest="command")
|
|
|
|
# lineage
|
|
p_lineage = sub.add_parser("lineage", help="查询两人师承关系")
|
|
p_lineage.add_argument("person_a", help="第一位人物名称")
|
|
p_lineage.add_argument("person_b", help="第二位人物名称")
|
|
|
|
# concept
|
|
p_concept = sub.add_parser("concept", help="跨传承概念对比")
|
|
p_concept.add_argument("concept", help="要比较的概念")
|
|
p_concept.add_argument(
|
|
"--teachers", "-t", required=True,
|
|
help="法师slug列表，逗号分隔 (如: xuanzang,kumarajiva)"
|
|
)
|
|
|
|
# list
|
|
sub.add_parser("list", help="列出所有可用法师")
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.command == "list":
|
|
print("Available teachers:")
|
|
for slug in list_teachers():
|
|
meta = load_teacher_meta(slug)
|
|
scope = meta.get("search_scope", {})
|
|
traditions = ", ".join(scope.get("traditions", []))
|
|
print(f" {slug:16s} {meta['name']} ({traditions})")
|
|
return
|
|
|
|
if args.command is None:
|
|
parser.print_help()
|
|
return
|
|
|
|
bridge = create_bridge()
|
|
|
|
if args.command == "lineage":
|
|
output = cmd_lineage(bridge, args.person_a, args.person_b)
|
|
elif args.command == "concept":
|
|
teacher_slugs = [s.strip() for s in args.teachers.split(",")]
|
|
output = cmd_concept(bridge, args.concept, teacher_slugs)
|
|
else:
|
|
parser.print_help()
|
|
return
|
|
|
|
print(output)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|