@evermind-ai/openclaw-plugin 1.1.0 → 1.3.0

package/src/compaction.js

@@ -1,85 +0,0 @@
-/**
- * Compaction Handler Module
- * Handles session compaction evaluation and participation
- */
-
-/**
- * @typedef {import("./types.js").EverMemOSConfig} EverMemOSConfig
- * @typedef {import("./types.js").Logger} Logger
- */
-
-/**
- * Compaction evaluation parameters
- * @typedef {Object} CompactionEvalParams
- * @property {Array} messages
- * @property {number} tokenCount
- * @property {number} turnCount
- * @property {number} lastAssembleTime
- */
-
-/**
- * Compaction decision result
- * @typedef {Object} CompactionDecision
- * @property {boolean} shouldCompact
- * @property {string} reason
- * @property {string} [memoryStrategy]
- */
-
-/**
- * Handles session compaction evaluation and participation
- * Evaluates when to compact the conversation context
- */
-export class CompactionHandler {
-  /**
-   * @param {EverMemOSConfig} cfg
-   * @param {Logger} logger
-   */
-  constructor(cfg, logger) {
-    this.cfg = cfg;
-    this.log = logger;
-
-    // Configurable thresholds
-    this.compactThresholdTokens = 8000;
-    this.compactThresholdTurns = 10;
-  }
-
-  /**
-   * Evaluate whether session should be compacted
-   * @param {CompactionEvalParams} params
-   * @returns {Promise<CompactionDecision>}
-   */
-  async evaluate({ messages, tokenCount, turnCount, lastAssembleTime }) {
-    // Compact if token count exceeds threshold
-    if (tokenCount > this.compactThresholdTokens) {
-      return {
-        shouldCompact: true,
-        reason: `token count (${tokenCount}) exceeds threshold (${this.compactThresholdTokens})`,
-        memoryStrategy: "consolidate_to_long_term",
-      };
-    }
-
-    // Compact if turn count exceeds threshold
-    if (turnCount > this.compactThresholdTurns) {
-      return {
-        shouldCompact: true,
-        reason: `turn count (${turnCount}) exceeds threshold (${this.compactThresholdTurns})`,
-        memoryStrategy: "consolidate_to_long_term",
-      };
-    }
-
-    // Compact if no recent memory assembly (stale session)
-    const timeSinceAssemble = Date.now() - lastAssembleTime;
-    if (lastAssembleTime > 0 && timeSinceAssemble > 30 * 60 * 1000) { // 30 minutes
-      return {
-        shouldCompact: true,
-        reason: `session inactive for ${Math.round(timeSinceAssemble / 60000)} minutes`,
-        memoryStrategy: "consolidate_to_long_term",
-      };
-    }
-
-    return {
-      shouldCompact: false,
-      reason: "token and turn counts within acceptable range",
-    };
-  }
-}

package/src/context-engine.js

