dsh-lite-memory 0.2.6 → 0.2.8

package/README.md

@@ -19,7 +19,7 @@ Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothi
 | **L1** 它发现有跨会话价值的经验 | 一行灰字 `memory · keep? "X" — 要记的内容` + 一个 `keep` 按钮；标题加一句话，看得懂才点，不点就永远不写，48 小时内不重复 |
 | **L2** 常识、一次性参数、凭据的值 | 永不写入 |
 
-这些行只属于产生它的那一轮：重进会话就没了，历史里只留正文。
+这些行只属于产生它的那一轮：重进会话就没了，历史里只留正文。同一件事再记一次会合并进原条目（旧要点保留，同键的新值覆盖）；前置条件不同的同一主题是两条，不合并。
 
 触发词：`记住`、`记一下`、`上次`、`规范`、`约定`、`路径`、`凭据怎么取`。
 
@@ -29,7 +29,7 @@ Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothi
 | **L1** it spots something worth keeping | one muted line `memory · keep? "X" — what would be remembered` with a single `keep` button — readable before you click, nothing written unless you click, at most once per two days |
 | **L2** common sense, one-off parameters, credential values | never written |
 
-Those lines belong to the turn that made them: reopening the session drops them, leaving only the prose in history.
+Those lines belong to the turn that made them: reopening the session drops them, leaving only the prose in history. Recording the same subject again merges into the existing entry — earlier points are kept and only conflicting keys are updated. The same subject under different preconditions stays two entries.
 
 ## 点一下就存 / One click, no turn
 

package/TRIGGERS.md

@@ -34,6 +34,23 @@
 
 这些行只属于产生它的那一轮：重进会话时不再显示，历史里只留正文。行出现在调用本身的位置——一轮正在跑时，那就是对话的最下面，不会悬浮在输入框上方。
 
+## 什么时候合并，什么时候新建
+
+一条约束只留一条，但**前置条件不一样就是两条**。同一条记忆挂在「什么情况下」上：换机器、换环境、换前提，内容往往互相矛盾，硬合并等于丢掉其中一种情况。
+
+判断顺序：
+
+1. 前置条件不同（含一边写了自己没写）→ 新建，标题后面跟场景，如「构建耗时长｜CI 容器」。
+2. 前置条件一致，且标题相同、标题字片重合 ≥ 0.6、或摘要重合 ≥ 0.75 → 合并。
+3. 只共用项目名不算合并（「插件市场条目字段」对「插件市场踩坑清单」重合约 0.4）。
+4. 判不准先 `memory_search`：命中且场景一致，就按那条的标题和场景写；不一致就新建。
+
+合并只做增添，绝不整篇覆盖：
+
+- 旧正文全留下；这次只写新增的要点。
+- `- 键：值` 形式的行，键相同则以新的为准（端口改了、路径改了）。
+- 真要把一条记忆作废重写（不是补充），先 `memory_forget` 再 `memory_save`，别用合并去覆盖。
+
 ## 频率与退让
 
 - 建议：同一项目 48 小时一条、一次对话最多一条；同一主题存过就不再建议。

package/index.js

@@ -114,6 +114,7 @@ const SAVE_PARAMS = {
     title: { type: 'string', description: `标题：名词短语，用户一眼能认出是哪件事，不超过 ${LIMITS.titleChars} 字` },
     summary: { type: 'string', description: `一句话说清要记的内容本身——用户只看这一行决定留不留，名词短语，不超过 ${LIMITS.summaryChars} 字` },
     body: { type: 'string', description: '正文 markdown。只写指针与要点，不抄录长文档' },
+    when: { type: 'string', description: `前置条件或适用场景（「在哪台机器 / 哪个环境 / 什么情况下」），不超过 ${LIMITS.whenChars} 字。同一主题但前置条件不同，会存成两条，不合并` },
     kind: { type: 'string', enum: ['preference', 'convention', 'procedure', 'pointer', 'pitfall', 'credential_hint', 'note'], description: '条目类型' },
     tags: { type: 'array', items: { type: 'string' }, description: '最多 5 个标签' },
   },
