morpheus-cli 0.2.6 → 0.2.8

package/dist/channels/telegram.js

@@ -11,6 +11,7 @@ import { Telephonist } from '../runtime/telephonist.js';
 import { readPid, isProcessRunning, checkStalePid } from '../runtime/lifecycle.js';
 import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
 import { SatiRepository } from '../runtime/memory/sati/repository.js';
+import { MCPManager } from '../config/mcp-manager.js';
 export class TelegramAdapter {
     bot = null;
     isConnected = false;
@@ -18,6 +19,18 @@ export class TelegramAdapter {
     config = ConfigManager.getInstance();
     oracle;
     telephonist = new Telephonist();
+    history = new SQLiteChatMessageHistory({ sessionId: '' });
+    HELP_MESSAGE = `/start - Show this welcome message and available commands
+/status - Check the status of the Morpheus agent
+/doctor - Diagnose environment and configuration issues
+/stats - Show token usage statistics
+/help - Show available commands
+/zaion - Show system configurations
+/sati <qnt> - Show specific memories
+/newsession - Archive current session and start fresh
+/sessions - List all sessions with titles and switch between them
+/restart - Restart the Morpheus agent
+/mcp or /mcps - List registered MCP servers`;
     constructor(oracle) {
         this.oracle = oracle;
     }
@@ -138,6 +151,45 @@ export class TelegramAdapter {
                     }
                 }
             });
