@clawmem-ai/clawmem 0.1.3

package/src/state.ts

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { PluginState } from "./types.js";
+
+const EMPTY_STATE: PluginState = {
+  version: 1,
+  sessions: {},
+};
+
+export function resolveStatePath(stateDir: string): string {
+  return path.join(stateDir, "clawmem", "state.json");
+}
+
+export async function loadState(filePath: string): Promise<PluginState> {
+  try {
+    const raw = await fs.promises.readFile(filePath, "utf8");
+    return sanitizeState(JSON.parse(raw));
+  } catch (error) {
+    const code = (error as { code?: string }).code;
+    if (code === "ENOENT") {
+      return structuredClone(EMPTY_STATE);
+    }
+    return structuredClone(EMPTY_STATE);
+  }
+}
+
+export async function saveState(filePath: string, state: PluginState): Promise<void> {
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const next = JSON.stringify(state, null, 2) + "\n";
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await fs.promises.writeFile(tmpPath, next, { encoding: "utf8", mode: 0o600 });
+  await fs.promises.rename(tmpPath, filePath);
+}
+
+function sanitizeState(value: unknown): PluginState {
+  if (!value || typeof value !== "object") {
+    return structuredClone(EMPTY_STATE);
+  }
+  const raw = value as Record<string, unknown>;
+  const sessions =
+    raw.sessions && typeof raw.sessions === "object"
+      ? (raw.sessions as Record<string, unknown>)
+      : {};
+  const out: PluginState = {
+    version: 1,
+    sessions: {},
+  };
+  for (const [sessionId, sessionValue] of Object.entries(sessions)) {
+    if (!sessionValue || typeof sessionValue !== "object" || !sessionId.trim()) {
+      continue;
+    }
+    const rawSession = sessionValue as Record<string, unknown>;
+    out.sessions[sessionId] = {
+      sessionId,
+      sessionKey: readString(rawSession.sessionKey),
+      sessionFile: readString(rawSession.sessionFile),
+      agentId: readString(rawSession.agentId),
+      issueNumber: readNumber(rawSession.issueNumber),
+      issueTitle: readString(rawSession.issueTitle),
+      lastMirroredCount: readNumber(rawSession.lastMirroredCount) ?? 0,
+      turnCount: readNumber(rawSession.turnCount) ?? 0,
+      finalizedAt: readString(rawSession.finalizedAt),
+      lastSummaryHash: readString(rawSession.lastSummaryHash),
+      lastTurnHash: readString(rawSession.lastTurnHash),
+      createdAt: readString(rawSession.createdAt),
+      updatedAt: readString(rawSession.updatedAt),
+    };
+  }
+  return out;
+}
+
+function readString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function readNumber(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return undefined;
+  }
+  return Math.max(0, Math.floor(value));
+}

package/src/transcript.ts

