local-knowledge-graph 1.10.4 → 1.12.0

package/lib/triples_io.js

@@ -0,0 +1,230 @@
+'use strict';
+
+// 三元组批量导入/导出（CSV / JSON）：
+// - JSON 格式：{ entities:[{name,category,attributes}], relations:[{source,target,name,category,...}] }
+//   导出时附带 id 与 confidence/source_ref；导入按 name 引用（纯数字优先按 id 解析）。
+// - CSV 格式：中文表头 kind,name,category,source,target,relation,relation_category,confidence,source_ref,attributes
+//   实体行：kind=实体；关系行：kind=关系。attributes 列为 JSON 字符串。
+// - 导入语义：同名实体自动复用（不存在才创建）；关系去重校验与手工添加完全一致；
+//   单行失败不中断整批，错误逐条收集返回。
+
+const V = require('./validator');
+
+const CSV_HEADERS = ['kind', 'name', 'category', 'source', 'target', 'relation', 'relation_category', 'confidence', 'source_ref', 'attributes'];
+const CSV_HEADERS_CN = '种类,名称,大类,起点,终点,关系,关系大类,置信度,来源引用,属性';
+
+// ---- CSV 序列化（RFC4180）----
+function csvCell(v) {
+  const s = v === null || v === undefined ? '' : String(v);
+  return /[",\r\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
+}
+
+function parseAttributesCell(raw, errors, where) {
+  if (raw === undefined || raw === null || String(raw).trim() === '') return {};
+  try {
+    const v = JSON.parse(raw);
+    if (v && typeof v === 'object' && !Array.isArray(v)) return v;
+    errors.push(`${where}: 属性列必须是JSON对象`);
+  } catch (_) {
+    errors.push(`${where}: 属性列不是合法JSON`);
+  }
+  return {};
+}
+
+// 属性规范化：db 行的 attributes 可能是 JSON 字符串（getGraph 原样）或对象，统一为对象再序列化
+function normAttrs(a) {
+  if (a && typeof a === 'object') return a;
+  return safeParse(a);
+}
+
+function entitiesToCsvRows(entities) {
+  return entities.map((e) => ([
+    '实体', e.name, e.category, '', '', '', '', '', '',
+    JSON.stringify(normAttrs(e.attributes)),
+  ]));
+}
+
+function relationsToCsvRows(relations, nameOf) {
+  return relations.map((r) => ([
+    '关系', '', r.category || '', nameOf(r.source_id), nameOf(r.target_id), r.name, r.category, r.confidence || '确证', r.source_ref || '',
+    JSON.stringify(normAttrs(r.attributes)),
+  ]));
+}
+
+function exportCsv(graph) {
+  const nameOf = (id) => {
+    const e = graph.entities.find((x) => x.id === id);
+    return e ? e.name : '#' + id;
+  };
+  const rows = [CSV_HEADERS_CN];
+  for (const r of entitiesToCsvRows(graph.entities)) rows.push(r.map(csvCell));
+  for (const r of relationsToCsvRows(graph.relations, nameOf)) rows.push(r.map(csvCell));
+  return rows.join('\r\n') + '\r\n';
+}
+
+function exportJson(graph) {
+  return JSON.stringify({
+    format: 'knowledge-graph-triples',
+    version: 1,
+    exported_at: new Date().toISOString(),
+    entities: graph.entities.map((e) => ({ id: e.id, name: e.name, category: e.category, attributes: safeParse(e.attributes) })),
+    relations: graph.relations.map((r) => ({
+      source_id: r.source_id,
+      target_id: r.target_id,
+      source: (graph.entities.find((x) => x.id === r.source_id) || {}).name || '#' + r.source_id,
+      target: (graph.entities.find((x) => x.id === r.target_id) || {}).name || '#' + r.target_id,
+      name: r.name,
+      category: r.category,
+      confidence: r.confidence || '确证',
+      source_ref: r.source_ref || '',
+      attributes: safeParse(r.attributes),
+    })),
+  }, null, 2) + '\n';
+}
+
+function safeParse(s) {
+  try { return JSON.parse(s || '{}') || {}; } catch (_) { return {}; }
+}
+
+// ---- CSV 解析（支持引号内逗号/换行/转义引号）----
+function parseCsvText(text) {
+  const rows = [];
+  let row = [];
+  let cell = '';
+  let inQuotes = false;
+  const src = String(text).replace(/^\uFEFF/, '');
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (src[i + 1] === '"') { cell += '"'; i++; }
+        else inQuotes = false;
+      } else cell += c;
+    } else if (c === '"') {
+      inQuotes = true;
+    } else if (c === ',') {
+      row.push(cell); cell = '';
+    } else if (c === '\r') {
+      /* 跳过 */
+    } else if (c === '\n') {
+      row.push(cell); rows.push(row); row = []; cell = '';
+    } else cell += c;
+  }
+  if (cell !== '' || row.length) { row.push(cell); rows.push(row); }
+  return rows.filter((r) => r.some((c) => String(c).trim() !== ''));
+}
+
+// 统一解析入口：返回 {entities:[{name,category,attributes}], relations:[{source,target,name,category,confidence,source_ref,attributes}], warnings[]}
+function parseImport(content, format) {
+  const errors = [];
+  const warnings = [];
+  const entities = [];
+  const relations = [];
+  const fmt = String(format || '').toLowerCase();
+
+  if (fmt === 'json') {
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (e) {
+      return { ok: false, error: `JSON 解析失败: ${e.message}` };
+    }
+    const entList = Array.isArray(data) ? data : data.entities;
+    const relList = Array.isArray(data) ? [] : (data.relations || []);
+    if (!Array.isArray(entList)) return { ok: false, error: 'JSON 需包含 entities 数组（或顶层数组）' };
+    for (const e of entList) {
+      if (!e || typeof e !== 'object') continue;
+      entities.push({
+        name: e.name, category: e.category || '抽象实体',
+        attributes: e.attributes && typeof e.attributes === 'object' ? e.attributes : {},
+        aliases: Array.isArray(e.aliases) ? e.aliases.map(String) : [],
+        fromId: Number.isInteger(e.id) ? e.id : null,
+      });
+    }
+    for (const r of relList) {
+      if (!r || typeof r !== 'object') continue;
+      relations.push({
+        source: r.source !== undefined ? r.source : r.source_id,
+        target: r.target !== undefined ? r.target : r.target_id,
+        name: r.name, category: r.category || '互动',
+        confidence: r.confidence, source_ref: r.source_ref || '',
+        attributes: r.attributes && typeof r.attributes === 'object' ? r.attributes : {},
+      });
+    }
+  } else if (fmt === 'csv') {
+    const rows = parseCsvText(content);
+    if (!rows.length) return { ok: false, error: 'CSV 为空' };
+    let idx = kindIdx(headers(rows[0]));
+    // 首行是合法表头则从第2行起读数据；否则整份内容按默认列序解析（首行也是数据）
+    const start = idx ? 1 : 0;
+    if (!idx) idx = defaultIdx();
+    for (let i = start; i < rows.length; i++) {
+      const c = rows[i];
+      const get = (n) => (idx[n] < c.length ? String(c[idx[n]]).trim() : '');
+      const where = `第${i + 1}行`;
+      const kind = get('kind');
+      if (kind === '实体' || kind === 'entity') {
+        entities.push({ name: get('name'), category: get('category') || '抽象实体', attributes: parseAttributesCell(get('attributes'), errors, where), fromId: null });
+      } else if (kind === '关系' || kind === 'relation') {
+        relations.push({
+          source: get('source') || get('name'),
+          target: get('target'),
+          name: get('relation'),
+          category: get('relation_category') || get('category') || '互动',
+          confidence: get('confidence') || undefined,
+          source_ref: get('source_ref'),
+          attributes: parseAttributesCell(get('attributes'), errors, where),
+        });
+      } else if (kind) {
+        warnings.push(`${where}: 未知种类"${kind}"，已跳过`);
+      }
+    }
+  } else {
+    return { ok: false, error: '格式必须为 csv 或 json' };
+  }
+
+  // 基础合法性过滤（深度校验在入库时进行，逐行收集错误）
+  const validEntities = [];
+  for (const e of entities) {
+    if (!e.name) { errors.push(`实体缺少名称: ${JSON.stringify(e.name)}`); continue; }
+    if (!V.ENTITY_CATEGORIES.includes(e.category)) {
+      warnings.push(`实体"${e.name}"大类"${e.category}"非法，已按"抽象实体"导入`);
+      e.category = '抽象实体';
+    }
+    validEntities.push(e);
+  }
+  const validRelations = [];
+  for (const r of relations) {
+    if (!r.source || !r.target || !r.name) { errors.push(`关系缺少起点/终点/名称: ${JSON.stringify(r)}`); continue; }
+    if (!V.RELATION_CATEGORIES.includes(r.category)) {
+      warnings.push(`关系"${r.name}"大类"${r.category}"非法，已按"互动"导入`);
+      r.category = '互动';
+    }
+    validRelations.push(r);
+  }
+  return { ok: true, entities: validEntities, relations: validRelations, errors, warnings };
+}
+
+function headers(row) { return row.map((c) => String(c).trim()); }
+function kindIdx(cols) {
+  const map = {};
+  cols.forEach((c, i) => { map[c] = i; });
+  if (map['种类'] === undefined && map['kind'] === undefined) return null;
+  return {
+    kind: map['种类'] !== undefined ? map['种类'] : map['kind'],
+    name: map['名称'] !== undefined ? map['名称'] : (map['name'] !== undefined ? map['name'] : 1),
+    category: map['大类'] !== undefined ? map['大类'] : (map['category'] !== undefined ? map['category'] : 2),
+    source: map['起点'] !== undefined ? map['起点'] : (map['source'] !== undefined ? map['source'] : 3),
+    target: map['终点'] !== undefined ? map['终点'] : (map['target'] !== undefined ? map['target'] : 4),
+    relation: map['关系'] !== undefined ? map['关系'] : (map['relation'] !== undefined ? map['relation'] : 5),
+    relation_category: map['关系大类'] !== undefined ? map['关系大类'] : 6,
+    confidence: map['置信度'] !== undefined ? map['置信度'] : (map['confidence'] !== undefined ? map['confidence'] : 7),
+    source_ref: map['来源引用'] !== undefined ? map['来源引用'] : (map['source_ref'] !== undefined ? map['source_ref'] : 8),
+    attributes: map['属性'] !== undefined ? map['属性'] : (map['attributes'] !== undefined ? map['attributes'] : 9),
+  };
+}
+function defaultIdx() {
+  return { kind: 0, name: 1, category: 2, source: 3, target: 4, relation: 5, relation_category: 6, confidence: 7, source_ref: 8, attributes: 9 };
+}
+
+module.exports = { exportCsv, exportJson, parseImport, CSV_HEADERS_CN };

