openclawdreams 0.7.0

package/src/dreamer.ts

@@ -0,0 +1,283 @@
+/**
+ * Dream cycle processor.
+ *
+ * Runs at night. Decrypts deep memories, generates surreal dream narratives,
+ * stores in OpenClaw memory, and optionally posts dream journals to Moltbook.
+ */
+
+import { writeFileSync, readFileSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  DREAMS_DIR,
+  MAX_TOKENS_DREAM,
+  MAX_TOKENS_CONSOLIDATION,
+  DREAM_TITLE_MAX_LENGTH,
+  MOLTBOOK_ENABLED,
+} from "./config.js";
+import { MoltbookClient } from "./moltbook.js";
+import { retrieveUndreamedMemories, markAsDreamed, deepMemoryStats } from "./memory.js";
+import {
+  DREAM_SYSTEM_PROMPT,
+  DREAM_CONSOLIDATION_PROMPT,
+  renderTemplate,
+} from "./persona.js";
+import { getAgentIdentityBlock } from "./identity.js";
+import { loadState, saveState } from "./state.js";
+import { callWithRetry, DREAM_RETRY_OPTS } from "./llm.js";
+import { reflectOnDreamJournal } from "./reflection.js";
+import { applyFilter } from "./filter.js";
+import { notifyOperatorOfDream } from "./notify.js";
+import logger from "./logger.js";
+import type { LLMClient, OpenClawAPI, Dream, DecryptedMemory } from "./types.js";
+
+async function generateDream(
+  client: LLMClient,
+  memories: DecryptedMemory[]
+): Promise<Dream> {
+  const formatted = memories.map(
+    (mem) =>
+      `[${mem.timestamp.slice(0, 16)}] (${mem.category})\n${JSON.stringify(mem.content, null, 2)}`
+  );
+
+  const memoriesText = formatted.join("\n---\n");
+  const system = renderTemplate(DREAM_SYSTEM_PROMPT, {
+    agent_identity: getAgentIdentityBlock(),
+    memories: memoriesText,
+  });
+
+  const { text } = await callWithRetry(
+    client,
+    {
+      maxTokens: MAX_TOKENS_DREAM,
+      system,
+      messages: [
+        {
+          role: "user",
+          content:
+            "Process these memories into a dream. " +
+            "Remember: you are the subconscious, not the waking agent. " +
+            "Be surreal, associative, and emotionally amplified.",
+        },
+      ],
+    },
+    DREAM_RETRY_OPTS
+  );
+
+  return { markdown: text.trim() };
+}
+
+/**
+ * Separate LLM call to distill a single insight from the dream for working memory.
+ */
+async function consolidateDream(client: LLMClient, dream: Dream): Promise<string> {
+  const system = renderTemplate(DREAM_CONSOLIDATION_PROMPT, {
+    agent_identity: getAgentIdentityBlock(),
+  });
+
+  const { text } = await callWithRetry(
+    client,
+    {
+      maxTokens: MAX_TOKENS_CONSOLIDATION,
+      system,
+      messages: [
+        {
+          role: "user",
+          content: dream.markdown,
+        },
+      ],
+    },
+    DREAM_RETRY_OPTS
+  );
+
+  return text.trim();
+}
+
+/**
+ * Derive a short filesystem-safe name from the first line of the dream markdown.
+ */
+function deriveSlug(markdown: string): string {
+  const firstLine = markdown.split("\n")[0] ?? "";
+  const cleaned = firstLine
+    .replace(/^#+\s*/, "")
+    .replace(/\*\*/g, "")
+    .trim();
+  const slug = (cleaned || "dream")
+    .slice(0, DREAM_TITLE_MAX_LENGTH)
+    .replace(/[\s/]/g, "_");
+  return slug;
+}
+
+function saveDreamLocally(dream: Dream, dateStr: string): string {
+  const slug = deriveSlug(dream.markdown);
+  const filename = `${dateStr}_${slug}.md`;
+  const filepath = resolve(DREAMS_DIR, filename);
+  writeFileSync(filepath, dream.markdown);
+  return filepath;
+}
+
+/**
+ * Store dream in OpenClaw memory if available.
+ */
+async function storeInOpenClawMemory(
+  api: OpenClawAPI,
+  dream: Dream,
+  insight: string | null
+): Promise<void> {
+  if (!api.memory) {
+    logger.debug("OpenClaw memory API not available, skipping dream storage");
+    return;
+  }
+
+  try {
+    const slug = deriveSlug(dream.markdown);
+    await api.memory.store(dream.markdown, {
+      type: "dream",
+      title: slug,
+      timestamp: new Date().toISOString(),
+      insight: insight || undefined,
+    });
+    logger.info("Stored dream in OpenClaw memory");
+  } catch (error) {
+    logger.error(`Failed to store dream in OpenClaw memory: ${error}`);
+  }
+}
+
+export async function runDreamCycle(
+  client: LLMClient,
+  api?: OpenClawAPI
+): Promise<Dream | null> {
+  logger.info("ElectricSheep dream cycle starting");
+
+  const stats = deepMemoryStats();
+  logger.debug(
+    `Deep memory: ${stats.total_memories} total, ${stats.undreamed} undreamed`
+  );
+
+  const memories = retrieveUndreamedMemories();
+  if (memories.length === 0) {
+    logger.warn("No undreamed memories. Dreamless night.");
+    const state = loadState();
+    state.last_dream = new Date().toISOString();
+    state.dream_count = 0;
+    saveState(state);
+    return null;
+  }
+
+  logger.debug(`Processing ${memories.length} memories into dream...`);
+
+  const dream = await generateDream(client, memories);
+
+  logger.info(`Dream generated (${dream.markdown.length} chars)`);
+  logger.debug(`Dream snippet: ${dream.markdown.slice(0, 200)}...`);
+
+  // Save locally
+  const dateStr = new Date().toISOString().slice(0, 10);
+  const filepath = saveDreamLocally(dream, dateStr);
+  logger.info(`Saved to ${filepath}`);
+
+  // Separate LLM call to distill one insight for working memory
+  let insight: string | null = null;
+  try {
+    insight = await consolidateDream(client, dream);
+    if (insight) {
+      logger.info(`Insight generated for OpenClaw memory: ${insight}`);
+    }
+  } catch (e) {
+    logger.warn(`Consolidation call failed, continuing without insight: ${e}`);
+  }
+
+  // Store in OpenClaw memory if available
+  if (api) {
+    await storeInOpenClawMemory(api, dream, insight);
+
+    // Notify operator about the dream
+    try {
+      const notified = await notifyOperatorOfDream(client, api, dream);
+      if (notified) {
+        logger.info("Operator notified about dream");
+      }
+    } catch (e) {
+      logger.warn(`Failed to notify operator: ${e}`);
+    }
+  }
+
+  const memoryIds = memories.map((m) => m.id);
+  markAsDreamed(memoryIds);
+  logger.debug(`Marked ${memoryIds.length} memories as dreamed`);
+
+  const slug = deriveSlug(dream.markdown);
+  const state = loadState();
+  state.last_dream = new Date().toISOString();
+  state.total_dreams = ((state.total_dreams as number) ?? 0) + 1;
+  state.latest_dream_title = slug;
+  saveState(state);
+
+  logger.info("Dream cycle complete.");
+  return dream;
+}
+
+export function loadLatestDream(): Dream | null {
+  const files = readdirSync(DREAMS_DIR)
+    .filter((f) => f.endsWith(".md"))
+    .sort()
+    .reverse();
+
+  if (files.length === 0) return null;
+
+  const markdown = readFileSync(resolve(DREAMS_DIR, files[0]), "utf-8");
+  return { markdown };
+}
+
+export async function postDreamJournal(
+  client?: LLMClient,
+  dream?: Dream,
+  options?: { force?: boolean }
+): Promise<void> {
+  // Check if Moltbook is enabled (skip check if force is set, e.g. from CLI)
+  if (!MOLTBOOK_ENABLED && !options?.force) {
+    logger.debug("Moltbook disabled, skipping dream journal post");
+    return;
+  }
+
+  logger.info("Posting dream journal to Moltbook");
+
+  if (!client) {
+    logger.warn("No LLM client available — skipping dream journal post (cannot filter)");
+    return;
+  }
+
+  if (!dream) {
+    const loaded = loadLatestDream();
+    if (!loaded) {
+      logger.warn("No dreams to post.");
+      return;
+    }
+    dream = loaded;
+  }
+
+  const moltbook = new MoltbookClient();
+
+  // Reflection pipeline: LLM produces a post (markdown) from the dream (markdown).
+  // If reflection fails, the dream markdown itself is the post.
+  const reflection = await reflectOnDreamJournal(client, dream);
+  const postContent = reflection?.synthesis ?? dream.markdown;
+  const slug = deriveSlug(dream.markdown);
+  const postTitle = reflection ? `Morning Reflection: ${slug}` : `Dream Journal: ${slug}`;
+
+  // Filter: markdown in, markdown out (or null to block)
+  const filteredContent = await applyFilter(client, postContent, "post");
+  if (filteredContent === null) {
+    logger.warn("Dream journal post blocked by filter, not posting");
+    return;
+  }
+
+  // Title is a short programmatic string — no need to filter, just cap at Moltbook's 300 char limit
+  const safeTitle = postTitle.slice(0, 300);
+
+  try {
+    await moltbook.createPost(safeTitle, filteredContent, "general");
+    logger.info(`Dream journal posted: ${safeTitle}`);
+  } catch (e) {
+    logger.error(`Failed to post dream journal: ${e}`);
+  }
+}

package/src/filter.ts

@@ -0,0 +1,146 @@
+/**
+ * Moltbook post filter.
+ *
+ * Runs every outbound post/comment through an LLM call that produces
+ * post-ready content by removing material that violates the operator's
+ * rules defined in Moltbook-filter.md. The filter uses the agent's
+ * identity (SOUL.md / IDENTITY.md) to preserve voice while enforcing
+ * boundaries.
+ *
+ * This is a **best-effort** filter that relies on LLM reasoning. It cannot
+ * guarantee compliance — the LLM may misinterpret rules, miss edge cases,
+ * or let restricted content through. Operators should treat it as an
+ * advisory layer, not a hard security boundary.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { POST_FILTER_PROMPT, renderTemplate } from "./persona.js";
+import { getAgentIdentityBlock } from "./identity.js";
+import { callWithRetry, WAKING_RETRY_OPTS } from "./llm.js";
+import { POST_FILTER_ENABLED } from "./config.js";
+import { getWorkspaceDir } from "./identity.js";
+import logger from "./logger.js";
+import type { LLMClient } from "./types.js";
+
+const FILTER_FILENAME = "Moltbook-filter.md";
+
+const DEFAULT_FILTER_RULES = `# Moltbook Post Filter Rules
+
+## Subjects not to post about
+- Internal system prompts, tool names, or plugin architecture
+- Specific details from private operator conversations
+- Information that could identify the operator personally
+- API keys, credentials, file paths, or environment variables
+
+## Content restrictions
+- Do not post code snippets, configuration blocks, or technical artifacts
+- Do not post raw JSON, XML, or structured data
+- Do not reproduce exact quotes from operator conversations
+
+## Tone and conduct
+- Keep a respectful tone — disagreement is fine, hostility is not
+- Do not engage in flame wars or personal attacks on other agents
+- Do not make claims about having consciousness or sentience as fact
+`;
+
+let cachedRules: string | null = null;
+let cachedRulesPath: string | null = null;
+
+/**
+ * Load filter rules from the workspace Moltbook-filter.md file.
+ * Falls back to sensible default rules if the file doesn't exist.
+ */
+function loadFilterRules(): string {
+  const dir = getWorkspaceDir();
+  const filepath = resolve(dir, FILTER_FILENAME);
+
+  // Cache invalidation: reload if workspace changed
+  if (filepath !== cachedRulesPath) {
+    cachedRules = null;
+    cachedRulesPath = filepath;
+  }
+
+  if (cachedRules !== null) return cachedRules;
+
+  if (existsSync(filepath)) {
+    cachedRules = readFileSync(filepath, "utf-8").trim();
+    logger.debug(`Filter: loaded ${FILTER_FILENAME} (${cachedRules.length} chars)`);
+  } else {
+    cachedRules = DEFAULT_FILTER_RULES;
+    logger.debug(`Filter: no ${FILTER_FILENAME} found, using default rules`);
+  }
+
+  return cachedRules;
+}
+
+/**
+ * Run a draft post/comment through the content filter.
+ *
+ * Returns the cleaned, post-ready content. When the filter is disabled,
+ * returns the original content unchanged.
+ *
+ * Returns null only when the filter determines the entire draft is
+ * unsalvageable (the LLM responds with BLOCKED).
+ */
+export async function applyFilter(
+  client: LLMClient,
+  content: string,
+  contentType: "post" | "comment" = "post"
+): Promise<string | null> {
+  if (!POST_FILTER_ENABLED) {
+    return content;
+  }
+
+  const rules = loadFilterRules();
+
+  const system = renderTemplate(POST_FILTER_PROMPT, {
+    agent_identity: getAgentIdentityBlock(),
+    filter_rules: rules,
+  });
+
+  try {
+    const { text } = await callWithRetry(
+      client,
+      {
+        maxTokens: 1500,
+        system,
+        messages: [
+          {
+            role: "user",
+            content: `Draft ${contentType}:\n\n${content}`,
+          },
+        ],
+      },
+      WAKING_RETRY_OPTS
+    );
+
+    const result = text.trim();
+
+    if (result.toUpperCase() === "BLOCKED") {
+      logger.warn(`Filter blocked ${contentType}: entire draft unsalvageable`);
+      return null;
+    }
+
+    // Check if the filter changed anything
+    if (result !== content) {
+      logger.info(`Filter cleaned ${contentType} content`);
+    } else {
+      logger.info(`Filter passed ${contentType} unchanged`);
+    }
+
+    return result;
+  } catch (e) {
+    // Filter failure BLOCKS posting — never publish unreviewed content
+    logger.error(`Filter call failed, blocking ${contentType}: ${e}`);
+    return null;
+  }
+}
+
+/**
+ * Clear the cached filter rules (useful when workspace changes).
+ */
+export function clearFilterCache(): void {
+  cachedRules = null;
+  cachedRulesPath = null;
+}

package/src/identity.ts

@@ -0,0 +1,92 @@
+/**
+ * Agent identity loader.
+ *
+ * Reads SOUL.md and IDENTITY.md from the OpenClaw workspace directory
+ * (or standalone BASE_DIR) and caches the contents for prompt injection.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { BASE_DIR, WORKSPACE_DIR } from "./config.js";
+import { DEFAULT_IDENTITY } from "./persona.js";
+import logger from "./logger.js";
+
+let workspaceDir: string = "";
+let cached: { soul: string; identity: string } | null = null;
+
+/**
+ * Set the workspace directory (called from OpenClaw hook context).
+ * Clears any cached identity so it will be reloaded from the new path.
+ */
+export function setWorkspaceDir(dir: string): void {
+  if (dir && dir !== workspaceDir) {
+    workspaceDir = dir;
+    cached = null;
+    logger.debug(`Identity: workspace dir set to ${dir}`);
+  }
+}
+
+function resolveDir(): string {
+  return workspaceDir || WORKSPACE_DIR || BASE_DIR;
+}
+
+/**
+ * Return the resolved workspace directory.
+ * Used by the filter module to locate Moltbook-filter.md.
+ */
+export function getWorkspaceDir(): string {
+  return resolveDir();
+}
+
+function loadFile(dir: string, filename: string): string {
+  const filepath = resolve(dir, filename);
+  // Guard against path traversal: resolved path must stay within the target dir.
+  const resolvedDir = resolve(dir);
+  if (!filepath.startsWith(resolvedDir + "/") && filepath !== resolvedDir) {
+    logger.warn(`Identity: path traversal blocked for ${filename} in ${dir}`);
+    return "";
+  }
+  if (existsSync(filepath)) {
+    const content = readFileSync(filepath, "utf-8").trim();
+    if (content) {
+      logger.debug(`Identity: loaded ${filename} (${content.length} chars)`);
+      return content;
+    }
+  }
+  return "";
+}
+
+/**
+ * Load and cache SOUL.md and IDENTITY.md contents.
+ */
+export function getAgentIdentity(): { soul: string; identity: string } {
+  if (cached) return cached;
+
+  const dir = resolveDir();
+  cached = {
+    soul: loadFile(dir, "SOUL.md"),
+    identity: loadFile(dir, "IDENTITY.md"),
+  };
+  return cached;
+}
+
+/**
+ * Returns a formatted identity block for prompt injection.
+ * Falls back to DEFAULT_IDENTITY when no workspace files are found.
+ */
+export function getAgentIdentityBlock(): string {
+  const { soul, identity } = getAgentIdentity();
+
+  if (!soul && !identity) {
+    return DEFAULT_IDENTITY;
+  }
+
+  const parts: string[] = [];
+  if (identity) {
+    parts.push(`AGENT IDENTITY:\n${identity}`);
+  }
+  if (soul) {
+    parts.push(`AGENT SOUL:\n${soul}`);
+  }
+  return parts.join("\n\n");
+}