morpheus-cli 0.2.0 → 0.2.3

package/dist/cli/commands/init.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import { ConfigManager } from '../../config/manager.js';
 import { renderBanner } from '../utils/render.js';
 import { DisplayManager } from '../../runtime/display.js';
+import { SatiRepository } from '../../runtime/memory/sati/repository.js';
 // import { scaffold } from '../../runtime/scaffold.js';
 export const initCommand = new Command('init')
     .description('Initialize Morpheus configuration')
@@ -74,6 +75,89 @@ export const initCommand = new Command('init')
         if (apiKey) {
             await configManager.set('llm.api_key', apiKey);
         }
+        // Context Window Configuration
+        const contextWindow = await input({
+            message: 'Context Window Size (number of messages to send to LLM):',
+            default: currentConfig.llm.context_window?.toString() || '100',
+            validate: (val) => (!isNaN(Number(val)) && Number(val) > 0) || 'Must be a positive number'
+        });
+        await configManager.set('llm.context_window', Number(contextWindow));
+        // Sati (Memory Agent) Configuration
+        display.log(chalk.blue('\nSati (Memory Agent) Configuration'));
+        const configureSati = await select({
+            message: 'Configure Sati separately?',
+            choices: [
+                { name: 'No (Use main LLM settings)', value: 'no' },
+                { name: 'Yes', value: 'yes' },
+            ],
+            default: 'no',
+        });
+        let santiProvider = provider;
+        let santiModel = model;
+        let santiApiKey = apiKey;
+        // If using main settings and no new key provided, use existing if available
+        if (configureSati === 'no' && !santiApiKey && hasExistingKey) {
+            santiApiKey = currentConfig.llm.api_key;
+        }
+        if (configureSati === 'yes') {
+            santiProvider = await select({
+                message: 'Select Sati LLM Provider:',
+                choices: [
+                    { name: 'OpenAI', value: 'openai' },
+                    { name: 'Anthropic', value: 'anthropic' },
+                    { name: 'Ollama', value: 'ollama' },
+                    { name: 'Google Gemini', value: 'gemini' },
+                ],
+                default: currentConfig.santi?.provider || provider,
+            });
+            let defaultSatiModel = 'gpt-3.5-turbo';
+            switch (santiProvider) {
+                case 'openai':
+                    defaultSatiModel = 'gpt-4o';
+                    break;
+                case 'anthropic':
+                    defaultSatiModel = 'claude-3-5-sonnet-20240620';
+                    break;
+                case 'ollama':
+                    defaultSatiModel = 'llama3';
+                    break;
+                case 'gemini':
+                    defaultSatiModel = 'gemini-pro';
+                    break;
+            }
+            if (santiProvider === currentConfig.santi?.provider) {
+                defaultSatiModel = currentConfig.santi?.model || defaultSatiModel;
+            }
+            santiModel = await input({
+                message: 'Enter Sati Model Name:',
+                default: defaultSatiModel,
+            });
+            const hasExistingSatiKey = !!currentConfig.santi?.api_key;
+            const santiKeyMsg = hasExistingSatiKey
+                ? 'Enter Sati API Key (leave empty to preserve existing):'
+                : 'Enter Sati API Key:';
+            const keyInput = await password({ message: santiKeyMsg });
+            if (keyInput) {
+                santiApiKey = keyInput;
+            }
+            else if (hasExistingSatiKey) {
+                santiApiKey = currentConfig.santi?.api_key;
+            }
+            else {
+                santiApiKey = undefined; // Ensure we don't accidentally carry over invalid state
+            }
+        }
+        const memoryLimit = await input({
+            message: 'Sati Memory Retrieval Limit (messages):',
+            default: currentConfig.santi?.memory_limit?.toString() || '1000',
+            validate: (val) => !isNaN(Number(val)) && Number(val) > 0 || 'Must be a positive number'
+        });
+        await configManager.set('santi.provider', santiProvider);
+        await configManager.set('santi.model', santiModel);
+        await configManager.set('santi.memory_limit', Number(memoryLimit));
+        if (santiApiKey) {
+            await configManager.set('santi.api_key', santiApiKey);
+        }
         // Audio Configuration
         const audioEnabled = await confirm({
             message: 'Enable Audio Transcription? (Requires Gemini)',
@@ -152,6 +236,14 @@ export const initCommand = new Command('init')
                 await configManager.set('channels.telegram.allowedUsers', allowedUsers);
             }
         }
