dsh-memory-engine 0.7.0-beta.4 → 0.7.0-beta.6b

package/lib/index.js

@@ -2,6 +2,8 @@ import { MemoryStore } from './store.js';
 import { chars, titleOf } from './decay.js';
 import { generateMap, mapReport, openMap } from './map.js';
 import { registerMemoryRoutes } from './routes.js';
+import { createAutoMemory } from './auto-memory.js';
+import { createAutoImport } from './auto-import.js';
 
 export const name = 'memory-engine';
 export const inject = ['tools', 'webServer'];
@@ -53,14 +55,28 @@ export function createTools(defineTool, store = new MemoryStore(), { map = gener
       }, output,
       async execute(args) {
         const hits = store.recall(args);
-        if (!hits.length) return `没有找到跟「${args.q}」相关的记忆。`;
+        if (!hits.length) return `【没有找到】「${args.q}」在记忆库里没有相关内容。`;
+        const quote = words => words.map(word => `「${word}」`).join('');
         let index = 0;
-        return ['direct', 'spread'].map(via => {
+        const describe = hit => `${++index}. [${hit.kind}] ${titleOf(hit)}（留存 ${hit.retention.toFixed(2)}；id=${hit.id}）`;
+        const sections = [];
+        for (const via of ['direct', 'partial']) {
           const group = hits.filter(hit => hit.via === via);
-          if (!group.length) return '';
-          return [via === 'direct' ? '【直接命中】' : '【联想到的】', ...group.map(hit =>
-            `${++index}. [${hit.kind}] ${titleOf(hit)}（留存 ${hit.retention.toFixed(2)}；id=${hit.id}）：${chars(hit.text, 120)}`)].join('\n');
-        }).filter(Boolean).join('\n\n');
+          if (!group.length) continue;
+          const terms = group[0].terms;
+          const matched = terms.filter(term => group.some(hit => hit.matched.includes(term)));
+          const missed = terms.filter(term => !matched.includes(term));
+          const label = via === 'direct' ? '直接命中' : '部分命中';
+          const summary = `【${label} ${group.length} 条】` + (via === 'partial' ? '（覆盖不足 50%，不是直接命中）' : '')
+            + `命中${quote(matched)}` + (missed.length ? `；未命中${quote(missed)}` : '；全部查询词均命中');
+          sections.push([summary, ...group.map(hit => `${describe(hit)}\n`
+            + `   覆盖 ${hit.matched.length}/${hit.terms.length}；命中${quote(hit.matched)}`
+            + (hit.missed.length ? `；未命中${quote(hit.missed)}` : '') + `\n   ${hit.snippet}`)].join('\n\n'));
+        }
+        const spread = hits.filter(hit => hit.via === 'spread');
+        if (spread.length) sections.push(['【联想到的（不是直接命中）】', ...spread.map(hit => `${describe(hit)}\n`
+          + `   从「${hit.from.title}」（id=${hit.from.id}）联想：完整标题「${hit.from.term}」出现在关联正文中。\n   ${hit.snippet}`)].join('\n\n'));
+        return sections.join('\n\n');
       },
     }),
     defineTool({
@@ -188,6 +204,12 @@ export function apply(ctx) {
         } catch (error) {
           warn(ctx, `图谱路由注册失败，记忆工具仍可用：${error.message}`);
         }
+        for (const create of [createAutoMemory, createAutoImport]) {
+          try {
+            const automation = create({ ctx, store, warn: message => warn(ctx, message) });
+            disposers.push(() => automation.dispose());
+          } catch (error) { warn(ctx, `自动任务初始化失败，记忆工具仍可用：${error.message}`); }
+        }
         const timer = setTimeout(() => {
           try { if (store.read().length > 0) generateMap(store); }
           catch (error) { warn(ctx, `启动时图谱生成失败：${error.message}`); }

package/lib/noise.js

@@ -0,0 +1,20 @@
+export const DEFAULT_NOISE_PATTERNS = Object.freeze([
+  '重复唤醒', '已经回过', '回过了', '先不重复', '继续潜水', '潜水状态',
+  '标成已读', '已读水位', '先不发送', '没再发', '等他说下一句',
+  '看一眼情况', '没有新消息', '这轮是', '我先不', '对话停在这里',
+  '对话就停在这', '等有人 @', '再回来就是', '未读 0',
+]);
+
+const REPORT_PREFIX = /^\s*(已回|已回复|已发送|已处理|已确认|已读|已标记|回过了|发过了)\s*[:：]/u;
+
+export function isNoise(text, extra = []) {
+  if (typeof text !== 'string') return false;
+  if (REPORT_PREFIX.test(Array.from(text).slice(0, 12).join(''))) return true;
+  const features = text.replace(/(?:他|她|对方|朋友|同事)(?:说|表示|告诉我)[\s“「『"']*(?:已经回过|回过了)/gu, '');
+  const patterns = new Set([...DEFAULT_NOISE_PATTERNS, ...extra].filter(pattern => typeof pattern === 'string' && pattern.length > 0));
+  let hits = 0;
+  for (const pattern of patterns) {
+    if (features.includes(pattern) && ++hits >= 2) return true;
+  }
+  return hits === 1 && Array.from(text).length < 150;
+}

package/lib/recall.js

@@ -1,25 +1,56 @@
 import { chars, retention, titleOf } from './decay.js';
 
+export function queryTerms(query) {
+  return [...new Set(query.trim().toLocaleLowerCase().split(/[\s\p{P}\p{S}]+/u)
+    .filter(term => Array.from(term).length >= 2))];
+}
+
 export function relevance(memory, query) {
-  const q = query.trim().toLocaleLowerCase();
-  if (!q) return 0;
+  const normalized = query.trim().toLocaleLowerCase();
   const title = titleOf(memory).toLocaleLowerCase();
   const text = memory.text.toLocaleLowerCase();
-  const terms = q.split(/[\s\p{P}\p{S}]+/u).filter(term => Array.from(term).length >= 2);
-  let rel = 0;
+  const terms = queryTerms(query);
+  const matched = terms.filter(term => title.includes(term) || text.includes(term));
+  const missed = terms.filter(term => !matched.includes(term));
+  let score = 0;
+  for (const term of terms) {
+    if (title.includes(term)) score += 3;
+    if (text.includes(term)) score += 2;
+    if (title.startsWith(term)) score += 2;
+  }
+  if (normalized && title.includes(normalized)) score += 4;
+  if (normalized && text.includes(normalized)) score += 2;
+  return Object.defineProperty({ score, coverage: terms.length ? matched.length / terms.length : 0, terms, matched, missed },
+    Symbol.toPrimitive, { value: () => score });
+}
+
+function snippet(text, terms) {
+  const characters = Array.from(text);
+  const positions = [];
   for (const term of terms) {
-    if (title.includes(term)) rel += 3;
-    if (text.includes(term)) rel += 2;
-    if (title.startsWith(term)) rel += 2;
+    const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const match of text.matchAll(new RegExp(escaped, 'giu'))) {
+      const start = Array.from(text.slice(0, match.index)).length;
+      positions.push({ start, end: start + Array.from(match[0]).length });
+    }
+  }
+  positions.sort((first, second) => first.start - second.start);
+  let selected = chars(text, 120), bestCoverage = 0;
+  for (const position of positions) {
+    const start = Math.max(0, position.start - 45);
+    const end = Math.min(characters.length, position.end + 45);
+    const context = characters.slice(start, end).join('');
+    const coverage = terms.filter(term => context.toLocaleLowerCase().includes(term)).length;
+    if (coverage <= bestCoverage) continue;
+    bestCoverage = coverage;
+    selected = (start > 0 ? '…' : '') + context + (end < characters.length ? '…' : '');
   }
-  if (title.includes(q)) rel += 4;
-  if (text.includes(q)) rel += 2;
-  return rel;
+  return selected;
 }
 
-function related(a, b) {
-  return [a.title, a.prefix].some(key => key && b.text.includes(key))
-    || [b.title, b.prefix].some(key => key && a.text.includes(key));
+function related(first, second) {
+  return (Array.from(first.title).length >= 4 && second.text.includes(first.title))
+    || (Array.from(second.title).length >= 4 && first.text.includes(second.title));
 }
 
 export function recall(memories, { q, limit = 8, hops = 1, kind }, now = Date.now()) {
@@ -28,32 +59,40 @@ export function recall(memories, { q, limit = 8, hops = 1, kind }, now = Date.no
   hops = Math.max(0, Math.min(2, Math.trunc(Number.isFinite(hops) ? hops : 1)));
   const pool = memories.filter(memory => kind === undefined || memory.kind === kind)
     .map(memory => ({ memory, retention: retention(memory, now),
-      title: titleOf(memory), prefix: chars(memory.text, 12), text: memory.text }));
+      title: titleOf(memory).toLocaleLowerCase(), text: memory.text.toLocaleLowerCase(), ...relevance(memory, q) }));
   const sorted = rows => rows.sort((a, b) => b.score - a.score || b.memory.ts - a.memory.ts);
-  const direct = sorted(pool.map(row => ({ ...row, rel: relevance(row.memory, q), via: 'direct' }))
-    .filter(row => row.rel > 0).map(row => ({ ...row, score: row.rel * (0.35 + 0.65 * row.retention) })))
-    .slice(0, limit);
-  const best = new Map(direct.map(row => [row.memory.id, row]));
+  const matches = sorted(pool.filter(row => row.matched.length > 0)
+    .map(row => ({ ...row, via: row.coverage >= 0.5 ? 'direct' : 'partial', score: row.score * (0.35 + 0.65 * row.retention) })));
+  const direct = matches.filter(row => row.via === 'direct').slice(0, limit);
+  const partial = matches.filter(row => row.via === 'partial').slice(0, limit - direct.length);
+  if (!direct.length && !partial.length) return [];
+  const spreadLimit = Math.min(limit - direct.length - partial.length, Math.floor(direct.length / 2));
+  const matchedIds = new Set(matches.map(row => row.memory.id));
+  const threshold = direct.length ? direct[0].score * 0.35 : Infinity;
+  const best = new Map();
   let frontier = direct;
-  for (let hop = 0; hop < hops; hop++) {
+  for (let hop = 0; hop < hops && spreadLimit > 0; hop++) {
     const next = new Map();
-    // Lower-scored paths only decay further, so they cannot enter the final
-    // top N once their best possible next score is below its existing floor.
-    const floor = best.size >= limit ? sorted([...best.values()])[limit - 1].score : 0;
     for (const source of frontier) {
-      if (source.score * 0.45 < floor) continue;
+      const score = source.score * 0.45;
+      if (score < threshold) continue;
       for (const neighbor of pool) {
-        if (neighbor.memory.id === source.memory.id || neighbor.retention <= 0.4
+        if (matchedIds.has(neighbor.memory.id) || neighbor.memory.id === source.memory.id || neighbor.retention <= 0.4
           || !related(source, neighbor)) continue;
-        const score = source.score * 0.45;
         if (score <= (best.get(neighbor.memory.id)?.score ?? 0)) continue;
-        const hit = { ...neighbor, score, via: 'spread' };
+        const sharedTitle = Array.from(source.title).length >= 4 && neighbor.text.includes(source.title)
+          ? titleOf(source.memory) : titleOf(neighbor.memory);
+        const hit = { ...neighbor, score, via: 'spread', from: { id: source.memory.id, title: titleOf(source.memory), term: sharedTitle } };
         best.set(neighbor.memory.id, hit);
         next.set(neighbor.memory.id, hit);
       }
     }
     frontier = [...next.values()];
   }
-  return sorted([...best.values()]).slice(0, limit)
-    .map(({ memory, score, retention: value, via }) => ({ ...memory, score, retention: value, via }));
+  return [...direct, ...partial, ...sorted([...best.values()]).slice(0, spreadLimit)]
+    .map(({ memory, score, retention: value, via, coverage, terms, matched, missed, from }) => ({
+      ...memory, score, retention: value, via, coverage, terms, matched, missed,
+      snippet: snippet(memory.text, via === 'spread' ? [from.term.toLocaleLowerCase()] : matched),
+      ...(from ? { from } : {}),
+    }));
 }

package/lib/render/canvas.js

@@ -6,15 +6,18 @@ export function createRenderer(canvas, data, options = {}) {
   if (!ctx) throw new Error('Canvas 2D 不可用');
   const colors = { '人格':[255,215,106], '印象':[143,216,255], '知识':[126,231,178], '日记':[190,160,255], '对话':[255,160,140], '情绪':[255,90,90] };
   const fallback = [145,205,255];
-  let nodes = [], links = [], hubs = [], linkTwinkle = [];
+  let nodes = [], links = [], hubs = [], linkTwinkle = [], visibleLinks = [];
   const byId = new Map(), adjacency = new Map(), sprites = new Map();
   const pulses = [], firing = new Map(), selections = new Set();
+  // 默认不画连线（数量太大会卡），只画选中光点周围的线
+  let selectedId=null, selectedNeighbours=new Set();
   if (typeof options.onSelect === 'function') selections.add(options.onSelect);
   let seed = 987654321;
   const random = () => ((seed = seed * 16807 % 2147483647) - 1) / 2147483646;
   let width=0,height=0,dpr=1,rotX=0.3,rotY=0.15,zoom=data.nodes.length<50?1.6:1,autoSpin=true;
   let spinSpeed=data.spinSpeed??0.35,resumeAt=0;
-  let drag=null,nextFire=0,lastTime=0,rafId=null,running=false,destroyed=false,generation=0,observer=null;
+  const frameInterval=Number.isFinite(options.frameInterval)?Math.max(0,options.frameInterval):0;
+  let drag=null,nextFire=0,lastTime=0,lastDrawAt=0,rafId=null,running=false,destroyed=false,generation=0,observer=null;
 
 function glowSprite(rgb) {
   const off = document.createElement('canvas');
@@ -46,6 +49,8 @@ function glowSprite(rgb) {
     nodes = nextData.nodes.map(node => ({ ...node, pos: { ...node.pos } }));
     links = nextData.links.map(link => [...link]);
     byId.clear(); adjacency.clear(); sprites.clear(); pulses.length = 0; firing.clear();
+    selectedId=typeof options.selectedId==='string'?options.selectedId:null;
+    selectedNeighbours=new Set(selectedId?(adjacency.get(selectedId)||[]):[]);
     seed = 987654321; nextFire = 0;
     for (const node of nextData.nodes) byId.set(node.id, node);
     for (const node of nodes) adjacency.set(node.id, []);
@@ -71,6 +76,23 @@ function glowSprite(rgb) {
         jitterEnd: ((Math.floor(h / 977) % 100) / 100 - 0.5) * 1.6,
       };
     });
+    // 连线数量会随记忆增长爆炸（332 条时 383 根，479 条时 1738 根）。
+    // 每帧全画会卡，所以按"两端留存"排序，最多画 LINK_DRAW_CAP 根最亮的，
+    // 其余的不进这一帧（数据没丢，只是不画，缩放/点击仍按全量算）。
+    const LINK_DRAW_CAP = 1200;
+    if (links.length <= LINK_DRAW_CAP) {
+      visibleLinks = links.map((_, index) => index);
+    } else {
+      const byIdLocal = new Map(nodes.map(node => [node.id, node]));
+      const strength = index => {
+        const [left, right] = links[index];
+        const a = byIdLocal.get(left), b = byIdLocal.get(right);
+        return Math.min(a?.retention ?? 0, b?.retention ?? 0) + Math.min(a?.degree ?? 0, b?.degree ?? 0) * 0.002;
+      };
+      visibleLinks = links.map((_, index) => index)
+        .sort((x, y) => strength(y) - strength(x))
+        .slice(0, LINK_DRAW_CAP);
+    }
 for (const star of nodes) {
   star._rgb = colors[star.kind] || fallback;
   const count = Math.min(9, 4 + Math.round(Math.sqrt(star.degree) * 1.2));
@@ -107,17 +129,19 @@ function project(pos) {
 function fire(id,now) {
   firing.set(id,1);
   const neighbours=adjacency.get(id)||[];
-  // 不再"点亮整个扇面"：只随机挑 2~4 条邻居。
-  // 一次把几十条边同时点亮，看上去就是全图一起闪。
-  const count=Math.min(neighbours.length,2+Math.floor(Math.random()*3));
+  // 选中某个光点时，把它的关联线都点亮几条脉冲（最多 24 条，避免又糊成一片）；
+  // 未选中时的随机心跳只挑 2~4 条，避免整片区域同时亮。
+  const selected = id===selectedId;
+  const limit = selected ? 24 : 2+Math.floor(Math.random()*3);
+  const count=Math.min(neighbours.length,limit);
   const picked=new Set();
   let guard=0;
-  while (picked.size<count && neighbours.length && guard++<200) {
+  while (picked.size<count && neighbours.length && guard++<400) {
     picked.add(neighbours[Math.floor(Math.random()*neighbours.length)]);
   }
   for (const other of picked) {
     // 邻居亮度也压低：原来 0.65 会让整片区域同时亮起来
-    firing.set(other,Math.max(0.26,firing.get(other)||0));
+    firing.set(other,Math.max(selected?0.4:0.26,firing.get(other)||0));
     pulses.push({from:id,to:other,born:now,life:700+Math.random()*2400});
   }
 }
@@ -133,6 +157,8 @@ function fire(id,now) {
     if (score<bestScore) {bestScore=score;best=star;}
   }
   if (!best) return;
+  selectedId = best.id;
+  selectedNeighbours = new Set(adjacency.get(best.id) || []);
   fire(best.id,performance.now());
     for (const callback of selections) callback(byId.get(best.id));
   }
@@ -171,10 +197,16 @@ function frame(now) {
   if (!autoSpin && !drag && now>=resumeAt) autoSpin=true;
   if (autoSpin) rotY+=0.0011*spinSpeed*3*delta/16.7;
   if (now>nextFire) {
-    // 心跳节奏别太机械：间隔随机，偶尔连发两个，偶尔安静久一点
-    const burst=Math.random()<0.22 ? 2 : 1;
-    for (let i=0;i<burst && hubs.length;i++) {
-      fire(hubs[Math.floor(Math.random()*hubs.length)].id,now);
+    // 默认不画连线，所以也不撒"沿线的脉冲"——否则会出现飘来飘去的小点，找不到来源。
+    // 选中光点后，脉冲只在它的关联线上跑。
+    if (selectedId) {
+      fire(selectedId,now);
+    } else {
+      // 没选中时只让枢纽光点自己亮一下，不动线
+      if (hubs.length) {
+        const hub=hubs[Math.floor(Math.random()*hubs.length)];
+        firing.set(hub.id,1);
+      }
     }
     nextFire=now+1400+Math.random()*3200;
   }
@@ -192,37 +224,37 @@ function frame(now) {
   }
   points.sort((left,right)=>left.star.isCore?1:right.star.isCore?-1:right.p.depth-left.p.depth);
   const screen=new Map(points.map(point=>[point.star.id,point]));
-  ctx.globalCompositeOperation='lighter';
-  for (let linkIndex=0;linkIndex<links.length;linkIndex++) {
-    const [left,right]=links[linkIndex];
-    const first=screen.get(left),second=screen.get(right);
-    if (!first||!second) continue;
-    const act=Math.max(firing.get(left)||0,firing.get(right)||0);
-    // 连线自己也会呼吸：每条线有独立相位和频率，不再"齐刷刷"地一起闪。
-    const twinkle=linkTwinkle[linkIndex];
-    const breathe=twinkle ? (0.5+0.5*Math.sin(now*twinkle.freq+twinkle.phase))*twinkle.amp : 0;
-    // 度数补偿：枢纽节点周围几十条线会糊成一块光斑，
-    // 按两端度数把这类线整体压暗，让"一条线"和"一堆线"的观感接近。
-    const degSum=(first.star.degree||0)+(second.star.degree||0);
-    const damp=1/(1+0.07*Math.max(0,degSum-6));
-    const alpha=Math.min(.85,(.1*Math.min(first.star.retention,second.star.retention)+.12*act+breathe)*damp);
-    if (alpha<.01) continue;
-    // 端点沿法线错开，多条线进入同一节点时散成扇形
-    const dx=second.p.x-first.p.x, dy=second.p.y-first.p.y;
-    const len=Math.hypot(dx,dy)||1;
-    const nx=-dy/len, ny=dx/len;
-    const r1=Math.max(2,first.star.radius*first.p.scale*.55);
-    const r2=Math.max(2,second.star.radius*second.p.scale*.55);
-    const sx=first.p.x+nx*r1*0.9*(twinkle?twinkle.jitterStart:0);
-    const sy=first.p.y+ny*r1*0.9*(twinkle?twinkle.jitterStart:0);
-    const ex=second.p.x+nx*r2*0.9*(twinkle?twinkle.jitterEnd:0);
-    const ey=second.p.y+ny*r2*0.9*(twinkle?twinkle.jitterEnd:0);
-    // 弯曲方向和弯度都按连线各自的哈希来，避免所有线朝同一侧弯成漩涡
-    const bow=twinkle?twinkle.bow:0.18;
-    const mx=(sx+ex)/2+nx*len*bow*0.5;
-    const my=(sy+ey)/2+ny*len*bow*0.5;
-    ctx.strokeStyle='rgba(110,190,255,'+alpha+')';ctx.lineWidth=.7+act*1.6+breathe*1.4;
-    ctx.beginPath();ctx.moveTo(sx,sy);ctx.quadraticCurveTo(mx,my,ex,ey);ctx.stroke();
+  // 连线只在"选中某个光点"时画，且只画和它相连的那些。
+  // 全量 1738 根每帧画会卡；默认干干净净，点谁看谁的关联。
+  const linkPaths=[];
+  if (selectedId) {
+    for (const [left,right] of links) {
+      if (left!==selectedId && right!==selectedId) continue;
+      const first=screen.get(left),second=screen.get(right);
+      if (!first||!second) continue;
+      const target = left===selectedId ? second : first;
+      const ret = Math.min(first.star.retention, second.star.retention);
+      const alpha = Math.min(.9, .22 + ret*.35);
+      const dx=second.p.x-first.p.x, dy=second.p.y-first.p.y;
+      const len=Math.hypot(dx,dy)||1;
+      const nx=-dy/len, ny=dx/len;
+      // 朝选中点那一侧弯，形成"从中心散开"的观感
+      const bow = (target===second ? 1 : -1) * .16;
+      const mx=(first.p.x+second.p.x)/2+nx*len*bow*.5;
+      const my=(first.p.y+second.p.y)/2+ny*len*bow*.5;
+      linkPaths.push([first.p.x,first.p.y,mx,my,second.p.x,second.p.y,alpha]);
+    }
+  }
+  if (linkPaths.length) {
+    ctx.strokeStyle='rgba(110,190,255,0.30)';
+    ctx.lineWidth=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='rgba(160,220,255,0.22)';
+    ctx.lineWidth=2;
+    ctx.stroke();
   }
   for (let index=pulses.length-1;index>=0;index--) {
     const pulse=pulses[index],fraction=(now-pulse.born)/pulse.life;
@@ -307,6 +339,13 @@ function frame(now) {
     function tick(now) {
       if (!running || destroyed || currentGeneration !== generation) return;
       rafId=null;
+      // 帧率上限靠 options.frameInterval 控制（默认 0 = 不限）。
+      // 界面里按 40fps 传；测试里不传，保持逐帧确定性。
+      if (frameInterval > 0 && now - lastDrawAt < frameInterval) {
+        rafId=window.requestAnimationFrame(tick);
+        return;
+      }
+      lastDrawAt = now;
       frame(now);
       if (running && !destroyed && currentGeneration === generation) rafId=window.requestAnimationFrame(tick);
     }

package/lib/render/render.mjs

@@ -39,7 +39,7 @@ export function renderHtml(data, title = '记忆神经网络') {
 <div class="hud"><strong>${safeTitle}</strong><div><span id="total"></span> 个神经元 · <span id="linkCount"></span> 条突触</div><div class="sub">大小＝重要度和连接数 · 亮度＝留存</div></div>
 <section class="panel" id="panel"><button class="close" id="close" aria-label="关闭">×</button><div id="kind"></div><h2 id="title"></h2><div class="meta" id="meta"></div><div class="text" id="body"></div><button class="copy" id="copy" hidden>复制全文</button></section>
 <section class="review"><h2>复习清单 · 留存最低的记忆</h2><div id="reviewList"></div></section>
-<div class="tip">拖拽旋转 · 滚轮缩放 · 点击查看记忆</div>
+<div class="tip">拖拽旋转 · 滚轮缩放 · 点击光点看关联</div>
 <script>
 const DATA = ${embedded};
 const canvas = document.getElementById('map');

package/lib/session-text.js

@@ -0,0 +1,44 @@
+export function eventText(event) {
+  let content;
+  if (event?.type === 'user/message' && (!event.data?.role || event.data.role === 'user')) content = event.data?.content;
+  if (event?.type === 'assistant/message' && (!event.data?.message?.role || event.data.message.role === 'assistant')) content = event.data?.message?.content;
+  if (!Array.isArray(content)) return '';
+  return content.filter(block => block?.type === 'text' && typeof block.text === 'string').map(block => block.text).join('\n').trim();
+}
+
+export function usefulText(text) {
+  return Array.from(text).length > 1 && !/^(?:嗯|哦|噢|啊|好|好的|好呀|好哒|行|哈哈|呵呵|嘿嘿|谢谢|收到|ok|[\s，。！!~～])+$/iu.test(text)
+    && text.replace(/```[\s\S]*?```|~~~[\s\S]*?~~~/gu, '').trim().length > 0;
+}
+
+export function createTurnCollector(onTurn) {
+  const sessions = new Map();
+  return {
+    accept(session, event) {
+      const id = session?.id;
+      if (typeof id !== 'string' || !event) return;
+      if (!['turn/start', 'turn/end', 'user/message', 'assistant/message'].includes(event.type)) return;
+      let state = sessions.get(id);
+      if (event.type === 'turn/start' && state?.turn !== undefined && state.turn !== event.data?.turn) state = undefined;
+      if (!state) {
+        state = { text: '', userText: '', turn: undefined };
+        sessions.set(id, state);
+        if (sessions.size > 256) sessions.delete(sessions.keys().next().value);
+      }
+      if (event.type === 'turn/start') state.turn = event.data?.turn;
+      if (event.type === 'assistant/message' && state.turn !== undefined && event.data?.turn !== state.turn) return;
+      const text = eventText(event);
+      if (text) {
+        const role = event.type === 'user/message' ? 'user' : 'assistant';
+        state.text = Array.from(`${state.text}\n${role}: ${text}`).slice(-4000).join('');
+        if (role === 'user') state.userText = Array.from(`${state.userText}\n${text}`).slice(-4000).join('');
+      }
+      if (event.type === 'turn/end') {
+        if (state.turn !== undefined && event.data?.turn !== state.turn) return;
+        sessions.delete(id);
+        if (state.userText.trim()) onTurn({ sessionId: id, text: state.text, userText: state.userText, time: event.time });
+      }
+    },
+    clear() { sessions.clear(); },
+  };
+}

package/lib/store.js

@@ -55,7 +55,7 @@ export class MemoryStore {
     }
   }
 
-  save({ text, kind = '对话', heat, who, ts = this.now() }) {
+  save({ text, kind = '对话', heat, who, ts = this.now() }, { threshold = 0.7 } = {}) {
     if (!nonempty(text) || Array.from(text).length > 2000) throw new Error('text 必须为 1–2000 字');
     if (!nonempty(kind)) throw new Error('kind 必须是非空字符串');
     if (heat !== undefined && ![1, 2, 3].includes(heat)) throw new Error('heat 只能为 1/2/3');
@@ -67,7 +67,7 @@ export class MemoryStore {
     let memory = { id: `m-${now}-${randomBytes(3).toString('hex')}`, text, kind, ts,
       heat: heat ?? inferred.heat, emotion: inferred.emotion,
       ...(who !== undefined ? { who } : {}), boosts: 0, createdAt: now };
-    const match = findDuplicate(rows, memory);
+    const match = findDuplicate(rows, memory, undefined, threshold);
     if (match) {
       // A repeated save is one reinforcement; batch merges simply sum counts.
       memory.boosts = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.7.0-beta.4",
+  "version": "0.7.0-beta.6b",
   "description": "Local DSH memory engine with neuron network visualization and private file import",
   "keywords": [
     "dsh",