halbot 1995.1.6 → 1995.1.8

package/lib/hal.mjs

@@ -144,7 +144,7 @@ const parseArgs = async (args, ctx) => {
 };
 
 const packMessage = (messages) => messages.map(x => ({
-    message_id: x.message_id, score: x.score,
+    message_id: x.message_id, score: x.score, created_at: x.created_at,
     request: x.received_text, response: x.response_text,
 }));
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "halbot",
   "description": "Just another AI powered Telegram bot, which is simple design, easy to use, extendable and fun.",
-  "version": "1995.1.6",
+  "version": "1995.1.8",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",

package/pipeline/010_broca.mjs

@@ -1,5 +1,5 @@
 import { alan, bot, hal, uoid, utilitas } from '../index.mjs';
-import { paginate } from 'tellegram';
+import { convert, paginate } from 'tellegram';
 
 const _name = 'Broca';
 const [PRIVATE_LIMIT, GROUP_LIMIT] = [60 / 60, 60 / 20].map(x => x * 1000);
@@ -44,26 +44,26 @@ const getExtra = (ctx, options) => {
     return resp;
 };
 
-const resp = async (ctx, text, md, extra) => {
+const resp = async (ctx, text, extra) => {
     // if (ctx._.type === 'inline_query') {
     //     return await ctx.answerInlineQuery([{}, {}]);
     // }
     let resp;
-    if (md) {
-        try {
-            resp = await (extra?.reply_parameters?.message_id
-                ? ctx.replyWithMarkdown(text, { parse_mode, ...extra })
-                : ctx.sendMessage(text, { parse_mode, ...extra }));
-        } catch (err) {
-            log(err);
-            await ctx.timeout();
-        }
+    if (!extra?.noMd) {
+        const txt = extra?.parsed ? text : convert(text);
+        resp = await utilitas.ignoreErrFunc(async (
+        ) => await (extra?.reply_parameters?.message_id
+            ? ctx.sendMessage(txt, { parse_mode, ...extra })
+            : ctx.replyWithMarkdown(txt, { parse_mode, ...extra })), hal.logOptions);
+    }
+    if (!resp) {
+        await ctx.timeout();
+        resp = await utilitas.ignoreErrFunc(
+            async () => await (extra?.reply_parameters?.message_id
+                ? ctx.sendMessage(text, extra) : ctx.reply(text, extra)
+            ), hal.logOptions
+        );
     }
-    resp || (resp = await utilitas.ignoreErrFunc(
-        async () => await (extra?.reply_parameters?.message_id
-            ? ctx.reply(text, extra) : ctx.sendMessage(text, extra)
-        ), hal.logOptions
-    ));
     resp && ctx._.done.push(resp);
     return resp;
 };
@@ -74,22 +74,22 @@ const replyWith = async (ctx, func, src, options) => ctx._.done.push(
     })) : { [getKey(src)]: src }, ctx.getExtra(options))
 );
 
