@modusensus/dsh-mneme 0.8.6 → 0.8.8

package/test/client.test.js

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync, existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const clientSource = readFileSync(join(root, "lib/client.js"), "utf8");
@@ -25,6 +26,15 @@ test("client bundle is lib-only with no src counterpart", () => {
   assert.equal(existsSync(join(root, "lib/client.js")), true, "lib/client.js must exist");
 });
 
+// 归档侧第五指标（#275）自己按「归档区为空就整段省略」门控，但整卡还有一道 hasData 门：
+// 那道门只认召回回执与活跃僵尸行时，「全归档 + 窗口内无回执」的库会直接 return null，
+// 指标永远不显示（自动评审 #312 指出的回归）。这里锁死 hasData 必须把 archive.total 计进来。
+test("status card: hasData counts the archive metric", () => {
+  const m = clientSource.match(/const hasData =[^;]+;/);
+  assert.ok(m, "the status card must declare hasData");
+  assert.match(m[0], /d\.archive\?\.total/, "hasData must count archive.total, not just runs/active rows");
+});
+
 // The memory entry lives at the sidebar foot, not in the settings modal: the
 // migration must register into `sidebar.footer.action` (the list slot the
 // sidebar shell renders beside Settings) and must not keep a `settings.section`
@@ -208,8 +218,8 @@ test("entry tracks native class, inherits native sizing, and lifts the toolbar d
     "the entry must use the native button width, which reserves its horizontal margins"
   );
   assert.ok(
-    clientSource.includes(".mneme-topentry{display:flex;flex-direction:column}"),
-    "the entry wrapper must stretch the native button within a column flex layout"
+    clientSource.includes(".mneme-topentry{display:flex;flex-direction:column;position:relative}"),
+    "the entry wrapper must stretch the native button within a column flex layout (position:relative hosts the #177 badge)"
   );
   assert.equal(
     clientSource.includes(".mneme-topentry-native .mneme-topentry-label{flex:1;min-width:0;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}"),
@@ -313,6 +323,35 @@ test("graph toggle uses a node-graph glyph, not the share icon", () => {
   );
 });
 
