From ec77a1ccd9691a2ccd69c8e84071900f5f84c721 Mon Sep 17 00:00:00 2001 From: modusensus Date: Wed, 18 Nov 2026 00:44:45 +0800 Subject: [PATCH 1/2] =?UTF-8?q?feat(panel):=20=E6=83=85=E7=BB=AA=E9=A1=B5?= =?UTF-8?q?=E6=8E=A5=E4=BD=8F=E5=90=8E=E7=AB=AF=E5=B7=B2=E7=BB=99=E7=9A=84?= =?UTF-8?q?=E5=AD=97=E5=8F=B7=E2=80=94=E2=80=94why/=E9=99=8D=E7=BA=A7?= =?UTF-8?q?=E7=95=99=E7=97=95/=E5=90=91=E6=80=A7/=E5=8E=9F=E8=AF=8D/?= =?UTF-8?q?=E7=BF=BB=E9=A1=B5/=E8=BF=87=E6=BB=A4/=E8=B4=A6=E6=9C=AC?= =?UTF-8?q?=E6=98=8E=E7=BB=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit #729/#732/#733/#734 合并后,GET 聚合端点已经在给 why、downgradedFrom、valence、 originals、firstSeen、next 游标与 person/emotion 过滤参数,账本行也一直带着 before/after 摘要——前端一个都没消费,「数据在、界面没显示」。本次全部上页面: - why 上行(两行截断、全文进 title);downgradedFrom 降级徽标摆在主行 (曾按倾向记后降回场合,是信任信号不藏 meta) - valence 与归一组原词进 meta:措辞漂移被归并这件事要可见 - 首页就按游标模式取(cursor 恒参、边帽放宽到 4×limit),主列表与归档区 各自「加载更多」;有游标可翻时截断提示让位,两句不同屏 - person/emotion 过滤:Enter 生效、草稿与生效态分开、一键清除;过滤下的 空态有自己的文案,不冒充「库里还没有情绪边」 - 账本行读 before/after:改词显示词面变化,其余四类显示档位/归档态迁移 几何全走 --mneme-space/type/radius 刻度(px 棘轮零增量,降级徽标组合 mneme-affective-emotion 复用已登记的 1px pill 边框);新增回归测试锁五个 字段的渲染形状、游标首页模式、过滤空态分话与账本 delta。 --- dsh-mneme/lib/client.js | 238 ++++++++++++++++++++++++++++++---- dsh-mneme/test/client.test.js | 57 ++++++++ 2 files changed, 270 insertions(+), 25 deletions(-) diff --git a/dsh-mneme/lib/client.js b/dsh-mneme/lib/client.js index 159f56b0..0e4b8b30 100644 --- a/dsh-mneme/lib/client.js +++ b/dsh-mneme/lib/client.js @@ -714,6 +714,23 @@ window.__ModuleLoader__.load({ "memory.affective.archiveEmpty": "归档区是空的。", "memory.affective.journalTitle": "最近变更", "memory.affective.journalEmpty": "还没有人工修正记录。", + "memory.affective.whyHint": "记下这条的缘由(取最新一次)", + "memory.affective.downgraded": "曾按稳定倾向记,后降回场合", + "memory.affective.valence": "向性 {v}", + "memory.affective.valencePositive": "正", + "memory.affective.valenceNegative": "负", + "memory.affective.valenceNeutral": "中性", + "memory.affective.originals": "也叫 {names}", + "memory.affective.firstSeen": "首次 {time}", + "memory.affective.loadMore": "加载更多", + "memory.affective.moreFailed": "没取到下一页:{error}。列表没变,可直接重试。", + "memory.affective.filterPerson": "按人过滤(名字)", + "memory.affective.filterEmotion": "按情绪词过滤", + "memory.affective.filterClear": "清除过滤", + "memory.affective.filtering": "过滤中:{cond}", + "memory.affective.emptyFiltered": "没有匹配过滤条件的情绪边。清掉过滤再看看。", + "memory.affective.journalActive": "活跃", + "memory.affective.journalArchived": "已归档", "memory.graph.title": "记忆图谱", "memory.graph.aria": "记忆图谱", "memory.graph.placeholder": "输入实体名,查看关联网络…", @@ -1940,6 +1957,23 @@ window.__ModuleLoader__.load({ "memory.affective.archiveEmpty": "The archive is empty.", "memory.affective.journalTitle": "Recent changes", "memory.affective.journalEmpty": "No manual corrections yet.", + "memory.affective.whyHint": "Why this was recorded (latest entry)", + "memory.affective.downgraded": "Once recorded as a lasting tendency, later downgraded to occasion", + "memory.affective.valence": "valence {v}", + "memory.affective.valencePositive": "positive", + "memory.affective.valenceNegative": "negative", + "memory.affective.valenceNeutral": "neutral", + "memory.affective.originals": "also seen as {names}", + "memory.affective.firstSeen": "first {time}", + "memory.affective.loadMore": "Load more", + "memory.affective.moreFailed": "Could not load the next page: {error}. The list is unchanged; retry right away.", + "memory.affective.filterPerson": "Filter by person (name)", + "memory.affective.filterEmotion": "Filter by emotion", + "memory.affective.filterClear": "Clear filters", + "memory.affective.filtering": "Filtered by {cond}", + "memory.affective.emptyFiltered": "No affective edges match the filters. Clear them to see everything.", + "memory.affective.journalActive": "active", + "memory.affective.journalArchived": "archived", "memory.graph.title": "Memory Graph", "memory.graph.aria": "Memory graph", "memory.graph.placeholder": "Type an entity name to see its network…", @@ -3097,6 +3131,13 @@ window.__ModuleLoader__.load({ ".mneme-affective-archlist{display:flex;flex-direction:column;gap:var(--mneme-space-6)}", ".mneme-affective-journal{display:flex;flex-direction:column;gap:var(--mneme-space-4)}", ".mneme-affective-journalrow{display:flex;align-items:baseline;gap:var(--mneme-space-6);font-size:var(--mneme-type-12);line-height:1.5;color:var(--mneme-fg-dim);font-variant-numeric:tabular-nums}", + // #726/#723/#724 的字段落页面:why 引文(两行截断、全文在 title)、降级徽标、 + // 过滤栏、加载更多。几何全走刻度,不进 px 棘轮。 + ".mneme-affective-why{font-size:var(--mneme-type-12);color:var(--mneme-fg-dim);margin-top:var(--mneme-space-4);line-height:1.5;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;word-break:break-word}", + ".mneme-affective-flag{font-size:var(--mneme-type-12);font-weight:400;color:var(--mneme-fg-dim)}", + ".mneme-affective-filterbar{display:flex;align-items:center;gap:var(--mneme-space-6);flex-wrap:wrap;margin-top:var(--mneme-space-8)}", + ".mneme-affective-filterbar .mneme-set-input{flex:1;min-width:0;margin-bottom:0}", + ".mneme-affective-more{display:flex;flex-direction:column;align-items:center;gap:var(--mneme-space-4);margin-top:var(--mneme-space-8)}", ".mneme-gs-affective{margin-top:2px}", // issue #24 块4 复核面:抬过的边。用虚线边色(--mneme-graphic-dim 同层) // 而不是新增颜色——它表达的是「同一条边,只是被用过」,不是新类别。 @@ -8551,51 +8592,69 @@ window.__ModuleLoader__.load({ return (hash % 5) + 1; } function AffectivePanel({ t }) { - const [state, setState] = useState({ loading: true, error: false, items: [], totalEdges: 0, skippedEdges: 0, truncated: false, archivedEdges: 0 }); + const [state, setState] = useState({ loading: true, error: false, items: [], totalEdges: 0, skippedEdges: 0, truncated: false, archivedEdges: 0, next: null }); + // #729 的过滤与游标翻页此前只到 API 层,页面上没人用。过滤收两个词 + // (人名 / 情绪词):草稿态与生效态分开,Enter 才生效,敲字不重取。 + const [filters, setFilters] = useState({ person: "", emotion: "" }); + const [filterDraft, setFilterDraft] = useState({ person: "", emotion: "" }); // #725:人工修正(apply)与它的可见性。纪律与 #497 复制回执同款——失败必须 // 看得见、逐边失败如实摆出,绝不把失败装成成功。 const [applyBusy, setApplyBusy] = useState(null); const [applyError, setApplyError] = useState(""); const [renaming, setRenaming] = useState(null); // { key, value }:行内改词 const [archOpen, setArchOpen] = useState(false); - const [archived, setArchived] = useState(null); // null=没读;数组=归档组 + const [archived, setArchived] = useState(null); // null=没读;{ items, next }=归档组与游标 const [journal, setJournal] = useState([]); const [reloadTick, setReloadTick] = useState(0); + const [moreBusy, setMoreBusy] = useState(false); + const [moreError, setMoreError] = useState(""); + // 请求串。cursor 恒参(空串=从头翻第一页):#729 的游标模式把边帽放宽到 + // 4×limit,首页就按这个模式取,超过一页的组才有 next 可翻;旧客户端不带的 + // 请求边帽=limit,组数永远到不了帽,next 永远是 null——那是翻不出第二页的。 + const affectiveUrl = (opts = {}) => { + const q = new URLSearchParams({ limit: "200", cursor: opts.cursor ?? "" }); + if (opts.archived) q.set("archived", "1"); + if (opts.person) q.set("person", opts.person); + if (opts.emotion) q.set("emotion", opts.emotion); + return "/api/dsh-mneme/semantic/graph/affective?" + q.toString(); + }; + const pickState = (j) => ({ + loading: false, + error: false, + items: Array.isArray(j.items) ? j.items : [], + totalEdges: j.totalEdges || 0, + skippedEdges: j.skippedEdges || 0, + truncated: j.truncated === true, + archivedEdges: j.archivedEdges || 0, + next: typeof j.next === "string" && j.next ? j.next : null + }); useEffect(() => { let cancelled = false; - apiFetch("/api/dsh-mneme/semantic/graph/affective?limit=200") + setState((s) => ({ ...s, loading: true, error: false })); + apiFetch(affectiveUrl({ person: filters.person, emotion: filters.emotion })) .then((res) => { if (!res.ok) throw new Error(`http ${res.status}`); return res.json(); }) .then((j) => { - if (cancelled) return; - setState({ - loading: false, - error: false, - items: Array.isArray(j.items) ? j.items : [], - totalEdges: j.totalEdges || 0, - skippedEdges: j.skippedEdges || 0, - truncated: j.truncated === true, - archivedEdges: j.archivedEdges || 0 - }); + if (!cancelled) setState(pickState(j)); }) .catch(() => { // 失败就报失败。这里绝不能退化成空 items —— 那会让「上游挂了」 // 长得和「你还没记过情绪」一模一样,用户会以为功能没用。 - if (!cancelled) setState({ loading: true, error: true, items: [], totalEdges: 0, skippedEdges: 0, truncated: false, archivedEdges: 0 }); + if (!cancelled) setState({ loading: true, error: true, items: [], totalEdges: 0, skippedEdges: 0, truncated: false, archivedEdges: 0, next: null }); }); return () => { cancelled = true; }; - }, [reloadTick]); + }, [reloadTick, filters]); // #725:归档区与账本各自读各自的。归档区只在展开时读——收起不挂载请求, // 与状态页折叠区同一信号语义(展开才是「我要看」的明确表态)。 useEffect(() => { if (!archOpen) return; let cancelled = false; - apiFetch("/api/dsh-mneme/semantic/graph/affective?archived=1&limit=200") + apiFetch(affectiveUrl({ archived: true })) .then((res) => { if (!res.ok) throw new Error(`http ${res.status}`); return res.json(); }) - .then((j) => { if (!cancelled) setArchived(Array.isArray(j.items) ? j.items : []); }) - .catch(() => { if (!cancelled) setArchived([]); }); + .then((j) => { if (!cancelled) setArchived({ items: Array.isArray(j.items) ? j.items : [], next: typeof j.next === "string" && j.next ? j.next : null }); }) + .catch(() => { if (!cancelled) setArchived({ items: [], next: null }); }); return () => { cancelled = true; }; }, [archOpen, reloadTick]); useEffect(() => { @@ -8633,6 +8692,46 @@ window.__ModuleLoader__.load({ } }; + // #729 翻页:主列表与归档区各自翻各自的。追加保序(响应顺序即聚合顺序), + // next 取响应里的新游标;失败如实报出(列表没变),绝不把失败装成「没了」。 + const loadMoreMain = async () => { + if (!state.next || moreBusy) return; + setMoreBusy(true); + setMoreError(""); + try { + const res = await apiFetch(affectiveUrl({ cursor: state.next, person: filters.person, emotion: filters.emotion })); + const body = await res.json().catch(() => null); + if (!res.ok) throw new Error(body?.error || `http ${res.status}`); + const page = pickState(body); + setState((s) => ({ ...s, items: s.items.concat(page.items), totalEdges: page.totalEdges, truncated: page.truncated, next: page.next })); + } catch (err) { + setMoreError(t("memory.affective.moreFailed").replace("{error}", String(err?.message ?? err))); + } finally { + setMoreBusy(false); + } + }; + const [archMoreBusy, setArchMoreBusy] = useState(false); + const [archMoreError, setArchMoreError] = useState(""); + const loadMoreArchived = async () => { + if (!archived?.next || archMoreBusy) return; + setArchMoreBusy(true); + setArchMoreError(""); + try { + const res = await apiFetch(affectiveUrl({ archived: true, cursor: archived.next })); + const body = await res.json().catch(() => null); + if (!res.ok) throw new Error(body?.error || `http ${res.status}`); + const page = { + items: Array.isArray(body?.items) ? body.items : [], + next: typeof body?.next === "string" && body.next ? body.next : null + }; + setArchived((a) => ({ items: (a?.items ?? []).concat(page.items), next: page.next })); + } catch (err) { + setArchMoreError(t("memory.affective.moreFailed").replace("{error}", String(err?.message ?? err))); + } finally { + setArchMoreBusy(false); + } + }; + if (state.loading && !state.error) { return h("div", { className: "mneme-set" }, h("div", { className: "mneme-set-inner" }, h("div", { className: "mneme-affective-empty", role: "status" }, t("memory.affective.loading")))); @@ -8658,7 +8757,15 @@ window.__ModuleLoader__.load({ if (Number.isFinite(it.evidenceCount) && it.evidenceCount > 0) { bits.push(t("memory.affective.evidence").replace("{n}", String(it.evidenceCount))); } + // 首现只在与最近不同时说:两个「3 天前」并排是噪声。 + if (it.firstSeen && it.firstSeen !== it.lastSeen) bits.push(t("memory.affective.firstSeen").replace("{time}", formatRelativeTime(it.firstSeen, t))); if (it.lastSeen) bits.push(t("memory.affective.lastSeen").replace("{time}", formatRelativeTime(it.lastSeen, t))); + // #723:向性跟词表组走,词表外的词后端给 null——不渲染就是了,别编。 + const valenceKey = { positive: "valencePositive", negative: "valenceNegative", neutral: "valenceNeutral" }[it.valence]; + if (valenceKey) bits.push(t("memory.affective.valence").replace("{v}", t("memory.affective." + valenceKey))); + // #723:归一组里出现过的全部原词。措辞漂移被归并这件事要可见,不然 + // 「为什么这组叫『开心』而我记得写的是『高兴』」没有答案。 + if (Array.isArray(it.originals) && it.originals.length > 1) bits.push(t("memory.affective.originals").replace("{names}", it.originals.join(" · "))); // #725:行级操作。对象是组(edgeIds 全量)。按钮的可见性就是操作的前提: // 升格只在场合档、降格只在已升格的组——不可用的操作不渲染,而不是渲染了 // 再报错。改词是行内输入,Enter 或 ✓ 提交、Esc 取消。 @@ -8704,9 +8811,19 @@ window.__ModuleLoader__.load({ h("span", { className: "mneme-affective-arrow" }, "·"), h("span", { className: "mneme-affective-emotion" + slotCls }, it.emotion), h("span", { className: "mneme-affective-arrow" }, "·"), - h("span", { className: "mneme-affective-target" }, it.target ?? "?") + h("span", { className: "mneme-affective-target" }, it.target ?? "?"), + // #724 留痕:这组曾按稳定倾向记、后降回场合。是信任信号(系统有过一次 + // 以偏概全并被纠正),所以要摆在明面上,不藏在 meta 里。组合 + // mneme-affective-emotion 复用已登记的 pill 边框(1px 存量棘轮不许新增), + // flag 只覆写字号/字重/颜色。 + it.downgradedFrom === "trait" + ? h("span", { className: "mneme-affective-emotion mneme-affective-flag", title: t("memory.affective.downgraded") }, t("memory.affective.downgraded")) + : null ), bits.length ? h("div", { className: "mneme-affective-meta" }, bits.join(" · ")) : null, + // #726:相位写的「为什么记下这条」。截在两行、全文进 title;模型写的 + // 一句话,不加引号不加工。 + it.why ? h("div", { className: "mneme-affective-why", title: it.why }, it.why) : null, actions ); }; @@ -8750,6 +8867,26 @@ window.__ModuleLoader__.load({ promote: t("memory.affective.applyPromote"), demote: t("memory.affective.applyDemote") }[op] ?? String(op ?? "")); + // #725 账本行此前只有「何时 · 做了什么」;before/after 摘要后端一直在写, + // 面板不读。这里把 delta 拼出来:改词显示词面变化,其余四类显示档位/归档 + // 状态迁移。JSON 解析失败就退回只显示动作——账本是审计面,宁可少说不错说。 + const journalDelta = (j) => { + const parse = (s) => { try { return s ? JSON.parse(s) : null; } catch { return null; } }; + const before = parse(j.before); + const after = parse(j.after); + if (j.op === "rename" && before?.emotion && after?.emotion && before.emotion !== after.emotion) { + return `${before.emotion} → ${after.emotion}`; + } + const A = t("memory.affective.occasion"); + const T = t("memory.affective.trait"); + const act = t("memory.affective.journalActive"); + const arc = t("memory.affective.journalArchived"); + if (j.op === "promote") return `${A} → ${T}`; + if (j.op === "demote") return `${T} → ${A}`; + if (j.op === "archive") return `${act} → ${arc}`; + if (j.op === "restore") return `${arc} → ${act}`; + return ""; + }; return h("div", { className: "mneme-set" }, h("div", { className: "mneme-set-inner" }, @@ -8757,17 +8894,61 @@ window.__ModuleLoader__.load({ h("div", { className: "mneme-affective-title" }, t("memory.affective.title")), h("div", { className: "mneme-affective-sub" }, t("memory.affective.sub")) ), + // #729 过滤参数的页面入口。Enter 生效(与行内改词同一交互惯例), + // Esc 清草稿;有生效过滤时给「清除过滤」,不是让用户逐格删字。 + h("div", { className: "mneme-affective-filterbar" }, + h("input", { + className: "mneme-set-input", placeholder: t("memory.affective.filterPerson"), + value: filterDraft.person, + onChange: (e) => setFilterDraft((d) => ({ ...d, person: e.target.value })), + onKeyDown: (e) => { + if (e.key === "Enter") setFilters({ person: filterDraft.person.trim(), emotion: filterDraft.emotion.trim() }); + if (e.key === "Escape") setFilterDraft({ person: "", emotion: "" }); + } + }), + h("input", { + className: "mneme-set-input", placeholder: t("memory.affective.filterEmotion"), + value: filterDraft.emotion, + onChange: (e) => setFilterDraft((d) => ({ ...d, emotion: e.target.value })), + onKeyDown: (e) => { + if (e.key === "Enter") setFilters({ person: filterDraft.person.trim(), emotion: filterDraft.emotion.trim() }); + if (e.key === "Escape") setFilterDraft({ person: "", emotion: "" }); + } + }), + (filters.person || filters.emotion) + ? h("button", { + type: "button", className: "mneme-btn", + onClick: () => { setFilters({ person: "", emotion: "" }); setFilterDraft({ person: "", emotion: "" }); } + }, t("memory.affective.filterClear")) + : null + ), + (filters.person || filters.emotion) + ? h("div", { className: "mneme-affective-note" }, + t("memory.affective.filtering").replace("{cond}", + [filters.person ? `person=${filters.person}` : "", filters.emotion ? `emotion=${filters.emotion}` : ""].filter(Boolean).join(" · "))) + : null, applyError ? h("div", { className: "mneme-affective-empty mneme-affective-empty--error", role: "alert" }, applyError) : null, state.items.length === 0 ? h("div", { className: "mneme-affective-empty mneme-affective-empty--hero", role: "status" }, h(Icon, { name: "heart", size: 20 }), - t("memory.affective.empty")) + // 过滤下的空和「一条都没记过」是两句话:前者清掉过滤就能看到数据, + // 混用一句会让用户以为整条情绪线是空的。 + (filters.person || filters.emotion) ? t("memory.affective.emptyFiltered") : t("memory.affective.empty")) : h(react.Fragment, null, group("memory.affective.trait", traitRows), group("memory.affective.occasion", occasionRows)), // 截断与跳过都要说出来:读者看到「就这些」时,得知道是自己没记够, - // 还是这一页只放了这么多。 - state.truncated ? h("div", { className: "mneme-affective-note" }, t("memory.affective.truncated").replace("{n}", String(state.totalEdges))) : null, + // 还是这一页只放了这么多。有游标可翻时截断提示交给「加载更多」, + // 两句同屏会打架。 + state.truncated && !state.next + ? h("div", { className: "mneme-affective-note" }, t("memory.affective.truncated").replace("{n}", String(state.totalEdges))) + : null, + state.next + ? h("div", { className: "mneme-affective-more" }, + h("button", { type: "button", className: "mneme-btn", disabled: moreBusy, onClick: loadMoreMain }, + moreBusy ? t("memory.affective.loading") : t("memory.affective.loadMore")), + moreError ? h("div", { className: "mneme-affective-note mneme-affective-empty--error", role: "alert" }, moreError) : null) + : null, state.skippedEdges > 0 ? h("div", { className: "mneme-affective-note" }, t("memory.affective.skipped").replace("{n}", String(state.skippedEdges))) : null, // #725:归档区(默认收起)与人工修正账本。归档边在默认档不出现——「情绪 // 变少了」由按钮上的计数解释成归档了而不是丢了。 @@ -8779,9 +8960,15 @@ window.__ModuleLoader__.load({ archOpen ? (archived === null ? h("div", { className: "mneme-affective-note" }, t("memory.affective.loading")) - : archived.length === 0 + : archived.items.length === 0 && !archived.next ? h("div", { className: "mneme-affective-note" }, t("memory.affective.archiveEmpty")) - : h("div", { className: "mneme-affective-list mneme-affective-archlist" }, archived.map(archivedRow))) + : h("div", { className: "mneme-affective-list mneme-affective-archlist" }, archived.items.map(archivedRow))) + : null, + archOpen && archived?.next + ? h("div", { className: "mneme-affective-more" }, + h("button", { type: "button", className: "mneme-btn", disabled: archMoreBusy, onClick: loadMoreArchived }, + archMoreBusy ? t("memory.affective.loading") : t("memory.affective.loadMore")), + archMoreError ? h("div", { className: "mneme-affective-note mneme-affective-empty--error", role: "alert" }, archMoreError) : null) : null, h("div", { className: "mneme-affective-journal" }, h("div", { className: "mneme-affective-note" }, t("memory.affective.journalTitle")), @@ -8789,7 +8976,8 @@ window.__ModuleLoader__.load({ ? h("div", { className: "mneme-affective-note" }, t("memory.affective.journalEmpty")) : journal.map((j, i) => h("div", { key: j.id ?? i, className: "mneme-affective-journalrow" }, h("span", null, formatRelativeTime(j.at, t)), - h("span", null, opLabel(j.op))))) + h("span", null, opLabel(j.op)), + journalDelta(j) ? h("span", null, journalDelta(j)) : null))) ) ) ); diff --git a/dsh-mneme/test/client.test.js b/dsh-mneme/test/client.test.js index 663705fb..0d032271 100644 --- a/dsh-mneme/test/client.test.js +++ b/dsh-mneme/test/client.test.js @@ -4752,6 +4752,63 @@ test("affective page wires the manual apply channel (#725)", () => { "apply 成功后要广播失效事件,依赖方不能等 60s 兜底轮询"); }); +// #729/#732 的字段落页面:后端一直在给 why / downgradedFrom / valence / originals / +// firstSeen,前端此前一个都没消费——「数据在、界面没显示」的又一次假绿。锁五件事: +// why 上行(全文进 title)、降级徽标、向性与原词进 meta、首页就按游标模式取 +// (否则边帽=limit,next 永远是 null,翻页按钮长不出来)。 +test("affective rows consume the #729/#732 fields the server already returns", () => { + const start = clientSource.indexOf("function AffectivePanel({ t })"); + const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start); + const body = clientSource.slice(start, end); + + assert.ok(/it\.why \? h\("div", \{ className: "mneme-affective-why", title: it\.why \}/.test(body), + "why 必须上行(截断展示 + title 带全文),不能只躺在响应里"); + assert.ok(/it\.downgradedFrom === "trait"\s*\?/.test(body) && body.includes("mneme-affective-flag"), + "降级留痕要摆到明面上(曾按倾向记后降回场合)"); + assert.ok(/it\.valence/.test(body) && /valencePositive|valenceNegative|valenceNeutral/.test(body), + "向性要进 meta(词表外的词 valence=null,不渲染就是了)"); + assert.ok(/it\.originals\.length > 1/.test(body), + "归一组出现过的原词要可见,措辞漂移不能静默发生"); + assert.ok(/it\.firstSeen && it\.firstSeen !== it\.lastSeen/.test(body), + "首现只在与最近不同时说"); + // 首页就带 cursor 恒参:不带 cursor 的请求边帽=limit(200),组数永远到不了帽, + // 服务端永远不发 next——翻页按钮就永远长不出来。 + assert.ok(/cursor: opts\.cursor \?\? ""/.test(body), + "首页必须按游标模式取(cursor 空串=从头翻第一页),否则 next 永远是 null"); + assert.ok(body.includes("loadMoreMain") && body.includes("mneme-affective-more"), + "下一页要真有按钮,不能只留截断提示"); +}); + +// 过滤下的空 ≠ 没记过:两句话混用一句,用户会以为整条情绪线是空的。 +// 锁:过滤参数真的进请求串、生效态与草稿态分开、过滤空态有自己的文案。 +test("affective filters hit the server params and keep filtered-empty apart from true-empty", () => { + const start = clientSource.indexOf("function AffectivePanel({ t })"); + const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start); + const body = clientSource.slice(start, end); + + assert.ok(/person: filters\.person, emotion: filters\.emotion/.test(body), + "过滤参数要真的进请求(服务端支持 person/emotion,#729)"); + assert.ok(/setFilters\(\{ person: "", emotion: "" \}\)/.test(body), + "清除过滤要一键回到全量,不是让用户逐格删字"); + assert.ok(body.includes("memory.affective.emptyFiltered"), + "过滤下的空态要有自己的话,不能冒充「库里还没有情绪边」"); +}); + +// 账本的 before/after 后端一直在写(rename 是词面、promote/demote/archive/restore +// 是档位与归档态),面板此前只读 at+op——「改了什么」全靠用户脑补。 +test("affective journal rows surface the before/after delta", () => { + const start = clientSource.indexOf("function AffectivePanel({ t })"); + const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start); + const body = clientSource.slice(start, end); + + assert.ok(/const journalDelta = \(j\) =>/.test(body), "delta 派生函数要存在"); + assert.ok(/j\.op === "rename" && before\?\.emotion && after\?\.emotion/.test(body), + "改词要显示词面变化(旧词 → 新词)"); + assert.ok(/if \(j\.op === "promote"\) return/.test(body) && /if \(j\.op === "restore"\) return/.test(body) + && /j\.op === "archive"/.test(body) && /j\.op === "demote"/.test(body), + "归档/恢复/升格/降格都要显示状态迁移(活跃 ↔ 已归档、场合 ↔ 倾向)"); +}); + // formatRelativeTime(value, t) 的 t 是必填的:它内部要 t("memory.time.now") // 之类的文案,少传就抛 TypeError,而它跑在 render 里 —— 整个面板会白屏, // 且不写进任何日志。v0.14.0-beta.1/2 的「情绪页一点就全白」就是这么来的 From f10fa552db3de5325abef60d8c1024e843d64e52 Mon Sep 17 00:00:00 2001 From: modusensus Date: Thu, 19 Nov 2026 00:41:13 +0800 Subject: [PATCH 2/2] =?UTF-8?q?fix(#750):=20=E8=AF=84=E5=AE=A1=E5=8D=81?= =?UTF-8?q?=E4=B8=83=E5=A4=84=E2=80=94=E2=80=94=E6=95=B4=E9=A1=B5=E6=97=A9?= =?UTF-8?q?=E9=80=80=E3=80=81=E7=BF=BB=E9=A1=B5=E4=BB=A3=E6=AC=A1=E3=80=81?= =?UTF-8?q?50=20=E6=9D=A1=E9=9D=99=E9=BB=98=E6=88=AA=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CodeRabbit 在 #750 上提了 17 条(2 Major + 15 Minor),逐条核到代码里 全部属实,没有一条是风格挑刺。三处会真出错: ① 筛选请求失败会整页早退,把输入框与「清除过滤」一起藏掉——带着生效中的 过滤读崩一次,除了离开页签没有别的出路。错误改在结果区摆,筛选栏照常 可用,另给就地重试。 ② 翻页与重取没有代次:旧筛选的续页在飞时提交新筛选,返回后仍往新结果上 追加并用旧 next 覆盖新游标;归档区同病,恢复操作触发重取后续页仍可拿 恢复前的游标跳页。加 mainGen/archGen,重取即作废旧页,写任何状态前校验。 ③ src/api.js 的 slice(0, 50) 静默截断(存量代码,本页的分页才让它可 触发):51 条边的组只做前 50 条,被丢的边不进 failures,回包是 applied:50 + failures:[],面板当整组成功。改成超限整组 400 too-many-edges(带 limit/got),写任何一条边之前退出。 其余十处:账本按 op 一律画箭头,promote 幂等复用与重复 archive/restore 都显示成没发生过的迁移(改按前后值判,坏 JSON 有原文却解析不出就留空); Escape 未 stopPropagation 会把整个面板一起关掉;isComposing 未判导致 输入法组合期 Enter 提交半截词;downgraded 文案与相位代码口径相反(那是 写入前驳回,边从未按 trait 存过);情绪筛选只比归一主词,填原词零结果; why 只靠 title 给全文;归档响应丢 truncated,扫到上限显示成「空」;归档 续页把坏正文当空页丢游标;唯一原词不同于主词时被隐藏。 测试 3,717 → 3,718。client.test.js 三条从「数源码里的字符串」改成真行为 (journalDelta 整段抠出来跑 11 条断言、翻页锁真函数与追加语义、过滤锁 两个 q.set 都进查询串);graph-api.test.js +2 锁后端两处行为。变异自证: 把 slice(0, 50) 与「只比主词」还原 → 两条新用例同时红。 --- dsh-mneme/CHANGELOG.md | 8 ++ dsh-mneme/lib/api.js | 14 +++- dsh-mneme/lib/client.js | 123 ++++++++++++++++++++++--------- dsh-mneme/src/api.js | 14 +++- dsh-mneme/test/client.test.js | 78 ++++++++++++++++---- dsh-mneme/test/graph-api.test.js | 53 +++++++++++++ 6 files changed, 240 insertions(+), 50 deletions(-) diff --git a/dsh-mneme/CHANGELOG.md b/dsh-mneme/CHANGELOG.md index 44fdd9ab..6c84a1fe 100644 --- a/dsh-mneme/CHANGELOG.md +++ b/dsh-mneme/CHANGELOG.md @@ -2,6 +2,14 @@ ## [Unreleased] +- **情绪页把后端早就给全的文字接上页面,评审提的十七处一并修掉(#750)**。`#729/#732/#733/#734` 合并后,聚合端点一直在给 `why`、`downgradedFrom`、`valence`、`originals`、`firstSeen`、`next` 游标与 `person`/`emotion` 过滤参数,账本行也带着 before/after 摘要——前端一个都没消费,「数据在、界面没显示」。本次全部上页面:`why` 两行截断、全文进 `title`(并补 `tabIndex`,否则键盘与触屏都拿不到全文);`downgradedFrom` 降级徽标摆在主行;`valence` 与归一组原词进 meta;首页即按游标模式取(边帽放宽到 `4×limit`),主列表与归档区各自「加载更多」,有游标可翻时截断提示让位;`person`/`emotion` 过滤 Enter 生效、草稿与生效态分开、一键清除,过滤下的空态有自己的文案;账本行读 before/after,改词显示词面变化、其余四类显示档位与归档态迁移。 + + CodeRabbit 随后提了 17 条(2 Major + 15 Minor),逐条核到代码里**全部属实**,没有一条是风格挑刺。三处会真出错的:① **筛选请求失败会整页早退**,把输入框与「清除过滤」一起藏掉,带着生效中的过滤读崩一次就只剩离开页签一条路——现在错误改在结果区摆,筛选栏照常可用,另给就地重试;② **翻页与重取没有代次**,旧筛选的续页在飞时提交新筛选,返回后仍往新结果上追加并用旧 `next` 覆盖新游标(归档区同病:恢复操作触发重取后,续页仍可拿恢复前的游标跳页)——加 `mainGen`/`archGen` 两个代次,重取即作废旧页并在写任何状态前校验;③ **`slice(0, 50)` 静默截断**(这是 `src/api.js` 里的存量代码,是本页的分页能力才让它可触发):51 条边的组只做前 50 条,被丢的边不进 `failures`,回包是 `applied:50, failures:[]`,面板当整组成功——改成超限整组 `400 too-many-edges`(带 `limit`/`got`),在写任何一条边之前退出,宁可整组拒不半做。 + + 其余十处:账本按 `op` 一律画箭头,`promote` 幂等复用(before 已是 `promotedToTrait:true`)与重复 `archive`/`restore` 都显示成没发生过的迁移——改按前后值判,并给坏 JSON 一条「有原文却解析不出就留空」的兜底;`Escape` 未 `stopPropagation`,取消改词会把整个面板一起关掉;`isComposing` 未判,输入法组合期按 Enter 就把半截词提交了;`downgraded` 文案写成「曾按稳定倾向记,后降回场合」,而相位代码是**写入前**驳回模型提议、边从未按 trait 存过;情绪筛选只比归一主词,用户填自己写过的原词(「高兴」,组主词「开心」)得零结果;`why` 只靠 `title` 给全文;归档响应丢掉 `truncated`,扫到上限时显示成「归档区是空的」;归档续页 `res.json().catch(() => null)` 把坏正文当空页,游标一并丢掉;唯一原词不同于主词时被隐藏。 + + **测试** 3,717 → **3,718**(`test/client.test.js` 三条从「数源码里的字符串」改成真行为:`journalDelta` 整段抠出来跑 11 条断言含幂等与坏 JSON、翻页锁 `onClick: loadMoreMain` 与 `next: page.next` 与追加而非替换、过滤锁 `affectiveUrl` 里两个 `q.set` 都真的写进查询串;`test/graph-api.test.js` +2 锁后端两处行为:原词过滤命中整组且不在组里的词仍不命中、51 条边整组 400 且 50 条不被拒且拒时一条边都没写脏)。变异自证:把 `slice(0, 50)` 与「只比主词」还原 → 两条新用例同时红。 + - **切卡竞态、卸载时序、请求体形状、半份摘要:评审提的五处,全属实(#752 复审)**。CodeRabbit 在 #752 上留了 5 条,逐条核到代码里都成立,不是风格挑刺—— ① `lib/client.js` 的 `loadDigest` / `loadFacts` 都是 `useCallback([])`,闭包里的卡名永远是首挂那一个,只有 `digestSeq` / `factsSeq` 序号挡着。序号只治同卡内乱序,治不了**切卡**:A 卡生成期间切到 B,A 的响应回来序号是新的,把 B 的摘要盖成 A 的。现在改用 `factsAgentRef` 认卡(成功与失败两条分支都判),手动蒸馏与生成摘要两条写路径也各自先取 `const key = factsAgent`,回执对不上就丢。 ② 页头「重试」只重读画像/persona/features/diary,**没重读摘要**——首次 GET 失败后摘要停在 error 态,生成闸关着时页面上再没有别的入口。现在 `tick` 的 effect 里补一次 `loadDigest`。 diff --git a/dsh-mneme/lib/api.js b/dsh-mneme/lib/api.js index 6a706a11..77f4e2ef 100644 --- a/dsh-mneme/lib/api.js +++ b/dsh-mneme/lib/api.js @@ -2240,7 +2240,10 @@ export function createApi(ctx, service, settings, commands, embedder, semantic = if (personF) { view = view.filter((g) => String(g.person ?? "").toLowerCase() === personF || String(g.personId ?? "") === personF); } - if (emotionF) view = view.filter((g) => g.emotion.toLowerCase() === emotionF); + // #750 复审 ⑥:只比归一主词时,用户照着自己写的原词(「高兴」)过滤会得 + // 零结果——库里那组的主词是「开心」。归一库里出现过的原词一并比。 + if (emotionF) view = view.filter((g) => g.emotion.toLowerCase() === emotionF + || (Array.isArray(g.originals) && g.originals.some((w) => String(w).toLowerCase() === emotionF))); if (attributionF === "trait" || attributionF === "occasion") { view = view.filter((g) => g.attribution === attributionF); } @@ -2341,8 +2344,15 @@ export function createApi(ctx, service, settings, commands, embedder, semantic = return sendJson(res, 400, { error: "unknown op" }); } const edgeIds = Array.isArray(body.edgeIds) - ? body.edgeIds.filter((id) => typeof id === "string" && id).slice(0, 50) + ? body.edgeIds.filter((id) => typeof id === "string" && id) : []; + // #750 复审 ⑧:此前 slice(0, 50) 静默丢弃第 51 条起,被丢的边不进 + // failures,51 条的组回 applied:50 + failures:[],面板把它当整组成功—— + // 升格/归档只做了一半,账本却写「做完了」。宁可整组拒,也不许半做: + // 写任何一条边之前就退出去。 + if (edgeIds.length > 50) { + return sendJson(res, 400, { error: "too-many-edges", limit: 50, got: edgeIds.length }); + } if (!edgeIds.length) return sendJson(res, 400, { error: "edgeIds required" }); if (op === "rename" && (typeof body.emotion !== "string" || !body.emotion.trim())) { return sendJson(res, 400, { error: "emotion required" }); diff --git a/dsh-mneme/lib/client.js b/dsh-mneme/lib/client.js index 0e4b8b30..e4119a74 100644 --- a/dsh-mneme/lib/client.js +++ b/dsh-mneme/lib/client.js @@ -715,7 +715,9 @@ window.__ModuleLoader__.load({ "memory.affective.journalTitle": "最近变更", "memory.affective.journalEmpty": "还没有人工修正记录。", "memory.affective.whyHint": "记下这条的缘由(取最新一次)", - "memory.affective.downgraded": "曾按稳定倾向记,后降回场合", + "memory.affective.downgraded": "倾向判断未通过校验,按场合记录", + "memory.affective.retry": "重试", + "memory.affective.archiveTruncated": "归档区只扫到上限,可能还有更早的没显示", "memory.affective.valence": "向性 {v}", "memory.affective.valencePositive": "正", "memory.affective.valenceNegative": "负", @@ -1958,7 +1960,9 @@ window.__ModuleLoader__.load({ "memory.affective.journalTitle": "Recent changes", "memory.affective.journalEmpty": "No manual corrections yet.", "memory.affective.whyHint": "Why this was recorded (latest entry)", - "memory.affective.downgraded": "Once recorded as a lasting tendency, later downgraded to occasion", + "memory.affective.downgraded": "Tendency claim failed validation; recorded as occasion", + "memory.affective.retry": "Retry", + "memory.affective.archiveTruncated": "The archive scan hit its cap; older entries may be missing", "memory.affective.valence": "valence {v}", "memory.affective.valencePositive": "positive", "memory.affective.valenceNegative": "negative", @@ -3134,6 +3138,9 @@ window.__ModuleLoader__.load({ // #726/#723/#724 的字段落页面:why 引文(两行截断、全文在 title)、降级徽标、 // 过滤栏、加载更多。几何全走刻度,不进 px 棘轮。 ".mneme-affective-why{font-size:var(--mneme-type-12);color:var(--mneme-fg-dim);margin-top:var(--mneme-space-4);line-height:1.5;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;word-break:break-word}", + // 两行截断只靠 title 的话,键盘与触屏都打不开全文:可聚焦,聚焦时解除截断。 + // 不加新尺寸、不动滚动容器,只在聚焦态改显示方式。 + ".mneme-affective-why:focus{-webkit-line-clamp:unset;display:block;overflow:visible}", ".mneme-affective-flag{font-size:var(--mneme-type-12);font-weight:400;color:var(--mneme-fg-dim)}", ".mneme-affective-filterbar{display:flex;align-items:center;gap:var(--mneme-space-6);flex-wrap:wrap;margin-top:var(--mneme-space-8)}", ".mneme-affective-filterbar .mneme-set-input{flex:1;min-width:0;margin-bottom:0}", @@ -8608,6 +8615,11 @@ window.__ModuleLoader__.load({ const [reloadTick, setReloadTick] = useState(0); const [moreBusy, setMoreBusy] = useState(false); const [moreError, setMoreError] = useState(""); + // #750 复审 ②:查询代次。翻页响应回来时筛选可能已经换了——旧的一页不能 + // 追加到新结果上,更不能拿旧 next 覆盖新游标。每次重取自增,响应侧对不上 + // 就整个丢掉(连同错误与忙碌态)。 + const mainGen = useRef(0); + const archGen = useRef(0); // 请求串。cursor 恒参(空串=从头翻第一页):#729 的游标模式把边帽放宽到 // 4×limit,首页就按这个模式取,超过一页的组才有 next 可翻;旧客户端不带的 // 请求边帽=limit,组数永远到不了帽,next 永远是 null——那是翻不出第二页的。 @@ -8630,6 +8642,7 @@ window.__ModuleLoader__.load({ }); useEffect(() => { let cancelled = false; + const gen = ++mainGen.current; setState((s) => ({ ...s, loading: true, error: false })); apiFetch(affectiveUrl({ person: filters.person, emotion: filters.emotion })) .then((res) => { @@ -8637,12 +8650,12 @@ window.__ModuleLoader__.load({ return res.json(); }) .then((j) => { - if (!cancelled) setState(pickState(j)); + if (!cancelled && gen === mainGen.current) setState(pickState(j)); }) .catch(() => { // 失败就报失败。这里绝不能退化成空 items —— 那会让「上游挂了」 // 长得和「你还没记过情绪」一模一样,用户会以为功能没用。 - if (!cancelled) setState({ loading: true, error: true, items: [], totalEdges: 0, skippedEdges: 0, truncated: false, archivedEdges: 0, next: null }); + if (!cancelled && gen === mainGen.current) setState({ loading: true, error: true, items: [], totalEdges: 0, skippedEdges: 0, truncated: false, archivedEdges: 0, next: null }); }); return () => { cancelled = true; }; }, [reloadTick, filters]); @@ -8651,10 +8664,23 @@ window.__ModuleLoader__.load({ useEffect(() => { if (!archOpen) return; let cancelled = false; + const gen = ++archGen.current; + // 重取开始就把上一份连同游标一起作废:留着旧 next,用户点的还是上一轮 + // 的位置,翻出来的是上一轮的续页。 + setArchived(null); apiFetch(affectiveUrl({ archived: true })) .then((res) => { if (!res.ok) throw new Error(`http ${res.status}`); return res.json(); }) - .then((j) => { if (!cancelled) setArchived({ items: Array.isArray(j.items) ? j.items : [], next: typeof j.next === "string" && j.next ? j.next : null }); }) - .catch(() => { if (!cancelled) setArchived({ items: [], next: null }); }); + .then((j) => { + if (cancelled || gen !== archGen.current) return; + setArchived({ + items: Array.isArray(j.items) ? j.items : [], + next: typeof j.next === "string" && j.next ? j.next : null, + // #750 复审 ⑨:服务端扫到上限会回 items:[] + next:null + truncated:true, + // 丢掉这个标志就变成「归档区是空的」——两件事含义相反。 + truncated: j.truncated === true + }); + }) + .catch(() => { if (!cancelled && gen === archGen.current) setArchived({ items: [], next: null, truncated: false }); }); return () => { cancelled = true; }; }, [archOpen, reloadTick]); useEffect(() => { @@ -8696,16 +8722,19 @@ window.__ModuleLoader__.load({ // next 取响应里的新游标;失败如实报出(列表没变),绝不把失败装成「没了」。 const loadMoreMain = async () => { if (!state.next || moreBusy) return; + const gen = mainGen.current; setMoreBusy(true); setMoreError(""); try { const res = await apiFetch(affectiveUrl({ cursor: state.next, person: filters.person, emotion: filters.emotion })); const body = await res.json().catch(() => null); if (!res.ok) throw new Error(body?.error || `http ${res.status}`); + // 代次变了(筛选换过 / 重取过)就把这一页连同游标一起丢掉,绝不追加。 + if (gen !== mainGen.current) return; const page = pickState(body); setState((s) => ({ ...s, items: s.items.concat(page.items), totalEdges: page.totalEdges, truncated: page.truncated, next: page.next })); } catch (err) { - setMoreError(t("memory.affective.moreFailed").replace("{error}", String(err?.message ?? err))); + if (gen === mainGen.current) setMoreError(t("memory.affective.moreFailed").replace("{error}", String(err?.message ?? err))); } finally { setMoreBusy(false); } @@ -8714,19 +8743,26 @@ window.__ModuleLoader__.load({ const [archMoreError, setArchMoreError] = useState(""); const loadMoreArchived = async () => { if (!archived?.next || archMoreBusy) return; + const gen = archGen.current; setArchMoreBusy(true); setArchMoreError(""); try { const res = await apiFetch(affectiveUrl({ archived: true, cursor: archived.next })); - const body = await res.json().catch(() => null); + // #750 复审 ⑩:正文坏了必须走 catch。原先 .catch(() => null) 把坏正文 + // 当成空页,next 一并变成 null——游标丢了,重试都没得重试。 + const text = await res.text(); + let body = null; + try { body = text ? JSON.parse(text) : null; } catch { body = null; } if (!res.ok) throw new Error(body?.error || `http ${res.status}`); + if (!body || typeof body !== "object") throw new Error("invalid body"); + if (gen !== archGen.current) return; const page = { - items: Array.isArray(body?.items) ? body.items : [], - next: typeof body?.next === "string" && body.next ? body.next : null + items: Array.isArray(body.items) ? body.items : [], + next: typeof body.next === "string" && body.next ? body.next : null }; - setArchived((a) => ({ items: (a?.items ?? []).concat(page.items), next: page.next })); + setArchived((a) => ({ items: (a?.items ?? []).concat(page.items), next: page.next, truncated: a?.truncated === true })); } catch (err) { - setArchMoreError(t("memory.affective.moreFailed").replace("{error}", String(err?.message ?? err))); + if (gen === archGen.current) setArchMoreError(t("memory.affective.moreFailed").replace("{error}", String(err?.message ?? err))); } finally { setArchMoreBusy(false); } @@ -8736,12 +8772,9 @@ window.__ModuleLoader__.load({ return h("div", { className: "mneme-set" }, h("div", { className: "mneme-set-inner" }, h("div", { className: "mneme-affective-empty", role: "status" }, t("memory.affective.loading")))); } - if (state.error) { - // role=alert:这是需要用户知道的一次失败,不是背景噪声。 - return h("div", { className: "mneme-set" }, - h("div", { className: "mneme-set-inner" }, - h("div", { className: "mneme-affective-empty mneme-affective-empty--error", role: "alert" }, t("memory.affective.error")))); - } + // #750 复审 ①:读取失败不再整页早退。早退会把筛选输入框和「清除过滤」 + // 一起藏掉——用户带着一个生效中的过滤读崩了,除了离开页签没有别的出路。 + // 错误改在结果区摆,筛选栏照常可用,另给一个就地重试。 const buildRow = (it, i) => { const isTrait = it.attribution === "trait"; @@ -8765,7 +8798,7 @@ window.__ModuleLoader__.load({ if (valenceKey) bits.push(t("memory.affective.valence").replace("{v}", t("memory.affective." + valenceKey))); // #723:归一组里出现过的全部原词。措辞漂移被归并这件事要可见,不然 // 「为什么这组叫『开心』而我记得写的是『高兴』」没有答案。 - if (Array.isArray(it.originals) && it.originals.length > 1) bits.push(t("memory.affective.originals").replace("{names}", it.originals.join(" · "))); + if (Array.isArray(it.originals) && it.originals.some((w) => w !== it.emotion)) bits.push(t("memory.affective.originals").replace("{names}", it.originals.join(" · "))); // #725:行级操作。对象是组(edgeIds 全量)。按钮的可见性就是操作的前提: // 升格只在场合档、降格只在已升格的组——不可用的操作不渲染,而不是渲染了 // 再报错。改词是行内输入,Enter 或 ✓ 提交、Esc 取消。 @@ -8778,11 +8811,13 @@ window.__ModuleLoader__.load({ placeholder: t("memory.affective.renamePlaceholder"), onChange: (e) => setRenaming({ key: rowKey, value: e.target.value }), onKeyDown: (e) => { - if (e.key === "Enter") { + if (e.key === "Enter" && !e.nativeEvent.isComposing) { const v = renaming.value.trim(); if (v) applyAffective("rename", groupEdgeIds, rowKey, { emotion: v }).then(() => setRenaming(null)); } - if (e.key === "Escape") setRenaming(null); + // 两个分支都要 stopPropagation:继续冒泡会走到 MemoryOverlay 的 + // window 监听器,把整个面板一起关掉——用户只想取消一次改词。 + if (e.key === "Escape") { e.stopPropagation(); setRenaming(null); } } }), h("button", { @@ -8823,7 +8858,7 @@ window.__ModuleLoader__.load({ bits.length ? h("div", { className: "mneme-affective-meta" }, bits.join(" · ")) : null, // #726:相位写的「为什么记下这条」。截在两行、全文进 title;模型写的 // 一句话,不加引号不加工。 - it.why ? h("div", { className: "mneme-affective-why", title: it.why }, it.why) : null, + it.why ? h("div", { className: "mneme-affective-why", title: it.why, tabIndex: 0 }, it.why) : null, actions ); }; @@ -8874,6 +8909,10 @@ window.__ModuleLoader__.load({ const parse = (s) => { try { return s ? JSON.parse(s) : null; } catch { return null; } }; const before = parse(j.before); const after = parse(j.after); + // 有原文却解析不出来 = 不知道迁移前是什么。这时画箭头就是把没核实的 + // 事写进审计面,所以宁可留空。服务端写下的 before/after 都是合法 JSON, + // 这条只管损坏的历史行。 + if ((j.before && before === null) || (j.after && after === null)) return ""; if (j.op === "rename" && before?.emotion && after?.emotion && before.emotion !== after.emotion) { return `${before.emotion} → ${after.emotion}`; } @@ -8881,10 +8920,13 @@ window.__ModuleLoader__.load({ const T = t("memory.affective.trait"); const act = t("memory.affective.journalActive"); const arc = t("memory.affective.journalArchived"); - if (j.op === "promote") return `${A} → ${T}`; - if (j.op === "demote") return `${T} → ${A}`; - if (j.op === "archive") return `${act} → ${arc}`; - if (j.op === "restore") return `${arc} → ${act}`; + // 前后值一致时不画箭头:promote 命中同题行会幂等复用(before 已是 + // promotedToTrait:true),archive 对已归档的边再来一次也一样。照 op 一律 + // 画「场合 → 倾向」「活跃 → 归档」就是把没发生的事写进审计面。 + if (j.op === "promote") return before?.promotedToTrait === true ? "" : `${A} → ${T}`; + if (j.op === "demote") return before?.promotedToTrait === true ? `${T} → ${A}` : ""; + if (j.op === "archive") return before?.archivedAt ? "" : `${act} → ${arc}`; + if (j.op === "restore") return before?.archivedAt ? `${arc} → ${act}` : ""; return ""; }; @@ -8902,8 +8944,8 @@ window.__ModuleLoader__.load({ value: filterDraft.person, onChange: (e) => setFilterDraft((d) => ({ ...d, person: e.target.value })), onKeyDown: (e) => { - if (e.key === "Enter") setFilters({ person: filterDraft.person.trim(), emotion: filterDraft.emotion.trim() }); - if (e.key === "Escape") setFilterDraft({ person: "", emotion: "" }); + if (e.key === "Enter" && !e.nativeEvent.isComposing) setFilters({ person: filterDraft.person.trim(), emotion: filterDraft.emotion.trim() }); + if (e.key === "Escape") { e.stopPropagation(); setFilterDraft({ person: "", emotion: "" }); } } }), h("input", { @@ -8911,8 +8953,8 @@ window.__ModuleLoader__.load({ value: filterDraft.emotion, onChange: (e) => setFilterDraft((d) => ({ ...d, emotion: e.target.value })), onKeyDown: (e) => { - if (e.key === "Enter") setFilters({ person: filterDraft.person.trim(), emotion: filterDraft.emotion.trim() }); - if (e.key === "Escape") setFilterDraft({ person: "", emotion: "" }); + if (e.key === "Enter" && !e.nativeEvent.isComposing) setFilters({ person: filterDraft.person.trim(), emotion: filterDraft.emotion.trim() }); + if (e.key === "Escape") { e.stopPropagation(); setFilterDraft({ person: "", emotion: "" }); } } }), (filters.person || filters.emotion) @@ -8928,7 +8970,17 @@ window.__ModuleLoader__.load({ [filters.person ? `person=${filters.person}` : "", filters.emotion ? `emotion=${filters.emotion}` : ""].filter(Boolean).join(" · "))) : null, applyError ? h("div", { className: "mneme-affective-empty mneme-affective-empty--error", role: "alert" }, applyError) : null, - state.items.length === 0 + // role=alert:这是需要用户知道的一次失败,不是背景噪声。重试与清除 + // 过滤都留在原地——读失败时用户最可能想做的两件事。 + state.error + ? h("div", { className: "mneme-affective-empty mneme-affective-empty--error", role: "alert" }, + t("memory.affective.error"), + h("div", { className: "mneme-affective-actions" }, + h("button", { type: "button", className: "mneme-btn", onClick: () => setReloadTick((n) => n + 1) }, t("memory.affective.retry")), + (filters.person || filters.emotion) + ? h("button", { type: "button", className: "mneme-btn", onClick: () => { setFilters({ person: "", emotion: "" }); setFilterDraft({ person: "", emotion: "" }); } }, t("memory.affective.filterClear")) + : null)) + : state.items.length === 0 ? h("div", { className: "mneme-affective-empty mneme-affective-empty--hero", role: "status" }, h(Icon, { name: "heart", size: 20 }), // 过滤下的空和「一条都没记过」是两句话:前者清掉过滤就能看到数据, @@ -8961,8 +9013,13 @@ window.__ModuleLoader__.load({ ? (archived === null ? h("div", { className: "mneme-affective-note" }, t("memory.affective.loading")) : archived.items.length === 0 && !archived.next - ? h("div", { className: "mneme-affective-note" }, t("memory.affective.archiveEmpty")) - : h("div", { className: "mneme-affective-list mneme-affective-archlist" }, archived.items.map(archivedRow))) + ? h("div", { className: "mneme-affective-note" }, + archived.truncated ? t("memory.affective.archiveTruncated") : t("memory.affective.archiveEmpty")) + : h(react.Fragment, null, + h("div", { className: "mneme-affective-list mneme-affective-archlist" }, archived.items.map(archivedRow)), + archived.truncated && !archived.next + ? h("div", { className: "mneme-affective-note" }, t("memory.affective.archiveTruncated")) + : null)) : null, archOpen && archived?.next ? h("div", { className: "mneme-affective-more" }, diff --git a/dsh-mneme/src/api.js b/dsh-mneme/src/api.js index 6a706a11..77f4e2ef 100644 --- a/dsh-mneme/src/api.js +++ b/dsh-mneme/src/api.js @@ -2240,7 +2240,10 @@ export function createApi(ctx, service, settings, commands, embedder, semantic = if (personF) { view = view.filter((g) => String(g.person ?? "").toLowerCase() === personF || String(g.personId ?? "") === personF); } - if (emotionF) view = view.filter((g) => g.emotion.toLowerCase() === emotionF); + // #750 复审 ⑥:只比归一主词时,用户照着自己写的原词(「高兴」)过滤会得 + // 零结果——库里那组的主词是「开心」。归一库里出现过的原词一并比。 + if (emotionF) view = view.filter((g) => g.emotion.toLowerCase() === emotionF + || (Array.isArray(g.originals) && g.originals.some((w) => String(w).toLowerCase() === emotionF))); if (attributionF === "trait" || attributionF === "occasion") { view = view.filter((g) => g.attribution === attributionF); } @@ -2341,8 +2344,15 @@ export function createApi(ctx, service, settings, commands, embedder, semantic = return sendJson(res, 400, { error: "unknown op" }); } const edgeIds = Array.isArray(body.edgeIds) - ? body.edgeIds.filter((id) => typeof id === "string" && id).slice(0, 50) + ? body.edgeIds.filter((id) => typeof id === "string" && id) : []; + // #750 复审 ⑧:此前 slice(0, 50) 静默丢弃第 51 条起,被丢的边不进 + // failures,51 条的组回 applied:50 + failures:[],面板把它当整组成功—— + // 升格/归档只做了一半,账本却写「做完了」。宁可整组拒,也不许半做: + // 写任何一条边之前就退出去。 + if (edgeIds.length > 50) { + return sendJson(res, 400, { error: "too-many-edges", limit: 50, got: edgeIds.length }); + } if (!edgeIds.length) return sendJson(res, 400, { error: "edgeIds required" }); if (op === "rename" && (typeof body.emotion !== "string" || !body.emotion.trim())) { return sendJson(res, 400, { error: "emotion required" }); diff --git a/dsh-mneme/test/client.test.js b/dsh-mneme/test/client.test.js index 0d032271..fd998ad5 100644 --- a/dsh-mneme/test/client.test.js +++ b/dsh-mneme/test/client.test.js @@ -4761,22 +4761,35 @@ test("affective rows consume the #729/#732 fields the server already returns", ( const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start); const body = clientSource.slice(start, end); - assert.ok(/it\.why \? h\("div", \{ className: "mneme-affective-why", title: it\.why \}/.test(body), - "why 必须上行(截断展示 + title 带全文),不能只躺在响应里"); + // 截断展示 + title 带全文,且要能打开全文——只靠 title 的话键盘与触屏都摸不到。 + assert.ok(/it\.why \? h\("div", \{ className: "mneme-affective-why", title: it\.why, tabIndex: 0 \}/.test(body), + "why 必须上行(截断展示 + title 带全文 + 可聚焦展开),不能只躺在响应里"); + assert.ok(/\.mneme-affective-why:focus\{-webkit-line-clamp:unset/.test(clientSource), + "聚焦态要解除截断,否则「可聚焦」也只是把鼠标提示换成键盘提示"); assert.ok(/it\.downgradedFrom === "trait"\s*\?/.test(body) && body.includes("mneme-affective-flag"), "降级留痕要摆到明面上(曾按倾向记后降回场合)"); assert.ok(/it\.valence/.test(body) && /valencePositive|valenceNegative|valenceNeutral/.test(body), "向性要进 meta(词表外的词 valence=null,不渲染就是了)"); - assert.ok(/it\.originals\.length > 1/.test(body), - "归一组出现过的原词要可见,措辞漂移不能静默发生"); + // 判据不是「多于一个」:只有「高兴」、主词是「开心」时也漏了信息。 + assert.ok(/it\.originals\.some\(\(w\) => w !== it\.emotion\)/.test(body), + "归一组出现过的原词要可见——唯一原词不同于主词时同样要露出来"); assert.ok(/it\.firstSeen && it\.firstSeen !== it\.lastSeen/.test(body), "首现只在与最近不同时说"); // 首页就带 cursor 恒参:不带 cursor 的请求边帽=limit(200),组数永远到不了帽, // 服务端永远不发 next——翻页按钮就永远长不出来。 assert.ok(/cursor: opts\.cursor \?\? ""/.test(body), "首页必须按游标模式取(cursor 空串=从头翻第一页),否则 next 永远是 null"); - assert.ok(body.includes("loadMoreMain") && body.includes("mneme-affective-more"), - "下一页要真有按钮,不能只留截断提示"); + // 只认名字的话,把 onClick 改成空操作照样绿。这里锁三件事:按钮真的把 + // loadMoreMain 挂在 onClick 上、追加用的是响应里的新游标、末页按钮消失。 + assert.ok(/onClick: loadMoreMain/.test(body), + "「加载更多」按钮的 onClick 必须真的接 loadMoreMain(改成空操作就是假绿)"); + assert.ok(/next: page\.next/.test(body), + "追加后游标要取响应里的新 next——沿用旧 next 会在原地打转"); + assert.ok(/items: s\.items\.concat\(page\.items\)/.test(body), + "第二页要追加到现有列表,不是整体替换"); + assert.ok(/\bstate\.next\s*\n?\s*\?\s*h\("div", \{ className: "mneme-affective-more" \}/.test(body) + || /\bstate\.next[\s\S]{0,120}mneme-affective-more/.test(body), + "没有游标时不该再长出「加载更多」按钮(末页要收掉)"); }); // 过滤下的空 ≠ 没记过:两句话混用一句,用户会以为整条情绪线是空的。 @@ -4786,8 +4799,14 @@ test("affective filters hit the server params and keep filtered-empty apart from const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start); const body = clientSource.slice(start, end); + // 只看调用处对象的话,删掉 affectiveUrl 里设 emotion 的分支仍能过——请求串 + // 里其实没有 emotion。这里锁 URL 构造函数本身的两个 set。 + assert.ok(/q\.set\("person", opts\.person\)/.test(body), + "affectiveUrl 必须真的把 person 写进查询串"); + assert.ok(/q\.set\("emotion", opts\.emotion\)/.test(body), + "affectiveUrl 必须真的把 emotion 写进查询串(删掉这行过滤就形同虚设)"); assert.ok(/person: filters\.person, emotion: filters\.emotion/.test(body), - "过滤参数要真的进请求(服务端支持 person/emotion,#729)"); + "两参数要一起交给 affectiveUrl,不能只传一个"); assert.ok(/setFilters\(\{ person: "", emotion: "" \}\)/.test(body), "清除过滤要一键回到全量,不是让用户逐格删字"); assert.ok(body.includes("memory.affective.emptyFiltered"), @@ -4801,12 +4820,45 @@ test("affective journal rows surface the before/after delta", () => { const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start); const body = clientSource.slice(start, end); - assert.ok(/const journalDelta = \(j\) =>/.test(body), "delta 派生函数要存在"); - assert.ok(/j\.op === "rename" && before\?\.emotion && after\?\.emotion/.test(body), - "改词要显示词面变化(旧词 → 新词)"); - assert.ok(/if \(j\.op === "promote"\) return/.test(body) && /if \(j\.op === "restore"\) return/.test(body) - && /j\.op === "archive"/.test(body) && /j\.op === "demote"/.test(body), - "归档/恢复/升格/降格都要显示状态迁移(活跃 ↔ 已归档、场合 ↔ 倾向)"); + // 原先只匹配调用的形状,删掉渲染节点、甚至箭头写反都照样绿。这里把 + // journalDelta 整段抠出来真跑:输入是服务端真实写下的 before/after 形态。 + const from = body.indexOf("const journalDelta = (j) => {"); + assert.ok(from > -1, "delta 派生函数要存在"); + const to = body.indexOf("\n };", from); + assert.ok(to > from, "journalDelta 必须能整段取出"); + const fnSrc = body.slice(from, to + 10).split("\n") + .filter((line) => !line.trim().startsWith("//")).join("\n"); + const labels = { + oc: "场合", tr: "倾向", act: "活跃", arc: "已归档" + }; + const t = (k) => ({ + "memory.affective.occasion": labels.oc, + "memory.affective.trait": labels.tr, + "memory.affective.journalActive": labels.act, + "memory.affective.journalArchived": labels.arc + }[k] ?? k); + const journalDelta = new Function("t", `${fnSrc}\nreturn journalDelta;`)(t); + + // 改词:词面真的变了才画箭头。 + assert.equal(journalDelta({ op: "rename", before: '{"emotion":"高兴"}', after: '{"emotion":"开心"}' }), "高兴 → 开心"); + assert.equal(journalDelta({ op: "rename", before: '{"emotion":"开心"}', after: '{"emotion":"开心"}' }), ""); + + // 升格/降格:只在真的发生迁移时画。幂等复用(before 已 promoted)不许画假箭头。 + assert.equal(journalDelta({ op: "promote", before: '{"promotedToTrait":false}', after: '{"promotedToTrait":true}' }), "场合 → 倾向"); + assert.equal(journalDelta({ op: "promote", before: '{"promotedToTrait":true}', after: '{"promotedToTrait":true}' }), "", + "promote 幂等复用时前后都是 true,画箭头就是把没发生的事写进审计面"); + assert.equal(journalDelta({ op: "demote", before: '{"promotedToTrait":true}', after: '{"promotedToTrait":false}' }), "倾向 → 场合"); + + // 归档/恢复:看 archivedAt 的前后值,不看 op 字面。 + assert.equal(journalDelta({ op: "archive", before: '{"archivedAt":null}', after: '{"archivedAt":"2026-11-18T00:00:00.000Z"}' }), "活跃 → 已归档"); + assert.equal(journalDelta({ op: "archive", before: '{"archivedAt":"2026-11-18T00:00:00.000Z"}', after: '{"archivedAt":"2026-11-18T00:00:00.000Z"}' }), "", + "重复归档不该再画一次「活跃 → 已归档」"); + assert.equal(journalDelta({ op: "restore", before: '{"archivedAt":"2026-11-18T00:00:00.000Z"}', after: '{"archivedAt":null}' }), "已归档 → 活跃"); + assert.equal(journalDelta({ op: "restore", before: '{"archivedAt":null}', after: '{"archivedAt":null}' }), "", + "重复恢复(null → null)不该画「已归档 → 活跃」"); + + // 坏 JSON 退回空串:账本宁可少说,不错说。 + assert.equal(journalDelta({ op: "promote", before: "not json", after: "{}" }), ""); }); // formatRelativeTime(value, t) 的 t 是必填的:它内部要 t("memory.time.now") diff --git a/dsh-mneme/test/graph-api.test.js b/dsh-mneme/test/graph-api.test.js index 78ff9a4a..9995e7ab 100644 --- a/dsh-mneme/test/graph-api.test.js +++ b/dsh-mneme/test/graph-api.test.js @@ -433,6 +433,42 @@ test("#726 affective overview filters by person, emotion and attribution", async assert.equal(byAttr.items[0].person, "乙"); }); +// #750 复审 ⑥:过滤只比归一主词时,用户照着自己写的原词过滤会得零结果—— +// 「库里那组的主词是「开心」」这件事面板上看不出来。归一库里出现过的原词一并比。 +test("#750 affective emotion filter matches a non-canonical original word", async () => { + const { routes, service } = setup(); + const a = service.createEntity({ name: "桉桉", type: "person" }); + const thing = service.createEntity({ name: "答辩", type: "concept" }); + // 同一条边两次记录:主词归一成「开心」,原词分别「开心」与「高兴」。 + // normalize_key 指向主词,emotion 是各自写下的原词——这正是 #723 的存法。 + const add = (emotion, normalizeKey) => service.saveRelation({ + from_entity: a.id, to_entity: thing.id, relation_type: "affective_context", + memory_id: "m-" + emotion + normalizeKey, source: "llm", + metadata: { emotion, normalize_key: normalizeKey, attribution: "occasion", evidence: ["x"] } + }); + add("开心", "开心"); + add("高兴", "开心"); + const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/affective"); + const call = async (qs) => { + const r = new FakeRes(); + await route.handler(req("/api/dsh-mneme/semantic/graph/affective" + qs), r); + return JSON.parse(r.body); + }; + + const byCanonical = await call("?emotion=开心"); + assert.equal(byCanonical.items.length, 1, "主词照常命中"); + assert.equal(byCanonical.items[0].emotion, "开心", "显示主词,不是原词"); + // 原词的顺序取决于边序(同毫秒创建时不稳定),比集合不比次序。 + assert.deepEqual([...byCanonical.items[0].originals].sort(), ["开心", "高兴"], "组内原词全量保留"); + + const byOriginal = await call("?emotion=高兴"); + assert.equal(byOriginal.items.length, 1, "填原词也要能命中——否则用户按自己写过的词过滤会得零结果"); + assert.equal(byOriginal.items[0].edgeIds.length, 2, "命中就是整组,不是只回那一条原词的边"); + + const byOther = await call("?emotion=焦虑"); + assert.equal(byOther.items.length, 0, "不在组里的词仍然不命中(别把判据放宽成恒真)"); +}); + // #726:cursor 分页。组数超过一页时 next 给出游标、翻页接着走;解不开的游标 400。 // 第一页也要带 cursor 参数(空串=从头翻)——分页模式下边帽才放宽,组才翻得出去。 test("#726 affective overview paginates by cursor", async () => { @@ -587,6 +623,23 @@ test("#725 affective apply renames, archives, restores — and writes the journa const bad = await call({ op: "rename", edgeIds: ["no-such-edge"], emotion: "平静" }); assert.equal(bad.status, 404, "组内全部边失效时 404,不假装成功"); + // #750 复审 ⑧:51 条边时原先静默截到 50,被丢的边不进 failures, + // 面板看到 applied:50 + failures:[] 就当整组做完了。宁可整组拒,不许半做。 + const tooMany = await call({ op: "archive", edgeIds: Array.from({ length: 51 }, (_, i) => e1.id + "-synthetic-" + i) }); + assert.equal(tooMany.status, 400, "超上限整组拒,不静默截断"); + assert.equal(tooMany.body.error, "too-many-edges"); + assert.equal(tooMany.body.limit, 50); + assert.equal(tooMany.body.got, 51, "报出实际条数,调用方才知道该拆不拆"); + + // 反向对照:正好 50 条不被拒(上限是 50,不是 49)。这些 id 都不存在, + // 所以走完校验仍是 404「一条都没成」,但那是另一条路径,不是超限拒。 + const atLimit = await call({ op: "archive", edgeIds: Array.from({ length: 50 }, (_, i) => "nope-" + i) }); + assert.equal(atLimit.status, 404, "50 条正好在上限内,不该被超限拒掉"); + + // 拒绝在写任何一条边之前发生:上面那次超限调用不许留下归档痕迹。 + const untouched = service.relationById(e1.id); + assert.equal(untouched.metadata.archivedAt, undefined, "超限拒不能先把边写脏再报错"); + const jr = graphRoute(routes, "/api/dsh-mneme/semantic/graph/affective/journal"); const jres = new FakeRes(); await jr.handler(req("/api/dsh-mneme/semantic/graph/affective/journal"), jres);