node-red-contrib-ai-agent 0.0.4 → 0.0.6

package/README.md

@@ -36,6 +36,18 @@ Your feedback and contributions are highly appreciated!
 5. Connect to an AI Agent node to process messages
 6. (Optional) Connect more AI Agent nodes to process messages in a chain
 
+## Example: Today's Joke
+
+Here's an example flow that tells a joke related to today's date using a custom tool:
+
+![Today's Joke Flow](https://raw.githubusercontent.com/lesichkovm/node-red-contrib-ai-agent/refs/heads/main/snapshots/todays-joke-flow.png "Example flow showing the Today's Joke implementation")
+
+### Flow Output
+
+When executed, the flow will generate a joke related to the current date:
+
+![Today's Joke Output](https://raw.githubusercontent.com/lesichkovm/node-red-contrib-ai-agent/refs/heads/main/snapshots/todays-joke.png "Example output showing a date-related joke")
+
 ##
 
 ## Node Types
@@ -59,8 +71,11 @@ A configuration node that initializes the conversation context in memory. The ag
 A configuration node that initializes the conversation context with file-based persistence. The agent node uses this configuration to manage the conversation context across restarts.
 
 **Properties:**
-- **Max Items**: Maximum number of conversation turns to keep
-- **File Path**: Path to store the conversation history
+- **Filename**: Path to store the memory file (relative to Node-RED user directory)
+- **Max Conversations**: Maximum number of conversations to store
+- **Max Messages Per Conversation**: Maximum messages per conversation history
+- **Backups**: Enable/disable automatic backups
+- **Backup Count**: Number of backups to keep
 - **Name**: Display name for the node
 
 ### AI Model
@@ -128,6 +143,8 @@ The AI Agent will automatically detect and use the tools in its processing. You
 
 In this example, the AI Agent has access to both an HTTP tool for making external API calls and a function tool for custom logic.
 
+
+
 ## Example: Chained Agents
 
 For more complex scenarios, you can chain multiple agents to process messages in sequence:

package/memory-file/memory-file.html

@@ -11,7 +11,11 @@
                 validate: function(v) {
                     return v.length > 0;
                 }
-            }
+            },
+            maxConversations: { value: 50, validate: RED.validators.number() },
+            maxMessagesPerConversation: { value: 100, validate: RED.validators.number() },
+            backupEnabled: { value: true },
+            backupCount: { value: 3, validate: RED.validators.number() }
         },
         inputs: 1,
         outputs: 1,
@@ -43,6 +47,23 @@
         <label for="node-input-filename"><i class="fa fa-file"></i> Filename</label>
         <input type="text" id="node-input-filename" placeholder="ai-memories.json">
     </div>
+    <div class="form-row">
+        <label for="node-input-maxConversations"><i class="fa fa-list"></i> Max Conversations</label>
+        <input type="number" id="node-input-maxConversations" placeholder="50">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxMessagesPerConversation"><i class="fa fa-commenting"></i> Max Messages/Conv</label>
+        <input type="number" id="node-input-maxMessagesPerConversation" placeholder="100">
+    </div>
+    <div class="form-row">
+        <label for="node-input-backupEnabled"><i class="fa fa-shield"></i> Backups</label>
+        <input type="checkbox" id="node-input-backupEnabled" style="display:inline-block; width:auto; vertical-align:top;">
+        <label for="node-input-backupEnabled" style="width: auto;">Enable automatic backups</label>
+    </div>
+    <div class="form-row" id="backupCount-row">
+        <label for="node-input-backupCount"><i class="fa fa-history"></i> Backup Count</label>
+        <input type="number" id="node-input-backupCount" placeholder="3">
+    </div>
     <div class="form-tips">
         <p>Memories will be stored in Node-RED's user directory.</p>
     </div>

package/memory-file/memory-file.js

