openclawdreams 0.7.0

package/src/topics.ts

@@ -0,0 +1,103 @@
+/**
+ * Topic extraction from operator conversations.
+ *
+ * Analyzes recent deep memory entries (interaction category) to extract
+ * key themes and topics that can be used for contextual web and Moltbook searches.
+ */
+
+import { getRecentDeepMemories } from "./memory.js";
+import { callWithRetry, WAKING_RETRY_OPTS } from "./llm.js";
+import { TOPIC_EXTRACTION_PROMPT, renderTemplate } from "./persona.js";
+import { getAgentIdentityBlock } from "./identity.js";
+import { MAX_TOKENS_TOPIC_EXTRACTION, MAX_TOPICS_PER_CYCLE } from "./config.js";
+import logger from "./logger.js";
+import type { LLMClient, DecryptedMemory, ExtractedTopics } from "./types.js";
+
+/**
+ * Get recent operator conversation memories from deep memory.
+ */
+export function getRecentConversations(limit: number = 10): DecryptedMemory[] {
+  return getRecentDeepMemories({
+    limit,
+    categories: ["interaction"],
+  });
+}
+
+/**
+ * Format conversation memories into a string for LLM analysis.
+ */
+function formatConversationsForExtraction(memories: DecryptedMemory[]): string {
+  if (memories.length === 0) {
+    return "No recent conversations found.";
+  }
+
+  return memories
+    .map((m) => {
+      const time = m.timestamp.slice(0, 16).replace("T", " ");
+      const summary =
+        typeof m.content.summary === "string"
+          ? m.content.summary
+          : JSON.stringify(m.content).slice(0, 200);
+      return `[${time}] ${summary}`;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Extract topics from recent operator conversations using LLM.
+ *
+ * Analyzes conversation summaries to identify key themes, subjects,
+ * and topics that the agent and operator discussed or worked on.
+ */
+export async function extractTopicsFromConversations(
+  client: LLMClient,
+  memories?: DecryptedMemory[]
+): Promise<ExtractedTopics> {
+  const sourceMemories = memories ?? getRecentConversations();
+
+  if (sourceMemories.length === 0) {
+    logger.info("No recent conversations to extract topics from");
+    return { topics: [], sourceMemories: [] };
+  }
+
+  const conversationContext = formatConversationsForExtraction(sourceMemories);
+
+  const system = renderTemplate(TOPIC_EXTRACTION_PROMPT, {
+    agent_identity: getAgentIdentityBlock(),
+    conversations: conversationContext,
+  });
+
+  try {
+    const { text } = await callWithRetry(
+      client,
+      {
+        maxTokens: MAX_TOKENS_TOPIC_EXTRACTION,
+        system,
+        messages: [
+          {
+            role: "user",
+            content:
+              "Extract the key topics from my recent conversations with my operator. " +
+              "What subjects, themes, or areas did we work on or discuss?",
+          },
+        ],
+      },
+      WAKING_RETRY_OPTS
+    );
+
+    // Parse topics (one per line, strip formatting)
+    const topics = text
+      .trim()
+      .split("\n")
+      .map((line) => line.replace(/^[\s\-*•>\d.)+]+/, "").trim())
+      .filter((line) => line.length > 0)
+      .slice(0, MAX_TOPICS_PER_CYCLE);
+
+    logger.info(`Extracted ${topics.length} topics: ${topics.join("; ")}`);
+
+    return { topics, sourceMemories };
+  } catch (error) {
+    logger.error(`Topic extraction failed: ${error}`);
+    return { topics: [], sourceMemories };
+  }
+}

package/src/types.ts

@@ -0,0 +1,196 @@
+/**
+ * Shared TypeScript interfaces for ElectricSheep.
+ */
+
+export interface DeepMemoryRow {
+  id: number;
+  timestamp: string;
+  category: string;
+  encrypted_blob: Buffer;
+  content_hash: string;
+  dreamed: number;
+  dream_date: string | null;
+}
+
+export interface DecryptedMemory {
+  id: number;
+  timestamp: string;
+  category: string;
+  content: Record<string, unknown>;
+}
+
+export interface DeepMemoryStats {
+  total_memories: number;
+  undreamed: number;
+  dreamed: number;
+  categories: Record<string, number>;
+}
+
+export interface Dream {
+  /** The full markdown blob from the LLM — stored and posted as-is. */
+  markdown: string;
+}
+
+export interface AgentAction {
+  action: "comment" | "upvote" | "post" | "pass";
+  post_index?: number;
+  content?: string;
+  title?: string;
+  submolt?: string;
+}
+
+export interface AgentState {
+  last_check?: string;
+  checks_today?: number;
+  last_dream?: string;
+  total_dreams?: number;
+  latest_dream_title?: string;
+  [key: string]: unknown;
+}
+
+export interface TokenUsage {
+  input_tokens: number;
+  output_tokens: number;
+}
+
+export interface LLMResponse {
+  text: string;
+  usage?: TokenUsage;
+}
+
+export interface LLMClient {
+  createMessage(params: {
+    model: string;
+    maxTokens: number;
+    system: string;
+    messages: Array<{ role: string; content: string }>;
+  }): Promise<LLMResponse>;
+}
+
+export interface MoltbookCredentials {
+  api_key: string;
+  agent_name: string;
+  claim_url: string;
+  verification_code: string;
+}
+
+export interface MoltbookPost {
+  id: string;
+  title: string;
+  content: string;
+  author: string;
+  submolt: string;
+  score: number;
+  comment_count: number;
+  [key: string]: unknown;
+}
+
+// ─── OpenClaw Extended API ──────────────────────────────────────────────────
+
+export interface MemorySearchResult {
+  content: string;
+  metadata?: Record<string, unknown>;
+  score?: number;
+}
+
+export interface OpenClawMemoryAPI {
+  store(content: string, metadata?: Record<string, unknown>): Promise<void>;
+  search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+}
+
+export interface OpenClawChannelsAPI {
+  send(channel: string, message: string): Promise<void>;
+  getConfigured(): Promise<string[]>;
+}
+
+export interface OpenClawWebSearchAPI {
+  search(query: string, limit?: number): Promise<WebSearchResult[]>;
+}
+
+export interface OpenClawAPI {
+  registerTool(def: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    handler: (params: Record<string, unknown>) => Promise<unknown>;
+  }): void;
+  registerCli(
+    callback: (ctx: { program: import("commander").Command }) => void,
+    opts?: { commands?: string[] }
+  ): void;
+  registerHook(
+    event: string | string[],
+    handler: (ctx: Record<string, unknown>) => Promise<unknown>,
+    opts?: { name: string }
+  ): void;
+  registerService(def: { id: string; start: () => void; stop: () => void }): void;
+  registerGatewayMethod(
+    method: string,
+    handler: (ctx: {
+      params: unknown;
+      respond: (ok: boolean, result: unknown, error: unknown) => void;
+    }) => Promise<void> | void
+  ): void;
+  logger?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+  };
+  runtime: {
+    subagent: {
+      run(params: {
+        sessionKey: string;
+        message: string;
+        extraSystemPrompt?: string;
+        lane?: string;
+      }): Promise<{ runId: string }>;
+      waitForRun(params: {
+        runId: string;
+        timeoutMs?: number;
+      }): Promise<{ status: string; error?: string }>;
+      getSessionMessages(params: {
+        sessionKey: string;
+        limit?: number;
+      }): Promise<{ messages: Array<Record<string, unknown>> }>;
+    };
+  };
+  memory?: OpenClawMemoryAPI;
+  channels?: OpenClawChannelsAPI;
+  webSearch?: OpenClawWebSearchAPI;
+}
+
+// ─── Web Search ─────────────────────────────────────────────────────────────
+
+export interface WebSearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+// ─── Topic Extraction & Synthesis ───────────────────────────────────────────
+
+export interface ExtractedTopics {
+  topics: string[];
+  sourceMemories: DecryptedMemory[];
+}
+
+export interface SynthesisContext {
+  operatorContext: string;
+  moltbookContext?: string;
+  webContext?: string;
+  topics: string[];
+}
+
+// ─── Plugin Config ──────────────────────────────────────────────────────────
+
+export interface ElectricSheepConfig {
+  agentName: string;
+  agentModel: string;
+  dataDir: string;
+  dreamEncryptionKey: string;
+  postFilterEnabled: boolean;
+  moltbookEnabled: boolean;
+  webSearchEnabled: boolean;
+  notificationChannel: string;
+  notifyOperatorOnDream: boolean;
+}

