@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/src/channels/wabot/WabotDevConnection.js

@@ -1,57 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { singleton } from '../../injection/index.js';
-import { Logger } from '../../logger/Logger.js';
-import { io } from 'socket.io-client';
-import { devEmitEvent } from './WabotDevSocketContracts.js';
-
-var WabotDevConnection_1;
-let WabotDevConnection = WabotDevConnection_1 = class WabotDevConnection {
-    devProxy;
-    devProxySocket = null;
-    devToken;
-    logger = new Logger('wabot:dev-connection');
-    static isTokenAvailable() {
-        return !!process.env.WABOT_DEV_TOKEN;
-    }
-    constructor() {
-        if (!WabotDevConnection_1.isTokenAvailable()) {
-            throw new Error('WABOT_DEV_TOKEN is not set in environment variables');
-        }
-        this.devToken = process.env.WABOT_DEV_TOKEN;
-        this.devProxy = process.env.WABOT_DEV_PROXY ?? 'https://proxy.wabot.dev';
-    }
-    async getSocket() {
-        if (this.devProxySocket) {
-            return this.devProxySocket;
-        }
-        return new Promise((resolve, reject) => {
-            const devProxySocket = io(this.devProxy, { autoConnect: false });
-            devProxySocket.on('connect', async () => {
-                try {
-                    const req = {
-                        token: this.devToken,
-                    };
-                    this.logger.debug('dev connection request');
-                    const ack = await devProxySocket.emitWithAck(devEmitEvent.DEV_CONNECTION, req);
-                    if (ack != 'OK') {
-                        return reject(new Error('Dev connection failed'));
-                    }
-                    this.logger.debug('success dev connection');
-                    this.devProxySocket = devProxySocket;
-                    resolve(devProxySocket);
-                }
-                catch (err) {
-                    this.logger.error(err);
-                    reject(err);
-                }
-            });
-            devProxySocket.connect();
-        });
-    }
-};
-WabotDevConnection = WabotDevConnection_1 = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [])
-], WabotDevConnection);
-
-export { WabotDevConnection };

package/dist/src/channels/wabot/WabotDevSocketContracts.js

@@ -1,10 +0,0 @@
-const devListentEvent = {
-    DEV_WATSAPP_WEBHOOK: 'dev-whatsapp-webhook',
-};
-const devEmitEvent = {
-    DEV_CONNECTION: 'dev-connection',
-    DEV_SEND_WHATSAPP: 'dev-send-whatsapp',
-    DEV_SEND_WHATSAPP_TEMPLATE: 'dev-send-whatsapp-template',
-};
-
-export { devEmitEvent, devListentEvent };

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

@@ -1,20 +0,0 @@
-import { container } from '../../injection/index.js';
-import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import { WhatsAppChannel } from './WhatsAppChannel.js';
-
-function whatsapp(config) {
-    return function (target, propertyKey) {
-        const store = container.resolve(ControllerMetadataStore);
-        store.saveChannelMetadata({
-            channelConstructor: WhatsAppChannel,
-            functionName: propertyKey.toString(),
-            controllerConstructor: target.constructor,
-            channelConfig: new WhatsappChannelConfig(config.number),
-        });
-    };
-}
-
-export { whatsapp };

package/dist/src/channels/whatsapp/WhatsAppReceiver.js

