@arephan/clawdbot-memory-supabase 0.1.0

package/plugin/index.ts

@@ -0,0 +1,650 @@
+/**
+ * Clawdbot Memory (Supabase) Plugin - Simple Edition
+ * 
+ * Logs EVERY message (user + assistant) to Supabase.
+ * Provides date-based recall for perfect memory.
+ * No embeddings, no vector search - just complete logging.
+ */
+
+import { Type } from "@sinclair/typebox";
+import { createClient, SupabaseClient } from "@supabase/supabase-js";
+import { randomUUID } from "node:crypto";
+import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+type Session = {
+  id: string;
+  agent_id: string;
+  user_id?: string;
+  channel?: string;
+  started_at: string;
+  ended_at?: string;
+  summary?: string;
+  metadata: Record<string, unknown>;
+};
+
+type Message = {
+  id: string;
+  session_id: string;
+  role: "user" | "assistant" | "system" | "tool";
+  content: string;
+  created_at: string;
+  metadata: Record<string, unknown>;
+};
+
+// ============================================================================
+// Config
+// ============================================================================
+
+const configSchema = {
+  parse: (cfg: unknown) => {
+    const config = cfg as {
+      supabase: { url: string; anonKey: string };
+      agentId?: string;
+    };
+    return {
+      supabase: config.supabase,
+      agentId: config.agentId ?? "hans-assistant",
+    };
+  },
+};
+
+// ============================================================================
+// Supabase Client
+// ============================================================================
+
+class ConversationDB {
+  private client: SupabaseClient;
+  private agentId: string;
+
+  constructor(url: string, anonKey: string, agentId: string) {
+    this.client = createClient(url, anonKey);
+    this.agentId = agentId;
+  }
+
+  // Session management
+  async createSession(params: {
+    userId?: string;
+    channel?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<Session> {
+    const id = randomUUID();
+    const { data, error } = await this.client
+      .from("sessions")
+      .insert({
+        id,
+        agent_id: this.agentId,
+        user_id: params.userId,
+        channel: params.channel,
+        started_at: new Date().toISOString(),
+        metadata: params.metadata ?? {},
+      })
+      .select()
+      .single();
+
+    if (error) throw new Error(`Failed to create session: ${error.message}`);
+    return data as Session;
+  }
+
+  async endSession(sessionId: string, summary?: string): Promise<void> {
+    const { error } = await this.client
+      .from("sessions")
+      .update({
+        ended_at: new Date().toISOString(),
+        summary,
+      })
+      .eq("id", sessionId);
+
+    if (error) throw new Error(`Failed to end session: ${error.message}`);
+  }
+
+  async addMessage(params: {
+    sessionId: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<Message> {
+    const id = randomUUID();
+    const created_at = new Date().toISOString();
+    
+    const { data, error } = await this.client
+      .from("messages")
+      .insert({
+        id,
+        session_id: params.sessionId,
+        role: params.role,
+        content: params.content,
+        created_at,
+        metadata: params.metadata ?? {},
+      })
+      .select()
+      .single();
+
+    if (error) throw new Error(`Failed to add message: ${error.message}`);
+    return data as Message;
+  }
+
+  // Recall by date
+  async getMessagesByDate(date: string, keywords?: string): Promise<Array<Message & { session_started: string }>> {
+    let query = this.client
+      .from("messages")
+      .select(`
+        *,
+        sessions!inner (
+          agent_id,
+          started_at
+        )
+      `)
+      .eq("sessions.agent_id", this.agentId)
+      .gte("created_at", `${date}T00:00:00`)
+      .lt("created_at", `${date}T23:59:59`)
+      .order("created_at", { ascending: true });
+
+    if (keywords) {
+      query = query.ilike("content", `%${keywords}%`);
+    }
+
+    const { data, error } = await query;
+
+    if (error) throw new Error(`Failed to get messages: ${error.message}`);
+    
+    return (data || []).map((row: any) => ({
+      ...row,
+      session_started: row.sessions?.started_at,
+    }));
+  }
+
+  // Recall by date range
+  async getMessagesByDateRange(
+    startDate: string,
+    endDate: string,
+    keywords?: string
+  ): Promise<Array<Message & { session_started: string }>> {
+    let query = this.client
+      .from("messages")
+      .select(`
+        *,
+        sessions!inner (
+          agent_id,
+          started_at
+        )
+      `)
+      .eq("sessions.agent_id", this.agentId)
+      .gte("created_at", `${startDate}T00:00:00`)
+      .lte("created_at", `${endDate}T23:59:59`)
+      .order("created_at", { ascending: true });
+
+    if (keywords) {
+      query = query.ilike("content", `%${keywords}%`);
+    }
+
+    const { data, error } = await query;
+
+    if (error) throw new Error(`Failed to get messages: ${error.message}`);
+    
+    return (data || []).map((row: any) => ({
+      ...row,
+      session_started: row.sessions?.started_at,
+    }));
+  }
+
+  // Search by keywords across all time
+  async searchMessages(keywords: string, limit = 50): Promise<Array<Message>> {
+    const { data, error } = await this.client
+      .from("messages")
+      .select(`
+        *,
+        sessions!inner (
+          agent_id
+        )
+      `)
+      .eq("sessions.agent_id", this.agentId)
+      .ilike("content", `%${keywords}%`)
+      .order("created_at", { ascending: false })
+      .limit(limit);
+
+    if (error) throw new Error(`Failed to search messages: ${error.message}`);
+    return data || [];
+  }
+
+  // Get recent sessions
+  async getRecentSessions(limit = 10): Promise<Session[]> {
+    const { data, error } = await this.client
+      .from("sessions")
+      .select("*")
+      .eq("agent_id", this.agentId)
+      .order("started_at", { ascending: false })
+      .limit(limit);
+
+    if (error) throw new Error(`Failed to get sessions: ${error.message}`);
+    return data as Session[];
+  }
+
+  // Get session with all messages
+  async getSessionWithMessages(sessionId: string): Promise<{ session: Session; messages: Message[] } | null> {
+    const { data: session, error: sessionError } = await this.client
+      .from("sessions")
+      .select("*")
+      .eq("id", sessionId)
+      .single();
+
+    if (sessionError || !session) return null;
+
+    const { data: messages, error: messagesError } = await this.client
+      .from("messages")
+      .select("*")
+      .eq("session_id", sessionId)
+      .order("created_at", { ascending: true });
+
+    if (messagesError) throw new Error(`Failed to get messages: ${messagesError.message}`);
+
+    return {
+      session: session as Session,
+      messages: messages as Message[],
+    };
+  }
+
+  // Stats
+  async getStats(): Promise<{ sessions: number; messages: number }> {
+    const { count: sessions } = await this.client
+      .from("sessions")
+      .select("*", { count: "exact", head: true })
+      .eq("agent_id", this.agentId);
+
+    const { count: messages } = await this.client
+      .from("messages")
+      .select("*, sessions!inner(agent_id)", { count: "exact", head: true })
+      .eq("sessions.agent_id", this.agentId);
+
+    return {
+      sessions: sessions ?? 0,
+      messages: messages ?? 0,
+    };
+  }
+}
+
+// ============================================================================
+// Plugin Definition
+// ============================================================================
+
+const memoryPlugin = {
+  id: "memory-supabase",
+  name: "Memory (Supabase)",
+  description: "Complete conversation logging to Supabase with date-based recall",
+  kind: "memory" as const,
+  configSchema,
+
+  register(api: ClawdbotPluginApi) {
+    const cfg = configSchema.parse(api.pluginConfig);
+    const db = new ConversationDB(cfg.supabase.url, cfg.supabase.anonKey, cfg.agentId);
+
+    let currentSessionId: string | null = null;
+
+    api.logger.info(
+      `memory-supabase: plugin registered (url: ${cfg.supabase.url}, agent: ${cfg.agentId})`
+    );
+
+    // ========================================================================
+    // Tools
+    // ========================================================================
+
+    api.registerTool(
+      {
+        name: "recall_conversation",
+        label: "Recall Conversation",
+        description:
+          "Recall past conversations by date. Use when user references something from a specific date or you need historical context.",
+        parameters: Type.Object({
+          date: Type.String({ 
+            description: "Date in YYYY-MM-DD format (e.g., '2026-01-15')" 
+          }),
+          keywords: Type.Optional(
+            Type.String({ description: "Optional keywords to filter by" })
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const { date, keywords } = params as { date: string; keywords?: string };
+
+          const messages = await db.getMessagesByDate(date, keywords);
+
+          if (messages.length === 0) {
+            return {
+              content: [{ 
+                type: "text", 
+                text: `No conversations found for ${date}${keywords ? ` with keywords "${keywords}"` : ""}.` 
+              }],
+              details: { count: 0, date },
+            };
+          }
+
+          const formatted = messages.map((m) => {
+            const time = new Date(m.created_at).toLocaleTimeString("en-US", {
+              hour: "2-digit",
+              minute: "2-digit",
+            });
+            return `[${time}] ${m.role.toUpperCase()}: ${m.content}`;
+          }).join("\n\n");
+
+          return {
+            content: [{ 
+              type: "text", 
+              text: `Found ${messages.length} messages from ${date}:\n\n${formatted}` 
+            }],
+            details: { 
+              count: messages.length, 
+              date,
+              messages: messages.map(m => ({
+                role: m.role,
+                content: m.content.slice(0, 200),
+                time: m.created_at,
+              })),
+            },
+          };
+        },
+      },
+      { name: "recall_conversation" }
+    );
+
+    api.registerTool(
+      {
+        name: "recall_date_range",
+        label: "Recall Date Range",
+        description:
+          "Recall conversations across a date range. Use for 'last week', 'this month', etc.",
+        parameters: Type.Object({
+          startDate: Type.String({ 
+            description: "Start date in YYYY-MM-DD format" 
+          }),
+          endDate: Type.String({ 
+            description: "End date in YYYY-MM-DD format" 
+          }),
+          keywords: Type.Optional(
+            Type.String({ description: "Optional keywords to filter by" })
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const { startDate, endDate, keywords } = params as { 
+            startDate: string; 
+            endDate: string; 
+            keywords?: string;
+          };
+
+          const messages = await db.getMessagesByDateRange(startDate, endDate, keywords);
+
+          if (messages.length === 0) {
+            return {
+              content: [{ 
+                type: "text", 
+                text: `No conversations found between ${startDate} and ${endDate}${keywords ? ` with keywords "${keywords}"` : ""}.` 
+              }],
+              details: { count: 0, startDate, endDate },
+            };
+          }
+
+          // Group by date
+          const byDate: Record<string, typeof messages> = {};
+          for (const m of messages) {
+            const date = m.created_at.split("T")[0];
+            if (!byDate[date]) byDate[date] = [];
+            byDate[date].push(m);
+          }
+
+          const formatted = Object.entries(byDate)
+            .map(([date, msgs]) => {
+              const lines = msgs.map((m) => {
+                const time = new Date(m.created_at).toLocaleTimeString("en-US", {
+                  hour: "2-digit",
+                  minute: "2-digit",
+                });
+                return `  [${time}] ${m.role.toUpperCase()}: ${m.content.slice(0, 150)}${m.content.length > 150 ? "..." : ""}`;
+              }).join("\n");
+              return `📅 ${date} (${msgs.length} messages):\n${lines}`;
+            })
+            .join("\n\n");
+
+          return {
+            content: [{ 
+              type: "text", 
+              text: `Found ${messages.length} messages across ${Object.keys(byDate).length} days:\n\n${formatted}` 
+            }],
+            details: { 
+              count: messages.length, 
+              days: Object.keys(byDate).length,
+              startDate, 
+              endDate,
+            },
+          };
+        },
+      },
+      { name: "recall_date_range" }
+    );
+
+    api.registerTool(
+      {
+        name: "search_history",
+        label: "Search History",
+        description:
+          "Search all conversation history by keywords. Use when user asks about something but doesn't know the date.",
+        parameters: Type.Object({
+          keywords: Type.String({ 
+            description: "Keywords to search for" 
+          }),
+          limit: Type.Optional(
+            Type.Number({ description: "Max results (default: 20)" })
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const { keywords, limit = 20 } = params as { keywords: string; limit?: number };
+
+          const messages = await db.searchMessages(keywords, limit);
+
+          if (messages.length === 0) {
+            return {
+              content: [{ 
+                type: "text", 
+                text: `No messages found containing "${keywords}".` 
+              }],
+              details: { count: 0, keywords },
+            };
+          }
+
+          const formatted = messages.map((m) => {
+            const date = new Date(m.created_at).toLocaleDateString("en-US", {
+              month: "short",
+              day: "numeric",
+              year: "numeric",
+            });
+            const time = new Date(m.created_at).toLocaleTimeString("en-US", {
+              hour: "2-digit",
+              minute: "2-digit",
+            });
+            return `[${date} ${time}] ${m.role.toUpperCase()}: ${m.content.slice(0, 200)}${m.content.length > 200 ? "..." : ""}`;
+          }).join("\n\n");
+
+          return {
+            content: [{ 
+              type: "text", 
+              text: `Found ${messages.length} messages matching "${keywords}":\n\n${formatted}` 
+            }],
+            details: { 
+              count: messages.length, 
+              keywords,
+            },
+          };
+        },
+      },
+      { name: "search_history" }
+    );
+
+    api.registerTool(
+      {
+        name: "memory_stats",
+        label: "Memory Stats",
+        description: "Show conversation logging statistics.",
+        parameters: Type.Object({}),
+        async execute() {
+          const stats = await db.getStats();
+          const sessions = await db.getRecentSessions(5);
+
+          const recentList = sessions.map((s) => {
+            const date = new Date(s.started_at).toLocaleDateString("en-US", {
+              month: "short",
+              day: "numeric",
+            });
+            return `- ${date}: ${s.channel || "unknown"} session`;
+          }).join("\n");
+
+          return {
+            content: [{ 
+              type: "text", 
+              text: `📊 Memory Stats:\n- Total sessions: ${stats.sessions}\n- Total messages: ${stats.messages}\n\nRecent sessions:\n${recentList}` 
+            }],
+            details: stats,
+          };
+        },
+      },
+      { name: "memory_stats" }
+    );
+
+    // ========================================================================
+    // CLI Commands
+    // ========================================================================
+
+    api.registerCli(
+      ({ program }) => {
+        const memory = program
+          .command("supamem")
+          .description("Supabase memory commands");
+
+        memory
+          .command("stats")
+          .description("Show memory statistics")
+          .action(async () => {
+            const stats = await db.getStats();
+            console.log(`Sessions: ${stats.sessions}`);
+            console.log(`Messages: ${stats.messages}`);
+          });
+
+        memory
+          .command("recall")
+          .description("Recall messages from a date")
+          .argument("<date>", "Date (YYYY-MM-DD)")
+          .option("-k, --keywords <keywords>", "Filter by keywords")
+          .action(async (date, opts) => {
+            const messages = await db.getMessagesByDate(date, opts.keywords);
+            for (const m of messages) {
+              const time = new Date(m.created_at).toLocaleTimeString();
+              console.log(`[${time}] ${m.role}: ${m.content.slice(0, 100)}...`);
+            }
+          });
+
+        memory
+          .command("search")
+          .description("Search messages by keywords")
+          .argument("<keywords>", "Keywords to search")
+          .option("-l, --limit <n>", "Max results", "20")
+          .action(async (keywords, opts) => {
+            const messages = await db.searchMessages(keywords, parseInt(opts.limit));
+            for (const m of messages) {
+              const date = new Date(m.created_at).toLocaleString();
+              console.log(`[${date}] ${m.role}: ${m.content.slice(0, 100)}...`);
+            }
+          });
+      },
+      { commands: ["supamem"] }
+    );
+
+    // ========================================================================
+    // Lifecycle Hooks - LOG EVERYTHING
+    // ========================================================================
+
+    // Start session when conversation begins
+    api.on("before_agent_start", async (event) => {
+      try {
+        const session = await db.createSession({
+          userId: (event as any).userId,
+          channel: (event as any).channel,
+          metadata: { 
+            prompt: (event as any).prompt?.slice(0, 500),
+            startedAt: new Date().toISOString(),
+          },
+        });
+        currentSessionId = session.id;
+        api.logger.info?.(`memory-supabase: started session ${session.id}`);
+      } catch (err) {
+        api.logger.warn?.(`memory-supabase: session start failed: ${String(err)}`);
+      }
+    });
+
+    // Log all messages after agent ends
+    api.on("agent_end", async (event) => {
+      if (!currentSessionId) {
+        api.logger.warn?.("memory-supabase: no active session to log messages");
+        return;
+      }
+
+      try {
+        const messages = (event as any).messages || [];
+        let logged = 0;
+
+        for (const msg of messages) {
+          if (!msg || typeof msg !== "object") continue;
+          
+          const role = (msg as any).role as string;
+          if (role !== "user" && role !== "assistant") continue;
+
+          const content = (msg as any).content;
+          let text = "";
+
+          if (typeof content === "string") {
+            text = content;
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block?.type === "text" && typeof block.text === "string") {
+                text += block.text;
+              }
+            }
+          }
+
+          if (text && text.length > 0) {
+            await db.addMessage({
+              sessionId: currentSessionId,
+              role: role as "user" | "assistant",
+              content: text,
+            });
+            logged++;
+          }
+        }
+
+        // End session
+        await db.endSession(currentSessionId);
+        api.logger.info?.(`memory-supabase: logged ${logged} messages, session ended`);
+        currentSessionId = null;
+
+      } catch (err) {
+        api.logger.warn?.(`memory-supabase: logging failed: ${String(err)}`);
+      }
+    });
+
+    // ========================================================================
+    // Service
+    // ========================================================================
+
+    api.registerService({
+      id: "memory-supabase",
+      start: () => {
+        api.logger.info(
+          `memory-supabase: initialized (logs every message to Supabase)`
+        );
+      },
+      stop: () => {
+        api.logger.info("memory-supabase: stopped");
+      },
+    });
+  },
+};
+
+export default memoryPlugin;