@wabot-dev/framework 0.0.1

package/dist/src/chatbot/chat/repository/IChatRepository.js

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

package/dist/src/chatbot/chat/repository/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ram';
+export * from './IChatMemory';
+export * from './IChatRepository';

package/dist/src/chatbot/chat/repository/ram/RamChatMemory.d.ts

@@ -0,0 +1,8 @@
+import { IChatItem } from "../../IChatItem";
+import { IChatMemory } from "../IChatMemory";
+export declare class RamChatMemory implements IChatMemory {
+    private memory;
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+    clearMemory(): Promise<void>;
+}

package/dist/src/chatbot/chat/repository/ram/RamChatMemory.js

@@ -0,0 +1,14 @@
+class RamChatMemory {
+    memory = [];
+    async findLastItems(count) {
+        return this.memory.slice(-count);
+    }
+    async saveItem(item) {
+        this.memory.push(item);
+    }
+    async clearMemory() {
+        this.memory = [];
+    }
+}
+
+export { RamChatMemory };

package/dist/src/chatbot/chat/repository/ram/RamChatRepository.d.ts

@@ -0,0 +1,11 @@
+import { Chat, IChatConnection } from '../../Chat';
+import { IChatRepository } from '../IChatRepository';
+import { IChatMemory } from '../IChatMemory';
+export declare class RamChatRepository implements IChatRepository {
+    private items;
+    private memories;
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+    private getMemory;
+}

package/dist/src/chatbot/chat/repository/ram/RamChatRepository.js

@@ -0,0 +1,41 @@
+import { __decorate } from 'tslib';
+import { v4 } from 'uuid';
+import { RamChatMemory } from './RamChatMemory.js';
+import { singleton } from '../../../../injection/index.js';
+
+let RamChatRepository = class RamChatRepository {
+    items = [];
+    memories = [];
+    async create(chat) {
+        if (chat.wasCreated()) {
+            throw new Error('Chat already created');
+        }
+        chat['data'].id = v4();
+        chat['data'].createdAt = new Date();
+        chat.validate();
+        this.items.push(chat);
+        const memory = {
+            memory: new RamChatMemory(),
+            chatId: chat.getId(),
+        };
+        this.memories.push(memory);
+    }
+    async findByConnection(query) {
+        return this.items.find((item) => item.hasConnection(query)) ?? null;
+    }
+    findMemory(chatId) {
+        const memory = this.getMemory(chatId);
+        if (!memory) {
+            return Promise.resolve(null);
+        }
+        return Promise.resolve(memory.memory);
+    }
+    getMemory(chatId) {
+        return this.memories.find((r) => r.chatId === chatId) ?? null;
+    }
+};
+RamChatRepository = __decorate([
+    singleton()
+], RamChatRepository);
+
+export { RamChatRepository };

package/dist/src/chatbot/chat/repository/ram/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RamChatMemory';
+export * from './RamChatRepository';

package/dist/src/chatbot/index.d.ts

@@ -0,0 +1,5 @@
+export * from './chat';
+export * from './metadata';
+export * from './ChatBot';
+export * from './ChatBotAdapter';
+export * from './IChatBot';

package/dist/src/chatbot/metadata/@chatBot.d.ts

