@modusensus/dsh-mneme 0.7.10 → 0.7.12

package/test/tools.test.js

@@ -0,0 +1,265 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { assertSupportedJsonSchema, validateJsonSchemaValue } from "@deepseek-ai/dsh-tools";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+function setup(embedder) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = {
+    tools: {
+      register(def) {
+        registered.push(def);
+        return () => {};
+      }
+    }
+  };
+  const tools = createTools(ctx, service, {}, embedder);
+  return { store, service, tools, registered };
+}
+
+// Collect authoring-DSL regressions in a compiled schema: property-level
+// `required: true` (must be projected to a top-level required array by
+// defineTool) and `minimum`/`maximum` (outside the enforced subset) are
+// rejected by the real harness, so they must never appear post-compilation.
+function walkSchema(node, path, problems) {
+  if (typeof node !== "object" || node === null || Array.isArray(node)) return;
+  if (typeof node.required === "boolean") {
+    problems.push(`${path}.required must be an array (property-level required leaks through)`);
+  }
+  if (Object.hasOwn(node, "minimum") || Object.hasOwn(node, "maximum")) {
+    problems.push(`${path} uses minimum/maximum, which the enforced JSON Schema subset rejects`);
+  }
+  if (node.properties && typeof node.properties === "object") {
+    for (const [key, value] of Object.entries(node.properties)) {
+      walkSchema(value, `${path}.properties.${key}`, problems);
+    }
+  }
+  if (node.items) walkSchema(node.items, `${path}.items`, problems);
+  if (Array.isArray(node.oneOf)) {
+    node.oneOf.forEach((branch, index) => walkSchema(branch, `${path}.oneOf[${index}]`, problems));
+  }
+}
+
+test("registers seven tools with correct names", () => {
+  const { registered } = setup();
+  const names = registered.map((t) => t.name).sort();
+  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_list", "memory_save", "memory_search", "memory_update"]);
+});
+
+test("compiled schemas pass the enforced DSH subset (defineTool projection)", () => {
+  const { registered } = setup();
+  assert.equal(registered.length, 7);
+  for (const tool of registered) {
+    assertSupportedJsonSchema(tool.parameters);
+    assertSupportedJsonSchema(tool.output.schema);
+    const problems = [];
+    walkSchema(tool.parameters, `parameters(${tool.name})`, problems);
+    walkSchema(tool.output.schema, `output.schema(${tool.name})`, problems);
+    assert.deepEqual(problems, []);
+  }
+});
+
+test("memory_save executes and stores", async () => {
+  const { registered, store } = setup();
+  const save = registered.find((t) => t.name === "memory_save");
+  const result = await save.execute({ type: "preference", title: "语言", content: "中文", importance: 4 });
+  assert.equal(result.action, "created");
+  assert.equal(store.count(), 1);
+});
+
+test("memory_save merges on matching title within type", async () => {
+  const { registered, store } = setup();
+  const save = registered.find((t) => t.name === "memory_save");
+  const first = await save.execute({ type: "preference", title: "语言", content: "中文" });
+  const second = await save.execute({ type: "preference", title: "语言", content: "简体中文" });
+  assert.equal(first.action, "created");
+  assert.equal(second.action, "merged");
+  assert.equal(first.id, second.id);
+  assert.equal(store.count(), 1);
+});
+
+test("memory_search finds by CJK substring", async () => {
+  const { registered, store, service } = setup();
+  service.saveWithDedupe({ type: "project", title: "记忆插件", content: "SQLite 存储中文记忆", importance: 3 });
+  const search = registered.find((t) => t.name === "memory_search");
+  const result = await search.execute({ query: "中文" });
+  assert.ok(result.items.length >= 1);
+  assert.equal(result.items[0].title, "记忆插件");
+});
+
+test("memory_list filters by type", async () => {
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "a", content: "x" });
+  service.saveWithDedupe({ type: "project", title: "b", content: "y" });
+  const list = registered.find((t) => t.name === "memory_list");
+  const result = await list.execute({ type: "project" });
+  assert.equal(result.items.length, 1);
+  assert.equal(result.items[0].title, "b");
+});
+
+test("memory_list total reflects the type filter", async () => {
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "a", content: "x" });
+  service.saveWithDedupe({ type: "preference", title: "b", content: "y" });
+  service.saveWithDedupe({ type: "project", title: "c", content: "z" });
+  const list = registered.find((t) => t.name === "memory_list");
+  const projectRes = await list.execute({ type: "project" });
+  assert.equal(projectRes.total, 1);
+  const allRes = await list.execute({});
+  assert.equal(allRes.total, 3);
+});
+
+test("memory_update modifies an entry", async () => {
+  const { registered, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "decision", title: "t", content: "c" });
+  const update = registered.find((t) => t.name === "memory_update");
+  const result = await update.execute({ id: memory.id, content: "updated" });
+  assert.equal(result.memory.content, "updated");
+});
+
+test("memory_update on missing id rejects", async () => {
+  const { registered } = setup();
+  const update = registered.find((t) => t.name === "memory_update");
+  await assert.rejects(() => update.execute({ id: "missing", content: "x" }), /memory not found/);
+});
+
+test("memory_delete removes an entry", async () => {
+  const { registered, service, store } = setup();
+  const { memory } = service.saveWithDedupe({ type: "decision", title: "t", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  await del.execute({ id: memory.id });
+  assert.equal(store.count(), 0);
+});
+
+test("memory_delete on missing id returns deleted:false", async () => {
+  const { registered } = setup();
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: "missing" });
+  assert.equal(result.deleted, false);
+});
+
+test("memory_forget suppresses injection without deleting", async () => {
+  const { registered, service, store } = setup();
+  const { memory } = service.saveWithDedupe({ type: "project", title: "t", content: "c", importance: 5 });
+  const forget = registered.find((t) => t.name === "memory_forget");
+  const result = await forget.execute({ id: memory.id });
+  assert.equal(result.memory.forgotten, true);
+  assert.equal(store.count(undefined, { includeForgotten: true }), 1, "still stored but suppressed");
+});
+
+test("memory_forget on missing id rejects", async () => {
+  const { registered } = setup();
+  const forget = registered.find((t) => t.name === "memory_forget");
+  await assert.rejects(() => forget.execute({ id: "missing" }), /memory not found/);
+});
+
+test("memory_forget restores with forgotten:false", async () => {
+  const { registered, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "project", title: "t", content: "c", importance: 5 });
+  const forget = registered.find((t) => t.name === "memory_forget");
+  await forget.execute({ id: memory.id });
+  const restored = await forget.execute({ id: memory.id, forgotten: false });
+  assert.equal(restored.memory.forgotten, false);
+});
+
+test("execution results validate against their declared output schemas", async () => {
+  const { registered, service } = setup();
+  const byName = (n) => registered.find((t) => t.name === n);
+
+  const saved = await byName("memory_save").execute({ type: "decision", title: "x", content: "y", tags: ["k"], source: "test" });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_save").output.schema, saved), []);
+
+  service.saveWithDedupe({ type: "project", title: "p", content: "q" });
+  const searchRes = await byName("memory_search").execute({ query: "q" });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_search").output.schema, searchRes), []);
+
+  const listRes = await byName("memory_list").execute({});
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_list").output.schema, listRes), []);
+
+  const updRes = await byName("memory_update").execute({ id: saved.id, content: "z" });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_update").output.schema, updRes), []);
+
+  const forgetRes = await byName("memory_forget").execute({ id: saved.id });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_forget").output.schema, forgetRes), []);
+
+  const delRes = await byName("memory_delete").execute({ id: saved.id });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_delete").output.schema, delRes), []);
+});
+
+test("memory_search semantic mode merges vector recalls", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  const embedder = { embed: async () => [1, 0, 0] };
+  createTools(ctx, service, {}, embedder);
+
+  const v = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  store.setEmbedding(v.memory.id, [1, 0, 0]);
+  service.saveWithDedupe({ type: "preference", title: "狗", content: "喜欢狗" });
+
+  const search = registered.find((t) => t.name === "memory_search");
+  // literal query matches only 猫; vector recall also surfaces it via embedding
+  const res = await search.execute({ query: "猫", semantic: true });
+  assert.ok(res.items.some((m) => m.title === "猫"), "vector + keyword merged result contains the hit");
+  // mode=vector keeps keyword items too (dedup merge)
+  const res2 = await search.execute({ query: "猫", mode: "vector" });
+  assert.ok(res2.items.some((m) => m.title === "猫"));
+});
+
+test("memory_search falls back to keyword when embedder unavailable or returns null", async () => {
+  // No embedder passed → plain keyword search still works.
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const search = registered.find((t) => t.name === "memory_search");
+  const res = await search.execute({ query: "中文", semantic: true });
+  assert.equal(res.items.length, 1);
+  assert.equal(res.items[0].title, "语言");
+
+  // Embedder that resolves null (provider disabled) → keyword fallback.
+  const store = createStore(":memory:");
+  const service2 = createService({ store, mirror: null, config: {} });
+  const registered2 = [];
+  const ctx = { tools: { register(def) { registered2.push(def); return () => {}; } } };
+  createTools(ctx, service2, {}, { embed: async () => null });
+  service2.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const search2 = registered2.find((t) => t.name === "memory_search");
+  const res2 = await search2.execute({ query: "中文", semantic: true });
+  assert.equal(res2.items.length, 1);
+});
+
+// --- memory_archive (item ⑤: archive + verifiable recovery) ----------------
+
+test("memory_archive hides an entry and memory_unarchive restores it", async () => {
+  const { registered, service } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "project", title: "t", content: "c" });
+  const archive = registered.find((t) => t.name === "memory_archive");
+  const archived = await archive.execute({ id: m.id });
+  assert.equal(archived.memory.archived, true);
+  assert.ok(!service.list({ type: "project" }).some((x) => x.id === m.id), "archived hidden from default list");
+  const restored = await archive.execute({ id: m.id, archived: false });
+  assert.equal(restored.memory.archived, false);
+  assert.ok(service.list({ type: "project" }).some((x) => x.id === m.id), "restored entry visible again");
+});
+
+test("memory_list include_archived lists hidden entries so they can be restored", async () => {
+  const { registered, service } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "preference", title: "a", content: "x" });
+  service.setArchived(m.id, true);
+  const list = registered.find((t) => t.name === "memory_list");
+  const hidden = await list.execute({ type: "preference", include_archived: true });
+  assert.ok(hidden.items.some((x) => x.id === m.id), "archived entry discoverable");
+  assert.equal(hidden.total, 1, "total counts the archived entry");
+  const visible = await list.execute({ type: "preference" });
+  assert.ok(!visible.items.some((x) => x.id === m.id), "archived entry hidden by default");
+});
+
+test("memory_archive on missing id rejects", async () => {
+  const { registered } = setup();
+  const archive = registered.find((t) => t.name === "memory_archive");
+  await assert.rejects(() => archive.execute({ id: "missing" }), /memory not found/);
+});

