@clawmem-ai/clawmem 0.1.18 → 0.1.19

package/src/state.test.ts

@@ -1,119 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { loadState } from "./state.js";
-
-function assert(condition: unknown, message: string): void {
-  if (!condition) throw new Error(message);
-}
-
-async function withTempStateFile(payload: unknown, fn: (filePath: string) => Promise<void>): Promise<void> {
-  const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "clawmem-state-"));
-  const filePath = path.join(dir, "state.json");
-  try {
-    await fs.promises.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
-    await fn(filePath);
-  } finally {
-    await fs.promises.rm(dir, { recursive: true, force: true });
-  }
-}
-
-async function testMigratesLegacyV2State(): Promise<void> {
-  await withTempStateFile({
-    version: 2,
-    sessions: {
-      "main:s-1": {
-        sessionId: "s-1",
-        agentId: "main",
-        issueNumber: 10,
-        lastMirroredCount: 6,
-        turnCount: 6,
-        lastMemorySyncCount: 4,
-        summaryStatus: "pending",
-        finalizedAt: "2026-04-03T10:00:00.000Z",
-      },
-    },
-  }, async (filePath) => {
-    const state = await loadState(filePath);
-    const session = state.sessions["main:s-1"];
-    assert(state.version === 4, "expected state version 4 after migration");
-    assert(Boolean(session), "expected migrated session to exist");
-    assert(session?.derived?.summary.status === "error", "expected finalized legacy sessions without a final summary to surface as needing manual attention");
-    assert(session?.derived?.memory.capturedCursor === 4, "expected legacy memory sync cursor to migrate into capturedCursor");
-  });
-}
-
-async function testNormalizesRunningTaskStates(): Promise<void> {
-  await withTempStateFile({
-    version: 3,
-    sessions: {
-      "main:s-2": {
-        sessionId: "s-2",
-        agentId: "main",
-        lastMirroredCount: 3,
-        turnCount: 3,
-        derived: {
-          summary: { basedOnCursor: 0, status: "running" },
-          memory: {
-            extractCursor: 1,
-            appliedCursor: 0,
-            extractStatus: "running",
-            reconcileStatus: "running",
-          },
-        },
-      },
-    },
-  }, async (filePath) => {
-    const state = await loadState(filePath);
-    const session = state.sessions["main:s-2"];
-    assert(session?.derived?.summary.status === "idle", "expected running summary tasks to normalize to idle on load");
-    assert(session?.derived?.memory.status === "idle", "expected running memory tasks to normalize to idle on load");
-    assert(session?.derived?.memory.capturedCursor === 0, "expected captured cursor to preserve the applied progress");
-  });
-}
-
-async function testPreservesCachedFinalArtifacts(): Promise<void> {
-  await withTempStateFile({
-    version: 4,
-    sessions: {
-      "main:s-3": {
-        sessionId: "s-3",
-        agentId: "main",
-        lastMirroredCount: 5,
-        turnCount: 5,
-        derived: {
-          summary: {
-            basedOnCursor: 5,
-            status: "idle",
-            text: "Recovered summary",
-            title: "Recovered title",
-          },
-          memory: {
-            capturedCursor: 0,
-            status: "error",
-            candidates: [
-              {
-                candidateId: "cand-1",
-                detail: "Store this durable fact.",
-                kind: "lesson",
-                topics: ["redis"],
-              },
-            ],
-          },
-        },
-      },
-    },
-  }, async (filePath) => {
-    const state = await loadState(filePath);
-    const session = state.sessions["main:s-3"];
-    assert(session?.derived?.summary.title === "Recovered title", "expected cached finalize title to survive state load");
-    assert(session?.derived?.memory.candidates?.length === 1, "expected cached memory candidates to survive state load");
-    assert(session?.derived?.memory.candidates?.[0]?.detail === "Store this durable fact.", "expected cached candidate detail to survive state load");
-  });
-}
-
-await testMigratesLegacyV2State();
-await testNormalizesRunningTaskStates();
-await testPreservesCachedFinalArtifacts();
-
-console.log("state tests passed");

package/src/state.ts