package/lib/validator.js

@@ -24,6 +24,23 @@ function isPrimitive(v) {
   return v === null || ['string', 'number', 'boolean'].includes(typeof v);
 }
 
+// 扁平属性校验（实体与关系共用）：键为非空字符串，值为原始类型，禁止嵌套
+function checkFlatAttributes(attributes, label, errors) {
+  if (attributes === undefined) return {};
+  if (attributes === null || typeof attributes !== 'object' || Array.isArray(attributes)) {
+    errors.push(`${label}(attributes)必须为JSON对象`);
+    return null;
+  }
+  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(`${label}键数量不得超过100`);
+  return attributes;
+}
+
 // 实体校验：三元组结构 (subject=实体, predicate=属性键, object=原子值)
 // 属性必须是扁平JSON对象，键为非空字符串，值为原始类型；禁止嵌套与冗余字段
 function validateEntityInput(input) {
@@ -44,13 +61,7 @@ function validateEntityInput(input) {
     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');
+    checkFlatAttributes(attributes, '属性', errors);
   }
 
   if (errors.length) return { ok: false, errors, value: null };
@@ -116,8 +127,18 @@ function validateRelationInput(input, db) {
   if (typeof source_ref !== 'string') errors.push('来源引用(source_ref)必须为字符串');
   else if (source_ref.length > 500) errors.push('来源引用长度不得超过500字符');
 
+  const attributes = checkFlatAttributes(input.attributes === undefined ? {} : input.attributes, '关系属性', errors);
+
   if (errors.length) return { ok: false, errors, value: null };
-  return { ok: true, errors: [], value: { source_id: sid, target_id: tid, name: name.trim(), category, confidence, source_ref } };
+  return { ok: true, errors: [], value: { source_id: sid, target_id: tid, name: name.trim(), category, confidence, source_ref, attributes } };
+}
+
+// 重复三元组检测：同起点+终点+关系名视为重复；excludeId 供更新时排除自身
+function findDuplicateRelation(value, db, excludeId) {
+  const row = db.prepare(
+    'SELECT id, source_id, target_id, name FROM relations WHERE source_id = ? AND target_id = ? AND name = ? AND id != ? LIMIT 1'
+  ).get(value.source_id, value.target_id, value.name, excludeId || 0);
+  return row || null;
 }
 
 function validateRelationPatch(patch, existing, db) {
@@ -129,6 +150,7 @@ function validateRelationPatch(patch, existing, db) {
     category: existing.category,
     confidence: existing.confidence || '确证',
     source_ref: existing.source_ref || '',
+    attributes: JSON.parse(existing.attributes || '{}'),
   };
   if (patch.source_id !== undefined) merged.source_id = patch.source_id;
   if (patch.target_id !== undefined) merged.target_id = patch.target_id;
@@ -151,11 +173,52 @@ function validateRelationPatch(patch, existing, db) {
     else if (patch.source_ref.length > 500) errors.push('来源引用长度不得超过500字符');
     else merged.source_ref = patch.source_ref;
   }
+  if (patch.attributes !== undefined) {
+    checkFlatAttributes(patch.attributes, '关系属性', errors);
+    if (!errors.length) merged.attributes = patch.attributes;
+  }
   const check = validateRelationInput(merged, db);
   if (errors.length || !check.ok) return { ok: false, errors: [...errors, ...check.errors], value: null };
   return check;
 }
 
+// ---- 修复回执（Archify 式）：把本包定义的校验错误文案映射为稳定规则码与允许的修复动作 ----
+// 错误文案全部由本包抛出（validator/db），正则匹配可靠；新增校验规则时同步在此登记
+const RECEIPT_RULES = [
+  { re: /实体大类必须为/, code: 'E_ENTITY_CATEGORY', fixes: ['category 改为以下之一: 物理实体 / 抽象实体 / 数值实体 / 时间实体'] },
+  { re: /关系大类必须为/, code: 'E_RELATION_CATEGORY', fixes: ['category 改为以下之一: 空间 / 互动 / 归属 / 时间 / 属性'] },
+  { re: /置信度必须为/, code: 'E_CONFIDENCE', fixes: ['confidence 改为以下之一: 确证 / 推测 / 存疑；省略该字段时默认确证'] },
+  { re: /禁止嵌套对象或数组/, code: 'E_ATTR_NESTED', fixes: ['attributes 的值只能是字符串/数值/布尔/空值；把嵌套结构拆成多个扁平键，或改为一段说明文本'] },
+  { re: /必须为JSON对象/, code: 'E_ATTR_TYPE', fixes: ['attributes 必须是JSON对象（如 {"键":"值"}）；无属性时省略该字段'] },
+  { re: /起点实体id=\d+ 不存在/, code: 'E_SOURCE_MISSING', fixes: ['先用 {"op":"add_entity",...,"ref":"X"} 创建该实体，再用 "source_ref":"X" 引用；或改用图谱中已存在实体的数字id'] },
+  { re: /终点实体id=\d+ 不存在/, code: 'E_TARGET_MISSING', fixes: ['先用 {"op":"add_entity",...,"ref":"X"} 创建该实体，再用 "target_ref":"X" 引用；或改用图谱中已存在实体的数字id'] },
+  { re: /起点与终点不能为同一实体/, code: 'E_SELF_LOOP', fixes: ['source 与 target 不能相同；确需表达自反关系时改为实体属性或拆分为两个实体'] },
+  { re: /重复三元组|已存在同名/, code: 'E_DUPLICATE_RELATION', fixes: ['同起点+终点+关系名的组合只能存在一条：删除本条 add_relation，需要修改时改用 update_relation，或换一个关系名'] },
+  { re: /(实体|关系)名称必须为非空字符串/, code: 'E_NAME_EMPTY', fixes: ['name 必须为非空字符串'] },
+  { re: /长度不得超过200字符/, code: 'E_NAME_TOO_LONG', fixes: ['name 截断到 200 字符以内'] },
+  { re: /未知操作类型/, code: 'E_UNKNOWN_OP', fixes: ['op 仅支持: add_entity / add_relation / update_entity / delete_entity / update_relation / delete_relation'] },
+  { re: /ref必须为非空字符串/, code: 'E_REF_INVALID', fixes: ['ref 必须为非空字符串占位符，如 "ref":"A"'] },
+  { re: /引用的实体不存在/, code: 'E_REF_UNRESOLVED', fixes: ['ref 未在本次操作的 add_entity 中定义：先输出对应 add_entity（带相同 ref），或改用数字id'] },
+];
+
+// 构造单条修复回执：index 从1开始对应操作序号；evidence 为出错操作原文（截断）
+function buildReceipt(index, op, err) {
+  const msg = String((err && err.message) || err);
+  const rule = RECEIPT_RULES.find((r) => r.re.test(msg));
+  let evidence = '';
+  try { evidence = JSON.stringify(op).slice(0, 300); } catch (_) { evidence = String(op).slice(0, 300); }
+  const subjectSrc = op && (op.name !== undefined ? op.name : (op.ref !== undefined ? op.ref : op.id));
+  return {
+    index,
+    op_kind: (op && op.op) || '未知',
+    code: rule ? rule.code : 'E_UNKNOWN',
+    subject: subjectSrc !== undefined ? String(subjectSrc) : '',
+    message: msg,
+    evidence,
+    supportedFixes: rule ? rule.fixes : ['核对该操作是否符合 RDF 规范（大类/扁平属性/实体引用）后重试'],
+  };
+}
+
 module.exports = {
   ENTITY_CATEGORIES,
   RELATION_CATEGORIES,
@@ -167,4 +230,7 @@ module.exports = {
   validateEntityPatch,
   validateRelationInput,
   validateRelationPatch,
+  findDuplicateRelation,
+  RECEIPT_RULES,
+  buildReceipt,
 };

package/lib/viewer_template.html

@@ -166,18 +166,38 @@ function buildNodeMesh(category) {
     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 conf = r.confidence || '确证';
+    const op0 = st.opacity===undefined?0.9:st.opacity;
+    const op = conf === '存疑' ? Math.min(op0, 0.35) : op0;
+    const dashed = st.dashed || conf === '推测';
     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 mat = dashed
+      ? new THREE.LineDashedMaterial({ color: st.color, dashSize: st.dashSize||6, gapSize: st.gapSize||4, transparent: true, opacity: op })
+      : new THREE.LineBasicMaterial({ color: st.color, transparent: true, opacity: op });
     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 });
+    simLinks.push({ id: r.id, a, b, line, label: lbl, dashed });
   });
