morpheus-cli 0.1.5 → 0.1.6

package/dist/runtime/tools/__tests__/tools.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ConfigQueryTool, ConfigUpdateTool } from '../config-tools.js';
+import { DiagnosticTool } from '../diagnostic-tools.js';
+import { MessageCountTool, TokenUsageTool } from '../analytics-tools.js';
+import { ConfigManager } from '../../../config/manager.js';
+// Mock the ConfigManager for testing
+vi.mock('../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: vi.fn(() => ({
+            load: vi.fn(async () => ({
+                llm: { provider: 'openai', model: 'gpt-4' },
+                logging: { enabled: true, level: 'info' },
+                ui: { enabled: true, port: 3000 }
+            })),
+            get: vi.fn(() => ({
+                llm: { provider: 'openai', model: 'gpt-4' },
+                logging: { enabled: true, level: 'info' },
+                ui: { enabled: true, port: 3000 }
+            })),
+            save: vi.fn(async (newConfig) => {
+                // Mock save implementation
+            })
+        }))
+    }
+}));
+describe('Config Tools', () => {
+    describe('ConfigQueryTool', () => {
+        it('should query all configuration values when no key is provided', async () => {
+            const result = await ConfigQueryTool.invoke({});
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('llm');
+            expect(parsedResult).toHaveProperty('logging');
+            expect(parsedResult).toHaveProperty('ui');
+        });
+        it('should query specific configuration value when key is provided', async () => {
+            const result = await ConfigQueryTool.invoke({ key: 'llm' });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('llm');
+            const llmConfig = parsedResult.llm;
+            expect(llmConfig).toHaveProperty('provider');
+            expect(llmConfig).toHaveProperty('model');
+        });
+    });
+    describe('ConfigUpdateTool', () => {
+        it('should update configuration values', async () => {
+            const updates = { 'ui.port': 4000 };
+            const result = await ConfigUpdateTool.invoke({ updates });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('success', true);
+        });
+        it('should return error when update fails', async () => {
+            // Create a new mock instance for this specific test
+            const originalGetInstance = ConfigManager.getInstance;
+            const mockGetInstance = vi.fn(() => ({
+                load: vi.fn(async () => ({
+                    llm: { provider: 'openai', model: 'gpt-4' },
+                    logging: { enabled: true, level: 'info' },
+                    ui: { enabled: true, port: 3000 }
+                })),
+                get: vi.fn(() => ({
+                    llm: { provider: 'openai', model: 'gpt-4' },
+                    logging: { enabled: true, level: 'info' },
+                    ui: { enabled: true, port: 3000 }
+                })),
+                save: vi.fn(async () => {
+                    throw new Error('Save failed');
+                })
+            }));
+            // Replace the getInstance method temporarily
+            ConfigManager.getInstance = mockGetInstance;
+            const updates = { 'invalid.field': 'value' };
+            const result = await ConfigUpdateTool.invoke({ updates });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toHaveProperty('error');
+            // Restore the original method
+            ConfigManager.getInstance = originalGetInstance;
+        });
+    });
+});
+describe('DiagnosticTool', () => {
+    it('should return a diagnostic report with component statuses', async () => {
+        const result = await DiagnosticTool.invoke({});
+        const parsedResult = JSON.parse(result);
+        expect(parsedResult).toHaveProperty('timestamp');
+        expect(parsedResult).toHaveProperty('components');
+        expect(parsedResult.components).toHaveProperty('config');
+        expect(parsedResult.components).toHaveProperty('storage');
+        expect(parsedResult.components).toHaveProperty('network');
+        expect(parsedResult.components).toHaveProperty('agent');
+    });
+});
+describe('Analytics Tools', () => {
+    // Note: These tools now use the existing SQLite class and access the database
+    describe('MessageCountTool', () => {
+        it('should return message count', async () => {
+            const result = await MessageCountTool.invoke({});
+            const parsedResult = JSON.parse(result);
+            // Should return a number (message count) or an error if database doesn't exist
+            if (typeof parsedResult === 'object' && parsedResult.error) {
+                // If there's an error (e.g., database doesn't exist), that's acceptable in test environment
+                expect(parsedResult).toHaveProperty('error');
+            }
+            else {
+                // Otherwise, should return a number
+                expect(typeof parsedResult).toBe('number');
+            }
+        });
+    });
+    describe('TokenUsageTool', () => {
+        it('should return token usage statistics', async () => {
+            const result = await TokenUsageTool.invoke({});
+            const parsedResult = JSON.parse(result);
+            // Should return token statistics or an error if database doesn't exist
+            if (typeof parsedResult === 'object' && parsedResult.error) {
+                // If there's an error (e.g., database doesn't exist), that's acceptable in test environment
+                expect(parsedResult).toHaveProperty('error');
+            }
+            else {
+                // Otherwise, should return token statistics
+                expect(parsedResult).toHaveProperty('totalTokens');
+                expect(parsedResult).toHaveProperty('inputTokens');
+                expect(parsedResult).toHaveProperty('outputTokens');
+                expect(parsedResult).toHaveProperty('timestamp');
+            }
+        });
+    });
+});

