@wabot-dev/framework 0.0.6 → 0.0.7

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -1,15 +1,17 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../injection/index.js';
 import { OpenAI } from 'openai';
-import '../../chatbot/chat/repository/ram/RamChatRepository.js';
-import '../../chatbot/chat/repository/IChatRepository.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 import 'uuid';
 import '../../chatbot/metadata/ChatBotMetadataStore.js';
 import '../../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import { MindsetOperator } from '../../mindset/MindsetOperator.js';
+import '../../core/chat/repository/ram/RamChatRepository.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/repository/ram/RamUserRepository.js';
+import '../../core/user/repository/IUserRepository.js';
 
 let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
     openai = new OpenAI();
@@ -48,7 +50,7 @@ let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
     mapChatItems(chatItems) {
         const openIaInput = [];
         for (const item of chatItems) {
-            if (item.type === 'USER_MESSAGE') {
+            if (item.type === 'CONNECTION_MESSAGE') {
                 if (!item.content.text) {
                     throw new Error('System message content is empty');
                 }
@@ -63,13 +65,13 @@ let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
             if (item.type === 'FUNCTION_CALL') {
                 openIaInput.push({
                     type: 'function_call',
-                    call_id: item.content.foreignId,
+                    call_id: item.content.id,
                     name: item.content.name,
                     arguments: JSON.stringify(item.content.arguments),
                 });
                 openIaInput.push({
                     type: 'function_call_output',
-                    call_id: item.content.foreignId,
+                    call_id: item.content.id,
                     output: item.content.result,
                 });
             }

package/dist/src/channels/cmd/@cmd.js

@@ -1,4 +1,5 @@
 import '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
 import { container } from '../../injection/index.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
 import { CmdChannel } from './CmdChannel.js';

package/dist/src/channels/cmd/CmdChannel.js

@@ -1,19 +1,29 @@
 import { __decorate, __metadata } from 'tslib';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
+import { v4 } from 'uuid';
+import '../../core/chat/repository/ram/RamChatRepository.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/repository/ram/RamUserRepository.js';
+import '../../core/user/repository/IUserRepository.js';
 import * as readline from 'readline';
 
 var CmdChannel_1;
+const chatId = v4();
+const userId = v4();
 let CmdChannel = CmdChannel_1 = class CmdChannel {
     chatResolver;
+    userResolver;
     rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
     callBack = null;
-    constructor(chatResolver) {
+    constructor(chatResolver, userResolver) {
         this.chatResolver = chatResolver;
+        this.userResolver = userResolver;
     }
     listen(callback) {
         this.callBack = callback;
@@ -21,29 +31,38 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
     connect() {
         this.rl.on('line', async (input) => {
             const trimmedInput = input.trim();
+            if (!trimmedInput) {
+                this.rl.prompt();
+                return;
+            }
             if (trimmedInput.toLowerCase() === 'exit') {
                 this.rl.close();
                 return;
             }
-            const origin = {
-                chatId: 'cmd',
+            const chatConnection = {
+                id: chatId,
                 chatType: 'PRIVATE',
-                channelType: CmdChannel_1,
+                channelName: CmdChannel_1.name,
+            };
+            const chat = await this.chatResolver.resolve(chatConnection);
+            const userConnection = {
+                id: userId,
+                channelName: CmdChannel_1.name,
             };
-            const chat = await this.chatResolver.resolve(origin);
+            const user = await this.userResolver.resolve(userConnection);
             if (!this.callBack)
                 return;
             this.callBack({
-                chatId: chat.getId(),
-                origin,
+                chat,
+                user,
                 message: {
+                    chatConnection,
+                    userConnection,
                     text: trimmedInput,
-                    sender: {
-                        shortName: 'Cmd',
-                    },
+                    senderName: 'cmd',
                 },
                 reply: (message) => {
-                    console.log(`\n[${message.sender.shortName}]: ${message.text}\n`);
+                    console.log(`\n[${message.senderName}]: ${message.text}\n`);
                     this.rl.prompt();
                 },
             });
@@ -52,7 +71,8 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
 };
 CmdChannel = CmdChannel_1 = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [ChatResolver])
+    __metadata("design:paramtypes", [ChatResolver,
+        UserResolver])
 ], CmdChannel);
 
 export { CmdChannel };

package/dist/src/channels/telegram/@telegram.js

@@ -1,5 +1,6 @@
 import { container } from '../../injection/index.js';
 import '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';

package/dist/src/channels/telegram/TelegramChannel.js

@@ -1,17 +1,25 @@
 import { __decorate, __metadata } from 'tslib';
-import { Bot } from 'grammy';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import { TelegramChannelConfig } from './TelegramChannelConfig.js';
+import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { Bot } from 'grammy';
+import '../../core/chat/repository/ram/RamChatRepository.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/repository/ram/RamUserRepository.js';
+import '../../core/user/repository/IUserRepository.js';
+import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 
 var TelegramChannel_1;
 let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
     config;
     chatResolver;
+    userResolver;
     bot;
-    constructor(config, chatResolver) {
+    constructor(config, chatResolver, userResolver) {
         this.config = config;
         this.chatResolver = chatResolver;
+        this.userResolver = userResolver;
         this.bot = new Bot(this.config.botToken);
     }
     listen(callback) {
@@ -19,21 +27,25 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
             if (!ctx.message) {
                 return;
             }
-            const origin = {
-                chatId: ctx.message.chat.id.toString(),
+            const chatConnection = {
+                id: ctx.message.chat.id.toString(),
                 chatType: ctx.message.chat.type === 'private' ? 'PRIVATE' : 'GROUP',
-                channelType: TelegramChannel_1,
+                channelName: TelegramChannel_1.name,
+            };
+            const chat = await this.chatResolver.resolve(chatConnection);
+            const userConnection = {
+                id: ctx.from.id.toString(),
+                channelName: TelegramChannel_1.name,
             };
-            const chat = await this.chatResolver.resolve(origin);
+            const user = await this.userResolver.resolve(userConnection);
             callback({
-                chatId: chat.getId(),
-                origin,
+                chat,
+                user,
                 message: {
+                    chatConnection,
+                    userConnection,
+                    senderName: ctx.from.first_name,
                     text: ctx.message.text,
-                    sender: {
-                        shortName: ctx.from.first_name,
-                        senderId: ctx.from.id != null ? ctx.from.id.toString() : undefined,
-                    },
                 },
                 reply: (replyMessage) => {
                     replyMessage.text && ctx.reply(replyMessage.text);
@@ -48,7 +60,8 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
 TelegramChannel = TelegramChannel_1 = __decorate([
     injectable(),
     __metadata("design:paramtypes", [TelegramChannelConfig,
-        ChatResolver])
+        ChatResolver,
+        UserResolver])
 ], TelegramChannel);
 
 export { TelegramChannel };

package/dist/src/chatbot/ChatBot.js

@@ -1,10 +1,12 @@
 import { __decorate, __metadata } from 'tslib';
+import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
+import '../core/chat/repository/ram/RamChatRepository.js';
+import '../core/chat/repository/IChatRepository.js';
+import '../core/user/repository/ram/RamUserRepository.js';
+import '../core/user/repository/IUserRepository.js';
+import { injectable } from '../injection/index.js';
 import { v4 } from 'uuid';
 import { ChatBotAdapter } from './ChatBotAdapter.js';
-import './chat/repository/ram/RamChatRepository.js';
-import { ChatMemory } from './chat/repository/IChatMemory.js';
-import './chat/repository/IChatRepository.js';
-import { injectable } from '../injection/index.js';
 
 let ChatBot = class ChatBot {
     memory;
@@ -18,7 +20,7 @@ let ChatBot = class ChatBot {
         const newChatItem = {
             id: v4(),
             createdAt: new Date(),
-            type: 'USER_MESSAGE',
+            type: 'CONNECTION_MESSAGE',
             content: message,
         };
         await this.memory.saveItem(newChatItem);

package/dist/src/chatbot/ChatBotAdapter.js

@@ -1,4 +1,12 @@
+import 'reflect-metadata';
+import '../injection/index.js';
+import '../mindset/metadata/MindsetMetadataStore.js';
+import '../mindset/MindsetOperator.js';
 import { v4 } from 'uuid';
+import '../core/chat/repository/ram/RamChatRepository.js';
+import '../core/chat/repository/IChatRepository.js';
+import '../core/user/repository/ram/RamUserRepository.js';
+import '../core/user/repository/IUserRepository.js';
 
 class ChatBotAdapter {
     mindset;
@@ -42,26 +50,26 @@ class ChatBotAdapter {
         return systemPrompt;
     }
     async buildBotMessageItem(text) {
-        const shortName = (await this.mindset.identity()).name;
+        const senderName = (await this.mindset.identity()).name;
         const newBotMessage = {
             id: v4(),
             createdAt: new Date(),
             type: 'BOT_MESSAGE',
             content: {
-                sender: { shortName },
+                senderName,
                 text,
             },
         };
         return newBotMessage;
     }
-    async buildFunctionCallItem(foreignId, functionName, functionArguments) {
+    async buildFunctionCallItem(id, functionName, functionArguments) {
         const functionResult = await this.mindset.callFunction(functionName, functionArguments);
         const newFunctionCall = {
             id: v4(),
             createdAt: new Date(),
             type: 'FUNCTION_CALL',
             content: {
-                foreignId,
+                id,
                 name: functionName,
                 arguments: functionArguments,
                 result: functionResult,

package/dist/src/chatbot/metadata/@chatBot.js

@@ -1,4 +1,7 @@
+import 'reflect-metadata';
 import { container, inject } from '../../injection/index.js';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import '../../mindset/MindsetOperator.js';
 import { v4 } from 'uuid';
 import { ChatBotMetadataStore } from './ChatBotMetadataStore.js';
 

package/dist/src/chatbot/metadata/ChatBotMetadataStore.js

@@ -1,5 +1,8 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../injection/index.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import '../../mindset/MindsetOperator.js';
 
 let ChatBotMetadataStore = class ChatBotMetadataStore {
     chatBots = [];

package/dist/src/controller/channel/ChatResolver.js

@@ -1,22 +1,21 @@
 import { __decorate, __metadata } from 'tslib';
-import '../../chatbot/chat/repository/ram/RamChatRepository.js';
-import { ChatRepository } from '../../chatbot/chat/repository/IChatRepository.js';
-import { Chat } from '../../chatbot/chat/Chat.js';
+import '../../core/chat/repository/ram/RamChatRepository.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import { Chat } from '../../core/chat/Chat.js';
+import '../../core/user/repository/ram/RamUserRepository.js';
+import '../../core/user/repository/IUserRepository.js';
 import { injectable } from '../../injection/index.js';
-import 'uuid';
-import '../../chatbot/metadata/ChatBotMetadataStore.js';
-import '../../chatbot/ChatBot.js';
 
 let ChatResolver = class ChatResolver {
     chatRepository;
     constructor(chatRepository) {
         this.chatRepository = chatRepository;
     }
-    async resolve(origin) {
-        if (origin.chatType === 'GROUP') {
-            return this.resolveGroupChat({ channelType: origin.channelType.name, chatId: origin.chatId });
+    async resolve(connection) {
+        if (connection.chatType === 'GROUP') {
+            return this.resolveGroupChat(connection);
         }
-        return this.resolvePrivateChat({ channelType: origin.channelType.name, chatId: origin.chatId });
+        return this.resolvePrivateChat(connection);
     }
     async resolveGroupChat(connection) {
         let chat = await this.chatRepository.findByConnection(connection);

package/dist/src/controller/channel/UserResolver.js

@@ -0,0 +1,23 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../core/chat/repository/ram/RamChatRepository.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/repository/ram/RamUserRepository.js';
+import { UserRepository } from '../../core/user/repository/IUserRepository.js';
+import { singleton } from '../../injection/index.js';
+
+let UserResolver = class UserResolver {
+    userRepository;
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+    async resolve(connection) {
+        let user = await this.userRepository.findByConnection(connection);
+        return user;
+    }
+};
+UserResolver = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [UserRepository])
+], UserResolver);
+
+export { UserResolver };

package/dist/src/core/IMessageContext.js

@@ -0,0 +1,15 @@
+import './user/repository/ram/RamUserRepository.js';
+import './user/repository/IUserRepository.js';
+
+class MessageContext {
+    message;
+    chat;
+    user;
+    constructor(message, chat, user) {
+        this.message = message;
+        this.chat = chat;
+        this.user = user;
+    }
+}
+
+export { MessageContext };

package/dist/src/{chatbot → core}/chat/Chat.js

@@ -11,7 +11,7 @@ class Chat {
     }
     hasConnection(connection) {
         for (const con of this.data.connections) {
-            if (con.channelType === connection.channelType && con.chatId === connection.chatId) {
+            if (con.channelName === connection.channelName && con.id === connection.id) {
                 return true;
             }
         }

package/dist/src/{chatbot → core}/chat/repository/ram/RamChatRepository.js

@@ -1,5 +1,6 @@
 import { __decorate } from 'tslib';
 import { v4 } from 'uuid';
+import '../IChatRepository.js';
 import { RamChatMemory } from './RamChatMemory.js';
 import { singleton } from '../../../../injection/index.js';
 

package/dist/src/core/user/User.js

@@ -0,0 +1,42 @@
+class User {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    getId() {
+        if (!this.data.id) {
+            throw new Error('User have not ID');
+        }
+        return this.data.id;
+    }
+    hasConnection(connection) {
+        for (const con of this.data.connections) {
+            if (con.channelName === connection.channelName && con.id === connection.id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    wasCreated() {
+        return !!this.data.createdAt || !!this.data.id;
+    }
+    validate() {
+        if (!this.data.id) {
+            throw new Error('User ID is required');
+        }
+        if (!this.data.createdAt) {
+            throw new Error('User createdAt is required');
+        }
+    }
+    getValue(key) {
+        return this.data.keyValueData[key];
+    }
+    setValue(key, value) {
+        this.data.keyValueData[key] = value;
+    }
+    addConnection(connection) {
+        this.data.connections.push(connection);
+    }
+}
+
+export { User };

package/dist/src/core/user/repository/IUserRepository.js

@@ -0,0 +1,19 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../../injection/index.js';
+
+let UserRepository = class UserRepository {
+    create(chat) {
+        throw new Error('Method not implemented.');
+    }
+    update(chat) {
+        throw new Error('Method not implemented.');
+    }
+    findByConnection(query) {
+        throw new Error('Method not implemented.');
+    }
+};
+UserRepository = __decorate([
+    singleton()
+], UserRepository);
+
+export { UserRepository };

package/dist/src/core/user/repository/ram/RamUserRepository.js

@@ -0,0 +1,28 @@
+import { __decorate } from 'tslib';
+import { v4 } from 'uuid';
+import '../IUserRepository.js';
+import { singleton } from '../../../../injection/index.js';
+
+let RamUserRepository = class RamUserRepository {
+    items = [];
+    async create(chat) {
+        if (chat.wasCreated()) {
+            throw new Error('User already created');
+        }
+        chat['data'].id = v4();
+        chat['data'].createdAt = new Date();
+        chat.validate();
+        this.items.push(chat);
+    }
+    async findByConnection(query) {
+        return this.items.find((item) => item.hasConnection(query)) ?? null;
+    }
+    async update(chat) {
+        // TODO
+    }
+};
+RamUserRepository = __decorate([
+    singleton()
+], RamUserRepository);
+
+export { RamUserRepository };