morpheus-cli 0.2.8 → 0.3.1

package/dist/http/server.js

@@ -12,8 +12,10 @@ const __dirname = path.dirname(__filename);
 export class HttpServer {
     app;
     server;
-    constructor() {
+    oracle;
+    constructor(oracle) {
         this.app = express();
+        this.oracle = oracle;
         this.setupMiddleware();
         this.setupRoutes();
     }
@@ -43,7 +45,7 @@ export class HttpServer {
                 uptime: process.uptime()
             });
         });
-        this.app.use('/api', authMiddleware, createApiRouter());
+        this.app.use('/api', authMiddleware, createApiRouter(this.oracle));
         // Serve static frontend from compiled output
         const uiPath = path.resolve(__dirname, '../ui');
         this.app.use(express.static(uiPath));

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

@@ -318,14 +318,17 @@ export class SatiRepository {
         try {
             this.display.log(`🔍 Iniciando busca de memória | Query: "${query}"`, { source: 'Sati', level: 'debug' });
             // 1️⃣ Vetorial
-            if (embedding) {
-                this.display.log('🧠 Tentando busca vetorial...', { source: 'Sati', level: 'debug' });
+            if (embedding && embedding.length > 0) {
+                this.display.log('🧠  Tentando busca vetorial...', { source: 'Sati', level: 'debug' });
                 const vectorResults = this.searchUnifiedVector(embedding, limit);
                 if (vectorResults.length > 0) {
-                    this.display.log(`✅ Vetorial retornou ${vectorResults.length} resultado(s)`, { source: 'Sati', level: 'success' });
+                    this.display.log(`✅  Vetorial retornou ${vectorResults.length} resultado(s)`, { source: 'Sati', level: 'success' });
                     return vectorResults.slice(0, limit);
                 }
-                this.display.log('⚠️ Vetorial não encontrou resultados relevantes', { source: 'Sati', level: 'debug' });
+                this.display.log('⚠️  Vetorial não encontrou resultados relevantes', { source: 'Sati', level: 'debug' });
+            }
+            else {
+                this.display.log('🛡️  Disabled Archived Sessions in Memory Retrieval', { source: 'Sati', level: 'info' });
             }
             // 2️⃣ BM25 (FTS)
             // Sanitize query: remove characters that could break FTS5 syntax (like ?, *, OR, etc)
@@ -335,7 +338,7 @@ export class SatiRepository {
                 .replace(/\s+/g, ' ')
                 .trim();
             if (safeQuery) {
-                this.display.log('📚 Tentando busca BM25 (FTS5)...', { source: 'Sati', level: 'debug' });
+                this.display.log('📚  Tentando busca BM25 (FTS5)...', { source: 'Sati', level: 'debug' });
                 const stmt = this.db.prepare(`
         SELECT m.*, bm25(memory_fts) as rank
         FROM long_term_memory m
@@ -347,13 +350,13 @@ export class SatiRepository {
       `);
                 const rows = stmt.all(safeQuery, limit);
                 if (rows.length > 0) {
-                    this.display.log(`✅ BM25 retornou ${rows.length} resultado(s)`, { source: 'Sati', level: 'success' });
+                    this.display.log(`✅  BM25 retornou ${rows.length} resultado(s)`, { source: 'Sati', level: 'success' });
                     return rows.map(this.mapRowToRecord);
                 }
-                this.display.log('⚠️ BM25 não encontrou resultados', { source: 'Sati', level: 'debug' });
+                this.display.log('⚠️  BM25 não encontrou resultados', { source: 'Sati', level: 'debug' });
             }
             // 3️⃣ LIKE fallback
-            this.display.log('🧵 Tentando fallback LIKE...', { source: 'Sati', level: 'debug' });
+            this.display.log('🧵  Tentando fallback LIKE...', { source: 'Sati', level: 'debug' });
             const likeStmt = this.db.prepare(`
       SELECT * FROM long_term_memory
       WHERE (summary LIKE ? OR details LIKE ?) 
@@ -364,15 +367,15 @@ export class SatiRepository {
             const pattern = `%${query}%`;
             const likeRows = likeStmt.all(pattern, pattern, limit);
             if (likeRows.length > 0) {
-                this.display.log(`✅ LIKE retornou ${likeRows.length} resultado(s)`, { source: 'Sati', level: 'success' });
+                this.display.log(`✅  LIKE retornou ${likeRows.length} resultado(s)`, { source: 'Sati', level: 'success' });
                 return likeRows.map(this.mapRowToRecord);
             }
             // 4️⃣ Final fallback
-            this.display.log('🛟 Nenhum mecanismo encontrou resultados. Usando fallback estratégico.', { source: 'Sati', level: 'warning' });
+            this.display.log('🛟  Nenhum mecanismo encontrou resultados. Usando fallback estratégico.', { source: 'Sati', level: 'warning' });
             return this.getFallbackMemories(limit);
         }
         catch (e) {
-            this.display.log(`❌ Erro durante busca: ${e}`, { source: 'Sati', level: 'error' });
+            this.display.log(`❌  Erro durante busca: ${e}`, { source: 'Sati', level: 'error' });
             return this.getFallbackMemories(limit);
         }
     }

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

@@ -24,8 +24,9 @@ export class SatiService {
         this.repository.initialize();
     }
     async recover(currentMessage, recentMessages) {
-        const santiConfig = ConfigManager.getInstance().getSatiConfig();
-        const memoryLimit = santiConfig.memory_limit || 10;
+        const satiConfig = ConfigManager.getInstance().getSatiConfig();
+        const memoryLimit = satiConfig.memory_limit || 10;
+        const enabled_vector_search = satiConfig.enabled_archived_sessions ?? true;
         let queryEmbedding;
         try {
             const embeddingService = await EmbeddingService.getInstance();
@@ -33,13 +34,14 @@ export class SatiService {
                 ...recentMessages.slice(-3),
                 currentMessage
             ].join(' ');
-            queryEmbedding = await embeddingService.generate(queryText);
+            if (enabled_vector_search) {
+                queryEmbedding = await embeddingService.generate(queryText);
+            }
         }
         catch (err) {
             console.warn('[Sati] Failed to generate embedding:', err);
         }
-        const memories = this.repository.search(currentMessage, memoryLimit, queryEmbedding // 🔥 agora vai usar vector search
-        );
+        const memories = this.repository.search(currentMessage, memoryLimit, queryEmbedding);
         return {
             relevant_memories: memories.map(m => ({
                 summary: m.summary,
@@ -50,12 +52,12 @@ export class SatiService {
     }
     async evaluateAndPersist(conversation) {
         try {
-            const santiConfig = ConfigManager.getInstance().getSatiConfig();
-            if (!santiConfig)
+            const satiConfig = ConfigManager.getInstance().getSatiConfig();
+            if (!satiConfig)
                 return;
             // Use the main provider factory to get an agent (Reusing Zion configuration)
             // We pass empty tools as Sati is a pure reasoning agent here
-            const agent = await ProviderFactory.create(santiConfig, []);
+            const agent = await ProviderFactory.create(satiConfig, []);
             // Get existing memories for context (Simulated "Working Memory" or full list if small)
             const allMemories = this.repository.getAllMemories();
             const existingSummaries = allMemories.slice(0, 50).map(m => m.summary);
@@ -80,8 +82,8 @@ export class SatiService {
                     name: 'sati_evaluation_input'
                 });
                 inputMsg.provider_metadata = {
-                    provider: santiConfig.provider,
-                    model: santiConfig.model
+                    provider: satiConfig.provider,
+                    model: satiConfig.model
                 };
                 await history.addMessage(inputMsg);
             }
@@ -101,8 +103,8 @@ export class SatiService {
                     outputToolMsg.usage_metadata = lastMessage.usage_metadata;
                 }
                 outputToolMsg.provider_metadata = {
-                    provider: santiConfig.provider,
-                    model: santiConfig.model
+                    provider: satiConfig.provider,
+                    model: satiConfig.model
                 };
                 await history.addMessage(outputToolMsg);
             }

package/dist/runtime/memory/session-embedding-worker.js

@@ -24,7 +24,6 @@ export async function runSessionEmbeddingWorker() {
       FROM sessions
       WHERE ended_at IS NOT NULL
         AND embedding_status = 'pending'
-        OR embedding_status = 'failed'
       LIMIT ?
     `).all(BATCH_LIMIT);
         if (sessions.length === 0) {
@@ -35,12 +34,8 @@ export async function runSessionEmbeddingWorker() {
             const sessionId = session.id;
             display.log(`🧠 Processando sessão ${sessionId}...`, { source: 'SessionEmbeddingWorker' });
             try {
-                // 🔒 marcar como processing
-                shortDb.prepare(`
-          UPDATE sessions
-          SET embedding_status = 'processing'
-          WHERE id = ?
-        `).run(sessionId);
+                // Skip setting 'processing' as it violates CHECK constraint
+                // active_processing.add(sessionId); // If we needed concurrency control
                 const chunks = satiDb.prepare(`
           SELECT id, content
           FROM session_chunks
@@ -51,7 +46,7 @@ export async function runSessionEmbeddingWorker() {
                     display.log(`⚠️ Sessão ${sessionId} não possui chunks.`, { source: 'SessionEmbeddingWorker' });
                     shortDb.prepare(`
             UPDATE sessions
-            SET embedding_status = 'completed',
+            SET embedding_status = 'embedded',
                 embedded = 1
             WHERE id = ?
           `).run(sessionId);
@@ -79,7 +74,7 @@ export async function runSessionEmbeddingWorker() {
                 // ✅ finalizar sessão
                 shortDb.prepare(`
           UPDATE sessions
-          SET embedding_status = 'completed',
+          SET embedding_status = 'embedded',
               embedded = 1
           WHERE id = ?
         `).run(sessionId);

package/dist/runtime/memory/sqlite.js

@@ -615,9 +615,26 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
       `).run(now, sessionId);
         });
         tx(); // Executar a transação
-        // Se a sessão era active, criar nova sessão ativa
+        // Se a sessão era active, verificar se há outra para ativar
         if (session.status === 'active') {
-            this.createFreshSession();
+            const nextSession = this.db.prepare(`
+        SELECT id FROM sessions
+        WHERE status = 'paused'
+        ORDER BY started_at DESC
+        LIMIT 1
+      `).get();
+            if (nextSession) {
+                // Promover a próxima sessão a ativa
+                this.db.prepare(`
+          UPDATE sessions
+          SET status = 'active'
+          WHERE id = ?
+        `).run(nextSession.id);
+            }
+            else {
+                // Nenhuma outra sessão, criar nova
+                this.createFreshSession();
+            }
         }
     }
     /**

package/dist/runtime/migration.js

@@ -27,6 +27,8 @@ export async function migrateConfigFile() {
     }
     // Migrate memory.limit to llm.context_window
     await migrateContextWindow();
+    // Migrate santi -> sati
+    await migrateSantiToSati();
 }
 /**
  * Migrates memory.limit to llm.context_window
@@ -78,3 +80,41 @@ async function migrateContextWindow() {
         });
     }
 }
+/**
+ * Migrates santi config section to sati
+ * Fixes typo in previous versions
+ */
+async function migrateSantiToSati() {
+    const display = DisplayManager.getInstance();
+    const configPath = PATHS.config;
+    try {
+        // Check if config file exists
+        if (!await fs.pathExists(configPath)) {
+            return;
+        }
+        // Read current config
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = yaml.load(configContent);
+        // Check if migration is needed
+        if (config?.santi !== undefined && config?.sati === undefined) {
+            // Create backup before migration
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = `${configPath}.backup-${timestamp}`;
+            await fs.copy(configPath, backupPath);
+            display.log(`Created config backup: ${backupPath}`, { source: 'Migration', level: 'info' });
+            // Perform migration
+            config.sati = config.santi;
+            delete config.santi;
+            // Write migrated config
+            const migratedYaml = yaml.dump(config);
+            await fs.writeFile(configPath, migratedYaml, 'utf8');
+            display.log('Migrated santi → sati in configuration', { source: 'Migration', level: 'info' });
+        }
+    }
+    catch (error) {
+        display.log(`Config migration (santi->sati) failed: ${error.message}`, {
+            source: 'Migration',
+            level: 'warning'
+        });
+    }
+}

package/dist/runtime/oracle.js

@@ -257,6 +257,62 @@ You maintain intent until resolution.
             throw new Error("Current history provider does not support session rollover.");
         }
     }
+    async setSessionId(sessionId) {
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        // Check if the history provider supports switching sessions
+        // SQLiteChatMessageHistory does support it via constructor (new instance) or maybe we can add a method there too?
+        // Actually SQLiteChatMessageHistory has `switchSession(targetSessionId)` but that one logic is "pause current, activate target".
+        // For API usage, we might just want to *target* a session without necessarily changing the global "active" state regarding the Daemon?
+        //
+        // However, the user request implies this is "the" chat.
+        // If we use `switchSession` it pauses others. That seems correct for a single-user agent model.
+        //
+        // But `SQLiteChatMessageHistory` properties are `sessionId`.
+        // It seems `switchSession` in `sqlite.ts` updates the DB state.
+        // We also need to update the `sessionId` property of the `SQLiteChatMessageHistory` instance held by Oracle.
+        //
+        // Let's check `SQLiteChatMessageHistory` again.
+        // It has `sessionId` property.
+        // It does NOT have a method to just update `sessionId` property without DB side effects?
+        //
+        // Use `switchSession` from `sqlite.ts` is good for "Active/Paused" state management.
+        // But we also need the `history` instance to know it is now pointing to `sessionId`.
+        if (this.history instanceof SQLiteChatMessageHistory) {
+            // Logic:
+            // 1. If currently active session is different, switch.
+            // 2. Update internal sessionId.
+            // Actually `switchSession` in `sqlite.ts` takes `targetSessionId`.
+            // It updates the DB status.
+            // It DOES NOT seem to update `this.sessionId` of the instance? 
+            // Wait, let me check `sqlite.ts` content from memory or view it again alongside.
+            //
+            // In `sqlite.ts`:
+            // public async switchSession(targetSessionId: string): Promise<void> { ... }
+            // It updates DB.
+            // It DOES NOT update `this.sessionId`.
+            //
+            // So we need to ensure `this.history` points to the new session.
+            // Since `SQLiteChatMessageHistory` might not allow changing `sessionId` publicly if it's protected/private...
+            // It is `private sessionId: string;`.
+            //
+            // So simple fix: Re-instantiate `this.history`?
+            // `this.history = new SQLiteChatMessageHistory({ sessionId: sessionId, ... })`
+            //
+            // This is safe and clean.
+            await this.history.switchSession(sessionId);
+            // Re-instantiate to point to new session
+            this.history = new SQLiteChatMessageHistory({
+                sessionId: sessionId,
+                databasePath: this.databasePath,
+                limit: this.config.llm?.context_window ?? 100
+            });
+        }
+        else {
+            throw new Error("Current history provider does not support session switching.");
+        }
+    }
     async clearMemory() {
         if (!this.history) {
             throw new Error("Message history not initialized. Call initialize() first.");

package/dist/types/config.js

@@ -32,4 +32,12 @@ export const DEFAULT_CONFIG = {
         enabled: true,
         port: 3333,
     },
+    sati: {
+        provider: 'openai',
+        model: 'gpt-4',
+        temperature: 0.7,
+        context_window: 100,
+        memory_limit: 100,
+        enabled_archived_sessions: true,
+    }
 };