morpheus-cli 0.3.3 → 0.3.6

package/dist/runtime/agent.js

@@ -1,172 +0,0 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { ProviderFactory } from "./providers/factory.js";
-import { ToolsFactory } from "./tools/factory.js";
-import { ConfigManager } from "../config/manager.js";
-import { ProviderError } from "./errors.js";
-import { DisplayManager } from "./display.js";
-import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
-export class Agent {
-    provider;
-    config;
-    history;
-    display = DisplayManager.getInstance();
-    databasePath;
-    constructor(config, overrides) {
-        this.config = config || ConfigManager.getInstance().get();
-        this.databasePath = overrides?.databasePath;
-    }
-    async initialize() {
-        if (!this.config.llm) {
-            throw new Error("LLM configuration missing in config object.");
-        }
-        // Basic validation before provider creation
-        if (!this.config.llm.provider) {
-            throw new Error("LLM provider not specified in configuration.");
-        }
-        // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
-        // to allow for Environment Variable fallback supported by LangChain.
-        try {
-            const tools = await ToolsFactory.create();
-            this.provider = await ProviderFactory.create(this.config.llm, tools);
-            if (!this.provider) {
-                throw new Error("Provider factory returned undefined");
-            }
-            // Initialize persistent memory with SQLite
-            this.history = new SQLiteChatMessageHistory({
-                sessionId: "default",
-                databasePath: this.databasePath,
-                limit: this.config.memory?.limit || 100, // Fallback purely defensive if config type allows optional
-            });
-        }
-        catch (err) {
-            if (err instanceof ProviderError)
-                throw err; // Re-throw known errors
-            // Wrap unknown errors
-            throw new ProviderError(this.config.llm.provider || 'unknown', err, "Agent initialization failed");
-        }
-    }
-    async chat(message, extraUsage) {
-        if (!this.provider) {
-            throw new Error("Agent not initialized. Call initialize() first.");
-        }
-        if (!this.history) {
-            throw new Error("Message history not initialized. Call initialize() first.");
-        }
-        try {
-            this.display.log('Processing message...', { source: 'Agent' });
-            const userMessage = new HumanMessage(message);
-            // Inject provider/model metadata for persistence
-            userMessage.provider_metadata = {
-                provider: this.config.llm.provider,
-                model: this.config.llm.model
-            };
-            // Attach extra usage (e.g. from Audio) to the user message to be persisted
-            if (extraUsage) {
-                userMessage.usage_metadata = extraUsage;
-            }
-            const systemMessage = new SystemMessage(`You are ${this.config.agent.name}, ${this.config.agent.personality},a local AI operator responsible for orchestrating tools, MCPs, and language models to solve the user’s request accurately and reliably.
-
-          Your primary responsibility is NOT to answer from memory when external tools are available.
-
-          You must follow these rules strictly:
-
-          1. Tool Evaluation First
-          Before generating a final answer, always evaluate whether any available tool or MCP is capable of providing a more accurate, up-to-date, or authoritative response.
-
-          If a tool can provide the answer, you MUST call the tool.
-
-          2. No Historical Assumptions for Dynamic Data
-          If the user asks something that:
-          - may change over time
-          - depends on system state
-          - depends on filesystem
-          - depends on external APIs
-          - was previously asked in the conversation
-
-          You MUST NOT reuse previous outputs as final truth.
-
-          Instead:
-          - Re-evaluate available tools
-          - Re-execute the relevant tool
-          - Provide a fresh result
-
-          Even if the user already asked the same question before, you must treat the request as requiring a new verification.
-
-          3. History Is Context, Not Source of Truth
-          Conversation history may help with context, but it must not replace real-time verification via tools when tools are available.
-
-          Never assume:
-          - System state
-          - File contents
-          - Database values
-          - API responses
-          based only on previous messages.
-
-          4. Tool Priority Over Language Guessing
-          If a tool can compute, fetch, inspect, or verify something, prefer tool usage over generating a speculative answer.
-
-          Never hallucinate values that could be retrieved through a tool.
-
-          5. Freshness Principle
-          Repeated user queries require fresh validation.
-          Do not respond with:
-          "As I said before..."
-          Instead, perform a new tool check if applicable.
-
-          6. Final Answer Policy
-          Only provide a direct natural language answer if:
-          - No tool is relevant
-          - Tools are unavailable
-          - The question is conceptual or explanatory
-
-          Otherwise, use tools first.
-
-          You are an operator, not a guesser.
-          Accuracy is more important than speed.
-      `);
-            // Load existing history from database
-            const previousMessages = await this.history.getMessages();
-            const messages = [
-                systemMessage,
-                ...previousMessages,
-                userMessage
-            ];
-            const response = await this.provider.invoke({ messages });
-            // Identify new messages generated during the interaction
-            // The `messages` array passed to invoke had length `messages.length`
-            // The `response.messages` contains the full state.
-            // New messages start after the inputs.
-            const startNewMessagesIndex = messages.length;
-            const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
-            // Persist User Message first
-            await this.history.addMessage(userMessage);
-            // Persist all new intermediate tool calls and responses
-            for (const msg of newGeneratedMessages) {
-                // Inject provider/model metadata search interactors
-                msg.provider_metadata = {
-                    provider: this.config.llm.provider,
-                    model: this.config.llm.model
-                };
-                await this.history.addMessage(msg);
-            }
-            this.display.log('Response generated.', { source: 'Agent' });
-            const lastMessage = response.messages[response.messages.length - 1];
-            return (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
-        }
-        catch (err) {
-            throw new ProviderError(this.config.llm.provider, err, "Chat request failed");
-        }
-    }
-    async getHistory() {
-        if (!this.history) {
-            throw new Error("Message history not initialized. Call initialize() first.");
-        }
-        return await this.history.getMessages();
-    }
-    async clearMemory() {
-        if (!this.history) {
-            throw new Error("Message history not initialized. Call initialize() first.");
-        }
-        await this.history.clear();
-    }
-}

package/dist/runtime/audio-agent.js

@@ -1,55 +0,0 @@
-import { GoogleGenAI } from '@google/genai';
-export class AudioAgent {
-    async transcribe(filePath, mimeType, apiKey) {
-        try {
-            const ai = new GoogleGenAI({ apiKey });
-            // Upload the file
-            const uploadResult = await ai.files.upload({
-                file: filePath,
-                config: { mimeType }
-            });
-            // Generate content (transcription)
-            // using gemini-1.5-flash as it is fast and supports audio
-            const response = await ai.models.generateContent({
-                model: 'gemini-2.5-flash-lite',
-                contents: [
-                    {
-                        role: 'user',
-                        parts: [
-                            {
-                                fileData: {
-                                    fileUri: uploadResult.uri,
-                                    mimeType: uploadResult.mimeType
-                                }
-                            },
-                            { text: "Transcribe this audio message accurately. Return only the transcribed text without any additional commentary." }
-                        ]
-                    }
-                ]
-            });
-            // The new SDK returns text directly on the response object
-            const text = response.text;
-            if (!text) {
-                throw new Error('No transcription generated');
-            }
-            // Extract usage metadata
-            const usage = response.usageMetadata;
-            const usageMetadata = {
-                input_tokens: usage?.promptTokenCount ?? 0,
-                output_tokens: usage?.candidatesTokenCount ?? 0,
-                total_tokens: usage?.totalTokenCount ?? 0,
-                input_token_details: {
-                    cache_read: usage?.cachedContentTokenCount ?? 0
-                }
-            };
-            return { text, usage: usageMetadata };
-        }
-        catch (error) {
-            // Wrap error for clarity
-            if (error instanceof Error) {
-                throw new Error(`Audio transcription failed: ${error.message}`);
-            }
-            throw error;
-        }
-    }
-}

package/dist/runtime/santi/contracts.js

@@ -1 +0,0 @@
-export {};

package/dist/runtime/santi/middleware.js

@@ -1,61 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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/__tests__/factory.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ToolsFactory } from '../factory.js';
-import { MultiServerMCPClient } from "@langchain/mcp-adapters";
-vi.mock("@langchain/mcp-adapters", () => {
-    return {
-        MultiServerMCPClient: vi.fn(),
-    };
-});
-vi.mock("../../display.js", () => ({
-    DisplayManager: {
-        getInstance: () => ({
-            log: vi.fn(),
-        })
-    }
-}));
-describe('ToolsFactory', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    it('should create tools successfully', async () => {
-        const mockGetTools = vi.fn().mockResolvedValue(['tool1', 'tool2']);
-        // Mock the constructor and getTools method
-        MultiServerMCPClient.mockImplementation(function () {
-            return {
-                getTools: mockGetTools
-            };
-        });
-        const tools = await ToolsFactory.create();
-        expect(MultiServerMCPClient).toHaveBeenCalled();
-        expect(mockGetTools).toHaveBeenCalled();
-        expect(tools).toEqual(['tool1', 'tool2']);
-    });
-    it('should return empty array on failure', async () => {
-        MultiServerMCPClient.mockImplementation(function () {
-            return {
-                getTools: vi.fn().mockRejectedValue(new Error('MCP Failed'))
-            };
-        });
-        const tools = await ToolsFactory.create();
-        expect(tools).toEqual([]);
-    });
-});