halbot 1989.6.37 → 1990.1.2

package/README.md

@@ -88,7 +88,27 @@ All supported configuration fields:
     // Defaule: ['private', 'mention'].
     // By default, it will only reply to `private` chats and group `mention`s.
     // Adding 'group' or 'channel' may cause too much disturbance.
-    "chatType": ["mention", "private"]
+    "chatType": ["mention", "private"],
+
+    // OPTIONAL, object.
+    // Session storage, support MariaDB/MySQL and Redis for now.
+    // If omitted, the bot will use memory storage and sync to this file.
+    // Example: (Compatibility: https://github.com/sidorares/node-mysql2)
+    "session": {
+        type: [['MARIADB' || 'MYSQL']],
+        host: [[DATABASE HOST]],
+        database: [[DATABASE NAME]],
+        user: [[DATABASE USER]],
+        password: [[DATABASE PASSWORD]],
+        ...[[OTHER DATABASE OPTIONS]],
+    },
+    // OR: (Compatibility: https://github.com/luin/ioredis)
+    "session": {
+        type: 'REDIS',
+        host: [[REDIS HOST]],
+        password: [[REDIS PASSWORD]],
+        ...[[OTHER REDIS OPTIONS]],
+    },
 
 }
 ```
@@ -161,6 +181,13 @@ const config = {
     //    | };
     skillPath: './skills',
 
+    // OPTIONAL, object.
+    // Using customized callback as storage engine.
+    session: {
+        get: async (chatId) => { /* return session object by chatId. */ },
+        set: async (chatId, session) => { /* save session object by chatId. */ },
+    },
+
 };
 
 await halbot(config);

package/bin/halbot.mjs

@@ -1,32 +1,34 @@
 #!/usr/bin/env node
 
-import { storage, utilitas } from 'utilitas';
+import { cache, dbio, memory, storage, utilitas } from 'utilitas';
 import halbot from '../index.mjs';
 
 const debug = utilitas.humanReadableBoolean(process.env['DEBUG']);
 const log = content => utilitas.log(content, import.meta.url);
+const getConfig = async () => (await storage.getConfig())?.config;
 
-// Disabled for current version.
-// const args = await (async (options) => {
-//     const { parseArgs } = await import('node:util');
-//     if (parseArgs) { // https://kgrz.io/node-has-native-arg-parsing.html
-//         const { values } = parseArgs({
-//             options: {
-//                 // xxx: { type: 'string', short: 'x', default: '' }
-//             },
-//             ...options || {},
-//         });
-//         return values;
-//     }
-//     let args = {}; // simple fallback for node version < 19
-//     process.argv.map(arg => {
-//         const item = arg.replace(/^\-*([^=]*)=(.*)$/ig, '$1<,>$2').split('<,>');
-//         item.length > 1 && (args[item[0]] = item[1]);
-//     });
-//     return args;
-// })();
+let session = {
+    get: async key => (await getConfig())?.sessions?.[key],
+    set: async (k, v) => await storage.setConfig({ sessions: { [k]: v } }),
+};
 
 try {
-    const { config } = await storage.getConfig();
-    await halbot(config);
+    const { filename, config } = await storage.getConfig();
+    assert(utilitas.countKeys(config), `Error loading config from ${filename}.`);
+    const sessionType = utilitas.trim(config.session?.type, { case: 'UP' });
+    if (config.session?.type) { delete config.session.type; }
+    switch (sessionType) {
+        case 'MARIADB': case 'MYSQL':
+            await dbio.init(config.session);
+            await memory.init();
+            session = memory;
+            break;
+        case 'REDIS':
+            await cache.init(config.session);
+            session = cache;
+            break;
+        default:
+            config.session && utilitas.throwError('Invalid session config.');
+    }
+    await halbot({ ...config, session });
 } catch (err) { debug ? utilitas.throwError(err) : log(err); }

package/index.mjs

@@ -2,16 +2,37 @@ import { bot, hal, shot, speech, utilitas } from 'utilitas';
 import { parse } from 'csv-parse/sync';
 
 await utilitas.locate(utilitas.__(import.meta.url, 'package.json'));
+const log = content => utilitas.log(content, 'halbot');
 const skillPath = utilitas.__(import.meta.url, 'skills');
-const MAX_MENU_LENGTH = 32;
 
 const promptSource = new Set([
-    'https://raw.githubusercontent.com/f/awesome-chatgpt-prompts/main/prompts.csv',
+    // 'https://raw.githubusercontent.com/f/awesome-chatgpt-prompts/main/prompts.csv',
+    'https://raw.githubusercontent.com/f/awesome-chatgpt-prompts/4fa40ad4067dce08a007f1c07562fac9dcbfcd1d/prompts.csv',
 ]);
 
+const fetchPrompts = async () => {
+    const prompts = {};
+    for (let source of promptSource) {
+        try {
+            const resp = (await shot.get(source)).content;
+            const pmts = parse(resp, { columns: true, skip_empty_lines: true });
+            assert(pmts?.length, `Failed to load external prompts: ${source}.`);
+            pmts.filter(x => x.act && x.prompt).map(x => {
+                const command = utilitas.ensureString(
+                    x.act, { case: 'SNAKE' }
+                ).slice(0, bot.MAX_MENU_LENGTH);
+                prompts[command] = { command, ...x };
+            });
+        } catch (err) { log(err?.message || err); }
+    }
+    log(`Awesome ChatGPT Prompts: fetch ${utilitas.countKeys(prompts)} items.`);
+    return prompts;
+};
+
 const init = async (options) => {
     assert(options?.telegramToken, 'Telegram Bot API Token is required.');
-    const [ai, _speech, prompts] = [{}, {}, {}];
+    const [pkg, ai, _speech] = [await utilitas.which(), {}, {}];
+    const info = bot.lines([`[🤖️ ${pkg.title}](${pkg.homepage})`, pkg.description]);
     if (options?.googleApiKey) {
         await speech.init({ apiKey: options?.googleApiKey, tts: true, stt: true });
         Object.assign(_speech, { stt: speech.stt, tts: speech.tts });
@@ -26,35 +47,21 @@ const init = async (options) => {
             provider: 'BING', clientOptions: { userToken: options.bingToken },
         });
     }
-    utilitas.ensureArray(options?.prompts).filter(x => x).map(promptSource.add);
-    for (let source of promptSource) {
-        try {
-            const resp = (await shot.get(source)).content;
-            const pmts = parse(resp, { columns: true, skip_empty_lines: true });
-            assert(pmts?.length, `Failed to load external prompts: ${source}.`);
-            pmts.filter(x => x.act && x.prompt).map(x => {
-                const cmd = utilitas.ensureString(x.act, { case: 'SNAKE' });
-                prompts[cmd.slice(0, MAX_MENU_LENGTH)]
-                    = { description: x.act, prompt: x.prompt }
-            });
-        } catch (err) { utilitas.log(err?.message || err); }
-    }
     assert(utilitas.countKeys(ai), 'No AI provider is configured.');
     const _bot = await bot.init({
+        info: options?.info || info,
         ai, auth: options?.auth,
         botToken: options?.telegramToken,
         chatType: options?.chatType,
         homeGroup: options?.homeGroup,
         magicWord: options?.magicWord,
         private: options?.private,
-        prompts, provider: 'telegram',
+        provider: 'telegram',
+        session: options?.session,
         skillPath: options?.skillPath || skillPath,
         speech: _speech,
     });
-    // https://limits.tginfo.me/en
-    await _bot.telegram.setMyCommands(Object.keys(prompts).slice(0, 100).map(
-        command => ({ command, description: prompts[command].description })
-    ));
+    _bot._.prompts = await fetchPrompts();
     return _bot;
 };
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "halbot",
-  "description": "Just another ChatGPT/Bing Telegram bob.",
-  "version": "1989.6.37",
+  "description": "Just another ChatGPT/Bing Chat Telegram bob, which is simple design, easy to use, extendable and fun.",
+  "version": "1990.1.2",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
   "engines": {
-    "node": ">=18.x"
+    "node": ">=19.x"
   },
   "main": "index.mjs",
   "bin": {
@@ -31,9 +31,11 @@
   "dependencies": {
     "@google-cloud/speech": "^5.4.0",
     "@google-cloud/text-to-speech": "^4.2.1",
-    "@waylaidwanderer/chatgpt-api": "^1.33.1",
+    "@waylaidwanderer/chatgpt-api": "^1.34.0",
     "csv-parse": "^5.3.6",
+    "ioredis": "^5.3.1",
+    "mysql2": "^3.2.0",
     "telegraf": "^4.12.2",
-    "utilitas": "^1992.4.46"
+    "utilitas": "^1992.4.70"
   }
 }

package/skills/ai-chat.mjs

@@ -0,0 +1,64 @@
+import { utilitas } from 'utilitas';
+
+const onProgress = { onProgress: true };
+const [YOU, BOT, LN2] = ['😸 You:', '🤖️ ', '\n\n'];
+const [joinL1, joinL2] = [a => a.join(`${LN2}---${LN2}`), a => a.join(LN2)];
+const enrich = name => name === 'Bing' ? `${name} (Sydney)` : name;
+const log = content => utilitas.log(content, import.meta.url);
+
+const action = async (ctx, next) => {
+    if (!ctx.text) { return await next(); }
+    const [msgs, tts, pms, extra] = [{}, {}, [], {}];
+    let [lastMsg, lastSent] = ['', 0];
+    const packMsg = options => {
+        const packed = [...ctx.overwrite ? [joinL2([YOU, ctx.overwrite])] : []];
+        const source = options?.tts ? tts : msgs;
+        ctx.selectedAi.map(n => packed.push(joinL2([
+            ...ctx.multiAi || !ctx.isDefaultAi(n) || ctx.overwrite ? [`${BOT}${enrich(n)}:`] : [],
+            options?.onProgress ? (
+                source[n] ? `${source[n].trim()} █` : '💬'
+            ) : (source[n] || ''),
+        ])));
+        return joinL1(packed);
+    };
+    const ok = async options => {
+        const [curTime, curMsg] = [Date.now(), packMsg(options)];
+        if (options?.onProgress && (
+            curTime - lastSent < ctx.limit || lastMsg === curMsg
+        )) { return; }
+        [lastSent, lastMsg] = [curTime, curMsg];
+        return await ctx.ok(curMsg, { md: true, ...options || {}, ...extra });
+    };
+    await ok(onProgress);
+    for (let n of ctx.selectedAi) {
+        pms.push((async () => {
+            try {
+                const resp = await ctx._.ai[n].send(
+                    ctx.text, { session: ctx.chatId }, tkn => {
+                        msgs[n] = `${(msgs[n] || '')}${tkn}`;
+                        ok(onProgress);
+                    }
+                );
+                msgs[n] = ctx.session.config?.render === false ? resp.response : resp.responseRendered;
+                tts[n] = resp.spokenText;
+                extra.buttons = resp?.suggestedResponses?.map?.(label => ({
+                    label, text: `/bing ${label}`,
+                }));
+            } catch (err) {
+                msgs[n] = err?.message || err;
+                tts[n] = msgs[n];
+                log(err);
+            }
+        })());
+    }
+    await Promise.all(pms);
+    await ok();
+    ctx.tts = packMsg({ tts: true });
+    await next();
+};
+
+export const { run, priority, func } = {
+    run: true,
+    priority: 60,
+    func: action,
+};

package/skills/ai-command.mjs

@@ -0,0 +1,40 @@
+import { bot, utilitas } from 'utilitas';
+
+const action = async (ctx, next) => {
+    const allAi = Object.keys(ctx._.ai);
+    switch (ctx.cmd.cmd) {
+        case 'all':
+            ctx.selectedAi = allAi;
+            ctx.multiAi = ctx.selectedAi.length > 1;
+            ctx.text = ctx.cmd.args || ctx._.hello;
+            break;
+        case 'bing':
+            assert(utilitas.insensitiveHas(allAi, 'bing'), 'Bing is not available.');
+            ctx.selectedAi = ['Bing'];
+            ctx.text = ctx.cmd.args || ctx._.hello;
+            break;
+        case 'chatgpt':
+            assert(utilitas.insensitiveHas(allAi, 'chatgpt'), 'ChatGPT is not available.');
+            ctx.selectedAi = ['ChatGPT'];
+            ctx.text = ctx.cmd.args || ctx._.hello;
+            break;
+    }
+    await next();
+};
+
+export const { run, priority, func, help, cmds } = {
+    run: true,
+    priority: 20,
+    func: action,
+    help: bot.lines([
+        'Useful commands for AI conversation.',
+        'Example 1: `/chatgpt Say hello to ChatGPT!`',
+        'Example 2: `/bing Say hello to Bing!`',
+        'Example 3: `/all Say hello to all AI engines!`',
+    ]),
+    cmds: {
+        all: 'Use all AI engines simultaneously temporary.',
+        bing: 'Use Bing as temporary AI engine.',
+        chatgpt: 'Use ChatGPT as temporary AI engine.',
+    },
+};

package/skills/ai-select.mjs

@@ -0,0 +1,57 @@
+import { bot, utilitas } from 'utilitas';
+
+let configuredAi;
+
+const action = async (ctx, next) => {
+    ctx.firstAi = (configuredAi = Object.keys(ctx._.ai))[0];
+    switch (ctx.session.config?.ai) {
+        case '.': ctx.selectedAi = [ctx.firstAi]; break;
+        case '@': ctx.selectedAi = configuredAi; break;
+        default: ctx.selectedAi = [configuredAi.includes(ctx.session.config?.ai)
+            ? ctx.session.config?.ai : ctx.firstAi];
+    }
+    ctx.multiAi = ctx.selectedAi.length > 1;
+    ctx.isDefaultAi = name => name === ctx.firstAi;
+    ctx.clear = () => (ctx.selectedAi || []).map(n => {
+        ctx._.ai[n].clear(ctx.chatId);
+        ctx.text = ctx._.hello;
+    });
+    await next();
+};
+
+const validate = val => {
+    assert(configuredAi, 'Preparing data for this option. Please try later.');
+    for (let name of [...configuredAi, '.', '@']) {
+        if (utilitas.insensitiveCompare(val, name)) { return name; }
+    }
+    utilitas.throwError('No AI engine matched.');
+};
+
+export const { run, priority, func, help, args } = {
+    run: true,
+    priority: 10,
+    func: action,
+    help: bot.lines([
+        'Config AI engine.',
+        'Set `ai`=`.` to use default AI engine.',
+        'Set `ai`=`@` to use all AI engines simultaneously.',
+        'Example 1: `/set --ai ChatGPT`',
+        'Example 2: `/set --ai Bing`',
+        'Example 3: `/set --ai .`',
+        'Example 4: `/set --ai @`',
+        'Example 5: `/set --render on`',
+        'Example 6: `/set --render off`',
+    ]),
+    args: {
+        ai: {
+            type: 'string', short: 'a', default: '',
+            desc: "`(ChatGPT, Bing, ., @)` Select AI engine.",
+            validate,
+        },
+        render: {
+            type: 'string', short: 'r', default: 'on',
+            desc: '`(on, off)` Enable/Disable enhanced output rendering.',
+            validate: utilitas.humanReadableBoolean,
+        },
+    },
+};

package/skills/execute.mjs

@@ -0,0 +1,18 @@
+import { bot, shot, utilitas } from 'utilitas';
+
+const action = async (ctx, next) => {
+    let prompt = ctx.session.prompts?.[ctx.cmdExt?.cmd] || (
+        ctx._.prompts[ctx.cmdExt?.cmd] && ctx._.prompts[ctx.cmdExt.cmd].prompt
+    );
+    if (prompt) {
+        ctx.clear();
+        ctx.overwrite = ctx.text = prompt;
+    }
+    await next();
+};
+
+export const { run, priority, func, help, cmds } = {
+    run: true,
+    priority: 40,
+    func: action,
+};

package/skills/prompt.mjs

@@ -0,0 +1,81 @@
+import { bot, utilitas } from 'utilitas';
+
+const ACP = '[🧠 Awesome ChatGPT Prompts](https://github.com/f/awesome-chatgpt-prompts)';
+
+const action = async (ctx, next) => {
+    ctx.session.prompts || (ctx.session.prompts = {});
+    switch (ctx.cmd.cmd) {
+        case 'prompts':
+            const prompts = bot.lines2(Object.keys(ctx.session.prompts || {}).map(
+                x => bot.lines([`- /${x}`, ctx.session.prompts[x]])
+            ));
+            await ctx.paging(prompts || 'No custom prompts.');
+            break;
+        case 'add':
+            const arrText = (ctx.cmd.args || '').split('\n');
+            const subArrText = arrText[0].split('>');
+            const cmd = utilitas.ensureString(
+                subArrText[0], { case: 'SNAKE' }
+            ).slice(0, bot.MAX_MENU_LENGTH);
+            const prompt = bot.lines([subArrText.slice(1).join(' '), ...arrText.slice(1)]).trim();
+            if (cmd && prompt) {
+                ctx.session.prompts[cmd] = prompt;
+                await ctx.ok(`Prompt added: /${cmd}`);
+            } else {
+                await ctx.ok('Invalid command or prompt.');
+            }
+            break;
+        case 'del':
+            if (ctx.session.prompts[ctx.cmd.args]) {
+                delete ctx.session.prompts[ctx.cmd.args];
+                await ctx.complete();
+            } else {
+                await ctx.ok('Prompt not found.');
+            }
+            break;
+        case 'acplist':
+            const list = bot.uList(Object.keys(ctx._.prompts || {}).map(
+                x => `/${ctx._.prompts[x].command}: ${ctx._.prompts[x].act}`
+            ));
+            await ctx.paging(list || 'Data not found.');
+            break;
+        case 'acpdetail':
+            const details = bot.lines2(Object.keys(ctx._.prompts || {}).map(
+                x => bot.lines([
+                    `- /${ctx._.prompts[x].command}: ${ctx._.prompts[x].act}`,
+                    ctx._.prompts[x].prompt
+                ])
+            ));
+            await ctx.paging(details || 'Data not found.');
+            break;
+        case 'clear':
+            ctx.clear();
+            await next();
+            break;
+    }
+};
+
+export const { run, priority, func, help, cmds } = {
+    run: true,
+    priority: 30,
+    func: action,
+    help: bot.lines([
+        'Maintain custom prompts.',
+        `Get prompts from ${ACP}.`,
+        `Tips: Use /clear to end current prompted AI conversation session.`,
+        'Example 1: /prompts',
+        'Example 2: /add code > Code with me.',
+        'Example 3: /del code',
+        'Example 4: `/acplist`',
+        'Example 5: `/acpdetail`',
+        'Example 6: `/clear`',
+    ]),
+    cmds: {
+        prompts: 'List custom prompts.',
+        add: 'Add or update a custom prompt: `/add [COMMAND] > [PROMPT]`.',
+        del: 'Delete a custom prompt: `/del [COMMAND]`.',
+        acplist: `List prompts from ${ACP}.`,
+        acpdetail: `Show details of ${ACP}.`,
+        clear: 'Clear current AI conversation session and start a new one.',
+    },
+};

package/skills/translate.mjs

@@ -1,3 +1,5 @@
+// @todo: This is a temporary solution, and will be replaced by a more elegant solution in the future.
+
 const getTranslatePrompt = (lang) => // https://github.com/yetone/bob-plugin-openai-translator/blob/main/src/main.js
     'You are a translation engine that can only translate text and cannot interpret it.'
     + ` Translate the following text into ${lang}: `;
@@ -6,25 +8,24 @@ const getPolishPrompt = () => // https://github.com/yetone/bob-plugin-openai-pol
     + ' Please note that you need to list the changes and briefly explain why: ';
 
 const action = async (ctx, next) => {
-    if (!ctx.text) { return await next(); }
-    switch (ctx.cmd) {
+    switch (ctx.cmdExt?.cmd) {
         case '2en':
-            ctx.text = ctx.text.replace(`/${ctx.cmd}`, getTranslatePrompt('English'));
+            ctx.text = ctx.text.replace(`/${ctx.cmdExt?.cmd}`, getTranslatePrompt('English'));
             break;
         case '2zh':
-            ctx.text = ctx.text.replace(`/${ctx.cmd}`, getTranslatePrompt('Traditional Chinese'));
+            ctx.text = ctx.text.replace(`/${ctx.cmdExt?.cmd}`, getTranslatePrompt('Traditional Chinese'));
             break;
         case '2zht':
-            ctx.text = ctx.text.replace(`/${ctx.cmd}`, getTranslatePrompt('Traditional Chinese'));
+            ctx.text = ctx.text.replace(`/${ctx.cmdExt?.cmd}`, getTranslatePrompt('Traditional Chinese'));
             break;
         case '2zhs':
-            ctx.text = ctx.text.replace(`/${ctx.cmd}`, getTranslatePrompt('Simplified Chinese'));
+            ctx.text = ctx.text.replace(`/${ctx.cmdExt?.cmd}`, getTranslatePrompt('Simplified Chinese'));
             break;
         case '2fr':
-            ctx.text = ctx.text.replace(`/${ctx.cmd}`, getTranslatePrompt('French'));
+            ctx.text = ctx.text.replace(`/${ctx.cmdExt?.cmd}`, getTranslatePrompt('French'));
             break;
         case 'p':
-            ctx.text = ctx.text.replace(`/${ctx.cmd}`, getPolishPrompt());
+            ctx.text = ctx.text.replace(`/${ctx.cmdExt?.cmd}`, getPolishPrompt());
             break;
     }
     await next();
@@ -32,7 +33,6 @@ const action = async (ctx, next) => {
 
 export const { run, priority, func } = {
     run: true,
-    priority: 20,
-    name: 'ai',
+    priority: 50,
     func: action,
 };

package/skills/ai.mjs

@@ -1,73 +0,0 @@
-import { utilitas } from 'utilitas';
-
-const onProgress = { onProgress: true };
-const [YOU, BOT, LN2] = ['😸 You:', '🤖️ ', '\n\n'];
-const [joinL1, joinL2] = [a => a.join(`${LN2}---${LN2}`), a => a.join(LN2)];
-const enrich = name => name === 'Bing' ? `${name} (Sydney)` : name;
-
-const action = async (ctx, next) => {
-    if (!ctx.text) { return await next(); }
-    const [multiAi, msgs, tts, pms, extra]
-        = [ctx.session.ai.size > 1, {}, {}, [], {}];
-    let [lastMsg, lastSent] = ['', 0];
-    const packMsg = options => {
-        const packed = [...ctx.overwrite ? [joinL2([YOU, ctx.overwrite])] : []];
-        const source = options?.tts ? tts : msgs;
-        for (let name of ctx.session.ai.size ? ctx.session.ai : [ctx.firstAi]) {
-            const defaultAi = name === ctx.firstAi;
-            packed.push(joinL2([
-                ...multiAi || !defaultAi || ctx.overwrite ? [`${BOT}${enrich(name)}:`] : [],
-                options?.onProgress ? (
-                    source[name] ? `${source[name].trim()} █` : '💬'
-                ) : (source[name] || ''),
-            ]));
-        }
-        console.log(packed);
-        return joinL1(packed);
-    };
-    const ok = async options => {
-        const [curTime, curMsg] = [Date.now(), packMsg(options)];
-        if (options?.onProgress && (
-            curTime - lastSent < ctx.limit || lastMsg === curMsg
-        )) { return; }
-        [lastSent, lastMsg] = [curTime, curMsg];
-        return await ctx.ok(curMsg, { ...options || {}, ...extra });
-    };
-    await ok(onProgress);
-    for (let name of ctx.session.ai.size ? ctx.session.ai : [ctx.firstAi]) {
-        if (utilitas.insensitiveCompare('/clear', ctx.text)) {
-            ctx._.ai[name].clear(ctx.chatId);
-            ctx.text = ctx._.hello;
-        }
-        pms.push((async () => {
-            try {
-                const resp = await ctx._.ai[name].send(
-                    ctx.text, { session: ctx.chatId }, tkn => {
-                        msgs[name] = `${(msgs[name] || '')}${tkn}`;
-                        ok(onProgress);
-                    }
-                );
-                msgs[name] = ctx.session.raw ? resp.response : resp.responseRendered;
-                tts[name] = resp.spokenText;
-                extra.textButtons = resp?.suggestedResponses?.map?.(text => ({
-                    text, data: `/bing ${text}`
-                }));
-            } catch (err) {
-                msgs[name] = `[ERROR] ${err?.message || err}`;
-                tts[name] = msgs[name];
-                utilitas.log(err);
-            }
-        })());
-    }
-    await Promise.all(pms);
-    await ok();
-    ctx.tts = packMsg({ tts: true });
-    await next();
-};
-
-export const { run, priority, func } = {
-    run: true,
-    priority: 30,
-    name: 'ai',
-    func: action,
-};

package/skills/cmd.mjs

@@ -1,32 +0,0 @@
-import { utilitas } from 'utilitas';
-
-const matchReg = /^\/([^\ ]*)(.*)$/ig;
-
-const action = async (ctx, next) => {
-    if (!ctx.text) { return await next(); }
-    ctx.session.ai || (ctx.session.ai = new Set());
-    const curAi = new Set();
-    ctx.cmd = ctx.text.split('\n')?.[0]?.replace(matchReg, '$1');
-    let catched;
-    switch (ctx.cmd) {
-        case 'raw': ctx.session.raw = true; catched = true; break;
-        case 'render': ctx.session.raw = false; catched = true; break;
-    }
-    for (let name in ctx._.ai) {
-        ctx.firstAi || (ctx.firstAi = name);
-        if (utilitas.insensitiveCompare(ctx.cmd, name) || ctx.cmd === '*') {
-            curAi.add(name);
-            catched = true;
-        }
-    }
-    curAi.size && (ctx.session.ai = curAi);
-    catched && (ctx.text = ctx.text.replace(matchReg, '$2').trim() || ctx._.hello);
-    await next();
-};
-
-export const { run, priority, func } = {
-    run: true,
-    priority: 10,
-    name: 'ai',
-    func: action,
-};