local-knowledge-graph 1.5.0

package/lib/updater.js

@@ -0,0 +1,144 @@
+'use strict';
+
+// 版本与更新（双模式）：
+//  - 开发模式（程序目录是Git仓库）：git fetch 对比 origin/master，pull --ff-only 更新
+//  - npm 模式（全局安装）：npm view 对比注册表版本，npm i -g <pkg>@latest 更新
+// 数据目录独立于程序目录，两种模式的升级都不影响用户数据。
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { APP_ROOT, PKG_NAME, isDevRepo } = require('./paths');
+
+const GIT_TIMEOUT = 20000;
+
+function git(args, timeout = GIT_TIMEOUT) {
+  return execFileSync('git', args, { cwd: APP_ROOT, timeout, encoding: 'utf8' }).trim();
+}
+
+function npm(args, timeout = 30000) {
+  const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  return execFileSync(bin, args, { cwd: APP_ROOT, timeout, encoding: 'utf8' }).trim();
+}
+
+function shortErr(e) {
+  return String(e.message || e).split('\n')[0].slice(0, 180);
+}
+
+function currentVersion() {
+  try { return JSON.parse(fs.readFileSync(path.join(APP_ROOT, 'package.json'), 'utf8')).version; }
+  catch (_) { return 'unknown'; }
+}
+
+function compareVersions(a, b) {
+  const pa = String(a).split('.').map(Number);
+  const pb = String(b).split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] || 0;
+    const y = pb[i] || 0;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  return 0;
+}
+
+function repoSlug() {
+  try {
+    const url = git(['remote', 'get-url', 'origin']);
+    const m = url.match(/github\.com[:/](.+?)(?:\.git)?\/?$/);
+    if (m) return m[1];
+  } catch (_) { /* fallback */ }
+  return 'iamsamyiok/local-knowledge-graph';
+}
+
+// 最新 Release 信息（尽力而为，失败不影响检查结果）
+async function fetchLatestRelease() {
+  try {
+    const res = await fetch(`https://api.github.com/repos/${repoSlug()}/releases/latest`, {
+      headers: { 'User-Agent': 'local-knowledge-graph-updater', Accept: 'application/vnd.github+json' },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) return null;
+    const j = await res.json();
+    return { tag: j.tag_name, name: j.name, url: j.html_url, published_at: j.published_at };
+  } catch (_) { return null; }
+}
+
+// ---------- npm 模式 ----------
+function checkSyncNpm() {
+  let registryVersion;
+  try { registryVersion = npm(['view', PKG_NAME, 'version'], 30000); }
+  catch (e) { return { ok: false, error: '无法连接 npm 注册表：' + shortErr(e) }; }
+  const cur = currentVersion();
+  const cmp = compareVersions(cur, registryVersion);
+  return {
+    ok: true,
+    mode: 'npm',
+    current_version: cur,
+    registry_version: registryVersion,
+    behind: cmp < 0 ? 1 : 0,
+    ahead: cmp > 0 ? 1 : 0,
+    up_to_date: cmp >= 0,
+  };
+}
+
+function applyUpdateNpm() {
+  const c = checkSyncNpm();
+  if (!c.ok) return c;
+  if (c.up_to_date) return { ok: true, up_to_date: true, version: currentVersion() };
+  try { npm(['install', '-g', `${PKG_NAME}@${c.registry_version}`], 300000); }
+  catch (e) { return { ok: false, error: 'npm 全局更新失败：' + shortErr(e) }; }
+  return { ok: true, up_to_date: false, version: c.registry_version, from_version: c.current_version };
+}
+
+// ---------- 开发模式（git） ----------
+function checkSyncGit() {
+  const info = { ok: true, mode: 'git', current_version: currentVersion(), up_to_date: true, behind: 0, ahead: 0 };
+  let localSha;
+  try { localSha = git(['rev-parse', 'HEAD']); }
+  catch (e) { return { ok: false, error: '当前目录不是Git仓库，无法检查更新：' + shortErr(e) }; }
+  try { git(['fetch', 'origin', 'master'], 30000); }
+  catch (e) { return { ok: false, error: '无法连接 GitHub：' + shortErr(e) }; }
+  let remoteSha;
+  try { remoteSha = git(['rev-parse', 'FETCH_HEAD']); }
+  catch (e) { return { ok: false, error: '读取远端版本失败：' + shortErr(e) }; }
+  info.local_sha = localSha.slice(0, 7);
+  info.remote_sha = remoteSha.slice(0, 7);
+  if (remoteSha !== localSha) {
+    try { info.behind = Number(git(['rev-list', '--count', `HEAD..${remoteSha}`])) || 0; } catch (_) { info.behind = 0; }
+    try { info.ahead = Number(git(['rev-list', '--count', `${remoteSha}..HEAD`])) || 0; } catch (_) { info.ahead = 0; }
+    info.up_to_date = info.behind === 0 && info.ahead === 0;
+    if (info.behind === 0 && info.ahead > 0) info.note = `本地领先远端 ${info.ahead} 个提交`;
+  }
+  return info;
+}
+
+function applyUpdateGit() {
+  const c = checkSyncGit();
+  if (!c.ok) return c;
+  if (c.up_to_date) return { ok: true, up_to_date: true, version: currentVersion() };
+  if (c.ahead > 0) return { ok: false, error: `本地存在 ${c.ahead} 个未发布提交，无法快进更新；请在项目目录手动处理（git stash 或推送后重试）` };
+  try { git(['pull', '--ff-only', 'origin', 'master'], 120000); }
+  catch (e) { return { ok: false, error: '更新失败：' + shortErr(e) }; }
+  return { ok: true, up_to_date: false, version: currentVersion(), from_sha: c.local_sha, to_sha: c.remote_sha };
+}
+
+// ---------- 对外接口 ----------
+function updateMode() {
+  return isDevRepo() ? 'git' : 'npm';
+}
+
+function checkSync() {
+  return updateMode() === 'git' ? checkSyncGit() : checkSyncNpm();
+}
+
+async function checkUpdate() {
+  const info = checkSync();
+  if (info.ok) info.latest_release = await fetchLatestRelease();
+  return info;
+}
+
+function applyUpdate() {
+  return updateMode() === 'git' ? applyUpdateGit() : applyUpdateNpm();
+}
+
+module.exports = { currentVersion, compareVersions, checkUpdate, applyUpdate, checkSync, updateMode, repoSlug };

package/lib/validator.js

@@ -0,0 +1,146 @@
+'use strict';
+
+// RDF规范校验器：所有手工与OpenCode操作共用同一套校验，标准完全一致
+
+const ENTITY_CATEGORIES = ['物理实体', '抽象实体', '数值实体', '时间实体'];
+const RELATION_CATEGORIES = ['空间', '互动', '归属', '时间', '属性'];
+const SOURCES = ['手工', 'OpenCode', '系统'];
+const RDF_TYPE_MAP = {
+  '物理实体': 'PhysicalEntity',
+  '抽象实体': 'AbstractEntity',
+  '数值实体': 'NumericEntity',
+  '时间实体': 'TemporalEntity',
+};
+const RDF_RELATION_TYPE_MAP = {
+  '空间': 'SpatialRelation',
+  '互动': 'InteractionRelation',
+  '归属': 'BelongingRelation',
+  '时间': 'TemporalRelation',
+  '属性': 'AttributeRelation',
+};
+
+function isPrimitive(v) {
+  return v === null || ['string', 'number', 'boolean'].includes(typeof v);
+}
+
+// 实体校验：三元组结构 (subject=实体, predicate=属性键, object=原子值)
+// 属性必须是扁平JSON对象，键为非空字符串，值为原始类型；禁止嵌套与冗余字段
+function validateEntityInput(input) {
+  const errors = [];
+  if (!input || typeof input !== 'object') return { ok: false, errors: ['输入必须为JSON对象'], value: null };
+
+  const name = input.name;
+  if (typeof name !== 'string' || name.trim().length === 0) errors.push('实体名称必须为非空字符串');
+  if (typeof name === 'string' && name.length > 200) errors.push('实体名称长度不得超过200字符');
+
+  const category = input.category;
+  if (!ENTITY_CATEGORIES.includes(category)) {
+    errors.push(`实体大类必须为以下4类之一: ${ENTITY_CATEGORIES.join(' / ')}`);
+  }
+
+  let attributes = input.attributes === undefined ? {} : input.attributes;
+  if (attributes === null || typeof attributes !== 'object' || Array.isArray(attributes)) {
+    errors.push('属性(attributes)必须为JSON对象');
+    attributes = null;
+  } else {
+    for (const [k, v] of Object.entries(attributes)) {
+      if (typeof k !== 'string' || k.trim().length === 0) errors.push(`属性键"${k}"必须为非空字符串`);
+      if (!isPrimitive(v)) {
+        errors.push(`属性"${k}"的值必须为字符串/数值/布尔/空值(扁平三元组结构)，禁止嵌套对象或数组`);
+      }
+    }
+    if (Object.keys(attributes).length > 100) errors.push('属性键数量不得超过100');
+  }
+
+  if (errors.length) return { ok: false, errors, value: null };
+  return { ok: true, errors: [], value: { name: name.trim(), category, attributes } };
+}
+
+function validateEntityPatch(patch, existing) {
+  const errors = [];
+  const merged = {
+    name: existing.name,
+    category: existing.category,
+    attributes: JSON.parse(existing.attributes || '{}'),
+  };
+  if (patch.name !== undefined) {
+    if (typeof patch.name !== 'string' || patch.name.trim().length === 0) errors.push('实体名称必须为非空字符串');
+    else merged.name = patch.name.trim();
+  }
+  if (patch.category !== undefined) {
+    if (!ENTITY_CATEGORIES.includes(patch.category)) errors.push(`实体大类必须为: ${ENTITY_CATEGORIES.join(' / ')}`);
+    else merged.category = patch.category;
+  }
+  if (patch.attributes !== undefined) {
+    const check = validateEntityInput({ name: merged.name, category: merged.category, attributes: patch.attributes });
+    if (!check.ok) errors.push(...check.errors);
+    else merged.attributes = check.value.attributes;
+  }
+  if (errors.length) return { ok: false, errors, value: null };
+  return { ok: true, errors: [], value: merged };
+}
+
+// 关系校验：三元组结构 (subject=起点实体, predicate=关系, object=终点实体)
+function validateRelationInput(input, db) {
+  const errors = [];
+  if (!input || typeof input !== 'object') return { ok: false, errors: ['输入必须为JSON对象'], value: null };
+
+  const sid = Number(input.source_id);
+  const tid = Number(input.target_id);
+  if (!Number.isInteger(sid) || sid <= 0) errors.push('起点实体id必须为正整数');
+  if (!Number.isInteger(tid) || tid <= 0) errors.push('终点实体id必须为正整数');
+  if (errors.length === 0) {
+    const s = db.prepare('SELECT id FROM entities WHERE id = ?').get(sid);
+    const t = db.prepare('SELECT id FROM entities WHERE id = ?').get(tid);
+    if (!s) errors.push(`起点实体id=${sid} 不存在`);
+    if (!t) errors.push(`终点实体id=${tid} 不存在`);
+    if (sid === tid) errors.push('起点与终点不能为同一实体');
+  }
+
+  const name = input.name;
+  if (typeof name !== 'string' || name.trim().length === 0) errors.push('关系名称必须为非空字符串');
+  if (typeof name === 'string' && name.length > 200) errors.push('关系名称长度不得超过200字符');
+
+  const category = input.category;
+  if (!RELATION_CATEGORIES.includes(category)) {
+    errors.push(`关系大类必须为以下5类之一: ${RELATION_CATEGORIES.join(' / ')}`);
+  }
+
+  if (errors.length) return { ok: false, errors, value: null };
+  return { ok: true, errors: [], value: { source_id: sid, target_id: tid, name: name.trim(), category } };
+}
+
+function validateRelationPatch(patch, existing, db) {
+  const errors = [];
+  const merged = {
+    source_id: existing.source_id,
+    target_id: existing.target_id,
+    name: existing.name,
+    category: existing.category,
+  };
+  if (patch.source_id !== undefined) merged.source_id = patch.source_id;
+  if (patch.target_id !== undefined) merged.target_id = patch.target_id;
+  if (patch.name !== undefined) {
+    if (typeof patch.name !== 'string' || patch.name.trim().length === 0) errors.push('关系名称必须为非空字符串');
+    else merged.name = patch.name.trim();
+  }
+  if (patch.category !== undefined) {
+    if (!RELATION_CATEGORIES.includes(patch.category)) errors.push(`关系大类必须为: ${RELATION_CATEGORIES.join(' / ')}`);
+    else merged.category = patch.category;
+  }
+  const check = validateRelationInput(merged, db);
+  if (errors.length || !check.ok) return { ok: false, errors: [...errors, ...check.errors], value: null };
+  return check;
+}
+
+module.exports = {
+  ENTITY_CATEGORIES,
+  RELATION_CATEGORIES,
+  SOURCES,
+  RDF_TYPE_MAP,
+  RDF_RELATION_TYPE_MAP,
+  validateEntityInput,
+  validateEntityPatch,
+  validateRelationInput,
+  validateRelationPatch,
+};

package/lib/vectors.js

@@ -0,0 +1,68 @@
+'use strict';
+
+// 实体向量库：独立 data/vectors.db，不参与图谱保存点/回溯（向量可随时重建，避免二进制BLOB撑爆git差量）。
+// 遵循与主库相同的 KG_DATA_DIR/KG_DB_PATH 环境变量约定，测试可完全隔离。
+
+const path = require('path');
+const fs = require('fs');
+const { DatabaseSync } = require('node:sqlite');
+
+const { DATA_DIR } = require('./paths');
+const VDB_PATH = process.env.KG_VDB_PATH || path.join(DATA_DIR, 'vectors.db');
+
+let vdb = null;
+
+function open() {
+  if (vdb) return vdb;
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  vdb = new DatabaseSync(VDB_PATH);
+  vdb.exec('PRAGMA journal_mode = DELETE; PRAGMA busy_timeout = 4000;');
+  vdb.exec(`
+    CREATE TABLE IF NOT EXISTS entity_embeddings (
+      entity_id INTEGER PRIMARY KEY,
+      text TEXT NOT NULL,
+      vector BLOB NOT NULL,
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+  `);
+  return vdb;
+}
+
+function close() {
+  try { if (vdb) vdb.close(); } catch (_) { /* 已关闭 */ }
+  vdb = null;
+}
+
+function count() {
+  return open().prepare('SELECT COUNT(*) AS c FROM entity_embeddings').get().c;
+}
+
+function get(entityId) {
+  return open().prepare('SELECT * FROM entity_embeddings WHERE entity_id = ?').get(entityId) || null;
+}
+
+function all() {
+  return open().prepare('SELECT entity_id, text, vector FROM entity_embeddings').all();
+}
+
+function upsert(entityId, text, vec) {
+  const f32 = Float32Array.from(vec);
+  open().prepare(
+    `INSERT INTO entity_embeddings(entity_id, text, vector, updated_at) VALUES (?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+     ON CONFLICT(entity_id) DO UPDATE SET text = excluded.text, vector = excluded.vector, updated_at = excluded.updated_at`
+  ).run(entityId, text, Buffer.from(f32.buffer));
+}
+
+// 实体已删除的向量行清理（主库删除实体后调用，保持两库引用一致）
+function pruneOrphans(liveIds) {
+  const live = new Set(liveIds);
+  const rows = open().prepare('SELECT entity_id FROM entity_embeddings').all();
+  const del = open().prepare('DELETE FROM entity_embeddings WHERE entity_id = ?');
+  let pruned = 0;
+  for (const r of rows) {
+    if (!live.has(r.entity_id)) { del.run(r.entity_id); pruned++; }
+  }
+  return pruned;
+}
+
+module.exports = { open, close, count, get, all, upsert, pruneOrphans, VDB_PATH };

package/lib/viewer.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// 单文件只读图谱查看器生成器：
+// 将图谱数据与 three.js 全部内联进一个 HTML 文件，离线可开、仅查看、涉及编辑。
+
+const fs = require('fs');
+const path = require('path');
+
+const VENDOR_DIR = path.join(__dirname, '..', 'public', 'vendor');
+
+function escapeScript(src) {
+  // 防止内联代码中出现 </script> 提前闭合标签
+  return String(src).replace(/<\/script/gi, '<\\/script');
+}
+
+function buildViewerHtml(graph, opts = {}) {
+  const three = fs.readFileSync(path.join(VENDOR_DIR, 'three.min.js'), 'utf8');
+  const controls = fs.readFileSync(path.join(VENDOR_DIR, 'OrbitControls.js'), 'utf8');
+  const data = JSON.stringify({ entities: graph.entities, relations: graph.relations });
+  const exportedAt = new Date().toLocaleString('zh-CN');
+  const title = opts.title || '知识图谱只读查看器';
+
+  const tpl = fs.readFileSync(path.join(__dirname, 'viewer_template.html'), 'utf8');
+  return tpl
+    .replace('/*__TITLE__*/', escapeScript(title))
+    .replace('/*__EXPORTED_AT__*/', escapeScript(exportedAt))
+    .replace('/*__COUNTS__*/', `${graph.entities.length} 实体 · ${graph.relations.length} 关系`)
+    .replace('"__GRAPH_DATA__"', escapeScript(data))
+    .replace('/*__THREE_JS__*/', () => escapeScript(three))
+    .replace('/*__ORBIT_CONTROLS__*/', () => escapeScript(controls));
+}
+
+module.exports = { buildViewerHtml };

package/lib/viewer_template.html

@@ -0,0 +1,283 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+<title>/*__TITLE__*/</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body { height: 100%; overflow: hidden; }
+  body { font-family: "PingFang SC", "Microsoft YaHei", system-ui, sans-serif; background: #0b0f1a; color: #d7dee9; font-size: 13px; }
+  header {
+    height: 44px; display: flex; align-items: center; gap: 10px; padding: 0 14px;
+    background: #101728; border-bottom: 1px solid #1e2a44; flex-wrap: wrap;
+  }
+  header h1 { font-size: 14px; font-weight: 600; color: #7fd1ff; }
+  header .badge { font-size: 11px; color: #8fa3c0; border: 1px solid #2a3a5c; border-radius: 10px; padding: 2px 9px; }
+  header .ro { color: #ffb74d; border-color: #ffb74d66; }
+  header .spacer { flex: 1; }
+  header .date { font-size: 10.5px; color: #5c6f92; }
+  #wrap { position: relative; height: calc(100% - 44px); background: radial-gradient(ellipse at center, #0d1424 0%, #070a12 100%); }
+  #wrap canvas { display: block; touch-action: none; }
+  .legend {
+    position: absolute; left: 12px; bottom: 12px; background: rgba(13,20,36,.85);
+    border: 1px solid #1e2a44; border-radius: 8px; padding: 9px 12px; font-size: 11px; color: #a9bbd8;
+    pointer-events: none; line-height: 1.9;
+  }
+  .legend b { color: #d7dee9; }
+  .sw { display: inline-block; width: 10px; height: 10px; border-radius: 50%; margin-right: 6px; vertical-align: -1px; }
+  .ln { display: inline-block; width: 22px; height: 0; border-top: 2.5px solid; margin-right: 6px; vertical-align: 3px; }
+  .ln.dash { border-top-style: dashed; }
+  #info-card {
+    position: absolute; top: 12px; right: 12px; width: 250px; max-height: 70%; overflow-y: auto; display: none;
+    background: rgba(13,20,36,.92); border: 1px solid #2a3a5c; border-radius: 8px; padding: 10px 12px;
+  }
+  #info-card h4 { color: #7fd1ff; font-size: 13px; margin-bottom: 6px; }
+  #info-card .kv { font-size: 11px; color: #a9bbd8; margin: 2px 0; word-break: break-all; }
+  #info-card .kv b { color: #d7dee9; }
+  .tag { display: inline-block; font-size: 10px; padding: 1px 7px; border-radius: 9px; border: 1px solid; margin-left: 4px; }
+  @media (max-width: 768px) {
+    #info-card { left: 8px; right: 8px; top: auto; bottom: 10px; width: auto; max-height: 40vh; }
+    header .date { display: none; }
+  }
+</style>
+</head>
+<body>
+<header>
+  <h1>/*__TITLE__*/</h1>
+  <span class="badge">/*__COUNTS__*/</span>
+  <span class="badge ro">只读查看</span>
+  <div class="spacer"></div>
+  <span class="date">导出于 /*__EXPORTED_AT__*/</span>
+</header>
+<div id="wrap">
+  <div class="legend" id="legend"></div>
+  <div id="info-card"></div>
+</div>
+<script>/*__THREE_JS__*/</script>
+<script>/*__ORBIT_CONTROLS__*/</script>
+<script>
+'use strict';
+const GRAPH = "__GRAPH_DATA__";
+
+const ENTITY_STYLE = {
+  '物理实体': { color: 0x4fc3f7, css: '#4fc3f7', shape: '实心球', size: 1 },
+  '抽象实体': { color: 0xba68c8, css: '#ba68c8', shape: '线框球', size: 1 },
+  '数值实体': { color: 0x81c784, css: '#81c784', shape: '立方体', size: 1 },
+  '时间实体': { color: 0xffb74d, css: '#ffb74d', shape: '圆环', size: 1 },
+};
+const RELATION_STYLE = {
+  '空间': { color: 0x4caf50, css: '#4caf50', dashed: false, dashSize: 6, gapSize: 4, opacity: 0.9 },
+  '互动': { color: 0xf44336, css: '#f44336', dashed: true, dashSize: 6, gapSize: 4, opacity: 0.9 },
+  '归属': { color: 0x2196f3, css: '#2196f3', dashed: false, dashSize: 6, gapSize: 4, opacity: 0.9 },
+  '时间': { color: 0xffc107, css: '#ffc107', dashed: true, dashSize: 6, gapSize: 4, opacity: 0.9 },
+  '属性': { color: 0x9c27b0, css: '#9c27b0', dashed: false, dashSize: 6, gapSize: 4, opacity: 0.9 },
+};
+
+const wrap = document.getElementById('wrap');
+const esc = (s) => String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+
+const scene = new THREE.Scene();
+const camera = new THREE.PerspectiveCamera(60, 1, 0.1, 5000);
+camera.position.set(0, 90, 260);
+const renderer = new THREE.WebGLRenderer({ antialias: true });
+renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+renderer.setClearColor(0x000000, 0);
+wrap.appendChild(renderer.domElement);
+const controls = new THREE.OrbitControls(camera, renderer.domElement);
+controls.enableDamping = true;
+controls.dampingFactor = 0.08;
+scene.add(new THREE.AmbientLight(0xffffff, 0.55));
+const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
+dirLight.position.set(120, 200, 100);
+scene.add(dirLight);
+const grid = new THREE.GridHelper(480, 48, 0x1c2a47, 0x141e35);
+grid.position.y = -60;
+scene.add(grid);
+
+const nodeGroup = new THREE.Group(), linkGroup = new THREE.Group(), labelGroup = new THREE.Group();
+scene.add(nodeGroup, linkGroup, labelGroup);
+
+const simNodes = [], simLinks = [];
+const entityMap = new Map();
+
+function makeLabelSprite(text, cssColor, fontSize) {
+  const canvas = document.createElement('canvas');
+  const ctx = canvas.getContext('2d');
+  const font = fontSize + 'px "PingFang SC","Microsoft YaHei",sans-serif';
+  ctx.font = font;
+  const w = Math.ceil(ctx.measureText(text).width) + 20;
+  canvas.width = w; canvas.height = fontSize + 16;
+  ctx.font = font;
+  ctx.fillStyle = 'rgba(9,13,24,0.78)';
+  const r = 8;
+  ctx.beginPath();
+  ctx.moveTo(r,0); ctx.lineTo(w-r,0); ctx.quadraticCurveTo(w,0,w,r);
+  ctx.lineTo(w,canvas.height-r); ctx.quadraticCurveTo(w,canvas.height,w-r,canvas.height);
+  ctx.lineTo(r,canvas.height); ctx.quadraticCurveTo(0,canvas.height,0,canvas.height-r);
+  ctx.lineTo(0,r); ctx.quadraticCurveTo(0,0,r,0);
+  ctx.fill();
+  ctx.strokeStyle = cssColor; ctx.globalAlpha = 0.55; ctx.stroke(); ctx.globalAlpha = 1;
+  ctx.fillStyle = cssColor; ctx.textBaseline = 'middle';
+  ctx.fillText(text, 10, canvas.height/2+1);
+  const tex = new THREE.CanvasTexture(canvas);
+  tex.minFilter = THREE.LinearFilter;
+  const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map: tex, transparent: true, depthTest: false }));
+  const s = 0.16;
+  sprite.scale.set(canvas.width*s, canvas.height*s, 1);
+  return sprite;
+}
+
+function buildNodeMesh(category) {
+  const st = ENTITY_STYLE[category] || { color: 0xaaaaaa, size: 1 };
+  let mesh;
+  if (category === '物理实体') {
+    mesh = new THREE.Mesh(new THREE.SphereGeometry(9, 26, 18), new THREE.MeshStandardMaterial({ color: st.color, roughness: 0.35, metalness: 0.15 }));
+  } else if (category === '抽象实体') {
+    mesh = new THREE.Mesh(new THREE.SphereGeometry(10, 18, 12), new THREE.MeshBasicMaterial({ color: st.color, wireframe: true }));
+  } else if (category === '数值实体') {
+    mesh = new THREE.Mesh(new THREE.BoxGeometry(13, 13, 13), new THREE.MeshStandardMaterial({ color: st.color, roughness: 0.4, metalness: 0.1 }));
+  } else {
+    mesh = new THREE.Mesh(new THREE.TorusGeometry(9.5, 3.4, 16, 42), new THREE.MeshStandardMaterial({ color: st.color, roughness: 0.35, metalness: 0.15 }));
+  }
+  mesh.scale.setScalar(st.size || 1);
+  return mesh;
+}
+
+(function build() {
+  const N = GRAPH.entities.length;
+  GRAPH.entities.forEach((e, i) => {
+    const mesh = buildNodeMesh(e.category);
+    const k = i + 0.5;
+    const phi = Math.acos(1 - 2*k/Math.max(N,1));
+    const theta = Math.PI * (1 + Math.sqrt(5)) * k;
+    const R = 40 + 12*Math.sqrt(N);
+    mesh.position.set(R*Math.sin(phi)*Math.cos(theta), (R*0.6)*Math.cos(phi), R*Math.sin(phi)*Math.sin(theta));
+    mesh.userData.entityId = e.id;
+    nodeGroup.add(mesh);
+    let attrs = {};
+    try { attrs = JSON.parse(e.attributes || '{}'); } catch (_) {}
+    const label = makeLabelSprite(e.name, ENTITY_STYLE[e.category] ? ENTITY_STYLE[e.category].css : '#ccc', 34);
+    labelGroup.add(label);
+    entityMap.set(e.id, { entity: e, mesh, label, attrs });
+    simNodes.push({ id: e.id, pos: mesh.position.clone(), vel: new THREE.Vector3(), mesh, label, sizeScale: (ENTITY_STYLE[e.category]||{}).size || 1 });
+  });
+  GRAPH.relations.forEach((r) => {
+    const a = simNodes.find(n => n.id === r.source_id), b = simNodes.find(n => n.id === r.target_id);
+    if (!a || !b) return;
+    const st = RELATION_STYLE[r.category] || { color: 0x999999, dashed: false };
+    const geo = new THREE.BufferGeometry().setFromPoints([a.pos, b.pos]);
+    const mat = st.dashed
+      ? new THREE.LineDashedMaterial({ color: st.color, dashSize: st.dashSize||6, gapSize: st.gapSize||4, transparent: true, opacity: st.opacity===undefined?0.9:st.opacity })
+      : new THREE.LineBasicMaterial({ color: st.color, transparent: true, opacity: st.opacity===undefined?0.9:st.opacity });
+    const line = new THREE.Line(geo, mat);
+    line.userData.relationId = r.id;
+    linkGroup.add(line);
+    const lbl = makeLabelSprite(r.name, st.css, 24);
+    lbl.position.copy(a.pos).add(b.pos).multiplyScalar(0.5);
+    labelGroup.add(lbl);
+    simLinks.push({ id: r.id, a, b, line, label: lbl, dashed: st.dashed });
+  });
+})();
+
+document.getElementById('legend').innerHTML =
+  '<b>实体样式</b><br>' + Object.keys(ENTITY_STYLE).map(c => '<span class="sw" style="background:'+ENTITY_STYLE[c].css+'"></span>'+c+' · '+ENTITY_STYLE[c].shape).join('<br>') +
+  '<br><b>关系线型</b><br>' + Object.keys(RELATION_STYLE).map(c => '<span class="ln '+(RELATION_STYLE[c].dashed?'dash':'')+'" style="border-color:'+RELATION_STYLE[c].css+'"></span>'+c+'关系').join('<br>');
+
+let budget = 480;
+function simStep() {
+  const REP = 2600, SPRING = 0.01, REST = 78, CENTER = 0.006, DAMP = 0.86;
+  for (let i = 0; i < simNodes.length; i++) for (let j = i+1; j < simNodes.length; j++) {
+    const A = simNodes[i], B = simNodes[j];
+    const dx = A.pos.x-B.pos.x, dy = A.pos.y-B.pos.y, dz = A.pos.z-B.pos.z;
+    let d2 = dx*dx+dy*dy+dz*dz; if (d2 < 4) d2 = 4;
+    const d = Math.sqrt(d2), f = REP/d2;
+    A.vel.x += dx/d*f; A.vel.y += dy/d*f; A.vel.z += dz/d*f;
+    B.vel.x -= dx/d*f; B.vel.y -= dy/d*f; B.vel.z -= dz/d*f;
+  }
+  for (const l of simLinks) {
+    const dx = l.b.pos.x-l.a.pos.x, dy = l.b.pos.y-l.a.pos.y, dz = l.b.pos.z-l.a.pos.z;
+    const d = Math.max(Math.sqrt(dx*dx+dy*dy+dz*dz), 0.01);
+    const f = SPRING*(d-REST);
+    l.a.vel.x += dx/d*f; l.a.vel.y += dy/d*f; l.a.vel.z += dz/d*f;
+    l.b.vel.x -= dx/d*f; l.b.vel.y -= dy/d*f; l.b.vel.z -= dz/d*f;
+  }
+  for (const nd of simNodes) { nd.vel.multiplyScalar(DAMP); nd.vel.addScaledVector(nd.pos, -CENTER); nd.pos.add(nd.vel); }
+  for (const l of simLinks) {
+    const pa = l.line.geometry.attributes.position;
+    pa.setXYZ(0, l.a.pos.x, l.a.pos.y, l.a.pos.z);
+    pa.setXYZ(1, l.b.pos.x, l.b.pos.y, l.b.pos.z);
+    pa.needsUpdate = true;
+    if (l.dashed) l.line.computeLineDistances();
+    l.label.position.copy(l.a.pos).add(l.b.pos).multiplyScalar(0.5);
+  }
+  for (const nd of simNodes) { nd.mesh.position.copy(nd.pos); nd.label.position.set(nd.pos.x, nd.pos.y+18, nd.pos.z); }
+}
+
+const selected = { obj: null };
+function animate() {
+  requestAnimationFrame(animate);
+  if (budget > 0) { simStep(); budget--; }
+  for (const nd of simNodes) nd.mesh.scale.setScalar(nd.sizeScale || 1);
+  if (selected.obj && selected.obj.type === 'entity') {
+    const nd = simNodes.find(n => n.id === selected.obj.id);
+    if (nd) nd.mesh.scale.setScalar((nd.sizeScale||1) * (1.25 + 0.08*Math.sin(Date.now()/300)));
+  }
+  controls.update();
+  renderer.render(scene, camera);
+}
+animate();
+
+const raycaster = new THREE.Raycaster();
+raycaster.params.Line = { threshold: 3 };
+let downPos = null;
+renderer.domElement.addEventListener('pointerdown', e => { downPos = {x:e.clientX, y:e.clientY}; });
+renderer.domElement.addEventListener('pointerup', e => {
+  if (!downPos) return;
+  const moved = Math.hypot(e.clientX-downPos.x, e.clientY-downPos.y);
+  downPos = null;
+  if (moved > (e.pointerType === 'touch' ? 12 : 5)) return;
+  const rect = renderer.domElement.getBoundingClientRect();
+  const mouse = new THREE.Vector2(((e.clientX-rect.left)/rect.width)*2-1, -((e.clientY-rect.top)/rect.height)*2+1);
+  raycaster.setFromCamera(mouse, camera);
+  const hits = raycaster.intersectObjects(nodeGroup.children, false);
+  if (hits.length) { selected.obj = { type: 'entity', id: hits[0].object.userData.entityId }; renderCard(); return; }
+  const lh = raycaster.intersectObjects(linkGroup.children, false);
+  if (lh.length) { selected.obj = { type: 'relation', id: lh[0].object.userData.relationId }; renderCard(); return; }
+  selected.obj = null; renderCard();
+});
+
+function renderCard() {
+  const card = document.getElementById('info-card');
+  if (!selected.obj) { card.style.display = 'none'; return; }
+  if (selected.obj.type === 'entity') {
+    const m = entityMap.get(selected.obj.id);
+    if (!m) { card.style.display = 'none'; return; }
+    const e = m.entity;
+    let attrHtml = '';
+    for (const [k, v] of Object.entries(m.attrs)) attrHtml += '<div class="kv"><b>'+esc(k)+'</b>: '+esc(String(v))+'</div>';
+    const relCount = GRAPH.relations.filter(r => r.source_id === e.id || r.target_id === e.id).length;
+    card.innerHTML = '<h4>'+esc(e.name)+' <span class="tag" style="color:'+ENTITY_STYLE[e.category].css+';border-color:'+ENTITY_STYLE[e.category].css+'55">'+e.category+' · '+ENTITY_STYLE[e.category].shape+'</span></h4>' +
+      '<div class="kv">id: '+e.id+'　来源: '+esc(e.source)+'</div><div class="kv">关联关系: '+relCount+' 条</div>' + (attrHtml || '<div class="kv">（无属性）</div>');
+    card.style.display = 'block';
+  } else {
+    const r = GRAPH.relations.find(x => x.id === selected.obj.id);
+    if (!r) { card.style.display = 'none'; return; }
+    const s = entityMap.get(r.source_id), t = entityMap.get(r.target_id);
+    card.innerHTML = '<h4>'+esc(r.name)+' <span class="tag" style="color:'+RELATION_STYLE[r.category].css+';border-color:'+RELATION_STYLE[r.category].css+'55">'+r.category+'关系</span></h4>' +
+      '<div class="kv"><b>'+(s ? esc(s.entity.name) : '?')+'</b> --&gt; <b>'+(t ? esc(t.entity.name) : '?')+'</b></div><div class="kv">id: '+r.id+'　来源: '+esc(r.source)+'</div>';
+    card.style.display = 'block';
+  }
+}
+
+function resize() {
+  const w = wrap.clientWidth, h = wrap.clientHeight;
+  camera.aspect = w/h;
+  camera.updateProjectionMatrix();
+  renderer.setSize(w, h);
+}
+window.addEventListener('resize', resize);
+resize();
+</script>
+</body>
+</html>