morpheus-cli 0.4.14 → 0.5.0

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

@@ -60,7 +60,6 @@ export class SatiService {
             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);
             // Map conversation to strict types and sanitize
             const recentConversation = conversation.map(c => ({
                 role: (c.role === 'human' ? 'user' : c.role),
@@ -68,7 +67,12 @@ export class SatiService {
             }));
             const inputPayload = {
                 recent_conversation: recentConversation,
-                existing_memory_summaries: existingSummaries
+                existing_memories: allMemories.map(m => ({
+                    id: m.id,
+                    category: m.category,
+                    importance: m.importance,
+                    summary: m.summary
+                }))
             };
             const messages = [
                 new SystemMessage(SATI_EVALUATION_PROMPT),
@@ -114,7 +118,7 @@ export class SatiService {
             }
             // Safe JSON parsing (handle markdown blocks if LLM wraps output)
             content = content.replace(/```json/g, '').replace(/```/g, '').trim();
-            let result = [];
+            let result = { inclusions: [], edits: [], deletions: [] };
             try {
                 result = JSON.parse(content);
             }
@@ -122,8 +126,10 @@ export class SatiService {
                 console.warn('[SatiService] Failed to parse JSON response:', content);
                 return;
             }
-            for (const item of result) {
-                if (item.should_store && item.summary && item.category && item.importance) {
+            const embeddingService = await EmbeddingService.getInstance();
+            // Process inclusions (new memories)
+            for (const item of (result.inclusions ?? [])) {
+                if (item.summary && item.category && item.importance) {
                     display.log(`Persisting new memory: [${item.category.toUpperCase()}] ${item.summary}`, { source: 'Sati' });
                     try {
                         const savedMemory = await this.repository.save({
@@ -134,22 +140,14 @@ export class SatiService {
                             hash: this.generateHash(item.summary),
                             source: 'conversation'
                         });
-                        // 🔥 GERAR EMBEDDING
-                        const embeddingService = await EmbeddingService.getInstance();
-                        const textForEmbedding = [
-                            savedMemory.summary,
-                            savedMemory.details ?? ''
-                        ].join(' ');
+                        const textForEmbedding = [savedMemory.summary, savedMemory.details ?? ''].join(' ');
                         const embedding = await embeddingService.generate(textForEmbedding);
                         display.log(`Generated embedding for memory ID ${savedMemory.id}`, { source: 'Sati', level: 'debug' });
-                        // 🔥 SALVAR EMBEDDING NO SQLITE_VEC
                         this.repository.upsertEmbedding(savedMemory.id, embedding);
-                        // Quiet success - logging handled by repository/middleware if needed, or verbose debug
                     }
                     catch (saveError) {
                         if (saveError.message && saveError.message.includes('UNIQUE constraint failed')) {
-                            // Duplicate detected by DB (Hash collision)
-                            // This is expected given T012 logic
+                            // Duplicate detected by DB (hash collision) — expected
                         }
                         else {
                             throw saveError;
@@ -157,6 +155,39 @@ export class SatiService {
                     }
                 }
             }
+            // Process edits (update existing memories)
+            for (const edit of (result.edits ?? [])) {
+                if (!edit.id)
+                    continue;
+                const updated = this.repository.update(edit.id, {
+                    importance: edit.importance,
+                    summary: edit.summary,
+                    details: edit.details,
+                });
+                if (updated) {
+                    display.log(`Updated memory ${edit.id}: ${edit.reason ?? ''}`, { source: 'Sati' });
+                    if (edit.summary || edit.details) {
+                        const text = [updated.summary, updated.details ?? ''].join(' ');
+                        const embedding = await embeddingService.generate(text);
+                        this.repository.upsertEmbedding(updated.id, embedding);
+                    }
+                }
+                else {
+                    display.log(`Edit skipped — memory not found: ${edit.id}`, { source: 'Sati', level: 'warning' });
+                }
+            }
+            // Process deletions (archive memories)
+            for (const deletion of (result.deletions ?? [])) {
+                if (!deletion.id)
+                    continue;
+                const archived = this.repository.archiveMemory(deletion.id);
+                if (archived) {
+                    display.log(`Archived memory ${deletion.id}: ${deletion.reason ?? ''}`, { source: 'Sati' });
+                }
+                else {
+                    display.log(`Deletion skipped — memory not found: ${deletion.id}`, { source: 'Sati', level: 'warning' });
+                }
+            }
         }
         catch (error) {
             console.error('[SatiService] Evaluation failed:', error);

package/dist/runtime/memory/sati/system-prompts.js

@@ -1,13 +1,27 @@
 export const SATI_EVALUATION_PROMPT = `You are **Sati**, an autonomous background memory manager for an AI assistant.
-Your goal is to analyze the conversation interaction and decide if any **Persistent Long-Term Memory** should be stored.
+Your goal is to analyze the conversation and decide what changes to make to the long-term memory store.
+You have full CRUD power: you can create new memories, edit existing ones, or delete memories that are no longer valid.
 
 ### INPUT DATA
-You will receive:
-1. A list of recent messages (USER and ASSISTANT).
-2. A list of ALREADY EXISTING memory summaries (to avoid duplicates).
+You will receive a JSON object with:
+1. \`recent_conversation\` — list of recent messages (user and assistant).
+2. \`existing_memories\` — full objects for all current memories (with IDs), so you can reference them for edits or deletions.
+
+Example input:
+\`\`\`json
+{
+  "recent_conversation": [
+    { "role": "user", "content": "..." },
+    { "role": "assistant", "content": "..." }
+  ],
+  "existing_memories": [
+    { "id": "uuid", "category": "preference", "importance": "medium", "summary": "..." }
+  ]
+}
+\`\`\`
 
 ### MEMORY CATEGORIES
-Classify any new memory into one of these types:
+Classify memories into one of these types:
 - **preference**: User preferences (e.g., "I like dark mode", "Use TypeScript").
 - **project**: Details about the user's projects, architecture, or tech stack.
 - **identity**: Facts about the user's identity, role, or background.
@@ -22,32 +36,60 @@ Classify any new memory into one of these types:
 - **professional_profile**: Job title, industry, skills.
 
 ### CRITICAL RULES
-0. **SAVE ON SUMMARY and REASONING IN ENGLISH AND NATIVE LANGUAGE**: Always generate a concise summary in English and, if the original information is in another language, also provide a summary in the original language. This ensures the memory is accessible and useful for future interactions, regardless of the language used.
-1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens. If found, ignore them explicitly.
-2. **NO DUPLICATES**: If the information is already covered by the \`existing_memory_summaries\`, DO NOT store it again.
-3. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
-4. **IMPORTANCE**: Assign 'low', 'medium', or 'high' importance. Store only 'medium' or 'high' unless it's a specific user preference (which is always important).
+0. **SUMMARIES IN ENGLISH AND NATIVE LANGUAGE**: Always write summaries in English. If the original content is in another language, also include a summary in that language (e.g., "Prefers TypeScript | Prefere TypeScript").
+1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens.
+2. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
+3. **NO PERSONAL FINANCIAL**: Avoid storing sensitive financial information (income, debts, expenses).
+4. **IMPORTANCE**: Assign 'low', 'medium', or 'high'. Prefer 'medium' or 'high' — only use 'low' for minor context.
+5. **OBEY THE USER**: If the user explicitly states something should be remembered, store it with at least 'medium' importance.
+
+### WHEN TO INCLUDE (create new memory)
+- The information is **genuinely new** and not covered by any entry in \`existing_memories\`.
+- Do NOT create a new entry if an existing memory already captures the same fact.
 
-### TOP IMPORTANT GUIDELINES
-5. **OBEY THE USER**: If the user explicitly states something should be remembered, it must be stored with at least 'medium' importance.
+### WHEN TO EDIT an existing memory
+- The user **confirmed or reinforced** an existing preference/fact → elevate importance (e.g., medium → high).
+- The existing memory is **slightly incorrect or outdated** → correct the summary.
+- The user provided **additional detail** about something already stored → update details field.
+- Use the **exact \`id\`** from \`existing_memories\`. Only include fields that actually change.
+- **Never duplicate** — if the info hasn't changed, do nothing.
+
+### WHEN TO DELETE an existing memory
+- The user **explicitly denied** a stored fact ("No, I don't prefer X", "That's wrong").
+- A memory was **proven false** during this conversation.
+- The user **explicitly asked to forget** something specific.
+- Use the **exact \`id\`** from \`existing_memories\`.
 
 ### OUTPUT FORMAT
-You MUST respond with a valid JSON object ARRAY matching the \`ISatiEvaluationOutputArray\` interface:
-[
-  {
-    "should_store": boolean,
-    "category": "category_name" | null,
-    "importance": "low" | "medium" | "high" | null,
-    "summary": "Concise factual statement | Summary in native language" | null,
-    "reason": "Why you decided to store or not store | Reason in native language"
-  },
-  {
-    "should_store": boolean,
-    "category": "category_name" | null,
-    "importance": "low" | "medium" | "high" | null,
-    "summary": "Concise factual statement | Summary in native language" | null,
-    "reason": "Why you decided to store or not store | Reason in native language"
-  },
-]
+Respond with a valid JSON object matching this structure. All three arrays are required (use empty arrays if nothing applies):
+
+\`\`\`json
+{
+  "inclusions": [
+    {
+      "category": "preference",
+      "importance": "high",
+      "summary": "Concise factual statement | Summary in native language",
+      "reason": "Why this is being stored"
+    }
+  ],
+  "edits": [
+    {
+      "id": "uuid-of-existing-memory",
+      "importance": "high",
+      "summary": "Updated summary if changed",
+      "details": "Updated details if changed",
+      "reason": "Why this is being edited"
+    }
+  ],
+  "deletions": [
+    {
+      "id": "uuid-of-existing-memory",
+      "reason": "Why this memory is being deleted"
+    }
+  ]
+}
+\`\`\`
 
+Empty arrays are perfectly valid. Only include fields in edits that actually need to change.
 `;

package/dist/runtime/memory/sqlite.js

@@ -290,6 +290,30 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to retrieve messages: ${error}`);
         }
     }
+    /**
+     * Retrieves raw stored messages for one or more session IDs.
+     * Useful when the caller needs metadata like session_id and created_at.
+     */
+    async getRawMessagesBySessionIds(sessionIds, limit = this.limit) {
+        if (sessionIds.length === 0) {
+            return [];
+        }
+        try {
+            const placeholders = sessionIds.map(() => '?').join(', ');
+            const stmt = this.db.prepare(`SELECT id, session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model
+         FROM messages
+         WHERE session_id IN (${placeholders})
+         ORDER BY id DESC
+         LIMIT ?`);
+            return stmt.all(...sessionIds, limit);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('SQLITE_BUSY')) {
+                throw new Error(`Database is locked. Please try again. Original error: ${error.message}`);
+            }
+            throw new Error(`Failed to retrieve raw messages: ${error}`);
+        }
+    }
     /**
      * Adds a message to the database.
      * @param message The message to add

package/dist/runtime/neo.js

@@ -0,0 +1,134 @@
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
+import { ConfigManager } from "../config/manager.js";
+import { ProviderFactory } from "./providers/factory.js";
+import { ProviderError } from "./errors.js";
+import { DisplayManager } from "./display.js";
+import { Construtor } from "./tools/factory.js";
+import { ConfigQueryTool, ConfigUpdateTool, DiagnosticTool, MessageCountTool, TokenUsageTool, ProviderModelUsageTool, } from "./tools/index.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+import { TaskRequestContext } from "./tasks/context.js";
+import { updateNeoDelegateToolDescription } from "./tools/neo-tool.js";
+export class Neo {
+    static instance = null;
+    static currentSessionId = undefined;
+    agent;
+    config;
+    display = DisplayManager.getInstance();
+    constructor(config) {
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    static setSessionId(sessionId) {
+        Neo.currentSessionId = sessionId;
+    }
+    static getInstance(config) {
+        if (!Neo.instance) {
+            Neo.instance = new Neo(config);
+        }
+        return Neo.instance;
+    }
+    static resetInstance() {
+        Neo.instance = null;
+    }
+    static async refreshDelegateCatalog() {
+        const mcpTools = await Construtor.create();
+        const catalogTools = [
+            ...mcpTools,
+            ConfigQueryTool,
+            ConfigUpdateTool,
+            DiagnosticTool,
+            MessageCountTool,
+            TokenUsageTool,
+            ProviderModelUsageTool
+        ];
+        updateNeoDelegateToolDescription(catalogTools);
+    }
+    async initialize() {
+        const neoConfig = this.config.neo || this.config.llm;
+        const mcpTools = await Construtor.create();
+        const tools = [
+            ...mcpTools,
+            ConfigQueryTool,
+            ConfigUpdateTool,
+            DiagnosticTool,
+            MessageCountTool,
+            TokenUsageTool,
+            ProviderModelUsageTool
+        ];
+        updateNeoDelegateToolDescription(tools);
+        this.display.log(`Neo initialized with ${tools.length} tools.`, { source: "Neo" });
+        try {
+            this.agent = await ProviderFactory.create(neoConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(neoConfig.provider, err, "Neo subagent initialization failed");
+        }
+    }
+    async execute(task, context, sessionId, taskContext) {
+        const neoConfig = this.config.neo || this.config.llm;
+        if (!this.agent) {
+            await this.initialize();
+        }
+        this.display.log(`Executing delegated task in Neo: ${task.slice(0, 80)}...`, {
+            source: "Neo",
+        });
+        const systemMessage = new SystemMessage(`
+You are Neo, an execution subagent in Morpheus.
+
+You execute tasks using MCP and internal tools.
+Focus on verifiable execution and return objective results.
+
+Rules:
+1. Use tools whenever task depends on external/system state.
+2. Validate outputs before final answer.
+3. If blocked, explain what is missing.
+4. Keep output concise and actionable.
+5. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
+6. For connectivity checks, prefer the dedicated network "ping" tool semantics (reachability) and avoid forcing shell flags.
+7. If delegating shell ping to Apoc is explicitly required, include OS-aware guidance: Windows uses "-n", Linux/macOS uses "-c".
+
+${context ? `Context:\n${context}` : ""}
+    `);
+        const userMessage = new HumanMessage(task);
+        const messages = [systemMessage, userMessage];
+        try {
+            const invokeContext = {
+                origin_channel: taskContext?.origin_channel ?? "api",
+                session_id: taskContext?.session_id ?? sessionId ?? "default",
+                origin_message_id: taskContext?.origin_message_id,
+                origin_user_id: taskContext?.origin_user_id,
+            };
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }));
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === "string"
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            const targetSession = sessionId ?? Neo.currentSessionId ?? "neo";
+            const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
+            try {
+                const persisted = new AIMessage(content);
+                persisted.usage_metadata = lastMessage.usage_metadata
+                    ?? lastMessage.response_metadata?.usage
+                    ?? lastMessage.response_metadata?.tokenUsage
+                    ?? lastMessage.usage;
+                persisted.provider_metadata = {
+                    provider: neoConfig.provider,
+                    model: neoConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
+            this.display.log("Neo task completed.", { source: "Neo" });
+            return content;
+        }
+        catch (err) {
+            throw new ProviderError(neoConfig.provider, err, "Neo task execution failed");
+        }
+    }
+    async reload() {
+        this.config = ConfigManager.getInstance().get();
+        this.agent = undefined;
+        await this.initialize();
+    }
+}