+            this.bot.action('confirm_new_session', async (ctx) => {
+                await this.handleApproveNewSessionCommand(ctx, ctx.from.username || ctx.from.first_name);
+                if (ctx.updateType === 'callback_query') {
+                    ctx.answerCbQuery();
+                    ctx.deleteMessage().catch(() => { });
+                }
+                ctx.reply("New session created.");
+            });
+            this.bot.action('cancel_new_session', async (ctx) => {
+                if (ctx.updateType === 'callback_query') {
+                    ctx.answerCbQuery();
+                    ctx.deleteMessage().catch(() => { });
+                }
+                ctx.reply("New session cancelled.");
+            });
+            this.bot.action(/^switch_session_/, async (ctx) => {
+                const callbackQuery = ctx.callbackQuery;
+                const data = callbackQuery && 'data' in callbackQuery ? callbackQuery.data : undefined;
+                const sessionId = typeof data === 'string' ? data.replace('switch_session_', '') : '';
+                if (!sessionId || sessionId === '') {
+                    await ctx.answerCbQuery('Invalid session ID');
+                    return;
+                }
+                try {
+                    // Obter a sessão atual antes de alternar
+                    const history = new SQLiteChatMessageHistory({ sessionId: "" });
+                    // Alternar para a nova sessão
+                    await history.switchSession(sessionId);
+                    await ctx.answerCbQuery();
+                    // Remover a mensagem anterior e enviar confirmação
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    ctx.reply(`✅ Switched to session ID: ${sessionId}`);
+                }
+                catch (error) {
+                    await ctx.answerCbQuery(`Error switching session: ${error.message}`);
+                }
+            });
             this.bot.launch().catch((err) => {
                 if (this.isConnected) {
                     this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
@@ -187,6 +239,11 @@ export class TelegramAdapter {
         this.bot = null;
         this.display.log(chalk.gray('Telegram disconnected.'), { source: 'Telegram' });
     }
+    /**
+    ** =========================
+    **     Commands Handlers
+    ** =========================
+    */
     async handleSystemCommand(ctx, text, user) {
         const command = text.split(' ')[0];
         const args = text.split(' ').slice(1);
@@ -215,24 +272,91 @@ export class TelegramAdapter {
             case '/restart':
                 await this.handleRestartCommand(ctx, user);
                 break;
+            case '/mcp':
+            case '/mcps':
+                await this.handleMcpListCommand(ctx, user);
+                break;
+            case '/newsession':
+            case '/reset':
+                await this.handleNewSessionCommand(ctx, user);
+                break;
+            case '/sessionstatus':
+            case '/session':
+            case '/sessions':
+                await this.handleSessionStatusCommand(ctx, user);
+                break;
             default:
                 await this.handleDefaultCommand(ctx, user, command);
         }
     }
+    async handleNewSessionCommand(ctx, user) {
+        try {
+            await ctx.reply("Are you ready to start a new session? Please confirm.", {
+                parse_mode: 'Markdown', reply_markup: {
+                    inline_keyboard: [
+                        [{ text: 'Yes, start new session', callback_data: 'confirm_new_session' }, { text: 'No, cancel', callback_data: 'cancel_new_session' }]
+                    ]
+                }
+            });
+        }
+        catch (e) {
+            await ctx.reply(`Error starting new session: ${e.message}`);
+        }
+    }
+    async handleApproveNewSessionCommand(ctx, user) {
+        try {
+            const history = new SQLiteChatMessageHistory({ sessionId: "" });
+            await history.createNewSession();
+        }
+        catch (e) {
+            await ctx.reply(`Error creating new session: ${e.message}`);
+        }
+    }
+    async handleSessionStatusCommand(ctx, user) {
+        try {
+            // Obter todas as sessões ativas e pausadas usando a nova função
+            const history = new SQLiteChatMessageHistory({ sessionId: "" });
+            const sessions = await history.listSessions();
+            if (sessions.length === 0) {
+                await ctx.reply('No active or paused sessions found.', { parse_mode: 'Markdown' });
+                return;
+            }
+            let response = '*Sessions:*\n\n';
+            const keyboard = [];
+            for (const session of sessions) {
+                const title = session.title || 'Untitled Session';
+                const statusEmoji = session.status === 'active' ? '🟢' : '🟡';
+                response += `${statusEmoji} *${title}*\n`;
+                response += `- ID: ${session.id}\n`;
+                response += `- Status: ${session.status}\n`;
+                response += `- Started: ${new Date(session.started_at).toLocaleString()}\n\n`;
+                // Adicionar botão inline para alternar para esta sessão
+                if (session.status !== 'active') {
+                    keyboard.push([{
+                            text: `Switch to: ${title}`,
+                            callback_data: `switch_session_${session.id}`
+                        }]);
+                }
+            }
+            await ctx.reply(response, {
+                parse_mode: 'Markdown',
+                reply_markup: {
+                    inline_keyboard: keyboard
+                }
+            });
+            history.close();
+        }
+        catch (e) {
+            await ctx.reply(`Error retrieving session status: ${e.message}`);
+        }
+    }
     async handleStartCommand(ctx, user) {
         const welcomeMessage = `
 Hello, @${user}! I am ${this.config.get().agent.name}, ${this.config.get().agent.personality}.
 
 I am your local AI operator/agent. Here are the commands you can use:
 
-/start - Show this welcome message and available commands
-/status - Check the status of the Morpheus agent
-/doctor - Diagnose environment and configuration issues
-/stats - Show token usage statistics
-/help - Show available commands
-/zaion - Show system configurations
-/sati <qnt> - Show specific memories
-/restart - Restart the Morpheus agent
+  ${this.HELP_MESSAGE}
 
 How can I assist you today?`;
         await ctx.reply(welcomeMessage);
@@ -316,7 +440,7 @@ How can I assist you today?`;
             if (groupedStats.length > 0) {
                 response += '*Breakdown by Provider and Model:*\n';
                 for (const stat of groupedStats) {
-                    response += `- ${stat.provider}/${stat.model}: ${stat.totalTokens} tokens (${stat.messageCount} messages)\n`;
+                    response += `- ${stat.provider}/${stat.model}:\n ${stat.totalTokens} tokens\n(${stat.messageCount} messages)\n\n`;
                 }
             }
             else {
@@ -331,9 +455,10 @@ How can I assist you today?`;
         }
     }
     async handleDefaultCommand(ctx, user, command) {
-        const prompt = `O usuário envio o comando: ${command},
+        const prompt = `O usuário enviou o comando: ${command},
     Não entendemos o comando
-    temos os seguintes comandos disponíveis: /start, /status, /doctor, /stats, /help, /zaion, /sati <qnt>, /restart
+    temos os seguintes comandos disponíveis:
+    ${this.HELP_MESSAGE}
     Identifique se ele talvez tenha errado o comando e pergunte se ele não quis executar outro comando.
     Só faça isso agora.`;
         let response = await this.oracle.chat(prompt);
@@ -346,14 +471,7 @@ How can I assist you today?`;
         const helpMessage = `
 *Available Commands:*
 
-/start - Show welcome message and available commands
-/status - Check the status of the Morpheus agent
-/doctor - Diagnose environment and configuration issues
-/stats - Show token usage statistics
-/help - Show this help message
-/zaion - Show system configurations
-/sati <qnt> - Show specific memories
-/restart - Restart the Morpheus agent
+${this.HELP_MESSAGE}
 
 How can I assist you today?`;
         await ctx.reply(helpMessage, { parse_mode: 'Markdown' });
@@ -473,4 +591,36 @@ How can I assist you today?`;
             this.display.log(`Error checking restart notification: ${error.message}`, { source: 'Telegram', level: 'error' });
         }
     }
+    async handleMcpListCommand(ctx, user) {
+        try {
+            const servers = await MCPManager.listServers();
+            if (servers.length === 0) {
+                await ctx.reply('*No MCP Servers Configured*\n\nThere are currently no MCP servers configured in the system.', { parse_mode: 'Markdown' });
+                return;
+            }
+            let response = `*MCP Servers (${servers.length})*\n\n`;
+            servers.forEach((server, index) => {
+                const status = server.enabled ? '✅ Enabled' : '❌ Disabled';
+                const transport = server.config.transport.toUpperCase();
+                response += `*${index + 1}. ${server.name}*\n`;
+                response += `Status: ${status}\n`;
+                response += `Transport: ${transport}\n`;
+                if (server.config.transport === 'stdio') {
+                    response += `Command: \`${server.config.command}\`\n`;
+                    if (server.config.args && server.config.args.length > 0) {
+                        response += `Args: \`${server.config.args.join(' ')}\`\n`;
+                    }
+                }
+                else if (server.config.transport === 'http') {
+                    response += `URL: \`${server.config.url}\`\n`;
+                }
+                response += '\n';
+            });
+            await ctx.reply(response, { parse_mode: 'Markdown' });
+        }
+        catch (error) {
+            this.display.log('Error listing MCP servers: ' + (error instanceof Error ? error.message : String(error)), { source: 'Telegram', level: 'error' });
+            await ctx.reply('An error occurred while retrieving the list of MCP servers. Please check the logs for more details.', { parse_mode: 'Markdown' });
+        }
+    }
 }