@@ -1,59 +0,0 @@
-class WhatsAppReceiver {
-    logger;
-    listeners = new Map();
-    constructor(logger) {
-        this.logger = logger;
-    }
-    listenMessage(request) {
-        this.listeners.set(request.to, request.listener);
-    }
-    async handlePayload(payload) {
-        try {
-            for (const entry of payload.entry) {
-                for (const change of entry.changes) {
-                    if (change.field !== 'messages' || !change.value.messages || !change.value.contacts) {
-                        continue;
-                    }
-                    for (const message of change.value.messages) {
-                        const contact = change.value.contacts.find((x) => x.wa_id === message.from);
-                        if (!contact) {
-                            continue;
-                        }
-                        await this.emmitMessage(change.value.metadata, message, contact);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            this.logger.error(err);
-        }
-    }
-    async emmitMessage(metadata, message, contact) {
-        const listener = this.listeners.get(metadata.display_phone_number);
-        if (!listener) {
-            return;
-        }
-        if (message.type !== 'text') {
-            this.logger.error(`message type ${message.type} is not supported yet`);
-            return;
-        }
-        const channelName = 'WhatsAppChannel';
-        const chatConnection = {
-            id: contact.wa_id,
-            chatType: 'PRIVATE',
-            channelName,
-        };
-        const userConnection = {
-            id: contact.wa_id,
-            channelName,
-        };
-        await listener({
-            chatConnection,
-            userConnection,
-            senderName: contact.profile.name,
-            text: message.text.body,
-        });
-    }
-}
-
-export { WhatsAppReceiver };

package/dist/src/channels/whatsapp/WhatsAppReceiverByDevConnection.js

@@ -1,32 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
-import { WhatsAppReceiver } from './WhatsAppReceiver.js';
-import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
-import { devListentEvent } from '../wabot/WabotDevSocketContracts.js';
-import { singleton } from 'tsyringe';
-import { container } from '../../injection/index.js';
-
-let WhatsAppReceiverByDevConnection = class WhatsAppReceiverByDevConnection extends WhatsAppReceiver {
-    wabotDevConnection;
-    constructor(wabotDevConnection) {
-        super(new Logger('wabot:whatsapp-receiver-by-dev-connection'));
-        this.wabotDevConnection = wabotDevConnection;
-    }
-    async connect() {
-        const socket = await this.wabotDevConnection.getSocket();
-        socket.on(devListentEvent.DEV_WATSAPP_WEBHOOK, (payload) => {
-            this.handlePayload(payload);
-        });
-    }
-};
-WhatsAppReceiverByDevConnection = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [WabotDevConnection])
-], WhatsAppReceiverByDevConnection);
-if (WabotDevConnection.isTokenAvailable()) {
-    container.register(WhatsAppReceiver, {
-        useClass: WhatsAppReceiverByDevConnection,
-    });
-}
-
-export { WhatsAppReceiverByDevConnection };

package/dist/src/channels/whatsapp/WhatsAppReceiverByWebHook.js

@@ -1,63 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
-import { WhatsAppReceiver } from './WhatsAppReceiver.js';
-import { singleton } from 'tsyringe';
-import { ExpressProvider } from '../express/ExpressProvider.js';
-import { WhatsAppRepository } from './WhatsAppRepository.js';
-import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
-import { container } from '../../injection/index.js';
-
-let WhatsAppReceiverByWebHook = class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
-    expressProvider;
-    whatsAppRepository;
-    expressApp;
-    webhookPath = '/whatsapp/web-hook/:slug';
-    constructor(expressProvider, whatsAppRepository) {
-        super(new Logger('wabot:whatsapp-receiver-by-webhook'));
-        this.expressProvider = expressProvider;
-        this.whatsAppRepository = whatsAppRepository;
-        this.expressApp = this.expressProvider.getExpress();
-    }
-    async connect() {
-        this.expressApp.get(this.webhookPath, async (req, res) => {
-            try {
-                let mode = req.query['hub.mode'];
-                let token = req.query['hub.verify_token'];
-                let challenge = req.query['hub.challenge'];
-                if (!mode || !token || !challenge) {
-                    res.sendStatus(400);
-                    return;
-                }
-                const whatsApp = await this.whatsAppRepository.findBySlug(req.params.slug);
-                if (!whatsApp || mode !== 'subscribe' || token !== whatsApp.getVerifyToken()) {
-                    res.sendStatus(403);
-                    return;
-                }
-                res.status(200).send(challenge);
-            }
-            catch (e) {
-                this.logger.error(e);
-                res.sendStatus(500);
-                return;
-            }
-        });
-        this.expressApp.post(this.webhookPath, (req, res) => {
-            const payload = req.body;
-            this.handlePayload(payload);
-            res.sendStatus(200);
-        });
-        this.expressProvider.listen();
-    }
-};
-WhatsAppReceiverByWebHook = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [ExpressProvider,
-        WhatsAppRepository])
-], WhatsAppReceiverByWebHook);
-if (!WabotDevConnection.isTokenAvailable()) {
-    container.register(WhatsAppReceiver, {
-        useClass: WhatsAppReceiverByWebHook,
-    });
-}
-
-export { WhatsAppReceiverByWebHook };

