morpheus-cli 0.4.15 → 0.5.1

package/dist/http/api.js

@@ -11,6 +11,10 @@ import { z } from 'zod';
 import { MCPManager } from '../config/mcp-manager.js';
 import { MCPServerConfigSchema } from '../config/schemas.js';
 import { Construtor } from '../runtime/tools/factory.js';
+import { TaskRepository } from '../runtime/tasks/repository.js';
+import { DatabaseRegistry } from '../runtime/memory/trinity-db.js';
+import { testConnection, introspectSchema } from '../runtime/trinity-connector.js';
+import { Trinity } from '../runtime/trinity.js';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -25,6 +29,7 @@ export function createApiRouter(oracle) {
     const router = Router();
     const configManager = ConfigManager.getInstance();
     const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+    const taskRepository = TaskRepository.getInstance();
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {
@@ -83,18 +88,76 @@ export function createApiRouter(oracle) {
         const { id } = req.params;
         const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
         try {
-            const messages = await sessionHistory.getMessages();
-            // Normalize messages for UI
-            const normalizedMessages = messages.map((msg) => {
-                const type = msg._getType ? msg._getType() : 'unknown';
+            const relatedSessionIds = id.startsWith('sati-evaluation-')
+                ? [id]
+                : [id, `sati-evaluation-${id}`];
+            const rows = await sessionHistory.getRawMessagesBySessionIds(relatedSessionIds, 200);
+            const normalizedMessages = rows.map((row) => {
+                let content = row.content;
+                let tool_calls;
+                let tool_name;
+                let tool_call_id;
+                if (row.type === 'ai') {
+                    try {
+                        const parsed = JSON.parse(row.content);
+                        if (parsed && typeof parsed === 'object') {
+                            if (Array.isArray(parsed.tool_calls)) {
+                                tool_calls = parsed.tool_calls;
+                            }
+                            if (typeof parsed.text === 'string') {
+                                content = parsed.text;
+                            }
+                        }
+                    }
+                    catch {
+                        // Keep raw content for legacy/plain-text messages.
+                    }
+                }
+                if (row.type === 'tool') {
+                    try {
+                        const parsed = JSON.parse(row.content);
+                        if (parsed && typeof parsed === 'object') {
+                            if (parsed.content !== undefined) {
+                                const parsedContent = parsed.content;
+                                content =
+                                    typeof parsedContent === 'string'
+                                        ? parsedContent
+                                        : JSON.stringify(parsedContent, null, 2);
+                            }
+                            if (typeof parsed.name === 'string') {
+                                tool_name = parsed.name;
+                            }
+                            if (typeof parsed.tool_call_id === 'string') {
+                                tool_call_id = parsed.tool_call_id;
+                            }
+                        }
+                    }
+                    catch {
+                        // Keep raw content for legacy/plain-text tool messages.
+                    }
+                }
+                const usage_metadata = row.total_tokens != null
+                    ? {
+                        input_tokens: row.input_tokens || 0,
+                        output_tokens: row.output_tokens || 0,
+                        total_tokens: row.total_tokens || 0,
+                        input_token_details: row.cache_read_tokens
+                            ? { cache_read: row.cache_read_tokens }
+                            : undefined,
+                    }
+                    : undefined;
                 return {
-                    type,
-                    content: msg.content,
-                    tool_calls: msg.tool_calls,
-                    usage_metadata: msg.usage_metadata
+                    session_id: row.session_id,
+                    created_at: row.created_at,
+                    type: row.type,
+                    content,
+                    tool_calls,
+                    tool_name,
+                    tool_call_id,
+                    usage_metadata,
                 };
             });
-            // Reverse to chronological order for UI
+            // Convert DESC to ASC for UI rendering
             res.json(normalizedMessages.reverse());
         }
         catch (err) {
@@ -117,13 +180,74 @@ export function createApiRouter(oracle) {
         try {
             const { message, sessionId } = parsed.data;
             await oracle.setSessionId(sessionId);
-            const response = await oracle.chat(message);
+            const response = await oracle.chat(message, undefined, false, {
+                origin_channel: 'ui',
+                session_id: sessionId,
+            });
             res.json({ response });
         }
         catch (err) {
             res.status(500).json({ error: err.message });
         }
     });
+    const TaskStatusSchema = z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']);
+    const TaskAgentSchema = z.enum(['apoc', 'neo', 'trinit']);
+    const OriginChannelSchema = z.enum(['telegram', 'discord', 'ui', 'api', 'webhook', 'cli']);
+    router.get('/tasks', (req, res) => {
+        try {
+            const status = req.query.status;
+            const agent = req.query.agent;
+            const originChannel = req.query.origin_channel;
+            const sessionId = req.query.session_id;
+            const limit = req.query.limit;
+            const parsedStatus = typeof status === 'string' ? TaskStatusSchema.safeParse(status) : null;
+            const parsedAgent = typeof agent === 'string' ? TaskAgentSchema.safeParse(agent) : null;
+            const parsedOrigin = typeof originChannel === 'string' ? OriginChannelSchema.safeParse(originChannel) : null;
+            const tasks = taskRepository.listTasks({
+                status: parsedStatus?.success ? parsedStatus.data : undefined,
+                agent: parsedAgent?.success ? parsedAgent.data : undefined,
+                origin_channel: parsedOrigin?.success ? parsedOrigin.data : undefined,
+                session_id: typeof sessionId === 'string' ? sessionId : undefined,
+                limit: typeof limit === 'string' ? Math.max(1, Math.min(500, Number(limit) || 200)) : 200,
+            });
+            res.json(tasks);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/tasks/stats', (req, res) => {
+        try {
+            res.json(taskRepository.getStats());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/tasks/:id', (req, res) => {
+        try {
+            const task = taskRepository.getTaskById(req.params.id);
+            if (!task) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            res.json(task);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/tasks/:id/retry', (req, res) => {
+        try {
+            const ok = taskRepository.retryTask(req.params.id);
+            if (!ok) {
+                return res.status(404).json({ error: 'Failed task not found for retry' });
+            }
+            res.json({ success: true });
+        }
+        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 {
@@ -396,6 +520,52 @@ export function createApiRouter(oracle) {
             res.status(500).json({ error: error.message });
         }
     });
+    // Neo config endpoints
+    router.get('/config/neo', (req, res) => {
+        try {
+            const neoConfig = configManager.getNeoConfig();
+            res.json(neoConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/neo', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, neo: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Neo 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/neo', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { neo: _neo, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Neo 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 });
+        }
+    });
     router.post('/config/apoc', async (req, res) => {
         try {
             const config = configManager.get();
@@ -578,6 +748,225 @@ export function createApiRouter(oracle) {
         // Redirect to POST logic or just reuse
         res.status(307).redirect(307, '/api/config');
     });
+    // ─── Trinity Config ────────────────────────────────────────────────────────
+    router.get('/config/trinity', (req, res) => {
+        try {
+            const trinityConfig = configManager.getTrinityConfig();
+            res.json(trinityConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/trinity', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, trinity: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Trinity 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/trinity', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { trinity: _trinity, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Trinity 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 });
+        }
+    });
+    // ─── Trinity Databases CRUD ─────────────────────────────────────────────────
+    const DatabaseCreateSchema = z.object({
+        name: z.string().min(1).max(100),
+        type: z.enum(['postgresql', 'mysql', 'sqlite', 'mongodb']),
+        host: z.string().optional().nullable(),
+        port: z.number().int().positive().optional().nullable(),
+        database_name: z.string().optional().nullable(),
+        username: z.string().optional().nullable(),
+        password: z.string().optional().nullable(),
+        connection_string: z.string().optional().nullable(),
+        allow_read: z.boolean().optional(),
+        allow_insert: z.boolean().optional(),
+        allow_update: z.boolean().optional(),
+        allow_delete: z.boolean().optional(),
+        allow_ddl: z.boolean().optional(),
+    });
+    router.get('/trinity/databases', (req, res) => {
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const databases = registry.listDatabases().map((db) => ({
+                ...db,
+                password: db.password ? '***' : null,
+                connection_string: db.connection_string ? '***' : null,
+            }));
+            res.json(databases);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.get('/trinity/databases/:id', (req, res) => {
+        try {
+            const id = parseInt(req.params.id);
+            if (isNaN(id))
+                return res.status(400).json({ error: 'Invalid id' });
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.getDatabase(id);
+            if (!db)
+                return res.status(404).json({ error: 'Database not found' });
+            res.json({
+                ...db,
+                password: db.password ? '***' : null,
+                connection_string: db.connection_string ? '***' : null,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/trinity/databases', async (req, res) => {
+        const parsed = DatabaseCreateSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.createDatabase(parsed.data);
+            // Test connection
+            let connectionOk = false;
+            try {
+                connectionOk = await testConnection(db);
+            }
+            catch { /* ignore */ }
+            // Introspect schema if connection successful
+            if (connectionOk) {
+                try {
+                    const schema = await introspectSchema(db);
+                    registry.updateSchema(db.id, JSON.stringify(schema, null, 2));
+                    await Trinity.refreshDelegateCatalog().catch(() => { });
+                }
+                catch { /* ignore schema errors */ }
+            }
+            const refreshed = registry.getDatabase(db.id);
+            res.status(201).json({
+                ...refreshed,
+                password: refreshed.password ? '***' : null,
+                connection_string: refreshed.connection_string ? '***' : null,
+                connection_ok: connectionOk,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.put('/trinity/databases/:id', async (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        const parsed = DatabaseCreateSchema.partial().safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const updated = registry.updateDatabase(id, parsed.data);
+            if (!updated)
+                return res.status(404).json({ error: 'Database not found' });
+            // Re-test and re-introspect
+            let connectionOk = false;
+            try {
+                connectionOk = await testConnection(updated);
+            }
+            catch { /* ignore */ }
+            if (connectionOk) {
+                try {
+                    const schema = await introspectSchema(updated);
+                    registry.updateSchema(id, JSON.stringify(schema, null, 2));
+                    await Trinity.refreshDelegateCatalog().catch(() => { });
+                }
+                catch { /* ignore */ }
+            }
+            const refreshed = registry.getDatabase(id);
+            res.json({
+                ...refreshed,
+                password: refreshed.password ? '***' : null,
+                connection_string: refreshed.connection_string ? '***' : null,
+                connection_ok: connectionOk,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.delete('/trinity/databases/:id', (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const deleted = registry.deleteDatabase(id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Database not found' });
+            Trinity.refreshDelegateCatalog().catch(() => { });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/trinity/databases/:id/refresh-schema', async (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.getDatabase(id);
+            if (!db)
+                return res.status(404).json({ error: 'Database not found' });
+            const schema = await introspectSchema(db);
+            registry.updateSchema(id, JSON.stringify(schema, null, 2));
+            await Trinity.refreshDelegateCatalog().catch(() => { });
+            const tableNames = schema.databases
+                ? schema.databases.flatMap((d) => d.tables.map((t) => `${d.name}.${t.name}`))
+                : schema.tables.map((t) => t.name);
+            res.json({ success: true, tables: tableNames, databases: schema.databases?.length });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/trinity/databases/:id/test', async (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.getDatabase(id);
+            if (!db)
+                return res.status(404).json({ error: 'Database not found' });
+            const ok = await testConnection(db);
+            res.json({ success: ok, status: ok ? 'connected' : 'failed' });
+        }
+        catch (error) {
+            res.json({ success: false, status: 'error', error: error.message });
+        }
+    });
     router.get('/logs', async (req, res) => {
         try {
             await fs.ensureDir(PATHS.logs);

package/dist/runtime/apoc.js

@@ -1,4 +1,4 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+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";
@@ -95,6 +95,11 @@ OPERATING RULES:
 3. Report clearly what was done and what the result was.
 4. If something fails, report the error and what you tried.
 5. Stay focused on the delegated task only.
+6. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
+7. For connectivity checks, prefer the dedicated network tool "ping" (TCP reachability) instead of shell "ping".
+8. Only use shell ping when explicitly required by the user. If shell ping is needed, detect OS first:
+   - Windows: use "-n" (never use "-c")
+   - Linux/macOS: use "-c"
 
 
 ────────────────────────────────────────
@@ -216,27 +221,30 @@ ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
         const messages = [systemMessage, userMessage];
         try {
             const response = await this.agent.invoke({ messages });
-            // Persist Apoc-generated messages so token usage is tracked in short-memory.db.
-            // Use the caller's session when provided, then the static session set by Oracle,
-            // otherwise fall back to 'apoc'.
+            // Persist one AI message per delegated task so usage can be parameterized later.
+            // Use task session id when provided.
             const apocConfig = this.config.apoc || this.config.llm;
-            const newMessages = response.messages.slice(messages.length);
-            if (newMessages.length > 0) {
-                const targetSession = sessionId ?? Apoc.currentSessionId ?? 'apoc';
-                const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
-                for (const msg of newMessages) {
-                    msg.provider_metadata = {
-                        provider: apocConfig.provider,
-                        model: apocConfig.model,
-                    };
-                }
-                await history.addMessages(newMessages);
-                history.close();
-            }
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"
                 ? lastMessage.content
                 : JSON.stringify(lastMessage.content);
+            const targetSession = sessionId ?? Apoc.currentSessionId ?? "apoc";
+            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: apocConfig.provider,
+                    model: apocConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
             this.display.log("Apoc task completed.", { source: "Apoc" });
             return content;
         }

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

@@ -220,7 +220,7 @@ export class SatiRepository {
         m.category as category,
         m.importance as importance,
         'long_term' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 1.7 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.8 as distance
       FROM memory_vec v
       JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
       JOIN long_term_memory m ON m.id = map.memory_id
@@ -236,7 +236,7 @@ export class SatiRepository {
         'session' as category,
         'medium' as importance,
         'session_chunk' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.5 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.2 as distance
       FROM session_vec v
       JOIN session_embedding_map map ON map.vec_rowid = v.rowid
       JOIN session_chunks sc ON sc.id = map.session_chunk_id
@@ -431,6 +431,34 @@ export class SatiRepository {
             archived: Boolean(row.archived)
         };
     }
+    update(id, data) {
+        if (!this.db)
+            this.initialize();
+        const existing = this.db.prepare('SELECT * FROM long_term_memory WHERE id = ?').get(id);
+        if (!existing)
+            return null;
+        const setClauses = ['updated_at = @updated_at', 'version = version + 1'];
+        const params = { id, updated_at: new Date().toISOString() };
+        if (data.importance !== undefined) {
+            setClauses.push('importance = @importance');
+            params.importance = data.importance;
+        }
+        if (data.category !== undefined) {
+            setClauses.push('category = @category');
+            params.category = data.category;
+        }
+        if (data.summary !== undefined) {
+            setClauses.push('summary = @summary');
+            params.summary = data.summary;
+        }
+        if (data.details !== undefined) {
+            setClauses.push('details = @details');
+            params.details = data.details;
+        }
+        this.db.prepare(`UPDATE long_term_memory SET ${setClauses.join(', ')} WHERE id = @id`).run(params);
+        const updated = this.db.prepare('SELECT * FROM long_term_memory WHERE id = ?').get(id);
+        return updated ? this.mapRowToRecord(updated) : null;
+    }
     archiveMemory(id) {
         if (!this.db)
             this.initialize();