@@ -0,0 +1,3 @@
+import { IMindset } from '@/mindset';
+import { IConstructor } from '@/shared';
+export declare function chatBot(mindset: IConstructor<IMindset>): (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;

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

@@ -0,0 +1,18 @@
+import { container, inject } from '../../injection/index.js';
+import { v4 } from 'uuid';
+import { ChatBotMetadataStore } from './ChatBotMetadataStore.js';
+
+function chatBot(mindset) {
+    return function (target, propertyKey, parameterIndex) {
+        const injectionToken = `ChatBot-${mindset.name}-${v4()}`;
+        const metadataStore = container.resolve(ChatBotMetadataStore);
+        metadataStore.saveChatBotMetadata({
+            constructor: target,
+            mindsetConstructor: mindset,
+            injectionToken,
+        });
+        inject(injectionToken)(target, propertyKey, parameterIndex);
+    };
+}
+
+export { chatBot };

package/dist/src/chatbot/metadata/ChatBotMetadataStore.d.ts

@@ -0,0 +1,6 @@
+import { IChatBotMetadata } from "./IChatBotMetadata";
+export declare class ChatBotMetadataStore {
+    private chatBots;
+    saveChatBotMetadata(chatBot: IChatBotMetadata): void;
+    getChatBotsMetadata(): IChatBotMetadata[];
+}

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

@@ -0,0 +1,17 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../injection/index.js';
+
+let ChatBotMetadataStore = class ChatBotMetadataStore {
+    chatBots = [];
+    saveChatBotMetadata(chatBot) {
+        this.chatBots.push(chatBot);
+    }
+    getChatBotsMetadata() {
+        return this.chatBots;
+    }
+};
+ChatBotMetadataStore = __decorate([
+    singleton()
+], ChatBotMetadataStore);
+
+export { ChatBotMetadataStore };

package/dist/src/chatbot/metadata/IChatBotMetadata.d.ts

@@ -0,0 +1,7 @@
+import { IMindset } from "@/mindset";
+import { IConstructor } from "@/shared";
+export interface IChatBotMetadata {
+    constructor: IConstructor<any>;
+    mindsetConstructor: IConstructor<IMindset>;
+    injectionToken: string;
+}

package/dist/src/chatbot/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export * from './@chatBot';
+export * from './ChatBotMetadataStore';
+export * from './IChatBotMetadata';

package/dist/src/context/IContext.d.ts

@@ -0,0 +1,18 @@
+import { IChatMessage } from '@/message';
+export interface IChatContext {
+    chatId: string;
+    message: IChatMessage;
+    reply: (message: IChatMessage) => void;
+}
+export interface IUserContext {
+    userId: string;
+}
+export interface IContext {
+    user?: IUserContext;
+    chat: IChatContext;
+}
+export declare class Context implements IContext {
+    chat: IChatContext;
+    user?: IUserContext | undefined;
+    constructor(chat: IChatContext, user?: IUserContext | undefined);
+}

package/dist/src/context/IContext.js

@@ -0,0 +1,10 @@
+class Context {
+    chat;
+    user;
+    constructor(chat, user) {
+        this.chat = chat;
+        this.user = user;
+    }
+}
+
+export { Context };

package/dist/src/context/index.d.ts

@@ -0,0 +1 @@
+export * from './IContext';

package/dist/src/controller/channel/ChatResolver.d.ts

@@ -0,0 +1,9 @@
+import { Chat, ChatRepository } from '@/chatbot';
+import { IMessageOrigin } from './IMessageContext';
+export declare class ChatResolver {
+    private chatRepository;
+    constructor(chatRepository: ChatRepository);
+    resolve(origin: IMessageOrigin): Promise<Chat>;
+    private resolveGroupChat;
+    private resolvePrivateChat;
+}

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

@@ -0,0 +1,43 @@
+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 { 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 });
+        }
+        return this.resolvePrivateChat({ channelType: origin.channelType.name, chatId: origin.chatId });
+    }
+    async resolveGroupChat(connection) {
+        let chat = await this.chatRepository.findByConnection(connection);
+        if (!chat) {
+            chat = new Chat({ type: 'GROUP', connections: [connection] });
+            await this.chatRepository.create(chat);
+        }
+        return chat;
+    }
+    async resolvePrivateChat(connection) {
+        let chat = await this.chatRepository.findByConnection(connection);
+        if (!chat) {
+            chat = new Chat({ type: 'PRIVATE', connections: [connection] });
+            await this.chatRepository.create(chat);
+        }
+        return chat;
+    }
+};
+ChatResolver = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ChatRepository])
+], ChatResolver);
+
+export { ChatResolver };

package/dist/src/controller/channel/IChatChannel.d.ts

@@ -0,0 +1,5 @@
+import { IMessageContext } from "./IMessageContext";
+export interface IChatChannel {
+    listen(callback: (message: IMessageContext) => void): void;
+    connect(): void;
+}

package/dist/src/controller/channel/IMessageContext.d.ts

@@ -0,0 +1,10 @@
+import { IChatType } from '@/chatbot/chat';
+import { IChatContext } from '@/context';
+export interface IMessageOrigin {
+    chatId: string;
+    chatType: IChatType;
+    channelType: Function;
+}
+export interface IMessageContext extends IChatContext {
+    origin: IMessageOrigin;
+}

