morpheus-cli 0.3.7 → 0.4.0

package/dist/channels/telegram.js

@@ -23,6 +23,16 @@ export class TelegramAdapter {
     telephonistProvider = null;
     telephonistModel = null;
     history = new SQLiteChatMessageHistory({ sessionId: '' });
+    RATE_LIMIT_MS = 3000; // minimum ms between requests per user
+    rateLimiter = new Map(); // userId -> last request timestamp
+    isRateLimited(userId) {
+        const now = Date.now();
+        const last = this.rateLimiter.get(userId);
+        if (last !== undefined && now - last < this.RATE_LIMIT_MS)
+            return true;
+        this.rateLimiter.set(userId, now);
+        return false;
+    }
     HELP_MESSAGE = `/start - Show this welcome message and available commands
 /status - Check the status of the Morpheus agent
 /doctor - Diagnose environment and configuration issues
@@ -61,11 +71,16 @@ export class TelegramAdapter {
                     return; // Silent fail for security
                 }
                 this.display.log(`@${user}: ${text}`, { source: 'Telegram' });
-                // Handle system commands
+                // Handle system commands (commands bypass rate limit)
                 if (text.startsWith('/')) {
                     await this.handleSystemCommand(ctx, text, user);
                     return;
                 }
+                // Rate limit check
+                if (this.isRateLimited(userId)) {
+                    await ctx.reply('Please wait a moment before sending another message.');
+                    return;
+                }
                 try {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
@@ -96,6 +111,11 @@ export class TelegramAdapter {
                     this.display.log(`Unauthorized audio attempt by @${user} (ID: ${userId})`, { source: 'Telegram', level: 'warning' });
                     return;
                 }
+                // Rate limit check
+                if (this.isRateLimited(userId)) {
+                    await ctx.reply('Please wait a moment before sending another message.');
+                    return;
+                }
                 if (!config.audio.enabled) {
                     await ctx.reply("Audio transcription is currently disabled.");
                     return;

package/dist/config/manager.js

@@ -70,7 +70,7 @@ export class ConfigManager {
             };
         }
         // Apply precedence to audio config
-        const audioProvider = config.audio.provider;
+        const audioProvider = resolveString('MORPHEUS_AUDIO_PROVIDER', config.audio.provider, DEFAULT_CONFIG.audio.provider);
         // AudioProvider uses 'google' but resolveApiKey expects LLMProvider which uses 'gemini'
         const audioProviderForKey = (audioProvider === 'google' ? 'gemini' : audioProvider);
         const audioConfig = {

package/dist/http/api.js

@@ -80,12 +80,11 @@ export function createApiRouter(oracle) {
         }
     });
     router.get('/sessions/:id/messages', async (req, res) => {
+        const { id } = req.params;
+        const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
         try {
-            const { id } = req.params;
-            const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
             const messages = await sessionHistory.getMessages();
             // Normalize messages for UI
-            const key = (msg) => msg._getType(); // Access internal type if available, or infer
             const normalizedMessages = messages.map((msg) => {
                 const type = msg._getType ? msg._getType() : 'unknown';
                 return {
@@ -101,57 +100,23 @@ export function createApiRouter(oracle) {
         catch (err) {
             res.status(500).json({ error: err.message });
         }
+        finally {
+            sessionHistory.close();
+        }
     });
     // --- Chat Interaction ---
+    const ChatSchema = z.object({
+        message: z.string().min(1).max(32_000),
+        sessionId: z.string().min(1)
+    });
     router.post('/chat', async (req, res) => {
+        const parsed = ChatSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.message });
+        }
         try {
-            const { message, sessionId } = req.body;
-            if (!message || !sessionId) {
-                return res.status(400).json({ error: 'Message and Session ID are required' });
-            }
-            // We need to ensure the Oracle uses the correct session history.
-            // The Oracle class uses its own internal history instance.
-            // We might need to refactor Oracle to accept a session ID per request or 
-            // instantiate a temporary Oracle wrapper/context?
-            //
-            // ACTUALLY: The Oracle class uses `this.history`. 
-            // `SQLiteChatMessageHistory` takes `sessionId` in constructor.
-            // To support multi-session chat via API, we should probably allow passing sessionId to `chat()` 
-            // OR (cleaner for now) we can rely on the fact that `Oracle` might not support swapping sessions easily without
-            // re-initialization or we extend `oracle.chat` to support overriding session.
-            //
-            // Let's look at `Oracle.chat`: it uses `this.history`.
-            // And `SQLiteChatMessageHistory` is tied to a sessionId.
-            //
-            // Quick fix for this feature:
-            // We can use a trick: `Oracle` allows `overrides` in constructor but that's for db path.
-            // `Oracle` initializes `this.history` in `initialize`.
-            // Better approach:
-            // We can temporarily switch the session of the Oracle's history if it exposes it,
-            // OR we just instantiate a fresh history for the chat request and use the provider?
-            // No, `oracle.chat` encapsulates the provider invocation.
-            // Let's check `Oracle` class again. (I viewed it earlier).
-            // It has `private history`.
-            // SOLUTION:
-            // I will add a `setSessionId(id: string)` method to `Oracle` interface and class.
-            // OR pass `sessionId` to `chat`.
-            // For now, I will assume I can update `Oracle` to support dynamic sessions.
-            // I'll modify `Oracle.chat` signature in a separate step if needed. 
-            // Wait, `Oracle` is a singleton-ish in `start.ts`.
-            // Let's modify `Oracle` to accept `sessionId` in `chat`?
-            // `chat(message: string, extraUsage?: UsageMetadata, isTelephonist?: boolean)`
-            //
-            // Adding `sessionId` to `chat` seems invasive if not threaded fast.
-            //
-            // Alternative:
-            // `router.post('/chat')` instantiates a *new* Oracle? No, expensive (provider factory).
-            //
-            // Ideally `Oracle` should be stateless regarding session, or easily switchable.
-            // `SQLiteChatMessageHistory` is cheap to instantiate.
-            //
-            // Let's update `Oracle` to allow switching session.
-            // `oracle.switchSession(sessionId)`
-            await oracle.setSessionId(sessionId); // Type cast for now, will implement next
+            const { message, sessionId } = parsed.data;
+            await oracle.setSessionId(sessionId);
             const response = await oracle.chat(message);
             res.json({ response });
         }

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

@@ -2,6 +2,8 @@ import { pipeline } from '@xenova/transformers';
 export class EmbeddingService {
     static instance;
     extractor;
+    MAX_CACHE_SIZE = 256;
+    cache = new Map(); // text prefix -> embedding
     constructor() { }
     static async getInstance() {
         if (!EmbeddingService.instance) {
@@ -12,10 +14,22 @@ export class EmbeddingService {
         return EmbeddingService.instance;
     }
     async generate(text) {
+        const cacheKey = text.slice(0, 200);
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
         const output = await this.extractor(text, {
             pooling: 'mean',
             normalize: true,
         });
-        return Array.from(output.data);
+        const embedding = Array.from(output.data);
+        if (this.cache.size >= this.MAX_CACHE_SIZE) {
+            // Evict oldest entry (FIFO)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(cacheKey, embedding);
+        return embedding;
     }
 }

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

@@ -83,6 +83,9 @@ export class SatiRepository {
       vec_rowid INTEGER NOT NULL
     );
 
+    CREATE INDEX IF NOT EXISTS idx_embedding_map_vec_rowid
+    ON memory_embedding_map(vec_rowid);
+
     -- ===============================
     -- 4️⃣ TRIGGERS FTS
     -- ===============================
@@ -129,6 +132,9 @@ export class SatiRepository {
       vec_rowid INTEGER NOT NULL
     );
 
+    CREATE INDEX IF NOT EXISTS idx_session_embedding_map_vec_rowid
+    ON session_embedding_map(vec_rowid);
+
   `);
     }
     // 🔥 NOVO — Salvar embedding
