dsh-memory-engine 0.5.6 → 0.6.0

package/README.md

@@ -4,6 +4,22 @@ DSH 插件的本地记忆引擎，带神经网络可视化。它让 agent 保存
 
 当前版本：0.5.2。Node ≥22，零新增依赖；DSH 宿主提供 `@deepseek-ai/dsh-tools@0.2.1-rc.3`。本机安装已启用，无需重复安装。
 
+## 支持的 DSH 版本
+
+实测可用范围：**@deepseek-ai/dsh-tools 0.1.0-rc.8 ~ 0.2.2-alpha.2**（本插件只用其中的 defineTool，这几个版本签名一致）。
+
+插件对宿主做了三处兜底，所以版本不合适时也不会「装上了却什么都没有」：
+
+| 宿主情况 | 插件行为 |
+| --- | --- |
+| 有 ctx.effect | 正常注册，随插件卸载一起清理 |
+| 没有 ctx.effect | 直接注册工具，功能不减少，日志留一条提示 |
+| 解析不到 @deepseek-ai/dsh-tools | 用内置直通 defineTool，工具照常可用 |
+| 没有 header.actions 插槽 | 图谱按钮退到 iews.actions（在「更多视图」菜单里） |
+| 完全没有 slots 服务 | 跳过按钮，记忆工具不受影响 |
+
+peerDependencies 已放宽为 >=0.1.0-rc.8 <0.3.0 并标为 optional——宿主自带这份 SDK，不该因为版本号不匹配而装不上。
+
 ## 界面
 
 安装并启用插件后，完全退出 DSH 再打开。进入任意会话，头部第一行会出现 **🧠 记忆图谱** 按钮。

package/lib/client.js