package/dist/src/channels/whatsapp/WhatsAppSenderByDevConnection.js

@@ -1,61 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { WhatsAppSender } from './WhatsAppSender.js';
-import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
-import { devEmitEvent } from '../wabot/WabotDevSocketContracts.js';
-import { Logger } from '../../logger/Logger.js';
-import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { singleton, container } from '../../injection/index.js';
-import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
-import { WhatsAppRepository } from './WhatsAppRepository.js';
-
-let WhatsAppSenderByDevConnection = class WhatsAppSenderByDevConnection extends WhatsAppSender {
-    wabotDevConnection;
-    constructor(wabotDevConnection, chatRepository, chatResolver, whatsAppRepository) {
-        super(new Logger('wabot:whatsapp-sender-by-dev-connection'), chatRepository, chatResolver, whatsAppRepository);
-        this.wabotDevConnection = wabotDevConnection;
-    }
-    async handleSendRequest(request) {
-        const socket = await this.wabotDevConnection.getSocket();
-        const req = {
-            from: request.from,
-            to: request.to,
-            message: request.message,
-        };
-        const ack = await socket.emitWithAck(devEmitEvent.DEV_SEND_WHATSAPP, req);
-        if (ack != 'OK') {
-            throw new Error(`Error sending WhatsApp template: ${ack}`);
-        }
-    }
-    async handleSendTemplateRequest(request) {
-        const socket = await this.wabotDevConnection.getSocket();
-        const req = {
-            from: request.from,
-            to: request.to,
-            message: request.templateMessage,
-        };
-        const ack = await socket.emitWithAck(devEmitEvent.DEV_SEND_WHATSAPP_TEMPLATE, req);
-        if (ack != 'OK') {
-            throw new Error(`Error sending WhatsApp template: ${ack}`);
-        }
-    }
-    async handleGetWhatsAppTemplate(request) {
-        throw new Error('Not implemented');
-    }
-};
-WhatsAppSenderByDevConnection = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [WabotDevConnection,
-        ChatRepository,
-        ChatResolver,
-        WhatsAppRepository])
-], WhatsAppSenderByDevConnection);
-if (WabotDevConnection.isTokenAvailable()) {
-    container.register(WhatsAppSender, {
-        useClass: WhatsAppSenderByDevConnection,
-    });
-}
-
-export { WhatsAppSenderByDevConnection };

package/dist/src/chatbot/ChatBot.js

@@ -1,51 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
-import '../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../core/chat/ChatItem.js';
-import '../core/user/IUserRepository.js';
-import { injectable } from '../injection/index.js';
-import { ChatBotAdapter } from './ChatBotAdapter.js';
-
-let ChatBot = class ChatBot {
-    memory;
-    adapter;
-    constructor(memory, adapter) {
-        this.memory = memory;
-        this.adapter = adapter;
-        this.memory = memory;
-    }
-    async sendMessage(message, callback) {
-        const newChatItem = new ChatItem({
-            type: 'CONNECTION_MESSAGE',
-            content: message,
-        });
-        await this.memory.create(newChatItem);
-        this.processLoop(callback);
-    }
-    async processLoop(callback) {
-        const prevChatItems = await this.memory.findLastItems(10);
-        if (prevChatItems.length === 0) {
-            return;
-        }
-        const lastChatItem = prevChatItems[prevChatItems.length - 1];
-        const lastItemType = lastChatItem.getType();
-        if (lastItemType === 'BOT_MESSAGE') {
-            return;
-        }
-        const newChatItem = await this.adapter.generateNextChatItem(prevChatItems);
-        await this.memory.create(newChatItem);
-        const newChatItemData = newChatItem.getData();
-        if (newChatItemData.type === 'BOT_MESSAGE') {
-            callback(newChatItemData.content);
-            return;
-        }
-        this.processLoop(callback);
-    }
-};
-ChatBot = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [ChatMemory,
-        ChatBotAdapter])
-], ChatBot);
-
-export { ChatBot };