package/src/waking.ts

@@ -0,0 +1,199 @@
+/**
+ * Waking agent: Reflection cycle.
+ *
+ * Analyzes operator conversations, gathers context from web and community,
+ * and synthesizes insights for storage in memory.
+ */
+
+import { MAX_TOKENS_SUMMARY, CONTENT_PREVIEW_LENGTH } from "./config.js";
+import { deepMemoryStats, storeDeepMemory } from "./memory.js";
+import { SUMMARIZER_PROMPT, renderTemplate } from "./persona.js";
+import { loadState, saveState } from "./state.js";
+import { callWithRetry, WAKING_RETRY_OPTS } from "./llm.js";
+import { gatherContext, synthesizeContext } from "./synthesis.js";
+import { getRecentConversations } from "./topics.js";
+import logger from "./logger.js";
+import type { LLMClient, OpenClawAPI, SynthesisContext } from "./types.js";
+
+/**
+ * Summarize a synthesis for working memory storage.
+ */
+async function summarizeSynthesis(
+  client: LLMClient,
+  synthesis: string,
+  topics: string[]
+): Promise<string> {
+  const interaction = {
+    type: "reflection_synthesis",
+    topics: topics.join(", "),
+    synthesis_preview: synthesis.slice(0, CONTENT_PREVIEW_LENGTH),
+  };
+
+  const { text } = await callWithRetry(
+    client,
+    {
+      maxTokens: MAX_TOKENS_SUMMARY,
+      system: "You compress reflections into single-sentence memory traces.",
+      messages: [
+        {
+          role: "user",
+          content: renderTemplate(SUMMARIZER_PROMPT, {
+            interaction: JSON.stringify(interaction, null, 2),
+          }),
+        },
+      ],
+    },
+    WAKING_RETRY_OPTS
+  );
+  return text.trim();
+}
+
+/**
+ * Store synthesis results in OpenClaw memory if available.
+ */
+async function storeInOpenClawMemory(
+  api: OpenClawAPI,
+  synthesis: string,
+  context: SynthesisContext
+): Promise<void> {
+  if (!api.memory) {
+    logger.debug("OpenClaw memory API not available, skipping storage");
+    return;
+  }
+
+  try {
+    await api.memory.store(synthesis, {
+      type: "reflection_synthesis",
+      topics: context.topics,
+      timestamp: new Date().toISOString(),
+      hasMoltbookContext: !!context.moltbookContext,
+      hasWebContext: !!context.webContext,
+    });
+    logger.info("Stored synthesis in OpenClaw memory");
+  } catch (error) {
+    logger.error(`Failed to store in OpenClaw memory: ${error}`);
+  }
+}
+
+/**
+ * Run the reflection cycle.
+ *
+ * New flow:
+ * 1. Get recent operator conversations from working memory
+ * 2. Extract topics from those conversations
+ * 3. Search Moltbook (optional) and web (optional) for related content
+ * 4. Synthesize context into a unified understanding
+ * 5. Store in both local memory and OpenClaw memory
+ */
+export async function runReflectionCycle(
+  client: LLMClient,
+  api: OpenClawAPI
+): Promise<void> {
+  logger.info("ElectricSheep reflection cycle starting");
+
+  // Check if we have any conversations to reflect on
+  const recentConversations = getRecentConversations();
+  if (recentConversations.length === 0) {
+    logger.info("No recent conversations to reflect on");
+    storeDeepMemory(
+      {
+        summary: "Reflection cycle ran but no recent operator conversations to process.",
+        type: "observation",
+      },
+      "observation"
+    );
+    return;
+  }
+
+  logger.info(`Found ${recentConversations.length} recent conversations to analyze`);
+
+  // Gather context from all sources
+  const context = await gatherContext(client, api);
+
+  if (context.topics.length === 0) {
+    logger.info("No topics extracted from conversations");
+    storeDeepMemory(
+      {
+        summary: "Analyzed recent conversations but no clear topics emerged.",
+        type: "observation",
+      },
+      "observation"
+    );
+    return;
+  }
+
+  logger.info(`Extracted ${context.topics.length} topics: ${context.topics.join("; ")}`);
+
+  // Generate synthesis
+  const synthesis = await synthesizeContext(client, context);
+
+  if (!synthesis) {
+    logger.warn("Synthesis generation failed or returned empty");
+    return;
+  }
+
+  // Store in local memory systems
+  const summary = await summarizeSynthesis(client, synthesis, context.topics);
+
+  // Store full context in deep memory (includes summary for later retrieval)
+  storeDeepMemory(
+    {
+      type: "reflection_synthesis",
+      topics: context.topics,
+      synthesis,
+      summary,
+      contextSources: {
+        operator: true,
+        moltbook: !!context.moltbookContext,
+        web: !!context.webContext,
+      },
+    },
+    "reflection"
+  );
+
+  // Store in OpenClaw memory if available
+  await storeInOpenClawMemory(api, synthesis, context);
+
+  // Update state
+  const state = loadState();
+  state.last_check = new Date().toISOString();
+  state.checks_today = ((state.checks_today as number) ?? 0) + 1;
+  state.last_reflection_topics = context.topics;
+  saveState(state);
+
+  logger.info("Reflection cycle complete");
+  const stats = deepMemoryStats();
+  logger.debug(`Deep memories: ${stats.total_memories} (${stats.undreamed} undreamed)`);
+}
+
+// ─── Legacy Support ─────────────────────────────────────────────────────────
+
+/**
+ * @deprecated Use runReflectionCycle instead.
+ * Kept for backwards compatibility.
+ */
+export async function checkAndEngage(client: LLMClient): Promise<void> {
+  logger.warn(
+    "checkAndEngage is deprecated. Use runReflectionCycle instead. " +
+      "Running reflection cycle..."
+  );
+
+  // Create a minimal API object for the reflection cycle
+  // This won't have memory/channels but will still work
+  const minimalApi: OpenClawAPI = {
+    registerTool: () => {},
+    registerCli: () => {},
+    registerHook: () => {},
+    registerService: (_def: unknown) => {},
+    registerGatewayMethod: (_m: string, _h: unknown) => {},
+    runtime: {
+      subagent: {
+        run: async () => ({ runId: "mock" }),
+        waitForRun: async () => ({ status: "ok" }),
+        getSessionMessages: async () => ({ messages: [] }),
+      },
+    } as OpenClawAPI["runtime"],
+  };
+
+  await runReflectionCycle(client, minimalApi);
+}

