dsh-memory-engine 0.8.0 → 0.8.2

package/lib/config-write.js

@@ -16,7 +16,7 @@ const writable = new Map([
   ['autoMemory.dailyCap', value => Number.isSafeInteger(value) && value >= 0 && value <= 500],
   ['spinSpeed', value => Number.isFinite(value) && value >= 0.05 && value <= 1.5],
   ['graphTheme', value => ['classic', 'neon', 'paper', 'mono'].includes(value)],
-  ['graphLayout', value => ['sphere', 'flat', 'spiral'].includes(value)],
+  ['graphLayout', value => ['sphere', 'galaxy', 'brain', 'flat', 'spiral'].includes(value)],
   ['showGuideOnEmpty', value => typeof value === 'boolean'],
   ['hideButton', value => typeof value === 'boolean'],
 ]);
@@ -61,6 +61,10 @@ export function updateConfig(home, changes, { now = Date.now, warn = () => {} }
     try { next.autoImport.sessionFilter = normalizeSessionFilter({ ...current.autoImport?.sessionFilter, ...changes.autoImport.sessionFilter }); }
     catch (error) { invalid(error.message); }
   }
+  if (Object.hasOwn(changes, 'graphLayout')) {
+    if (next.graphLayout === 'flat') next.graphLayout = 'galaxy';
+    if (next.graphLayout === 'spiral') next.graphLayout = 'brain';
+  }
   if (changes.autoMemory?.enabled === true) next.showAutoMemoryCostHint = false;
   fs.mkdirSync(directory, { recursive: true });
   const prefix = `config.json.bak-${now()}`;

package/lib/config.js

