@clawmem-ai/clawmem 0.1.12 → 0.1.14

package/src/memory.ts

@@ -3,7 +3,7 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { LABEL_MEMORY_STALE, MEMORY_TITLE_PREFIX, extractLabelNames, labelVal } from "./config.js";
 import type { GitHubIssueClient } from "./github-client.js";
 import { normalizeMessages } from "./transcript.js";
-import type { ClawMemPluginConfig, MemoryDraft, MemoryListOptions, MemorySchema, NormalizedMessage, ParsedMemoryIssue, SessionMirrorState, TranscriptSnapshot } from "./types.js";
+import type { ClawMemPluginConfig, MemoryDraft, MemoryListOptions, MemorySchema, ParsedMemoryIssue, SessionMirrorState, TranscriptSnapshot } from "./types.js";
 import { fmtTranscript, localDate, sha256, subKey } from "./utils.js";
 import { parseFlatYaml, stringifyFlatYaml } from "./yaml.js";
 
@@ -84,8 +84,8 @@ export class MemoryStore {
 
     const date = localDate();
     const labels = memLabels(normalized.kind, normalized.topics);
-    const title = `${MEMORY_TITLE_PREFIX}${trunc(detail, 72)}`;
-    const body = stringifyFlatYaml([["memory_hash", hash], ["date", date], ["detail", detail]]);
+    const title = renderMemoryTitle(normalized);
+    const body = renderMemoryBody(detail, hash, date);
     await this.client.ensureLabels(labels);
     const issue = await this.client.createIssue({ title, body, labels });
     return {
@@ -104,10 +104,15 @@ export class MemoryStore {
     };
   }
 
-  async update(memoryId: string, patch: { detail?: string; kind?: string; topics?: string[] }): Promise<ParsedMemoryIssue | null> {
+  async update(memoryId: string, patch: { title?: string; detail?: string; kind?: string; topics?: string[] }): Promise<ParsedMemoryIssue | null> {
     const current = await this.get(memoryId, "all");
     if (!current) return null;
     const nextDetail = typeof patch.detail === "string" && patch.detail.trim() ? norm(patch.detail) : current.detail;
+    const nextTitle = typeof patch.title === "string" && patch.title.trim()
+      ? renderMemoryTitle({ title: patch.title.trim(), detail: nextDetail })
+      : patch.detail !== undefined
+        ? renderMemoryTitle({ detail: nextDetail })
+        : current.title || renderMemoryTitle({ detail: nextDetail });
     const nextKind = patch.kind !== undefined ? normalizeLabelValue(patch.kind, "kind:") : current.kind;
     const nextTopics = patch.topics !== undefined
       ? uniqueNormalized(patch.topics.map((topic) => normalizeLabelValue(topic, "topic:")).filter(Boolean) as string[])
@@ -118,8 +123,7 @@ export class MemoryStore {
       return (memory.memoryHash || sha256(norm(memory.detail))) === nextHash;
     });
     if (duplicate) throw new Error(`another active memory already stores this detail as [${duplicate.memoryId}]`);
-    const nextTitle = `${MEMORY_TITLE_PREFIX}${trunc(nextDetail, 72)}`;
-    const nextBody = stringifyFlatYaml([["memory_hash", nextHash], ["date", current.date], ["detail", nextDetail]]);
+    const nextBody = renderMemoryBody(nextDetail, nextHash, current.date);
     const nextLabels = memLabels(nextKind, nextTopics);
     await this.client.ensureLabels(nextLabels);
     await this.client.updateIssue(current.issueNumber, { title: nextTitle, body: nextBody });
@@ -201,15 +205,16 @@ export class MemoryStore {
     const kind = labelVal(labels, "kind:");
     const topics = labels.filter((l) => l.startsWith("topic:")).map((l) => l.slice(6).trim()).filter(Boolean);
     const rawBody = (issue.body ?? "").trim();
-    const body = rawBody ? parseFlatYaml(rawBody) : {};
-    const detail = body.detail?.trim() || rawBody;
+    const parsed = parseStoredMemoryBody(rawBody);
+    const detail = parsed.detail?.trim() || rawBody;
     const status = issue.state === "closed" || labels.includes(LABEL_MEMORY_STALE) ? "stale" : "active";
     if (!detail) return null;
     return {
-      issueNumber: issue.number, title: issue.title?.trim() || "",
-      memoryId: body.memory_id?.trim() || String(issue.number),
-      memoryHash: body.memory_hash?.trim() || undefined,
-      date: body.date?.trim() || "1970-01-01",
+      issueNumber: issue.number,
+      title: issue.title?.trim() || "",
+      memoryId: parsed.meta.memory_id?.trim() || String(issue.number),
+      memoryHash: parsed.meta.memory_hash?.trim() || undefined,
+      date: parsed.meta.date?.trim() || "1970-01-01",
       detail,
       ...(kind ? { kind } : {}),
       ...(topics.length > 0 ? { topics } : {}),
@@ -235,8 +240,8 @@ export class MemoryStore {
       }
       const labels = memLabels(draft.kind, draft.topics);
       const date = localDate();
-      const title = `${MEMORY_TITLE_PREFIX}${trunc(detail, 72)}`;
-      const body = stringifyFlatYaml([["memory_hash", hash], ["date", date], ["detail", detail]]);
+      const title = renderMemoryTitle(draft);
+      const body = renderMemoryBody(detail, hash, date);
       await this.client.ensureLabels(labels);
       const issue = await this.client.createIssue({ title, body, labels });
       activeByHash.set(hash, {
@@ -279,8 +284,10 @@ export class MemoryStore {
     const sessionKey = subKey(session, "memory");
     const message = [
       "Extract durable memories from the conversation below.",
-      'Return JSON only in the form {"save":[{"detail":"...","kind":"...","topics":["..."]}],"stale":["memory-id"]}.',
+      'Return JSON only in the form {"save":[{"title":"...","detail":"...","kind":"...","topics":["..."]}],"stale":["memory-id"]}.',
+      "Each save item must contain one durable fact. If a turn contains several independent facts, save them separately instead of bundling them into one summary memory.",
       "Use save for stable, reusable facts, preferences, decisions, constraints, workflows, and ongoing context worth remembering later.",
+      "Title is optional. If you provide one, make it concise and human-readable.",
       "Use stale for existing memory IDs only when the conversation clearly supersedes or invalidates them.",
       "Infer kind and topics when they would help future retrieval. Reuse existing kinds and topics when possible.",
       "If no existing kind fits, you may propose a new short kind label. Keep kinds concise and reusable.",
@@ -293,9 +300,12 @@ export class MemoryStore {
     ].join("\n");
     try {
       const run = await subagent.run({
-        sessionKey, message, deliver: false, lane: "clawmem-memory",
+        sessionKey,
+        message,
+        deliver: false,
+        lane: "clawmem-memory",
         idempotencyKey: sha256(`${session.sessionId}:${snapshot.messages.length}:memory-decision`),
-        extraSystemPrompt: "You extract durable memory updates from OpenClaw conversations. Output JSON only with save objects containing detail, optional kind, and optional topics, plus stale string ids.",
+        extraSystemPrompt: "You extract durable memory updates from OpenClaw conversations. Output JSON only with save objects containing detail, optional title, optional kind, and optional topics, plus stale string ids. Keep each save item to one durable fact.",
       });
       const wait = await subagent.waitForRun({ runId: run.runId, timeoutMs: this.config.summaryWaitTimeoutMs });
       if (wait.status === "timeout") throw new Error("memory decision subagent timed out");
@@ -304,7 +314,9 @@ export class MemoryStore {
       const text = [...msgs].reverse().find((e) => e.role === "assistant" && e.text.trim())?.text;
       if (!text) throw new Error("memory decision subagent returned no assistant text");
       return parseDecision(text);
-    } finally { subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {}); }
+    } finally {
+      subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {});
+    }
   }
 
   private async mergeSchema(memory: ParsedMemoryIssue, draft: MemoryDraft): Promise<ParsedMemoryIssue> {
@@ -333,11 +345,42 @@ function memLabels(kind?: string, topics?: string[]): string[] {
     ...((topics ?? []).map((topic) => `topic:${topic}`)),
   ];
 }
+
+function renderMemoryTitle(draft: Pick<MemoryDraft, "detail" | "title">): string {
+  const raw = typeof draft.title === "string" && draft.title.trim() ? draft.title : draft.detail;
+  const normalized = norm(raw);
+  return normalized.startsWith(MEMORY_TITLE_PREFIX) ? normalized : `${MEMORY_TITLE_PREFIX}${normalized}`;
+}
+
+function renderMemoryBody(detail: string, memoryHash: string, date: string): string {
+  return stringifyFlatYaml([["memory_hash", memoryHash], ["date", date], ["detail", norm(detail)]]);
+}
+
+function parseStoredMemoryBody(rawBody: string): { detail: string; meta: Record<string, string> } {
+  const trimmed = rawBody.trim();
+  if (!trimmed) return { detail: "", meta: {} };
+
+  const legacyYaml = parseFlatYaml(trimmed);
+  if (legacyYaml.detail?.trim()) {
+    return { detail: legacyYaml.detail.trim(), meta: legacyYaml };
+  }
+
+  const hiddenMeta = /(?:^|\n)<!--\s*clawmem-meta\s*\n([\s\S]*?)\n-->\s*$/.exec(trimmed);
+  if (!hiddenMeta) {
+    return { detail: trimmed, meta: {} };
+  }
+
+  const meta = parseFlatYaml(hiddenMeta[1] ?? "");
+  const detail = trimmed.slice(0, hiddenMeta.index).trim() || meta.detail?.trim() || "";
+  return { detail, meta };
+}
+
 function norm(v: string): string { return v.replace(/\s+/g, " ").trim(); }
 function trunc(v: string, max: number): string { const s = norm(v); return s.length <= max ? s : `${s.slice(0, max - 1).trimEnd()}…`; }
 function normalizeSearch(v: string): string {
   return v.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim();
 }
+
 function buildSearchIndex(memory: ParsedMemoryIssue): SearchIndex {
   return {
     title: normalizeSearch(memory.title),
@@ -346,6 +389,7 @@ function buildSearchIndex(memory: ParsedMemoryIssue): SearchIndex {
     topics: (memory.topics ?? []).map(normalizeSearch).filter(Boolean),
   };
 }
+
 function searchTokens(v: string): string[] {
   const seen = new Set<string>();
   for (const token of v.split(/[^0-9\p{L}]+/u)) {
@@ -359,6 +403,7 @@ function searchTokens(v: string): string[] {
   }
   return [...seen];
 }
+
 function charBigrams(v: string): Set<string> {
   const compact = v.replace(/\s+/g, "");
   if (compact.length < 2) return new Set(compact ? [compact] : []);
@@ -366,16 +411,19 @@ function charBigrams(v: string): Set<string> {
   for (let i = 0; i < compact.length - 1; i++) out.add(compact.slice(i, i + 2));
   return out;
 }
+
 function overlapRatio(left: Set<string>, right: Set<string>): number {
   if (left.size === 0 || right.size === 0) return 0;
   let hits = 0;
   for (const token of left) if (right.has(token)) hits++;
   return hits / Math.max(left.size, right.size);
 }
+
 function buildMemorySearchQuery(query: string, repo: string): string {
   const parts = [query.trim(), `repo:${repo}`, "is:issue", "state:open", 'label:"type:memory"'].filter(Boolean);
   return parts.join(" ");
 }
+
 export function scoreMemoryMatch(memory: ParsedMemoryIssue, rawQuery: string): number {
   const query = normalizeSearch(rawQuery);
   if (!query) return 0;
@@ -411,17 +459,21 @@ export function scoreMemoryMatch(memory: ParsedMemoryIssue, rawQuery: string): n
 
   return score;
 }
+
 function normalizeDraft(input: MemoryDraft): MemoryDraft {
   const detail = norm(input.detail);
   if (!detail) throw new Error("memory detail is empty");
+  const title = typeof input.title === "string" && input.title.trim() ? norm(input.title) : undefined;
   const kind = normalizeLabelValue(input.kind, "kind:");
   const topics = uniqueNormalized((input.topics ?? []).map((topic) => normalizeLabelValue(topic, "topic:")).filter(Boolean) as string[]);
   return {
+    ...(title ? { title } : {}),
     detail,
     ...(kind ? { kind } : {}),
     ...(topics.length > 0 ? { topics } : {}),
   };
 }
+
 function normalizeLabelValue(value: string | undefined, prefix: string): string | undefined {
   if (!value) return undefined;
   const raw = value.trim().replace(new RegExp(`^${prefix}`, "i"), "");
@@ -433,6 +485,7 @@ function normalizeLabelValue(value: string | undefined, prefix: string): string
     .replace(/^-+|-+$/g, "");
   return normalized || undefined;
 }
+
 function normalizeOptionalLabelValue(value: string | undefined, prefix: string): string | undefined {
   try {
     return normalizeLabelValue(value, prefix);
@@ -440,16 +493,22 @@ function normalizeOptionalLabelValue(value: string | undefined, prefix: string):
     return undefined;
   }
 }
+
 function uniqueNormalized(values: string[]): string[] {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
 }
+
 function parseDecision(raw: string): MemoryDecision {
   const tryParse = (s: string): MemoryDecision | null => {
     try {
       const p = JSON.parse(s) as Record<string, unknown>;
-      return { save: Array.isArray(p.save) ? p.save.map(parseSaveItem).filter((v): v is MemoryDraft => Boolean(v)) : [],
-               stale: Array.isArray(p.stale) ? p.stale.filter((v): v is string => typeof v === "string") : [] };
-    } catch { return null; }
+      return {
+        save: Array.isArray(p.save) ? p.save.map(parseSaveItem).filter((v): v is MemoryDraft => Boolean(v)) : [],
+        stale: Array.isArray(p.stale) ? p.stale.filter((v): v is string => typeof v === "string") : [],
+      };
+    } catch {
+      return null;
+    }
   };
   const t = raw.trim();
   return tryParse(t) ?? (() => {
@@ -459,6 +518,7 @@ function parseDecision(raw: string): MemoryDecision {
     throw new Error("memory decision subagent returned invalid JSON");
   })();
 }
+
 function parseSaveItem(value: unknown): MemoryDraft | null {
   if (typeof value === "string") {
     const detail = norm(value);
@@ -466,12 +526,13 @@ function parseSaveItem(value: unknown): MemoryDraft | null {
   }
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
+  const title = typeof record.title === "string" ? record.title : undefined;
   const detail = typeof record.detail === "string" ? norm(record.detail) : "";
   if (!detail) return null;
   const kind = typeof record.kind === "string" ? record.kind : undefined;
   const topics = Array.isArray(record.topics) ? record.topics.filter((v): v is string => typeof v === "string") : undefined;
   try {
-    return normalizeDraft({ detail, ...(kind ? { kind } : {}), ...(topics ? { topics } : {}) });
+    return normalizeDraft({ ...(title ? { title } : {}), detail, ...(kind ? { kind } : {}), ...(topics ? { topics } : {}) });
   } catch {
     return null;
   }

package/src/service.test.ts

@@ -0,0 +1,141 @@
+import {
+  buildLegacyRelevantMemoriesContext,
+  buildRelevantMemoriesSystemContext,
+  extractPromptTextForRecall,
+  resolveOpenClawHostVersion,
+  resolvePromptHookMode,
+} from "./service.js";
+
+function assert(condition: unknown, message: string): void {
+  if (!condition) throw new Error(message);
+}
+
+function testExtractPromptFromString(): void {
+  assert(extractPromptTextForRecall("  help me fix redis  ") === "help me fix redis", "expected direct string prompts to be trimmed");
+}
+
+function testExtractPromptFromPromptField(): void {
+  assert(
+    extractPromptTextForRecall({ prompt: "Summarize the release notes." }) === "Summarize the release notes.",
+    "expected prompt field to be used when present",
+  );
+}
+
+function testExtractPromptFromLatestUserMessage(): void {
+  const prompt = extractPromptTextForRecall({
+    messages: [
+      { role: "assistant", text: "How can I help?" },
+      { role: "user", text: "Please fix the login bug." },
+    ],
+  });
+  assert(prompt === "Please fix the login bug.", "expected the latest user message to drive recall");
+}
+
+function testExtractPromptFromStructuredContent(): void {
+  const prompt = extractPromptTextForRecall({
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Check the deployment logs" },
+          { type: "text", text: "and verify nginx." },
+        ],
+      },
+    ],
+  });
+  assert(prompt === "Check the deployment logs\nand verify nginx.", "expected structured text content to be flattened");
+}
+
+function testBuildRelevantMemoriesSystemContext(): void {
+  const context = buildRelevantMemoriesSystemContext([
+    { detail: "OpenClaw main agent identity uses Gandalf." },
+    { detail: "Shared memories can break if the repo path changes." },
+  ]);
+
+  assert(context.includes("ClawMem relevant memories:"), "expected a human-readable heading");
+  assert(context.includes("- OpenClaw main agent identity uses Gandalf."), "expected memories to be listed as bullets");
+  assert(!context.includes("<relevant-memories>"), "expected the legacy XML wrapper to be removed");
+}
+
+function testBuildLegacyRelevantMemoriesContext(): void {
+  const context = buildLegacyRelevantMemoriesContext([
+    { detail: "Use the shared repo for team memory." },
+  ]);
+
+  assert(context.includes("Relevant ClawMem memories for this request:"), "expected a legacy-safe heading");
+  assert(context.includes("- Use the shared repo for team memory."), "expected memories to stay readable");
+  assert(!context.includes("<relevant-memories>"), "expected legacy context to avoid XML wrappers too");
+}
+
+function testResolveHostVersionFromRuntime(): void {
+  const version = resolveOpenClawHostVersion({ runtime: { version: "2026.3.28" } } as never);
+  assert(version === "2026.3.28", "expected runtime.version to take precedence");
+}
+
+function testResolveHostVersionFromEnvFallback(): void {
+  const previous = {
+    OPENCLAW_VERSION: process.env.OPENCLAW_VERSION,
+    OPENCLAW_SERVICE_VERSION: process.env.OPENCLAW_SERVICE_VERSION,
+    npm_package_version: process.env.npm_package_version,
+  };
+  try {
+    delete process.env.OPENCLAW_VERSION;
+    process.env.OPENCLAW_SERVICE_VERSION = "2026.3.6";
+    delete process.env.npm_package_version;
+    const version = resolveOpenClawHostVersion({ runtime: {} } as never);
+    assert(version === "2026.3.6", "expected OPENCLAW_SERVICE_VERSION fallback");
+  } finally {
+    process.env.OPENCLAW_VERSION = previous.OPENCLAW_VERSION;
+    process.env.OPENCLAW_SERVICE_VERSION = previous.OPENCLAW_SERVICE_VERSION;
+    process.env.npm_package_version = previous.npm_package_version;
+  }
+}
+
+function testIgnoresNpmPackageVersionFallback(): void {
+  const previous = {
+    OPENCLAW_VERSION: process.env.OPENCLAW_VERSION,
+    OPENCLAW_SERVICE_VERSION: process.env.OPENCLAW_SERVICE_VERSION,
+    npm_package_version: process.env.npm_package_version,
+  };
+  try {
+    delete process.env.OPENCLAW_VERSION;
+    delete process.env.OPENCLAW_SERVICE_VERSION;
+    process.env.npm_package_version = "2026.3.99";
+    const version = resolveOpenClawHostVersion({ runtime: {} } as never);
+    assert(version === undefined, "expected npm_package_version to be ignored for host detection");
+  } finally {
+    process.env.OPENCLAW_VERSION = previous.OPENCLAW_VERSION;
+    process.env.OPENCLAW_SERVICE_VERSION = previous.OPENCLAW_SERVICE_VERSION;
+    process.env.npm_package_version = previous.npm_package_version;
+  }
+}
+
+function testResolvePromptHookModeModern(): void {
+  const mode = resolvePromptHookMode({ runtime: { version: "2026.3.28" } } as never);
+  assert(mode === "modern", "expected modern hook mode for OpenClaw 2026.3.28");
+}
+
+function testResolvePromptHookModeLegacy(): void {
+  const mode = resolvePromptHookMode({ runtime: { version: "2026.3.6" } } as never);
+  assert(mode === "legacy", "expected legacy hook mode before 2026.3.7");
+}
+
+function testResolvePromptHookModeLegacyForUnknownVersion(): void {
+  const mode = resolvePromptHookMode({ runtime: {} } as never);
+  assert(mode === "legacy", "expected unknown host versions to fall back to legacy mode");
+}
+
+testExtractPromptFromString();
+testExtractPromptFromPromptField();
+testExtractPromptFromLatestUserMessage();
+testExtractPromptFromStructuredContent();
+testBuildRelevantMemoriesSystemContext();
+testBuildLegacyRelevantMemoriesContext();
+testResolveHostVersionFromRuntime();
+testResolveHostVersionFromEnvFallback();
+testIgnoresNpmPackageVersionFallback();
+testResolvePromptHookModeModern();
+testResolvePromptHookModeLegacy();
+testResolvePromptHookModeLegacyForUnknownVersion();
+
+console.log("service tests passed");