package/dist/src/controller/channel/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ChatResolver';
+export * from './IChatChannel';
+export * from './IMessageContext';

package/dist/src/controller/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channel';
+export * from './metadata';

package/dist/src/controller/metadata/ControllerMetadataStore.d.ts

@@ -0,0 +1,12 @@
+import { IChatControllerMetadata } from './controller/IChatControllerMetadata';
+import { IChannelMetadata } from './channel/IChannelMetadata';
+export declare class ControllerMetadataStore {
+    private channels;
+    private chatControllers;
+    saveChannelMetadata(channelMetadata: IChannelMetadata): void;
+    saveChatControllerMetadata(controllerMetadata: IChatControllerMetadata): void;
+    getChatControllerMetadata(controllerConstructor: Function): {
+        config: IChatControllerMetadata;
+        channels: IChannelMetadata[];
+    } | null;
+}

package/dist/src/controller/metadata/ControllerMetadataStore.js

@@ -0,0 +1,42 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../injection/index.js';
+
+let ControllerMetadataStore = class ControllerMetadataStore {
+    channels = new Map();
+    chatControllers = new Map();
+    saveChannelMetadata(channelMetadata) {
+        let controllerChannels = this.channels.get(channelMetadata.controllerConstructor);
+        if (!controllerChannels) {
+            controllerChannels = new Map();
+            this.channels.set(channelMetadata.controllerConstructor, controllerChannels);
+        }
+        let functionChannels = controllerChannels.get(channelMetadata.functionName);
+        if (!functionChannels) {
+            functionChannels = [];
+            controllerChannels.set(channelMetadata.functionName, functionChannels);
+        }
+        functionChannels.push(channelMetadata);
+    }
+    saveChatControllerMetadata(controllerMetadata) {
+        this.chatControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
+    }
+    getChatControllerMetadata(controllerConstructor) {
+        const mainMetadata = this.chatControllers.get(controllerConstructor);
+        if (!mainMetadata)
+            return null;
+        const config = mainMetadata;
+        const channelsMap = this.channels.get(controllerConstructor);
+        const channels = Array.from(channelsMap?.values() ?? [])
+            .map((channelMetadata) => channelMetadata)
+            .flat();
+        return {
+            config,
+            channels,
+        };
+    }
+};
+ControllerMetadataStore = __decorate([
+    singleton()
+], ControllerMetadataStore);
+
+export { ControllerMetadataStore };

package/dist/src/controller/metadata/channel/IChannelMetadata.d.ts

@@ -0,0 +1,8 @@
+import { IConstructor } from '@/shared';
+import { IChatChannel } from '../../channel/IChatChannel';
+export interface IChannelMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    channelConstructor: IConstructor<IChatChannel>;
+    channelConfig: object;
+}

package/dist/src/controller/metadata/channel/index.d.ts

@@ -0,0 +1 @@
+export * from './IChannelMetadata';

package/dist/src/controller/metadata/controller/@chatController.d.ts

@@ -0,0 +1,3 @@
+import { IchatControllerConfig } from "./IChatControllerConfig";
+import { IConstructor } from "@/shared";
+export declare function chatController(config?: IchatControllerConfig): (target: IConstructor<any>) => void;

package/dist/src/controller/metadata/controller/@chatController.js

@@ -0,0 +1,14 @@
+import { container, injectable } from '../../../injection/index.js';
+import { ControllerMetadataStore } from '../ControllerMetadataStore.js';
+
+function chatController(config) {
+    return function (target) {
+        const controllerMetaDataStore = container.resolve(ControllerMetadataStore);
+        controllerMetaDataStore.saveChatControllerMetadata({
+            controllerConstructor: target,
+        });
+        injectable()(target);
+    };
+}
+
+export { chatController };

package/dist/src/controller/metadata/controller/IChatControllerConfig.d.ts

@@ -0,0 +1,2 @@
+export interface IchatControllerConfig {
+}

package/dist/src/controller/metadata/controller/IChatControllerMetadata.d.ts

@@ -0,0 +1,3 @@
+export interface IChatControllerMetadata {
+    controllerConstructor: Function;
+}

package/dist/src/controller/metadata/controller/index.d.ts

@@ -0,0 +1,3 @@
+export * from './@chatController';
+export * from './IChatControllerConfig';
+export * from './IChatControllerMetadata';