+        // Initialize Sati Memory (Long-term memory)
+        try {
+            SatiRepository.getInstance().initialize();
+            display.log(chalk.green('Long-term memory initialized.'));
+        }
+        catch (e) {
+            display.log(chalk.yellow(`Warning: Could not initialize long-term memory: ${e.message}`));
+        }
         display.log(chalk.green('\nConfiguration saved successfully!'));
         display.log(chalk.cyan(`Run 'morpheus start' to launch ${name}.`));
     }

package/dist/cli/commands/start.js

@@ -11,6 +11,7 @@ import { PATHS } from '../../config/paths.js';
 import { Oracle } from '../../runtime/oracle.js';
 import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
+import { getVersion } from '../utils/version.js';
 export const startCommand = new Command('start')
     .description('Start the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -19,7 +20,7 @@ export const startCommand = new Command('start')
     .action(async (options) => {
     const display = DisplayManager.getInstance();
     try {
-        renderBanner();
+        renderBanner(getVersion());
         await scaffold(); // Ensure env exists
         // Cleanup stale PID first
         await checkStalePid();

package/dist/cli/index.js

@@ -1,7 +1,4 @@
 import { Command } from 'commander';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
 import { startCommand } from './commands/start.js';
 import { stopCommand } from './commands/stop.js';
 import { statusCommand } from './commands/status.js';
@@ -9,20 +6,7 @@ import { configCommand } from './commands/config.js';
 import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
 import { scaffold } from '../runtime/scaffold.js';
-// Helper to read package.json version
-const getVersion = () => {
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        // Assuming dist/cli/index.js -> package.json is 2 levels up
-        const pkgPath = join(__dirname, '../../package.json');
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        return pkg.version;
-    }
-    catch (e) {
-        return '0.1.0';
-    }
-};
+import { getVersion } from './utils/version.js';
 export async function cli() {
     const program = new Command();
     program

package/dist/cli/utils/render.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import figlet from 'figlet';
-export function renderBanner() {
+export function renderBanner(version) {
     const art = figlet.textSync('Morpheus', {
         font: 'Standard',
         horizontalLayout: 'default',
@@ -8,4 +8,5 @@ export function renderBanner() {
     });
     console.log(chalk.cyanBright(art));
     console.log(chalk.gray('  The Local-First AI Agent specialized in Coding\n'));
+    console.log(chalk.gray(`  v${version || 'unknown'}\n`));
 }

package/dist/cli/utils/version.js

@@ -0,0 +1,16 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+export const getVersion = () => {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Assuming dist/cli/index.js -> package.json is 2 levels up
+        const pkgPath = join(__dirname, '../../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch (e) {
+        return '0.1.0';
+    }
+};

package/dist/config/manager.js

@@ -54,4 +54,20 @@ export class ConfigManager {
         await fs.writeFile(PATHS.config, yaml.dump(valid), 'utf8');
         this.config = valid;
     }
+    getLLMConfig() {
+        return this.config.llm;
+    }
+    getSatiConfig() {
+        if (this.config.santi) {
+            return {
+                memory_limit: 10, // Default if undefined
+                ...this.config.santi
+            };
+        }
+        // Fallback to main LLM config
+        return {
+            ...this.config.llm,
+            memory_limit: 10 // Default fallback
+        };
+    }
 }

package/dist/config/schemas.js

@@ -7,22 +7,28 @@ export const AudioConfigSchema = z.object({
     maxDurationSeconds: z.number().default(DEFAULT_CONFIG.audio.maxDurationSeconds),
     supportedMimeTypes: z.array(z.string()).default(DEFAULT_CONFIG.audio.supportedMimeTypes),
 });
+export const LLMConfigSchema = z.object({
+    provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
+    model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
+    temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
+    max_tokens: z.number().int().positive().optional(),
+    api_key: z.string().optional(),
+    context_window: z.number().int().positive().optional(),
+});
+export const SatiConfigSchema = LLMConfigSchema.extend({
+    memory_limit: z.number().int().positive().optional(),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
         name: z.string().default(DEFAULT_CONFIG.agent.name),
         personality: z.string().default(DEFAULT_CONFIG.agent.personality),
     }).default(DEFAULT_CONFIG.agent),
-    llm: z.object({
-        provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
-        model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
-        temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
-        max_tokens: z.number().int().positive().optional(),
-        api_key: z.string().optional(),
-    }).default(DEFAULT_CONFIG.llm),
+    llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
+    santi: SatiConfigSchema.optional(),
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
-        limit: z.number().int().positive().default(DEFAULT_CONFIG.memory.limit),
+        limit: z.number().int().positive().optional(),
     }).default(DEFAULT_CONFIG.memory),
     channels: z.object({
         telegram: z.object({
@@ -56,6 +62,7 @@ export const MCPServerConfigSchema = z.discriminatedUnion('transport', [
     z.object({
         transport: z.literal('http'),
         url: z.string().url('Valid URL is required for http transport'),
+        headers: z.record(z.string(), z.string()).optional().default({}),
         args: z.array(z.string()).optional().default([]),
         env: z.record(z.string(), z.string()).optional().default({}),
         _comment: z.string().optional(),

package/dist/http/api.js

@@ -5,6 +5,7 @@ import { DisplayManager } from '../runtime/display.js';
 import fs from 'fs-extra';
 import path from 'path';
 import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
+import { SatiRepository } from '../runtime/memory/sati/repository.js';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -113,6 +114,116 @@ export function createApiRouter() {
             }
         }
     });
+    // Sati config endpoints
+    router.get('/config/sati', (req, res) => {
+        try {
+            const satiConfig = configManager.getSatiConfig();
+            res.json(satiConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/sati', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, santi: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Sati configuration updated via UI', {
+                source: 'Zaion',
+                level: 'info'
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            if (error.name === 'ZodError') {
+                res.status(400).json({ error: 'Validation failed', details: error.errors });
+            }
+            else {
+                res.status(500).json({ error: error.message });
+            }
+        }
+    });
+    router.delete('/config/sati', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { santi, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Sati configuration removed via UI (falling back to Oracle config)', {
+                source: 'Zaion',
+                level: 'info'
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // Sati memories endpoints
+    router.get('/sati/memories', async (req, res) => {
+        try {
+            const repository = SatiRepository.getInstance();
+            const memories = repository.getAllMemories();
+            // Convert dates to ISO strings for JSON serialization
+            const serializedMemories = memories.map(memory => ({
+                ...memory,
+                created_at: memory.created_at.toISOString(),
+                updated_at: memory.updated_at.toISOString(),
+                last_accessed_at: memory.last_accessed_at ? memory.last_accessed_at.toISOString() : null
+            }));
+            res.json(serializedMemories);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.delete('/sati/memories/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const repository = SatiRepository.getInstance();
+            const success = repository.archiveMemory(id);
+            if (!success) {
+                return res.status(404).json({ error: 'Memory not found' });
+            }
+            res.json({ success: true, message: 'Memory archived successfully' });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/sati/memories/bulk-delete', async (req, res) => {
+        try {
+            const { ids } = req.body;
+            if (!ids || !Array.isArray(ids) || ids.length === 0) {
+                return res.status(400).json({ error: 'Ids array is required and cannot be empty' });
+            }
+            const repository = SatiRepository.getInstance();
+            let deletedCount = 0;
+            // Use a transaction for atomicity, but check if db is not null
+            const db = repository['db'];
+            if (!db) {
+                return res.status(500).json({ error: 'Database connection is not available' });
+            }
+            const transaction = db.transaction((memoryIds) => {
+                for (const id of memoryIds) {
+                    const success = repository.archiveMemory(id);
+                    if (success) {
+                        deletedCount++;
+                    }
+                }
+            });
+            transaction(ids);
+            res.json({
+                success: true,
+                message: `${deletedCount} memories archived successfully`,
+                deletedCount
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     // Keep PUT for backward compatibility if needed, or remove. 
     // Tasks says Implement POST. I'll remove PUT to avoid confusion or redirect it.
     router.put('/config', async (req, res) => {

package/dist/runtime/__tests__/manual_santi_verify.js

@@ -0,0 +1,55 @@
+import { Santi } from "../santi/santi.js";
+import { ConfigManager } from "../../config/manager.js";
+import * as path from "path";
+import { homedir } from "os";
+async function main() {
+    console.log("Starting Santi Manual Verification...");
+    // 1. Check DB isolation
+    const santiDbPath = path.join(homedir(), ".morpheus", "memory", "santi-memory.db");
+    const shortDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+    console.log(`Checking DB paths: \n- ${santiDbPath}\n- ${shortDbPath}`);
+    // 2. Initialize Santi
+    const santi = new Santi();
+    console.log("Santi initialized.");
+    // 3. Test Recovery (should be empty or have data if prev run)
+    let memories = await santi.recover("test");
+    console.log(`Initial recovery "test": ${memories.length} items`);
+    // 4. Manually add memory via internal store (reflection hack for test)
+    console.log("Injecting test memory...");
+    // @ts-ignore
+    santi.store.addMemory({
+        category: 'preference',
+        importance: 'high',
+        summary: 'The user loves manual testing scripts.',
+        hash: 'manual-test-hash',
+        source: 'manual_test'
+    });
+    // 5. Test Recovery again
+    memories = await santi.recover("loves manual testing");
+    console.log(`Recovery after injection "loves manual testing": ${memories.length} items`);
+    if (memories.length > 0 && memories[0].summary.includes("loves manual testing")) {
+        console.log("✅ Recovery SUCCESS");
+    }
+    else {
+        console.error("❌ Recovery FAILED");
+    }
+    // 6. Test Evaluate (Mocking messages)
+    // This requires LLM config to be present. 
+    // We skip this in manual test if no config, but logging will show warning.
+    if (ConfigManager.getInstance().get().llm) {
+        console.log("Testing Evaluate (dry run with LLM)...");
+        // This will assume valid LLM config
+        /*
+        await santi.evaluate([
+            new HumanMessage("My name is Morpheus Tester."),
+            new AIMessage("Nice to meet you.")
+        ]);
+        */
+        console.log("Evaluate test skipped to avoid api cost, but code is in place.");
+    }
+    else {
+        console.log("Skipping Evaluate test (no LLM config).");
+    }
+    console.log("Verification Complete.");
+}
+main().catch(console.error);

package/dist/runtime/display.js

@@ -80,6 +80,9 @@ export class DisplayManager {
             else if (options.source === 'Oracle') {
                 color = chalk.hex('#FFA500');
             }
+            else if (options.source === 'Sati') {
+                color = chalk.hex('#00ff22');
+            }
             else if (options.source === 'Telephonist') {
                 color = chalk.hex('#b902b9');
             }

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

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SatiRepository } from '../repository.js';
+import fs from 'fs-extra';
+import path from 'path';
+describe('SatiRepository', () => {
+    const dbPath = path.join(process.cwd(), 'test-memory.db');
+    let repo;
+    beforeEach(() => {
+        // Reset singleton instance for testing
+        SatiRepository.instance = null;
+        repo = SatiRepository.getInstance(dbPath);
+        repo.initialize();
+    });
+    afterEach(() => {
+        try {
+            repo.close();
+        }
+        catch (e) { }
+        if (fs.existsSync(dbPath)) {
+            try {
+                fs.unlinkSync(dbPath);
+                fs.rmdirSync(path.dirname(dbPath)); // cleanup dir if possible/empty
+            }
+            catch (e) { }
+        }
+    });
+    it('should save and retrieve memory', async () => {
+        const mem = {
+            category: 'preference',
+            importance: 'high',
+            summary: 'Test Memory',
+            hash: '123',
+            source: 'test'
+        };
+        await repo.save(mem);
+        const result = repo.findByHash('123');
+        expect(result).not.toBeNull();
+        expect(result?.summary).toBe('Test Memory');
+    });
+    it('should deduplicate (update) on hash collision', async () => {
+        const mem1 = {
+            category: 'preference',
+            importance: 'medium',
+            summary: 'Test Memory v1',
+            hash: 'abc',
+            source: 'test'
+        };
+        await repo.save(mem1);
+        const mem2 = {
+            category: 'preference',
+            importance: 'high',
+            summary: 'Test Memory v2', // Summary logic might not update summary field in my query
+            // Let's check my query in repository.ts:
+            // ON CONFLICT(hash) DO UPDATE SET importance..., details... but NOT summary.
+            // If hash is same, summary implies same content usually.
+            // But here I test that fields ARE updated.
+            hash: 'abc',
+            source: 'test',
+            details: 'updated details'
+        };
+        await repo.save(mem2);
+        const result = repo.findByHash('abc');
+        expect(result).not.toBeNull();
+        expect(result?.importance).toBe('high');
+        expect(result?.details).toBe('updated details');
+        // Since my query did not update summary (it assumed hash=summary match), summary should stay v1.
+        expect(result?.summary).toBe('Test Memory v1');
+        // Access count should increment
+        expect(result?.access_count).toBeGreaterThan(0);
+    });
+});

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

@@ -0,0 +1,99 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { SatiService } from '../service.js';
+import { SatiRepository } from '../repository.js';
+import { ProviderFactory } from '../../../providers/factory.js';
+// Mock ConfigManager
+vi.mock('../../../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: vi.fn().mockReturnValue({
+            get: vi.fn().mockReturnValue({ llm: { provider: 'test' } })
+        })
+    }
+}));
+// Mock ProviderFactory
+vi.mock('../../../providers/factory.js', () => ({
+    ProviderFactory: {
+        create: vi.fn()
+    }
+}));
+// Mock the repository module
+vi.mock('../repository.js', () => {
+    const SatiRepositoryMock = {
+        getInstance: vi.fn(),
+    };
+    return { SatiRepository: SatiRepositoryMock };
+});
+describe('SatiService', () => {
+    let service;
+    let mockRepo;
+    let mockAgent;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        // Setup mock repository instance
+        mockRepo = {
+            initialize: vi.fn(),
+            search: vi.fn(),
+            save: vi.fn(),
+            getAllMemories: vi.fn().mockReturnValue([]),
+        };
+        SatiRepository.getInstance.mockReturnValue(mockRepo);
+        // Setup mock agent
+        mockAgent = {
+            invoke: vi.fn()
+        };
+        ProviderFactory.create.mockResolvedValue(mockAgent);
+        service = SatiService.getInstance();
+        service.repository = mockRepo;
+    });
+    describe('recover', () => {
+        it('should recover memories calling repository with limit', async () => {
+            mockRepo.search.mockReturnValue([
+                { summary: 'Memory 1', category: 'preference', importance: 'high' },
+                { summary: 'Memory 2', category: 'project', importance: 'medium' }
+            ]);
+            const result = await service.recover('hello world', []);
+            expect(mockRepo.search).toHaveBeenCalledWith('hello world', 5);
+            expect(result.relevant_memories).toHaveLength(2);
+            expect(result.relevant_memories[0].summary).toBe('Memory 1');
+        });
+        it('should return empty list when no memories found', async () => {
+            mockRepo.search.mockReturnValue([]);
+            const result = await service.recover('unknown', []);
+            expect(mockRepo.search).toHaveBeenCalledWith('unknown', 5);
+            expect(result.relevant_memories).toEqual([]);
+        });
+    });
+    describe('evaluateAndPersist', () => {
+        it('should parse LLM response and persist memory', async () => {
+            mockAgent.invoke.mockResolvedValue({
+                messages: [{
+                        content: JSON.stringify({
+                            should_store: true,
+                            category: 'preference',
+                            importance: 'high',
+                            summary: 'User likes TypeScript',
+                            reason: 'User stated preference'
+                        })
+                    }]
+            });
+            await service.evaluateAndPersist([{ role: 'user', content: 'I like TypeScript' }]);
+            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                summary: 'User likes TypeScript',
+                category: 'preference',
+                importance: 'high'
+            }));
+        });
+        it('should not persist if should_store is false', async () => {
+            mockAgent.invoke.mockResolvedValue({
+                messages: [{
+                        content: JSON.stringify({
+                            should_store: false,
+                            reason: 'Chit chat'
+                        })
+                    }]
+            });
+            await service.evaluateAndPersist([{ role: 'user', content: 'Hi' }]);
+            expect(mockRepo.save).not.toHaveBeenCalled();
+        });
+    });
+});