@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/test/dream.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { validateDecisions, applyDecisions, createDreamScheduler } from "../src/dream.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
-import { mockCtx } from "./helpers/dream-mock.js";
+import { mockCtx, sessionDecisions } from "./helpers/dream-mock.js";
 
 function snapshot(ids, type = "project") {
   return new Map(ids.map((id, i) => [id, { id, type, title: `t${i}`, content: `c${i}`, importance: 3, archived: false, forgotten: false }]));
@@ -905,6 +905,67 @@ test("runDream sliding window keeps the newest N memories and excludes the oldes
   store.close();
 });
 
+// --- issue #557：dream 审计行输入快照瘦身（dreamInputSummaryEnabled）-----------
+//
+// dream_runs.input 单行体积随记忆量涨（#557 实测平均 40-79 KB/轮，大头是
+// content），轮数又随天数涨，超线性。本组用例锁三件事：
+//   ① 默认关 = 审计行逐字节一致（content 原样落库）；
+//   ② 开启后 auto 轮只落骨架（id/type/title/importance/updated_at），且
+//      input_count / snapshot_hash / receipt / decisions 都不变——瘦身的只是
+//      落库副本，LLM 输入与 receipt 完整性不受影响；
+//   ③ organize 轮的重放载荷不经过 dream.js 的快照构造（结构性分叉），这里锁
+//      auto 路径的形状，organize 侧由 organize.test.js 的 apply 重放用例兜住。
+
+test("issue#557: 默认关 = 审计行快照带 content（行为与改动前一致）", async () => {
+  const { store, service } = dreamSetup();
+  const content = "很长的正文，瘦身前应原样落库。".repeat(20);
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content, importance: 3 });
+  }
+  const ctx = mockCtx({ onConsolidation: sessionDecisions });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat"
+  });
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.input_count, 3);
+  assert.deepEqual(
+    Object.keys(run.input[0]).sort(),
+    ["content", "id", "importance", "title", "type", "updated_at"],
+    "默认快照含 content"
+  );
+  assert.equal(run.input[0].content, content, "content 原样落库");
+  store.close();
+});
+
+test("issue#557: dreamInputSummaryEnabled 开启后快照只留骨架，判定与回执不变", async () => {
+  const { store, service } = dreamSetup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `很长的正文${i}`.repeat(20), importance: 3 });
+  }
+  const ctx = mockCtx({ onConsolidation: sessionDecisions });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat",
+    dreamInputSummaryEnabled: true
+  });
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.input_count, 3, "input_count 语义不变");
+  for (const m of run.input) {
+    assert.deepEqual(
+      Object.keys(m).sort(),
+      ["id", "importance", "title", "type", "updated_at"],
+      "瘦身快照不含 content"
+    );
+  }
+  assert.deepEqual(run.input.map((m) => m.title).sort(), ["主题0", "主题1", "主题2"], "骨架字段带出标题");
+  assert.ok(run.snapshot_hash && run.snapshot_hash.length === 64, "snapshot_hash 形状不变（内存里对含 content 快照计算）");
+  assert.match(run.receipt, /^dsh-mneme:run:/, "receipt 形状不变");
+  assert.ok(Array.isArray(run.decisions) && run.decisions.length > 0, "决策不受影响");
+  assert.ok(JSON.stringify(run.input).length < 2048, "骨架行确实小（content 不在）");
+  store.close();
+});
+
 // --- v0.4.4 fix: 决策 JSON schema 固化（kimi 等模型输出合规） -----------------
 
 test("consolidation prompt pins the decision schema (action field, single-string winner/loser, single claim per id)", async () => {

package/test/dsh-go-host.test.js

@@ -0,0 +1,134 @@
+// src/dsh-go/host.js —— 进程内派发的判据。
+//
+// 这个文件锁的是「面板能不能拿到宿主真的答复」，而不是某一屏长什么样：
+//   - 请求体必须在 handler 挂好监听之后再 flush，否则 readBody 永远等不到 end；
+//   - handler 返回 undefined 但稍后才 res.end（/version-check 就是这样）时，
+//     调用方必须等到响应真的结束，不能拿着空 body 当成结果；
+//   - 配了 apiToken 之后写路由要带令牌，否则被自家路由注册器拦成 401；
+//   - 超时、未注册路径都要抛错，而不是返回一个空对象让面板显示成「0 条」。
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createHostCall } from "../src/dsh-go/host.js";
+
+function fakeServer(routes) {
+  return {
+    match(pathname) {
+      const handler = routes[pathname];
+      return handler === undefined ? undefined : { kind: "exact", path: pathname, handler };
+    },
+  };
+}
+
+function readAll(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += String(chunk);
+    });
+    req.on("end", () => resolve(data));
+  });
+}
+
+const ctxWith = (routes) => ({ get: (name) => (name === "webServer" ? fakeServer(routes) : undefined) });
+
+test("进程内调用能读到请求体，并且同步响应即可返回", async () => {
+  let seen = null;
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/echo": (req, res) => {
+        seen = { method: req.method, url: req.url };
+        void readAll(req).then((body) => {
+          seen.body = body;
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ ok: true, body: JSON.parse(body) }));
+        });
+      },
+    }),
+  );
+  const result = await call("/echo", { method: "POST", body: { title: "x" } });
+  assert.deepEqual(result, { ok: true, body: { title: "x" } });
+  assert.equal(seen.method, "POST");
+  assert.equal(seen.body, JSON.stringify({ title: "x" }));
+});
+
+test("handler 同步返回 undefined、稍后 res.end 时仍然等到响应结束", async () => {
+  // /version-check 的真实形状：handler 立即 return，答复在 promise 回调里写完。
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/version-check": (req, res) => {
+        setTimeout(() => {
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ version: "0.10.1", status: "latest" }));
+        }, 5);
+        return undefined;
+      },
+    }),
+  );
+  const result = await call("/version-check");
+  assert.equal(result.version, "0.10.1");
+  assert.equal(result.status, "latest");
+});
+
+test("配了 apiToken 就把令牌放进 x-dsh-mneme-token 头", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/update": (req, res) => {
+        const token = req.headers["x-dsh-mneme-token"] ?? "";
+        res.writeHead(token === "secret-token" ? 200 : 401);
+        res.end(JSON.stringify(token === "secret-token" ? { ok: true } : { error: "unauthorized" }));
+      },
+    }),
+    { apiToken: "secret-token" },
+  );
+  assert.deepEqual(await call("/update", { method: "POST", body: { id: "m1" } }), { ok: true });
+});
+
+test("没有令牌时写路由的 401 会变成异常，而不是空结果", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/update": (req, res) => {
+        res.writeHead(401);
+        res.end(JSON.stringify({ error: "unauthorized" }));
+      },
+    }),
+  );
+  await assert.rejects(call("/update", { method: "POST", body: { id: "m1" } }), /401/);
+});
+
+test("未注册的路径直接报错，不会静默返回空对象", async () => {
+  const call = createHostCall(ctxWith({}));
+  await assert.rejects(call("/list"), /mneme 未注册/);
+});
+
+test("宿主没有 webServer 时报错", async () => {
+  const call = createHostCall({ get: () => undefined });
+  await assert.rejects(call("/list"), /webServer 不可用/);
+});
+
+test("超时抛错（避免面板永远等着）", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/slow": () => {
+        // 永不响应
+      },
+    }),
+  );
+  await assert.rejects(call("/slow", { timeoutMs: 30 }), /超时/);
+});
+
+test("空响应体归一成 {}，非 JSON 归一成 { text }", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/empty": (req, res) => {
+        res.writeHead(200);
+        res.end("");
+      },
+      "/api/dsh-mneme/plain": (req, res) => {
+        res.writeHead(200);
+        res.end("hello");
+      },
+    }),
+  );
+  assert.deepEqual(await call("/empty"), {});
+  assert.deepEqual(await call("/plain"), { text: "hello" });
+});