package/dist/src/chatbot/ChatBotAdapter.js

@@ -1,72 +0,0 @@
-import '../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../core/chat/ChatItem.js';
-import '../core/user/IUserRepository.js';
-
-class ChatBotAdapter {
-    mindset;
-    constructor(mindset) {
-        this.mindset = mindset;
-    }
-    generateNextChatItem(chatItems) {
-        throw new Error('Not implemented');
-    }
-    async systemPrompt() {
-        let [identity, skills, limits] = await Promise.all([
-            this.mindset.identity(),
-            this.mindset.skills(),
-            this.mindset.limits(),
-        ]);
-        const language = identity.language.replaceAll('#', ' ');
-        const name = identity.name.replaceAll('#', ' ');
-        const age = identity.age ? identity.age.toString().replaceAll('#', ' ') : null;
-        const personality = identity.personality ? identity.personality.replaceAll('#', ' ') : null;
-        skills = skills.replaceAll('#', ' ');
-        limits = limits.replaceAll('#', ' ');
-        const systemPrompt = `
-         # System Instructions
-         you should act as a assistant.
-         your main language is ${language}.
-         your name is ${name}.
-         ${age ? 'you are ' + age + ' years old.' : ''}
-         
-          ${personality ? '## Personality (in your main language) \n' + personality : ''}
-  
-          ## Skills (in your main language)
-          ${skills}
-  
-          ## System limitations (in your main language)
-          ${limits}
-  
-          ## Chat memory
-          Next you will receive a chat history,
-          you should use this information to answer the user.
-      `;
-        return systemPrompt;
-    }
-    async buildBotMessageItem(text) {
-        const senderName = (await this.mindset.identity()).name;
-        const newBotMessage = new ChatItem({
-            type: 'BOT_MESSAGE',
-            content: {
-                senderName,
-                text,
-            },
-        });
-        return newBotMessage;
-    }
-    async buildFunctionCallItem(id, functionName, functionArguments) {
-        const functionResult = await this.mindset.callFunction(functionName, functionArguments);
-        const newFunctionCall = new ChatItem({
-            type: 'FUNCTION_CALL',
-            content: {
-                id,
-                name: functionName,
-                arguments: functionArguments,
-                result: functionResult,
-            },
-        });
-        return newFunctionCall;
-    }
-}
-
-export { ChatBotAdapter };

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

@@ -1,21 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../core/chat/repository/IChatRepository.js';
-import { UserRepository } from '../../core/user/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

@@ -1,12 +0,0 @@
-class MessageContext {
-    message;
-    chat;
-    user;
-    constructor(message, chat, user) {
-        this.message = message;
-        this.chat = chat;
-        this.user = user;
-    }
-}
-
-export { MessageContext };

package/dist/src/core/chat/ChatItem.js

@@ -1,15 +0,0 @@
-import { Persistent } from '../Persistent.js';
-
-class ChatItem extends Persistent {
-    getType() {
-        return this.data.type;
-    }
-    getContent() {
-        return this.data.content;
-    }
-    getData() {
-        return this.data;
-    }
-}
-
-export { ChatItem };

package/dist/src/core/chat/repository/IChatMemory.js

@@ -1,10 +0,0 @@
-class ChatMemory {
-    findLastItems(count) {
-        throw new Error('Method not implemented.');
-    }
-    create(item) {
-        throw new Error('Method not implemented.');
-    }
-}
-
-export { ChatMemory };

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

@@ -1,19 +0,0 @@
-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/User.js

