n8n-nodes-smart-memory 1.0.0

package/dist/storage/RedisStorage.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStorage = void 0;
+class RedisStorage {
+    async getMemory(_chatId) {
+        // TODO: Implement Redis storage
+        console.log('Redis storage not implemented yet');
+        return null;
+    }
+    async saveMemory(_chatId, _memory) {
+        // TODO: Implement Redis storage
+        console.log('Redis storage not implemented yet');
+    }
+    async clearMemory(_chatId) {
+        // TODO: Implement Redis storage
+        console.log('Redis storage not implemented yet');
+    }
+}
+exports.RedisStorage = RedisStorage;
+//# sourceMappingURL=RedisStorage.js.map

package/dist/storage/RedisStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisStorage.js","sourceRoot":"","sources":["../../src/storage/RedisStorage.ts"],"names":[],"mappings":";;;AAGA,MAAa,YAAY;IACvB,KAAK,CAAC,SAAS,CAAC,OAAe;QAC7B,gCAAgC;QAChC,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;QACjD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,OAAe,EAAE,OAA6B;QAC7D,gCAAgC;QAChC,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;IACnD,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAe;QAC/B,gCAAgC;QAChC,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;IACnD,CAAC;CACF;AAhBD,oCAgBC"}

package/dist/utils/ExpressionEvaluator.d.ts

@@ -0,0 +1,4 @@
+export declare class ExpressionEvaluator {
+    static evaluate(_data: any, expression: string): string;
+}
+//# sourceMappingURL=ExpressionEvaluator.d.ts.map

package/dist/utils/ExpressionEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionEvaluator.d.ts","sourceRoot":"","sources":["../../src/utils/ExpressionEvaluator.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAyBxD"}

package/dist/utils/ExpressionEvaluator.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionEvaluator = void 0;
+class ExpressionEvaluator {
+    static evaluate(_data, expression) {
+        // Simple expression evaluator - in real implementation, use n8n's expression system
+        // Examples: "={{ $json.message.from.first_name + ' ' + $json.message.from.last_name }}"
+        //           "={{ $json.message.from.username }}"
+        try {
+            // This would integrate with n8n's expression system
+            if (expression.startsWith('={{ ') && expression.endsWith(' }}')) {
+                // Extract the expression part
+                const expr = expression.slice(3, -2);
+                // Simple evaluation for common cases
+                if (expr.includes('$json.message.from.first_name') && expr.includes('$json.message.from.last_name')) {
+                    const firstName = _data.message?.from?.first_name || '';
+                    const lastName = _data.message?.from?.last_name || '';
+                    return `${firstName} ${lastName}`.trim();
+                }
+                if (expr.includes('$json.message.from.username')) {
+                    return _data.message?.from?.username || '';
+                }
+                return expr;
+            }
+            return expression;
+        }
+        catch {
+            return '';
+        }
+    }
+}
+exports.ExpressionEvaluator = ExpressionEvaluator;
+//# sourceMappingURL=ExpressionEvaluator.js.map

package/dist/utils/ExpressionEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionEvaluator.js","sourceRoot":"","sources":["../../src/utils/ExpressionEvaluator.ts"],"names":[],"mappings":";;;AAAA,MAAa,mBAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,KAAU,EAAE,UAAkB;QAC5C,oFAAoF;QACpF,wFAAwF;QACxF,iDAAiD;QACjD,IAAI,CAAC;YACH,oDAAoD;YACpD,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAChE,8BAA8B;gBAC9B,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACrC,qCAAqC;gBACrC,IAAI,IAAI,CAAC,QAAQ,CAAC,+BAA+B,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,8BAA8B,CAAC,EAAE,CAAC;oBACpG,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,UAAU,IAAI,EAAE,CAAC;oBACxD,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC;oBACtD,OAAO,GAAG,SAAS,IAAI,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;gBAC3C,CAAC;gBACD,IAAI,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,CAAC;oBACjD,OAAO,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC;gBAC7C,CAAC;gBACD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;CACF;AA1BD,kDA0BC"}

