@jerryjiao/knowflow 0.3.0

package/scripts/wiki-health.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""Wiki Health Check — validates links, file sizes, and orphan pages.
+
+Usage:
+    python scripts/wiki-health.py [WIKI_DIR]
+
+Checks:
+  1. Broken links: [[wiki-links]] and [markdown](links) pointing to missing files
+  2. Tiny files: .md files under 100 bytes
+  3. Orphan pages: .md files not linked from any other page (excludes index.md, topics.md, overview.md, log.md)
+
+Exit codes:
+  0 — all checks pass (or only warnings)
+  1 — broken links found
+  2 — errors during execution
+"""
+
+import os
+import re
+import sys
+import urllib.request
+import urllib.parse
+from pathlib import Path
+from collections import defaultdict
+
+# --- Configuration ---
+WIKI_ROOT = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("wiki")
+TINY_THRESHOLD = 100  # bytes
+INDEX_FILES = {"index.md", "topics.md", "overview.md", "log.md"}
+
+# --- Helpers ---
+
+def resolve_wiki_link(link_target: str, source_file: Path, wiki_root: Path) -> Path:
+    """Resolve a [[wiki-link]] target to an actual file path.
+
+    Wiki-links are relative to wiki_root, not to the source file.
+    Supports optional display text: [[target|Display Text]] -> target
+    """
+    # Strip optional display text: [[target|display]] -> target
+    target = link_target.split("|")[0].strip()
+    if not target:
+        return None
+
+    # Wiki-links are relative to wiki root
+    resolved = wiki_root / target
+
+    # Try exact path first
+    if resolved.is_file():
+        return resolved
+
+    # Try with .md extension
+    md_path = resolved.with_suffix(".md")
+    if md_path.is_file():
+        return md_path
+
+    return None
+
+
+def resolve_md_link(link_target: str, source_file: Path, wiki_root: Path) -> Path:
+    """Resolve a [markdown](link) target to an actual file path.
+
+    Markdown links are relative to the source file's directory.
+    """
+    if not link_target or link_target.startswith(("http://", "https://", "#", "mailto:")):
+        return None  # External or anchor links — skip
+
+    # URL-decode for Chinese filenames
+    decoded = urllib.parse.unquote(link_target)
+
+    # Markdown links are relative to the source file directory
+    source_dir = source_file.parent
+    resolved = (source_dir / decoded).resolve()
+
+    if resolved.is_file():
+        return resolved
+
+    return None
+
+
+def strip_code_blocks(content: str) -> str:
+    """Remove fenced code blocks and inline code to avoid false positive links."""
+    # Remove fenced code blocks (```...```)
+    content = re.sub(r'```.*?```', '', content, flags=re.DOTALL)
+    # Remove inline code (`...`)
+    content = re.sub(r'`[^`]+`', '', content)
+    return content
+
+
+def extract_links(content: str, source_file: Path, wiki_root: Path):
+    """Extract all link targets from markdown content.
+
+    Returns:
+        wiki_links: set of (raw_target, resolved_path_or_None) for [[]] links
+        md_links: set of (raw_target, resolved_path_or_None) for []() links
+    """
+    wiki_links = set()
+    md_links = set()
+
+    # Strip code blocks to avoid false positives
+    clean = strip_code_blocks(content)
+
+    # [[wiki-links]] — may contain | for display text
+    for match in re.finditer(r'\[\[([^\]]+)\]\]', clean):
+        raw = match.group(1)
+        target = raw.split("|")[0].strip()
+        resolved = resolve_wiki_link(target, source_file, wiki_root)
+        wiki_links.add((target, resolved))
+
+    # [markdown](links) — standard markdown
+    for match in re.finditer(r'\[([^\]]*)\]\(([^)]+)\)', clean):
+        raw_target = match.group(2).strip()
+        resolved = resolve_md_link(raw_target, source_file, wiki_root)
+        if resolved is not None or not raw_target.startswith(("http://", "https://", "#", "mailto:")):
+            md_links.add((raw_target, resolved))
+
+    return wiki_links, md_links
+
+
+# --- Checks ---
+
+def check_broken_links(wiki_root: Path) -> list[dict]:
+    """Find all broken links across the wiki."""
+    broken = []
+
+    for md_file in sorted(wiki_root.rglob("*.md")):
+        try:
+            content = md_file.read_text(encoding="utf-8")
+        except Exception as e:
+            broken.append({
+                "file": str(md_file.relative_to(wiki_root)),
+                "error": f"Cannot read file: {e}"
+            })
+            continue
+
+        wiki_links, md_links = extract_links(content, md_file, wiki_root)
+
+        rel_path = str(md_file.relative_to(wiki_root))
+
+        for raw_target, resolved in wiki_links:
+            if resolved is None:
+                broken.append({
+                    "type": "wiki-link",
+                    "file": rel_path,
+                    "target": raw_target,
+                    "detail": f"[[{raw_target}]] -> file not found"
+                })
+
+        for raw_target, resolved in md_links:
+            # Skip external links
+            if raw_target.startswith(("http://", "https://", "#", "mailto:")):
+                continue
+            if resolved is None:
+                broken.append({
+                    "type": "md-link",
+                    "file": rel_path,
+                    "target": raw_target,
+                    "detail": f"[]({raw_target}) -> file not found"
+                })
+
+    return broken
+
+
+def check_tiny_files(wiki_root: Path, threshold: int = TINY_THRESHOLD) -> list[dict]:
+    """Find .md files smaller than threshold bytes."""
+    tiny = []
+
+    for md_file in sorted(wiki_root.rglob("*.md")):
+        try:
+            size = md_file.stat().st_size
+        except OSError:
+            continue
+
+        if size < threshold:
+            tiny.append({
+                "file": str(md_file.relative_to(wiki_root)),
+                "size": size,
+                "detail": f"{size}B < {threshold}B threshold"
+            })
+
+    return tiny
+
+
+def check_orphan_pages(wiki_root: Path) -> list[dict]:
+    """Find .md pages not referenced by any other page."""
+    # Collect all existing pages
+    all_pages = set()
+    for md_file in wiki_root.rglob("*.md"):
+        all_pages.add(md_file)
+
+    # Collect all link targets across all files
+    referenced = set()
+    for md_file in wiki_root.rglob("*.md"):
+        try:
+            content = md_file.read_text(encoding="utf-8")
+        except Exception:
+            continue
+
+        wiki_links, md_links = extract_links(content, md_file, wiki_root)
+
+        for _, resolved in wiki_links:
+            if resolved is not None:
+                referenced.add(resolved)
+
+        for _, resolved in md_links:
+            if resolved is not None:
+                referenced.add(resolved)
+
+    orphans = []
+    for page in sorted(all_pages):
+        rel = str(page.relative_to(wiki_root))
+        # Index files are never considered orphans
+        if page.name in INDEX_FILES:
+            continue
+        if page not in referenced:
+            orphans.append({
+                "file": rel,
+                "detail": "not linked from any other page"
+            })
+
+    return orphans
+
+
+# --- Main ---
+
+def main():
+    if not WIKI_ROOT.is_dir():
+        print(f"ERROR: wiki directory not found: {WIKI_ROOT}")
+        sys.exit(2)
+
+    print(f"Wiki Health Check — {WIKI_ROOT.resolve()}")
+    print(f"{'=' * 60}")
+
+    # Count files
+    md_files = list(WIKI_ROOT.rglob("*.md"))
+    print(f"Total .md files: {len(md_files)}")
+
+    exit_code = 0
+
+    # 1. Broken links
+    print(f"\n--- Broken Links ---")
+    broken = check_broken_links(WIKI_ROOT)
+    if broken:
+        errors = [b for b in broken if "error" in b]
+        link_issues = [b for b in broken if "error" not in b]
+        if link_issues:
+            print(f"  BROKEN LINKS: {len(link_issues)}")
+            for item in link_issues:
+                print(f"    [{item['type']}] {item['file']} -> {item['target']}")
+            exit_code = 1
+        if errors:
+            print(f"  READ ERRORS: {len(errors)}")
+            for item in errors:
+                print(f"    {item['file']}: {item['error']}")
+    else:
+        print("  OK — no broken links found")
+
+    # 2. Tiny files
+    print(f"\n--- Tiny Files (< {TINY_THRESHOLD}B) ---")
+    tiny = check_tiny_files(WIKI_ROOT)
+    if tiny:
+        print(f"  TINY FILES: {len(tiny)}")
+        for item in tiny:
+            print(f"    {item['file']} ({item['detail']})")
+    else:
+        print("  OK — no tiny files found")
+
+    # 3. Orphan pages
+    print(f"\n--- Orphan Pages ---")
+    orphans = check_orphan_pages(WIKI_ROOT)
+    if orphans:
+        print(f"  ORPHAN PAGES: {len(orphans)}")
+        for item in orphans:
+            print(f"    {item['file']}")
+    else:
+        print("  OK — no orphan pages found")
+
+    print(f"\n{'=' * 60}")
+    total_issues = len(broken) + len(tiny) + len(orphans)
+    print(f"Total issues: {total_issues}")
+
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/wiki-health.sh

@@ -0,0 +1,335 @@
+#!/opt/homebrew/bin/bash
+# knowflow health check — broken links, empty files, orphan pages
+# Usage: bash scripts/wiki-health.sh [--wiki-root <path>] [--json]
+#
+# M2 改进:
+#   - 添加 --json 选项输出结构化 JSON（方便 CLI 解析）
+#   - 输出结构化格式，每行前缀统一
+#   - 保持向后兼容（默认人类可读模式不变）
+#
+# Checks:
+#   1. Broken links  — [[wikilinks]] and [md](path.md) that point to missing files
+#   2. Empty files   — .md files < 100 bytes
+#   3. Orphan pages  — .md files never referenced by any other page
+
+set -euo pipefail
+
+# ── Config ──────────────────────────────────────────────
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+WIKI_ROOT="${KNOWFLOW_ROOT:-${WIKI_ROOT:-$(cd "$SCRIPT_DIR/.." && pwd)}}"
+WIKI_DIR="${KNOWFLOW_WIKI_DIR:-$WIKI_ROOT/wiki}"
+MIN_SIZE=100
+OUTPUT_FORMAT="text"  # text | json
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --wiki-root) WIKI_ROOT="$2"; WIKI_DIR="$2/wiki"; shift 2 ;;
+    --wiki-dir) WIKI_DIR="$2"; shift 2 ;;
+    --json) OUTPUT_FORMAT="json"; shift ;;
+    --min-size) MIN_SIZE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+if [ ! -d "$WIKI_DIR" ]; then
+  if [ "$OUTPUT_FORMAT" = "json" ]; then
+    echo "{\"status\":\"error\",\"message\":\"Wiki directory not found: $WIKI_DIR\"}"
+  else
+    echo "Error: wiki directory not found at $WIKI_DIR" >&2
+  fi
+  exit 1
+fi
+
+# ── Counters ────────────────────────────────────────────
+BROKEN_COUNT=0
+EMPTY_COUNT=0
+ORPHAN_COUNT=0
+
+# JSON output accumulators (used only when --json)
+JSON_BROKEN=""
+JSON_EMPTY=""
+JSON_ORPHAN=""
+
+# ── Helper: resolve a wikilink to an absolute path ──
+resolve_link() {
+  local mode="$1"
+  local basedir="$2"
+  local target="$3"
+  local abs_path
+
+  if [[ "$target" == /* ]]; then
+    abs_path="$WIKI_DIR${target}"
+  elif [ "$mode" = "wiki" ]; then
+    abs_path="$WIKI_DIR/$target"
+  else
+    abs_path="$WIKI_DIR/$basedir/$target"
+  fi
+
+  local dir_part="$(dirname "$abs_path")"
+  local base_part="$(basename "$abs_path")"
+  local norm_dir
+  norm_dir="$(cd "$dir_part" 2>/dev/null && pwd)" 2>/dev/null || {
+    return 1
+  }
+  echo "${norm_dir}/${base_part}"
+}
+
+# ── Helper: extract [[wikilinks]] (macOS grep compatible) ──
+# grep -o finds every link on a line; a sed s///gp approach would only catch
+# one per line, which silently drops references on index-style pages that put
+# dozens of links on a single line.
+extract_wikilinks() {
+  grep -oE '\[\[[^]]+\]\]' "$1" 2>/dev/null \
+    | sed 's/^\[\[//; s/\]\]$//; s/|.*//' \
+    | grep -v '^[[:space:]]*$' \
+    | awk '!seen[$0]++' || true
+}
+
+# ── Helper: extract [text](path.md) markdown links ──
+extract_mdlinks() {
+  grep -oE '\]\([^)]+\.md\)' "$1" 2>/dev/null \
+    | sed 's/^\](//; s/)$//' \
+    | awk '!seen[$0]++' || true
+}
+
+# ── Check 1: Broken Links ──────────────────────────────
+check_broken_links() {
+  local found=0
+  local json_items=""
+
+  while IFS= read -r -d '' file; do
+    local relpath="${file#$WIKI_DIR/}"
+    local basedir
+    basedir="$(dirname "$relpath")"
+
+    # Check [[wikilinks]]
+    while IFS= read -r link; do
+      [ -z "$link" ] && continue
+      local target="${link%.md}.md"
+      local resolved
+      resolved="$(resolve_link wiki "$basedir" "$target")" || true
+
+      if [ -z "$resolved" ] || [ ! -f "$resolved" ]; then
+        if [ "$OUTPUT_FORMAT" = "json" ]; then
+          json_items="${json_items:+$json_items, }{\"file\":\"$relpath\",\"link\":\"$link\",\"type\":\"wikilink\"}"
+        else
+          echo "  ✗ $relpath → [[$link]] (not found)"
+        fi
+        BROKEN_COUNT=$((BROKEN_COUNT + 1))
+        found=1
+      fi
+    done < <(extract_wikilinks "$file")
+
+    # Check [text](path.md) markdown links
+    while IFS= read -r link; do
+      [ -z "$link" ] && continue
+      case "$link" in http:*|https:*|mailto:*) continue ;; esac
+      local target="${link%.md}.md"
+      local resolved
+      resolved="$(resolve_link md "$basedir" "$target")" || true
+
+      if [ -z "$resolved" ] || [ ! -f "$resolved" ]; then
+        if [ "$OUTPUT_FORMAT" = "json" ]; then
+          json_items="${json_items:+$json_items, }{\"file\":\"$relpath\",\"link\":\"$link\",\"type:\"markdown\"}"
+        else
+          echo "  ✗ $relpath → $link (not found)"
+        fi
+        BROKEN_COUNT=$((BROKEN_COUNT + 1))
+        found=1
+      fi
+    done < <(extract_mdlinks "$file")
+
+  done < <(find "$WIKI_DIR" -name '*.md' -not -path '*/.understand-anything/*' -print0 2>/dev/null)
+
+  if [ "$found" -eq 0 ]; then
+    if [ "$OUTPUT_FORMAT" != "json" ]; then
+      echo "  ✓ All links resolve correctly"
+    fi
+  fi
+
+  JSON_BROKEN="$json_items"
+}
+
+# ── Check 2: Empty Files ───────────────────────────────
+check_empty_files() {
+  local found=0
+  local json_items=""
+
+  while IFS= read -r -d '' file; do
+    local relpath="${file#$WIKI_DIR/}"
+    local size
+    size="$(wc -c < "$file" | tr -d ' ')"
+
+    if [ "$OUTPUT_FORMAT" = "json" ]; then
+      json_items="${json_items:+$json_items, }{\"file\":\"$relpath\",\"size\":$size}"
+    else
+      echo "  ✗ $relpath ($size bytes)"
+    fi
+    EMPTY_COUNT=$((EMPTY_COUNT + 1))
+    found=1
+  done < <(find "$WIKI_DIR" -name '*.md' -not -path '*/.understand-anything/*' -size -${MIN_SIZE}c -print0 2>/dev/null)
+
+  if [ "$found" -eq 0 ]; then
+    if [ "$OUTPUT_FORMAT" != "json" ]; then
+      echo "  ✓ No empty files found"
+    fi
+  fi
+
+  JSON_EMPTY="$json_items"
+}
+
+# ── Check 3: Orphan Pages ──────────────────────────────
+# KNOWFLOW_HEALTH_EXCLUDE_ORPHAN (colon-separated relative dirs, e.g. "sources/:logs/")
+# lists directories whose pages are expected to be unreferenced (feed/inbox
+# pages) and should not count as orphans.
+EXCLUDE_ORPHAN="${KNOWFLOW_HEALTH_EXCLUDE_ORPHAN:-}"
+
+is_orphan_excluded() {
+  local rel="$1"
+  [ -z "$EXCLUDE_ORPHAN" ] && return 1
+  local parts part
+  IFS=':' read -ra parts <<< "$EXCLUDE_ORPHAN"
+  for part in "${parts[@]}"; do
+    part="${part%/}"
+    [[ -n "$part" && ( "$rel" == "$part" || "$rel" == "$part"/* ) ]] && return 0
+  done
+  return 1
+}
+
+check_orphan_pages() {
+  local found=0
+  local json_items=""
+
+  local ref_file
+  ref_file="$(mktemp)"
+
+  while IFS= read -r -d '' file; do
+    local relpath="${file#$WIKI_DIR/}"
+    local basedir
+    basedir="$(dirname "$relpath")"
+
+    while IFS= read -r link; do
+      [ -z "$link" ] && continue
+      local target="${link%.md}.md"
+      local resolved
+      resolved="$(resolve_link wiki "$basedir" "$target")" || continue
+      echo "${resolved#$WIKI_DIR/}" >> "$ref_file"
+    done < <(extract_wikilinks "$file")
+
+    while IFS= read -r link; do
+      [ -z "$link" ] && continue
+      case "$link" in http:*|https:*|mailto:*) continue ;; esac
+      local target="${link%.md}.md"
+      local resolved
+      resolved="$(resolve_link md "$basedir" "$target")" || continue
+      echo "${resolved#$WIKI_DIR/}" >> "$ref_file"
+    done < <(extract_mdlinks "$file")
+
+  done < <(find "$WIKI_DIR" -name '*.md' -not -path '*/.understand-anything/*' -print0 2>/dev/null)
+
+  while IFS= read -r -d '' file; do
+    local relpath="${file#$WIKI_DIR/}"
+    if [ "$relpath" = "index.md" ]; then
+      continue
+    fi
+    if is_orphan_excluded "$relpath"; then
+      continue
+    fi
+    if ! grep -qxF "$relpath" "$ref_file" 2>/dev/null; then
+      if [ "$OUTPUT_FORMAT" = "json" ]; then
+        json_items="${json_items:+$json_items, }{\"file\":\"$relpath\"}"
+      else
+        echo "  ✗ $relpath"
+      fi
+      ORPHAN_COUNT=$((ORPHAN_COUNT + 1))
+      found=1
+    fi
+  done < <(find "$WIKI_DIR" -name '*.md' -not -path '*/.understand-anything/*' -print0 2>/dev/null)
+
+  rm -f "$ref_file"
+
+  if [ "$found" -eq 0 ]; then
+    if [ "$OUTPUT_FORMAT" != "json" ]; then
+      echo "  ✓ All pages are referenced"
+    fi
+  fi
+
+  JSON_ORPHAN="$json_items"
+}
+
+# ── Main ────────────────────────────────────────────────
+TIMESTAMP="$(date '+%Y-%m-%d %H:%M:%S')"
+TOTAL=$((BROKEN_COUNT + EMPTY_COUNT + ORPHAN_COUNT))
+
+if [ "$OUTPUT_FORMAT" = "json" ]; then
+  # ── JSON mode: run checks silently, output structured JSON ──
+  check_broken_links || { BROKEN_COUNT=0; }
+  check_empty_files || { EMPTY_COUNT=0; }
+  check_orphan_pages || { ORPHAN_COUNT=0; }
+
+  TOTAL=$((BROKEN_COUNT + EMPTY_COUNT + ORPHAN_COUNT))
+
+  cat << EOF
+{
+  "status": "$([ $TOTAL -eq 0 ] && echo "ok" || echo "issues_found")",
+  "timestamp": "$TIMESTAMP",
+  "wiki_root": "$WIKI_DIR",
+  "summary": {
+    "broken_links": $BROKEN_COUNT,
+    "empty_files": $EMPTY_COUNT,
+    "orphan_pages": $ORPHAN_COUNT,
+    "total_issues": $TOTAL,
+    "min_size_bytes": $MIN_SIZE
+  },
+  "details": {
+    "broken_links": [$JSON_BROKEN],
+    "empty_files": [$JSON_EMPTY],
+    "orphan_pages": [$JSON_ORPHAN]
+  }
+}
+EOF
+
+  [ $TOTAL -eq 0 ] && exit 0 || exit 1
+
+else
+  # ── Text mode (default, backward compatible) ──
+  echo "🏥 KnowFlow Wiki — Health Check"
+  echo "====================================="
+  echo "Wiki root: $WIKI_DIR"
+  echo "Time: $TIMESTAMP"
+  echo ""
+
+  echo "## 🔗 Broken Links"
+  echo ""
+  check_broken_links || { echo "  ⚠️ Broken links check interrupted"; BROKEN_COUNT=0; }
+  echo ""
+
+  echo "## 📄 Empty Files (< ${MIN_SIZE} bytes)"
+  echo ""
+  check_empty_files || { echo "  ⚠️ Empty files check interrupted"; EMPTY_COUNT=0; }
+  echo ""
+
+  echo "## 🏝️ Orphan Pages (never referenced)"
+  echo ""
+  check_orphan_pages || { echo "  ⚠️ Orphan pages check interrupted"; ORPHAN_COUNT=0; }
+  echo ""
+
+  TOTAL=$((BROKEN_COUNT + EMPTY_COUNT + ORPHAN_COUNT))
+
+  echo "## 📊 Summary"
+  echo ""
+  echo "  Broken links:  $BROKEN_COUNT"
+  echo "  Empty files:   $EMPTY_COUNT"
+  echo "  Orphan pages:  $ORPHAN_COUNT"
+  echo "  Total issues:  $TOTAL"
+  echo ""
+
+  if [ "$TOTAL" -eq 0 ]; then
+    echo "✅ All checks passed"
+    exit 0
+  else
+    echo "❌ $TOTAL issue(s) found"
+    exit 1
+  fi
+fi

package/templates/comparison.md

@@ -0,0 +1,31 @@
+# {{对比主题}}
+
+> 对比分析 | 创建时间: {{YYYY-MM-DD}}
+
+## 📋 对比对象
+
+| 维度 | {{对象A}} | {{对象B}} | {{对象C(可选)}} |
+|------|-----------|-----------|----------------|
+| 定位/定义 | ... | ... | ... |
+| 核心优势 | ... | ... | ... |
+| 核心劣势 | ... | ... | ... |
+| 适用场景 | ... | ... | ... |
+| 学习成本 | ... | ... | ... |
+| 生态成熟度 | ... | ... | ... |
+| 成本 | ... | ... | ... |
+
+## 🏆 结论
+
+### 最适合的场景
+- 场景 A → 推荐 **{{对象X}}**，因为...
+- 场景 B → 推荐 **{{对象Y}}**，因为...
+
+## 🔗 关联内容
+- 实体: [[entities/...]], [[entities/...]]
+- 概念: [[concepts/...]]
+- 来源: [[sources/...]]
+
+## ⚠️ 局限性
+> 本次对比基于以下来源，可能存在信息偏差：
+> - [[sources/{{来源1}}]]
+> - [[sources/{{来源2}}]]

package/templates/concept.md

@@ -0,0 +1,37 @@
+# {{概念名称}}
+
+> 定义 | 置信度: EXTRACTED
+
+## 📖 定义
+{{一句话定义这个概念}}
+
+## 🎯 核心观点
+
+### 观点 1: {{标题}}
+> 描述... (EXTRACTED)
+>
+> 来源: [[sources/{{来源}}]]
+
+### 观点 2: {{标题}}
+> 描述... (INFERRED)
+
+### 观点 3: {{不同视角/反面观点}}
+> 如果有争议或不同视角，记录在此
+
+## 🔬 不同来源的视角对比
+
+| 来源 | 视角 | 关键论点 |
+|------|------|---------|
+| [[sources/...]] | ... | ... |
+| [[sources/...]] | ... | ... |
+
+## 💡 实践应用
+1. **应用场景 1**: ...
+2. **应用场景 2**: ...
+
+## 🔗 关联内容
+- 实体: [[entities/{{相关实体}}]]
+- 概念: [[concepts/{{相关概念}}]]
+
+## 📚 延伸阅读
+- [[sources/{{相关来源}}]]