@modusensus/dsh-mneme 0.6.6 → 0.6.8

package/test/provenance.test.js

@@ -1,103 +1,103 @@
-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 { createService } from "../src/service.js";
-import { createTools } from "../src/tools.js";
-
-const openMemory = () => createStore(":memory:");
-
-// Memory provenance (v0.5.x): every memory born from a session carries its
-// session_id so v0.6.0 reasoning-path / interest-drift analysis can rebuild
-// the derivation chain later. session_id is birth provenance — set once at
-// creation, preserved by merges, never fabricated when no session exists.
-
-test("save persists session_id and returns it", () => {
-  const store = openMemory();
-  const saved = store.save({
-    type: "preference",
-    title: "A",
-    content: "c",
-    tags: [],
-    importance: 3,
-    source: "tool",
-    session_id: "session-42"
-  });
-  assert.equal(saved.session_id, "session-42");
-  assert.equal(store.getById(saved.id).session_id, "session-42");
-  store.close();
-});
-
-test("save without session_id leaves it undefined (never fabricated)", () => {
-  const store = openMemory();
-  const saved = store.save({ type: "history", title: "B", content: "c" });
-  assert.equal(saved.session_id, undefined);
-  store.close();
-});
-
-test("dedupe merge keeps the ORIGINAL session_id (provenance = birth)", () => {
-  const store = openMemory();
-  const service = createService({ store, mirror: null, config: {} });
-  service.saveWithDedupe({
-    type: "preference", title: "语言", content: "中文", session_id: "session-1"
-  });
-  const merged = service.saveWithDedupe({
-    type: "preference", title: "语言", content: "中文 + 英文", session_id: "session-2"
-  });
-  assert.equal(merged.action, "merged");
-  assert.equal(store.getById(merged.memory.id).session_id, "session-1");
-  store.close();
-});
-
-test("memory_save tool records exec.agent.session.id as session_id", async () => {
-  const store = openMemory();
-  const service = createService({ store, mirror: null, config: {} });
-  const ctx = { tools: { register() { return () => {}; } } };
-  const tools = createTools(ctx, service, {}, undefined);
-  const saveTool = tools.find((t) => t.name === "memory_save");
-  const out = await saveTool.execute(
-    { type: "decision", title: "T", content: "c" },
-    { agent: { session: { id: "session-tool-9" } } }
-  );
-  assert.equal(store.getById(out.id).session_id, "session-tool-9");
-  store.close();
-});
-
-test("memory_save tool without agent context leaves session_id null", async () => {
-  const store = openMemory();
-  const service = createService({ store, mirror: null, config: {} });
-  const ctx = { tools: { register() { return () => {}; } } };
-  const tools = createTools(ctx, service, {}, undefined);
-  const saveTool = tools.find((t) => t.name === "memory_save");
-  const out = await saveTool.execute({ type: "decision", title: "T2", content: "c" }, {});
-  assert.equal(store.getById(out.id).session_id, undefined);
-  store.close();
-});
-
-test("legacy DB without session_id column migrates and saves with provenance", () => {
-  const dir = mkdtempSync(join(tmpdir(), "mneme-prov-"));
-  const dbPath = join(dir, "legacy.db");
-  const db = new DatabaseSync(dbPath);
-  db.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, content_history TEXT, embedding TEXT,
-    epistemic_status TEXT NOT NULL DEFAULT 'subjective',
-    last_accessed_at TEXT, _full_content TEXT,
-    created_at TEXT NOT NULL, updated_at TEXT NOT NULL
-  );`);
-  db.close();
-  const store = createStore(dbPath);
-  const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
-  assert.ok(cols.includes("session_id"), "session_id column added by migration");
-  const saved = store.save({
-    type: "history", title: "旧库", content: "迁移后仍可溯源", session_id: "session-legacy"
-  });
-  assert.equal(store.getById(saved.id).session_id, "session-legacy");
-  store.close();
-  rmSync(dir, { recursive: true, force: true });
-});
+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 { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+const openMemory = () => createStore(":memory:");
+
+// Memory provenance (v0.5.x): every memory born from a session carries its
+// session_id so v0.6.0 reasoning-path / interest-drift analysis can rebuild
+// the derivation chain later. session_id is birth provenance — set once at
+// creation, preserved by merges, never fabricated when no session exists.
+
+test("save persists session_id and returns it", () => {
+  const store = openMemory();
+  const saved = store.save({
+    type: "preference",
+    title: "A",
+    content: "c",
+    tags: [],
+    importance: 3,
+    source: "tool",
+    session_id: "session-42"
+  });
+  assert.equal(saved.session_id, "session-42");
+  assert.equal(store.getById(saved.id).session_id, "session-42");
+  store.close();
+});
+
+test("save without session_id leaves it undefined (never fabricated)", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "history", title: "B", content: "c" });
+  assert.equal(saved.session_id, undefined);
+  store.close();
+});
+
+test("dedupe merge keeps the ORIGINAL session_id (provenance = birth)", () => {
+  const store = openMemory();
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({
+    type: "preference", title: "语言", content: "中文", session_id: "session-1"
+  });
+  const merged = service.saveWithDedupe({
+    type: "preference", title: "语言", content: "中文 + 英文", session_id: "session-2"
+  });
+  assert.equal(merged.action, "merged");
+  assert.equal(store.getById(merged.memory.id).session_id, "session-1");
+  store.close();
+});
+
+test("memory_save tool records exec.agent.session.id as session_id", async () => {
+  const store = openMemory();
+  const service = createService({ store, mirror: null, config: {} });
+  const ctx = { tools: { register() { return () => {}; } } };
+  const tools = createTools(ctx, service, {}, undefined);
+  const saveTool = tools.find((t) => t.name === "memory_save");
+  const out = await saveTool.execute(
+    { type: "decision", title: "T", content: "c" },
+    { agent: { session: { id: "session-tool-9" } } }
+  );
+  assert.equal(store.getById(out.id).session_id, "session-tool-9");
+  store.close();
+});
+
+test("memory_save tool without agent context leaves session_id null", async () => {
+  const store = openMemory();
+  const service = createService({ store, mirror: null, config: {} });
+  const ctx = { tools: { register() { return () => {}; } } };
+  const tools = createTools(ctx, service, {}, undefined);
+  const saveTool = tools.find((t) => t.name === "memory_save");
+  const out = await saveTool.execute({ type: "decision", title: "T2", content: "c" }, {});
+  assert.equal(store.getById(out.id).session_id, undefined);
+  store.close();
+});
+
+test("legacy DB without session_id column migrates and saves with provenance", () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-prov-"));
+  const dbPath = join(dir, "legacy.db");
+  const db = new DatabaseSync(dbPath);
+  db.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, content_history TEXT, embedding TEXT,
+    epistemic_status TEXT NOT NULL DEFAULT 'subjective',
+    last_accessed_at TEXT, _full_content TEXT,
+    created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+  );`);
+  db.close();
+  const store = createStore(dbPath);
+  const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
+  assert.ok(cols.includes("session_id"), "session_id column added by migration");
+  const saved = store.save({
+    type: "history", title: "旧库", content: "迁移后仍可溯源", session_id: "session-legacy"
+  });
+  assert.equal(store.getById(saved.id).session_id, "session-legacy");
+  store.close();
+  rmSync(dir, { recursive: true, force: true });
+});