@@ -53,7 +53,9 @@ export function readConfig(home = defaultHome(), { warn } = {}) {
     if (value.spinSpeed !== undefined && (!Number.isFinite(value.spinSpeed) || value.spinSpeed < 0.05 || value.spinSpeed > 1.5)) {
       throw new Error('spinSpeed 必须是 0.05～1.5 的数字');
     }
-    for (const [key, choices] of [['graphTheme', ['classic', 'neon', 'paper', 'mono']], ['graphLayout', ['sphere', 'flat', 'spiral']]]) {
+    if (value.graphLayout === 'flat') value.graphLayout = 'galaxy';
+    if (value.graphLayout === 'spiral') value.graphLayout = 'brain';
+    for (const [key, choices] of [['graphTheme', ['classic', 'neon', 'paper', 'mono']], ['graphLayout', ['sphere', 'galaxy', 'brain']]]) {
       if (value[key] !== undefined && !choices.includes(value[key])) throw new Error(`${key} 必须是 ${choices.join('、')}`);
     }
     return { ...value, personaTitle: value.personaTitle?.trim() || '角色卡', spinSpeed: value.spinSpeed ?? 0.35,

package/lib/render/canvas.js

@@ -38,7 +38,9 @@ export function createRenderer(canvas, data, options = {}) {
   if (!Object.hasOwn(THEMES, themeName)) throw new Error('未知图谱配色');
   let theme = THEMES[themeName];
   let layoutName = options.graphLayout ?? data.graphLayout ?? 'sphere';
-  if (!['sphere', 'flat', 'spiral'].includes(layoutName)) throw new Error('未知图谱布局');
+  if (layoutName === 'flat') layoutName = 'galaxy';
+  if (layoutName === 'spiral') layoutName = 'brain';
+  if (!['sphere', 'galaxy', 'brain'].includes(layoutName)) throw new Error('未知图谱布局');
   let sphereNodes = [];
   const layouts = new Map();
   let nodes = [], links = [], hubs = [], linkTwinkle = [], visibleLinks = [];
@@ -86,7 +88,9 @@ function glowSprite(rgb) {
 
   function setLayout(nextLayout) {
     if (destroyed) return;
-    if (!['sphere', 'flat', 'spiral'].includes(nextLayout)) throw new Error('未知图谱布局');
+    if (nextLayout === 'flat') nextLayout = 'galaxy';
+    if (nextLayout === 'spiral') nextLayout = 'brain';
+    if (!['sphere', 'galaxy', 'brain'].includes(nextLayout)) throw new Error('未知图谱布局');
     if (layoutName === nextLayout && layouts.has(nextLayout)) return;
     if (!layouts.has(nextLayout)) {
       if (typeof options.layoutNodes !== 'function') throw new Error('缺少图谱布局函数');
@@ -311,20 +315,22 @@ function frame(now) {
     }
   }
   if (linkPaths.length) {
+    if (layoutName === 'galaxy') ctx.globalAlpha=0.8;
     if (Array.isArray(theme.link)) {
       const gradient = ctx.createLinearGradient(0,0,width,height);
       gradient.addColorStop(0,theme.link[0]);
       gradient.addColorStop(1,theme.link[1]);
       ctx.strokeStyle=gradient;
     } else ctx.strokeStyle=theme.link;
-    ctx.lineWidth=1;
+    ctx.lineWidth=layoutName === 'galaxy' ? 0.8 : 1;
     ctx.beginPath();
     for (const p of linkPaths) { ctx.moveTo(p[0],p[1]); ctx.quadraticCurveTo(p[2],p[3],p[4],p[5]); }
     ctx.stroke();
     // 更亮的一层，让关联线看得清
     ctx.strokeStyle=theme.linkHighlight;
-    ctx.lineWidth=2;
+    ctx.lineWidth=layoutName === 'galaxy' ? 1.6 : 2;
     ctx.stroke();
+    if (layoutName === 'galaxy') ctx.globalAlpha=1;
   }
   for (let index=pulses.length-1;index>=0;index--) {
     const pulse=pulses[index],fraction=(now-pulse.born)/pulse.life;

package/lib/render/layout.mjs

@@ -1,7 +1,9 @@
 const SEED = 20261030;
 
 export function layoutPositions(nodes, layout = 'sphere') {
-  if (!['sphere', 'flat', 'spiral'].includes(layout)) throw new Error('未知图谱布局');
+  if (layout === 'flat') layout = 'galaxy';
+  if (layout === 'spiral') layout = 'brain';
+  if (!['sphere', 'galaxy', 'brain'].includes(layout)) throw new Error('未知图谱布局');
   if (layout === 'sphere') return nodes.map(node => ({ ...node, pos: { ...node.pos } }));
   const memories = nodes.filter(node => !node.isCore).sort((left, right) =>
     (right.degree || 0) - (left.degree || 0) || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0));
@@ -12,25 +14,107 @@ export function layoutPositions(nodes, layout = 'sphere') {
     hash = Math.imul(hash ^ (hash >>> 16), 0x45d9f3b);
     return ((hash ^ (hash >>> 16)) >>> 0) / 4294967295 * 2 - 1;
   }
-  if (layout === 'flat') {
-    for (let ring = 0; ring < 3; ring++) {
-      const members = memories.slice(Math.ceil(memories.length * ring / 3), Math.ceil(memories.length * (ring + 1) / 3));
-      const radius = [30, 55, 80][ring];
-      members.forEach((node, index) => {
-        const angle = index / members.length * Math.PI * 2;
-        positions.set(node.id, { x: Math.cos(angle) * radius + jitter(node.id, 'x') * 3,
-          y: Math.sin(angle) * radius + jitter(node.id, 'y') * 3, z: 0 });
-      });
-    }
-  } else {
+  let datasetSeed = 20261030;
+  for (const id of memories.map(node => String(node.id)).sort()) {
+    for (const character of id + '\u0000') datasetSeed = Math.imul(datasetSeed ^ character.codePointAt(0), 16777619);
+  }
+  const uniform = (id, axis) => Math.max(1e-9, Math.min(1 - 1e-9, (jitter(datasetSeed + ':' + id, axis) + 1) / 2));
+  const gaussian = (id, axis) => Math.sqrt(-2 * Math.log(uniform(id, axis + ':radius'))) * Math.cos(2 * Math.PI * uniform(id, axis + ':angle'));
+  if (layout === 'galaxy') {
+    const armCount = 2 + Math.floor(uniform('galaxy', 'arms') * 3);
+    const rotation = uniform('galaxy', 'rotation') * Math.PI * 2;
+    const coreCount = Math.ceil(memories.length * 0.15);
+    const haloCount = Math.floor(memories.length * 0.05);
+    const diskEnd = memories.length - haloCount;
+    const dustCount = Math.round(memories.length * 0.30);
+    const dust = new Set(memories.slice(coreCount, diskEnd)
+      .sort((left, right) => uniform(left.id, 'dust') - uniform(right.id, 'dust') || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0))
+      .slice(0, Math.max(0, dustCount - haloCount)).map(node => node.id));
     memories.forEach((node, index) => {
-      const fraction = index / Math.max(1, memories.length - 1);
-      const angle = fraction * 3.2 * Math.PI + index % 3 * Math.PI * 2 / 3 + jitter(node.id, 'angle') * 0.35;
-      const radius = 18 + fraction * 92;
-      positions.set(node.id, { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: jitter(node.id, 'z') * 14 });
+      let radius, angle;
+      if (index < coreCount) {
+        radius = 6 + Math.sqrt(uniform(node.id, 'core-radius')) * 16;
+        angle = uniform(node.id, 'core-angle') * Math.PI * 2;
+      } else if (index >= diskEnd) {
+        radius = 95 + Math.sqrt(uniform(node.id, 'halo-radius')) * 35;
+        angle = uniform(node.id, 'halo-angle') * Math.PI * 2;
+      } else if (dust.has(node.id)) {
+        radius = 22 + Math.sqrt(uniform(node.id, 'dust-radius')) * 73;
+        angle = uniform(node.id, 'dust-angle') * Math.PI * 2;
+      } else {
+        const fraction = (index - coreCount + 0.5) / Math.max(1, diskEnd - coreCount);
+        const offset = fraction * 73 + gaussian(node.id, 'radius') * 9;
+        const folded = ((offset % 146) + 146) % 146;
+        radius = 22 + (folded <= 73 ? folded : 146 - folded);
+        const arm = Math.floor(uniform(node.id, 'arm') * armCount);
+        const base = rotation + arm * Math.PI * 2 / armCount + (uniform(arm, 'arm-offset') - 0.5) * 0.35;
+        const twist = (radius - 18) / 95 * 2.2 * Math.PI;
+        const ripple = Math.sin(radius * 0.055 + uniform(arm, 'phase') * Math.PI * 2) * 0.10;
+        angle = base + twist + ripple + gaussian(node.id, 'angle') * 0.30;
+      }
+      const thickness = 8 / (1 + radius / 40);
+      const height = Math.max(-1, Math.min(1, gaussian(node.id, 'height') * 0.5)) * thickness;
+      positions.set(node.id, { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: height });
+    });
+  } else {
+    function brainPoint(id, axis, extent = 1) {
+      const horizontal = gaussian(id, axis + ':x');
+      const vertical = gaussian(id, axis + ':y');
+      const depth = gaussian(id, axis + ':z');
+      const scale = Math.cbrt(uniform(id, axis + ':distance')) * extent / Math.hypot(horizontal, vertical, depth);
+      return { x: 42 + horizontal * scale * 40, y: vertical * scale * 106, z: depth * scale * 52 };
+    }
+    const centers = [0, 1].map(side => {
+      const count = 12 + Math.floor(uniform('brain:' + side, 'clusters') * 3);
+      const candidates = Array.from({ length: 96 }, (_, index) => {
+        const id = 'brain:' + side + ':' + index;
+        const point = brainPoint(id, 'center', 0.82 + uniform(id, 'surface') * 0.12);
+        return { ...point, spread: 6 + uniform(id, 'spread') * 8, phase: uniform(id, 'phase') * Math.PI * 2 };
+      });
+      const interior = candidates.reduce((best, point, index) => Math.hypot(point.x - 42, point.y, point.z)
+        < Math.hypot(candidates[best].x - 42, candidates[best].y, candidates[best].z) ? index : best, 0);
+      const selected = [candidates.splice(interior, 1)[0]];
+      while (selected.length < count) {
+        let best = 0, greatest = -Infinity;
+        candidates.forEach((point, index) => {
+          const distance = Math.min(...selected.map(center => Math.hypot(point.x - center.x, point.y - center.y, (point.z - center.z) * 0.7)));
+          if (distance > greatest) { greatest = distance; best = index; }
+        });
+        selected.push(candidates.splice(best, 1)[0]);
+      }
+      return selected;
+    });
+    const roamers = new Set([...memories].sort((left, right) => uniform(left.id, 'roaming') - uniform(right.id, 'roaming')
+      || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0))
+      .slice(0, Math.round(memories.length * 0.05)).map(node => node.id));
+    memories.forEach(node => {
+      const side = uniform(node.id, 'hemisphere') < 0.5 ? 0 : 1;
+      const target = brainPoint(node.id, 'target');
+      let center, nearest = Infinity;
+      centers[side].forEach((candidate, index) => {
+        const distance = Math.hypot(target.x - candidate.x, target.y - candidate.y, target.z - candidate.z)
+          * (0.8 + uniform(node.id, 'weight:' + index) * 0.4);
+        if (distance < nearest) { nearest = distance; center = candidate; }
+      });
+      const point = roamers.has(node.id) ? target : {
+        x: center.x + gaussian(node.id, 'scatter:x') * center.spread,
+        y: center.y + gaussian(node.id, 'scatter:y') * center.spread,
+        z: center.z + gaussian(node.id, 'scatter:z') * center.spread,
+      };
+      point.x += Math.sin(point.y * 0.08 + center.phase) * 6;
+      point.z += Math.sin(point.y * 0.09 + center.phase) * 4;
+      point.y += Math.sin(point.z * 0.12 + center.phase) * 3;
+      const envelope = 0.96 + 0.06 * Math.sin(point.y * 0.08) + 0.035 * Math.cos(point.z * 0.11 + side);
+      const distance = Math.hypot((point.x - 42) / 40, point.y / 106, point.z / 52);
+      if (distance > envelope) {
+        const scale = envelope * (0.93 + uniform(node.id, 'edge') * 0.06) / distance;
+        point.x = 42 + (point.x - 42) * scale; point.y *= scale; point.z *= scale;
+      }
+      positions.set(node.id, { x: (side ? 1 : -1) * (4 + Math.abs(point.x)) + (side ? 2 : 0),
+        y: point.y - (side ? 1 : 0), z: point.z });
     });
   }
-  return nodes.map(node => ({ ...node, pos: node.isCore ? { x: 0, y: 0, z: 0 } : positions.get(node.id) }));
+  return nodes.map(node => ({ ...node, pos: node.isCore ? { x: 0, y: layout === 'brain' ? 14 : 0, z: 0 } : positions.get(node.id) }));
 }
 
 export function layoutMemories(nodes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "DSH 本地记忆插件：自动记忆、遗忘曲线、关键词关联、可检索可编辑，数据留在本机。",
   "keywords": [
     "dsh",