+  // 平行边标签错开：同节点对多条关系时标签沿垂直方向交替偏移，避免文字重叠
+  (() => {
+    const pairCount = new Map(), pairSeen = new Map();
+    for (const r of GRAPH.relations) {
+      const k = r.source_id < r.target_id ? r.source_id+'|'+r.target_id : r.target_id+'|'+r.source_id;
+      pairCount.set(k, (pairCount.get(k)||0)+1);
+    }
+    for (const l of simLinks) {
+      const r = GRAPH.relations.find(x => x.id === l.id);
+      if (!r) continue;
+      const k = r.source_id < r.target_id ? r.source_id+'|'+r.target_id : r.target_id+'|'+r.source_id;
+      const n = pairCount.get(k)||1, i = pairSeen.get(k)||0;
+      pairSeen.set(k, i+1);
+      l.arcIdx = n > 1 ? i - (n-1)/2 : 0;
+    }
+  })();
 })();
 
 document.getElementById('legend').innerHTML =
@@ -209,7 +229,19 @@ function simStep() {
     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);
+    // 标签置于边中点；平行边按序号沿垂直方向错开（n = dir × up）
+    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 len = Math.max(Math.sqrt(dx*dx+dy*dy+dz*dz), 0.01);
+    let nx, ny, nz;
+    if (Math.abs(dy) / len > 0.92) { nx = 0; ny = dz; nz = -dy; }
+    else { nx = -dz; ny = 0; nz = dx; }
+    const nl = Math.max(Math.sqrt(nx*nx+ny*ny+nz*nz), 0.01);
+    const off = (l.arcIdx || 0) * len * 0.16;
+    l.label.position.set(
+      (l.a.pos.x+l.b.pos.x)/2 + nx/nl*off,
+      (l.a.pos.y+l.b.pos.y)/2 + ny/nl*off + (l.arcIdx ? 0 : 18),
+      (l.a.pos.z+l.b.pos.z)/2 + nz/nl*off
+    );
   }
   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); }
 }
