@hippodid/openclaw-plugin 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hippodid/openclaw-plugin",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Cloud sync for MEMORY.md with structured character memory. Survives context compaction.",
   "license": "Apache-2.0",
   "repository": {

package/src/hooks/auto-capture.ts

@@ -1,58 +1,37 @@
 import type { HippoDidClient } from '../hippodid-client.js';
-import type { PluginConfig, OpenClawPluginAPI } from '../types.js';
+import type { PluginConfig } from '../types.js';
 
 export function createAutoCaptureHook(
   client: HippoDidClient,
   config: PluginConfig,
   logger: { info(msg: string): void; warn(msg: string): void },
-): (api: OpenClawPluginAPI) => void {
-  return (api: OpenClawPluginAPI) => {
-    api.on('agent_end', (...args: unknown[]) => {
-      try {
-        const exchange = extractExchange(args);
-        if (!exchange) return;
+): (api: any) => void {
+  return (api: any) => {
+    // OpenClaw 2026 does not support api.on() for post-response hooks.
+    // Register a capture tool that agents invoke to store important information.
+    api.registerTool('hippodid:remember', {
+      description: 'Save important information to HippoDid character memory. Call this to store facts, decisions, preferences, or context that should persist across sessions.',
+      args: [
+        {
+          name: 'content',
+          description: 'The information to remember',
+          required: true,
+        },
+      ],
+      handler: async (args: Record<string, string>) => {
+        const content = args['content'] ?? '';
+        if (!content) return 'Nothing to remember.';
 
-        client
-          .addMemory(config.characterId, exchange, 'openclaw-auto-capture')
-          .then((result) => {
-            if (result.ok) {
-              logger.info('hippodid: captured exchange for memory extraction');
-            } else {
-              logger.warn(
-                `hippodid: capture failed: ${result.error.message}`,
-              );
-            }
-          })
-          .catch((e) => {
-            logger.warn(
-              `hippodid: capture error: ${e instanceof Error ? e.message : 'unknown'}`,
-            );
-          });
-      } catch (e) {
-        logger.warn(
-          `hippodid: capture hook error: ${e instanceof Error ? e.message : 'unknown'}`,
-        );
-      }
+        const result = await client.addMemory(config.characterId, content);
+        if (result.ok) {
+          logger.info(`hippodid: captured memory: ${content.slice(0, 80)}...`);
+          return 'Remembered.';
+        } else {
+          logger.warn(`hippodid: capture failed: ${result.error.message}`);
+          return `Failed to remember: ${result.error.message}`;
+        }
+      },
     });
+    logger.info('hippodid: auto-capture tool registered as hippodid:remember');
   };
 }
-
-function extractExchange(args: unknown[]): string | null {
-  if (args.length > 0 && typeof args[0] === 'object' && args[0] !== null) {
-    const event = args[0] as Record<string, unknown>;
-
-    const userMsg =
-      typeof event['userMessage'] === 'string' ? event['userMessage'] : '';
-    const agentResp =
-      typeof event['agentResponse'] === 'string' ? event['agentResponse'] : '';
-
-    if (userMsg || agentResp) {
-      return `User: ${userMsg}\n\nAgent: ${agentResp}`;
-    }
-
-    if (typeof event['content'] === 'string') return event['content'];
-    if (typeof event['text'] === 'string') return event['text'];
-  }
-  if (typeof args[0] === 'string') return args[0];
-  return null;
-}

package/src/hooks/auto-recall.ts

@@ -1,67 +1,36 @@
 import type { HippoDidClient } from '../hippodid-client.js';
-import type { PluginConfig, OpenClawPluginAPI } from '../types.js';
+import type { PluginConfig } from '../types.js';
 
 export function createAutoRecallHook(
   client: HippoDidClient,
   config: PluginConfig,
   logger: { info(msg: string): void; warn(msg: string): void },
-): (api: OpenClawPluginAPI) => void {
-  return (api: OpenClawPluginAPI) => {
-    api.on('before_agent_start', async (...args: unknown[]) => {
-      try {
-        const userMessage = extractUserMessage(args);
-        if (!userMessage) return;
-
-        const result = await client.searchMemories(
-          config.characterId,
-          userMessage,
-          5,
-        );
-
-        if (!result.ok) {
-          logger.warn(
-            `hippodid: recall search failed: ${result.error.message}`,
-          );
-          return;
-        }
-
-        const memories = result.value;
-        if (memories.length === 0) {
-          logger.info('hippodid: no relevant memories found');
-          return;
+): (api: any) => void {
+  return (api: any) => {
+    // OpenClaw 2026 does not support api.on() for pre-response hooks.
+    // Register a recall tool that agents invoke when they need memory context.
+    api.registerTool('hippodid:recall', {
+      description: 'Search HippoDid character memory and return relevant context. Call this at the start of a task to recall relevant memories.',
+      args: [
+        {
+          name: 'query',
+          description: 'What to search for in memory',
+          required: true,
+        },
+      ],
+      handler: async (args: Record<string, string>) => {
+        const query = args['query'] ?? '';
+        const result = await client.searchMemories(config.characterId, query);
+        if (result.ok) {
+          const memories = result.value;
+          logger.info(`hippodid: recalled ${memories.length} memories for query: ${query}`);
+          return memories.map((m) => m.content).join('\n\n');
+        } else {
+          logger.warn(`hippodid: recall failed: ${result.error.message}`);
+          return 'No memories found.';
         }
-
-        const contextBlock = formatMemoriesBlock(memories);
-        api.context.prepend(contextBlock);
-        logger.info(`hippodid: recalled ${memories.length} memories for context`);
-      } catch (e) {
-        logger.warn(
-          `hippodid: recall hook error: ${e instanceof Error ? e.message : 'unknown'}`,
-        );
-      }
+      },
     });
+    logger.info('hippodid: auto-recall tool registered as hippodid:recall');
   };
 }
-
-function extractUserMessage(args: unknown[]): string | null {
-  if (args.length > 0 && typeof args[0] === 'object' && args[0] !== null) {
-    const event = args[0] as Record<string, unknown>;
-    if (typeof event['message'] === 'string') return event['message'];
-    if (typeof event['content'] === 'string') return event['content'];
-    if (typeof event['text'] === 'string') return event['text'];
-  }
-  if (typeof args[0] === 'string') return args[0];
-  return null;
-}
-
-interface MemoryEntry {
-  content: string;
-  category: string;
-}
-
-function formatMemoriesBlock(memories: MemoryEntry[]): string {
-  const lines = memories.map(
-    (m) => `- [Category: ${m.category}] ${m.content}`,
-  );
-  return `<hippodid-memories>\n${lines.join('\n')}\n</hippodid-memories>`;
-}

package/src/hooks/memory-flush.ts

@@ -1,22 +1,14 @@
 import type { FileSync } from '../file-sync.js';
-import type { OpenClawPluginAPI } from '../types.js';
 
 export function createMemoryFlushHook(
   fileSync: FileSync,
   logger: { info(msg: string): void; warn(msg: string): void },
-): (api: OpenClawPluginAPI) => void {
-  return (api: OpenClawPluginAPI) => {
-    api.on('memoryFlush', async () => {
-      try {
-        const { synced, changed } = await fileSync.flushNow();
-        logger.info(
-          `hippodid: pre-compaction flush — synced ${synced} files (${changed} changed)`,
-        );
-      } catch (e) {
-        logger.warn(
-          `hippodid: pre-compaction flush failed: ${e instanceof Error ? e.message : 'unknown'}`,
-        );
-      }
-    });
+): (api: any) => void {
+  return (_api: any) => {
+    // OpenClaw 2026 does not support api.on() for event hooks.
+    // Pre-compaction flush is available via the hippodid:sync tool,
+    // which agents can call explicitly before a compaction.
+    // Background sync is handled by fileSync.start() interval.
+    logger.info('hippodid: memory flush handler ready (use hippodid:sync tool to trigger)');
   };
 }

package/src/hooks/session-lifecycle.ts

@@ -1,42 +1,16 @@
 import type { FileSync } from '../file-sync.js';
 import type { TierManager } from '../tier-manager.js';
-import type { OpenClawPluginAPI } from '../types.js';
 
 export function createSessionHooks(
   fileSync: FileSync,
   tierManager: TierManager,
-  autoRecallEnabled: boolean,
+  autoRecall: boolean,
   logger: { info(msg: string): void; warn(msg: string): void },
-): (api: OpenClawPluginAPI) => void {
-  return (api: OpenClawPluginAPI) => {
-    api.on('session:start', async () => {
-      try {
-        await tierManager.initialize();
-
-        if (tierManager.shouldHydrateOnStart(autoRecallEnabled)) {
-          const count = await fileSync.hydrateFromCloud();
-          logger.info(`hippodid: session started, hydrated ${count} files from cloud`);
-        } else {
-          logger.info('hippodid: session started, hydration skipped (autoRecall active)');
-        }
-      } catch (e) {
-        logger.warn(
-          `hippodid: session start error: ${e instanceof Error ? e.message : 'unknown'}`,
-        );
-      }
-    });
-
-    api.on('session:end', async () => {
-      try {
-        const { synced, changed } = await fileSync.flushNow();
-        logger.info(
-          `hippodid: session ended, final sync — ${synced} files (${changed} changed)`,
-        );
-      } catch (e) {
-        logger.warn(
-          `hippodid: session end flush failed: ${e instanceof Error ? e.message : 'unknown'}`,
-        );
-      }
-    });
+): (api: any) => void {
+  return (_api: any) => {
+    // OpenClaw 2026 does not support api.on() for session lifecycle events.
+    // Session start hydration happens automatically via fileSync.start()
+    // which pulls cloud state on initialization.
+    logger.info('hippodid: session lifecycle handler ready');
   };
 }

package/src/index.ts

@@ -17,7 +17,7 @@ export default {
 
   register(api: any): void {
     try {
-      const config = resolveConfig(api.config);
+      const config = resolveConfig(api.config ?? {});
       const logger = api.logger ?? {
         info: (msg: string) => console.log(msg),
         warn: (msg: string) => console.warn(msg),
@@ -122,9 +122,20 @@ export default {
 };
 
 function resolveConfig(raw: any): PluginConfig {
+  if (!raw || typeof raw !== 'object') {
+    return {
+      apiKey: '',
+      characterId: '',
+      baseUrl: 'https://api.hippodid.com',
+      syncIntervalSeconds: 300,
+      autoRecall: false,
+      autoCapture: false,
+      additionalPaths: [],
+    };
+  }
   return {
-    apiKey: raw.apiKey,
-    characterId: raw.characterId,
+    apiKey: raw.apiKey ?? '',
+    characterId: raw.characterId ?? '',
     baseUrl: raw.baseUrl ?? 'https://api.hippodid.com',
     syncIntervalSeconds: raw.syncIntervalSeconds ?? 300,
     autoRecall: raw.autoRecall ?? false,

package/src/types.ts

@@ -127,32 +127,7 @@ export interface FileTrackingEntry {
   lastSyncedAt: Date;
 }
 
-// --- OpenClaw Plugin API (local type, matches openclaw/plugin-sdk/core) ---
-
-export interface OpenClawPluginAPI {
-  config: PluginConfig;
-  logger: {
-    info(message: string): void;
-    warn(message: string): void;
-    error(message: string): void;
-  };
-  on(event: string, handler: (...args: any[]) => void | Promise<void>): void;
-  context: {
-    prepend(content: string): void;
-  };
-  commands: {
-    register(name: string, options: CommandOptions): void;
-  };
-}
-
-export interface CommandOptions {
-  description: string;
-  args?: CommandArg[];
-  handler: (args: Record<string, string>) => void | Promise<void>;
-}
-
-export interface CommandArg {
-  name: string;
-  description: string;
-  required?: boolean;
-}
+// OpenClaw Plugin API — typed as `any` at boundaries.
+// The real type comes from openclaw/plugin-sdk/core at runtime.
+// Methods used: api.registerTool(), api.logger, api.config
+export type OpenClawPluginAPI = any;