package/test/quality-filter.test.js

@@ -1,118 +1,118 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import {
-  evaluateMemoryQuality,
-  META_MEMORY_RE,
-  textSimilarity,
-  dedupRatio
-} from "../src/quality-filter.js";
-
-// Bug7: rule-based memory quality filter. Gated on
-// config.memoryQualityFilter.enabled === true — raw configs (`{}`) keep the
-// legacy behavior. Score bands:
-//   >= 60       stored normally
-//   30 .. < 60  quality_score persisted, injection ranked by importance × score/100
-//   < 30        archived + tagged low_quality (explicit search still recalls it)
-
-function setup(over = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: { memoryQualityFilter: { enabled: true }, ...over } });
-  return { store, service };
-}
-
-test("evaluateMemoryQuality: meta-memory scores below 60 (degraded, not archived)", () => {
-  const { score, tags } = evaluateMemoryQuality({
-    type: "history",
-    title: "对话总结",
-    content: "总结一下刚才的对话，需要记住以下要点"
-  });
-  assert.ok(score >= 30 && score < 60, `meta memory should be degraded (30..60), got ${score}`);
-  assert.ok(tags.includes("meta"), "tagged meta");
-});
-
-test("evaluateMemoryQuality: short content is archived (< 30)", () => {
-  const { score, tags } = evaluateMemoryQuality({ type: "preference", title: "语言", content: "短" });
-  assert.ok(score < 30, `short content should be archived, got ${score}`);
-  assert.ok(tags.includes("short_content"));
-  assert.ok(tags.includes("low_quality"));
-});
-
-test("evaluateMemoryQuality: near-duplicate of a recent memory is archived", () => {
-  const { score, tags } = evaluateMemoryQuality(
-    { type: "preference", title: "重复", content: "猫咪喜欢在阳台晒太阳并打盹" },
-    { recentContents: ["猫咪喜欢在阳台晒太阳并打盹"] }
-  );
-  assert.ok(score < 30, `duplicate should be archived, got ${score}`);
-  assert.ok(tags.includes("duplicate"));
-});
-
-test("saveWithDedupe: meta memory persists quality_score < 60 and is not archived", () => {
-  const { store, service } = setup();
-  const { memory } = service.saveWithDedupe({
-    type: "history",
-    title: "对话总结",
-    content: "总结一下刚才的对话，需要记住以下要点"
-  });
-  const got = store.getById(memory.id);
-  assert.ok(got.quality_score !== undefined && got.quality_score < 60,
-    `meta memory should store quality_score < 60, got ${got.quality_score}`);
-  assert.equal(got.archived, false, "degraded memory stays un-archived");
-});
-
-test("saveWithDedupe: short text is archived + tagged low_quality", () => {
-  const { store, service } = setup();
-  const { memory } = service.saveWithDedupe({
-    type: "preference",
-    title: "语言",
-    content: "短"
-  });
-  const got = store.getById(memory.id);
-  assert.equal(got.archived, true, "short text archived");
-  assert.ok(got.tags.includes("low_quality"), "tagged low_quality");
-  assert.ok(got.quality_score < 30, `score below archive threshold, got ${got.quality_score}`);
-});
-
-test("saveWithDedupe: near-duplicate content is archived", () => {
-  const { store, service } = setup();
-  service.saveWithDedupe({ type: "preference", title: "习惯一", content: "猫咪喜欢在阳台晒太阳并打盹" });
-  const { memory: dup } = service.saveWithDedupe({ type: "preference", title: "习惯二", content: "猫咪喜欢在阳台晒太阳并打盹" });
-  const got = store.getById(dup.id);
-  assert.equal(got.archived, true, "near-duplicate archived");
-  assert.ok(got.tags.includes("low_quality"));
-});
-
-test("saveWithDedupe: filter disabled (raw config) skips scoring entirely", () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const { memory } = service.saveWithDedupe({ type: "preference", title: "语言", content: "短" });
-  const got = store.getById(memory.id);
-  assert.equal(got.archived, false, "nothing archived when filter off");
-  assert.equal(got.quality_score, undefined, "no quality_score when filter off");
-  assert.ok(!got.tags.includes("low_quality"));
-});
-
-test("injectCandidates: degraded memory ranks below a healthy preference", () => {
-  const { service } = setup();
-  // Healthy preference: score 100 → weight 1.0 → 3 * 1.0 = 3.0.
-  service.saveWithDedupe({ type: "preference", title: "健康偏好", content: "用户平时习惯用中文交流", importance: 3 });
-  // Degraded (meta-memory) preference: score ~55 → weight 0.55 → 5 * 0.55 = 2.75.
-  service.saveWithDedupe({ type: "preference", title: "元记忆偏好", content: "总结一下刚才的对话内容吧", importance: 5 });
-  const candidates = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  const titles = candidates.map((c) => c.title);
-  assert.ok(titles.includes("健康偏好"), "healthy preference present");
-  assert.ok(titles.includes("元记忆偏好"), "degraded preference present");
-  assert.ok(titles.indexOf("健康偏好") < titles.indexOf("元记忆偏好"),
-    "degraded memory is demoted below the healthy one");
-});
-
-test("exported helpers behave (meta regex, similarity, dedup ratio)", () => {
-  assert.ok(META_MEMORY_RE.test("总结一下刚才的对话"));
-  assert.ok(META_MEMORY_RE.test("作为AI助手，我需要记住"));
-  assert.ok(!META_MEMORY_RE.test("用户喜欢喝咖啡"));
-  assert.equal(textSimilarity("猫咪喜欢晒太阳", "猫咪喜欢晒太阳"), 1);
-  assert.ok(textSimilarity("猫咪喜欢晒太阳", "完全不同的内容") < 0.3);
-  assert.ok(dedupRatio("哈哈哈哈哈哈") < 0.3, "repetitive filler has low dedup ratio");
-  assert.ok(dedupRatio("一句信息量足够的话") > 0.3);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import {
+  evaluateMemoryQuality,
+  META_MEMORY_RE,
+  textSimilarity,
+  dedupRatio
+} from "../src/quality-filter.js";
+
+// Bug7: rule-based memory quality filter. Gated on
+// config.memoryQualityFilter.enabled === true — raw configs (`{}`) keep the
+// legacy behavior. Score bands:
+//   >= 60       stored normally
+//   30 .. < 60  quality_score persisted, injection ranked by importance × score/100
+//   < 30        archived + tagged low_quality (explicit search still recalls it)
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { memoryQualityFilter: { enabled: true }, ...over } });
+  return { store, service };
+}
+
+test("evaluateMemoryQuality: meta-memory scores below 60 (degraded, not archived)", () => {
+  const { score, tags } = evaluateMemoryQuality({
+    type: "history",
+    title: "对话总结",
+    content: "总结一下刚才的对话，需要记住以下要点"
+  });
+  assert.ok(score >= 30 && score < 60, `meta memory should be degraded (30..60), got ${score}`);
+  assert.ok(tags.includes("meta"), "tagged meta");
+});
+
+test("evaluateMemoryQuality: short content is archived (< 30)", () => {
+  const { score, tags } = evaluateMemoryQuality({ type: "preference", title: "语言", content: "短" });
+  assert.ok(score < 30, `short content should be archived, got ${score}`);
+  assert.ok(tags.includes("short_content"));
+  assert.ok(tags.includes("low_quality"));
+});
+
+test("evaluateMemoryQuality: near-duplicate of a recent memory is archived", () => {
+  const { score, tags } = evaluateMemoryQuality(
+    { type: "preference", title: "重复", content: "猫咪喜欢在阳台晒太阳并打盹" },
+    { recentContents: ["猫咪喜欢在阳台晒太阳并打盹"] }
+  );
+  assert.ok(score < 30, `duplicate should be archived, got ${score}`);
+  assert.ok(tags.includes("duplicate"));
+});
+
+test("saveWithDedupe: meta memory persists quality_score < 60 and is not archived", () => {
+  const { store, service } = setup();
+  const { memory } = service.saveWithDedupe({
+    type: "history",
+    title: "对话总结",
+    content: "总结一下刚才的对话，需要记住以下要点"
+  });
+  const got = store.getById(memory.id);
+  assert.ok(got.quality_score !== undefined && got.quality_score < 60,
+    `meta memory should store quality_score < 60, got ${got.quality_score}`);
+  assert.equal(got.archived, false, "degraded memory stays un-archived");
+});
+
+test("saveWithDedupe: short text is archived + tagged low_quality", () => {
+  const { store, service } = setup();
+  const { memory } = service.saveWithDedupe({
+    type: "preference",
+    title: "语言",
+    content: "短"
+  });
+  const got = store.getById(memory.id);
+  assert.equal(got.archived, true, "short text archived");
+  assert.ok(got.tags.includes("low_quality"), "tagged low_quality");
+  assert.ok(got.quality_score < 30, `score below archive threshold, got ${got.quality_score}`);
+});
+
+test("saveWithDedupe: near-duplicate content is archived", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "习惯一", content: "猫咪喜欢在阳台晒太阳并打盹" });
+  const { memory: dup } = service.saveWithDedupe({ type: "preference", title: "习惯二", content: "猫咪喜欢在阳台晒太阳并打盹" });
+  const got = store.getById(dup.id);
+  assert.equal(got.archived, true, "near-duplicate archived");
+  assert.ok(got.tags.includes("low_quality"));
+});
+
+test("saveWithDedupe: filter disabled (raw config) skips scoring entirely", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const { memory } = service.saveWithDedupe({ type: "preference", title: "语言", content: "短" });
+  const got = store.getById(memory.id);
+  assert.equal(got.archived, false, "nothing archived when filter off");
+  assert.equal(got.quality_score, undefined, "no quality_score when filter off");
+  assert.ok(!got.tags.includes("low_quality"));
+});
+
+test("injectCandidates: degraded memory ranks below a healthy preference", () => {
+  const { service } = setup();
+  // Healthy preference: score 100 → weight 1.0 → 3 * 1.0 = 3.0.
+  service.saveWithDedupe({ type: "preference", title: "健康偏好", content: "用户平时习惯用中文交流", importance: 3 });
+  // Degraded (meta-memory) preference: score ~55 → weight 0.55 → 5 * 0.55 = 2.75.
+  service.saveWithDedupe({ type: "preference", title: "元记忆偏好", content: "总结一下刚才的对话内容吧", importance: 5 });
+  const candidates = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  const titles = candidates.map((c) => c.title);
+  assert.ok(titles.includes("健康偏好"), "healthy preference present");
+  assert.ok(titles.includes("元记忆偏好"), "degraded preference present");
+  assert.ok(titles.indexOf("健康偏好") < titles.indexOf("元记忆偏好"),
+    "degraded memory is demoted below the healthy one");
+});
+
+test("exported helpers behave (meta regex, similarity, dedup ratio)", () => {
+  assert.ok(META_MEMORY_RE.test("总结一下刚才的对话"));
+  assert.ok(META_MEMORY_RE.test("作为AI助手，我需要记住"));
+  assert.ok(!META_MEMORY_RE.test("用户喜欢喝咖啡"));
+  assert.equal(textSimilarity("猫咪喜欢晒太阳", "猫咪喜欢晒太阳"), 1);
+  assert.ok(textSimilarity("猫咪喜欢晒太阳", "完全不同的内容") < 0.3);
+  assert.ok(dedupRatio("哈哈哈哈哈哈") < 0.3, "repetitive filler has low dedup ratio");
+  assert.ok(dedupRatio("一句信息量足够的话") > 0.3);
+});