@@ -9,6 +9,9 @@ window.__ModuleLoader__.load({
     // views.actions 是「更多视图」下拉菜单的行（Chat/Trajectory 旁边的 ⋯），
     // 注册进去只是菜单里多一行，看不见；header.actions 才是头部正常按钮区。
     var SLOT_NAME = "conversation.session.header.actions";
+    // 不同 DSH 版本暴露的插槽名不一样：新版本用 header.actions，
+    // 老版本没有这个槽时退回 views.actions（会出现在「更多视图」菜单里，虽然不显眼但能用）。
+    var SLOT_FALLBACKS = ["conversation.session.header.actions", "conversation.session.header.views.actions"];
     var VIEW_URL = "http://127.0.0.1:18886/index.html";
 
     function MemoryButton() {
@@ -56,16 +59,35 @@ window.__ModuleLoader__.load({
       return React.createElement(React.Fragment, null, button, ReactDOM.createPortal(overlay, document.body));
     }
 
-    function apply(ctx) {
-      try {
-        ctx.slots.inject(SLOT_NAME, function () {
-          return ctx.slots.register({
-            name: SLOT_NAME,
+    function registerOn(slots, name) {
+      var disposable = null;
+      slots.inject(name, function () {
+        try {
+          disposable = slots.register({
+            name: name,
             id: "memory-engine-map",
             order: 50,
             label: function () { return "记忆图谱"; },
           }, MemoryButton);
-        });
+        } catch (error) {
+          try { console.error("[dsh-memory-engine] 注册到 " + name + " 失败：", error); } catch (ignored) {}
+        }
+        return disposable;
+      });
+      return disposable;
+    }
+
+    function apply(ctx) {
+      try {
+        if (!ctx || !ctx.slots || typeof ctx.slots.inject !== "function") {
+          try { console.warn("[dsh-memory-engine] 宿主没有 slots 服务，跳过图谱按钮（记忆工具不受影响）"); } catch (ignored) {}
+          return;
+        }
+        // 只注册第一个能用的插槽：优先 header.actions，老宿主没有就退到 views.actions
+        var target = ctx.slots && typeof ctx.slots.has === "function" && !ctx.slots.has(SLOT_FALLBACKS[0])
+          ? SLOT_FALLBACKS[1]
+          : SLOT_NAME;
+        registerOn(ctx.slots, target);
       } catch (error) {
         try { console.error("[dsh-memory-engine] 插槽注册失败：", error); } catch (ignored) {}
       }

package/lib/index.js

@@ -154,15 +154,33 @@ export function createTools(defineTool, store = new MemoryStore(), { map = gener
   ];
 }
 
+// 宿主 SDK 的 defineTool 在不同 DSH 版本间签名一致（实测 0.1.0-rc.8 ~ 0.2.2-alpha.2 都是
+// defineTool(options)），但**包不一定能解析到**——比如插件被装在宿主 node_modules 之外。
+// 解析失败时退回一个直通实现：工具照常注册，只是少了宿主的返回值包装。
+async function resolveDefineTool(warning) {
+  try {
+    const sdk = await import('@deepseek-ai/dsh-tools');
+    if (typeof sdk.defineTool === 'function') {
+      const version = sdk.version ?? '';
+      if (version) warning(`宿主 dsh-tools 版本 ${version}`);
+      return sdk.defineTool;
+    }
+    warning('@deepseek-ai/dsh-tools 没有导出 defineTool，改用内置直通实现');
+  } catch (error) {
+    warning(`解析 @deepseek-ai/dsh-tools 失败（${error.message}），改用内置直通实现`);
+  }
+  return options => options;
+}
+
 export function apply(ctx) {
   try {
     if (typeof ctx?.tools?.register !== 'function') throw new Error('tools 服务不可用');
-    if (typeof ctx.effect !== 'function') throw new Error('ctx.effect 不可用');
-    const registration = ctx.effect(async () => {
+    // ctx.effect 是较新宿主才有的生命周期钩子。没有它就直接注册——
+    // 否则老版本 DSH 上插件会「装上了但一个工具都没有」，这是最糟的失败方式。
+    const setup = async () => {
       const disposers = [];
       try {
-        // The host resolves this public SDK; no bundled copy or runtime dependency.
-        const { defineTool } = await import('@deepseek-ai/dsh-tools');
+        const defineTool = await resolveDefineTool(message => warn(ctx, message));
         const store = new MemoryStore();
         for (const tool of createTools(defineTool, store, { warning: message => warn(ctx, message) })) disposers.push(ctx.tools.register(tool));
         try {
@@ -182,8 +200,14 @@ export function apply(ctx) {
         for (const dispose of disposers.reverse()) { try { dispose(); } catch { /* keep unwinding */ } }
         report(ctx, error);
       }
-    }, 'memory-engine.tools');
-    // Await setup without returning its disposer as a second plugin teardown.
-    return Promise.resolve(registration).then(() => undefined, error => { report(ctx, error); });
+    };
+
+    if (typeof ctx.effect === 'function') {
+      const registration = ctx.effect(setup, 'memory-engine.tools');
+      // Await setup without returning its disposer as a second plugin teardown.
+      return Promise.resolve(registration).then(() => undefined, error => { report(ctx, error); });
+    }
+    warn(ctx, '宿主没有 ctx.effect，直接用注册式初始化（功能不减少）');
+    return Promise.resolve(setup()).then(() => undefined, error => { report(ctx, error); });
   } catch (error) { report(ctx, error); }
 }

package/lib/render/layout.mjs

@@ -1,5 +1,7 @@
+const SEED = 20261030;
+
 export function layoutMemories(nodes) {
-  let seed = 20261030;
+  let seed = SEED;
   const random = () => ((seed = (seed * 16807) % 2147483647) - 1) / 2147483646;
   function brainPoint(radiusScale) {
     const radius = Math.pow(random(), 1 / 3) * radiusScale;
@@ -11,12 +13,49 @@ export function layoutMemories(nodes) {
       z: radius * Math.sin(phi) * Math.sin(theta) * 0.78,
     };
   }
-  return nodes.map((node) => {
+
+  const placed = nodes.map((node) => {
     const inner = ['人格', '印象', '知识'].includes(node.kind) || node.majorEmotion;
-    const distance = inner ? 14 + Math.pow(random(), 0.65) * 36 : 48 + Math.min(1, node.ageDays / 30) * 58 + random() * 12;
+    // 整体半径放大 1.35 倍：原来 298 个节点挤在一起，点谁都容易点错
+    const distance = (inner ? 14 + Math.pow(random(), 0.65) * 36 : 48 + Math.min(1, node.ageDays / 30) * 58 + random() * 12) * 1.35;
     const baseRadius = node.majorEmotion ? 3.2 : inner
       ? (node.heat === 1 ? 2.4 : node.heat === 2 ? 1.8 : 1.3)
       : (node.heat === 1 ? 2.1 : node.heat === 2 ? 1.5 : 1.0);
-    return { ...node, pos: brainPoint(distance), radius: baseRadius + Math.min(1.4, Math.sqrt(node.degree) * 0.18) };
+    // 连接数加成收敛得更紧一点，避免枢纽节点长得过大压住邻居
+    return { ...node, pos: brainPoint(distance), radius: baseRadius + Math.min(1.1, Math.sqrt(node.degree) * 0.15) };
   });
+
+  // ── 分离松弛：把互相重叠的节点推开 ──
+  // 不做这一步的话，随机落点会让相邻节点的圆重叠，视觉糊成一片，点击也分不清。
+  // 只在世界坐标里推开，不改 z 深度关系太多；迭代次数固定，保证同一份数据每次布局一致。
+  relax(placed, { iterations: 60, gap: 1.55, strength: 0.5 });
+  return placed;
+}
+
+function relax(items, { iterations, gap, strength }) {
+  if (items.length < 2) return;
+  for (let round = 0; round < iterations; round++) {
+    let moved = false;
+    for (let i = 0; i < items.length; i++) {
+      const a = items[i];
+      for (let j = i + 1; j < items.length; j++) {
+        const b = items[j];
+        const dx = b.pos.x - a.pos.x;
+        const dy = b.pos.y - a.pos.y;
+        const dz = b.pos.z - a.pos.z;
+        const dist = Math.hypot(dx, dy, dz) || 1e-6;
+        const minDist = (a.radius + b.radius) * gap;
+        if (dist >= minDist) continue;
+        // 单位向量；重合时用一个确定的、由索引决定的偏移方向，避免除零和随机抖动
+        const ux = dist > 1e-5 ? dx / dist : Math.cos(i * 2.39996);
+        const uy = dist > 1e-5 ? dy / dist : Math.sin(i * 2.39996);
+        const uz = dist > 1e-5 ? dz / dist : 0.35;
+        const push = (minDist - dist) * strength * 0.5;
+        a.pos.x -= ux * push; a.pos.y -= uy * push; a.pos.z -= uz * push;
+        b.pos.x += ux * push; b.pos.y += uy * push; b.pos.z += uz * push;
+        moved = true;
+      }
+    }
+    if (!moved) break;
+  }
 }

package/lib/render/render.mjs

@@ -121,11 +121,17 @@ function fire(id,now) {
   }
 }
 function select(x,y) {
-  let best=null,distance=Infinity;
+  // 命中判定：先按「离光标最近的节点」选，而不是「第一个框住光标的节点」。
+  // 原来要求 值<该节点半径，小节点容易被邻居抢走 → 点错。
+  // 现在给每个节点一个最小容差，再用距离减去一点半径作为打分（同样近时偏向大的那个）。
+  let best=null,bestScore=Infinity;
   for (const star of DATA.stars) {
     if (!star._screen) continue;
     const value=Math.hypot(star._screen.x-x,star._screen.y-y);
-    if (value<star._screen.r && value<distance) {best=star;distance=value;}
+    const tolerance=Math.max(14,star._screen.r*1.15);
+    if (value>tolerance) continue;
+    const score=value-star._screen.r*0.22;
+    if (score<bestScore) {bestScore=score;best=star;}
   }
   if (!best) return;
   fire(best.id,performance.now());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "description": "Local DSH memory engine with neuron network visualization and private file import",
   "keywords": [
     "dsh",
@@ -36,7 +36,7 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "@deepseek-ai/dsh-tools": "0.2.1-rc.3"
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.8 <0.3.0"
   },
   "dsh": {
     "bundle": {
@@ -48,6 +48,11 @@
     }
   },
   "bugs": "https://github.com/",
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    }
+  },
   "scripts": {
     "test": "node --test test/*.test.mjs"
   }