supaclaw 1.0.0

package/dist/clawdbot-integration.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * Clawdbot Integration for OpenClaw Memory
+ *
+ * This module provides integration hooks for Clawdbot to:
+ * 1. Auto-log all messages to sessions
+ * 2. Replace memory_search with semantic recall
+ * 3. Replace memory_get with database queries
+ * 4. Inject relevant context into system prompts
+ * 5. Handle session lifecycle
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClawdbotMemoryIntegration = void 0;
+exports.createClawdbotIntegration = createClawdbotIntegration;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+const index_1 = require("./index");
+class ClawdbotMemoryIntegration {
+    memory;
+    config;
+    activeSessions;
+    sessionTimeoutMs;
+    constructor(config) {
+        this.config = config;
+        this.memory = new index_1.OpenClawMemory({
+            supabaseUrl: config.supabaseUrl,
+            supabaseKey: config.supabaseKey,
+            agentId: config.agentId,
+            embeddingProvider: config.embeddingProvider || 'openai',
+            openaiApiKey: config.openaiApiKey
+        });
+        this.activeSessions = new Map();
+        this.sessionTimeoutMs = config.sessionTimeout || 30 * 60 * 1000; // 30 minutes default
+    }
+    /**
+     * Initialize the memory system
+     */
+    async initialize() {
+        await this.memory.initialize();
+    }
+    /**
+     * Get or create a session for a chat/user
+     */
+    async getOrCreateSession(chatId, context = {}) {
+        // Check if active session exists
+        const existing = this.activeSessions.get(chatId);
+        const now = Date.now();
+        if (existing && (now - existing.lastActivity) < this.sessionTimeoutMs) {
+            // Update last activity
+            existing.lastActivity = now;
+            return existing.sessionId;
+        }
+        // End old session if it exists
+        if (existing) {
+            await this.endSession(chatId);
+        }
+        // Create new session
+        const session = await this.memory.startSession({
+            userId: context.userId || this.config.userId,
+            channel: context.channel,
+            metadata: {
+                chatId,
+                startedBy: 'clawdbot-integration'
+            }
+        });
+        this.activeSessions.set(chatId, {
+            sessionId: session.id,
+            lastActivity: now
+        });
+        return session.id;
+    }
+    /**
+     * Log a user message
+     */
+    async logUserMessage(chatId, content, context = {}) {
+        if (!this.config.autoLog)
+            return;
+        const sessionId = await this.getOrCreateSession(chatId, context);
+        await this.memory.addMessage(sessionId, {
+            role: 'user',
+            content,
+            metadata: {
+                messageId: context.messageId,
+                timestamp: context.timestamp || new Date().toISOString(),
+                channel: context.channel
+            }
+        });
+    }
+    /**
+     * Log an assistant message
+     */
+    async logAssistantMessage(chatId, content, context = {}) {
+        if (!this.config.autoLog)
+            return;
+        const sessionId = await this.getOrCreateSession(chatId, context);
+        await this.memory.addMessage(sessionId, {
+            role: 'assistant',
+            content,
+            metadata: {
+                messageId: context.messageId,
+                timestamp: context.timestamp || new Date().toISOString(),
+                model: context.model,
+                channel: context.channel
+            }
+        });
+    }
+    /**
+     * Log a system message
+     */
+    async logSystemMessage(chatId, content, context = {}) {
+        if (!this.config.autoLog)
+            return;
+        const sessionId = await this.getOrCreateSession(chatId, context);
+        await this.memory.addMessage(sessionId, {
+            role: 'system',
+            content,
+            metadata: {
+                timestamp: context.timestamp || new Date().toISOString()
+            }
+        });
+    }
+    /**
+     * Replace memory_search - semantic search for memories
+     */
+    async memorySearch(query, opts = {}) {
+        const results = await this.memory.recall(query, {
+            userId: opts.userId || this.config.userId,
+            category: opts.category,
+            limit: opts.limit || 5,
+            minImportance: opts.minImportance || 0.5
+        });
+        return results.map(r => ({
+            content: r.content,
+            category: r.category,
+            importance: r.importance,
+            created_at: r.created_at
+        }));
+    }
+    /**
+     * Replace memory_get - get memories by category
+     */
+    async memoryGet(opts = {}) {
+        const results = await this.memory.getMemories({
+            userId: opts.userId || this.config.userId,
+            category: opts.category,
+            limit: opts.limit || 10
+        });
+        return results.map(r => ({
+            content: r.content,
+            category: r.category,
+            importance: r.importance
+        }));
+    }
+    /**
+     * Build context for system prompt injection
+     */
+    async buildContext(query, opts = {}) {
+        const parts = [];
+        // Include relevant memories
+        if (opts.includeMemories !== false) {
+            const memories = await this.memorySearch(query, {
+                limit: opts.maxMemories || 5
+            });
+            if (memories.length > 0) {
+                parts.push('## Relevant Context\n');
+                memories.forEach(m => {
+                    parts.push(`- [${m.category || 'general'}] ${m.content}`);
+                });
+                parts.push('');
+            }
+        }
+        // Include relevant learnings
+        if (opts.includeLearnings !== false) {
+            const learnings = await this.memory.getLearningRecommendations(query, opts.maxLearnings || 3);
+            if (learnings.length > 0) {
+                parts.push('## Past Learnings\n');
+                learnings.forEach(l => {
+                    parts.push(`- [${l.category}] ${l.lesson}`);
+                    if (l.action) {
+                        parts.push(`  Action: ${l.action}`);
+                    }
+                });
+                parts.push('');
+            }
+        }
+        // Include recent messages from session
+        if (opts.includeRecentMessages && opts.chatId) {
+            const session = this.activeSessions.get(opts.chatId);
+            if (session) {
+                const messages = await this.memory.getMessages(session.sessionId, {
+                    limit: opts.maxMessages || 10
+                });
+                if (messages.length > 0) {
+                    parts.push('## Recent Conversation\n');
+                    messages.slice(-5).forEach(m => {
+                        const preview = m.content.length > 100
+                            ? m.content.substring(0, 100) + '...'
+                            : m.content;
+                        parts.push(`- ${m.role}: ${preview}`);
+                    });
+                    parts.push('');
+                }
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Store a memory
+     */
+    async remember(content, opts = {}) {
+        let sessionId;
+        if (opts.chatId) {
+            const session = this.activeSessions.get(opts.chatId);
+            sessionId = session?.sessionId;
+        }
+        return await this.memory.remember({
+            content,
+            category: opts.category,
+            importance: opts.importance || 0.5,
+            userId: opts.userId || this.config.userId,
+            sessionId,
+            expiresAt: opts.expiresAt
+        });
+    }
+    /**
+     * Record a learning
+     */
+    async learn(learning) {
+        let sessionId;
+        if (learning.chatId) {
+            const session = this.activeSessions.get(learning.chatId);
+            sessionId = session?.sessionId;
+        }
+        return await this.memory.learn({
+            category: learning.category,
+            trigger: learning.trigger,
+            lesson: learning.lesson,
+            action: learning.action,
+            severity: learning.severity || 'info',
+            sessionId
+        });
+    }
+    /**
+     * Create a task
+     */
+    async createTask(task) {
+        return await this.memory.createTask({
+            ...task,
+            userId: task.userId || this.config.userId
+        });
+    }
+    /**
+     * Get upcoming tasks for reminders
+     */
+    async getUpcomingTasks(hoursAhead = 24) {
+        return await this.memory.getTasksNeedingReminders({
+            userId: this.config.userId,
+            hoursAhead
+        });
+    }
+    /**
+     * End a session
+     */
+    async endSession(chatId, opts = {}) {
+        const session = this.activeSessions.get(chatId);
+        if (!session)
+            return;
+        // End session with optional summary
+        await this.memory.endSession(session.sessionId, {
+            summary: opts.summary,
+            autoSummarize: opts.autoSummarize !== false // Default true
+        });
+        // Extract memories if requested
+        if (opts.extractMemories) {
+            await this.memory.extractMemoriesFromSession(session.sessionId, {
+                autoExtract: true,
+                minImportance: 0.6
+            });
+        }
+        this.activeSessions.delete(chatId);
+    }
+    /**
+     * End all inactive sessions
+     */
+    async cleanupInactiveSessions() {
+        const now = Date.now();
+        const toEnd = [];
+        this.activeSessions.forEach((session, chatId) => {
+            if (now - session.lastActivity >= this.sessionTimeoutMs) {
+                toEnd.push(chatId);
+            }
+        });
+        for (const chatId of toEnd) {
+            await this.endSession(chatId, { autoSummarize: true });
+        }
+    }
+    /**
+     * Heartbeat check - call this periodically (e.g., every 30 min)
+     */
+    async heartbeat() {
+        // Clean up inactive sessions
+        await this.cleanupInactiveSessions();
+        // Get upcoming tasks
+        const upcomingTasks = await this.getUpcomingTasks(2); // Next 2 hours
+        return {
+            upcomingTasks,
+            inactiveSessions: this.activeSessions.size
+        };
+    }
+    /**
+     * Get the underlying OpenClawMemory instance for advanced operations
+     */
+    getMemory() {
+        return this.memory;
+    }
+}
+exports.ClawdbotMemoryIntegration = ClawdbotMemoryIntegration;
+/**
+ * Factory function to create integration instance
+ */
+function createClawdbotIntegration(config) {
+    return new ClawdbotMemoryIntegration(config);
+}
+/**
+ * Express/Koa-style middleware for auto-logging
+ */
+function createLoggingMiddleware(integration) {
+    return async (message) => {
+        const { chatId, role, content, context = {} } = message;
+        if (role === 'user') {
+            await integration.logUserMessage(chatId, content, context);
+        }
+        else if (role === 'assistant') {
+            await integration.logAssistantMessage(chatId, content, context);
+        }
+        else if (role === 'system') {
+            await integration.logSystemMessage(chatId, content, context);
+        }
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};