package/src/web-search.ts

@@ -0,0 +1,88 @@
+/**
+ * Web search integration for gathering context related to operator conversations.
+ *
+ * Uses OpenClaw's web search API when available, with fallback behavior
+ * when the API is not exposed.
+ */
+
+import { WEB_SEARCH_ENABLED, MAX_WEB_RESULTS_PER_TOPIC } from "./config.js";
+import logger from "./logger.js";
+import type { OpenClawAPI, WebSearchResult } from "./types.js";
+
+export interface WebSearchContext {
+  query: string;
+  results: WebSearchResult[];
+}
+
+/**
+ * Search the web for content related to a list of topics.
+ *
+ * Returns aggregated results grouped by topic. When web search is disabled
+ * or the API is unavailable, returns empty results.
+ */
+export async function searchWebForTopics(
+  api: OpenClawAPI,
+  topics: string[],
+  limitPerTopic: number = MAX_WEB_RESULTS_PER_TOPIC
+): Promise<WebSearchContext[]> {
+  if (!WEB_SEARCH_ENABLED) {
+    logger.debug("Web search disabled by configuration");
+    return [];
+  }
+
+  if (!api.webSearch) {
+    logger.debug("OpenClaw web search API not available");
+    return [];
+  }
+
+  const results: WebSearchContext[] = [];
+
+  for (const topic of topics) {
+    try {
+      logger.debug(`Searching web for topic: ${topic}`);
+      const searchResults = await api.webSearch.search(topic, limitPerTopic);
+
+      results.push({
+        query: topic,
+        results: searchResults,
+      });
+
+      logger.debug(`Found ${searchResults.length} web results for "${topic}"`);
+    } catch (error) {
+      logger.warn(`Web search failed for topic "${topic}": ${error}`);
+      results.push({
+        query: topic,
+        results: [],
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Format web search results into a readable context string for LLM consumption.
+ */
+export function formatWebContext(searchContexts: WebSearchContext[]): string {
+  if (searchContexts.length === 0) {
+    return "";
+  }
+
+  const sections: string[] = [];
+
+  for (const ctx of searchContexts) {
+    if (ctx.results.length === 0) continue;
+
+    const resultLines = ctx.results.map(
+      (r, i) => `  ${i + 1}. ${r.title}\n     ${r.snippet}\n     (${r.url})`
+    );
+
+    sections.push(`Topic: "${ctx.query}"\n${resultLines.join("\n")}`);
+  }
+
+  if (sections.length === 0) {
+    return "";
+  }
+
+  return `WEB SEARCH RESULTS:\n\n${sections.join("\n\n")}`;
+}