@@ -1,283 +0,0 @@
-/**
- * EverMemOS ContextEngine Implementation for OpenClaw 3.8+
- * Implements full-lifecycle memory management: bootstrap, assemble, afterTurn, compact, subagent
- */
-
-import { resolveConfig } from "./config.js";
-import { toText, isSessionResetPrompt, collectMessages } from "./message-utils.js";
-import { ContextAssembler } from "./assembler.js";
-import { LifecycleManager } from "./lifecycle.js";
-import { CompactionHandler } from "./compaction.js";
-import { SubagentTracker } from "./subagent.js";
-
-/**
- * @typedef {import("./types.js").EverMemOSConfig} EverMemOSConfig
- * @typedef {import("./types.js").Logger} Logger
- * @typedef {import("./types.js").BootstrapContext} BootstrapContext
- * @typedef {import("./types.js").AssembleContext} AssembleContext
- * @typedef {import("./types.js").AssembleResult} AssembleResult
- * @typedef {import("./types.js").AfterTurnContext} AfterTurnContext
- * @typedef {import("./types.js").CompactContext} CompactContext
- * @typedef {import("./types.js").CompactResult} CompactResult
- * @typedef {import("./types.js").PrepareSubagentContext} PrepareSubagentContext
- * @typedef {import("./types.js").PrepareSubagentResult} PrepareSubagentResult
- * @typedef {import("./types.js").SubagentEndedContext} SubagentEndedContext
- */
-
-/**
- * EverMemOS ContextEngine implementation for OpenClaw 3.8+
- * Implements full-lifecycle memory management: bootstrap, assemble, afterTurn, compact, subagent
- */
-export class EverMemOSContextEngine {
-  /**
-   * @param {EverMemOSConfig} config
-   * @param {Logger} logger
-   */
-  constructor(config, logger = console) {
-    this.cfg = resolveConfig(config);
-    this.log = logger;
-
-    // Session state tracking
-    this.turnCount = 0;
-    this.lastAssembleTime = 0;
-    this.pendingFlush = false;
-
-    // Submodules
-    this.assembler = new ContextAssembler(this.cfg, this.log);
-    this.lifecycle = new LifecycleManager(this.cfg, this.log);
-    this.compaction = new CompactionHandler(this.cfg, this.log);
-    this.subagentTracker = new SubagentTracker(this.cfg, this.log);
-  }
-
-  /**
-   * Bootstrap: Called once when plugin loads. Initialize connection and verify backend health.
-   * @param {BootstrapContext} ctx
-   * @returns {Promise<void>}
-   */
-  async bootstrap(ctx) {
-    this.log("[evermemos] bootstrap: initializing EverMemOS connection");
-    try {
-      const result = await this._healthCheck();
-      if (result?.status === "ok") {
-        this.log("[evermemos] bootstrap: backend healthy");
-      } else {
-        this.log.warn("[evermemos] bootstrap: backend unhealthy, will degrade gracefully");
-      }
-    } catch (err) {
-      this.log.warn(`[evermemos] bootstrap: health check failed: ${err.message}`);
-    }
-  }
-
-  /**
-   * Assemble: Build context from memories before agent processes the prompt.
-   * This replaces the old before_agent_start hook with query-aware assembly.
-   * @param {AssembleContext} ctx
-   * @returns {Promise<AssembleResult>}
-   */
-  async assemble(ctx) {
-    const { prompt, messages } = ctx;
-    const query = toText(prompt);
-
-    // Detect session reset (/new, /reset)
-    if (isSessionResetPrompt(query)) {
-      this.log("[evermemos] assemble: session reset detected, skipping search");
-      this.pendingFlush = true;
-      return { context: "", metadata: { skipped: "session_reset" } };
-    }
-
-    if (!query || query.length < 3) {
-      return { context: "", metadata: { skipped: "empty_query" } };
-    }
-
-    try {
-      this.lastAssembleTime = Date.now();
-      const result = await this.assembler.assemble(query, messages, this.turnCount);
-      this.log(`[evermemos] assemble: retrieved ${result.memoryCount} memories`);
-      return {
-        context: result.context,
-        metadata: {
-          memoryCount: result.memoryCount,
-          retrieveMethod: this.cfg.retrieveMethod,
-          turnCount: this.turnCount,
-        },
-      };
-    } catch (err) {
-      this.log.warn(`[evermemos] assemble: ${err.message}`);
-      return { context: "", metadata: { error: err.message } };
-    }
-  }
-
-  /**
-   * AfterTurn: Called after each agent turn. Extract memories promptly.
-   * This enables timely extraction instead of waiting for agent_end.
-   * @param {AfterTurnContext} ctx
-   * @returns {Promise<void>}
-   */
-  async afterTurn(ctx) {
-    const { messages, success } = ctx;
-    this.turnCount++;
-
-    if (!success || !messages?.length) {
-      this.log(`[evermemos] afterTurn: turn ${this.turnCount} skipped (no success/messages)`);
-      return;
-    }
-
-    try {
-      const collected = collectMessages(messages);
-      if (!collected.length) {
-        this.log(`[evermemos] afterTurn: turn ${this.turnCount} - no messages to save`);
-        return;
-      }
-
-      await this.lifecycle.ingestTurn({
-        userId: this.cfg.userId,
-        groupId: this.cfg.groupId,
-        messages: collected,
-        turnCount: this.turnCount,
-        flush: this.pendingFlush,
-      });
-
-      this.log(`[evermemos] afterTurn: turn ${this.turnCount} - saved ${collected.length} messages`);
-
-      // Consume flush flag after successful save
-      if (this.pendingFlush) {
-        this.pendingFlush = false;
-        this.log("[evermemos] afterTurn: flush flag consumed");
-      }
-    } catch (err) {
-      this.log.warn(`[evermemos] afterTurn: ${err.message}`);
-    }
-  }
-
-  /**
-   * Compact: Participate in session compaction decision and memory consolidation.
-   * @param {CompactContext} ctx
-   * @returns {Promise<CompactResult>}
-   */
-  async compact(ctx) {
-    const { messages, tokenCount } = ctx;
-
-    this.log(`[evermemos] compact: evaluating compaction (tokens: ${tokenCount}, turns: ${this.turnCount})`);
-
-    try {
-      const decision = await this.compaction.evaluate({
-        messages,
-        tokenCount,
-        turnCount: this.turnCount,
-        lastAssembleTime: this.lastAssembleTime,
-      });
-
-      if (decision.shouldCompact) {
-        this.log(`[evermemos] compact: compaction recommended - ${decision.reason}`);
-        return {
-          shouldCompact: true,
-          reason: decision.reason,
-          metadata: {
-            turnCount: this.turnCount,
-            memoryStrategy: decision.memoryStrategy,
-          },
-        };
-      }
-
-      this.log("[evermemos] compact: no compaction needed");
-      return { shouldCompact: false, reason: decision.reason };
-    } catch (err) {
-      this.log.warn(`[evermemos] compact: ${err.message}`);
-      return { shouldCompact: false, reason: "error evaluating compaction" };
-    }
-  }
-
-  /**
-   * PrepareSubagentSpawn: Called before spawning a subagent.
-   * @param {PrepareSubagentContext} ctx
-   * @returns {Promise<PrepareSubagentResult>}
-   */
-  async prepareSubagentSpawn(ctx) {
-    const { subagentId, parentMessages } = ctx;
-
-    this.log(`[evermemos] prepareSubagentSpawn: tracking subagent ${subagentId}`);
-
-    // Register the subagent
-    this.subagentTracker.register(subagentId, {
-      subagentType: ctx.subagentType,
-      parentTurnCount: this.turnCount,
-    });
-
-    try {
-      // Collect relevant memories for the subagent
-      const query = toText(ctx.prompt);
-      const context = query
-        ? await this.assembler.assembleForSubagent(query)
-        : "";
-
-      return {
-        prependContext: context || "",
-        metadata: {
-          subagentId,
-          parentTurnCount: this.turnCount,
-        },
-      };
-    } catch (err) {
-      this.log.warn(`[evermemos] prepareSubagentSpawn: ${err.message}`);
-      return { prependContext: "", metadata: {} };
-    }
-  }
-
-  /**
-   * OnSubagentEnded: Called after a subagent completes.
-   * @param {SubagentEndedContext} ctx
-   * @returns {Promise<void>}
-   */
-  async onSubagentEnded(ctx) {
-    const { subagentId, messages, success } = ctx;
-
-    this.log(`[evermemos] onSubagentEnded: subagent ${subagentId} ended, success=${success}`);
-
-    // Unregister the subagent
-    this.subagentTracker.unregister(subagentId);
-
-    try {
-      if (success && messages?.length) {
-        const collected = collectMessages(messages);
-        if (collected.length) {
-          await this.lifecycle.ingestTurn({
-            userId: this.cfg.userId,
-            groupId: this.cfg.groupId,
-            messages: collected,
-            turnCount: this.turnCount,
-            flush: false,
-          });
-          this.log(`[evermemos] onSubagentEnded: saved ${collected.length} messages from subagent`);
-        }
-      }
-    } catch (err) {
-      this.log.warn(`[evermemos] onSubagentEnded: ${err.message}`);
-    }
-  }
-
-  /**
-   * Internal: Verify backend health
-   * @private
-   * @returns {Promise<{status: string}|null>}
-   */
-  async _healthCheck() {
-    const { serverUrl } = this.cfg;
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 5000);
-
-      const response = await fetch(`${serverUrl}/api/v0/health`, {
-        method: "GET",
-        signal: controller.signal,
-      });
-      clearTimeout(timeout);
-
-      if (response.ok) {
-        return await response.json();
-      }
-      return { status: "error", httpStatus: response.status };
-    } catch {
-      return { status: "error" };
-    }
-  }
-}