@@ -1,206 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { MemoryCandidate, PluginState, SessionDerivedState, SessionMirrorState, SessionTaskStatus } from "./types.js";
-import { normalizeAgentId, sessionScopeKey } from "./utils.js";
-
-const EMPTY_STATE: PluginState = {
-  version: 4,
-  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 migrations: Record<string, string> = {};
-  if (raw.migrations && typeof raw.migrations === "object") {
-    for (const [k, v] of Object.entries(raw.migrations as Record<string, unknown>)) {
-      const s = readString(v);
-      if (s) migrations[k] = s;
-    }
-  }
-  const out: PluginState = {
-    version: 4,
-    sessions: {},
-    ...(Object.keys(migrations).length > 0 ? { migrations } : {}),
-  };
-  for (const [storedKey, sessionValue] of Object.entries(sessions)) {
-    if (!sessionValue || typeof sessionValue !== "object" || !storedKey.trim()) continue;
-    const rawSession = sessionValue as Record<string, unknown>;
-    const sessionId = readString(rawSession.sessionId) ?? storedKey.trim();
-    if (!sessionId) continue;
-    const agentId = normalizeAgentId(readString(rawSession.agentId));
-    const lastMirroredCount = readNumber(rawSession.lastMirroredCount) ?? 0;
-    const finalizedAt = readString(rawSession.finalizedAt);
-    const derived = sanitizeDerivedState(rawSession, lastMirroredCount, finalizedAt);
-    out.sessions[sessionScopeKey(sessionId, agentId)] = {
-      sessionId,
-      sessionKey: readString(rawSession.sessionKey),
-      sessionFile: readString(rawSession.sessionFile),
-      agentId,
-      issueNumber: readNumber(rawSession.issueNumber),
-      issueTitle: readString(rawSession.issueTitle),
-      titleSource: readTitleSource(rawSession.titleSource),
-      lastMirroredCount,
-      turnCount: readNumber(rawSession.turnCount) ?? 0,
-      finalizedAt,
-      lastSummaryHash: readString(rawSession.lastSummaryHash),
-      derived,
-      createdAt: readString(rawSession.createdAt),
-      updatedAt: readString(rawSession.updatedAt),
-    };
-  }
-  return out;
-}
-
-function sanitizeDerivedState(
-  rawSession: Record<string, unknown>,
-  lastMirroredCount: number,
-  finalizedAt?: string,
-): SessionDerivedState {
-  const rawDerived = asRecord(rawSession.derived);
-  const rawSummary = asRecord(rawDerived?.summary);
-  const rawMemory = asRecord(rawDerived?.memory);
-  const legacySummaryStatus = readEnum(rawSession.summaryStatus, ["pending", "complete"]);
-  const legacyMemoryCursor = readNumber(rawSession.lastMemorySyncCount);
-
-  const summaryText = readString(rawSummary?.text);
-  const summaryTitle = readString(rawSummary?.title);
-  const summaryStatus = readTaskStatus(
-    rawSummary?.status,
-    summaryText || legacySummaryStatus === "complete" ? "complete" : "idle",
-  );
-  const summaryCursor = clampCursor(
-    readNumber(rawSummary?.basedOnCursor),
-    summaryStatus === "complete" ? lastMirroredCount : 0,
-    lastMirroredCount,
-  );
-
-  const capturedCursor = clampCursor(
-    readNumber(rawMemory?.capturedCursor)
-      ?? readNumber(rawMemory?.appliedCursor)
-      ?? legacyMemoryCursor,
-    summaryStatus === "complete" ? lastMirroredCount : 0,
-    lastMirroredCount,
-  );
-  const memoryStatus = readTaskStatus(
-    rawMemory?.status ?? rawMemory?.extractStatus ?? rawMemory?.reconcileStatus,
-    capturedCursor >= lastMirroredCount && lastMirroredCount > 0 ? "complete" : "idle",
-  );
-  const candidates = readMemoryCandidates(rawMemory?.candidates);
-
-  return {
-    summary: {
-      basedOnCursor: summaryCursor,
-      status: finalizedAt && summaryStatus === "idle" && lastMirroredCount > 0 ? "error" : summaryStatus,
-      ...(summaryText ? { text: summaryText } : {}),
-      ...(summaryTitle ? { title: summaryTitle } : {}),
-      ...(readString(rawSummary?.lastError) ? { lastError: readString(rawSummary?.lastError) } : {}),
-      ...(readString(rawSummary?.updatedAt) ? { updatedAt: readString(rawSummary?.updatedAt) } : {}),
-    },
-    memory: {
-      capturedCursor,
-      status: memoryStatus,
-      ...(candidates ? { candidates } : {}),
-      ...(readString(rawMemory?.lastError) ? { lastError: readString(rawMemory?.lastError) } : {}),
-      ...(readString(rawMemory?.updatedAt) ? { updatedAt: readString(rawMemory?.updatedAt) } : {}),
-    },
-  };
-}
-
-function readString(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : undefined;
-}
-
-function readEnum<T extends string>(value: unknown, allowed: T[]): T | undefined {
-  const s = readString(value);
-  return s && (allowed as string[]).includes(s) ? (s as T) : undefined;
-}
-
-function readNumber(value: unknown): number | undefined {
-  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
-  return Math.max(0, Math.floor(value));
-}
-
-function readTaskStatus(value: unknown, fallback: SessionTaskStatus): SessionTaskStatus {
-  const status = readEnum(value, ["idle", "pending", "running", "complete", "error"]);
-  if (!status) return fallback;
-  if (status === "pending" || status === "running") return "idle";
-  return status;
-}
-
-function readTitleSource(value: unknown): "placeholder" | "llm" | undefined {
-  const source = readEnum(value, ["placeholder", "digest", "llm"]);
-  if (!source) return undefined;
-  return source === "digest" ? "llm" : source;
-}
-
-function readMemoryCandidates(value: unknown): MemoryCandidate[] | undefined {
-  if (!Array.isArray(value)) return undefined;
-  const out = value
-    .map((entry) => sanitizeMemoryCandidate(entry))
-    .filter((candidate): candidate is MemoryCandidate => candidate !== null);
-  return out;
-}
-
-function sanitizeMemoryCandidate(value: unknown): MemoryCandidate | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record = value as Record<string, unknown>;
-  const candidateId = readString(record.candidateId);
-  const detail = readString(record.detail);
-  if (!candidateId || !detail) return null;
-  const title = readString(record.title);
-  const kind = readString(record.kind);
-  const topics = Array.isArray(record.topics)
-    ? record.topics.map((topic) => readString(topic)).filter((topic): topic is string => Boolean(topic))
-    : undefined;
-  const evidence = readString(record.evidence);
-  return {
-    candidateId,
-    detail,
-    ...(title ? { title } : {}),
-    ...(kind ? { kind } : {}),
-    ...(topics && topics.length > 0 ? { topics } : {}),
-    ...(evidence ? { evidence } : {}),
-  };
-}
-
-function clampCursor(value: number | undefined, fallback: number, max: number): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return Math.min(max, Math.max(0, fallback));
-  return Math.min(max, Math.max(0, Math.floor(value)));
-}
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
-}

