morpheus-cli 0.4.15 → 0.5.1

package/dist/channels/telegram.js

@@ -13,30 +13,101 @@ import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
 import { SatiRepository } from '../runtime/memory/sati/repository.js';
 import { MCPManager } from '../config/mcp-manager.js';
 import { Construtor } from '../runtime/tools/factory.js';
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+/** Strips HTML tags and unescapes entities for plain-text Telegram fallback. */
+function stripHtmlTags(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<\/?(p|div|li|tr)[^>]*>/gi, '\n')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+}
 /**
- * Converts standard Markdown (as produced by LLMs) to Telegram MarkdownV2.
- * Unsupported tags (e.g. tables) have their special chars escaped so they
- * render as plain text instead of breaking the parse.
- * Truncates to Telegram's 4096-char hard limit.
- * Use for dynamic LLM/Oracle output.
+ * Splits an HTML string into chunks ≤ maxLen that never break inside an HTML tag.
+ * Prefers splitting at paragraph (double newline) or line boundaries.
  */
-// Cached dynamic import of telegram-markdown-v2 (ESM-safe, loaded once on first use)
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _convertFn = null;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function getConvert() {
-    if (!_convertFn) {
-        const mod = await import('telegram-markdown-v2');
-        _convertFn = mod.convert;
+function splitHtmlChunks(html, maxLen = 4096) {
+    if (html.length <= maxLen)
+        return [html];
+    const chunks = [];
+    let remaining = html.trim();
+    while (remaining.length > maxLen) {
+        let splitAt = -1;
+        for (const sep of ['\n\n', '\n', ' ']) {
+            const pos = remaining.lastIndexOf(sep, maxLen - 1);
+            if (pos < maxLen / 4)
+                continue; // avoid tiny first chunks
+            // Confirm position is not inside an HTML tag
+            const before = remaining.slice(0, pos);
+            const lastOpen = before.lastIndexOf('<');
+            const lastClose = before.lastIndexOf('>');
+            if (lastOpen > lastClose)
+                continue; // inside a tag — try next separator
+            splitAt = pos + sep.length;
+            break;
+        }
+        if (splitAt <= 0) {
+            // Fallback: split right after the last closing '>' before maxLen
+            const closing = remaining.lastIndexOf('>', maxLen - 1);
+            splitAt = closing > 0 ? closing + 1 : maxLen;
+        }
+        const chunk = remaining.slice(0, splitAt).trim();
+        if (chunk)
+            chunks.push(chunk);
+        remaining = remaining.slice(splitAt).trim();
     }
-    return _convertFn;
+    if (remaining)
+        chunks.push(remaining);
+    return chunks.filter(Boolean);
 }
-async function toMd(text) {
-    const MAX = 4096;
-    const convert = await getConvert();
-    const converted = convert(text, 'escape');
-    const safe = converted.length > MAX ? converted.slice(0, MAX - 3) + '\\.\\.\\.' : converted;
-    return { text: safe, parse_mode: 'MarkdownV2' };
+async function toTelegramRichText(text) {
+    let source = String(text ?? '').replace(/\r\n/g, '\n');
+    const uuidRegex = /\b([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})\b/g;
+    const codeBlocks = [];
+    source = source.replace(/```([a-zA-Z0-9_-]+)?\n?([\s\S]*?)```/g, (_m, _lang, code) => {
+        const idx = codeBlocks.push(`<pre><code>${escapeHtml(String(code).trimEnd())}</code></pre>`) - 1;
+        return `@@CODEBLOCK_${idx}@@`;
+    });
+    const inlineCodes = [];
+    source = source.replace(/`([^`\n]+)`/g, (_m, code) => {
+        const idx = inlineCodes.push(`<code>${escapeHtml(code)}</code>`) - 1;
+        return `@@INLINECODE_${idx}@@`;
+    });
+    const links = [];
+    source = source.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_m, label, url) => {
+        const safeUrl = String(url).replace(/"/g, '&quot;');
+        const idx = links.push(`<a href="${safeUrl}">${escapeHtml(label)}</a>`) - 1;
+        return `@@LINK_${idx}@@`;
+    });
+    // Markdown bullets become visible bullets in Telegram HTML mode.
+    source = source.replace(/^(\s*)[-*]\s+/gm, '$1• ');
+    // Escape user/model content before reinserting HTML tags.
+    source = escapeHtml(source);
+    // Headings -> bold lines
+    source = source.replace(/^#{1,6}\s+(.+)$/gm, (_m, title) => `<b>${title.trim()}</b>`);
+    // Bold
+    source = source.replace(/\*\*([\s\S]+?)\*\*/g, '<b>$1</b>');
+    source = source.replace(/__([\s\S]+?)__/g, '<b>$1</b>');
+    // Italic (conservative)
+    source = source.replace(/(^|[\s(])\*([^*\n]+)\*(?=[$\s).,!?:;])/gm, '$1<i>$2</i>');
+    source = source.replace(/(^|[\s(])_([^_\n]+)_(?=[$\s).,!?:;])/gm, '$1<i>$2</i>');
+    // Make task/session IDs easier to copy in Telegram.
+    source = source.replace(uuidRegex, '<code>$1</code>');
+    // Restore placeholders
+    source = source.replace(/@@CODEBLOCK_(\d+)@@/g, (_m, idx) => codeBlocks[Number(idx)] || '');
+    source = source.replace(/@@INLINECODE_(\d+)@@/g, (_m, idx) => inlineCodes[Number(idx)] || '');
+    source = source.replace(/@@LINK_(\d+)@@/g, (_m, idx) => links[Number(idx)] || '');
+    return { chunks: splitHtmlChunks(source.trim()), parse_mode: 'HTML' };
 }
 /**
  * Escapes special characters in a plain string segment so it's safe to embed
@@ -78,7 +149,8 @@ export class TelegramAdapter {
 /stats \\- Show token usage statistics
 /help \\- Show available commands
 /zaion \\- Show system configurations
-/sati <qnt> \\- Show specific memories
+/sati qnt \\- Show specific memories
+/trinity \\- List registered Trinity databases
 /newsession \\- Archive current session and start fresh
 /sessions \\- List all sessions with titles and switch between them
 /restart \\- Restart the Morpheus agent
@@ -123,18 +195,25 @@ export class TelegramAdapter {
                 try {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
+                    const sessionId = await this.history.getCurrentSessionOrCreate();
+                    await this.oracle.setSessionId(sessionId);
                     // Process with Agent
-                    const response = await this.oracle.chat(text);
+                    const response = await this.oracle.chat(text, undefined, false, {
+                        origin_channel: 'telegram',
+                        session_id: sessionId,
+                        origin_message_id: String(ctx.message.message_id),
+                        origin_user_id: userId,
+                    });
                     if (response) {
-                        try {
-                            await ctx.reply((await toMd(response)).text, { parse_mode: 'MarkdownV2' });
-                        }
-                        catch {
+                        const rich = await toTelegramRichText(response);
+                        for (const chunk of rich.chunks) {
                             try {
-                                ctx.reply(response, { parse_mode: 'MarkdownV2' });
+                                await ctx.reply(chunk, { parse_mode: rich.parse_mode });
                             }
                             catch {
-                                await ctx.reply(response);
+                                const plain = stripHtmlTags(chunk).slice(0, 4096);
+                                if (plain)
+                                    await ctx.reply(plain);
                             }
                         }
                         this.display.log(`Responded to @${user}: ${response}`, { source: 'Telegram' });
@@ -205,8 +284,15 @@ export class TelegramAdapter {
                     // So I should treat 'text' as if it was a text message.
                     await ctx.reply(`🎤 Transcription: "${text}"`);
                     await ctx.sendChatAction('typing');
+                    const sessionId = await this.history.getCurrentSessionOrCreate();
+                    await this.oracle.setSessionId(sessionId);
                     // Process with Agent
-                    const response = await this.oracle.chat(text, usage, true);
+                    const response = await this.oracle.chat(text, usage, true, {
+                        origin_channel: 'telegram',
+                        session_id: sessionId,
+                        origin_message_id: String(ctx.message.message_id),
+                        origin_user_id: userId,
+                    });
                     // if (listeningMsg) {
                     //   try {
                     //     await ctx.telegram.deleteMessage(ctx.chat.id, listeningMsg.message_id);
@@ -215,11 +301,16 @@ export class TelegramAdapter {
                     //   }
                     // }
                     if (response) {
-                        try {
-                            await ctx.reply((await toMd(response)).text, { parse_mode: 'MarkdownV2' });
-                        }
-                        catch {
-                            await ctx.reply(response);
+                        const rich = await toTelegramRichText(response);
+                        for (const chunk of rich.chunks) {
+                            try {
+                                await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                            }
+                            catch {
+                                const plain = stripHtmlTags(chunk).slice(0, 4096);
+                                if (plain)
+                                    await ctx.reply(plain);
+                            }
                         }
                         this.display.log(`Responded to @${user} (via audio)`, { source: 'Telegram' });
                     }
@@ -376,6 +467,125 @@ export class TelegramAdapter {
                     await ctx.reply(`❌ Failed to ${enable ? 'enable' : 'disable'} MCP '${serverName}': ${error.message}`);
                 }
             });
+            // --- Trinity DB Test Connection ---
+            this.bot.action(/^test_trinity_db_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('test_trinity_db_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                await ctx.answerCbQuery('Testing connection…');
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const { testConnection } = await import('../runtime/trinity-connector.js');
+                    const db = DatabaseRegistry.getInstance().getDatabase(id);
+                    if (!db) {
+                        await ctx.reply('❌ Database not found.');
+                        return;
+                    }
+                    const ok = await testConnection(db);
+                    await ctx.reply(ok
+                        ? `✅ <b>${escapeHtml(db.name)}</b>: connection successful.`
+                        : `❌ <b>${escapeHtml(db.name)}</b>: connection failed.`, { parse_mode: 'HTML' });
+                }
+                catch (e) {
+                    await ctx.reply(`❌ Error testing connection: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                }
+            });
+            // --- Trinity DB Refresh Schema ---
+            this.bot.action(/^refresh_trinity_db_schema_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('refresh_trinity_db_schema_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                await ctx.answerCbQuery('Refreshing schema…');
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const { introspectSchema } = await import('../runtime/trinity-connector.js');
+                    const { Trinity } = await import('../runtime/trinity.js');
+                    const registry = DatabaseRegistry.getInstance();
+                    const db = registry.getDatabase(id);
+                    if (!db) {
+                        await ctx.reply('❌ Database not found.');
+                        return;
+                    }
+                    const schema = await introspectSchema(db);
+                    registry.updateSchema(id, JSON.stringify(schema, null, 2));
+                    await Trinity.refreshDelegateCatalog().catch(() => { });
+                    const tableNames = schema.databases
+                        ? schema.databases.flatMap((d) => d.tables.map((t) => `${d.name}.${t.name}`))
+                        : schema.tables.map((t) => t.name);
+                    const count = tableNames.length;
+                    await ctx.reply(`🔄 <b>${escapeHtml(db.name)}</b>: schema refreshed — ${count} ${count === 1 ? 'table' : 'tables'}.`, { parse_mode: 'HTML' });
+                }
+                catch (e) {
+                    await ctx.reply(`❌ Error refreshing schema: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                }
+            });
+            // --- Trinity DB Delete Flow ---
+            this.bot.action(/^ask_trinity_db_delete_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('ask_trinity_db_delete_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const db = DatabaseRegistry.getInstance().getDatabase(id);
+                    if (!db) {
+                        await ctx.answerCbQuery('Database not found');
+                        return;
+                    }
+                    await ctx.answerCbQuery();
+                    await ctx.reply(`⚠️ Delete <b>${escapeHtml(db.name)}</b> (${escapeHtml(db.type)}) from Trinity?\n\nThe actual database won't be affected — only this registration will be removed.`, {
+                        parse_mode: 'HTML',
+                        reply_markup: {
+                            inline_keyboard: [
+                                [
+                                    { text: '🗑️ Yes, delete', callback_data: `confirm_trinity_db_delete_${id}` },
+                                    { text: 'Cancel', callback_data: 'cancel_trinity_db_delete' },
+                                ],
+                            ],
+                        },
+                    });
+                }
+                catch (e) {
+                    await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true });
+                }
+            });
+            this.bot.action(/^confirm_trinity_db_delete_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('confirm_trinity_db_delete_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const registry = DatabaseRegistry.getInstance();
+                    const db = registry.getDatabase(id);
+                    const name = db?.name ?? `#${id}`;
+                    const deleted = registry.deleteDatabase(id);
+                    await ctx.answerCbQuery(deleted ? '🗑️ Deleted' : 'Not found');
+                    if (ctx.updateType === 'callback_query')
+                        ctx.deleteMessage().catch(() => { });
+                    const user = ctx.from?.username || ctx.from?.first_name || 'unknown';
+                    this.display.log(`Trinity DB '${name}' deleted by @${user}`, { source: 'Telegram', level: 'info' });
+                    await ctx.reply(deleted ? `🗑️ <b>${escapeHtml(name)}</b> removed from Trinity.` : `❌ Database #${id} not found.`, { parse_mode: 'HTML' });
+                }
+                catch (e) {
+                    await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true });
+                }
+            });
+            this.bot.action('cancel_trinity_db_delete', async (ctx) => {
+                await ctx.answerCbQuery('Cancelled');
+                if (ctx.updateType === 'callback_query')
+                    ctx.deleteMessage().catch(() => { });
+            });
             this.bot.launch().catch((err) => {
                 if (this.isConnected) {
                     this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
@@ -410,18 +620,10 @@ export class TelegramAdapter {
         await fs.writeFile(filePath, buffer);
         return filePath;
     }
-    /**
-     * Escapes a string for Telegram MarkdownV2 format.
-     * All special characters outside code spans must be escaped with a backslash.
-     */
-    escapeMarkdownV2(text) {
-        // Characters that must be escaped in MarkdownV2 outside of code/pre blocks
-        return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1');
-    }
     /**
      * Sends a proactive message to all allowed Telegram users.
      * Used by the webhook notification system to push results.
-     * Tries plain text first to avoid Markdown parse errors from LLM output.
+     * Uses Telegram HTML parse mode for richer formatting, with plain-text fallback.
      */
     async sendMessage(text) {
         if (!this.isConnected || !this.bot) {
@@ -433,22 +635,39 @@ export class TelegramAdapter {
             this.display.log('No allowed Telegram users configured — skipping notification.', { source: 'Telegram', level: 'warning' });
             return;
         }
-        // toMd() already truncates to 4096 chars (Telegram's hard limit)
-        const { text: mdText, parse_mode } = await toMd(text);
+        const rich = await toTelegramRichText(text);
         for (const userId of allowedUsers) {
+            for (const chunk of rich.chunks) {
+                try {
+                    await this.bot.telegram.sendMessage(userId, chunk, { parse_mode: rich.parse_mode });
+                }
+                catch {
+                    try {
+                        const plain = stripHtmlTags(chunk).slice(0, 4096);
+                        if (plain)
+                            await this.bot.telegram.sendMessage(userId, plain);
+                    }
+                    catch (err) {
+                        this.display.log(`Failed to send message chunk to Telegram user ${userId}: ${err.message}`, { source: 'Telegram', level: 'error' });
+                    }
+                }
+            }
+        }
+    }
+    async sendMessageToUser(userId, text) {
+        if (!this.isConnected || !this.bot) {
+            this.display.log('Cannot send direct message: Telegram bot not connected.', { source: 'Telegram', level: 'warning' });
+            return;
+        }
+        const rich = await toTelegramRichText(text);
+        for (const chunk of rich.chunks) {
             try {
-                await this.bot.telegram.sendMessage(userId, mdText, { parse_mode });
+                await this.bot.telegram.sendMessage(userId, chunk, { parse_mode: rich.parse_mode });
             }
             catch {
-                // Fallback to plain text if MarkdownV2 conversion still fails
-                try {
-                    const MAX_LEN = 4096;
-                    const plain = text.length > MAX_LEN ? text.slice(0, MAX_LEN - 3) + '...' : text;
+                const plain = stripHtmlTags(chunk).slice(0, 4096);
+                if (plain)
                     await this.bot.telegram.sendMessage(userId, plain);
-                }
-                catch (err) {
-                    this.display.log(`Failed to send message to Telegram user ${userId}: ${err.message}`, { source: 'Telegram', level: 'error' });
-                }
             }
         }
     }
@@ -497,6 +716,9 @@ export class TelegramAdapter {
             case '/sati':
                 await this.handleSatiCommand(ctx, user, args);
                 break;
+            case '/trinity':
+                await this.handleTrinityCommand(ctx, user);
+                break;
             case '/restart':
                 await this.handleRestartCommand(ctx, user);
                 break;
@@ -627,7 +849,7 @@ How can I assist you today?`;
             response += `✅ Node\\.js: ${escMd(nodeVersion)}\n`;
         }
         else {
-            response += `❌ Node\\.js: ${escMd(nodeVersion)} \\(Required: >=18\\)\n`;
+            response += `❌ Node\\.js: ${escMd(nodeVersion)} \\(Required: \\>\\=18\\)\n`;
         }
         if (config) {
             response += '✅ Configuration: Valid\n';
@@ -677,6 +899,17 @@ How can I assist you today?`;
                     response += `❌ Apoc API key missing \\(${escMd(apocProvider)}\\)\n`;
                 }
             }
+            // Neo
+            const neo = config.neo;
+            const neoProvider = neo?.provider || llmProvider;
+            if (neoProvider && neoProvider !== 'ollama') {
+                if (hasApiKey(neoProvider, neo?.api_key ?? config.llm?.api_key)) {
+                    response += `✅ Neo API key \\(${escMd(neoProvider)}\\)\n`;
+                }
+                else {
+                    response += `❌ Neo API key missing \\(${escMd(neoProvider)}\\)\n`;
+                }
+            }
             // Telegram token
             if (config.channels?.telegram?.enabled) {
                 const hasTelegramToken = config.channels.telegram?.token || process.env.TELEGRAM_BOT_TOKEN;
@@ -760,11 +993,16 @@ How can I assist you today?`;
     Só faça isso agora.`;
         let response = await this.oracle.chat(prompt);
         if (response) {
-            try {
-                await ctx.reply((await toMd(response)).text, { parse_mode: 'MarkdownV2' });
-            }
-            catch {
-                await ctx.reply(response);
+            const rich = await toTelegramRichText(response);
+            for (const chunk of rich.chunks) {
+                try {
+                    await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                }
+                catch {
+                    const plain = stripHtmlTags(chunk).slice(0, 4096);
+                    if (plain)
+                        await ctx.reply(plain);
+                }
             }
         }
         // await ctx.reply(`Command not recognized. Type /help to see available commands.`);
@@ -812,6 +1050,22 @@ How can I assist you today?`;
             response += `\\- Inherits Oracle config\n`;
         }
         response += '\n';
+        // Neo config (falls back to llm if not set)
+        const neo = config.neo;
+        response += `*Neo \\(MCP \\+ Internal Tools\\):*\n`;
+        if (neo?.provider) {
+            response += `\\- Provider: ${escMd(neo.provider)}\n`;
+            response += `\\- Model: ${escMd(neo.model || config.llm.model)}\n`;
+            response += `\\- Temperature: ${escMd(neo.temperature ?? 0.2)}\n`;
+            response += `\\- Context Window: ${escMd(neo.context_window ?? config.llm.context_window ?? 100)}\n`;
+            if (neo.max_tokens !== undefined) {
+                response += `\\- Max Tokens: ${escMd(neo.max_tokens)}\n`;
+            }
+        }
+        else {
+            response += `\\- Inherits Oracle config\n`;
+        }
+        response += '\n';
         response += `*Channels:*\n`;
         response += `\\- Telegram Enabled: ${escMd(config.channels.telegram.enabled)}\n`;
         response += `\\- Discord Enabled: ${escMd(config.channels.discord.enabled)}\n\n`;
@@ -823,6 +1077,56 @@ How can I assist you today?`;
         response += `\\- Max Duration: ${escMd(config.audio.maxDurationSeconds)}s\n`;
         await ctx.reply(response, { parse_mode: 'MarkdownV2' });
     }
+    async handleTrinityCommand(ctx, user) {
+        try {
+            const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+            const registry = DatabaseRegistry.getInstance();
+            const databases = registry.listDatabases();
+            if (databases.length === 0) {
+                await ctx.reply('No databases registered in Trinity. Use the web UI to register databases.');
+                return;
+            }
+            let html = `<b>Trinity Databases (${databases.length}):</b>\n\n`;
+            const keyboard = [];
+            for (const db of databases) {
+                const schema = db.schema_json ? JSON.parse(db.schema_json) : null;
+                const tables = schema?.tables?.map((t) => t.name).filter(Boolean) ?? [];
+                const updatedAt = db.schema_updated_at
+                    ? new Date(db.schema_updated_at).toLocaleDateString()
+                    : 'never';
+                html += `🗄️ <b>${escapeHtml(db.name)}</b> (${escapeHtml(db.type)})\n`;
+                if (db.host)
+                    html += `  Host: ${escapeHtml(db.host)}:${db.port}\n`;
+                if (db.database_name && !db.host)
+                    html += `  File: ${escapeHtml(db.database_name)}\n`;
+                if (tables.length > 0) {
+                    const tableList = tables.slice(0, 20).join(', ');
+                    const extra = tables.length > 20 ? ` (+${tables.length - 20} more)` : '';
+                    html += `  Tables: ${escapeHtml(tableList)}${escapeHtml(extra)}\n`;
+                }
+                else {
+                    html += `  Tables: (schema not loaded)\n`;
+                }
+                html += `  Schema updated: ${escapeHtml(updatedAt)}\n\n`;
+                keyboard.push([
+                    { text: `🔌 Test ${db.name}`, callback_data: `test_trinity_db_${db.id}` },
+                    { text: `🔄 Schema`, callback_data: `refresh_trinity_db_schema_${db.id}` },
+                    { text: `🗑️ Delete`, callback_data: `ask_trinity_db_delete_${db.id}` },
+                ]);
+            }
+            const chunks = splitHtmlChunks(html.trim());
+            for (let i = 0; i < chunks.length; i++) {
+                const isLast = i === chunks.length - 1;
+                await ctx.reply(chunks[i], {
+                    parse_mode: 'HTML',
+                    ...(isLast && keyboard.length > 0 ? { reply_markup: { inline_keyboard: keyboard } } : {}),
+                });
+            }
+        }
+        catch (e) {
+            await ctx.reply(`Error listing Trinity databases: ${e.message}`);
+        }
+    }
     async handleSatiCommand(ctx, user, args) {
         let limit = null;
         if (args.length > 0) {
@@ -833,28 +1137,29 @@ How can I assist you today?`;
             }
         }
         try {
-            // Usar o repositório SATI para obter memórias de longo prazo
             const repository = SatiRepository.getInstance();
             const memories = repository.getAllMemories();
             if (memories.length === 0) {
-                await ctx.reply(`No memories found.`);
+                await ctx.reply('No memories found.');
                 return;
             }
-            // Se nenhum limite for especificado, usar todas as memórias
-            let selectedMemories = memories;
-            if (limit !== null) {
-                selectedMemories = memories.slice(0, Math.min(limit, memories.length));
-            }
+            const selectedMemories = limit !== null
+                ? memories.slice(0, Math.min(limit, memories.length))
+                : memories;
             const countLabel = limit !== null
-                ? `${escMd(selectedMemories.length)} SATI Memories \\(Showing first ${escMd(selectedMemories.length)}\\)`
-                : `${escMd(selectedMemories.length)} SATI Memories`;
-            let response = `*${countLabel}:*\n\n`;
+                ? `${selectedMemories.length} SATI Memories (showing first ${selectedMemories.length})`
+                : `${selectedMemories.length} SATI Memories`;
+            let html = `<b>${escapeHtml(countLabel)}:</b>\n\n`;
             for (const memory of selectedMemories) {
-                // Limitar o tamanho do resumo para evitar mensagens muito longas
-                const truncatedSummary = memory.summary.length > 200 ? memory.summary.substring(0, 200) + '...' : memory.summary;
-                response += `*${escMd(memory.category)} \\(${escMd(memory.importance)}\\):* ${escMd(truncatedSummary)}\n\n`;
+                const summary = memory.summary.length > 200
+                    ? memory.summary.substring(0, 200) + '...'
+                    : memory.summary;
+                html += `<b>${escapeHtml(memory.category)} (${escapeHtml(memory.importance)}):</b> ${escapeHtml(summary)}\n\n`;
+            }
+            const chunks = splitHtmlChunks(html.trim());
+            for (const chunk of chunks) {
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
             }
-            await ctx.reply(response, { parse_mode: 'MarkdownV2' });
         }
         catch (error) {
             await ctx.reply(`Failed to retrieve memories: ${error.message}`);

package/dist/cli/commands/doctor.js

@@ -50,6 +50,8 @@ export const doctorCommand = new Command('doctor')
             // Check API keys availability for active providers
             const llmProvider = config.llm?.provider;
             const satiProvider = config.sati?.provider;
+            const apocProvider = config.apoc?.provider || llmProvider;
+            const neoProvider = config.neo?.provider || llmProvider;
             // Check LLM provider API key
             if (llmProvider && llmProvider !== 'ollama') {
                 const hasLlmApiKey = config.llm?.api_key ||
@@ -80,6 +82,38 @@ export const doctorCommand = new Command('doctor')
                     allPassed = false;
                 }
             }
+            // Check Apoc provider API key
+            if (apocProvider && apocProvider !== 'ollama') {
+                const hasApocApiKey = config.apoc?.api_key ||
+                    config.llm?.api_key ||
+                    (apocProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (apocProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (apocProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (apocProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasApocApiKey) {
+                    console.log(chalk.green('✓') + ` Apoc API key available for ${apocProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` Apoc API key missing for ${apocProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
+            // Check Neo provider API key
+            if (neoProvider && neoProvider !== 'ollama') {
+                const hasNeoApiKey = config.neo?.api_key ||
+                    config.llm?.api_key ||
+                    (neoProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (neoProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (neoProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (neoProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasNeoApiKey) {
+                    console.log(chalk.green('✓') + ` Neo API key available for ${neoProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` Neo API key missing for ${neoProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
             // Check audio API key if enabled
             if (config.audio?.enabled && config.llm?.provider !== 'gemini') {
                 const hasAudioApiKey = config.audio?.apiKey || process.env.GOOGLE_API_KEY;