@clawmem-ai/clawmem 0.1.15 → 0.1.17

package/src/memory.test.ts

@@ -1,5 +1,6 @@
-import { MemoryStore, scoreMemoryMatch } from "./memory.js";
+import { MemoryStore, mergeMemoryCandidates } from "./memory.js";
 import type { ParsedMemoryIssue } from "./types.js";
+import { sha256 } from "./utils.js";
 import { stringifyFlatYaml } from "./yaml.js";
 
 function memory(overrides: Partial<ParsedMemoryIssue> = {}): ParsedMemoryIssue {
@@ -41,15 +42,6 @@ function assert(condition: unknown, message: string): void {
   if (!condition) throw new Error(message);
 }
 
-function testConfig(): never {
-  return {
-    memoryRecallLimit: 5,
-    memoryAutoRecallLimit: 3,
-    turnCommentDelayMs: 1000,
-    summaryWaitTimeoutMs: 120000,
-  } as never;
-}
-
 async function testBackendSearchBuildsSingleCleanedQuery(): Promise<void> {
   const queries: string[] = [];
   const client = {
@@ -59,7 +51,7 @@ async function testBackendSearchBuildsSingleCleanedQuery(): Promise<void> {
       return [] as IssueRecord[];
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   await store.search([
     "<clawmem-context>",
     "- [11] Previous memory that should be stripped",
@@ -108,7 +100,7 @@ async function testBackendSearchPreferredForRecall(): Promise<void> {
       return searched;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const found = await store.search("redis rate limiting", 1);
 
   assert(queries.length === 1, "expected backend search to be called once");
@@ -132,7 +124,7 @@ async function testBackendSearchReturnsEmptyWithoutLexicalFallback(): Promise<vo
     listIssues: async () => issues,
     searchIssues: async () => [] as IssueRecord[],
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const found = await store.search("redis rate limiting", 5);
 
   assert(found.length === 0, "expected backend-only recall to return no results when the backend finds nothing");
@@ -143,7 +135,7 @@ async function testBackendSearchPropagatesErrors(): Promise<void> {
     repo: () => "owner/main-memory",
     searchIssues: async () => { throw new Error("search unavailable"); },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   let message = "";
   try {
     await store.search("redis rate limiting", 5);
@@ -154,23 +146,30 @@ async function testBackendSearchPropagatesErrors(): Promise<void> {
   assert(message.includes("search unavailable"), "expected backend failures to propagate instead of falling back locally");
 }
 
-function testCjkScoring(): void {
-  const billing = memory({
-    issueNumber: 3,
-    title: "Memory: 账单修复流程",
-    detail: "遇到账单不一致时，先核对 invoice_id，再补发 webhook。",
-    topics: ["账单", "支付"],
-  });
-  const unrelated = memory({
-    issueNumber: 4,
-    title: "Memory: 部署备注",
-    detail: "发布前需要确认灰度流量比例。",
-    topics: ["部署"],
-  });
-  const billingScore = scoreMemoryMatch(billing, "账单 webhook");
-  const unrelatedScore = scoreMemoryMatch(unrelated, "账单 webhook");
-  assert(billingScore > unrelatedScore, "expected Chinese query scoring to prefer the billing memory");
-  assert(billingScore > 0, "expected Chinese query to produce a positive match score");
+function testMergeMemoryCandidates(): void {
+  const merged = mergeMemoryCandidates(
+    [
+      {
+        candidateId: "abc",
+        detail: "Redis Lua scripts keep rate limiting atomic.",
+        topics: ["redis"],
+      },
+    ],
+    [
+      {
+        candidateId: "abc",
+        detail: "Redis Lua scripts keep rate limiting atomic.",
+        kind: "lesson",
+        topics: ["rate-limit"],
+        evidence: "User confirmed the production path uses Lua.",
+      },
+    ],
+  );
+
+  assert(merged.length === 1, "expected duplicate candidates to merge by candidateId");
+  assert(merged[0]?.kind === "lesson", "expected merged candidates to preserve new schema hints");
+  assert(JSON.stringify(merged[0]?.topics) === JSON.stringify(["rate-limit", "redis"]), "expected merged candidates to union topics");
+  assert(merged[0]?.evidence === "User confirmed the production path uses Lua.", "expected merged candidates to preserve evidence");
 }
 
 async function testStructuredStoreAndSchema(): Promise<void> {
@@ -178,6 +177,8 @@ async function testStructuredStoreAndSchema(): Promise<void> {
   const ensured: string[][] = [];
   const labels: LabelRecord[] = [{ name: "kind:lesson" }, { name: "topic:redis" }];
   const client = {
+    repo: () => "owner/main-memory",
+    searchIssues: async () => [] as IssueRecord[],
     listIssues: async () => [] as IssueRecord[],
     listLabels: async () => labels,
     ensureLabels: async (next: string[]) => { ensured.push(next); },
@@ -186,7 +187,7 @@ async function testStructuredStoreAndSchema(): Promise<void> {
       return { number: 99, title: payload.title };
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const result = await store.store({ detail: "Redis Lua scripts are required for atomic rate limiting.", kind: "Lesson", topics: ["Redis Ops", "rate_limit"] });
   const schema = await store.listSchema();
 
@@ -207,6 +208,47 @@ async function testStructuredStoreAndSchema(): Promise<void> {
   assert(schema.topics.includes("redis"), "expected schema to expose existing topic labels");
 }
 
+async function testListSchemaPrefersLabelsWithoutIssueScan(): Promise<void> {
+  const client = {
+    listLabels: async () => [{ name: "kind:lesson" }, { name: "topic:redis" }, { name: "topic:rate-limit" }],
+    listIssues: async () => { throw new Error("listSchema should not scan issues when label schema is available"); },
+  };
+  const store = new MemoryStore(client as never);
+  const schema = await store.listSchema();
+
+  assert(JSON.stringify(schema.kinds) === JSON.stringify(["lesson"]), "expected schema kinds to come from labels");
+  assert(JSON.stringify(schema.topics) === JSON.stringify(["rate-limit", "redis"]), "expected schema topics to come from labels");
+}
+
+async function testStoreDeduplicatesViaHashSearch(): Promise<void> {
+  const detail = "Redis Lua scripts are required for atomic rate limiting.";
+  const hash = sha256(detail);
+  const existing = memory({
+    issueNumber: 77,
+    detail,
+    memoryHash: hash,
+    kind: "lesson",
+    topics: ["redis-ops"],
+  });
+  const queries: string[] = [];
+  const client = {
+    repo: () => "owner/main-memory",
+    searchIssues: async (query: string) => {
+      queries.push(query);
+      return [issueFromMemory(existing)];
+    },
+    listIssues: async () => { throw new Error("store should not scan all active memories"); },
+    ensureLabels: async () => {},
+    createIssue: async () => { throw new Error("store should not create a duplicate issue"); },
+  };
+  const store = new MemoryStore(client as never);
+  const result = await store.store({ detail, kind: "lesson", topics: ["redis_ops"] });
+
+  assert(result.created === false, "expected hash search to reuse an existing exact duplicate");
+  assert(result.memory.issueNumber === 77, "expected hash search to return the existing memory");
+  assert(queries.length === 1 && queries[0]?.includes(hash), "expected store to query by memory hash");
+}
+
 async function testStoreKeepsFullAutoTitleAndSupportsExplicitTitle(): Promise<void> {
   const created: Array<{ title: string; body: string; labels: string[] }> = [];
   const client = {
@@ -218,7 +260,7 @@ async function testStoreKeepsFullAutoTitleAndSupportsExplicitTitle(): Promise<vo
       return { number: created.length + 100, title: payload.title };
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const longDetail = "Tech Decision #001: Frontend = React Native, Backend = FastAPI, Database = PostgreSQL, and analytics events must stay append-only for auditability.";
   const auto = await store.store({ detail: longDetail });
   const explicit = await store.store({ title: "Architecture Decision #001", detail: "Use React Native + FastAPI for the first mobile stack." });
@@ -255,6 +297,11 @@ async function testGetAndListMemories(): Promise<void> {
     })),
   ];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -266,7 +313,7 @@ async function testGetAndListMemories(): Promise<void> {
       });
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const exact = await store.get("4");
   const activeFacts = await store.listMemories({ status: "active", kind: "core-fact", limit: 10 });
   const sports = await store.listMemories({ status: "all", topic: "sports", limit: 10 });
@@ -288,6 +335,11 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
   ];
   const client = {
     repo: () => "owner/main-memory",
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -300,7 +352,7 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
     },
     searchIssues: async () => issues,
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const exact = await store.get("4");
   const recalled = await store.search("F1 Dota 2", 5);
 
@@ -323,6 +375,11 @@ async function testUpdateMemoryInPlace(): Promise<void> {
   const updatedIssues: Array<{ number: number; title?: string; body?: string }> = [];
   const syncedLabels: Array<{ number: number; labels: string[] }> = [];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -349,7 +406,7 @@ async function testUpdateMemoryInPlace(): Promise<void> {
       issue.labels = labels;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const updated = await store.update("4", {
     detail: "xiangz likes F1, watches Dota 2 as a viewer, and recently follows tennis.",
     topics: ["preferences", "sports"],
@@ -378,6 +435,11 @@ async function testUpdateSupportsExplicitRetitle(): Promise<void> {
   ];
   const updatedIssues: Array<{ number: number; title?: string; body?: string }> = [];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -399,13 +461,58 @@ async function testUpdateSupportsExplicitRetitle(): Promise<void> {
     },
     syncManagedLabels: async () => {},
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const updated = await store.update("20", { title: "Billing Audit Convention" });
 
   assert(updated?.title === "Memory: Billing Audit Convention", "expected memory_update to support explicit retitle");
   assert(updatedIssues[0]?.title === "Memory: Billing Audit Convention", "expected issue title patch to use the explicit retitle");
 }
 
+async function testUpdateUsesHashSearchForDuplicateCheck(): Promise<void> {
+  const currentDetail = "We use append-only audit events for billing changes.";
+  const conflictingDetail = "Billing events must stay append-only for auditability.";
+  const current = issueFromMemory(memory({
+    issueNumber: 20,
+    title: "Memory: billing convention",
+    detail: currentDetail,
+    memoryHash: sha256(currentDetail),
+    kind: "convention",
+  }));
+  const conflicting = issueFromMemory(memory({
+    issueNumber: 21,
+    title: "Memory: audit rule",
+    detail: conflictingDetail,
+    memoryHash: sha256(conflictingDetail),
+    kind: "convention",
+  }));
+  const queries: string[] = [];
+  const client = {
+    repo: () => "owner/main-memory",
+    getIssue: async (number: number) => {
+      if (number === 20) return current;
+      throw new Error("issue missing");
+    },
+    searchIssues: async (query: string) => {
+      queries.push(query);
+      return [conflicting];
+    },
+    listIssues: async () => { throw new Error("update should not scan all active memories when direct lookup/search are available"); },
+    ensureLabels: async () => {},
+    updateIssue: async () => { throw new Error("duplicate update should fail before mutating"); },
+    syncManagedLabels: async () => {},
+  };
+  const store = new MemoryStore(client as never);
+  let message = "";
+  try {
+    await store.update("20", { detail: conflictingDetail });
+  } catch (error) {
+    message = String(error);
+  }
+
+  assert(message.includes("[21]"), "expected duplicate detection to reference the conflicting memory");
+  assert(queries.length === 1 && queries[0]?.includes(sha256(conflictingDetail)), "expected update duplicate checks to search by memory hash");
+}
+
 async function testForgetClosesMemoryIssue(): Promise<void> {
   const issues: IssueRecord[] = [
     issueFromMemory(memory({
@@ -419,6 +526,11 @@ async function testForgetClosesMemoryIssue(): Promise<void> {
   const syncedLabels: Array<{ number: number; labels: string[] }> = [];
   const updatedIssues: Array<{ number: number; state?: "open" | "closed" }> = [];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -443,7 +555,7 @@ async function testForgetClosesMemoryIssue(): Promise<void> {
       return issue;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const forgotten = await store.forget("12");
 
   assert(forgotten?.status === "stale", "expected forgotten memory to be returned as stale");
@@ -456,14 +568,17 @@ async function main(): Promise<void> {
   await testBackendSearchPreferredForRecall();
   await testBackendSearchReturnsEmptyWithoutLexicalFallback();
   await testBackendSearchPropagatesErrors();
-  testCjkScoring();
+  testMergeMemoryCandidates();
   await testStructuredStoreAndSchema();
+  await testListSchemaPrefersLabelsWithoutIssueScan();
+  await testStoreDeduplicatesViaHashSearch();
   await testStoreKeepsFullAutoTitleAndSupportsExplicitTitle();
   await testGetAndListMemories();
   await testLegacyMemoriesWithoutSessionOrDate();
   await testUpdateMemoryInPlace();
   await testUpdateSupportsExplicitRetitle();
   await testForgetClosesMemoryIssue();
+  await testUpdateUsesHashSearchForDuplicateCheck();
   console.log("memory tests passed");
 }