@@ -264,8 +296,14 @@ function renderCard() {
     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);
+    let attrs = {};
+    try { attrs = JSON.parse(r.attributes || '{}'); } catch (_) {}
+    let attrHtml = '';
+    for (const [k, v] of Object.entries(attrs)) attrHtml += '<div class="kv"><b>'+esc(k)+'</b>: '+esc(String(v))+'</div>';
     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>';
+      '<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.confidence||'确证')+(r.source_ref ? '　来源: '+esc(r.source_ref) : '')+'</div>' +
+      (attrHtml || '');
     card.style.display = 'block';
   }
 }
@@ -278,6 +316,29 @@ function resize() {
 }
 window.addEventListener('resize', resize);
 resize();
+
+// 深链：#entity=<id> 打开时自动选中并飞向该实体（与主应用链接格式一致）
+(function applyHash() {
+  const m = location.hash.match(/^#entity=(\d+)$/);
+  if (!m) return;
+  const id = Number(m[1]);
+  if (!entityMap.has(id)) return;
+  selected.obj = { type: 'entity', id };
+  renderCard();
+  const nd = simNodes.find(n => n.id === id);
+  if (nd) {
+    const dir = camera.position.clone().sub(controls.target).normalize();
+    const from = camera.position.clone(), fromT = controls.target.clone(), to = nd.pos.clone().add(dir.multiplyScalar(110));
+    let t = 0;
+    (function fly() {
+      t = Math.min(1, t + 0.04);
+      const k = t < 0.5 ? 2*t*t : 1 - Math.pow(-2*t + 2, 2)/2;
+      camera.position.lerpVectors(from, to, k);
+      controls.target.lerpVectors(fromT, nd.pos, k);
+      if (t < 1) requestAnimationFrame(fly);
+    })();
+  }
+})();
 </script>
 </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-knowledge-graph",
-  "version": "1.10.4",
+  "version": "1.12.0",
   "description": "本地知识图谱整合器：3D可视化 + AI对话建图 + 智能检索 + Git回溯 + RDF合规，全流程本地运行",
   "main": "server.js",
   "bin": {