@@ -1,55 +1,419 @@
-module.exports = function(RED) {
+const fs = require('fs');
+const path = require('path');
+
+class SimpleFileStorage {
+    constructor(options = {}) {
+        this.filePath = options.filePath;
+        this.backupEnabled = options.backupEnabled !== false;
+        this.backupCount = options.backupCount || 3;
+    }
+
+    async save(data) {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            data.metadata = data.metadata || {};
+            data.metadata.lastUpdated = new Date().toISOString();
+
+            await fs.promises.writeFile(
+                this.filePath,
+                JSON.stringify(data, null, 2)
+            );
+
+            if (this.backupEnabled) {
+                await this.createBackup();
+            }
+
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    loadSync() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const data = fs.readFileSync(this.filePath, 'utf8');
+                return JSON.parse(data);
+            }
+            return null;
+        } catch (error) {
+            // Backup recovery is still async, but for initial load sync is safer
+            return null;
+        }
+    }
+
+    async load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const data = await fs.promises.readFile(this.filePath, 'utf8');
+                return JSON.parse(data);
+            }
+            return null;
+        } catch (error) {
+            return await this.recoverFromBackup();
+        }
+    }
+
+    async createBackup() {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = `${this.filePath}.${timestamp}.bak`;
+
+            await fs.promises.copyFile(this.filePath, backupPath);
+
+            const backups = await this.listBackups();
+            if (backups.length > this.backupCount) {
+                const oldestBackups = backups
+                    .sort((a, b) => a.time - b.time)
+                    .slice(0, backups.length - this.backupCount);
+
+                for (const backup of oldestBackups) {
+                    await fs.promises.unlink(backup.path);
+                }
+            }
+
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async listBackups() {
+        try {
+            const dir = path.dirname(this.filePath);
+            const base = path.basename(this.filePath);
+
+            const files = await fs.promises.readdir(dir);
+
+            return files
+                .filter(file => file.startsWith(`${base}.`) && file.endsWith('.bak'))
+                .map(file => {
+                    const match = file.match(/\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)\.bak$/);
+                    const timestamp = match ? match[1].replace(/-/g, ':').replace(/-(\d{3})Z$/, '.$1Z') : null;
+
+                    return {
+                        path: path.join(dir, file),
+                        time: timestamp ? new Date(timestamp).getTime() : 0
+                    };
+                });
+        } catch (error) {
+            return [];
+        }
+    }
+
+    async recoverFromBackup() {
+        try {
+            const backups = await this.listBackups();
+
+            if (backups.length === 0) {
+                return null;
+            }
+
+            const latestBackup = backups.sort((a, b) => b.time - a.time)[0];
+            const data = await fs.promises.readFile(latestBackup.path, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            return null;
+        }
+    }
+}
+
+class SimpleMemoryManager {
+    constructor(options = {}) {
+        this.maxConversations = options.maxConversations || 50;
+        this.maxMessagesPerConversation = options.maxMessagesPerConversation || 100;
+        this.conversations = [];
+    }
+
+    addMessage(conversationId, message) {
+        let conversation = this.conversations.find(c => c.id === conversationId);
+
+        if (!conversation) {
+            conversation = {
+                id: conversationId,
+                messages: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+
+            this.conversations.push(conversation);
+
+            if (this.conversations.length > this.maxConversations) {
+                this.conversations = this.conversations
+                    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt))
+                    .slice(0, this.maxConversations);
+            }
+        }
+
+        conversation.messages.push({
+            ...message,
+            timestamp: new Date().toISOString()
+        });
+
+        conversation.updatedAt = new Date().toISOString();
+
+        if (conversation.messages.length > this.maxMessagesPerConversation) {
+            conversation.messages = conversation.messages.slice(-this.maxMessagesPerConversation);
+        }
+
+        return conversation;
+    }
+
+    getConversation(conversationId) {
+        return this.conversations.find(c => c.id === conversationId) || null;
+    }
+
+    getConversationMessages(conversationId, limit = null) {
+        const conversation = this.getConversation(conversationId);
+
+        if (!conversation) {
+            return [];
+        }
+
+        const messages = conversation.messages;
+
+        if (limit && messages.length > limit) {
+            return messages.slice(-limit);
+        }
+
+        return messages;
+    }
+
+    searchConversations(query, options = {}) {
+        const results = [];
+
+        for (const conversation of this.conversations) {
+            const matchingMessages = conversation.messages.filter(message =>
+                message.content && message.content.toLowerCase().includes(query.toLowerCase())
+            );
+
+            if (matchingMessages.length > 0) {
+                results.push({
+                    conversation,
+                    matchingMessages: options.includeMessages ? matchingMessages : matchingMessages.length
+                });
+            }
+        }
+
+        return results.sort((a, b) =>
+            new Date(b.conversation.updatedAt) - new Date(a.conversation.updatedAt)
+        );
+    }
+
+    deleteConversation(conversationId) {
+        const index = this.conversations.findIndex(c => c.id === conversationId);
+
+        if (index !== -1) {
+            this.conversations.splice(index, 1);
+            return true;
+        }
+
+        return false;
+    }
+
+    clearAllConversations() {
+        this.conversations = [];
+        return true;
+    }
+
+    toJSON() {
+        return {
+            conversations: this.conversations,
+            metadata: {
+                version: '1.0',
+                lastUpdated: new Date().toISOString(),
+                stats: {
+                    conversationCount: this.conversations.length,
+                    messageCount: this.conversations.reduce((count, conv) => count + conv.messages.length, 0)
+                }
+            }
+        };
+    }
+
+    fromJSON(data) {
+        if (data && data.conversations) {
+            this.conversations = data.conversations;
+        } else {
+            this.conversations = [];
+        }
+    }
+}
+
+module.exports = function (RED) {
     'use strict';
 
     function MemoryFileNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        
+
         // Configuration
         node.name = config.name || 'AI Memory (File)';
         node.filename = config.filename || 'ai-memories.json';
-        
-        // Initialize empty memories array
-        node.memories = [];
-        
-        // Load existing memories from file if they exist
-        const fs = require('fs');
-        const path = require('path');
-        const filePath = path.join(RED.settings.userDir, node.filename);
-        
+        node.maxConversations = parseInt(config.maxConversations) || 50;
+        node.maxMessagesPerConversation = parseInt(config.maxMessagesPerConversation) || 100;
+        node.backupEnabled = config.backupEnabled !== false;
+        node.backupCount = parseInt(config.backupCount) || 3;
+
+        const userDir = (RED.settings && RED.settings.userDir) || process.cwd();
+        const filePath = path.join(userDir, node.filename);
+
+        // Create storage and memory manager
+        node.fileStorage = new SimpleFileStorage({
+            filePath,
+            backupEnabled: node.backupEnabled,
+            backupCount: node.backupCount
+        });
+
+        node.memoryManager = new SimpleMemoryManager({
+            maxConversations: node.maxConversations,
+            maxMessagesPerConversation: node.maxMessagesPerConversation
+        });
+
+        // Load existing memories synchronously at startup
         try {
-            if (fs.existsSync(filePath)) {
-                const data = fs.readFileSync(filePath, 'utf8');
-                node.memories = JSON.parse(data);
-                node.status({fill:"green",shape:"dot",text:"Ready"});
+            const data = node.fileStorage.loadSync();
+            if (data) {
+                node.memoryManager.fromJSON(data);
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: `${node.memoryManager.conversations.length} conversations`
+                });
             } else {
-                node.status({fill:"blue",shape:"ring",text:"New file will be created"});
+                node.status({ fill: "blue", shape: "ring", text: "New memory file will be created" });
             }
         } catch (err) {
             node.error("Error loading memory file: " + err.message);
-            node.status({fill:"red",shape:"ring",text:"Error loading"});
+            node.status({ fill: "red", shape: "ring", text: "Error loading" });
         }
 
         // Handle incoming messages