package/.github/workflows/publish.yml

@@ -1,58 +0,0 @@
-name: Publish to npm
-
-# 发布路径：registry.npmjs.org 在本机云服务器被出口 SNI 过滤 + 17897 隧道不稳定，
-# 改由 GitHub runner 发布（不依赖本机出网）。打 v* tag 自动触发，或 workflow_dispatch 手动。
-#
-# ⚠️ 版本号机制（血的教训）：
-#   root package.json 在 git 里永远停在 0.7.2，真实版本号在 dsh-mneme/package.json。
-#   npm 在跑 prepublishOnly 之前就已加载 manifest，脚本里改 root 版本不生效，
-#   会把 root 的旧版本（0.7.2）发出去。必须在 npm publish 之前显式同步 root 版本。
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org/
-
-      - name: Registry current state (diagnostic)
-        run: |
-          npm view @modusensus/dsh-mneme versions --json || true
-          npm view @modusensus/dsh-mneme time --json || true
-
-      # 关键：先同步 root 版本 → 再 publish（prepublishOnly 改版本不可靠）
-      - name: Sync root version from dsh-mneme
-        run: |
-          V="$(node -p "require('./dsh-mneme/package.json').version")"
-          echo "Syncing root package.json to v${V}"
-          node -e "const fs=require('fs');const v=process.argv[1];const p=JSON.parse(fs.readFileSync('./package.json','utf8'));p.version=v;fs.writeFileSync('./package.json',JSON.stringify(p,null,2)+'\n')" "$V"
-          node -p "console.log('root now:', require('./package.json').version)"
-
-      - name: Publish @modusensus/dsh-mneme (skip if exists)
-        run: |
-          V="$(node -p "require('./dsh-mneme/package.json').version")"
-          if npm view "@modusensus/dsh-mneme@${V}" version >/dev/null 2>&1; then
-            echo "v${V} already published on registry — skipping"
-          else
-            npm publish
-          fi
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Verify published version
-        run: |
-          V="$(node -p "require('./dsh-mneme/package.json').version")"
-          echo "Published: $(npm view "@modusensus/dsh-mneme@${V}" version)"