package/src/transcript.ts

@@ -1,186 +0,0 @@
-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

@@ -1,86 +0,0 @@
-// Shared types for the clawmem plugin.
-export type ClawMemAgentConfig = {
-  baseUrl?: string;
-  defaultRepo?: string;
-  repo?: string;
-  token?: string;
-  authScheme?: "token" | "bearer";
-};
-
-export type ClawMemPluginConfig = {
-  baseUrl: string;
-  defaultRepo?: string;
-  repo?: string;
-  token?: string;
-  authScheme: "token" | "bearer";
-  agents: Record<string, ClawMemAgentConfig>;
-  memoryRecallLimit: number;
-  memoryAutoRecallLimit: number;
-  summaryWaitTimeoutMs: number;
-  memoryExtractWaitTimeoutMs: number;
-};
-
-export type ClawMemResolvedRoute = {
-  agentId: string;
-  baseUrl: string;
-  defaultRepo?: string;
-  repo?: string;
-  token?: string;
-  authScheme: "token" | "bearer";
-};
-
-export type BootstrapIdentityResponse = { token: string; repo_full_name: string };
-export type AgentRegistrationResponse = BootstrapIdentityResponse & { login: string };
-export type AnonymousSessionResponse = BootstrapIdentityResponse & { owner_login: string; repo_name: string };
-export type SessionTaskStatus = "idle" | "complete" | "error";
-export type MemoryCandidate = {
-  candidateId: string;
-  detail: string;
-  title?: string;
-  kind?: string;
-  topics?: string[];
-  evidence?: string;
-};
-export type SessionSummaryState = {
-  basedOnCursor: number;
-  status: SessionTaskStatus;
-  text?: string;
-  title?: string;
-  lastError?: string;
-  updatedAt?: string;
-};
-export type SessionMemoryState = {
-  capturedCursor: number;
-  status: SessionTaskStatus;
-  candidates?: MemoryCandidate[];
-  lastError?: string;
-  updatedAt?: string;
-};
-export type SessionDerivedState = {
-  summary: SessionSummaryState;
-  memory: SessionMemoryState;
-};
-export type SessionMirrorState = {
-  sessionId: string; sessionKey?: string; sessionFile?: string; agentId?: string;
-  issueNumber?: number; issueTitle?: string; titleSource?: "placeholder" | "llm";
-  lastMirroredCount: number; turnCount: number;
-  finalizedAt?: string; lastSummaryHash?: string;
-  derived?: SessionDerivedState;
-  createdAt?: string; updatedAt?: string;
-};
-export type PluginState = { version: 4; sessions: Record<string, SessionMirrorState>; migrations?: Record<string, string> };
-export type NormalizedMessage = { role: string; text: string; toolName?: string; timestamp?: string; stopReason?: string };
-export type TranscriptSnapshot = { sessionId?: string; messages: NormalizedMessage[] };
-export type MemoryDraft = { title?: string; detail: string; kind?: string; topics?: string[] };
-export type MemorySchema = { kinds: string[]; topics: string[] };
-export type MemoryListOptions = {
-  status?: "active" | "stale" | "all";
-  kind?: string;
-  topic?: string;
-  limit?: number;
-};
-export type ParsedMemoryIssue = {
-  issueNumber: number; title: string; memoryId: string; memoryHash?: string;
-  date: string; detail: string;
-  kind?: string; topics?: string[]; status: "active" | "stale";
-};

