@clawmem-ai/clawmem 0.1.16 → 0.1.18

package/src/service.test.ts

@@ -1,5 +1,7 @@
 import {
+  buildClawMemPromptSection,
   buildAutoRecallContext,
+  createClawMemPlugin,
   extractPromptTextForRecall,
   resolveOpenClawHostVersion,
   resolvePromptHookMode,
@@ -75,6 +77,185 @@ function testBuildAutoRecallContext(): void {
   assert(context.includes("- [11] OpenClaw main agent identity uses Gandalf."), "expected memories to be listed as bullets");
 }
 
+function testBuildClawMemPromptSection(): void {
+  const lines = buildClawMemPromptSection({
+    availableTools: new Set([
+      "memory_recall",
+      "memory_list",
+      "memory_get",
+      "memory_repos",
+      "memory_labels",
+      "memory_store",
+      "memory_update",
+      "memory_forget",
+    ]),
+  });
+  const prompt = lines.join("\n");
+
+  assert(lines[0] === "## ClawMem", "expected a stable heading for always-on ClawMem guidance");
+  assert(prompt.includes("active long-term memory system"), "expected the prompt to frame ClawMem as the active memory system");
+  assert(prompt.includes("`memory_recall`, `memory_list`, and `memory_get`"), "expected explicit retrieval guidance");
+  assert(prompt.includes("`memory_store` and `memory_update`"), "expected explicit save guidance");
+  assert(prompt.includes("`memory_forget`"), "expected explicit stale-memory guidance");
+  assert(prompt.includes("Store one durable fact per memory."), "expected one-fact-per-memory guidance");
+  assert(prompt.includes("Skip temporary requests, tool chatter"), "expected anti-noise write guardrails");
+  assert(prompt.includes("explicit short `title` plus a fuller `detail`"), "expected explicit title guidance");
+  assert(prompt.includes("user's current language"), "expected language guidance for new memories");
+  assert(prompt.includes("`memory_labels`"), "expected schema reuse guidance to mention memory_labels");
+  assert(prompt.includes("translated or near-duplicate variant"), "expected anti-duplication schema guidance");
+}
+
+function createFakePluginApi(options?: {
+  slot?: string;
+  exposeCapability?: boolean;
+  exposePromptSection?: boolean;
+  runtimeVersion?: string;
+}) {
+  let registeredCapability: { promptBuilder?: typeof buildClawMemPromptSection } | undefined;
+  let registeredPromptSection: typeof buildClawMemPromptSection | undefined;
+  const handlers = new Map<string, Array<(...args: any[]) => unknown>>();
+  const warnings: string[] = [];
+  const infos: string[] = [];
+  const api = {
+    id: "clawmem",
+    name: "ClawMem",
+    source: "test",
+    registrationMode: "test",
+    config: {},
+    pluginConfig: {
+      agents: {
+        main: {
+          token: "test-token",
+          defaultRepo: "acme/memory",
+        },
+      },
+    },
+    logger: {
+      info: (message: string) => { infos.push(message); },
+      warn: (message: string) => { warnings.push(message); },
+    },
+    runtime: {
+      version: options?.runtimeVersion ?? "2026.4.9",
+      config: {
+        loadConfig: () => ({
+          plugins: {
+            slots: {
+              memory: options?.slot ?? "clawmem",
+            },
+          },
+        }),
+      },
+      events: {
+        onSessionTranscriptUpdate: () => () => {},
+      },
+      subagent: {},
+    },
+    on: (event: string, handler: (...args: any[]) => unknown) => {
+      const current = handlers.get(event) ?? [];
+      current.push(handler);
+      handlers.set(event, current);
+    },
+    registerTool: () => {},
+    registerService: () => {},
+    ...(options?.exposeCapability === false
+      ? {}
+      : {
+          registerMemoryCapability: (capability: { promptBuilder?: typeof buildClawMemPromptSection }) => {
+            registeredCapability = capability;
+          },
+        }),
+    ...(options?.exposePromptSection === false
+      ? {}
+      : {
+          registerMemoryPromptSection: (builder: typeof buildClawMemPromptSection) => {
+            registeredPromptSection = builder;
+          },
+        }),
+  };
+
+  return {
+    api,
+    getRegisteredCapability: () => registeredCapability,
+    getRegisteredPromptSection: () => registeredPromptSection,
+    getWarnings: () => warnings,
+    getInfos: () => infos,
+    getHandler: (event: string) => handlers.get(event)?.[0],
+  };
+}
+
+function testRegistersAlwaysOnMemoryPromptCapability(): void {
+  const fake = createFakePluginApi();
+  createClawMemPlugin(fake.api as never);
+
+  const capability = fake.getRegisteredCapability();
+  assert(Boolean(capability?.promptBuilder), "expected ClawMem to register a memory prompt builder");
+  const prompt = capability?.promptBuilder?.({ availableTools: new Set(["memory_recall", "memory_store"]) }).join("\n") ?? "";
+  assert(prompt.includes("## ClawMem"), "expected the registered prompt builder to emit ClawMem guidance");
+}
+
+function testFallsBackToLegacyMemoryPromptSectionRegistration(): void {
+  const fake = createFakePluginApi({ exposeCapability: false });
+  createClawMemPlugin(fake.api as never);
+
+  assert(!fake.getRegisteredCapability(), "expected no memory capability registration when the host lacks that API");
+  const builder = fake.getRegisteredPromptSection();
+  assert(Boolean(builder), "expected fallback registration through registerMemoryPromptSection");
+  const prompt = builder?.({ availableTools: new Set(["memory_recall"]) }).join("\n") ?? "";
+  assert(prompt.includes("## ClawMem"), "expected the fallback builder to emit ClawMem guidance");
+}
+
+function testOlderHostWithoutPromptRegistrationDoesNotWarn(): void {
+  const fake = createFakePluginApi({
+    exposeCapability: false,
+    exposePromptSection: false,
+    runtimeVersion: "2026.3.13",
+  });
+  createClawMemPlugin(fake.api as never);
+
+  assert(fake.getWarnings().length === 0, "expected older hosts without prompt registration to avoid warnings");
+  assert(
+    fake.getInfos().some((message) => message.includes("falling back to before_prompt_build prependSystemContext")),
+    "expected older hosts to log an informational compatibility note",
+  );
+}
+
+function testModernHostWithoutPromptRegistrationWarns(): void {
+  const fake = createFakePluginApi({
+    exposeCapability: false,
+    exposePromptSection: false,
+    runtimeVersion: "2026.3.22",
+  });
+  createClawMemPlugin(fake.api as never);
+
+  assert(
+    fake.getWarnings().some((message) => message.includes("falling back to before_prompt_build prependSystemContext")),
+    "expected warning when a new-enough host is missing prompt registration",
+  );
+}
+
+async function testOlderModernHostInjectsPromptGuidanceViaPrependSystemContext(): Promise<void> {
+  const fake = createFakePluginApi({
+    exposeCapability: false,
+    exposePromptSection: false,
+    runtimeVersion: "2026.3.13",
+  });
+  createClawMemPlugin(fake.api as never);
+
+  const handler = fake.getHandler("before_prompt_build");
+  assert(typeof handler === "function", "expected before_prompt_build handler to be registered for modern hosts");
+  const result = await handler?.({ prompt: "hi" }, { agentId: "main" }) as { prependContext?: string; prependSystemContext?: string } | void;
+  assert(Boolean(result && result.prependSystemContext?.includes("## ClawMem")), "expected static ClawMem guidance to use prependSystemContext fallback");
+  assert(!result || !result.prependContext, "expected no dynamic recall context when the prompt is too short for auto-recall");
+}
+
+function testSkipsAlwaysOnPromptWhenClawMemIsNotSelectedMemoryPlugin(): void {
+  const fake = createFakePluginApi({ slot: "other-memory" });
+  createClawMemPlugin(fake.api as never);
+
+  assert(!fake.getRegisteredCapability(), "expected no memory prompt registration when ClawMem is not the selected memory plugin");
+  assert(!fake.getRegisteredPromptSection(), "expected no legacy prompt registration when ClawMem is not selected");
+}
+
 function testResolveHostVersionFromRuntime(): void {
   const version = resolveOpenClawHostVersion({ runtime: { version: "2026.3.28" } } as never);
   assert(version === "2026.3.28", "expected runtime.version to take precedence");
@@ -139,11 +320,18 @@ testExtractPromptFallsBackToLatestUserMessage();
 testExtractPromptFromPromptField();
 testExtractPromptFromStructuredContent();
 testBuildAutoRecallContext();
+testBuildClawMemPromptSection();
 testResolveHostVersionFromRuntime();
 testResolveHostVersionFromEnvFallback();
 testIgnoresNpmPackageVersionFallback();
 testResolvePromptHookModeModern();
 testResolvePromptHookModeLegacy();
 testResolvePromptHookModeLegacyForUnknownVersion();
+testRegistersAlwaysOnMemoryPromptCapability();
+testFallsBackToLegacyMemoryPromptSectionRegistration();
+testOlderHostWithoutPromptRegistrationDoesNotWarn();
+testModernHostWithoutPromptRegistrationWarns();
+testSkipsAlwaysOnPromptWhenClawMemIsNotSelectedMemoryPlugin();
+await testOlderModernHostInjectsPromptGuidanceViaPrependSystemContext();
 
 console.log("service tests passed");