@@ -162,41 +168,47 @@ export class SatiRepository {
         transaction();
     }
     // 🔥 NOVO — Busca vetorial
-    searchByVector(embedding, limit) {
-        if (!this.db)
-            return [];
-        const SIMILARITY_THRESHOLD = 0.5; // ajuste fino depois
-        const stmt = this.db.prepare(`
-    SELECT 
-      m.*,
-      vec_distance_cosine(v.embedding, ?) as distance
-    FROM memory_vec v
-    JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
-    JOIN long_term_memory m ON m.id = map.memory_id
-    WHERE m.archived = 0
-    ORDER BY distance ASC
-    LIMIT ?
-  `);
-        const rows = stmt.all(new Float32Array(embedding), limit);
-        // 🔥 Filtrar por similaridade real
-        const ranked = rows
-            .map(r => ({
-            ...r,
-            similarity: 1 - r.distance
-        }))
-            .sort((a, b) => b.distance - a.distance);
-        const filtered = ranked
-            .filter(r => r.distance >= SIMILARITY_THRESHOLD)
-            .sort((a, b) => b.distance - a.distance);
-        if (filtered.length > 0) {
-            console.log(`[SatiRepository] Vector hit (${filtered.length})`);
-        }
-        return filtered.map(this.mapRowToRecord);
-    }
+    // private searchByVector(
+    //   embedding: number[],
+    //   limit: number
+    // ): IMemoryRecord[] {
+    //   if (!this.db) return [];
+    //   const SIMILARITY_THRESHOLD = 0.5; // ajuste fino depois
+    //   const stmt = this.db.prepare(`
+    //   SELECT 
+    //     m.*,
+    //     vec_distance_cosine(v.embedding, ?) as distance
+    //   FROM memory_vec v
+    //   JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
+    //   JOIN long_term_memory m ON m.id = map.memory_id
+    //   WHERE m.archived = 0
+    //   ORDER BY distance ASC
+    //   LIMIT ?
+    // `);
+    //   const rows = stmt.all(
+    //     new Float32Array(embedding),
+    //     limit
+    //   ) as any[];
+    //   // 🔥 Filtrar por similaridade real
+    //   const ranked = rows
+    //     .map(r => ({
+    //       ...r,
+    //       similarity: 1 - r.distance
+    //     }));
+    //   const filtered = ranked
+    //     .filter(r => r.distance >= SIMILARITY_THRESHOLD)
+    //     .sort((a, b) => b.similarity - a.similarity);
+    //   if (filtered.length > 0) {
+    //     console.log(
+    //       `[SatiRepository] Vector hit (${filtered.length})`
+    //     );
+    //   }
+    //   return filtered.map(this.mapRowToRecord);
+    // }
     searchUnifiedVector(embedding, limit) {
         if (!this.db)
             return [];
-        const SIMILARITY_THRESHOLD = 0.75;
+        const SIMILARITY_THRESHOLD = 0.8;
         const stmt = this.db.prepare(`
     SELECT *
     FROM (
@@ -208,7 +220,7 @@ export class SatiRepository {
         m.category as category,
         m.importance as importance,
         'long_term' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.7 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 1.7 as distance
       FROM memory_vec v
       JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
       JOIN long_term_memory m ON m.id = map.memory_id
@@ -224,7 +236,7 @@ export class SatiRepository {
         'session' as category,
         'medium' as importance,
         'session_chunk' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.3 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.5 as distance
       FROM session_vec v
       JOIN session_embedding_map map ON map.vec_rowid = v.rowid
       JOIN session_chunks sc ON sc.id = map.session_chunk_id
@@ -240,6 +252,8 @@ export class SatiRepository {
         // rows.forEach((row, index) => {
         //   console.log(`[SatiRepository] Row ${index + 1}:`, row);
         // });
+        // Note: the SQL query already computes distance as (1 - cosine_distance) * weight,
+        // so higher values mean higher similarity. Use distance directly as similarity score.
         const ranked = rows
             .map(r => ({
             ...r,

package/dist/runtime/memory/sqlite.js

@@ -13,6 +13,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     dbSati; // Optional separate DB for Sati memory, if needed in the future
     sessionId;
     limit;
+    titleSet = false; // cache: skip setSessionTitleIfNeeded after title is set
     constructor(fields) {
         super();
         this.sessionId = fields.sessionId && fields.sessionId !== '' ? fields.sessionId : '';
@@ -110,9 +111,12 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
           model TEXT
         );
         
-        CREATE INDEX IF NOT EXISTS idx_messages_session_id 
+        CREATE INDEX IF NOT EXISTS idx_messages_session_id
         ON messages(session_id);
 
+        CREATE INDEX IF NOT EXISTS idx_messages_session_id_id
+        ON messages(session_id, id DESC);
+
         CREATE TABLE IF NOT EXISTS sessions (
           id TEXT PRIMARY KEY,
           title TEXT,
@@ -335,11 +339,67 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to add message: ${error}`);
         }
     }