package/src/lifecycle.js

@@ -1,65 +0,0 @@
-/**
- * Lifecycle Manager Module
- * Handles turn-level memory ingestion
- */
-
-import { saveMemories } from "./memory-api.js";
-
-/**
- * @typedef {import("./types.js").EverMemOSConfig} EverMemOSConfig
- * @typedef {import("./types.js").Logger} Logger
- */
-
-/**
- * Turn ingestion parameters
- * @typedef {Object} IngestTurnParams
- * @property {string} userId
- * @property {string} groupId
- * @property {Array} messages
- * @property {number} turnCount
- * @property {boolean} flush
- */
-
-/**
- * Handles turn-level memory ingestion
- * Extracts and saves memories after each conversation turn
- */
-export class LifecycleManager {
-  /**
-   * @param {EverMemOSConfig} cfg
-   * @param {Logger} logger
-   */
-  constructor(cfg, logger) {
-    this.cfg = cfg;
-    this.log = logger;
-  }
-
-  /**
-   * Ingest messages from a single turn
-   * @param {IngestTurnParams} params
-   * @returns {Promise<void>}
-   */
-  async ingestTurn({ userId, groupId, messages, turnCount, flush }) {
-    await saveMemories(this.cfg, {
-      userId,
-      groupId,
-      messages,
-      flush,
-    });
-  }
-
-  /**
-   * Flush pending memories to storage
-   * Called when session ends or reset is detected
-   * @returns {Promise<void>}
-   */
-  async flush() {
-    // Force save with flush=true
-    await saveMemories(this.cfg, {
-      userId: this.cfg.userId,
-      groupId: this.cfg.groupId,
-      messages: [],
-      flush: true,
-    });
-  }
-}