package/.github/workflows/test.yml

@@ -1,32 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches: [master, main]
-  pull_request:
-    branches: [master, main]
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [24]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install dependencies
-        working-directory: dsh-mneme
-        run: npm ci
-      - name: Run tests
-        working-directory: dsh-mneme
-        run: npm run test:coverage
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          files: dsh-mneme/coverage/lcov.info
-          fail_ci_if_error: false

package/CHANGELOG.md

@@ -1,91 +0,0 @@
-# Changelog
-
-> **完整版本历史见 [dsh-mneme/CHANGELOG.md](dsh-mneme/CHANGELOG.md)**（正式版本正源，0.3.8 → 0.7.9）。以下为仓库早期开发记录（0.1.0–0.2.x，2026-08-13~14，已归档）。
-
-All notable changes to dsh-mneme are documented here.
-
-## [Unreleased]
-
-- **诚实审计修复（v0.2.7，F-03）**
-  - autoDream 决策无变更且 summary 为空时，不再误报 ok:true——新增 `noop` 状态（ok:false，baseline 不刷新），避免空跑循环
-  - 有变更但 summary 缺失 → `degraded`（ok:true 但如实标记 summary 缺失）
-  - parseReceipt 支持 ok/noop/degraded/reconcile/failed
-  - 测试 259 → **263**
-
-- **社区贡献 · 嵌入式面板 UI 改进（PR #2，@Liuxin4950）**
-  - 记忆面板与设置面板的嵌入模式（settings.section 插槽）不再复用弹窗面板样式（去掉 boxShadow / background / borderRadius / padding），改为全宽平铺渲染，消除 DSH 设置页内多余的悬浮卡片与阴影
-  - 弹窗（portal）模式保持原有面板样式不变；新增回归测试锁定 embedded 分支不携带 modal chrome
-
-- **安全审计修复（v0.2.5）**
-  - 并发安全：CAS 冲突守卫——过期快照不再覆盖并发写入（防丢更新）
-  - 事务化决策应用：merge/archive 原子提交，receipt 反映已提交子步骤，部分提交 = reconcile（绝不虚报 ok）
-  - 压测硬断言：lost-update 与多步原子性失败即非零退出（`npm run stress`）
-  - 运行时人工编辑三方合并（three-way），不再静默覆盖
-  - 新增 `memory_archive` 工具（第 7 个模型工具）+ `memory_list include_archived`，归档可恢复
-  - reranker 改为 opt-in：`rerankEnabled=false`、`rerankProvider=none` 默认（裸装不加载 onnxruntime）
-  - npm `files` 纳入 scripts/test，tarball 内可直接跑压测
-  - 测试 236 → **258**（+22）
-
-- **安全加固（v0.2.4）**：API 鉴权 `apiToken`（写操作与密钥端点要求 Bearer 校验）+ `apiKey` 掩码回传 + timing-safe token 比对
-
-- **审查修复补丁（v0.2.3）**
-  - failure 记录增加 `before` JSON 快照（title/content/importance 变更可追溯，不只 content）
-  - vector-index `rebuildIndex` guard 改为检查 `embedSingle`（修复 embed/embedSingle 不一致导致的静默跳过）
-
-- **流水线补全（v0.2.2）**
-  - reflection 修复：failure 记录检查 title/importance 变化（不只 content）；支持 query 上下文（memory_update 加 `reason` 参数）；update 校验失败不污染 claimed；`failure_memories` 清理（`deleteOldFailures` + 启动自动清理 90 天前）
-  - 专项测试补全：`vector-index.test.js`（modelHash 漂移/重建/增量）+ `service-search.test.js`（hybrid/auto/rerank 端到端）
-  - api.js `/search` 的 mode 参数文档化
-  - 测试 212 → **233**
-
-- **反思更新（v0.2.1）**：`update` 决策 + 失败追踪
-  - autoDream 新增 `update` 决策类型：修正单条记忆的过时/错误内容（单 id、必须实际变化、非 summary、24h 保护、每次 ≤2）
-  - 审计记录 update 的 `_before` 快照；update 后向量索引同步
-  - `failure_memories` 表：记录用户纠正（user_correction）+ 查询/统计接口
-  - 配置：`reflectionUpdateEnabled` / `reflectionFailureTracking` / `reflectionUpdateMaxPerRun` / `reflectionUpdateMinAgeHours`
-
-- **Semantic 升级（v0.2.0-semantic）**：完全离线语义记忆引擎
-  - 本地 Embedding：`embedProvider: local`（ONNX bge-small-zh-v1.5，transformers.js/onnxruntime）或 `ollama`；原 `openai` 外部 API 保留为默认，向后兼容
-  - 向量索引层：`vector_meta` 模型指纹追踪 + 索引统计（`/api/dsh-mneme/semantic`）
-  - Rerank 精排：`rerankEnabled`（bge-reranker-base cross-encoder），召回后精排 Top-K，失败自动跳过
-  - 混合搜索：`memory_search` 新增 `mode: hybrid`（向量优先 + 关键词补位）；`auto` 保持关键词优先 + 向量补位
-  - autoDream 语义增强：K-Means 聚类预分组（k-means++）、`[潜在冲突]` 向量相似度标记、整理后向量索引重建
-  - 模型下载：断点续传 + 缓存（transformers.js 内置）；`.npmrc` 跳过 onnxruntime CUDA 下载避免安装失败
-  - 文档：`docs/SEMANTIC.md` / `docs/LOCAL_MODEL.md` / `docs/MIGRATION.md` + 基准脚本 `benchmark-embed` / `benchmark-rerank`
-- autoDream 裁决审计：每次运行写入 `dream_runs`（输入快照 sha256 digest + 完整输入快照 + LLM 决策清单 + 逐 id 去向 + receipt `dsh-mneme:run:<id>:<status>:<hash>:<count>:<applied>`），可离线回放、定位静默错误
-- 幂等决策应用：merge / conflict 重复应用无累积副作用（来源注释不重复追加），防并发/重放下的重复合并
-- 三轴线压测 `npm run stress`：长会话检索（Recall@k、陈旧残留率）/ 冲突裁决（可重放仲裁集）/ 多 Agent 并发（丢更新、重复合并、事务/崩溃恢复）
-
-## [0.1.6] - 2026-08-14
-
-- Vector (semantic) search via OpenAI-compatible embeddings endpoint, with automatic fallback to LIKE keyword search on failure
-- Web GUI memory panel: browse by type, full-text + semantic search
-
-## [0.1.5] - 2026-08-14
-
-- autoDream consolidation refinements: conflict resolution with source tracking, fail-safe decision validation
-
-## [0.1.4] - 2026-08-14
-
-- User settings: profile + behavior rules injected every turn
-- Custom slash commands (register, route to agent)
-
-## [0.1.3] - 2026-08-14
-
-- autoDream background consolidation: dedup / merge / archive / conflict resolution
-
-## [0.1.2] - 2026-08-14
-
-- Session summarization: auto-distill preferences / decisions / lessons at session end
-- Web panel improvements
-
-## [0.1.1] - 2026-08-13
-
-- Memory tools: memory_save / memory_search / memory_list / memory_update / memory_delete / memory_forget
-- Markdown mirror sync (human-editable, manual edits take priority)
-
-## [0.1.0] - 2026-08-13
-
-- Initial release: cross-session memory for DeepSeek Harness
-- SQLite store (node:sqlite, zero native deps) + human-editable Markdown mirror
-- Auto-injection of relevant memories at session start