package/dist/runtime/tools/analytics-tools.js

@@ -0,0 +1,73 @@
+import { tool } from "langchain";
+import * as z from "zod";
+import path from "path";
+import Database from "better-sqlite3";
+import { homedir } from "os";
+// Tool for querying message counts from the database
+const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+export const MessageCountTool = tool(async ({ timeRange }) => {
+    try {
+        // Connect to database
+        const db = new Database(dbPath);
+        let query = "SELECT COUNT(*) as count FROM messages";
+        const params = [];
+        if (timeRange) {
+            query += " WHERE timestamp BETWEEN ? AND ?";
+            params.push(timeRange.start);
+            params.push(timeRange.end);
+        }
+        const result = db.prepare(query).get(params);
+        db.close();
+        return JSON.stringify(result.count);
+    }
+    catch (error) {
+        console.error("Error in MessageCountTool:", error);
+        return JSON.stringify({ error: `Failed to count messages: ${error.message}` });
+    }
+}, {
+    name: "message_count",
+    description: "Returns count of stored messages. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    schema: z.object({
+        timeRange: z.object({
+            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+        }).optional(),
+    }),
+});
+// Tool for querying token usage statistics from the database
+export const TokenUsageTool = tool(async ({ timeRange }) => {
+    try {
+        // Connect to database
+        const db = new Database(dbPath);
+        let query = "SELECT SUM(input_tokens) as inputTokens, SUM(output_tokens) as outputTokens, SUM(input_tokens + output_tokens) as totalTokens FROM messages";
+        const params = [];
+        if (timeRange) {
+            query += " WHERE timestamp BETWEEN ? AND ?";
+            params.push(timeRange.start);
+            params.push(timeRange.end);
+        }
+        const result = db.prepare(query).get(params);
+        db.close();
+        // Handle potential null values
+        const tokenStats = {
+            totalTokens: result.totalTokens || 0,
+            inputTokens: result.inputTokens || 0,
+            outputTokens: result.outputTokens || 0,
+            timestamp: new Date().toISOString()
+        };
+        return JSON.stringify(tokenStats);
+    }
+    catch (error) {
+        console.error("Error in TokenUsageTool:", error);
+        return JSON.stringify({ error: `Failed to get token usage: ${error.message}` });
+    }
+}, {
+    name: "token_usage",
+    description: "Returns token usage statistics. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    schema: z.object({
+        timeRange: z.object({
+            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+        }).optional(),
+    }),
+});

package/dist/runtime/tools/config-tools.js

@@ -0,0 +1,70 @@
+import { tool } from "langchain";
+import * as z from "zod";
+import { ConfigManager } from "../../config/manager.js";
+// Tool for querying configuration values
+export const ConfigQueryTool = tool(async ({ key }) => {
+    try {
+        const configManager = ConfigManager.getInstance();
+        // Load config if not already loaded
+        await configManager.load();
+        const config = configManager.get();
+        if (key) {
+            // Return specific configuration value
+            const value = config[key];
+            return JSON.stringify({ [key]: value });
+        }
+        else {
+            // Return all configuration values
+            return JSON.stringify(config);
+        }
+    }
+    catch (error) {
+        console.error("Error in ConfigQueryTool:", error);
+        return JSON.stringify({ error: "Failed to query configuration" });
+    }
+}, {
+    name: "config_query",
+    description: "Queries current configuration values. Accepts an optional 'key' parameter to get a specific configuration value, or no parameter to get all configuration values.",
+    schema: z.object({
+        key: z.string().optional(),
+    }),
+});
+// Tool for updating configuration values
+export const ConfigUpdateTool = tool(async ({ updates }) => {
+    try {
+        const configManager = ConfigManager.getInstance();
+        // Load current config
+        await configManager.load();
+        const currentConfig = configManager.get();
+        // Create new config with updates
+        const newConfig = { ...currentConfig, ...updates };
+        // Save the updated config
+        await configManager.save(newConfig);
+        return JSON.stringify({ success: true, message: "Configuration updated successfully" });
+    }
+    catch (error) {
+        console.error("Error in ConfigUpdateTool:", error);
+        return JSON.stringify({ error: `Failed to update configuration: ${error.message}` });
+    }
+}, {
+    name: "config_update",
+    description: "Updates configuration values with validation. Accepts an 'updates' object containing key-value pairs to update.",
+    schema: z.object({
+        updates: z.object({
+            // Define common config properties that might be updated
+            // Using optional fields to allow flexible updates
+            "llm.provider": z.string().optional(),
+            "llm.model": z.string().optional(),
+            "llm.temperature": z.number().optional(),
+            "llm.api_key": z.string().optional(),
+            "ui.enabled": z.boolean().optional(),
+            "ui.port": z.number().optional(),
+            "logging.enabled": z.boolean().optional(),
+            "logging.level": z.enum(['debug', 'info', 'warn', 'error']).optional(),
+            "audio.enabled": z.boolean().optional(),
+            "audio.provider": z.string().optional(),
+            "memory.limit": z.number().optional(),
+            // Add more specific fields as needed, or use a catch-all for other properties
+        }).passthrough(), // Allow additional properties not explicitly defined
+    }),
+});