package/src/utils.ts

@@ -1,74 +0,0 @@
-// Shared utility helpers used by memory.ts and conversation.ts.
-import crypto from "node:crypto";
-import path from "node:path";
-import type { NormalizedMessage } from "./types.js";
-
-export const DEFAULT_AGENT_ID = "main";
-export const DEFAULT_BOOTSTRAP_REPO_NAME = "memory";
-
-const MAX_AGENT_LOGIN_PREFIX_LEN = 32;
-
-export function sha256(v: string): string { return crypto.createHash("sha256").update(v).digest("hex"); }
-
-export function normalizeAgentId(value: string | undefined | null): string {
-  const trimmed = (value ?? "").trim().toLowerCase();
-  if (!trimmed) return DEFAULT_AGENT_ID;
-  return trimmed.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || DEFAULT_AGENT_ID;
-}
-
-export function buildAgentBootstrapRegistration(agentId: string): { prefixLogin: string; defaultRepoName: string } {
-  const prefixLogin = normalizeAgentId(agentId)
-    .replace(/_/g, "-")
-    .replace(/-+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, MAX_AGENT_LOGIN_PREFIX_LEN)
-    .replace(/-+$/g, "") || DEFAULT_AGENT_ID;
-  return { prefixLogin, defaultRepoName: DEFAULT_BOOTSTRAP_REPO_NAME };
-}
-
-export function sessionScopeKey(sessionId: string, agentId?: string): string {
-  return `${normalizeAgentId(agentId)}:${sessionId.trim()}`;
-}
-
-export function inferAgentIdFromTranscriptPath(filePath: string): string | undefined {
-  const parts = path.resolve(filePath).split(path.sep);
-  const idx = parts.lastIndexOf("agents");
-  if (idx < 0 || !parts[idx + 1] || parts[idx + 2] !== "sessions") return undefined;
-  return normalizeAgentId(parts[idx + 1]);
-}
-
-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 fmtTranscriptFrom(msgs: NormalizedMessage[], startIndex: number): string {
-  return msgs.map((m, i) => `${startIndex + i + 1}. ${m.role === "assistant" ? "assistant" : "user"}: ${m.text}`).join("\n\n");
-}
-
-export function sliceTranscriptDelta(
-  msgs: NormalizedMessage[],
-  fromIndex: number,
-  anchorCount = 2,
-): { anchorStart: number; deltaStart: number; anchorMessages: NormalizedMessage[]; deltaMessages: NormalizedMessage[] } {
-  const deltaStart = Math.min(Math.max(0, Math.floor(fromIndex)), msgs.length);
-  const anchorStart = Math.max(0, deltaStart - Math.max(0, Math.floor(anchorCount)));
-  return {
-    anchorStart,
-    deltaStart,
-    anchorMessages: msgs.slice(anchorStart, deltaStart),
-    deltaMessages: msgs.slice(deltaStart),
-  };
-}
-
-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")}`;
-}