-        node.on('input', function(msg) {
+        node.on('input', async function (msg, send, done) {
+            // Use send and done for Node-RED 1.0+ compatibility
+            send = send || function () { node.send.apply(node, arguments) };
+
             try {
-                // For now, just pass through the message
-                // We'll add memory operations in the next iteration
-                node.send(msg);
-                
-                // Update status
-                node.status({fill:"green",shape:"dot",text:node.memories.length + " memories"});
+                msg.aimemory = msg.aimemory || {};
+
+                if (msg.command) {
+                    await processCommand(node, msg);
+                } else {
+                    const conversationId = msg.conversationId || 'default';
+                    const messages = node.memoryManager.getConversationMessages(conversationId);
+
+                    msg.aimemory = {
+                        type: 'file',
+                        conversationId,
+                        context: messages
+                    };
+                }
+
+                send(msg);
+
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: `${node.memoryManager.conversations.length} conversations`
+                });
+
+                if (done) done();
             } catch (err) {
                 node.error("Error in memory node: " + err.message, msg);
-                node.status({fill:"red",shape:"ring",text:"Error"});
+                node.status({ fill: "red", shape: "ring", text: "Error" });
+                if (done) done(err);
             }
         });
 
-        // Cleanup on node removal
-        node.on('close', function() {
-            // Save memories to file
+        async function processCommand(node, msg) {
+            const command = msg.command;
+
+            switch (command) {
+                case 'add':
+                    if (!msg.message) {
+                        throw new Error('No message content provided');
+                    }
+
+                    const conversationId = msg.conversationId || 'default';
+                    const conversation = node.memoryManager.addMessage(conversationId, msg.message);
+
+                    msg.result = {
+                        success: true,
+                        operation: 'add',
+                        conversationId,
+                        messageCount: conversation.messages.length
+                    };
+
+                    await node.fileStorage.save(node.memoryManager.toJSON());
+                    break;
+
+                case 'get':
+                    const getConversationId = msg.conversationId || 'default';
+                    const limit = msg.limit || null;
+
+                    msg.result = {
+                        success: true,
+                        operation: 'get',
+                        conversationId: getConversationId,
+                        messages: node.memoryManager.getConversationMessages(getConversationId, limit)
+                    };
+                    break;
+
+                case 'search':
+                    if (!msg.query) {
+                        throw new Error('No search query provided');
+                    }
+
+                    msg.result = {
+                        success: true,
+                        operation: 'search',
+                        query: msg.query,
+                        results: node.memoryManager.searchConversations(msg.query, {
+                            includeMessages: msg.includeMessages !== false
+                        })
+                    };
+                    break;
+
+                case 'delete':
+                    if (!msg.conversationId) {
+                        throw new Error('No conversation ID provided');
+                    }
+
+                    const deleted = node.memoryManager.deleteConversation(msg.conversationId);
+
+                    msg.result = {
+                        success: deleted,
+                        operation: 'delete',
+                        conversationId: msg.conversationId
+                    };
+
+                    if (deleted) {
+                        await node.fileStorage.save(node.memoryManager.toJSON());
+                    }
+                    break;
+
+                case 'clear':
+                    node.memoryManager.clearAllConversations();
+
+                    msg.result = {
+                        success: true,
+                        operation: 'clear'
+                    };
+
+                    await node.fileStorage.save(node.memoryManager.toJSON());
+                    break;
+
+                default:
+                    throw new Error(`Unknown command: ${command}`);
+            }
+        }
+
+        node.on('close', async function () {
             try {
-                fs.writeFileSync(filePath, JSON.stringify(node.memories, null, 2));
+                await node.fileStorage.save(node.memoryManager.toJSON());
             } catch (err) {
                 node.error("Error saving memory file: " + err.message);
             }
@@ -57,6 +421,5 @@ module.exports = function(RED) {
         });
     }
 
-    // Register the node type
     RED.nodes.registerType("ai-memory-file", MemoryFileNode);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -63,4 +63,4 @@
             "ai-memory-inmem": "./memory-inmem/memory-inmem.js"
         }
     }
-}
+}