morpheus-cli 0.1.11 → 0.2.2

package/dist/runtime/santi/middleware.js

@@ -0,0 +1,61 @@
+import { createMiddleware } from "langchain";
+import { SystemMessage } from "@langchain/core/messages";
+import { DisplayManager } from "../display.js";
+// T009: Create skeleton
+export const createSantiMiddleware = (santi) => {
+    const display = DisplayManager.getInstance();
+    return createMiddleware({
+        name: "SatiMemoryMiddleware",
+        // T010: beforeAgent hook
+        async beforeAgent(state) {
+            try {
+                const messages = state.messages;
+                if (!messages || messages.length === 0)
+                    return;
+                // Extract last user message
+                const lastMessage = messages[messages.length - 1];
+                if (lastMessage._getType() !== "human")
+                    return;
+                // Recover memories
+                const memories = await santi.recover(lastMessage.content);
+                if (memories.length > 0) {
+                    const memoryText = memories.map(m => `- [${m.category.toUpperCase()}] ${m.summary}`).join("\n");
+                    const systemMsg = new SystemMessage(`Relevant long-term memory about the Architect:\n${memoryText}`);
+                    // Inject into state logic - typically by appending to messages or inserting
+                    // Since this is "beforeAgent", modifying state.messages usually propagates to the agent input
+                    // We need to check if 'state' is mutable or if we return a diff.
+                    // In standard LangGraph/LangChain middleware, we might return an update.
+                    // Spec example: "return;" implies mutation of 'state' or side-effect? 
+                    // Spec: "The injection... should occur adding a SystemMessage to the array state.messages"
+                    // Assuming direct mutation as per common JS middleware patterns if not specified otherwise
+                    state.messages.push(systemMsg);
+                    display.log('Injected long-term memories into context', { source: 'SatiMiddleware' });
+                }
+            }
+            catch (error) {
+                display.log(`Error in beforeAgent: ${error}`, { level: "error", source: 'SatiMiddleware' });
+            }
+        },
+        // T013: afterAgent hook
+        async afterAgent(state) {
+            try {
+                const messages = state.messages;
+                // We interact with the *result* of the agent.
+                // 'state' usually contains the full history at this point.
+                // We pass the full recent history to evaluate.
+                if (messages && messages.length > 0) {
+                    // We fire and forget this to not block the response?
+                    // Or await it? Middleware in LangGraph might be blocking.
+                    // Given performance goals (<2s), and that this is post-generation, blocking is safer to ensure data consistency
+                    // but user might perceive latency.
+                    // Spec says "afterAgent... Persist if necessary".
+                    // We'll await it.
+                    await santi.evaluate(messages);
+                }
+            }
+            catch (error) {
+                display.log(`Error in afterAgent: ${error}`, { level: "error", source: 'SatiMiddleware' });
+            }
+        }
+    });
+};

package/dist/runtime/santi/santi.js

