morpheus-cli 0.2.7 → 0.3.1

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

@@ -37,7 +37,7 @@ export class Oracle {
             const contextWindow = this.config.llm?.context_window ?? this.config.memory?.limit ?? 100;
             this.display.log(`Using context window: ${contextWindow} messages`, { source: 'Oracle' });
             this.history = new SQLiteChatMessageHistory({
-                sessionId: "default",
+                sessionId: '', // Let the history manage session IDs internally
                 databasePath: this.databasePath,
                 limit: contextWindow,
             });
@@ -245,6 +245,74 @@ You maintain intent until resolution.
         }
         return await this.history.getMessages();
     }
+    async createNewSession() {
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        if (this.history instanceof SQLiteChatMessageHistory) {
+            await this.history.createNewSession();
+            this.display.log('Session rolled over successfully.', { source: 'Oracle' });
+        }
+        else {
+            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/runtime/session-embedding-scheduler.js

@@ -0,0 +1,21 @@
+import { runSessionEmbeddingWorker } from './memory/session-embedding-worker.js';
+import { DisplayManager } from './display.js';
+const INTERVAL_MS = 60_000 * 5; // 5 minutos
+export function startSessionEmbeddingScheduler() {
+    const display = DisplayManager.getInstance();
+    display.log('🕒 Scheduler de embeddings iniciado', { source: 'SessionEmbeddingScheduler' });
+    // roda imediatamente na inicialização
+    runSessionEmbeddingWorker().catch(console.error);
+    let isRunning = false;
+    setInterval(async () => {
+        if (isRunning)
+            return;
+        isRunning = true;
+        try {
+            await runSessionEmbeddingWorker();
+        }
+        finally {
+            isRunning = false;
+        }
+    }, INTERVAL_MS);
+}

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,
+    }
 };