Fixes and enhancements

package.json

@@ -1,6 +1,6 @@
 {
   "name": "bilderberg_butler",
-  "version": "2.57.0",
+  "version": "2.58.0",
   "description": "Discord bot for bilderberg club",
   "main": "index.js",
   "scripts": {

telegram/command-handlers/help-handler.js

@@ -3,25 +3,12 @@
  * @returns {[null, String | null]}
  */
 
-async function help() {
-    let message = `Вот список доступных команд:
-/help - список команд
-/ping - pong
-/info - получить информацию о чате
-/calc {математическое выражение} - получить информацию о чате
-/cur {число} {валюта1} {валюта2} - конвертор валют
-/wiki {запрос} - возвращает подходящие страницы из Википедии
-/answer {текст?} - при реплае использует текст оригинального сообщения для запроса к GPT, также использует текст переданный вместе с командой если таковой есть
-/urban {слово?} - определение из <a href="https://www.urbandictionary.com/">Urban Dictionary</>
-/set {название} - сохранить содержимое сообщения
-/get {название} - вызвать контент, сохранённый командой /set
-/get_list - показать список гетов, доступных в этом чате
-/del {название} - удалить гет
-/ahegao - получить случайное ахегао
-/curl {ссылка} - возвращает результат запроса к указанной ссылке
-/deep {запрос} - генерирует изображение по запросу с помощью DeepAI
-/0o0 {текст} - превращает текст в ТеКсТ
-`;
+async function help({}, interaction) {
+    let message = 'Вот список доступных команд:\n';
+    interaction.registered_commands.forEach((help, command_name) => {
+        if (!help?.length) return;
+        message += `/${command_name} — ${help.join(' ')}\n`;
+    });
     return [null, message];
 }
 

telegram/gpt-handler.js

@@ -9,7 +9,7 @@ const { OpenAIApi, Configuration } = require('openai');
 
 const CHAT_MODEL_NAME = 'gpt-4';
 
-const DEFAULT_SYSTEM_PROMPT = 'you are a chat-assistant\nanswer in english and/or russian languages\nanswer should not exceed 3000 characters\nyou can mention users by `@<username>` and call them by name';
+const DEFAULT_SYSTEM_PROMPT = `you are a chat-assistant\nanswer should not exceed 3000 characters\neach message starts with user's name and username, username is mentionable with @`;
 /**
    @param {String} input
    @return {String}
@@ -379,7 +379,7 @@ class ChatGPTHandler{
         const context_tree = this._getContextTree(context.chat.id);
 
         if (!new_system_prompt) {
-            [`Нужен не пустой системный промпт.\nПо умолчанию: <code>${DEFAULT_SYSTEM_PROMPT}</code>\nСейчас: <code>${context_tree.root_node.content}</code>`];
+            return [`Нужен не пустой системный промпт.\nПо умолчанию: <code>${DEFAULT_SYSTEM_PROMPT}</code>\nСейчас: <code>${context_tree.root_node.content}</code>`];
         }
 
         context_tree.root_node.content = new_system_prompt;

telegram/presence-subscriber.js

@@ -60,7 +60,7 @@ class PresenceNotification {
     }
 
     getNotificationText() {
-        let text = 'Активность';
+        let text = '\nАктивность';
         for (const [{}, { member_name, activity, call_me_by = null }] of this.presence_collection.entries()) {
             if (activity) text += `\n${call_me_by || member_name} — ${activity}`;
         }

telegram/telegram-client.js

@@ -9,7 +9,6 @@ const { commands, conditions, definitions, handlers } = require('../commands/han
 const ChatGPTHandler = require('./gpt-handler');
 const { isNotificationMessage: isChannelNotificationMessage } = require('./channel-subscriber.js');
 const { isNotificationMessage: isEventNotificationMessage } = require('./event-subscriber.js');
-// const { isNotificationMessage: isPresenceNotificationMessage } = require('./presence-subscriber.js');
 
 const no_tags_regex = /<\/?[^>]+(>|$)/g;
 
@@ -110,6 +109,13 @@ class TelegramInteraction {
         return this.client.inline_commands;
     }
 
+    /**
+     * @returns {Map<'string', 'string'[]>}
+     */
+    get registered_commands() {
+        return this.client.registered_commands;
+    }
+
     /**
      * @returns {Telegram}
      */
@@ -301,14 +307,14 @@ class TelegramInteraction {
      * @returns {undefined | Promise}
      */
     reply() {
-        if (typeof this.handler[this.command_name] !== 'function') {
+        if (typeof this.handler[this.command_name]?.handler !== 'function') {
             this.logger.warn(`Received nonsense, how did it get here???`);
             return;
         }
 
         this.logger.info(`Received command: ${this.command_name}`);
 
-        this.handler[this.command_name](this.context, this).then(([err, response, callback = () => {}, overrides]) => {
+        this.handler[this.command_name].handler(this.context, this).then(([err, response, callback = () => {}, overrides]) => {
             if (err) {
                 return this._reply(err, overrides).catch((err) => {
                     this.logger.error(`Error while replying with an error message to [${this.command_name}]`, { error: err.stack || err });
@@ -454,25 +460,20 @@ class TelegramInteraction {
         if (matching_command_names.length > 0 && !this.inline_commands.includes(command_name)) {
             let results = [];
             for (const matching_command_name of matching_command_names) {
-                if (commands.includes(matching_command_name)) {
-                    const index = commands.indexOf(matching_command_name);
-                    let line = `/${matching_command_name} `;
-                    if (definitions[index].args && definitions[index].args.length) {
-                        for (const arg of definitions[index].args) {
-                            line += `{${arg.name}${arg.optional ? '?' : ''}} `;
-                        }
-                    }
+                this.registered_commands.forEach((help, command_name) => {
+                    if (command_name !== matching_command_name || !help.length) return;
+                    let line = `/${command_name} ${help.length > 1 ? help.slice(0, -1).join(' ') : ''}`;
                     results.push(
                         this._generateInlineText(
                             line,
                             {
-                                description: definitions[index].description,
+                                description: help.slice(-1)[0],
                                 id: `${matching_command_name}${require('../package.json').version}${process.env.ENV}`,
-                                message_text: `<code>@${this.context.me.username} ${line}</code>\n<i>${definitions[index].description}</i>`,
+                                message_text: `<code>@${this.context.me.username} ${line}</code>\n<i>${help.slice(-1)[0]}</i>`,
                             }
                         )
                     );
-                }
+                });
             }
 
             if (!results.length) {
@@ -509,8 +510,8 @@ class TelegramInteraction {
         this.logger.info(`Received eligible inline query, parsed context [${JSON.stringify(parsed_context)}]`);
 
         (async () => {
-            if (this.handler[command_name]) {
-                return this.handler[command_name](parsed_context, this);
+            if (this.handler[command_name]?.handler) {
+                return this.handler[command_name].handler(parsed_context, this);
             }
             const common_command_index = commands.indexOf(command_name);
             if (common_command_index >= 0) {
@@ -562,6 +563,7 @@ class TelegramClient {
         this.logger = require('../logger').child(this.log_meta);
         this.handler = new TelegramHandler(this);
         this.inline_commands = [];
+        this.registered_commands = new Map();
     }
 
     /**
@@ -572,20 +574,14 @@ class TelegramClient {
      * @param {String?} handle_function_name {command_name} which function from TelegramHandler handles this command
      */
     _registerTelegramCommand(command_name, condition = false, is_inline = false, handle_function_name = command_name) {
-        if (!command_name) {
-            return;
-        }
-
         if (typeof condition === 'function') {
-            condition = condition();
+            if (!condition()) return;
         }
+        else if (!condition)  return;
 
-        if (!condition) {
-            return;
-        }
+        this.handler[handle_function_name]?.help && this.registered_commands.set(command_name, this.handler[handle_function_name].help);
 
         this.client.command(command_name, async (ctx) => new TelegramInteraction(this, handle_function_name, ctx).reply());
-
         if (is_inline) {
             this.inline_commands.push(command_name);
         }
@@ -624,21 +620,53 @@ class TelegramClient {
         // Registering common commands
         commands.forEach((command_name, index) => {
             if (typeof conditions[index] === 'function') {
-                if (!conditions[index]()) {
-                    return;
-                }
+                if (!conditions[index]()) return;
             }
-            else if (!conditions[index]) {
-                return;
+            else if (!conditions[index]) return;
+
+            let args = [];
+            if (definitions?.[index]?.args?.length) {
+                for (const arg of definitions[index].args) {
+                    args.push(`{${arg.name}${arg.optional ? '?' : ''}}`);
+                }
             }
+            this.registered_commands.set(command_name, [args.join(' '), definitions[index].description]);
 
             this.client.command(command_name, async (ctx) => handleCommand(ctx, handlers[index], definitions[index]));
-
             if (definitions[index].is_inline) {
                 this.inline_commands.push(command_name);
             }
         });
 
+        this.client.api.setMyCommands(
+            [...this.registered_commands.entries()]
+                .reduce((acc, [command_name, help]) => {
+                    if (help?.length) {
+                        acc.push({command: command_name, description: help.join(' ')});
+                    }
+                    return acc;
+                }, []),
+            {
+                scope: {
+                    type: 'default'
+                }
+            }
+        )
+        .catch(err => {
+            this.logger.error('Error while registering commands', { error: err.stack || err });
+        })
+        .then(registered => {
+            if (registered) this.logger.debug('Received successful response for commands registering');
+            return this.client.api.getMyCommands({ scope: { type: 'default' } });
+        })
+        .catch(err => {
+            this.logger.error('Error while getting registered commands', { error: err.stack || err });
+        })
+        .then(commands => {
+            this.logger.debug(`Received following registered commands: ${JSON.stringify(commands)}`);
+        })
+        ;
+
         this.client.on('inline_query', async (ctx) => new TelegramInteraction(this, 'inline_query', ctx).answer());
     }
 

telegram/telegram-handler.js

@@ -32,48 +32,51 @@ class TelegramHandler {
         return args;
     }
 
-    /**
-     * `/start` command handler
-     * @returns {[null, String]}
-     */
-    async start() {
-        let message = 'Этот бот что-то может, чтобы узнать что, воспользуйся командой /help';
-        return [null, message];
-    }
+    start = {
+        /**
+         * `/start` command handler
+         * @returns {[null, String]}
+         */
+        handler: async () => {
+            let message = 'Этот бот что-то может, чтобы узнать что, воспользуйся командой /help';
+            return [null, message];
+        },
+        help: []
+    }        
 
-    fizzbuzz = fizzbuzz.bind(this);
+    fizzbuzz = { handler: fizzbuzz.bind(this), help: [] };
 
-    get = get.bind(this);
+    get = { handler: get.bind(this), help: ['{название}', 'Вызвать контент, сохранённый командой /set'] };
 
-    set = set.bind(this);
+    set = { handler: set.bind(this), help: ['{название}', 'Сохранить содержимое сообщения']};
 
-    get_list = getList.bind(this);
+    get_list = { handler: getList.bind(this), help: ['Вызвать список гетов, доступных в этом чате'] };
 
-    del = del.bind(this);
+    del = { handler: del.bind(this), help: ['{название}', 'Удалить гет, доступно только владельцу (если он есть)'] };
 
-    gh = gh.bind(this);
+    gh = { handler: gh.bind(this), help: [] };
 
-    help = help;
+    help = { handler: help, help: ['Вызвать список доступных команд']};
 
-    html = html.bind(this);
+    html = { handler: html.bind(this), help: [] };
 
-    deep = generateImage.bind(this);
+    deep = { handler: generateImage.bind(this), help: ['{описание}', 'Генерирует 4 картинки по описанию (DeepAI)'] };
 
-    info = info.bind(this);
+    info = { handler: info.bind(this), help: ['Вызвать информацию о чате и отправителе'] };
 
-    ytdl = require('./command-handlers/ytdl-handler').ytdl.bind(this);
+    ytdl = { handler: require('./command-handlers/ytdl-handler').ytdl.bind(this), help: [] };
 
-    webapp = require('./command-handlers/webapp-handler').webapp.bind(this);
+    webapp = { handler: require('./command-handlers/webapp-handler').webapp.bind(this), help: [] };
 
-    roundit = require('./command-handlers/roundit-handler').roundit.bind(this);
+    roundit = { handler: require('./command-handlers/roundit-handler').roundit.bind(this), help: ['Превратить видео в кружок'] };
 
-    imagine = require('./command-handlers/imagine-handler').imagine.bind(this);
+    imagine = { handler: require('./command-handlers/imagine-handler').imagine.bind(this), help: ['{описание}', 'Генерирует 4 картинки по описанию (DALL-E)'] };
 
-    new_system_prompt = ChatGPTHandler.handleAdjustSystemPrompt.bind(ChatGPTHandler);
+    new_system_prompt = { handler: ChatGPTHandler.handleAdjustSystemPrompt.bind(ChatGPTHandler), help: ['{промпт}', 'Задать новый системный промпт для ChatGPT и/или проверить, установленный сейчас'] };
 
-    answer = ChatGPTHandler.handleAnswerCommand.bind(ChatGPTHandler);
+    answer = { handler: ChatGPTHandler.handleAnswerCommand.bind(ChatGPTHandler), help: ['{запрос?}', 'Спросить у ChatGPT, можно использовать как реплай'] };
 
-    tree = ChatGPTHandler.handleTreeRequest.bind(ChatGPTHandler);
+    tree = { handler: ChatGPTHandler.handleTreeRequest.bind(ChatGPTHandler), help: ['Запросить контекстное дерево ChatGPT'] };
 }
 
 module.exports = TelegramHandler;