@@ -156,7 +157,7 @@ export function apply(ctx) {
 
   ctx.effect(() => tools.register({
     name: 'memory_save',
-    description: `保存一条记忆。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。用户点了「保留」或发「保留记忆「X」」时，用那条建议的内容调用。${NOTES}`,
+    description: `保存一条记忆。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。用户点了「保留」或发「保留记忆「X」」时，用那条建议的内容调用。更新已知主题时先 memory_read 旧正文再写：标题相同、或标题与摘要高度相近、且前置条件一致时，会合并进原来那条（merges+1），旧要点保留，同键的新值覆盖。前置条件不同的同一主题是两条，不要硬合并。正文只写这次新增的要点。${NOTES}`,
     parameters: SAVE_PARAMS,
     output: {
       schema: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "On-demand memory for the DeepSeek Harness: nothing in the system prompt, one muted line only when something is saved, hit or suggested.",
   "type": "module",
   "main": "index.js",

package/store.js

@@ -12,6 +12,7 @@ export const LIMITS = {
   entryBytes: 4096,
   totalBytes: 512 * 1024,
   titleChars: 40,
+  whenChars: 60,
   summaryChars: 60,
   suggestionWindowMs: 48 * 60 * 60 * 1000,
 };
@@ -125,20 +126,73 @@ export function trimIndex(scope, index) {
   }
 }
 
+/** 同一主题的判定线。跨过就合并成一条，跨不过就新建。 */
+export const MERGE = { title: 0.6, summary: 0.75 };
+
+/** 相邻两字为一组：中文没有空格，按词切分永远对不上，按字片才认得出改写的同一件事。 */
+function bigrams(text) {
+  const plain = normalizeText(text, 400).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '');
+  if (!plain) return new Set();
+  if (plain.length < 2) return new Set([plain]);
+  const out = new Set();
+  for (let i = 0; i + 1 < plain.length; i += 1) out.add(plain.slice(i, i + 2));
+  return out;
+}
+
 function similarity(a, b) {
-  const words = (text) => new Set(normalizeText(text, 400).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 1));
-  const left = words(a);
-  const right = words(b);
+  const left = bigrams(a);
+  const right = bigrams(b);
   if (left.size === 0 || right.size === 0) return 0;
   let shared = 0;
-  for (const word of left) if (right.has(word)) shared += 1;
-  return shared / Math.max(left.size, right.size);
+  for (const gram of left) if (right.has(gram)) shared += 1;
+  return shared / (left.size + right.size - shared);
 }
 
 /**
- * Save or merge one memory. A repeat of an existing topic updates it and counts
- * the merge instead of adding a row, which is what keeps a long-lived store tidy.
+ * 同一主题的判定。前置条件必须一致：同一件事在不同场景下是两条记忆，
+ * 哪怕正文互相看不上眼，也不能合并成一条。
  */
+function mergeCandidate(entries, title, summary, when) {
+  let best = null;
+  let bestScore = 0;
+  for (const item of entries) {
+    if ((item.when || '') !== when) continue;
+    if (item.title === title) return item;
+    const titleScore = similarity(item.title, title);
+    const summaryScore = similarity(item.summary, summary);
+    if (titleScore < MERGE.title && summaryScore < MERGE.summary) continue;
+    const score = Math.max(titleScore, summaryScore);
+    if (score > bestScore) {
+      best = item;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+/** 合并只做增添：旧要点全留下；同一个键（`- 键：值`）的新值覆盖旧值。 */
+export function mergeBody(oldBody, incoming) {
+  const keyOf = (line) => {
+    const match = /^\s*[-*]\s*([^：:]{1,20})[：:]/.exec(line);
+    return match ? match[1].trim() : null;
+  };
+  const flat = (line) => line.replace(/\s+/g, ' ').trim();
+  const out = String(oldBody || '').split('\n').filter((line) => line.trim());
+  for (const raw of String(incoming || '').split('\n')) {
+    const line = raw.trim();
+    if (!line) continue;
+    const key = keyOf(line);
+    if (key) {
+      const at = out.findIndex((item) => keyOf(item) === key);
+      if (at >= 0) out[at] = line;
+      else out.push(line);
+      continue;
+    }
+    if (!out.some((item) => flat(item) === flat(line))) out.push(line);
+  }
+  return out.join('\n');
+}
+
 export function upsert(scope, draft) {
   const title = normalizeText(draft.title, LIMITS.titleChars);
   if (!title) throw new Error('标题为空');
@@ -149,13 +203,18 @@ export function upsert(scope, draft) {
   const asSecret = detectSecret(`${title}\n${summary.text}\n${body}`);
   if (asSecret) throw new Error(`检出疑似凭据，未保存（${asSecret}）。凭据只记位置与调用方式`);
 
+  const when = normalizeText(draft.when ?? '', LIMITS.whenChars);
   const index = loadIndex(scope);
   const now = new Date().toISOString();
-  const existing = index.entries.find((item) => item.title === title) || index.entries.find((item) => similarity(item.summary, summary.text) > 0.8);
+  const existing = mergeCandidate(index.entries, title, summary.text, when);
   const id = existing ? existing.id : `mem_${Date.now().toString(36)}${crypto.randomBytes(2).toString('hex')}`;
+  const stated = existing ? fs.readFileSync(entryFile(scope, id), 'utf8') : '';
+  const mergedBody = existing ? mergeBody(stated, body) : body;
+  if (Buffer.byteLength(mergedBody, 'utf8') > LIMITS.entryBytes) throw new Error(`合并后超过 ${LIMITS.entryBytes} 字：只写这次新增的要点，或先归档旧条目`);
   const record = {
     id,
-    title,
+    title: existing ? existing.title : when ? `${title}｜${when}`.slice(0, LIMITS.titleChars) : title,
+    when,
     summary: summary.text,
     kind: draft.kind || 'note',
     tags: Array.isArray(draft.tags) ? draft.tags.map((tag) => normalizeText(tag, 20)).filter(Boolean).slice(0, 5) : [],
@@ -164,15 +223,15 @@ export function upsert(scope, draft) {
     lastUsed: now,
     hits: existing ? existing.hits || 0 : 0,
     merges: existing ? (existing.merges || 0) + 1 : 0,
-    bytes: Buffer.byteLength(body, 'utf8'),
+    bytes: Buffer.byteLength(mergedBody, 'utf8'),
   };
-  writeAtomic(entryFile(scope, id), body);
+  writeAtomic(entryFile(scope, id), mergedBody);
   if (existing) index.entries = index.entries.map((item) => (item.id === id ? record : item));
   else index.entries.push(record);
   index.suggestions = (index.suggestions || []).filter((item) => item.title !== title).slice(-19);
   trimIndex(scope, index);
   saveIndex(scope, index);
-  return { record, merged: Boolean(existing) };
+  return { record, merged: Boolean(existing), mergedFrom: existing && existing.title !== title ? existing.title : null };
 }
 
 export function search(scope, query, limit = 4) {
@@ -182,7 +241,7 @@ export function search(scope, query, limit = 4) {
     .split(/[^\p{L}\p{N}]+/u)
     .filter((word) => word.length > 1);
   const scored = index.entries.map((item) => {
-    const hay = `${item.title} ${item.summary} ${(item.tags || []).join(' ')}`.toLowerCase();
+    const hay = `${item.title} ${item.summary} ${item.when || ''} ${(item.tags || []).join(' ')}`.toLowerCase();
     let score = 0;
     for (const term of terms) if (hay.includes(term)) score += term.length > 2 ? 2 : 1;
     if (terms.length > 0 && score === 0) score = similarity(item.title, query) > 0.5 ? 1 : 0;
@@ -267,7 +326,8 @@ export function renderIndex(entries, budget = 400) {
   for (const item of entries) {
     const last = Date.parse(item.lastUsed || item.updated || item.created || '') || now;
     const stale = now - last > staleMs;
-    const line = stale ? `- ${item.id} ${item.title}` : `- ${item.id} ${item.title}｜${item.summary}`;
+    const head = item.when ? `${item.title}（${item.when}）` : item.title;
+    const line = stale ? `- ${item.id} ${head}` : `- ${item.id} ${head}｜${item.summary}`;
     if (used + line.length > budget) break;
     lines.push(line);
     used += line.length + 1;

package/test/store.test.mjs

@@ -63,3 +63,41 @@ assert.ok(trimmed.totalBytes <= store.LIMITS.totalBytes);
 
 fs.rmSync(home, { recursive: true, force: true });
 console.log('store: 16 checks passed');
+
+// 同一主题换个说法：合并，不新增。
+const mergeScope = store.scopeOf('/tmp/project-merge');
+store.upsert(mergeScope, { title: '插件市场条目规范', summary: '市场上传指南的位置与要点', body: '见 UPLOAD-GUIDE.md' });
+const paraphrase = store.upsert(mergeScope, { title: '插件市场条目规范（改写）', summary: '市场上传指南的位置与要点', body: '见 UPLOAD-GUIDE.md#第二节' });
+assert.equal(paraphrase.merged, true);
+assert.equal(paraphrase.mergedFrom, '插件市场条目规范');
+assert.equal(store.loadIndex(mergeScope).entries.length, 1);
+
+// 同一项目下的另一件事：不合并。
+const sibling = store.upsert(mergeScope, { title: '插件市场踩坑清单', summary: '卡片不刷新与抓取失败的已知原因', body: 'y' });
+assert.equal(sibling.merged, false);
+assert.equal(store.loadIndex(mergeScope).entries.length, 2);
+
+console.log('store: merge rules ok');
+
+// 前置条件不同 → 两条，哪怕标题一样。
+const mac = store.upsert(mergeScope, { title: '构建耗时长', summary: '本机构建要几分钟', when: 'macOS 本地', body: '- 原因：磁盘加密' });
+const ci = store.upsert(mergeScope, { title: '构建耗时长', summary: '本机构建要几分钟', when: 'CI 容器', body: '- 原因：冷缓存' });
+assert.equal(mac.merged, false);
+assert.equal(ci.merged, false);
+assert.notEqual(ci.record.id, mac.record.id);
+assert.equal(store.loadIndex(mergeScope).entries.filter((item) => item.title.startsWith('构建耗时长')).length, 2);
+
+// 同一前置条件下合并：旧要点保留，同键覆盖。
+const plus = store.upsert(mergeScope, { title: '构建耗时长', summary: '本机构建要几分钟', when: 'macOS 本地', body: '- 绕过：先跑 cache\n- 原因：磁盘加密拖慢' });
+assert.equal(plus.merged, true);
+assert.equal(plus.record.id, mac.record.id);
+const body = store.readEntry(mergeScope, mac.record.id).body;
+assert.match(body, /绕过/);
+assert.match(body, /磁盘加密拖慢/);
+assert.equal(body.includes('磁盘加密\n'), false);
+
+// 前置条件参与检索。
+const hit = store.search(mergeScope, 'CI 容器');
+assert.ok(hit.some((item) => item.id === ci.record.id));
+
+console.log('store: precondition rules ok');