package/dist/src/controller/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export * from './controller';
+export * from './channel';
+export * from './ControllerMetadataStore';

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './ai';
+export * from './channels';
+export * from './chatbot';
+export * from './context';
+export * from './controller';
+export * from './injection';
+export * from './message';
+export * from './mindset';
+export * from './server';
+export * from './shared';

package/dist/src/index.js

@@ -0,0 +1,34 @@
+export { OpenaiChatBotAdapter } from './ai/openia/OpenaiChatBotAdapter.js';
+export { CmdChannel } from './channels/cmd/CmdChannel.js';
+export { telegram } from './channels/telegram/@telegram.js';
+export { TelegramChannelConfig } from './channels/telegram/TelegramChannelConfig.js';
+export { TelegramChannel } from './channels/telegram/TelegramChannel.js';
+export { RamChatMemory } from './chatbot/chat/repository/ram/RamChatMemory.js';
+export { RamChatRepository } from './chatbot/chat/repository/ram/RamChatRepository.js';
+export { ChatMemory } from './chatbot/chat/repository/IChatMemory.js';
+export { ChatRepository } from './chatbot/chat/repository/IChatRepository.js';
+export { Chat } from './chatbot/chat/Chat.js';
+export { chatBot } from './chatbot/metadata/@chatBot.js';
+export { ChatBotMetadataStore } from './chatbot/metadata/ChatBotMetadataStore.js';
+export { ChatBot } from './chatbot/ChatBot.js';
+export { ChatBotAdapter } from './chatbot/ChatBotAdapter.js';
+export { Context } from './context/IContext.js';
+export { ChatResolver } from './controller/channel/ChatResolver.js';
+export { chatController } from './controller/metadata/controller/@chatController.js';
+export { ControllerMetadataStore } from './controller/metadata/ControllerMetadataStore.js';
+export { container, inject, injectable, singleton } from './injection/index.js';
+export { mindsetFunction } from './mindset/metadata/functions/@mindsetFunction.js';
+export { MINDSET_FUNCTION_DECORATION_FUNCTION } from './mindset/metadata/functions/decoratorNames.js';
+export { mindset } from './mindset/metadata/mindsets/@mindset.js';
+export { MINDSET_DECORATION_MINDSET } from './mindset/metadata/mindsets/decoratorNames.js';
+export { mindsetModule } from './mindset/metadata/modules/@mindsetModule.js';
+export { MINDSET_MODULE_DECORATION_MODULE } from './mindset/metadata/modules/decoratorNames.js';
+export { isOptional } from './mindset/metadata/params/@isOptional.js';
+export { param } from './mindset/metadata/params/@param.js';
+export { MindsetMetadataStore } from './mindset/metadata/MindsetMetadataStore.js';
+export { Mindset } from './mindset/IMindset.js';
+export { MindsetOperator } from './mindset/MindsetOperator.js';
+export { prepareChatContainer } from './server/prepareChatContainer.js';
+export { runChannel } from './server/runChannel.js';
+export { runServer } from './server/runServer.js';
+export { Container } from './injection/Container.js';

package/dist/src/injection/Container.d.ts

@@ -0,0 +1,18 @@
+import { DependencyContainer, InjectionToken } from "tsyringe";
+import { InterceptionOptions } from "tsyringe/dist/typings/types";
+import { PostResolutionInterceptorCallback, PreResolutionInterceptorCallback } from "tsyringe/dist/typings/types/dependency-container";
+export declare class Container implements DependencyContainer {
+    register(token: unknown, provider: unknown, options?: unknown): DependencyContainer;
+    registerSingleton(from: unknown, to?: unknown): DependencyContainer;
+    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): DependencyContainer;
+    registerInstance<T>(token: InjectionToken<T>, instance: T): DependencyContainer;
+    resolve<T>(token: InjectionToken<T>): T;
+    resolveAll<T>(token: InjectionToken<T>): T[];
+    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean;
+    reset(): void;
+    clearInstances(): void;
+    createChildContainer(): DependencyContainer;
+    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: InterceptionOptions): void;
+    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: InterceptionOptions): void;
+    dispose(): Promise<void> | void;
+}

package/dist/src/injection/Container.js