package/jest.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.test.ts',
+    '!src/index.ts',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  setupFilesAfterEnv: ['<rootDir>/src/__tests__/setup.ts'],
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "n8n-nodes-smart-memory",
+  "version": "1.0.0",
+  "description": "Smart memory management node for n8n with support for multiple storage backends",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts"
+  },
+  "keywords": [
+    "n8n",
+    "memory",
+    "chatbot",
+    "llm",
+    "telegram"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "dependencies": {
+    "n8n-core": "^1.113.0",
+    "n8n-workflow": "^1.111.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.7",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "^29.7.0",
+    "jest-environment-node": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.5"
+  },
+  "n8n": {
+    "nodes": {
+      "Smart Memory": "./dist/SmartMemory.node.js"
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/SmartMemory.node.ts

@@ -0,0 +1,153 @@
+import {
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+} from 'n8n-workflow';
+import { PureMemoryManager } from './SmartMemory';
+import { MemoryManagerConfig } from './interfaces/MemoryInterfaces';
+
+// Helper function outside the class
+function estimateTokenCount(memory: any): number {
+  // Estimate tokens for the entire memory structure
+  const text = JSON.stringify(memory);
+  return Math.ceil(text.length / 4);
+}
+
+export class SmartMemory implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: 'Smart Memory',
+    name: 'smartMemory',
+    icon: 'fa:memory',
+    group: ['transform'],
+    version: 1.0,
+    description: 'Configuration-driven memory management without prompt manipulation',
+    defaults: {
+      name: 'Smart Memory',
+    },
+    inputs: ['main'],
+    outputs: ['main'],
+    properties: [
+      {
+        displayName: 'Memory Window Size',
+        name: 'memoryWindowSize',
+        type: 'number',
+        typeOptions: {
+          minValue: 5,
+          maxValue: 50,
+        },
+        default: 15,
+        description: 'Number of messages to keep in memory',
+      },
+      
+      {
+        displayName: 'Assistant Role',
+        name: 'assistantRole',
+        type: 'string',
+        default: 'Assistant',
+        description: 'How the assistant should be identified in memory',
+      },
+      
+      {
+        displayName: 'User Display Name Expression',
+        name: 'userDisplayNameExpression',
+        type: 'string',
+        default: '={{ $json.message.from.first_name + " " + $json.message.from.last_name }}',
+        description: 'Expression to combine user name fields',
+      },
+      
+      {
+        displayName: 'User Username Expression',
+        name: 'userUsernameExpression',
+        type: 'string',
+        default: '={{ $json.message.from.username }}',
+        description: 'Expression to get username (leave empty to disable)',
+      },
+      
+      {
+        displayName: 'Include Reply Context',
+        name: 'includeReplyContext',
+        type: 'boolean',
+        default: true,
+        description: 'Include information about replied-to messages',
+      },
+      
+      {
+        displayName: 'Storage Backend',
+        name: 'storageBackend',
+        type: 'options',
+        options: [
+          { name: 'In-Memory', value: 'memory' },
+          { name: 'Google Sheets', value: 'googleSheets' },
+          { name: 'Redis', value: 'redis' },
+        ],
+        default: 'memory',
+      },
+    ],
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const items = this.getInputData();
+    const returnData: INodeExecutionData[] = [];
+    
+    // Build configuration from node parameters
+    const config: MemoryManagerConfig = {
+      memoryWindowSize: this.getNodeParameter('memoryWindowSize', 0) as number,
+      storageBackend: this.getNodeParameter('storageBackend', 0) as 'memory' | 'googleSheets' | 'redis',
+      assistantRole: this.getNodeParameter('assistantRole', 0) as string,
+      userFieldMapping: {
+        displayName: this.getNodeParameter('userDisplayNameExpression', 0) as string,
+        username: this.getNodeParameter('userUsernameExpression', 0) as string,
+      },
+      includeReplyContext: this.getNodeParameter('includeReplyContext', 0) as boolean,
+      enableSemanticMemory: false,
+      enableEpisodicMemory: false,
+    };
+    
+    // Initialize memory manager
+    const memoryManager = new PureMemoryManager(config);
+    
+    for (let i = 0; i < items.length; i++) {
+      try {
+        // Process the message
+        if (!items[i]?.json) {
+          throw new Error('Invalid input data: missing json property');
+        }
+        
+        const jsonData = items[i]!.json as any;
+        if (!jsonData || !jsonData.message || !jsonData.message.chat) {
+          throw new Error('Invalid message format: missing message or chat data');
+        }
+        
+        const chatId = jsonData.message.chat.id;
+        let memory = await memoryManager.processMessage(jsonData);
+        
+        // Apply memory window size
+        memory.messages = memory.messages.slice(-config.memoryWindowSize);
+        
+        // Build output - just the memory data, no prompt manipulation
+        const output = {
+          chatId,
+          chatType: memory.chatInfo.chatType,
+          memory: memory,
+          messageCount: memory.messages.length,
+          tokenEstimate: estimateTokenCount(memory),
+        };
+        
+        returnData.push({
+          json: output,
+        });
+        
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        returnData.push({
+          json: {
+            error: errorMessage,
+          },
+        });
+      }
+    }
+    
+    return [returnData];
+  }
+}

package/src/SmartMemory.ts

@@ -0,0 +1,195 @@
+import { CleanMemoryStructure, MemoryManagerConfig } from './interfaces/MemoryInterfaces';
+import { InMemoryStorage } from './storage/InMemoryStorage';
+// Import placeholder implementations for now
+// import { GoogleSheetsStorage } from './storage/GoogleSheetsStorage';
+// import { RedisStorage } from './storage/RedisStorage';
+
+// Placeholder implementations
+class GoogleSheetsStorage {
+  async getMemory(_chatId: string): Promise<CleanMemoryStructure | null> {
+    throw new Error('Google Sheets storage not implemented yet');
+  }
+  async saveMemory(_chatId: string, _memory: CleanMemoryStructure): Promise<void> {
+    throw new Error('Google Sheets storage not implemented yet');
+  }
+  async clearMemory(_chatId: string): Promise<void> {
+    throw new Error('Google Sheets storage not implemented yet');
+  }
+}
+
+class RedisStorage {
+  async getMemory(_chatId: string): Promise<CleanMemoryStructure | null> {
+    throw new Error('Redis storage not implemented yet');
+  }
+  async saveMemory(_chatId: string, _memory: CleanMemoryStructure): Promise<void> {
+    throw new Error('Redis storage not implemented yet');
+  }
+  async clearMemory(_chatId: string): Promise<void> {
+    throw new Error('Redis storage not implemented yet');
+  }
+}
+
+export class PureMemoryManager {
+  private config: MemoryManagerConfig;
+  private storage: any; // Use proper interface
+  
+  constructor(config: MemoryManagerConfig) {
+    this.config = config;
+    
+    // Initialize storage backend
+    switch (config.storageBackend) {
+      case 'memory':
+        this.storage = new InMemoryStorage();
+        break;
+      case 'googleSheets':
+        this.storage = new GoogleSheetsStorage();
+        break;
+      case 'redis':
+        this.storage = new RedisStorage();
+        break;
+    }
+  }
+  
+  async processMessage(inputData: any): Promise<CleanMemoryStructure> {
+    const chatId = inputData.message?.chat?.id;
+    const existingMemory = await this.getMemory(chatId);
+    
+    if (!existingMemory) {
+      const newMemory = await this.createNewMemory(inputData);
+      // Save the new memory
+      await this.storage.saveMemory(chatId, newMemory);
+      return newMemory;
+    }
+    
+    const updatedMemory = await this.updateExistingMemory(existingMemory, inputData);
+    // Save the updated memory
+    await this.storage.saveMemory(chatId, updatedMemory);
+    return updatedMemory;
+  }
+  
+  private async getMemory(chatId: string): Promise<CleanMemoryStructure | null> {
+    return await this.storage.getMemory(chatId);
+  }
+  
+  private async createNewMemory(inputData: any): Promise<CleanMemoryStructure> {
+    const chat = inputData.message?.chat;
+    const user = inputData.message?.from;
+    const isBotResponse = !!inputData.bot_response;
+    
+    const memory: CleanMemoryStructure = {
+      chatInfo: {
+        chatId: chat.id,
+        chatType: chat.type,
+        chatName: chat.title || chat.username || 'Private Chat',
+      },
+      messages: []
+    };
+    
+    // Only add private user info for private chats
+    if (chat.type === 'private' && !isBotResponse && user) {
+      const displayName = this.evaluateExpression(inputData, this.config.userFieldMapping.displayName);
+      const username = this.config.userFieldMapping.username ? 
+                      this.evaluateExpression(inputData, this.config.userFieldMapping.username) : 
+                      undefined;
+      
+      // Create the object conditionally to avoid exactOptionalPropertyTypes issue
+      const privateUserInfo: any = {
+        userId: user.id,
+        displayName,
+      };
+      
+      if (username !== undefined) {
+        privateUserInfo.username = username;
+      }
+      
+      memory.privateUserInfo = privateUserInfo;
+    }
+    
+    // Add the first message
+    return await this.addMessageToMemory(memory, inputData);
+  }
+  
+  private async updateExistingMemory(
+    memory: CleanMemoryStructure, 
+    inputData: any
+  ): Promise<CleanMemoryStructure> {
+    return await this.addMessageToMemory(memory, inputData);
+  }
+  
+  private async addMessageToMemory(
+    memory: CleanMemoryStructure, 
+    inputData: any
+  ): Promise<CleanMemoryStructure> {
+    const message = inputData.message;
+    const isBotResponse = !!inputData.bot_response;
+    
+    const newMessage = {
+      role: isBotResponse ? this.config.assistantRole : 'user',
+      content: message.text || message.caption || inputData.bot_response || '',
+      timestamp: new Date().toISOString(),
+    } as any;
+    
+    // Add user info for user messages in groups
+    if (!isBotResponse && memory.chatInfo.chatType !== 'private' && message.from) {
+      newMessage.userInfo = {
+        displayName: this.evaluateExpression(inputData, this.config.userFieldMapping.displayName),
+        username: this.config.userFieldMapping.username ? 
+                  this.evaluateExpression(inputData, this.config.userFieldMapping.username) : 
+                  undefined,
+      };
+    }
+    
+    // Add reply information if enabled and present
+    if (this.config.includeReplyContext && message.reply_to_message) {
+      const replyUser = message.reply_to_message.from;
+      if (replyUser) {
+        newMessage.replyInfo = {
+          replyToDisplayName: this.evaluateExpression(
+            { message: { from: replyUser } }, 
+            this.config.userFieldMapping.displayName
+          ),
+          replyToUsername: this.config.userFieldMapping.username ? 
+                            this.evaluateExpression(
+                              { message: { from: replyUser } }, 
+                              this.config.userFieldMapping.username
+                            ) : 
+                            undefined,
+          replyToMessage: message.reply_to_message.text || 
+                        message.reply_to_message.caption || 
+                        '[Media/Other content]',
+        };
+      }
+    }
+    
+    return {
+      ...memory,
+      messages: [...memory.messages, newMessage],
+    };
+  }
+  
+  private evaluateExpression(data: any, expression: string): string {
+    // Simple expression evaluator - in real implementation, use n8n's expression system
+    // Examples: "={{ $json.message.from.first_name + ' ' + $json.message.from.last_name }}"
+    //           "={{ $json.message.from.username }}"
+    try {
+      // This would integrate with n8n's expression system
+      if (expression.startsWith('={{ ') && expression.endsWith(' }}')) {
+        // Extract the expression part
+        const expr = expression.slice(3, -2);
+        // Simple evaluation for common cases
+        if (expr.includes('$json.message.from.first_name') && expr.includes('$json.message.from.last_name')) {
+          const firstName = data.message?.from?.first_name || '';
+          const lastName = data.message?.from?.last_name || '';
+          return `${firstName} ${lastName}`.trim();
+        }
+        if (expr.includes('$json.message.from.username')) {
+          return data.message?.from?.username || '';
+        }
+        return expr;
+      }
+      return expression;
+    } catch {
+      return '';
+    }
+  }
+}

package/src/__tests__/SmartMemory.test.ts

@@ -0,0 +1,157 @@
+import { PureMemoryManager } from '../SmartMemory';
+
+describe('PureMemoryManager', () => {
+  let memoryManager: PureMemoryManager;
+  
+  beforeEach(() => {
+    memoryManager = new PureMemoryManager({
+      memoryWindowSize: 10,
+      storageBackend: 'memory',
+      userFieldMapping: {
+        displayName: '={{ $json.message.from.first_name + " " + $json.message.from.last_name }}',
+        username: '={{ $json.message.from.username }}',
+      },
+      assistantRole: 'Assistant',
+      includeReplyContext: true,
+      enableSemanticMemory: false,
+      enableEpisodicMemory: false,
+    });
+  });
+  
+  describe('processMessage', () => {
+    it('should create new memory for first message', async () => {
+      const inputData = {
+        message: {
+          chat: {
+            id: '123',
+            type: 'private',
+          },
+          from: {
+            id: '456',
+            first_name: 'John',
+            last_name: 'Doe',
+            username: 'johndoe',
+          },
+          text: 'Hello',
+        },
+      };
+      
+      const result = await memoryManager.processMessage(inputData);
+      
+      expect(result.chatInfo.chatId).toBe('123');
+      expect(result.chatInfo.chatType).toBe('private');
+      expect(result.privateUserInfo).toBeDefined();
+      expect(result.privateUserInfo?.displayName).toBe('John Doe');
+      expect(result.messages).toHaveLength(1);
+      if (result.messages[0]) {
+        expect(result.messages[0].content).toBe('Hello');
+      }
+    });
+    
+    it('should update existing memory for subsequent messages', async () => {
+      const inputData = {
+        message: {
+          chat: {
+            id: '123',
+            type: 'private',
+          },
+          from: {
+            id: '456',
+            first_name: 'John',
+            last_name: 'Doe',
+            username: 'johndoe',
+          },
+          text: 'Hello',
+        },
+      };
+      
+      // First message
+      await memoryManager.processMessage(inputData);
+      
+      // Second message
+      const secondInput = {
+        ...inputData,
+        message: {
+          ...inputData.message,
+          text: 'How are you?',
+        },
+      };
+      
+      const result = await memoryManager.processMessage(secondInput);
+      
+      expect(result.messages).toHaveLength(2);
+      if (result.messages[0]) {
+        expect(result.messages[0].content).toBe('Hello');
+      }
+      if (result.messages[1]) {
+        expect(result.messages[1].content).toBe('How are you?');
+      }
+    });
+    
+    it('should handle group messages with user info', async () => {
+      const inputData = {
+        message: {
+          chat: {
+            id: '789',
+            type: 'group',
+            title: 'Test Group',
+          },
+          from: {
+            id: '456',
+            first_name: 'John',
+            last_name: 'Doe',
+            username: 'johndoe',
+          },
+          text: 'Hello group',
+        },
+      };
+      
+      const result = await memoryManager.processMessage(inputData);
+      
+      expect(result.chatInfo.chatType).toBe('group');
+      expect(result.privateUserInfo).toBeUndefined();
+      expect(result.messages).toHaveLength(1);
+      if (result.messages[0]) {
+        expect(result.messages[0].userInfo).toBeDefined();
+        expect(result.messages[0].userInfo?.displayName).toBe('John Doe');
+      }
+    });
+    
+    it('should handle reply context', async () => {
+      const inputData = {
+        message: {
+          chat: {
+            id: '789',
+            type: 'group',
+            title: 'Test Group',
+          },
+          from: {
+            id: '456',
+            first_name: 'John',
+            last_name: 'Doe',
+            username: 'johndoe',
+          },
+          reply_to_message: {
+            from: {
+              id: '789',
+              first_name: 'Jane',
+              last_name: 'Smith',
+              username: 'janesmith',
+            },
+            text: 'Original message',
+          },
+          text: 'Replying to your message',
+        },
+      };
+      
+      const result = await memoryManager.processMessage(inputData);
+      
+      expect(result.messages).toHaveLength(1);
+      if (result.messages[0]) {
+        expect(result.messages[0].replyInfo).toBeDefined();
+        expect(result.messages[0].replyInfo?.replyToDisplayName).toBe('Jane Smith');
+        expect(result.messages[0].replyInfo?.replyToMessage).toBe('Original message');
+      }
+    });
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,18 @@
+// Global test setup
+import { jest } from '@jest/globals';
+
+// Mock n8n-core and n8n-workflow
+jest.mock('n8n-core', () => ({
+  // Add mock implementations as needed
+}));
+
+jest.mock('n8n-workflow', () => ({
+  // Add mock implementations as needed
+  IExecuteFunctions: class {},
+  INodeExecutionData: class {},
+  INodeType: class {},
+  INodeTypeDescription: class {},
+}));
+
+// Set test timeout
+jest.setTimeout(30000);