morpheus-cli 0.2.7 → 0.3.1

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)
@@ -78,7 +79,7 @@ export const startCommand = new Command('start')
         // Initialize Web UI
         if (options.ui && config.ui.enabled) {
             try {
-                httpServer = new HttpServer();
+                httpServer = new HttpServer(oracle);
                 // Use CLI port if provided and valid, otherwise fallback to config or default
                 const port = parseInt(options.port) || config.ui.port || 3333;
                 httpServer.start(port);
@@ -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/config/manager.js

@@ -54,18 +54,19 @@ export class ConfigManager {
             context_window: config.llm.context_window !== undefined ? resolveNumeric('MORPHEUS_LLM_CONTEXT_WINDOW', config.llm.context_window, DEFAULT_CONFIG.llm.context_window) : undefined
         };
         // Apply precedence to Sati config
-        let santiConfig;
-        if (config.santi) {
-            const santiProvider = resolveProvider('MORPHEUS_SANTI_PROVIDER', config.santi.provider, llmConfig.provider);
-            santiConfig = {
-                provider: santiProvider,
-                model: resolveModel(santiProvider, 'MORPHEUS_SANTI_MODEL', config.santi.model || llmConfig.model),
-                temperature: resolveNumeric('MORPHEUS_SANTI_TEMPERATURE', config.santi.temperature, llmConfig.temperature),
-                max_tokens: config.santi.max_tokens !== undefined ? resolveNumeric('MORPHEUS_SANTI_MAX_TOKENS', config.santi.max_tokens, config.santi.max_tokens) : llmConfig.max_tokens,
-                api_key: resolveApiKey(santiProvider, 'MORPHEUS_SANTI_API_KEY', config.santi.api_key || llmConfig.api_key),
-                base_url: config.santi.base_url || config.llm.base_url,
-                context_window: config.santi.context_window !== undefined ? resolveNumeric('MORPHEUS_SANTI_CONTEXT_WINDOW', config.santi.context_window, config.santi.context_window) : llmConfig.context_window,
-                memory_limit: config.santi.memory_limit !== undefined ? resolveNumeric('MORPHEUS_SANTI_MEMORY_LIMIT', config.santi.memory_limit, config.santi.memory_limit) : undefined
+        let satiConfig;
+        if (config.sati) {
+            const satiProvider = resolveProvider('MORPHEUS_SATI_PROVIDER', config.sati.provider, llmConfig.provider);
+            satiConfig = {
+                provider: satiProvider,
+                model: resolveModel(satiProvider, 'MORPHEUS_SATI_MODEL', config.sati.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_SATI_TEMPERATURE', config.sati.temperature, llmConfig.temperature),
+                max_tokens: config.sati.max_tokens !== undefined ? resolveNumeric('MORPHEUS_SATI_MAX_TOKENS', config.sati.max_tokens, config.sati.max_tokens) : llmConfig.max_tokens,
+                api_key: resolveApiKey(satiProvider, 'MORPHEUS_SATI_API_KEY', config.sati.api_key || llmConfig.api_key),
+                base_url: config.sati.base_url || config.llm.base_url,
+                context_window: config.sati.context_window !== undefined ? resolveNumeric('MORPHEUS_SATI_CONTEXT_WINDOW', config.sati.context_window, config.sati.context_window) : llmConfig.context_window,
+                memory_limit: config.sati.memory_limit !== undefined ? resolveNumeric('MORPHEUS_SATI_MEMORY_LIMIT', config.sati.memory_limit, config.sati.memory_limit) : undefined,
+                enabled_archived_sessions: resolveBoolean('MORPHEUS_SATI_ENABLED_ARCHIVED_SESSIONS', config.sati.enabled_archived_sessions, true)
             };
         }
         // Apply precedence to audio config
@@ -107,7 +108,7 @@ export class ConfigManager {
         return {
             agent: agentConfig,
             llm: llmConfig,
-            santi: santiConfig,
+            sati: satiConfig,
             audio: audioConfig,
             channels: channelsConfig,
             ui: uiConfig,
@@ -137,10 +138,10 @@ export class ConfigManager {
         return this.config.llm;
     }
     getSatiConfig() {
-        if (this.config.santi) {
+        if (this.config.sati) {
             return {
                 memory_limit: 10, // Default if undefined
-                ...this.config.santi
+                ...this.config.sati
             };
         }
         // Fallback to main LLM config

package/dist/config/schemas.js

@@ -19,6 +19,7 @@ export const LLMConfigSchema = z.object({
 });
 export const SatiConfigSchema = LLMConfigSchema.extend({
     memory_limit: z.number().int().positive().optional(),
+    enabled_archived_sessions: z.boolean().default(true),
 });
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
@@ -27,7 +28,7 @@ export const ConfigSchema = z.object({
         personality: z.string().default(DEFAULT_CONFIG.agent.personality),
     }).default(DEFAULT_CONFIG.agent),
     llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
-    santi: SatiConfigSchema.optional(),
+    sati: SatiConfigSchema.optional(),
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
         limit: z.number().int().positive().optional(),

package/dist/http/__tests__/config_api.test.js

@@ -27,10 +27,15 @@ describe('Config API', () => {
             log: vi.fn(),
         };
         DisplayManager.getInstance.mockReturnValue(mockDisplayManager);
+        // Mock Oracle instance
+        const mockOracle = {
+            think: vi.fn(),
+            getMemory: vi.fn(),
+        };
         // Setup App
         app = express();
         app.use(bodyParser.json());
-        app.use('/api', createApiRouter());
+        app.use('/api', createApiRouter(mockOracle));
     });
     afterEach(() => {
         vi.restoreAllMocks();

package/dist/http/api.js

@@ -20,9 +20,166 @@ async function readLastLines(filePath, n) {
         return [];
     }
 }
-export function createApiRouter() {
+export function createApiRouter(oracle) {
     const router = Router();
     const configManager = ConfigManager.getInstance();
+    const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+    // --- Session Management ---
+    router.get('/sessions', async (req, res) => {
+        try {
+            const allSessions = await history.listSessions();
+            res.json(allSessions);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/sessions', async (req, res) => {
+        try {
+            await history.createNewSession();
+            const newSessionId = await history.getCurrentSessionOrCreate(); // Should be the new one
+            res.json({ success: true, id: newSessionId, message: 'New session started' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.delete('/sessions/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            await history.deleteSession(id);
+            res.json({ success: true, message: 'Session deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/sessions/:id/archive', async (req, res) => {
+        try {
+            const { id } = req.params;
+            await history.archiveSession(id);
+            res.json({ success: true, message: 'Session archived' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.patch('/sessions/:id/title', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { title } = req.body;
+            if (!title) {
+                return res.status(400).json({ error: 'Title is required' });
+            }
+            await history.renameSession(id, title);
+            res.json({ success: true, message: 'Session renamed' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/sessions/:id/messages', async (req, res) => {
+        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 {
+                    type,
+                    content: msg.content,
+                    tool_calls: msg.tool_calls,
+                    usage_metadata: msg.usage_metadata
+                };
+            });
+            // Reverse to chronological order for UI
+            res.json(normalizedMessages.reverse());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // --- Chat Interaction ---
+    router.post('/chat', async (req, res) => {
+        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 response = await oracle.chat(message);
+            res.json({ response });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Legacy /session/reset (keep for backward compat or redirect to POST /sessions)
+    router.post('/session/reset', async (req, res) => {
+        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 {
@@ -154,7 +311,7 @@ export function createApiRouter() {
     router.post('/config/sati', async (req, res) => {
         try {
             const config = configManager.get();
-            await configManager.save({ ...config, santi: req.body });
+            await configManager.save({ ...config, sati: req.body });
             const display = DisplayManager.getInstance();
             display.log('Sati configuration updated via UI', {
                 source: 'Zaion',
@@ -174,7 +331,7 @@ export function createApiRouter() {
     router.delete('/config/sati', async (req, res) => {
         try {
             const config = configManager.get();
-            const { santi, ...restConfig } = config;
+            const { sati: sati, ...restConfig } = config;
             await configManager.save(restConfig);
             const display = DisplayManager.getInstance();
             display.log('Sati configuration removed via UI (falling back to Oracle config)', {

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/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' });
         }
     }
 }