@@ -0,0 +1,109 @@
+import { HumanMessage } from "@langchain/core/messages";
+import { SantiStore } from "./store.js";
+import { DisplayManager } from "../display.js";
+import { ConfigManager } from "../../config/manager.js";
+import { ProviderFactory } from "../providers/factory.js";
+import * as crypto from 'crypto';
+export class Santi {
+    store;
+    display = DisplayManager.getInstance();
+    constructor() {
+        this.store = new SantiStore();
+    }
+    // T007 & T008: Recover implementation
+    async recover(message, limit = 5) {
+        this.display.log('Recovering memories...', { source: 'Sati' });
+        // 1. Keyword extraction (simple heuristic: words > 3 chars)
+        // Ideally this could be an LLM call to generate search queries, but for now we stick to the plan/store logic.
+        // If we want to be smarter, we could ask the LLM "Extract search keywords from this message".
+        // For MVP, direct search is faster and meets the "textual search" constraint.
+        // T008: Fetch from store
+        const memories = this.store.searchMemories(message, limit);
+        if (memories.length > 0) {
+            this.display.log(`Recovered ${memories.length} memories`, { source: 'Sati' });
+        }
+        return memories;
+    }
+    // T012: Evaluate implementation
+    async evaluate(recentMessages) {
+        if (recentMessages.length < 2)
+            return; // Need at least user + AI response to evaluate context
+        this.display.log('Evaluating interaction for memory persistence...', { source: 'Sati' });
+        try {
+            const config = ConfigManager.getInstance().get().llm;
+            if (!config) {
+                this.display.log('LLM config missing, skipping memory evaluation.', { level: "warning", source: 'Sati' });
+                return;
+            }
+            const model = ProviderFactory.createModel(config);
+            // Format conversation for prompt
+            const conversationText = recentMessages.map(m => {
+                const role = m._getType() === 'human' ? 'User' : 'Assistant';
+                const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+                return `${role}: ${content}`;
+            }).join('\n');
+            const prompt = `
+You are Sati, guardian of the long-term memory system.
+Analyze the interaction below between the Architect (User) and the System.
+
+Decide if there is any information that should be stored as long-term memory.
+Store ONLY:
+- Persistent preferences
+- Architectural decisions
+- Permanent constraints
+- Project context
+- Personal identity (non-sensitive)
+- Favorite languages/tech
+- Relationships/Pets/Names
+
+IGNORE:
+- One-off questions
+- Temporary context
+- Redundant info
+- SENSITIVE DATA (API Keys, Secrets, Passwords) - NEVER STORE THESE.
+
+Format output as JSON:
+{
+ "should_store": boolean,
+ "category": "preference" | "project" | "identity" | "constraint" | "context" | "personal_data" | "languages" | "favorite_things" | "relationships" | "pets" | "naming" | "professional_profile",
+ "importance": "low" | "medium" | "high",
+ "summary": "Concise summary",
+ "reason": "Why this is important"
+}
+
+Interaction:
+${conversationText}
+        `;
+            const response = await model.invoke([new HumanMessage(prompt)]);
+            const content = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+            // Parse JSON (handle potential markdown code blocks)
+            const jsonMatch = content.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                return; // No JSON found
+            }
+            const result = JSON.parse(jsonMatch[0]);
+            if (result.should_store && result.summary && result.category && result.importance) {
+                // T015: Privacy Filter (Regex check)
+                const sensitiveRegex = /(sk-[a-zA-Z0-9]{20,}|eyJ[a-zA-Z0-9]{20,}|password|secret|[0-9a-f]{32,})/;
+                if (sensitiveRegex.test(result.summary)) {
+                    this.display.log('Sensitive data detected in memory summary. Aborting persistence.', { level: 'warning', source: 'Sati' });
+                    return;
+                }
+                // Generate hash for deduplication
+                const hash = crypto.createHash('sha256').update(result.summary.toLowerCase().trim()).digest('hex');
+                // T014: Persist
+                const memory = this.store.addMemory({
+                    category: result.category,
+                    importance: result.importance,
+                    summary: result.summary,
+                    hash: hash,
+                    source: 'conversation_evaluation'
+                });
+                this.display.log(`Persisted new memory: ${memory.summary.substring(0, 50)}...`, { source: 'Sati' });
+            }
+        }
+        catch (err) {
+            this.display.log(`Evaluation failed: ${err}`, { level: "error", source: 'Sati' });
+        }
+    }
+}

package/dist/runtime/santi/store.js