package/dist/runtime/tools/diagnostic-tools.js

@@ -0,0 +1,124 @@
+import { tool } from "langchain";
+import * as z from "zod";
+import { ConfigManager } from "../../config/manager.js";
+import { promises as fsPromises } from "fs";
+import path from "path";
+import { homedir } from "os";
+// Tool for performing system diagnostics
+export const DiagnosticTool = tool(async () => {
+    try {
+        const timestamp = new Date().toISOString();
+        const components = {};
+        // Check configuration
+        try {
+            const configManager = ConfigManager.getInstance();
+            await configManager.load();
+            const config = configManager.get();
+            // Basic validation - check if required fields exist
+            const requiredFields = ['llm', 'logging', 'ui'];
+            const missingFields = requiredFields.filter(field => !(field in config));
+            if (missingFields.length === 0) {
+                components.config = {
+                    status: "healthy",
+                    message: "Configuration is valid and complete",
+                    details: {
+                        llmProvider: config.llm?.provider,
+                        uiEnabled: config.ui?.enabled,
+                        uiPort: config.ui?.port
+                    }
+                };
+            }
+            else {
+                components.config = {
+                    status: "warning",
+                    message: `Missing required configuration fields: ${missingFields.join(', ')}`,
+                    details: { missingFields }
+                };
+            }
+        }
+        catch (error) {
+            components.config = {
+                status: "error",
+                message: `Configuration error: ${error.message}`,
+                details: {}
+            };
+        }
+        // Check storage/database
+        try {
+            // For now, we'll check if the data directory exists
+            const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+            await fsPromises.access(dbPath);
+            components.storage = {
+                status: "healthy",
+                message: "Database file is accessible",
+                details: { path: dbPath }
+            };
+        }
+        catch (error) {
+            components.storage = {
+                status: "error",
+                message: `Storage error: ${error.message}`,
+                details: {}
+            };
+        }
+        // Check network connectivity (basic check)
+        try {
+            // For now, we'll just check if we can reach the LLM provider configuration
+            const configManager = ConfigManager.getInstance();
+            await configManager.load();
+            const config = configManager.get();
+            if (config.llm && config.llm.provider) {
+                components.network = {
+                    status: "healthy",
+                    message: `LLM provider configured: ${config.llm.provider}`,
+                    details: { provider: config.llm.provider }
+                };
+            }
+            else {
+                components.network = {
+                    status: "warning",
+                    message: "No LLM provider configured",
+                    details: {}
+                };
+            }
+        }
+        catch (error) {
+            components.network = {
+                status: "error",
+                message: `Network check error: ${error.message}`,
+                details: {}
+            };
+        }
+        // Check if the agent is running
+        try {
+            // This is a basic check - in a real implementation, we might check if the agent process is running
+            components.agent = {
+                status: "healthy",
+                message: "Agent is running",
+                details: { uptime: "N/A - runtime information not available in this context" }
+            };
+        }
+        catch (error) {
+            components.agent = {
+                status: "error",
+                message: `Agent check error: ${error.message}`,
+                details: {}
+            };
+        }
+        return JSON.stringify({
+            timestamp,
+            components
+        });
+    }
+    catch (error) {
+        console.error("Error in DiagnosticTool:", error);
+        return JSON.stringify({
+            timestamp: new Date().toISOString(),
+            error: "Failed to run diagnostics"
+        });
+    }
+}, {
+    name: "diagnostic_check",
+    description: "Performs system health diagnostics and returns a comprehensive report on system components.",
+    schema: z.object({}),
+});

