halbot 1995.1.2 → 1995.1.4

package/lib/hal.mjs

@@ -2,6 +2,7 @@ import { alan, bot, callosum, dbio, storage, utilitas, } from 'utilitas';
 import { join } from 'path';
 import { parseArgs as _parseArgs } from 'node:util';
 import { readdirSync } from 'fs';
+import { ignoreErrFunc } from 'utilitas/lib/utilitas.mjs';
 
 // 👇 https://core.telegram.org/bots/faq#my-bot-is-hitting-limits-how-do-i-avoid-this
 const [ // https://limits.tginfo.me/en
@@ -111,30 +112,21 @@ const json = obj => bot.lines([
 ]);
 
 const establish = module => {
-    if (!module.run) { return; }
     assert(module?.func, 'Pipeline function is required.', 500);
     _.pipeline[module.name || (module.name = uuidv4())] = {
-        args: module.args || {},
-        cmds: module.cmds || {},
-        cmdx: module.cmdx,
-        help: module.help || '',
+        help: module.help || '', args: module.args || {},
         hidden: !!module.hidden,
     };
     _.args = { ..._.args, ...module.args || {} };
-    for (let sub of ['cmds', 'cmdx']) {
-        Object.keys(module[sub] || {}).map(command => _.cmds.push(
-            newCommand(command, module[sub][command])
-        ));
-    }
+    Object.keys(module?.cmds || {}).map(command => _.cmds.push(
+        newCommand(command, module?.cmds[command])
+    ));
     log(`Establishing: ${module.name} (${module.priority})`, { force: true });
-    return _.bot.use(utilitas.countKeys(module.cmds) && !module.cmdx ? async (ctx, next) => {
-        for (let c in module.cmds) {
-            if (utilitas.insensitiveCompare(ctx._?.cmd?.cmd, c)) {
-                return await module.func(ctx, next);
-            }
-        }
-        return await next();
-    } : module.func);
+    return _.bot.use(utilitas.countKeys(module.cmds) ? (async (ctx, next) =>
+        await (utilitas.insensitiveHas(
+            Object.keys(module.cmds), ctx._?.cmd?.cmd
+        ) || module.run ? module.func(ctx, next) : next())
+    ) : module.func);
 };
 
 const parseArgs = async (args, ctx) => {
@@ -269,6 +261,11 @@ const extendSessionStorage = storage => storage && storage.client && {
     set: async (id, session, options) => await storage.set(id, session, options),
 };
 
+const subconscious = {
+    name: 'Subconscious', run: true, priority: 0,
+    func: async (_, next) => ignoreErrFunc(next, logOptions),    // non-blocking
+};
+
 const init = async (options) => {
     if (options) {
         const { ais } = await alan.initChat({
@@ -302,7 +299,6 @@ const init = async (options) => {
                 storage: options?.storage,
                 supportedMimeTypes,
             };
-            const mods = [];
             if (_.storage) {
                 assert([
                     dbio.MYSQL, dbio.POSTGRESQL, storage.FILE
@@ -322,6 +318,7 @@ const init = async (options) => {
                     } catch (e) { console.error(e); }
                 }
             }
+            const mods = [subconscious];
             for (let pipeline of utilitas.ensureArray(options?.pipelinePath || [])) {
                 log(`PIPELINE: ${pipeline}`);
                 const files = (readdirSync(pipeline) || []).filter(

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.2",
+  "version": "1995.1.4",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",

package/pipeline/010_broca.mjs

@@ -135,11 +135,11 @@ const ctxExt = ctx => {
         for (let i in pages) {
             const lastPage = ~~i === pages.length - 1;
             const shouldExtra = options?.lastMessageId || lastPage;
-            if (options?.onProgress && !options?.lastMessageId
+            if (options?.processing && !options?.lastMessageId
                 && pageMap[pageIds[~~i]]?.text === pages[i]) { continue; }
-            if (options?.onProgress && !pageIds[~~i]) {                     // progress: new page, reply text
+            if (options?.processing && !pageIds[~~i]) {                     // progress: new page, reply text
                 await ctx.resp(pages[i], false, extra);
-            } else if (options?.onProgress) {                               // progress: ongoing, edit text
+            } else if (options?.processing) {                               // progress: ongoing, edit text
                 await ctx.edit(
                     pageIds[~~i], pages[i], false, shouldExtra ? extra : {}
                 );

package/pipeline/020_cmd.mjs

@@ -72,6 +72,12 @@ const action = async (ctx, next) => {
     await next();
 };
 
-export const { name, run, priority, func, cmdx } = {
-    name: _name, run: true, priority: 20, func: action, cmdx: {}
+export const { name, run, hidden, priority, func, help, cmds } = {
+    name: _name, run: true, hidden: true, priority: 20, func: action,
+    help: bot.lines([
+        '¶ Commands handler.',
+    ]),
+    cmds: {
+        clearkb: 'Clear keyboard: /clearkb',
+    },
 };

package/pipeline/030_echo.mjs

@@ -38,7 +38,7 @@ const action = async (ctx, next) => {
             await ctx.ok(bot.EMOJI_THINKING);
             for (let i = 0; i < 2; i++) {
                 await ctx.timeout();
-                await ctx.ok(ipsum(), { ...extra, onProgress: true });
+                await ctx.ok(ipsum(), { ...extra, processing: true });
             }
             await ctx.timeout();
             await ctx.ok(ipsum(), { ...extra, md });
@@ -54,9 +54,9 @@ const action = async (ctx, next) => {
     await ctx.ok(resp, { md });
 };
 
-export const { _NEED, name, run, hidden, priority, func, help, cmds } = {
+export const { _NEED, name, hidden, priority, func, help, cmds } = {
     _NEED: ['lorem-ipsum'],
-    name: 'Echo', run: true, hidden: true, priority: 30, func: action,
+    name: 'Echo', hidden: true, priority: 30, func: action,
     help: bot.lines([
         '¶ Basic behaviors for debug only.',
     ]),

package/pipeline/040_help.mjs

@@ -10,14 +10,11 @@ const action = async (ctx, next) => {
         if (hal._.pipeline[i].help) {
             _help.push(hal._.pipeline[i].help);
         }
-        const cmdsx = {
-            ...hal._.pipeline[i].cmds || {},
-            ...hal._.pipeline[i].cmdx || {},
-        };
-        if (utilitas.countKeys(cmdsx)) {
+        const cmds = hal._.pipeline[i].cmds || {};
+        if (utilitas.countKeys(cmds)) {
             _help.push(bot.lines([
                 '_🪄 Commands:_',
-                ...Object.keys(cmdsx).map(x => `- /${x}: ${cmdsx[x]}`),
+                ...Object.keys(cmds).map(x => `- /${x}: ${cmds[x]}`),
             ]));
         }
         if (utilitas.countKeys(hal._.pipeline[i].args)) {
@@ -36,8 +33,8 @@ const action = async (ctx, next) => {
     await ctx.ok(lines2(help), { md: true });
 };
 
-export const { name, run, priority, func, help, cmds } = {
-    name: 'Help', run: true, priority: 40, func: action,
+export const { name, priority, func, help, cmds } = {
+    name: 'Help', priority: 40, func: action,
     help: bot.lines([
         '¶ Basic syntax of this document:',
         'Scheme for commands: /`COMMAND`: `DESCRIPTION`',

package/pipeline/060_config.mjs

@@ -11,7 +11,7 @@ const ctxExt = ctx => {
 const action = async (ctx, next) => {
     ctxExt(ctx);
     let parsed = null;
-    switch (ctx._.cmd?.cmd) {
+    switch (ctx._.cmd.cmd) {
         case 'lang':
             if (!ctx._.cmd.args) {
                 return await ctx.ok('Please specify a language.');
@@ -54,8 +54,8 @@ const action = async (ctx, next) => {
     await next();
 };
 
-export const { name, run, priority, func, help, cmdx, args } = {
-    name: 'Config', run: true, priority: 60, func: action,
+export const { name, priority, func, help, cmds, args } = {
+    name: 'Config', priority: 60, func: action,
     help: bot.lines([
         '¶ Configure the bot by UNIX/Linux CLI style.',
         'Using [node:util.parseArgs](https://nodejs.org/api/util.html#utilparseargsconfig) to parse arguments.',
@@ -64,12 +64,14 @@ export const { name, run, priority, func, help, cmdx, args } = {
         '¶ When enabled, the bot will speak out the answer if available.',
         'Example 1: /set --tts on',
         'Example 2: /set --tts off',
-    ]), cmdx: {
+    ]),
+    cmds: {
         lang: 'Set your default language: /lang `LANG`',
         toggle: 'Toggle configurations. Only works for boolean values.',
         set: 'Usage: /set --`OPTION` `VALUE` -`SHORT`',
         reset: 'Reset configurations.',
-    }, args: {
+    },
+    args: {
         chatty: {
             type: 'string', short: 'c', default: hal.ON,
             desc: `\`(${hal.BINARY_STRINGS.join(', ')})\` Enable/Disable chatty mode.`,

package/pipeline/080_history.mjs

@@ -99,13 +99,14 @@ const action = async (ctx, next) => {
     }
 };
 
-export const { name, run, priority, func, help, cmdx } = {
+export const { name, run, priority, func, help, cmds } = {
     name: 'History', run: true, priority: 80, func: action,
     help: bot.lines([
         '¶ Search history.',
         'Example 1: /search Answer to the Ultimate Question',
         'Example 2: /search Answer to the Ultimate Question --skip=10',
-    ]), cmdx: {
+    ]),
+    cmds: {
         search: 'Usage: /search `ANYTHING` --skip=`OFFSET`',
-    }
+    },
 };

package/pipeline/090_ai.mjs

@@ -5,17 +5,19 @@ const TOP = 'top';
 
 const listAIs = async ctx => {
     const lastMessageId = ctx?.update?.callback_query?.message?.message_id;
-    const message = `Features:\n`
-        + hal.uList(Object.entries(alan.FEATURE_ICONS).map(
-            x => `${x[1]} ${x[0]}`
-        )) + `\n\nAI${ais.length > 0 ? 's' : ''}:\n`;
+    const message = `*Time:* \n${new Date().toLocaleString()}\n\n`
+        + `*Features:*\n` + hal.uList(Object.entries(alan.FEATURE_ICONS).filter(
+            x => x[0] !== 'hidden'
+        ).map(
+            x => `${x[1]} \`${x[0]}\``
+        )) + `\n\n*AI${ais.length > 0 ? 's' : ''}:*\n`;
     const buttons = ais.map((x, i) => ({
         label: `${ctx._.session.config?.ai === x.id
             || (!ctx._.session.config?.ai && i === 0) ? `${hal.CHECK} `
-            : ''}${x.name}: ${x.features}`,
+            : ''}${x.label}`,
         text: `/set --ai=${x.id}`,
     }));
-    return await ctx.ok(message, { lastMessageId, buttons });
+    return await ctx.ok(message, { lastMessageId, buttons, md: true });
 };
 
 const action = async (ctx, next) => {
@@ -43,11 +45,8 @@ const validateAi = async (val, ctx) => {
     utilitas.throwError('No AI engine matched.');
 };
 
-export const { name, run, priority, func, help, args, cmdx } = {
-    name: 'AI',
-    run: true,
-    priority: 90,
-    func: action,
+export const { name, run, priority, func, help, args, cmds } = {
+    name: 'AI', run: true, priority: 90, func: action,
     help: bot.lines([
         '¶ Set initial prompt to the AI model.',
         "Tip 1: Set `hello=''` to reset to default initial prompt.",
@@ -59,6 +58,10 @@ export const { name, run, priority, func, help, args, cmdx } = {
         'Tip 5: `/[AI_ID]` Tell me a joke.',
         'Tip 6: `/all` Use the top 3 AI models simultaneously, for current prompt.',
     ]),
+    cmds: {
+        ai: 'List all available AIs.',
+        all: 'Use the top 3 AI models simultaneously: /all Say hello to all AIs!',
+    },
     args: {
         hello: {
             type: 'string', short: 's', default: 'Hello!',
@@ -70,8 +73,4 @@ export const { name, run, priority, func, help, args, cmdx } = {
             validate: validateAi,
         },
     },
-    cmdx: {
-        ai: 'List all available AIs.',
-        all: 'Use the top 3 AI models simultaneously: /all Say hello to all AIs!',
-    }
 };

package/pipeline/100_chat.mjs

@@ -3,63 +3,53 @@ import { alan } from '../index.mjs';
 const _name = 'Chat';
 const log = (c, o) => utilitas.log(c, _name, { time: 1, ...o || {} });
 
-const generate = async (ctx) => {
-    try {
-        let [resp, extra, lock, sResp, lastMsg, lastSent] =
-            [null, { buttons: [] }, 1000 * 5, null, null, 0];
-        const ok = async options => {
-            const curTime = Date.now();
-            if (options?.processing && (
-                curTime - lastSent < ctx._.limit || lastMsg === resp.text
-            )) { return; }
-            [lastSent, lastMsg] = [curTime + lock, resp.text];
-            if (!options?.processing) {
-                (resp.annotations || []).map((x, i) => extra.buttons.push({
-                    label: `${i + 1}. ${x.title}`, url: x.url,
-                }));
-            }
-            sResp = await ctx.ok(resp.text, {
-                ...ctx._.keyboards ? { keyboards: ctx._.keyboards } : {},
-                md: true, ...extra, ...options || {},
-            });
-            lastSent = curTime;
-            return sResp;
-        };
-        resp = await alan.talk(ctx._.text, {
-            ...ctx._, sessionId: ctx._.chatId, // THIS LINE IS IMPORTANT
-            stream: async rsp => { resp = rsp; ok({ processing: true }); }, // Never await, it will block the stream.
-        });
-        for (let image of resp?.images || []) {
-            await ctx.timeout();
-            await ctx.image(image.data, { caption: image.caption });
-        }
-        for (let video of resp?.videos || []) {
-            await ctx.timeout();
-            await ctx.video(video.data, { caption: video.caption });
-        }
-        for (let audio of resp?.audios || []) {
-            await ctx.timeout();
-            await ctx.audio(audio.data, { caption: audio.caption });
-        }
-        // print(resp);
-        await resp.text.trim() ? ok({ processing: false })
-            : ctx.deleteMessage(ctx._.done[0].message_id);
-        ctx._.request = resp.request;
-        ctx._.response = resp.response;
-        ctx.memorize && await ctx.memorize();
-    } catch (err) { log(err); }
-};
-
 const action = async (ctx, next) => {
-    ctx.finish();
+    if (!ctx._.text && !ctx._.collected.length) { return await next(); }
+    let [resp, extra, lock, sResp, lastMsg, lastSent] =
+        [null, { buttons: [] }, 1000 * 5, null, null, 0];
+    const ok = async options => {
+        const curTime = Date.now();
+        if (options?.processing && (
+            curTime - lastSent < ctx._.limit || lastMsg === resp.text
+        )) { return; }
+        [lastSent, lastMsg] = [curTime + lock, resp.text];
+        if (!options?.processing) {
+            (resp.annotations || []).map((x, i) => extra.buttons.push({
+                label: `${i + 1}. ${x.title}`, url: x.url,
+            }));
+        }
+        sResp = await ctx.ok(resp.text, {
+            ...ctx._.keyboards ? { keyboards: ctx._.keyboards } : {},
+            md: true, ...extra, ...options || {},
+        });
+        lastSent = curTime;
+        return sResp;
+    };
+    resp = await alan.talk(ctx._.text, {
+        ...ctx._, sessionId: ctx._.chatId, // THIS LINE IS IMPORTANT
+        stream: async rsp => { resp = rsp; ok({ processing: true }); }, // Never await, it will block the stream.
+    });
+    for (let image of resp?.images || []) {
+        await ctx.timeout();
+        await ctx.image(image.data, { caption: image.caption });
+    }
+    for (let video of resp?.videos || []) {
+        await ctx.timeout();
+        await ctx.video(video.data, { caption: video.caption });
+    }
+    for (let audio of resp?.audios || []) {
+        await ctx.timeout();
+        await ctx.audio(audio.data, { caption: audio.caption });
+    }
+    // print(resp);
+    await resp.text.trim() ? ok({ processing: false })
+        : ctx.deleteMessage(ctx._.done[0].message_id);
+    ctx._.request = resp.request;
+    ctx._.response = resp.response;
+    ctx.memorize && await ctx.memorize();
     await next();
-    if (!ctx._.text && !ctx._.collected.length) { return; }
-    generate(ctx);
 };
 
 export const { name, run, priority, func } = {
-    name: _name,
-    run: true,
-    priority: 100,
-    func: action,
+    name: _name, run: true, priority: 100, func: action,
 };