@@ -0,0 +1,43 @@
+class Container {
+    register(token, provider, options) {
+        throw new Error('Method not implemented.');
+    }
+    registerSingleton(from, to) {
+        throw new Error('Method not implemented.');
+    }
+    registerType(from, to) {
+        throw new Error('Method not implemented.');
+    }
+    registerInstance(token, instance) {
+        throw new Error('Method not implemented.');
+    }
+    resolve(token) {
+        throw new Error('Method not implemented.');
+    }
+    resolveAll(token) {
+        throw new Error('Method not implemented.');
+    }
+    isRegistered(token, recursive) {
+        throw new Error('Method not implemented.');
+    }
+    reset() {
+        throw new Error('Method not implemented.');
+    }
+    clearInstances() {
+        throw new Error('Method not implemented.');
+    }
+    createChildContainer() {
+        throw new Error('Method not implemented.');
+    }
+    beforeResolution(token, callback, options) {
+        throw new Error('Method not implemented.');
+    }
+    afterResolution(token, callback, options) {
+        throw new Error('Method not implemented.');
+    }
+    dispose() {
+        throw new Error('Method not implemented.');
+    }
+}
+
+export { Container };

package/dist/src/injection/index.d.ts

@@ -0,0 +1,3 @@
+export declare const injectable: typeof import("tsyringe").injectable, container: import("tsyringe").DependencyContainer, singleton: typeof import("tsyringe").singleton, inject: typeof import("tsyringe").inject;
+export { Container } from './Container';
+export type { DependencyContainer } from 'tsyringe';

package/dist/src/injection/index.js

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

package/dist/src/message/IChatDocument.d.ts

@@ -0,0 +1,2 @@
+export interface IChatDocument {
+}

package/dist/src/message/IChatImage.d.ts

@@ -0,0 +1,2 @@
+export interface IChatImage {
+}

package/dist/src/message/IChatMessage.d.ts

@@ -0,0 +1,9 @@
+import { IChatDocument } from './IChatDocument';
+import { IChatImage } from './IChatImage';
+import { IChatSender } from './IChatSender';
+export interface IChatMessage {
+    sender: IChatSender;
+    text?: string;
+    documents?: IChatDocument[];
+    images?: IChatImage[];
+}

package/dist/src/message/IChatSender.d.ts

@@ -0,0 +1,4 @@
+export interface IChatSender {
+    shortName: string;
+    senderId?: string;
+}

package/dist/src/message/index.d.ts

@@ -0,0 +1,4 @@
+export * from './IChatDocument';
+export * from './IChatImage';
+export * from './IChatMessage';
+export * from './IChatSender';

package/dist/src/mindset/IMindset.d.ts

@@ -0,0 +1,17 @@
+export interface IMindsetIdentity {
+    name: string;
+    language: string;
+    age?: number;
+    personality?: string;
+    emotions?: string;
+}
+export interface IMindset {
+    identity(): Promise<IMindsetIdentity>;
+    skills(): Promise<string>;
+    limits(): Promise<string>;
+}
+export declare class Mindset implements IMindset {
+    identity(): Promise<IMindsetIdentity>;
+    skills(): Promise<string>;
+    limits(): Promise<string>;
+}

package/dist/src/mindset/IMindset.js

@@ -0,0 +1,13 @@
+class Mindset {
+    identity() {
+        throw new Error("Method not implemented.");
+    }
+    skills() {
+        throw new Error("Method not implemented.");
+    }
+    limits() {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export { Mindset };

package/dist/src/mindset/MindsetOperator.d.ts

@@ -0,0 +1,25 @@
+import { Container } from '@/injection';
+import { IMindset, IMindsetIdentity, Mindset } from './IMindset';
+import { MindsetMetadataStore } from './metadata/MindsetMetadataStore';
+export declare class MindsetOperator implements IMindset {
+    private mindset;
+    private container;
+    private metadata;
+    constructor(mindset: Mindset, container: Container, metadataStore: MindsetMetadataStore);
+    identity(): Promise<IMindsetIdentity>;
+    skills(): Promise<string>;
+    limits(): Promise<string>;
+    callFunction(name: string, params: string): Promise<string>;
+    allFunctionsDescriptors(): Promise<{
+        readonly type: "function";
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {};
+            readonly required: string[];
+        };
+    }[]>;
+    private functionDescriptor;
+    private toolParam;
+}