package/dist/runtime/tools/factory.js

@@ -1,33 +1,77 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { DisplayManager } from "../display.js";
+import { loadMCPConfig } from "../../config/mcp-loader.js";
+const display = DisplayManager.getInstance();
+// Fields not supported by Google Gemini API
+const UNSUPPORTED_SCHEMA_FIELDS = ['examples', 'additionalInfo', 'default', '$schema'];
+/**
+ * Recursively removes unsupported fields from JSON schema objects.
+ * This is needed because some MCP servers (like Coolify) return schemas
+ * with fields that Gemini doesn't accept.
+ */
+function sanitizeSchema(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sanitizeSchema);
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!UNSUPPORTED_SCHEMA_FIELDS.includes(key)) {
+            sanitized[key] = sanitizeSchema(value);
+        }
+    }
+    return sanitized;
+}
+/**
+ * Wraps a tool to sanitize its schema for Gemini compatibility.
+ * Creates a proxy that intercepts schema access and sanitizes the output.
+ */
+function wrapToolWithSanitizedSchema(tool) {
+    display.log('Tool loaded: - ' + tool.name, { source: 'ToolsFactory' });
+    // The MCP tools have a schema property that returns JSON Schema
+    // We need to intercept and sanitize it
+    const originalSchema = tool.schema;
+    if (originalSchema && typeof originalSchema === 'object') {
+        // Sanitize the schema object directly
+        const sanitized = sanitizeSchema(originalSchema);
+        tool.schema = sanitized;
+    }
+    return tool;
+}
 export class ToolsFactory {
     static async create() {
         const display = DisplayManager.getInstance();
+        const mcpServers = await loadMCPConfig();
+        const serverCount = Object.keys(mcpServers).length;
+        if (serverCount === 0) {
+            display.log('No MCP servers configured in mcps.json', { level: 'info', source: 'ToolsFactory' });
+            return [];
+        }
         const client = new MultiServerMCPClient({
-            mcpServers: {
-                coingecko: {
-                    transport: "stdio",
-                    command: "npx",
-                    args: ["-y", "mcp_coingecko_price_ts"],
-                },
-            },
+            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)}`);
+                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)}`);
+                display.log(`MCP Tool Result - ${JSON.stringify(res)}`, { source: 'MCPServer' });
                 return;
             }
         });
         try {
             const tools = await client.getTools();
-            return tools;
+            // 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: 'ToolsFactory' });
+            return sanitizedTools;
         }
         catch (error) {
-            display.log(`Failed to initialize MCP tools: ${error}`, { level: 'warning' });
+            display.log(`Failed to initialize MCP tools: ${error}`, { level: 'warning', source: 'ToolsFactory' });
             return []; // Return empty tools on failure to allow agent to start
         }
     }

package/dist/runtime/tools/index.js

@@ -0,0 +1,4 @@
+// Export all tools from the tools module
+export * from './config-tools.js';
+export * from './diagnostic-tools.js';
+export * from './analytics-tools.js';

package/dist/types/auth.js

@@ -0,0 +1,4 @@
+/**
+ * Shared constants and interfaces for HTTP Authentication
+ */
+export const AUTH_HEADER = 'x-architect-pass';

package/dist/types/config.js

@@ -9,6 +9,7 @@ export const DEFAULT_CONFIG = {
         retention: '14d',
     },
     audio: {
+        provider: 'google',
         enabled: true,
         maxDurationSeconds: 300,
         supportedMimeTypes: ['audio/ogg', 'audio/mp3', 'audio/mpeg', 'audio/wav'],

package/dist/types/mcp.js

@@ -0,0 +1,11 @@
+export const DEFAULT_MCP_TEMPLATE = {
+    "_comment": "MCP Server Configuration for Morpheus",
+    "_docs": "Add your MCP servers below. Each key is a unique server name.",
+    "example": {
+        "_comment": "EXAMPLE - Remove or replace this entry with your own MCPs",
+        "transport": "stdio",
+        "command": "npx",
+        "args": ["-y", "your-mcp-package-name"],
+        "env": {}
+    }
+};

package/dist/types/tools.js

@@ -0,0 +1,2 @@
+// Tool type definitions for Morpheus internal tools
+export {};

package/dist/types/usage.js

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