@@ -0,0 +1,158 @@
+import Database from "better-sqlite3";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { homedir } from "os";
+import { v4 as uuidv4 } from 'uuid';
+export class SantiStore {
+    db;
+    constructor(databasePath) {
+        const dbPath = databasePath || path.join(homedir(), ".morpheus", "memory", "santi-memory.db");
+        this.ensureDirectory(dbPath);
+        this.db = new Database(dbPath, { timeout: 5000 });
+        this.init();
+    }
+    ensureDirectory(filePath) {
+        const dir = path.dirname(filePath);
+        fs.ensureDirSync(dir);
+    }
+    init() {
+        // T003: Table creation
+        const schema = `
+      CREATE TABLE IF NOT EXISTS long_term_memory (
+        id TEXT PRIMARY KEY,
+        category TEXT NOT NULL CHECK(category IN ('preference','project','identity','constraint','context','personal_data','languages','favorite_things','relationships','pets','naming','professional_profile')),
+        importance TEXT NOT NULL CHECK(importance IN ('low','medium','high')),
+        summary TEXT NOT NULL,
+        details TEXT,
+        hash TEXT NOT NULL UNIQUE,
+        source TEXT,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        last_accessed_at DATETIME,
+        access_count INTEGER DEFAULT 0,
+        version INTEGER DEFAULT 1,
+        archived BOOLEAN DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_category ON long_term_memory(category);
+      CREATE INDEX IF NOT EXISTS idx_memory_importance ON long_term_memory(importance);
+      CREATE INDEX IF NOT EXISTS idx_memory_archived ON long_term_memory(archived);
+    `;
+        this.db.exec(schema);
+    }
+    // T004: addMemory
+    addMemory(memory) {
+        // Check for existing hash
+        const existing = this.db.prepare('SELECT * FROM long_term_memory WHERE hash = ?').get(memory.hash);
+        if (existing) {
+            // If exact hash match, return existing (idempotent)
+            return existing;
+        }
+        const id = uuidv4();
+        const now = new Date().toISOString();
+        const newMemory = {
+            ...memory,
+            id,
+            details: memory.details || null, // Ensure explicit null if undefined
+            source: memory.source || null,
+            created_at: now,
+            updated_at: now,
+            access_count: 0,
+            version: 1,
+            archived: false
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO long_term_memory (
+        id, category, importance, summary, details, hash, source, 
+        created_at, updated_at, access_count, version, archived
+      ) VALUES (
+        @id, @category, @importance, @summary, @details, @hash, @source,
+        @created_at, @updated_at, @access_count, @version, @archived
+      )
+    `);
+        const bindParams = {
+            ...newMemory,
+            archived: newMemory.archived ? 1 : 0
+        };
+        stmt.run(bindParams);
+        return newMemory;
+    }
+    // T005: searchMemories
+    searchMemories(query, limit = 5) {
+        // Basic text search using LIKE for now as per requirements (no vectors)
+        // We split query into keywords and search for any match
+        // Prioritizing importance and recency
+        const keywords = query.split(' ').filter(word => word.length > 3).map(w => `%${w}%`);
+        if (keywords.length === 0)
+            return [];
+        // Construct dynamic query for multiple keywords (OR logic for broader retrieval, refined by importance)
+        const conditions = keywords.map((_, i) => `summary LIKE ?`).join(' OR ');
+        const stmt = this.db.prepare(`
+      SELECT * FROM long_term_memory 
+      WHERE archived = 0 AND (${conditions})
+      ORDER BY 
+        CASE importance 
+          WHEN 'high' THEN 1 
+          WHEN 'medium' THEN 2 
+          WHEN 'low' THEN 3 
+        END ASC,
+        updated_at DESC
+      LIMIT ?
+    `);
+        const results = stmt.all(...keywords, limit);
+        // Update access stats
+        if (results.length > 0) {
+            this.updateAccessStats(results.map(r => r.id));
+        }
+        return results;
+    }
+    updateAccessStats(ids) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`
+        UPDATE long_term_memory 
+        SET access_count = access_count + 1, last_accessed_at = ?
+        WHERE id = ?
+      `);
+        const transaction = this.db.transaction((timestamp, memoryIds) => {
+            for (const id of memoryIds) {
+                stmt.run(timestamp, id);
+            }
+        });
+        transaction(now, ids);
+    }
+    // T006: updateMemory
+    updateMemory(id, data) {
+        const setClauses = [];
+        const params = [];
+        if (data.summary) {
+            setClauses.push("summary = ?");
+            params.push(data.summary);
+        }
+        if (data.details) {
+            setClauses.push("details = ?");
+            params.push(data.details);
+        }
+        if (data.importance) {
+            setClauses.push("importance = ?");
+            params.push(data.importance);
+        }
+        if (data.hash) {
+            setClauses.push("hash = ?");
+            params.push(data.hash);
+        }
+        if (setClauses.length === 0)
+            return;
+        setClauses.push("updated_at = CURRENT_TIMESTAMP");
+        setClauses.push("version = version + 1");
+        params.push(id); // Where ID
+        const stmt = this.db.prepare(`
+          UPDATE long_term_memory
+          SET ${setClauses.join(', ')}
+          WHERE id = ?
+      `);
+        stmt.run(...params);
+    }
+    getByHash(hash) {
+        return this.db.prepare('SELECT * FROM long_term_memory WHERE hash = ?').get(hash);
+    }
+}

package/dist/runtime/tools/factory.js

@@ -29,7 +29,7 @@ function sanitizeSchema(obj) {
  * Creates a proxy that intercepts schema access and sanitizes the output.
  */
 function wrapToolWithSanitizedSchema(tool) {
-    display.log('Tool loaded: - ' + tool.name, { source: 'Construtor' });
+    // display.log('Tool loaded: - '+ tool.name, { source: 'Construtor' });
     // The MCP tools have a schema property that returns JSON Schema
     // We need to intercept and sanitize it
     const originalSchema = tool.schema;
@@ -45,34 +45,40 @@ export class Construtor {
         const display = DisplayManager.getInstance();
         const mcpServers = await loadMCPConfig();
         const serverCount = Object.keys(mcpServers).length;
+        // console.log(mcpServers);
         if (serverCount === 0) {
             display.log('No MCP servers configured in mcps.json', { level: 'info', source: 'Construtor' });
             return [];
         }
-        const client = new MultiServerMCPClient({
-            mcpServers: mcpServers,
-            onConnectionError: "ignore",
-            // log the MCP client's internal events
-            // beforeToolCall: ({ serverName, name, args }) => {
-            //   display.log(`MCP Tool Call - Server: ${serverName}, Tool: ${name}, Args: ${JSON.stringify(args)}`, { source: 'MCPServer' });
-            //   return;
-            // },
-            // // log the results of tool calls
-            // afterToolCall: (res) => {
-            //   display.log(`MCP Tool Result - ${JSON.stringify(res)}`, { source: 'MCPServer' });
-            //   return;
-            // }
-        });
-        try {
-            const tools = await client.getTools();
-            // Sanitize tool schemas to remove fields not supported by Gemini
-            const sanitizedTools = tools.map(tool => wrapToolWithSanitizedSchema(tool));
-            display.log(`Loaded ${sanitizedTools.length} MCP tools (schemas sanitized for Gemini compatibility)`, { level: 'info', source: 'Construtor' });
-            return sanitizedTools;
-        }
-        catch (error) {
-            display.log(`Failed to initialize MCP tools: ${error}`, { level: 'warning', source: 'Construtor' });
-            return []; // Return empty tools on failure to allow agent to start
+        const allTools = [];
+        // Create a client for each server to handle tool naming conflicts
+        for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+            const client = new MultiServerMCPClient({
+                mcpServers: {
+                    [serverName]: serverConfig
+                },
+                onConnectionError: "ignore",
+            });
+            try {
+                const tools = await client.getTools();
+                // Rename tools to include server prefix to avoid collisions
+                tools.forEach(tool => {
+                    const originalName = tool.name;
+                    const newName = `${serverName}_${originalName}`;
+                    Object.defineProperty(tool, "name", { value: newName });
+                    const shortDesc = tool.description && typeof tool.description === 'string' ? tool.description.slice(0, 100) + '...' : '';
+                    display.log(`\nLoaded MCP tool: ${tool.name} (from ${serverName})\n ${shortDesc}`, { level: 'info', source: 'Construtor' });
+                });
+                // Sanitize tool schemas to remove fields not supported by Gemini
+                const sanitizedTools = tools.map(tool => wrapToolWithSanitizedSchema(tool));
+                allTools.push(...sanitizedTools);
+            }
+            catch (error) {
+                display.log(`Failed to initialize MCP tools for server '${serverName}': ${error}`, { level: 'warning', source: 'Construtor' });
+                // Continue to other servers even if one fails
+            }
         }
+        display.log(`Loaded ${allTools.length} total MCP tools (schemas sanitized for Gemini compatibility)`, { level: 'info', source: 'Construtor' });
+        return allTools;
     }
 }

package/dist/types/config.js

@@ -21,6 +21,7 @@ export const DEFAULT_CONFIG = {
         provider: 'openai',
         model: 'gpt-4',
         temperature: 0.7,
+        context_window: 100,
     },
     channels: {
         telegram: { enabled: false, allowedUsers: [] },