package/dist/cli/commands/doctor.js

@@ -144,7 +144,7 @@ export const doctorCommand = new Command('doctor')
     }
     // 5. Check Sati Memory DB
     try {
-        const satiDbPath = path.join(PATHS.memory, 'santi-memory.db');
+        const satiDbPath = path.join(PATHS.memory, 'sati-memory.db');
         if (await fs.pathExists(satiDbPath)) {
             console.log(chalk.green('✓') + ' Sati Memory: Database exists');
         }

package/dist/cli/commands/session.js

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { ConfigManager } from '../../config/manager.js';
+import { confirm } from '@inquirer/prompts';
+const session = new Command('session')
+    .description('Manage chat sessions');
+session.command('new')
+    .description('Archive current session and start a new one')
+    .action(async () => {
+    const confirmNew = await confirm({
+        message: 'Are you sure you want to start a new session?',
+        default: false,
+    });
+    if (confirmNew) {
+        const config = ConfigManager.getInstance().get();
+        const port = config.ui.port || 3333;
+        const authPass = process.env.THE_ARCHITECT_PASS || 'iamthearchitect';
+        try {
+            const response = await fetch(`http://localhost:${port}/api/session/reset`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-architect-pass': authPass
+                }
+            });
+            if (response.ok) {
+                console.log(chalk.green('✓ New session started successfully on running Morpheus instance.'));
+            }
+            else {
+                const errorText = await response.text();
+                console.log(chalk.red(`Failed: ${response.status} ${response.statusText}`));
+                if (errorText)
+                    console.log(chalk.gray(errorText));
+            }
+        }
+        catch (err) {
+            console.log(chalk.red('Could not connect to Morpheus daemon.'));
+            console.log(chalk.yellow(`Ensure Morpheus is running and listening on port ${port}.`));
+        }
+    }
+    else {
+        console.log(chalk.yellow('Session reset cancelled. Current session is intact.'));
+    }
+});
+session.command('status')
+    .description('Get current session status')
+    .action(async () => {
+    const config = ConfigManager.getInstance().get();
+    const port = config.ui.port || 3333;
+    const authPass = process.env.THE_ARCHITECT_PASS || 'iamthearchitect';
+    try {
+        const response = await fetch(`http://localhost:${port}/api/session/status`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-architect-pass': authPass
+            }
+        });
+        if (response.ok) {
+            const data = await response.json();
+            console.log(chalk.bold('Current Session Status:'));
+            console.log(`- Session ID: ${data.id}`);
+            console.log(`- Messages in Session: ${data.messageCount}`);
+            console.log(`- Embedded: ${data.embedded}`);
+            console.log(`- Embedding Status: ${data.embedding_status}`);
+        }
+        else {
+            const errorText = await response.text();
+            console.log(chalk.red(`Failed: ${response.status} ${response.statusText}`));
+            if (errorText)
+                console.log(chalk.gray(errorText));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red('Could not connect to Morpheus daemon.'));
+        console.log(chalk.yellow(`Ensure Morpheus is running and listening on port ${port}.`));
+    }
+});
+export const sessionCommand = session;