+// #287 跨代图标守卫：primitives 在 0.1.7 把归档图标从「像素后缀」改名成「字重后缀」
+// （IconArchiveOutline20 → …OutlineRegular / …OutlineMedium），旧名不留别名，而
+// peerDependencies 仍同时覆盖 0.1.6 与 0.1.7 两代宿主。只认某一代的名字，另一代就会
+// 把 undefined 交给 h()，落成 slot entry 里的 React #130（该 entry 整块崩），因此必须
+// 探测两代名字、并在全缺时降级为不渲染图标。
+test("#287: archive glyph probes both naming generations and degrades to no glyph", () => {
+  assert.ok(
+    /primitives\.IconArchiveOutline20\s*\?\?\s*primitives\.IconArchiveOutlineRegular\s*\?\?\s*primitives\.IconArchiveOutlineMedium/.test(clientSource),
+    "the glyph must probe the 0.1.6 pixel name before the 0.1.7 weight names"
+  );
+  assert.equal(
+    /h\(IconArchiveOutline20/.test(clientSource),
+    false,
+    "the raw constant must never reach h() — on a host lacking that name it renders undefined (React #130)"
+  );
+  assert.ok(
+    /const renderArchiveIcon = \(props\) => \(IconArchive \? h\(IconArchive, props\) : null\)/.test(clientSource),
+    "the glyph must render through a null-guarded helper so a missing icon degrades to nothing"
+  );
+  for (const site of [
+    "renderArchiveIcon({ size: 15 })",              // 浮层标题栏
+    "renderArchiveIcon({ size: wide ? 16 : 18 })",  // 侧栏 trigger
+    "renderArchiveIcon({ size: wide ? 15 : 18 })",  // portal 到宿主原生侧栏的入口
+    "renderArchiveIcon({ size })"                   // better-sidebar tab 图标
+  ]) {
+    assert.ok(clientSource.includes(site), `every render site must go through the helper: ${site}`);
+  }
+});
+
 // 方案 A：查询收敛。状态页只做仪表盘（小页预览 + 服务端 total + 查看全部），
 // 沉淀/归档的完整浏览走记忆库的 deposited/archived 筛选视图（chip 预置 +
 // 状态页入口跳转），详情抽屉给归档记忆一个反向的「恢复」。
@@ -665,7 +704,7 @@ test("settings feedback card: prefilled issue + mailto + browse, version from /i
   );
   // 2. GitHub 新建 issue：issues/new?title=&body= 预填环境信息（当前仓库无模板）
   assert.ok(
-    clientSource.includes("https://github.com/slow-stack/dsh-mneme/issues/new?title="),
+    clientSource.includes("https://github.com/slow-stack/mneme/issues/new?title="),
     "the issue link must prefill title+body on issues/new"
   );
   assert.ok(
@@ -679,7 +718,7 @@ test("settings feedback card: prefilled issue + mailto + browse, version from /i
   );
   // 4. 浏览已知问题：跳仓库 issues 列表页（去重前置步骤）
   assert.ok(
-    clientSource.includes('href: "https://github.com/slow-stack/dsh-mneme/issues"'),
+    clientSource.includes('href: "https://github.com/slow-stack/mneme/issues"'),
     "the browse link must open the repo issues list"
   );
   // 5. 双语 i18n
@@ -844,8 +883,55 @@ test("a11y: entity graph svg exposes a count summary", () => {
   }
 });
 
-// --- issue #179：注入预览（状态页卡片 + /inject-preview 端点透传的旁路快照） ---
+// --- issue #177：冲突队列交互与视觉重做 ---
 
+// 相似度进度条：只从「相似度 X / similarity X」锚定短语回收数字（防把年份当
+// 相似度），A/B 卡片带侧色类，冻结徽章替代预裁决阶段的「已归档」徽章。
+test("conflict queue: similarity bar, side colors and frozen badge", () => {
+  assert.ok(clientSource.includes("similarityOf(it.reason)"), "reason must be parsed for similarity");
+  assert.ok(clientSource.includes("/(?:相似度|similarity)\\s*([01](?:\\.\\d+)?)/i"), "parse must anchor on the similarity phrase");
+  for (const key of ["memory.status.conflictQueue.similarity", "memory.status.conflictQueue.frozenBadge"]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(clientSource.includes('"mneme-conflict-side--a"'), "side A must carry the A color class");
+  assert.ok(clientSource.includes('"mneme-conflict-side--b"'), "side B must carry the B color class");
+  assert.ok(!/s\.archived && h\("span", \{ className: "mneme-badge mneme-badge--archived"/.test(clientSource),
+    "the pre-ruling archived badge must be replaced by the frozen badge");
+  assert.ok(clientSource.includes("mneme-badge--frozen"), "frozen badge class must exist");
+});
+
+// 词级 diff：LCS 对齐是纯函数，锁它的存在、上限护栏与渲染接线（无损性由
+// difftest 独立验证，此处只锁形状）。
+test("conflict queue: word diff is wired with size guards", () => {
+  assert.ok(clientSource.includes("function wordDiff(aText, bText)"), "wordDiff must exist");
+  assert.ok(clientSource.includes("mneme-conflict-mark--del"), "del highlight class must exist");
+  assert.ok(clientSource.includes("mneme-conflict-mark--ins"), "ins highlight class must exist");
+  assert.ok(clientSource.includes("n > 800 || m > 800"), "DP must bail on oversized inputs");
+});
+
+// 空态教育卡：0 冲突时也渲染（原来整块 return null），解释冻结是什么。
+test("conflict queue: empty-state explainer card", () => {
+  assert.ok(!/if \(!items \|\| items\.length === 0\) return null;/.test(clientSource),
+    "empty queue must render the explainer instead of nothing");
+  for (const key of ["memory.status.conflictQueue.emptyTitle", "memory.status.conflictQueue.emptyBody"]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+});
+
+// 状态卡待处理高亮 + 侧边栏入口 badge（挂 portal 与回退两个按钮）。
+test("conflict queue: actionable status card and sidebar entry badge", () => {
+  assert.ok(clientSource.includes('"mneme-conflict-jump"'), "pending>0 card must carry the highlight class");
+  assert.ok(clientSource.includes("mneme-statuscard--actionable"), "highlight CSS must exist");
+  assert.ok((clientSource.match(/h\(ConflictBadge, \{ pending \}\)/g) || []).length === 2,
+    "badge must be wired into both entry buttons");
+  assert.ok((clientSource.match(/= useConflictBadgeCount\(t\)/g) || []).length === 2,
+    "both entry components must subscribe to the badge count");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/dream-status"'), "badge must reuse the dream-status endpoint");
+});
+
+// --- issue #179：注入预览（状态页卡片 + /inject-preview 端点透传的旁路快照） ---
 test("a11y+preview: inject preview card is wired on the status tab", () => {
   assert.ok(clientSource.includes('"/api/dsh-mneme/inject-preview"'), "card must fetch the preview endpoint");
   assert.ok(clientSource.includes("h(InjectPreviewCard, { t })"), "status grid must render the preview card");
@@ -858,4 +944,15 @@ test("a11y+preview: inject preview card is wired on the status tab", () => {
     const occurrences = clientSource.split(`"${key}"`).length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
-});
+});
+// 面板 bundle 在本文件里只被当**文本**读（上面的断言全是正则/字符串包含），
+// 而仓库的 CI 里没有任何一步**解析**它：于是重复声明这类语法错误能一路绿灯进
+// 主干，后果却是整个面板加载失败（__ModuleLoader__ 拿到的模块一执行就抛
+// SyntaxError）。lib/client.js 无 src 对应物、不参与 sync，也就没有别的闸门
+// 覆盖它——这里补一道解析闸（PR #320 rebase 时真实踩到：与上游新增的
+// summarizeSub 撞名，node --check 报 "Identifier 'summarizeSub' has already
+// been declared"，而当时 CI 全绿）。
+test("client bundle parses: 面板产物必须是合法 JS（无重复声明等语法错误）", () => {
+  const result = spawnSync(process.execPath, ["--check", join(root, "lib/client.js")], { encoding: "utf8" });
+  assert.equal(result.status, 0, `lib/client.js 解析失败：\n${result.stderr || result.stdout}`);
+});

package/test/content-hash.test.js

@@ -0,0 +1,204 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createStore } from "../src/store.js";
+import { contentHashOf, normalizeForHash } from "../src/content-hash.js";
+
+// #254 内容哈希（写入准入的确定性计量锚）。
+// 这批用例锁三件事：归一化口径（只差格式不算两次）、派生列随内容走（insert/update/
+// CAS 三处都得重算，漏一处标记就在说谎）、以及老库打开时的迁移顺序（索引必须在加列
+// 之后建，否则 exec(SCHEMA) 直接报 no such column，插件整树加载失败）。
+
+test("归一化口径：大小写/空白/标点/全角差异落在同一个键上", () => {
+  assert.equal(normalizeForHash("Hello,  World!\n"), "hello world");
+  assert.equal(normalizeForHash("ｈｅｌｌｏ　ｗｏｒｌｄ"), "hello world", "NFKC 折全角");
+  assert.equal(
+    contentHashOf({ title: "Task A", content: "Line1.\n\nLine2" }),
+    contentHashOf({ title: "task a", content: "line1 line2" })
+  );
+  // 分隔符防拼接歧义：('ab','c') 与 ('a','bc') 不能同键
+  assert.notEqual(contentHashOf({ title: "ab", content: "c" }), contentHashOf({ title: "a", content: "bc" }));
+  assert.notEqual(contentHashOf({ title: "t", content: "同一件事" }), contentHashOf({ title: "t", content: "另一件事" }));
+});
+
+test("归一化口径：同义词与词序不折叠（哈希只认逐字节相同）", () => {
+  assert.notEqual(contentHashOf({ title: "t", content: "a b" }), contentHashOf({ title: "t", content: "b a" }));
+});
+
+test("已知等价类：去标点让 3.5 与 35 同键（口径选择的结果，不是判据出错）", () => {
+  // 这条把「已知会误报」的样子钉住，防止有人把文件头的「命中即精确重复」当承诺、
+  // 进而以为这是个 bug 去改归一化——改口径要带存量重算（见 content-hash.js 文件头）。
+  assert.equal(contentHashOf({ title: "t", content: "版本 3.5" }), contentHashOf({ title: "t", content: "版本 35" }));
+  assert.equal(contentHashOf({ title: "t", content: "a-b" }), contentHashOf({ title: "t", content: "ab" }));
+  // 但数字本身没被折叠：不同数值不落同一键
+  assert.notEqual(contentHashOf({ title: "t", content: "3.5" }), contentHashOf({ title: "t", content: "3.6" }));
+});
+
+test("空标题空正文没有可比内容 → null（不互相匹配成「全是重复」）", () => {
+  assert.equal(contentHashOf({ title: "", content: "" }), null);
+  assert.equal(contentHashOf({ title: "   ", content: "\n\t" }), null);
+  assert.equal(contentHashOf({}), null);
+  assert.ok(contentHashOf({ title: "只有标题" }));
+});
+
+test("save 落 content_hash，findContentHashMatches 按 type + scope 收窄", () => {
+  const store = createStore(":memory:");
+  const a = store.save({ type: "project", title: "同一件事", content: "正文", agent_scope: "A" });
+  assert.equal(a.content_hash, contentHashOf({ title: "同一件事", content: "正文" }));
+
+  const sameScope = store.findContentHashMatches({ type: "project", hash: a.content_hash, agent_scope: "A" });
+  assert.deepEqual(sameScope.map((m) => m.id), [a.id]);
+
+  // 跨 scope 永不互判（与 saveWithDedupe 的三维去重键同口径）
+  const otherScope = store.findContentHashMatches({ type: "project", hash: a.content_hash, agent_scope: "B" });
+  assert.equal(otherScope.length, 0);
+  const unannotated = store.findContentHashMatches({ type: "project", hash: a.content_hash });
+  assert.equal(unannotated.length, 0, "已标注行不与未标注行匹配");
+
+  // 入参先按 store 自己的口径归一，免得调用方传 " A " 就漏配
+  assert.equal(store.findContentHashMatches({ type: "project", hash: a.content_hash, agent_scope: " A " }).length, 1);
+  // type 不同不互判
+  assert.equal(store.findContentHashMatches({ type: "preference", hash: a.content_hash, agent_scope: "A" }).length, 0);
+  store.close();
+});
+
+test("归档行在候选集内（#275 分界：出口止体积、不止重复）", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "project", title: "被归档的事实", content: "同样的正文" });
+  store.setArchived(saved.id, true);
+  const hits = store.findContentHashMatches({ type: "project", hash: saved.content_hash });
+  assert.deepEqual(hits, [{ id: saved.id, archived: true, forgotten: false }]);
+  store.close();
+});
+
+test("同键命中超过窗口宽度时，活跃行仍在窗口内（归档动作会顶 updated_at）", () => {
+  // 回归（自动评审 #311 store.js:1055）：LIMIT 先于调用方的「活区优先」执行。若只按
+  // updated_at 倒序，第 11 条起写下的归档行会把更早的活跃行挤出窗口，调用方只能看见
+  // 归档命中，把「活跃重复」错记成「归档重复」——正是 dup 信号要分流的两类。
+  const store = createStore(":memory:");
+  const live = store.save({ type: "project", title: "窗口内", content: "同一段正文" });
+  assert.ok(live.content_hash, "写入即落 content_hash");
+  const sinks = [];
+  for (let i = 0; i < 10; i++) {
+    sinks.push(store.save({ type: "project", title: "窗口内", content: "同一段正文" }));
+  }
+  for (const row of sinks) store.setArchived(row.id, true);
+  const hits = store.findContentHashMatches({ type: "project", hash: live.content_hash });
+  assert.equal(hits.length, 10, "窗口宽度不变");
+  assert.deepEqual(hits[0], { id: live.id, archived: false, forgotten: false });
+  store.close();
+});
+
+test("update 与 compareAndUpdate 都重算 content_hash", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "project", title: "T", content: "旧正文" });
+  assert.equal(store.findContentHashMatches({ type: "project", hash: contentHashOf({ title: "T", content: "旧正文" }) }).length, 1);
+
+  const updated = store.update(saved.id, { content: "新正文" });
+  assert.equal(updated.content_hash, contentHashOf({ title: "T", content: "新正文" }));
+  assert.equal(
+    store.findContentHashMatches({ type: "project", hash: contentHashOf({ title: "T", content: "旧正文" }) }).length,
+    0,
+    "旧内容的锚必须失效"
+  );
+
+  const cas = store.compareAndUpdate(updated.id, updated.updated_at, { title: "T2" });
+  assert.equal(cas.content_hash, contentHashOf({ title: "T2", content: "新正文" }));
+  assert.equal(
+    store.findContentHashMatches({ type: "project", hash: contentHashOf({ title: "T", content: "新正文" }) }).length,
+    0,
+    "CAS 路径漏重算的话标记会指向不再存在的内容"
+  );
+  store.close();
+});
+
+test("demoteToSummary 与 restoreContent 也重算 content_hash", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "project", title: "T", content: "完整正文" });
+  const demoted = store.demoteToSummary(saved.id, "摘要行");
+  assert.equal(demoted.content_hash, contentHashOf({ title: "T", content: "摘要行" }));
+  assert.equal(
+    store.findContentHashMatches({ type: "project", hash: contentHashOf({ title: "T", content: "完整正文" }) }).length,
+    0,
+    "降级后的行装的是摘要，锚不能还指着完整正文"
+  );
+
+  const restored = store.restoreContent(saved.id);
+  assert.equal(restored.content_hash, contentHashOf({ title: "T", content: "完整正文" }));
+  store.close();
+});
+
+test("老库打开：加列 + 建索引 + 存量回填（索引顺序错会直接开不起来）", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-hash-migrate-"));
+  const dbPath = join(dir, "legacy.db");
+  try {
+    const legacy = new DatabaseSync(dbPath);
+    legacy.exec(`CREATE TABLE memories (
+      id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL,
+      tags TEXT NOT NULL DEFAULT '[]', importance INTEGER NOT NULL DEFAULT 3,
+      forgotten INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0,
+      source TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+    );`);
+    legacy
+      .prepare(
+        "INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, created_at, updated_at) VALUES (?, ?, ?, ?, '[]', 3, 0, ?, NULL, ?, ?)"
+      )
+      .run("legacy-1", "project", "老库事实", "同一件事的正文", 0, "2026-01-01T00:00:00.000Z", "2026-01-01T00:00:00.000Z");
+    legacy
+      .prepare(
+        "INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, created_at, updated_at) VALUES (?, ?, ?, ?, '[]', 3, 0, ?, NULL, ?, ?)"
+      )
+      .run("legacy-2", "project", "被归档的老事实", "归档区里同一件事的正文", 1, "2026-01-02T00:00:00.000Z", "2026-01-02T00:00:00.000Z");
+    legacy.close();
+
+    const store = createStore(dbPath);
+    const index = store.db
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_memories_content_hash'")
+      .get();
+    assert.ok(index, "老库也要建上索引（候选集靠它 seek，否则每次写入都是全表扫）");
+
+    // 索引不只是「存在」：回填的 NULL 扫描与准入的候选集查询都得真的走它。列序写反
+    // （type 打头）时前者退化成全表扫——每次打开都要把全部正文读一遍。
+    const planOf = (sql, ...params) =>
+      store.db.prepare(`EXPLAIN QUERY PLAN ${sql}`).all(...params).map((r) => r.detail).join(" | ");
+    assert.match(
+      planOf("SELECT id, title, content FROM memories WHERE content_hash IS NULL"),
+      /idx_memories_content_hash/,
+      "存量回填走索引"
+    );
+    assert.match(
+      planOf("SELECT id FROM memories WHERE type = ? AND content_hash = ?", "project", "x"),
+      /idx_memories_content_hash/,
+      "候选集查询走索引"
+    );
+
+    const backfilled = store.getById("legacy-1");
+    assert.equal(backfilled.content_hash, contentHashOf({ title: "老库事实", content: "同一件事的正文" }));
+    assert.deepEqual(
+      store.findContentHashMatches({ type: "project", hash: backfilled.content_hash }).map((m) => m.id),
+      ["legacy-1"]
+    );
+    const archivedBackfilled = store.getById("legacy-2");
+    assert.deepEqual(
+      store.findContentHashMatches({ type: "project", hash: archivedBackfilled.content_hash }),
+      [{ id: "legacy-2", archived: true, forgotten: false }],
+      "存量归档行回填后也要在候选集里（不然这条信号在老库上量不到归档区）"
+    );
+
+    // 回填后仍能正常写入（幂等迁移没有把表锁死）
+    const fresh = store.save({ type: "project", title: "新行", content: "新正文" });
+    assert.ok(fresh.content_hash);
+    const firstPassHash = archivedBackfilled.content_hash;
+    store.close();
+
+    // 再开一次：只算 NULL 行，已有锚原样保留
+    const again = createStore(dbPath);
+    assert.equal(again.getById("legacy-2").content_hash, firstPassHash, "重复打开不得改写已有锚");
+    again.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});