-const edit = async (ctx, lastMsgId, text, md, extra) => {
+const edit = async (ctx, lastMsgId, text, extra) => {
     let resp;
-    if (md) {
-        try {
-            resp = await ctx.telegram.editMessageText(
-                ctx._.chatId, lastMsgId, '', text, { parse_mode, ...extra }
-            );
-        } catch (err) {
-            log(err);
-            await ctx.timeout();
-        }
+    if (!extra?.noMd) {
+        const txt = extra?.parsed ? text : convert(text);
+        resp = await utilitas.ignoreErrFunc(async (
+        ) => await ctx.telegram.editMessageText(
+            ctx._.chatId, lastMsgId, '', txt, { parse_mode, ...extra }
+        ), hal.logOptions);
+    }
+    if (!resp) {
+        await ctx.timeout();
+        resp = await utilitas.ignoreErrFunc(async (
+        ) => await ctx.telegram.editMessageText(
+            ctx._.chatId, lastMsgId, '', text, extra
+        ), hal.logOptions);
     }
-    resp || (resp = await utilitas.ignoreErrFunc(async (
-    ) => await ctx.telegram.editMessageText(
-        ctx._.chatId, lastMsgId, '', text, extra
-    ), hal.logOptions));
     resp && ctx._.done.push(resp);
     return resp;
 };
@@ -121,12 +121,12 @@ const ctxExt = ctx => {
         return str;
     };
     ctx.getExtra = (options) => getExtra(ctx, options);
-    ctx.resp = async (text, md, extra) => await resp(ctx, text, md, extra);
-    ctx.edit = async (lastMsgId, text, md, extra) =>
-        await edit(ctx, lastMsgId, text, md, extra);
+    ctx.resp = async (text, extra) => await resp(ctx, text, extra);
+    ctx.edit = async (lastMsgId, text, extra) =>
+        await edit(ctx, lastMsgId, text, extra);
     ctx.ok = async (message, options) => {
         let pages = paginate(message, options);
-        const extra = ctx.getExtra(options);
+        const extra = { ...ctx.getExtra(options), parsed: true };
         const [pageIds, pageMap] = [[], {}];
         options?.pageBreak || ctx._.done.filter(x => x).map(x => {
             pageMap[x?.message_id] || (pageIds.push(x?.message_id));
@@ -140,22 +140,25 @@ const ctxExt = ctx => {
             if (lastMsgId && pageMap[lastMsgId]?.text === pages[i]) {
                 continue;
             }
-            await (lastMsgId ? ctx.edit(lastMsgId, pages[i], options?.md, _extra) // ongoing, edit
-                : ctx.resp(pages[i], options?.md, _extra));                       // new page, reply
+            await (lastMsgId ? ctx.edit(lastMsgId, pages[i], _extra) // ongoing, edit
+                : ctx.resp(pages[i], _extra));                       // new page, reply
             await ctx.timeout();
         }
         return ctx._.done;
     };
     ctx.err = async (m, opts) => {
         log(m);
-        return await ctx.ok(`⚠️ ${m?.message || m} `, opts);
+        return await ctx.ok(`${bot.EMOJI_WARNING} ${m?.message || m} `, {
+            ...opts, pageBreak: true,
+        });
     };
-    ctx.shouldReply = async text => {
+    ctx.shouldReply = async (text, options) => {
         const should = utilitas.insensitiveHas(hal._?.chatType, ctx._.chatType)
             || ctx._.session?.config?.chatty;
         text = utilitas.isSet(text, true) ? (text || '') : '';
         if (!should || !text) { return should; }
-        return await ctx.ok(text);
+        return await (options?.error
+            ? ctx.err(text, options) : ctx.ok(text, options));
     };
     ctx.finish = () => ctx._.done.unshift(null);
     ctx.complete = async (options) => await ctx.ok(hal.CHECK, options);
@@ -241,10 +244,10 @@ const action = async (ctx, next) => {
     await sessionSet(ctx._.chatId, ctx._.session);
     // fallback response and log
     if (ctx._.done.length) { return; }
-    const errStr = '⚠️ ' + (ctx._.cmd?.cmd
-        ? `Command not found: /${ctx._.cmd.cmd}` : 'No suitable response.');
+    const errStr = ctx._.cmd?.cmd
+        ? `Command not found: /${ctx._.cmd.cmd}` : 'No suitable response.';
     log(`INFO: ${errStr}`);
-    await ctx.shouldReply(errStr);
+    await ctx.shouldReply(errStr, { error: true });
 };
 
 export const { _NEED, name, run, priority, func } = {

package/pipeline/020_cmd.mjs

@@ -68,6 +68,15 @@ const action = async (ctx, next) => {
         case 'clearkb':
             return await ctx.complete({ keyboards: [] });
     }
+    // update commands
+    await utilitas.ignoreErrFunc(async () =>
+        await hal._.bot.telegram.setMyCommands(hal._.cmds.sort((x, y) =>
+            (ctx._.session?.cmds?.[y.command.toLowerCase()]?.touchedAt || 0)
+            - (ctx._.session?.cmds?.[x.command.toLowerCase()]?.touchedAt || 0)
+        ).slice(0, hal.COMMAND_LIMIT), {
+            scope: { type: 'chat', chat_id: ctx._.chatId },
+        }), hal.logOptions
+    );
     // next middleware
     await next();
 };

package/pipeline/030_echo.mjs

@@ -3,7 +3,7 @@ import { bot, hal, utilitas } from '../index.mjs';
 let lorem;
 
 const action = async (ctx, next) => {
-    let resp, md = true;
+    let resp;
     switch (ctx._.cmd.cmd) {
         case 'echo':
             const carry = { ...ctx._ };
@@ -41,17 +41,17 @@ const action = async (ctx, next) => {
                 await ctx.ok(ipsum(), { ...extra, processing: true });
             }
             await ctx.timeout();
-            await ctx.ok(ipsum(), { ...extra, md });
+            await ctx.ok(ipsum(), extra);
             // testing incomplete markdown reply {
-            // await ctx.ok('_8964', { md });
+            // await ctx.ok('_8964', extra);
             // }
             // test pagebreak {
             // await ctx.timeout();
-            // await ctx.ok(ipsum(), { md, pageBreak: true });
+            // await ctx.ok(ipsum(), { pageBreak: true });
             // }
             return;
     }
-    await ctx.ok(resp, { md });
+    await ctx.ok(resp);
 };
 
 export const { _NEED, name, hidden, priority, func, help, cmds } = {

package/pipeline/040_help.mjs

@@ -30,7 +30,7 @@ const action = async (ctx, next) => {
         }
         _help.length && help.push(bot.lines([`*${i.toUpperCase()}*`, ..._help]));
     }
-    await ctx.ok(lines2(help), { md: true });
+    await ctx.ok(lines2(help));
 };
 
 export const { name, priority, func, help, cmds } = {

package/pipeline/080_history.mjs

@@ -35,31 +35,21 @@ const memorize = async (ctx) => {
         }
         await hal._.storage?.client?.upsert?.(hal.table, event, { skipEcho: true });
     }, hal.logOptions);
-    // TODO: 調整，如果命令執行過，應該更新菜單 ！？
-    await utilitas.ignoreErrFunc(async () => await hal._.bot.telegram.setMyCommands([
-        ...hal._.cmds, ...Object.keys(ctx._.message.prompts || {}).map(
-            command => hal.newCommand(command, ctx._.message.prompts[command])
-        )
-    ].sort((x, y) =>
-        (ctx._.message?.cmds?.[y.command.toLowerCase()]?.touchedAt || 0)
-        - (ctx._.message?.cmds?.[x.command.toLowerCase()]?.touchedAt || 0)
-    ).slice(0, hal.COMMAND_LIMIT), {
-        scope: { type: 'chat', chat_id: ctx._.chatId },
-    }), hal.logOptions);
 };
 
 const ctxExt = ctx => {
     ctx.memorize = async () => await memorize(ctx);
     ctx.recall = async (keyword, offset = 0, limit = hal.SEARCH_LIMIT, options = {}) =>
-        await recall(ctx._.chatId, keyword, offset, limit, options);
+        await hal.recall(ctx._.chatId, keyword, offset, limit, options);
     // ctx.getContext = async (offset = 0, limit = hal.SEARCH_LIMIT, options = {}) =>
-    //     await getContext(ctx._.chatId, offset, limit, options);
+    //     await hal.getContext(ctx._.chatId, offset, limit, options);
 };
 
 const action = async (ctx, next) => {
     ctxExt(ctx);
     switch (ctx._.cmd?.cmd) {
         case 'search':
+            // print(ctx.update.callback_query?.message);
             (ctx._.type === 'callback_query')
                 && await ctx.deleteMessage(ctx._.message.message_id);
             const regex = '[-—]+skip=[0-9]*';
@@ -71,27 +61,32 @@ const action = async (ctx, next) => {
             const result = await ctx.recall(keywords, offset);
             for (const i in result) {
                 const content = bot.lines([
-                    '```↩️', compactLimit(result[i].response_text), '```',
+                    '```↩️', compactLimit(result[i].response), '```',
                     [`${utilitas.getTimeIcon(result[i].created_at)} ${result[i].created_at.toLocaleString()}`,
                     `🏆 ${(Math.round(result[i].score * 100) / 100).toFixed(2)}`].join('  '),
                 ]);
-                await ctx.resp(content, true, {
+                await ctx.resp(content, {
                     reply_parameters: {
                         message_id: result[i].message_id,
                     }, disable_notification: ~~i > 0,
                 });
                 await ctx.timeout();
             }
-            // TODO: NEED MORE DEBUG
-            result.length === hal.SEARCH_LIMIT && await ctx.resp(
-                '___', true, ctx.getExtra({
+            const options = {
+                reply_parameters: {
+                    message_id: ctx.update.callback_query?.message?.reply_to_message?.message_id
+                        || ctx._.message.message_id,
+                }
+            };
+            result.length === hal.SEARCH_LIMIT ? await ctx.resp(
+                '___', ctx.getExtra({
                     buttons: [{
                         label: '🔍 More',
                         text: `/search@${ctx.botInfo.username} ${keywords} `
                             + `--skip=${offset + result.length}`,
-                    }]
-                }));
-            result.length || await ctx.err('No more records.');
+                    }],
+                    ...options,
+                })) : await ctx.err('No more records.', options);
             break;
         default:
             await next();

package/pipeline/090_ai.mjs

@@ -17,7 +17,7 @@ const listAIs = async ctx => {
             : ''}${x.label}`,
         text: `/set --ai=${x.id}`,
     }));
-    return await ctx.ok(message, { lastMessageId, buttons, md: true });
+    return await ctx.ok(message, { lastMessageId, buttons });
 };
 
 const action = async (ctx, next) => {

package/pipeline/100_chat.mjs

@@ -20,7 +20,7 @@ const action = async (ctx, next) => {
         }
         sResp = await ctx.ok(resp.text, {
             ...ctx._.keyboards ? { keyboards: ctx._.keyboards } : {},
-            md: true, ...extra, ...options || {},
+            ...extra, ...options || {},
         });
         lastSent = curTime;
         return sResp;