package/dist/cli/commands/start.js

@@ -12,6 +12,7 @@ import { Oracle } from '../../runtime/oracle.js';
 import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
 import { getVersion } from '../utils/version.js';
+import { startSessionEmbeddingScheduler } from '../../runtime/session-embedding-scheduler.js';
 export const startCommand = new Command('start')
     .description('Start the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -103,6 +104,8 @@ export const startCommand = new Command('start')
                 display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'));
             }
         }
+        // Start Background Services
+        startSessionEmbeddingScheduler();
         // Handle graceful shutdown
         const shutdown = async (signal) => {
             display.stopSpinner();

package/dist/cli/index.js

@@ -6,6 +6,7 @@ import { configCommand } from './commands/config.js';
 import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
 import { restartCommand } from './commands/restart.js';
+import { sessionCommand } from './commands/session.js';
 import { scaffold } from '../runtime/scaffold.js';
 import { getVersion } from './utils/version.js';
 export async function cli() {
@@ -24,7 +25,8 @@ export async function cli() {
     program.addCommand(statusCommand);
     program.addCommand(configCommand);
     program.addCommand(doctorCommand);
-    program.parse(process.argv);
+    program.addCommand(sessionCommand);
+    await program.parseAsync(process.argv);
 }
 // Support direct execution via tsx
 if (import.meta.url.startsWith('file:') && (process.argv[1]?.endsWith('index.ts') || process.argv[1]?.endsWith('cli/index.js'))) {

package/dist/http/api.js

@@ -23,6 +23,31 @@ async function readLastLines(filePath, n) {
 export function createApiRouter() {
     const router = Router();
     const configManager = ConfigManager.getInstance();
+    const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+    router.post('/session/reset', async (req, res) => {
+        // if (!oracle) {
+        //   return res.status(503).json({ error: 'Oracle unavailable' });
+        // }
+        try {
+            await history.createNewSession();
+            res.json({ success: true, message: 'New session started' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/session/status', async (req, res) => {
+        try {
+            const sessionStatus = await history.getSessionStatus();
+            if (!sessionStatus) {
+                return res.status(404).json({ error: 'No session found' });
+            }
+            res.json(sessionStatus);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     router.get('/status', async (req, res) => {
         let version = 'unknown';
         try {

package/dist/runtime/memory/backfill-embeddings.js

@@ -0,0 +1,54 @@
+import Database from 'better-sqlite3';
+import { EmbeddingService } from './embedding.service.js';
+import path from 'path';
+import { homedir } from 'os';
+import loadVecExtension from './sqlite-vec.js';
+const db = new Database(path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db'));
+db.pragma('journal_mode = WAL');
+// 🔥 ISSO AQUI É O QUE ESTÁ FALTANDO
+loadVecExtension(db);
+const embeddingService = await EmbeddingService.getInstance();
+const BATCH_SIZE = 50;
+async function run() {
+    console.log('🔎 Buscando memórias sem embedding vetorial...');
+    while (true) {
+        const rows = db.prepare(`
+      SELECT m.rowid, m.summary, m.details
+      FROM long_term_memory m
+      LEFT JOIN memory_vec v ON m.rowid = v.rowid
+      WHERE v.rowid IS NULL
+      LIMIT ?
+    `).all(BATCH_SIZE);
+        if (rows.length === 0) {
+            console.log('✅ Todas as memórias já possuem embedding.');
+            break;
+        }
+        console.log(`⚙️ Processando batch de ${rows.length} memórias...`);
+        const vectors = [];
+        for (const row of rows) {
+            const text = `${row.summary} ${row.details || ''}`.trim();
+            const vector = await embeddingService.generate(text);
+            vectors.push({ rowid: row.rowid, vector });
+        }
+        const insertVec = db.prepare(`
+        INSERT INTO memory_vec (embedding)
+        VALUES (?)
+        `);
+        const insertMap = db.prepare(`
+        INSERT INTO memory_embedding_map (memory_id, vec_rowid)
+        VALUES (?, ?)
+        `);
+        const transaction = db.transaction((items) => {
+            for (const item of items) {
+                const result = insertVec.run(new Float32Array(item.vector));
+                const vecRowId = result.lastInsertRowid;
+                insertMap.run(item.memory_id, vecRowId);
+            }
+        });
+        transaction(vectors);
+    }
+    console.log('🎉 Backfill concluído.');
+}
+run().catch(err => {
+    console.error('❌ Erro no backfill:', err);
+});

package/dist/runtime/memory/embedding.service.js

@@ -0,0 +1,21 @@
+import { pipeline } from '@xenova/transformers';
+export class EmbeddingService {
+    static instance;
+    extractor;
+    constructor() { }
+    static async getInstance() {
+        if (!EmbeddingService.instance) {
+            const service = new EmbeddingService();
+            service.extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+            EmbeddingService.instance = service;
+        }
+        return EmbeddingService.instance;
+    }
+    async generate(text) {
+        const output = await this.extractor(text, {
+            pooling: 'mean',
+            normalize: true,
+        });
+        return Array.from(output.data);
+    }
+}

package/dist/runtime/memory/sati/index.js

@@ -18,16 +18,16 @@ export class SatiMemoryMiddleware {
         try {
             // Extract recent messages content strings for context
             const recentText = history.slice(-10).map(m => m.content.toString());
-            display.log(`[Sati] Searching memories for: "${currentMessage.substring(0, 50)}${currentMessage.length > 50 ? '...' : ''}"`, { source: 'Sati' });
+            display.log(`Searching memories for: "${currentMessage.substring(0, 50)}${currentMessage.length > 50 ? '...' : ''}"`, { source: 'Sati' });
             const result = await this.service.recover(currentMessage, recentText);
             if (result.relevant_memories.length === 0) {
-                display.log('[Sati] No relevant memories found', { source: 'Sati' });
+                display.log('No relevant memories found', { source: 'Sati' });
                 return null;
             }
             const memoryContext = result.relevant_memories
                 .map(m => `- [${m.category.toUpperCase()}] ${m.summary}`)
                 .join('\n');
-            display.log(`[Sati] Retrieved ${result.relevant_memories.length} memories.`, { source: 'Sati' });
+            display.log(`Retrieved ${result.relevant_memories.length} memories.`, { source: 'Sati' });
             return new AIMessage(`
                 ### LONG-TERM MEMORY (SATI)
                 The following information was retrieved from previous sessions. Use it if relevant:
@@ -36,7 +36,7 @@ export class SatiMemoryMiddleware {
             `);
         }
         catch (error) {
-            display.log(`[SatiMiddleware] Error in beforeAgent: ${error}`, { source: 'Sati' });
+            display.log(`Error in beforeAgent: ${error}`, { source: 'Sati' });
             // Fail open: return null so execution continues without memory
             return null;
         }
@@ -52,7 +52,7 @@ export class SatiMemoryMiddleware {
             ]);
         }
         catch (error) {
-            console.error('[SatiMiddleware] Error in afterAgent:', error);
+            display.log(`Error in afterAgent: ${error}`, { source: 'Sati' });
         }
     }
 }