@@ -1,26 +0,0 @@
-import { Persistent } from '../Persistent.js';
-
-class User extends Persistent {
-    constructor(data) {
-        super(data);
-    }
-    hasConnection(connection) {
-        for (const con of this.data.connections) {
-            if (con.channelName === connection.channelName && con.id === connection.id) {
-                return true;
-            }
-        }
-        return false;
-    }
-    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/env/WabotEnv.js

@@ -1,27 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { singleton } from 'tsyringe';
-
-let WabotEnv = class WabotEnv {
-    envType;
-    constructor() {
-        this.envType = process.env.WABOT_ENV ?? 'development';
-    }
-    isDevelopment() {
-        return this.envType === 'development';
-    }
-    isProduction() {
-        return this.envType === 'production';
-    }
-    requireString(varName) {
-        const value = process.env[varName];
-        if (!value)
-            throw new Error(`Env Variable ${varName} is required`);
-        return value;
-    }
-};
-WabotEnv = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [])
-], WabotEnv);
-
-export { WabotEnv };

package/dist/src/injection/index.js

@@ -1,4 +0,0 @@
-await import('reflect-metadata');
-const { injectable, container, singleton, inject } = await import('tsyringe');
-
-export { container, inject, injectable, singleton };

package/dist/src/mindset/MindsetOperator.js

@@ -1,101 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { injectable } from '../injection/index.js';
-import { Mindset } from './IMindset.js';
-import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
-import { Container } from '../injection/Container.js';
-
-let MindsetOperator = class MindsetOperator {
-    mindset;
-    container;
-    metadata;
-    constructor(mindset, container, metadataStore) {
-        this.mindset = mindset;
-        this.container = container;
-        this.metadata = metadataStore.getMindsetMetadata(this.mindset.constructor);
-    }
-    identity() {
-        return this.mindset.identity();
-    }
-    skills() {
-        return this.mindset.skills();
-    }
-    limits() {
-        return this.mindset.limits();
-    }
-    async callFunction(name, params) {
-        const fnMetadata = this.metadata.modules
-            .map((module) => module.functions)
-            .flat()
-            .find((fn) => fn.name === name);
-        if (!fnMetadata) {
-            throw new Error(`Function ${name} not found`);
-        }
-        const paramsObj = JSON.parse(params);
-        const module = this.container.resolve(fnMetadata.moduleConstructor);
-        try {
-            const response = await module[name](paramsObj);
-            if (!response) {
-                return 'success';
-            }
-            return response.toString();
-        }
-        catch (error) {
-            return `Error: ${error}`;
-        }
-    }
-    async allFunctionsDescriptors() {
-        return this.metadata.modules
-            .map((module) => module.functions.map((fn) => this.functionDescriptor(fn)))
-            .flat();
-    }
-    functionDescriptor(fn) {
-        const description = fn.config.description.replaceAll('#', ' ');
-        return {
-            type: 'function',
-            name: fn.name,
-            description,
-            parameters: {
-                type: 'object',
-                properties: fn.params.reduce((prev, param) => ({
-                    ...prev,
-                    [param.name]: this.toolParam(param),
-                }), {}),
-                required: fn.params.filter((param) => !param.config.optional).map((param) => param.name),
-            },
-        };
-    }
-    toolParam(param) {
-        const addons = {
-            description: `
-      ### description (in your main language)
-      ${param.config.description.replaceAll('#', ' ')}
-      `,
-        };
-        const type = (() => {
-            if (param.type === Number)
-                return 'number';
-            if (param.type === String)
-                return 'string';
-            if (param.type === Date) {
-                addons.description = `${addons.description}
-          ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
-          ${addons.description}
-        `;
-                return 'string';
-            }
-            throw new Error(`Unsupported type`);
-        })();
-        return {
-            type,
-            ...addons,
-        };
-    }
-};
-MindsetOperator = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [Mindset,
-        Container,
-        MindsetMetadataStore])
-], MindsetOperator);
-
-export { MindsetOperator };