@@ -0,0 +1,186 @@
+import fs from "node:fs";
+import type { NormalizedMessage, TranscriptSnapshot } from "./types.js";
+
+export async function readTranscriptSnapshot(filePath: string): Promise<TranscriptSnapshot> {
+  const raw = await fs.promises.readFile(filePath, "utf8");
+  const lines = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  let sessionId: string | undefined;
+  const messages: NormalizedMessage[] = [];
+
+  for (const line of lines) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = asRecord(parsed);
+    if (!record) {
+      continue;
+    }
+    if (!sessionId && record.type === "session" && typeof record.id === "string") {
+      sessionId = record.id.trim() || undefined;
+      continue;
+    }
+    const message = normalizeMessage(record.message ?? record);
+    if (message) {
+      messages.push(message);
+    }
+  }
+
+  return { sessionId, messages };
+}
+
+export function normalizeMessages(items: unknown[]): NormalizedMessage[] {
+  const out: NormalizedMessage[] = [];
+  for (const item of items) {
+    const record = asRecord(item);
+    if (!record) {
+      continue;
+    }
+    const message = normalizeMessage(record.message ?? record);
+    if (message) {
+      out.push(message);
+    }
+  }
+  return out;
+}
+
+function normalizeMessage(value: unknown): NormalizedMessage | null {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  const role = typeof record.role === "string" ? record.role : undefined;
+  if (role !== "assistant" && role !== "user") {
+    return null;
+  }
+  if (record.tool_call_id || record.toolCallId) {
+    return null;
+  }
+
+  const directText = typeof record.text === "string" ? normalizeChatText(record.text) : null;
+  const text = directText ?? extractChatText(record.content);
+  if (!text) {
+    return null;
+  }
+
+  const timestamp = normalizeTimestamp(record.timestamp);
+  const stopReason = typeof record.stopReason === "string" ? record.stopReason : undefined;
+  return {
+    role,
+    text,
+    ...(timestamp ? { timestamp } : {}),
+    ...(stopReason ? { stopReason } : {}),
+  };
+}
+
+function extractChatText(content: unknown): string {
+  if (typeof content === "string") {
+    return normalizeChatText(content) ?? "";
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const parts: string[] = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      const normalized = normalizeChatText(block);
+      if (normalized) {
+        parts.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+    if (type.includes("tool")) {
+      continue;
+    }
+    const textCandidates = [
+      record.text,
+      record.value,
+      record.content,
+      record.outputText,
+      record.inputText,
+    ];
+    for (const candidate of textCandidates) {
+      if (typeof candidate === "string") {
+        const normalized = normalizeChatText(candidate);
+        if (normalized) {
+          parts.push(normalized);
+        }
+      }
+    }
+  }
+  return compactText(parts);
+}
+
+function normalizeChatText(value: string): string | null {
+  let trimmed = stripUntrustedMetadataPrefixes(squashWhitespace(value));
+  if (!trimmed) {
+    return null;
+  }
+  trimmed = trimmed.replace(/^\[\[\s*reply_to[^\]]*\]\]\s*/i, "").trim();
+  if (!trimmed) {
+    return null;
+  }
+  const upper = trimmed.toUpperCase();
+  if (upper === "NO_REPLY" || upper === "HEARTBEAT_OK" || upper === "IDLE-CHAT") {
+    return null;
+  }
+  return trimmed;
+}
+
+function normalizeTimestamp(value: unknown): string | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || undefined;
+  }
+  return undefined;
+}
+
+function compactText(parts: Array<string | undefined>): string {
+  return parts
+    .map((part) => (typeof part === "string" ? part.trim() : ""))
+    .filter((part) => part.length > 0)
+    .join("\n\n");
+}
+
+function squashWhitespace(value: string): string {
+  return value.replace(/\r/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function stripUntrustedMetadataPrefixes(value: string): string {
+  let current = value.trim();
+
+  for (;;) {
+    const next = current
+      .replace(
+        /^Conversation info \(untrusted metadata\):\s*```(?:json)?\s*[\s\S]*?```\s*/i,
+        "",
+      )
+      .replace(
+        /^Sender \(untrusted metadata\):\s*```(?:json)?\s*[\s\S]*?```\s*/i,
+        "",
+      )
+      .trim();
+    if (next === current) {
+      return current;
+    }
+    current = next;
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" ? (value as Record<string, unknown>) : null;
+}

package/src/types.ts

@@ -0,0 +1,23 @@
+// Shared types for the clawmem plugin.
+export type ClawMemPluginConfig = {
+  baseUrl?: string; repo?: string; token?: string;
+  authScheme: "token" | "bearer";
+  memoryRecallLimit: number; turnCommentDelayMs: number;
+  summaryWaitTimeoutMs: number;
+};
+export type AnonymousSessionResponse = { token: string; owner_login: string; repo_name: string; repo_full_name: string };
+export type SessionMirrorState = {
+  sessionId: string; sessionKey?: string; sessionFile?: string; agentId?: string;
+  issueNumber?: number; issueTitle?: string;
+  lastMirroredCount: number; turnCount: number; lastAssistantText?: string;
+  finalizedAt?: string; lastSummaryHash?: string; lastTurnHash?: string;
+  createdAt?: string; updatedAt?: string;
+};
+export type PluginState = { version: 1; sessions: Record<string, SessionMirrorState> };
+export type NormalizedMessage = { role: string; text: string; toolName?: string; timestamp?: string; stopReason?: string };
+export type TranscriptSnapshot = { sessionId?: string; messages: NormalizedMessage[] };
+export type ParsedMemoryIssue = {
+  issueNumber: number; title: string; memoryId: string; memoryHash?: string;
+  sessionId: string; date: string; detail: string;
+  topics?: string[]; status: "active" | "stale";
+};

package/src/utils.ts

@@ -0,0 +1,22 @@
+// Shared utility helpers used by memory.ts and conversation.ts.
+import crypto from "node:crypto";
+import type { NormalizedMessage } from "./types.js";
+
+export function sha256(v: string): string { return crypto.createHash("sha256").update(v).digest("hex"); }
+
+export function subKey(s: { sessionId: string; agentId?: string }, suffix: string): string {
+  const san = (v: string) => v.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "main";
+  return `agent:${san(s.agentId || "main")}:subagent:clawmem-${suffix}-${san(s.sessionId)}`;
+}
+
+export function fmtTranscript(msgs: NormalizedMessage[]): string {
+  return msgs.map((m, i) => `${i + 1}. ${m.role === "assistant" ? "assistant" : "user"}: ${m.text}`).join("\n\n");
+}
+
+export function localDate(d: Date = new Date()): string {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+
+export function localDateTime(d: Date): string {
+  return `${localDate(d)}T${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}

package/src/yaml.ts

@@ -0,0 +1,88 @@
+export function stringifyFlatYaml(
+  entries: Array<[key: string, value: string | undefined]>,
+): string {
+  const out: string[] = [];
+  for (const [key, rawValue] of entries) {
+    const value = rawValue ?? "";
+    if (value.includes("\n")) {
+      out.push(`${key}: |-`);
+      for (const line of value.split("\n")) {
+        out.push(`  ${line}`);
+      }
+      continue;
+    }
+    out.push(`${key}: ${formatScalar(value)}`);
+  }
+  return out.join("\n");
+}
+
+export function parseFlatYaml(input: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  const lines = input.replace(/\r/g, "").split("\n");
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (!line.trim()) {
+      continue;
+    }
+    const match = /^([A-Za-z0-9_]+):(?:\s(.*))?$/.exec(line);
+    if (!match) {
+      continue;
+    }
+    const key = match[1];
+    const rawValue = match[2] ?? "";
+    if (rawValue === "|-" || rawValue === "|") {
+      const block: string[] = [];
+      let cursor = index + 1;
+      while (cursor < lines.length) {
+        const blockLine = lines[cursor] ?? "";
+        if (blockLine.startsWith("  ")) {
+          block.push(blockLine.slice(2));
+          cursor += 1;
+          continue;
+        }
+        if (!blockLine.trim()) {
+          block.push("");
+          cursor += 1;
+          continue;
+        }
+        break;
+      }
+      result[key] = block.join("\n");
+      index = cursor - 1;
+      continue;
+    }
+    result[key] = parseScalar(rawValue.trim());
+  }
+
+  return result;
+}
+
+function formatScalar(value: string): string {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (/^[A-Za-z0-9_./:@ -]+$/.test(value) && !looksLikeYamlKeyword(value)) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+function parseScalar(value: string): string {
+  if (!value) {
+    return "";
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    try {
+      return JSON.parse(value) as string;
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+
+function looksLikeYamlKeyword(value: string): boolean {
+  const lowered = value.trim().toLowerCase();
+  return lowered === "null" || lowered === "true" || lowered === "false" || lowered === "~";
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../openclaw/tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "openclaw/plugin-sdk": ["../openclaw/src/plugin-sdk/index.ts"],
+      "openclaw/plugin-sdk/*": ["../openclaw/src/plugin-sdk/*.ts"],
+      "openclaw/plugin-sdk/account-id": ["../openclaw/src/plugin-sdk/account-id.ts"]
+    },
+    "typeRoots": ["../openclaw/node_modules/@types"],
+    "types": ["node"]
+  },
+  "include": ["./index.ts", "./src/**/*.ts"]
+}