+    /**
+     * Adds multiple messages in a single SQLite transaction for better performance.
+     * Replaces calling addMessage() in a loop when inserting agent-generated messages.
+     */
+    async addMessages(messages) {
+        if (messages.length === 0)
+            return;
+        const stmt = this.db.prepare("INSERT INTO messages (session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+        const insertAll = this.db.transaction((msgs) => {
+            for (const message of msgs) {
+                let type;
+                if (message instanceof HumanMessage)
+                    type = "human";
+                else if (message instanceof AIMessage)
+                    type = "ai";
+                else if (message instanceof SystemMessage)
+                    type = "system";
+                else if (message instanceof ToolMessage)
+                    type = "tool";
+                else
+                    throw new Error(`Unsupported message type: ${message.constructor.name}`);
+                const anyMsg = message;
+                const usage = anyMsg.usage_metadata || anyMsg.response_metadata?.usage || anyMsg.response_metadata?.tokenUsage || anyMsg.usage;
+                let finalContent;
+                if (type === 'ai' && (message.tool_calls?.length ?? 0) > 0) {
+                    finalContent = JSON.stringify({ text: message.content, tool_calls: message.tool_calls });
+                }
+                else if (type === 'tool') {
+                    const tm = message;
+                    finalContent = JSON.stringify({ content: tm.content, tool_call_id: tm.tool_call_id, name: tm.name });
+                }
+                else {
+                    finalContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+                }
+                stmt.run(this.sessionId, type, finalContent, Date.now(), usage?.input_tokens ?? null, usage?.output_tokens ?? null, usage?.total_tokens ?? null, usage?.input_token_details?.cache_read ?? usage?.cache_read_tokens ?? null, anyMsg.provider_metadata?.provider ?? null, anyMsg.provider_metadata?.model ?? null);
+            }
+        });
+        try {
+            insertAll(messages);
+            await this.setSessionTitleIfNeeded();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('SQLITE_BUSY'))
+                    throw new Error(`Database is locked. Please try again. Original error: ${error.message}`);
+                if (error.message.includes('SQLITE_READONLY'))
+                    throw new Error(`Database is read-only. Check file permissions. Original error: ${error.message}`);
+                if (error.message.includes('SQLITE_FULL'))
+                    throw new Error(`Database is full or disk space is exhausted. Original error: ${error.message}`);
+            }
+            throw new Error(`Failed to add messages in batch: ${error}`);
+        }
+    }
     /**
      * Verifies if the session has a title, and if not, sets it automatically
      * using the first 50 characters of the oldest human message.
      */
     async setSessionTitleIfNeeded() {
+        // Fast path: skip DB query if we already set the title this session
+        if (this.titleSet)
+            return;
         // Verificar se a sessão já tem título
         const session = this.db.prepare(`
       SELECT title FROM sessions
@@ -347,6 +407,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     `).get(this.sessionId);
         if (session && session.title) {
             // A sessão já tem título, não precisa fazer nada
+            this.titleSet = true;
             return;
         }
         // Obter a mensagem mais antiga do tipo "human" da sessão
@@ -369,6 +430,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             }
             // Chamar a função renameSession para definir o título automaticamente
             await this.renameSession(this.sessionId, title);
