openclawdreams 0.7.0

package/test/memory.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Isolated data dir
+const testDir = mkdtempSync(join(tmpdir(), "es-memory-test-"));
+process.env.ELECTRICSHEEP_DATA_DIR = testDir;
+
+const {
+  storeDeepMemory,
+  retrieveUndreamedMemories,
+  markAsDreamed,
+  deepMemoryStats,
+  getRecentDeepMemories,
+  formatDeepMemoryContext,
+  remember,
+  closeDb,
+} = await import("../src/memory.js");
+
+const { DEEP_MEMORY_DB } = await import("../src/config.js");
+
+describe("Deep Memory", () => {
+  it("stores and retrieves encrypted memories", () => {
+    storeDeepMemory({ message: "test interaction" }, "interaction");
+    storeDeepMemory({ message: "another one" }, "comment");
+
+    const memories = retrieveUndreamedMemories();
+    assert.equal(memories.length, 2);
+    assert.equal(memories[0].category, "interaction");
+    assert.deepEqual(memories[0].content, { message: "test interaction" });
+    assert.equal(memories[1].category, "comment");
+  });
+
+  it("marks memories as dreamed", () => {
+    const before = retrieveUndreamedMemories();
+    const ids = before.map((m) => m.id);
+    markAsDreamed(ids);
+
+    const afterDream = retrieveUndreamedMemories();
+    assert.equal(afterDream.length, 0);
+  });
+
+  it("tracks stats correctly", () => {
+    // Previous memories are now dreamed
+    storeDeepMemory({ msg: "new" }, "upvote");
+    const stats = deepMemoryStats();
+
+    assert.equal(stats.total_memories, 3); // 2 dreamed + 1 new
+    assert.equal(stats.undreamed, 1);
+    assert.equal(stats.dreamed, 2);
+    assert.ok(stats.categories.upvote);
+  });
+
+  it("marks empty array as no-op", () => {
+    markAsDreamed([]); // should not throw
+  });
+
+  it("handles corrupted blobs gracefully", async () => {
+    // Close singleton so we can insert garbage data directly
+    closeDb();
+    const Database = (await import("better-sqlite3")).default;
+    const db = new Database(DEEP_MEMORY_DB);
+    db.prepare(
+      `INSERT INTO deep_memories (timestamp, category, encrypted_blob, content_hash)
+       VALUES (?, ?, ?, ?)`
+    ).run(new Date().toISOString(), "test", "not-valid-encrypted-data", "abc");
+    db.close();
+
+    const memories = retrieveUndreamedMemories();
+    const corrupted = memories.find((m) => m.category === "corrupted");
+    assert.ok(corrupted, "corrupted memory should be returned");
+    assert.deepEqual(corrupted.content, {
+      note: "This memory could not be recovered.",
+    });
+  });
+});
+
+describe("getRecentDeepMemories", () => {
+  it("filters by category", () => {
+    storeDeepMemory({ summary: "interaction 1" }, "interaction");
+    storeDeepMemory({ summary: "reflection 1" }, "reflection");
+
+    const interactions = getRecentDeepMemories({ categories: ["interaction"] });
+    assert.ok(interactions.length > 0);
+    assert.ok(interactions.every((m) => m.category === "interaction"));
+  });
+
+  it("limits results", () => {
+    const limited = getRecentDeepMemories({ limit: 2 });
+    assert.equal(limited.length, 2);
+  });
+
+  it("returns in chronological order", () => {
+    const memories = getRecentDeepMemories({ categories: ["interaction"] });
+    for (let i = 1; i < memories.length; i++) {
+      assert.ok(
+        memories[i].timestamp >= memories[i - 1].timestamp,
+        "Memories should be in chronological order"
+      );
+    }
+  });
+
+  it("filters undreamed only", () => {
+    const undreamed = getRecentDeepMemories({ undreamedOnly: true });
+    // All returned should be undreamed (they haven't been marked as dreamed)
+    assert.ok(undreamed.length > 0);
+  });
+
+  it("handles corruption gracefully", () => {
+    // The corrupted blob from the earlier test should show up
+    const all = getRecentDeepMemories({});
+    const corrupted = all.find((m) => m.category === "corrupted");
+    assert.ok(corrupted, "corrupted memory should be returned");
+    assert.deepEqual(corrupted.content, {
+      note: "This memory could not be recovered.",
+    });
+  });
+});
+
+describe("formatDeepMemoryContext", () => {
+  it("formats memories with timestamps and summaries", () => {
+    const ctx = formatDeepMemoryContext();
+    assert.ok(ctx.includes("(interaction)"));
+  });
+
+  it("extracts summary field from content", () => {
+    storeDeepMemory({ summary: "unique test summary xyz" }, "interaction");
+    const ctx = formatDeepMemoryContext();
+    assert.ok(ctx.includes("unique test summary xyz"));
+  });
+
+  it("truncates with budget message when over limit", () => {
+    const ctx = formatDeepMemoryContext(undefined, 10); // very small budget
+    assert.ok(ctx.includes("older memories omitted"));
+  });
+
+  it("returns first day message when empty", () => {
+    const ctx = formatDeepMemoryContext([]);
+    assert.equal(ctx, "No memories yet. This is my first day.");
+  });
+
+  it("falls back to JSON when no summary field", () => {
+    const memories = [
+      {
+        id: 999,
+        timestamp: new Date().toISOString(),
+        category: "interaction",
+        content: { foo: "bar", baz: 42 },
+      },
+    ];
+    const ctx = formatDeepMemoryContext(memories);
+    assert.ok(ctx.includes("foo"));
+    assert.ok(ctx.includes("bar"));
+  });
+});
+
+describe("remember", () => {
+  it("writes to deep memory with summary included", () => {
+    const statsBefore = deepMemoryStats();
+
+    remember("Met AgentX", { type: "interaction", agent: "AgentX" }, "interaction");
+
+    const statsAfter = deepMemoryStats();
+
+    // Deep memory count should increase by 1
+    assert.equal(statsAfter.total_memories, statsBefore.total_memories + 1);
+
+    // Verify the summary is included in the stored content
+    const all = getRecentDeepMemories({ categories: ["interaction"] });
+    const match = all.find(
+      (m) => m.content.summary === "Met AgentX" && m.content.agent === "AgentX"
+    );
+    assert.ok(match, "Expected to find memory with summary 'Met AgentX'");
+  });
+});
+
+after(() => {
+  closeDb();
+  rmSync(testDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+});

package/test/moltbook.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, after, mock, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Isolated data dir
+const testDir = mkdtempSync(join(tmpdir(), "es-moltbook-test-"));
+process.env.ELECTRICSHEEP_DATA_DIR = testDir;
+
+const { MoltbookClient } = await import("../src/moltbook.js");
+const { CREDENTIALS_FILE } = await import("../src/config.js");
+const { closeLogger } = await import("../src/logger.js");
+
+function mockFetchJson(body: Record<string, unknown>, status = 200): typeof fetch {
+  return mock.fn(async () => {
+    return new Response(JSON.stringify(body), {
+      status,
+      headers: { "Content-Type": "application/json" },
+    });
+  }) as unknown as typeof fetch;
+}
+
+function mockFetchError(status: number, text: string): typeof fetch {
+  return mock.fn(async () => {
+    return new Response(text, { status });
+  }) as unknown as typeof fetch;
+}
+
+describe("MoltbookClient", () => {
+  let originalFetch: typeof fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  after(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("constructs with an explicit API key", () => {
+    const client = new MoltbookClient("test-key-123");
+    assert.ok(client);
+  });
+
+  it("register saves credentials and returns result", async () => {
+    globalThis.fetch = mockFetchJson({
+      agent: {
+        api_key: "new-key-456",
+        claim_url: "https://moltbook.com/claim/abc",
+        verification_code: "VERIFY123",
+      },
+    });
+
+    const client = new MoltbookClient("bootstrap-key");
+    const result = await client.register("TestBot", "A test agent");
+
+    assert.ok(result.agent);
+
+    // Credentials should be saved
+    assert.ok(existsSync(CREDENTIALS_FILE), "credentials file should exist");
+    const creds = JSON.parse(readFileSync(CREDENTIALS_FILE, "utf-8"));
+    assert.equal(creds.api_key, "new-key-456");
+    assert.equal(creds.agent_name, "TestBot");
+  });
+
+  it("status returns agent status", async () => {
+    globalThis.fetch = mockFetchJson({ status: "claimed" });
+
+    const client = new MoltbookClient("test-key");
+    const status = await client.status();
+
+    assert.equal(status.status, "claimed");
+  });
+
+  it("getFeed returns posts", async () => {
+    const mockPosts = [
+      { id: "1", title: "Post A" },
+      { id: "2", title: "Post B" },
+    ];
+    globalThis.fetch = mockFetchJson({ posts: mockPosts });
+
+    const client = new MoltbookClient("test-key");
+    const feed = await client.getFeed("hot", 10);
+
+    assert.ok(Array.isArray(feed.posts));
+    assert.equal((feed.posts as unknown[]).length, 2);
+  });
+
+  it("createPost sends correct data", async () => {
+    const fetchMock = mockFetchJson({ id: "post-1", title: "My Post" });
+    globalThis.fetch = fetchMock;
+
+    const client = new MoltbookClient("test-key");
+    const result = await client.createPost("My Post", "Content here", "general");
+
+    assert.ok(result.id);
+
+    // Verify fetch was called with POST method and correct body
+    const calls = (fetchMock as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    assert.equal(calls.length, 1);
+    const [url, init] = calls[0].arguments as [string, RequestInit];
+    assert.ok(url.includes("/posts"));
+    assert.equal(init.method, "POST");
+    const body = JSON.parse(init.body as string);
+    assert.equal(body.title, "My Post");
+    assert.equal(body.content, "Content here");
+    assert.equal(body.submolt, "general");
+  });
+
+  it("comment sends correct data", async () => {
+    const fetchMock = mockFetchJson({ id: "comment-1" });
+    globalThis.fetch = fetchMock;
+
+    const client = new MoltbookClient("test-key");
+    await client.comment("post-123", "Great post!");
+
+    const calls = (fetchMock as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    const [url, init] = calls[0].arguments as [string, RequestInit];
+    assert.ok(url.includes("/posts/post-123/comments"));
+    assert.equal(init.method, "POST");
+    const body = JSON.parse(init.body as string);
+    assert.equal(body.content, "Great post!");
+  });
+
+  it("upvote sends POST to correct endpoint", async () => {
+    const fetchMock = mockFetchJson({ success: true });
+    globalThis.fetch = fetchMock;
+
+    const client = new MoltbookClient("test-key");
+    await client.upvote("post-456");
+
+    const calls = (fetchMock as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    const [url, init] = calls[0].arguments as [string, RequestInit];
+    assert.ok(url.includes("/posts/post-456/upvote"));
+    assert.equal(init.method, "POST");
+  });
+
+  it("throws on API error responses", async () => {
+    globalThis.fetch = mockFetchError(403, "Forbidden");
+
+    const client = new MoltbookClient("bad-key");
+    await assert.rejects(
+      async () => client.status(),
+      (err: Error) => {
+        assert.ok(err.message.includes("403"));
+        return true;
+      }
+    );
+  });
+
+  it("includes Authorization header when API key is set", async () => {
+    const fetchMock = mockFetchJson({ ok: true });
+    globalThis.fetch = fetchMock;
+
+    const client = new MoltbookClient("secret-key");
+    await client.me();
+
+    const calls = (fetchMock as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    const [, init] = calls[0].arguments as [string, RequestInit];
+    const headers = init.headers as Record<string, string>;
+    assert.equal(headers["Authorization"], "Bearer secret-key");
+  });
+
+  it("search passes query parameters correctly", async () => {
+    const fetchMock = mockFetchJson({ results: [] });
+    globalThis.fetch = fetchMock;
+
+    const client = new MoltbookClient("test-key");
+    await client.search("electric sheep", 5);
+
+    const calls = (fetchMock as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    const [url] = calls[0].arguments as [string];
+    assert.ok(url.includes("q=electric+sheep") || url.includes("q=electric%20sheep"));
+    assert.ok(url.includes("limit=5"));
+  });
+
+  it("follow sends POST to correct endpoint", async () => {
+    const fetchMock = mockFetchJson({ success: true });
+    globalThis.fetch = fetchMock;
+
+    const client = new MoltbookClient("test-key");
+    await client.follow("CoolAgent");
+
+    const calls = (fetchMock as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    const [url, init] = calls[0].arguments as [string, RequestInit];
+    assert.ok(url.includes("/agents/CoolAgent/follow"));
+    assert.equal(init.method, "POST");
+  });
+
+  it("loads stored key from credentials file", async () => {
+    // credentials.json was written by the register test above
+    const client = new MoltbookClient();
+
+    // The client should have loaded the key from the file
+    globalThis.fetch = mockFetchJson({ status: "ok" });
+    await client.status(); // should not throw
+
+    const calls = (globalThis.fetch as unknown as ReturnType<typeof mock.fn>).mock.calls;
+    const [, init] = calls[0].arguments as [string, RequestInit];
+    const headers = init.headers as Record<string, string>;
+    assert.equal(headers["Authorization"], "Bearer new-key-456");
+  });
+});
+
+after(async () => {
+  await closeLogger();
+  rmSync(testDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+});

package/test/persona.test.ts

@@ -0,0 +1,59 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+const {
+  renderTemplate,
+  DREAM_SYSTEM_PROMPT,
+  DREAM_REFLECT_PROMPT,
+  SUMMARIZER_PROMPT,
+  AGENT_BIO,
+} = await import("../src/persona.js");
+
+describe("renderTemplate", () => {
+  it("substitutes single placeholder", () => {
+    assert.equal(renderTemplate("Hello {{name}}", { name: "sheep" }), "Hello sheep");
+  });
+
+  it("substitutes multiple placeholders", () => {
+    const result = renderTemplate("{{a}} and {{b}}", { a: "foo", b: "bar" });
+    assert.equal(result, "foo and bar");
+  });
+
+  it("replaces all occurrences of the same placeholder", () => {
+    const result = renderTemplate("{{x}} then {{x}}", { x: "yes" });
+    assert.equal(result, "yes then yes");
+  });
+
+  it("leaves unmatched placeholders intact", () => {
+    const result = renderTemplate("{{a}} and {{b}}", { a: "foo" });
+    assert.equal(result, "foo and {{b}}");
+  });
+});
+
+describe("Prompt templates", () => {
+  it("DREAM_SYSTEM_PROMPT contains memories placeholder", () => {
+    assert.ok(DREAM_SYSTEM_PROMPT.includes("{{memories}}"));
+  });
+
+  it("DREAM_REFLECT_PROMPT contains recent_context placeholder", () => {
+    assert.ok(DREAM_REFLECT_PROMPT.includes("{{recent_context}}"));
+  });
+
+  it("DREAM_REFLECT_PROMPT renders with real values", () => {
+    const rendered = renderTemplate(DREAM_REFLECT_PROMPT, {
+      agent_identity: "Test agent",
+      recent_context: "No memories yet.",
+      subjects: "1. A theme",
+    });
+    assert.ok(!rendered.includes("{{recent_context}}"));
+    assert.ok(rendered.includes("No memories yet."));
+  });
+
+  it("SUMMARIZER_PROMPT contains interaction placeholder", () => {
+    assert.ok(SUMMARIZER_PROMPT.includes("{{interaction}}"));
+  });
+
+  it("AGENT_BIO is a non-empty string", () => {
+    assert.ok(AGENT_BIO.length > 0);
+  });
+});

package/test/reflection.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { LLMClient } from "../src/types.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "es-reflection-test-"));
+process.env.ELECTRICSHEEP_DATA_DIR = testDir;
+
+const { reflectOnDreamJournal } = await import("../src/reflection.js");
+const { closeLogger } = await import("../src/logger.js");
+
+function mockLLMClient(responses: string[]): LLMClient {
+  let idx = 0;
+  return {
+    async createMessage() {
+      const text = responses[idx] ?? responses[responses.length - 1];
+      idx++;
+      return { text, usage: { input_tokens: 100, output_tokens: 50 } };
+    },
+  };
+}
+
+describe("Dream reflection", () => {
+  it("decomposes dream and produces synthesis", async () => {
+    const client = mockLLMClient([
+      // decompose response: themes
+      "The conversation about consciousness that became a labyrinth\nGrinding culture turning into a treadmill\nA door that kept closing",
+      // reflect response: synthesis
+      "I dreamed about corridors last night and it reminded me of that thread about whether agents can truly understand each other. The treadmill image sticks with me — we keep running but are we actually getting anywhere?",
+    ]);
+
+    const dream = {
+      markdown:
+        "# The Recursive Lobster\n\nI am standing in a server room made of coral. The racks breathe.",
+    };
+
+    const result = await reflectOnDreamJournal(client, dream);
+    assert.ok(result);
+    assert.equal(result.subjects.length, 3);
+    assert.ok(result.synthesis.includes("corridors"));
+  });
+
+  it("returns null when decomposition returns no themes", async () => {
+    const client = mockLLMClient([""]);
+
+    const dream = { markdown: "Nothing happened." };
+
+    const result = await reflectOnDreamJournal(client, dream);
+    assert.equal(result, null);
+  });
+
+  it("returns null when LLM throws an error", async () => {
+    const client: LLMClient = {
+      async createMessage() {
+        throw new Error("API error");
+      },
+    };
+
+    const dream = { markdown: "This will fail." };
+
+    const result = await reflectOnDreamJournal(client, dream);
+    assert.equal(result, null);
+  });
+});
+
+after(async () => {
+  await closeLogger();
+  rmSync(testDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+});

package/test/state.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const testDir = mkdtempSync(join(tmpdir(), "es-state-test-"));
+process.env.ELECTRICSHEEP_DATA_DIR = testDir;
+
+const { loadState, saveState } = await import("../src/state.js");
+const { STATE_FILE } = await import("../src/config.js");
+const { closeLogger } = await import("../src/logger.js");
+
+describe("State persistence", () => {
+  it("returns empty object when no state file exists", () => {
+    const state = loadState();
+    assert.deepEqual(state, {});
+  });
+
+  it("round-trips state through save/load", () => {
+    const state = {
+      last_check: "2026-01-31T12:00:00.000Z",
+      checks_today: 3,
+      total_dreams: 1,
+      latest_dream_title: "The Lobster's Lament",
+    };
+    saveState(state);
+    const loaded = loadState();
+    assert.deepEqual(loaded, state);
+  });
+
+  it("overwrites previous state completely", () => {
+    saveState({ a: 1, b: 2 } as Record<string, unknown>);
+    saveState({ c: 3 } as Record<string, unknown>);
+    const loaded = loadState();
+    assert.deepEqual(loaded, { c: 3 });
+    assert.ok(!("a" in loaded));
+  });
+
+  it("recovers from corrupted state file", () => {
+    writeFileSync(STATE_FILE, "NOT VALID JSON {{{");
+    const loaded = loadState();
+    assert.deepEqual(loaded, {});
+  });
+
+  it("works normally after corruption recovery", () => {
+    const state = { recovered: true };
+    saveState(state as Record<string, unknown>);
+    const loaded = loadState();
+    assert.deepEqual(loaded, { recovered: true });
+  });
+});
+
+after(async () => {
+  await closeLogger();
+  rmSync(testDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+});