+            this.titleSet = true;
         }
     }
     /**
@@ -508,6 +570,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
       `).run(newId, now);
             // Atualizar o ID da sessão atual desta instância
             this.sessionId = newId;
+            this.titleSet = false; // reset cache for new session
         });
         tx(); // Executar a transação
         this.display.log('✅ Nova sessão iniciada e sessão anterior pausada', { source: 'Sati' });

package/dist/runtime/oracle.js

@@ -216,17 +216,15 @@ You maintain intent until resolution.
             const startNewMessagesIndex = messages.length;
             const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
             // console.log('New generated messages', newGeneratedMessages);
-            // Persist User Message first
-            await this.history.addMessage(userMessage);
-            // Persist all new intermediate tool calls and responses
+            // Inject provider/model metadata into all new messages
             for (const msg of newGeneratedMessages) {
-                // Inject provider/model metadata search interactors
                 msg.provider_metadata = {
                     provider: this.config.llm.provider,
                     model: this.config.llm.model
                 };
-                await this.history.addMessage(msg);
             }
+            // Persist user message + all generated messages in a single transaction
+            await this.history.addMessages([userMessage, ...newGeneratedMessages]);
             this.display.log('Response generated.', { source: 'Oracle' });
             const lastMessage = response.messages[response.messages.length - 1];
             const responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
@@ -302,6 +300,8 @@ You maintain intent until resolution.
             //
             // This is safe and clean.
             await this.history.switchSession(sessionId);
+            // Close previous connection before re-instantiating to avoid file handle leaks
+            this.history.close();
             // Re-instantiate to point to new session
             this.history = new SQLiteChatMessageHistory({
                 sessionId: sessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"
@@ -53,7 +53,8 @@
     "telegraf": "^4.16.3",
     "winston": "^3.19.0",
     "winston-daily-rotate-file": "^5.0.0",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "mcp-remote": "^0.1.38"
   },
   "devDependencies": {
     "@types/body-parser": "^1.19.6",