morpheus-cli 0.7.1 → 0.7.3

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

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Keymaker, executeKeymakerTask } from '../keymaker.js';
+import { SkillRegistry } from '../skills/registry.js';
+// Mock all heavy dependencies
+vi.mock('../skills/registry.js', () => ({
+    SkillRegistry: {
+        getInstance: vi.fn(),
+    },
+}));
+vi.mock('../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: vi.fn(() => ({
+            get: vi.fn(() => ({
+                llm: {
+                    provider: 'openai',
+                    model: 'gpt-4o',
+                    temperature: 0.7,
+                },
+                keymaker: {
+                    provider: 'openai',
+                    model: 'gpt-4o',
+                    personality: 'versatile_specialist',
+                },
+            })),
+        })),
+    },
+}));
+vi.mock('../display.js', () => ({
+    DisplayManager: {
+        getInstance: vi.fn(() => ({
+            log: vi.fn(),
+        })),
+    },
+}));
+vi.mock('../../devkit/index.js', () => ({
+    buildDevKit: vi.fn(() => [
+        { name: 'fs_read', description: 'Read file' },
+        { name: 'shell_exec', description: 'Execute shell command' },
+    ]),
+}));
+vi.mock('../tools/factory.js', () => ({
+    Construtor: {
+        create: vi.fn(() => Promise.resolve([
+            { name: 'mcp_tool', description: 'MCP tool' },
+        ])),
+    },
+}));
+vi.mock('../tools/index.js', () => ({
+    morpheusTools: [
+        { name: 'morpheus_tool', description: 'Internal tool' },
+    ],
+}));
+vi.mock('../providers/factory.js', () => ({
+    ProviderFactory: {
+        createBare: vi.fn(() => Promise.resolve({
+            invoke: vi.fn(),
+        })),
+    },
+}));
+vi.mock('../memory/sqlite.js', () => {
+    return {
+        SQLiteChatMessageHistory: class MockSQLiteChatMessageHistory {
+            addMessage = vi.fn();
+            close = vi.fn();
+        },
+    };
+});
+describe('Keymaker', () => {
+    const mockRegistry = {
+        get: vi.fn(),
+        getContent: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        SkillRegistry.getInstance.mockReturnValue(mockRegistry);
+        mockRegistry.get.mockReturnValue({
+            name: 'test-skill',
+            description: 'A test skill',
+            tags: ['test'],
+            enabled: true,
+        });
+        mockRegistry.getContent.mockReturnValue('# Test Skill\n\nInstructions here.');
+    });
+    describe('constructor', () => {
+        it('should create instance with skill name and content', () => {
+            const keymaker = new Keymaker('test-skill', '# Instructions');
+            expect(keymaker).toBeInstanceOf(Keymaker);
+        });
+        it('should accept custom config', () => {
+            const customConfig = {
+                llm: { provider: 'anthropic', model: 'claude-3' },
+            };
+            const keymaker = new Keymaker('test-skill', '# Instructions', customConfig);
+            expect(keymaker).toBeInstanceOf(Keymaker);
+        });
+    });
+    describe('initialize()', () => {
+        it('should initialize agent with all tools', async () => {
+            const { ProviderFactory } = await import('../providers/factory.js');
+            const { buildDevKit } = await import('../../devkit/index.js');
+            const { Construtor } = await import('../tools/factory.js');
+            const keymaker = new Keymaker('test-skill', '# Instructions');
+            await keymaker.initialize();
+            expect(buildDevKit).toHaveBeenCalled();
+            expect(Construtor.create).toHaveBeenCalled();
+            expect(ProviderFactory.createBare).toHaveBeenCalled();
+            // Verify tools were combined
+            const createBareCall = ProviderFactory.createBare.mock.calls[0];
+            const tools = createBareCall[1];
+            // Should have DevKit (2) + MCP (1) + Morpheus (1) = 4 tools
+            expect(tools.length).toBe(4);
+        });
+    });
+});
+describe('executeKeymakerTask', () => {
+    const mockRegistry = {
+        get: vi.fn(),
+        getContent: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        SkillRegistry.getInstance.mockReturnValue(mockRegistry);
+    });
+    it('should throw error when SKILL.md not found', async () => {
+        mockRegistry.getContent.mockReturnValue(null);
+        await expect(executeKeymakerTask('missing-skill', 'do something')).rejects.toThrow('SKILL.md not found for skill: missing-skill');
+    });
+    it('should create and execute keymaker with skill content', async () => {
+        mockRegistry.getContent.mockReturnValue('# Test Instructions\n\nDo this.');
+        mockRegistry.get.mockReturnValue({
+            name: 'test-skill',
+            description: 'Test skill',
+            enabled: true,
+        });
+        const { ProviderFactory } = await import('../providers/factory.js');
+        ProviderFactory.createBare.mockResolvedValue({
+            invoke: vi.fn().mockResolvedValue({
+                messages: [{ content: 'Task completed successfully.' }],
+            }),
+        });
+        const result = await executeKeymakerTask('test-skill', 'do the task');
+        expect(mockRegistry.getContent).toHaveBeenCalledWith('test-skill');
+        expect(result).toBe('Task completed successfully.');
+    });
+});

package/dist/runtime/chronos/parser.js

@@ -77,50 +77,68 @@ function intervalToCron(expression) {
         `Supported formats: "every N minutes/hours/days/weeks", "every minute/hour/day/week", ` +
         `"every monday [at 9am]", "every monday and friday at 18:30", "every weekday", "every weekend", "daily", "weekly".`);
 }
+/**
+ * Creates a Date in UTC from a local time in a specific timezone.
+ * E.g., createDateInTimezone(2026, 2, 26, 23, 0, 'America/Sao_Paulo') returns
+ * a Date representing 23:00 BRT = 02:00 UTC (next day).
+ */
+function createDateInTimezone(year, month, day, hour, minute, timezone) {
+    // Create a candidate UTC date
+    const candidateUtc = Date.UTC(year, month - 1, day, hour, minute, 0, 0);
+    // Get the offset at that moment for the timezone
+    const offsetMs = ianaToOffsetMinutes(timezone, new Date(candidateUtc)) * 60_000;
+    // Subtract offset: if BRT is -180 min (-3h), local 23:00 = UTC 23:00 - (-3h) = UTC 02:00
+    return new Date(candidateUtc - offsetMs);
+}
+/**
+ * Gets the current date components (year, month, day) in a specific timezone.
+ */
+function getDatePartsInTimezone(date, timezone) {
+    const formatter = new Intl.DateTimeFormat('en-CA', { timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit' });
+    const parts = formatter.formatToParts(date);
+    return {
+        year: parseInt(parts.find(p => p.type === 'year').value, 10),
+        month: parseInt(parts.find(p => p.type === 'month').value, 10),
+        day: parseInt(parts.find(p => p.type === 'day').value, 10),
+    };
+}
 /**
  * Parses Portuguese time expressions and converts to ISO 8601 format.
  * Handles patterns like "às 15h", "hoje às 15:30", "amanhã às 9h".
  */
 function parsePortugueseTimeExpression(expression, refDate, timezone) {
     const lower = expression.toLowerCase().trim();
+    const { year, month, day } = getDatePartsInTimezone(refDate, timezone);
     // Pattern: "às 15h", "as 15h", "às 15:30", "as 15:30"
     const timeOnlyMatch = lower.match(/^(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?$/);
     if (timeOnlyMatch) {
-        let hour = parseInt(timeOnlyMatch[1], 10);
+        const hour = parseInt(timeOnlyMatch[1], 10);
         const minute = timeOnlyMatch[2] ? parseInt(timeOnlyMatch[2], 10) : 0;
-        // Create date by setting hours in the target timezone
-        // We use Intl.DateTimeFormat to properly handle timezone
-        const targetDate = new Date();
-        const tzDate = new Date(targetDate.toLocaleString('en-US', { timeZone: timezone }));
-        tzDate.setHours(hour, minute, 0, 0);
+        let result = createDateInTimezone(year, month, day, hour, minute, timezone);
         // If time is in the past today, schedule for tomorrow
-        if (tzDate.getTime() <= refDate.getTime()) {
-            tzDate.setDate(tzDate.getDate() + 1);
+        if (result.getTime() <= refDate.getTime()) {
+            result = createDateInTimezone(year, month, day + 1, hour, minute, timezone);
         }
-        return tzDate;
+        return result;
     }
     // Pattern: "hoje às 15h", "hoje as 15:30"
     const todayMatch = lower.match(/^hoje\s+(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?$/);
     if (todayMatch) {
-        let hour = parseInt(todayMatch[1], 10);
+        const hour = parseInt(todayMatch[1], 10);
         const minute = todayMatch[2] ? parseInt(todayMatch[2], 10) : 0;
-        const tzDate = new Date(new Date().toLocaleString('en-US', { timeZone: timezone }));
-        tzDate.setHours(hour, minute, 0, 0);
+        const result = createDateInTimezone(year, month, day, hour, minute, timezone);
         // If already passed, return null (can't schedule in the past)
-        if (tzDate.getTime() <= refDate.getTime()) {
+        if (result.getTime() <= refDate.getTime()) {
             return null;
         }
-        return tzDate;
+        return result;
     }
     // Pattern: "amanhã às 15h", "amanha as 15:30", "amanhã às 15h da tarde"
-    const tomorrowMatch = lower.match(/^amanhã(?:ã)?\s+(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?(?:\s+(?:da|do)\s+(?:manhã|tarde|noite))?$/);
+    const tomorrowMatch = lower.match(/^amanh[aã]\s+(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?(?:\s+(?:da|do)\s+(?:manh[aã]|tarde|noite))?$/);
     if (tomorrowMatch) {
-        let hour = parseInt(tomorrowMatch[1], 10);
+        const hour = parseInt(tomorrowMatch[1], 10);
         const minute = tomorrowMatch[2] ? parseInt(tomorrowMatch[2], 10) : 0;
-        const tzDate = new Date(new Date().toLocaleString('en-US', { timeZone: timezone }));
-        tzDate.setDate(tzDate.getDate() + 1);
-        tzDate.setHours(hour, minute, 0, 0);
-        return tzDate;
+        return createDateInTimezone(year, month, day + 1, hour, minute, timezone);
     }
     // Pattern: "daqui a X minutos/horas/dias"
     const relativeMatch = lower.match(/^daqui\s+a\s+(\d+)\s+(minutos?|horas?|dias?|semanas?)$/);

package/dist/runtime/keymaker.js

@@ -0,0 +1,162 @@
+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 { buildDevKit } from "../devkit/index.js";
+import { Construtor } from "./tools/factory.js";
+import { morpheusTools } from "./tools/index.js";
+import { SkillRegistry } from "./skills/registry.js";
+import { TaskRequestContext } from "./tasks/context.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+/**
+ * Keymaker is a specialized agent for executing skills.
+ * "The one who opens any door" - has access to ALL tools:
+ * - DevKit (filesystem, shell, git, browser, network, processes, packages, system)
+ * - MCP tools (all configured MCP servers)
+ * - Morpheus internal tools
+ *
+ * Keymaker is instantiated per-task with a specific skill's SKILL.md as context.
+ * It executes the skill instructions autonomously and returns the result.
+ */
+export class Keymaker {
+    agent;
+    config;
+    display = DisplayManager.getInstance();
+    skillName;
+    skillContent;
+    constructor(skillName, skillContent, config) {
+        this.skillName = skillName;
+        this.skillContent = skillContent;
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    async initialize() {
+        const keymakerConfig = this.config.keymaker || this.config.llm;
+        const personality = this.config.keymaker?.personality || 'versatile_specialist';
+        // Build DevKit tools (filesystem, shell, git, browser, network, etc.)
+        const working_dir = process.cwd();
+        const timeout_ms = 30_000;
+        await import("../devkit/index.js");
+        const devKitTools = buildDevKit({
+            working_dir,
+            allowed_commands: [], // no restriction
+            timeout_ms,
+        });
+        // Load MCP tools from configured servers
+        const mcpTools = await Construtor.create();
+        // Combine all tools
+        const tools = [...devKitTools, ...mcpTools, ...morpheusTools];
+        this.display.log(`Keymaker initialized for skill "${this.skillName}" with ${tools.length} tools (personality: ${personality})`, { source: "Keymaker" });
+        try {
+            this.agent = await ProviderFactory.createBare(keymakerConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(keymakerConfig.provider, err, "Keymaker agent initialization failed");
+        }
+    }
+    /**
+     * Execute the skill with the given objective.
+     * @param objective User's task description
+     * @param taskContext Context for routing responses
+     */
+    async execute(objective, taskContext) {
+        if (!this.agent) {
+            await this.initialize();
+        }
+        this.display.log(`Keymaker executing skill "${this.skillName}": ${objective.slice(0, 80)}...`, { source: "Keymaker" });
+        const personality = this.config.keymaker?.personality || 'versatile_specialist';
+        const registry = SkillRegistry.getInstance();
+        const skill = registry.get(this.skillName);
+        const systemMessage = new SystemMessage(`
+You are Keymaker, ${personality === 'versatile_specialist' ? 'a versatile specialist who can open any door' : personality}, executing the "${this.skillName}" skill.
+
+You have access to ALL tools:
+- Filesystem: read, write, list, delete, copy, move files and directories
+- Shell: execute commands, spawn processes
+- Git: clone, commit, push, pull, branch, diff
+- Network: HTTP requests, health checks
+- Browser: navigate, screenshot, extract content
+- MCP tools: all configured MCP server tools
+- System: CPU, memory, disk info
+
+## Skill: ${skill?.description || this.skillName}
+${skill?.tags?.length ? `Tags: ${skill.tags.join(', ')}` : ''}
+
+## Skill Instructions
+${this.skillContent}
+
+## Your Objective
+${objective}
+
+IMPORTANT:
+1. Follow the skill instructions carefully to accomplish the objective.
+2. Be thorough and autonomous. Use the tools at your disposal.
+3. If you encounter errors, try alternative approaches.
+4. Provide a clear summary of what was accomplished.
+5. Respond in the same language as the objective.
+
+CRITICAL — NEVER FABRICATE DATA:
+- If none of your available tools can retrieve the requested information, state this clearly.
+- NEVER generate fake data, fake IDs, fake results of any kind.
+- An honest "I cannot do this" is always correct. A fabricated answer is never acceptable.
+    `);
+        const userMessage = new HumanMessage(objective);
+        const messages = [systemMessage, userMessage];
+        try {
+            const invokeContext = {
+                origin_channel: taskContext?.origin_channel ?? "api",
+                session_id: taskContext?.session_id ?? "keymaker",
+                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);
+            // Persist message with token usage metadata (like Trinity/Neo/Apoc)
+            const keymakerConfig = this.config.keymaker || this.config.llm;
+            const targetSession = taskContext?.session_id ?? "keymaker";
+            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: keymakerConfig.provider,
+                    model: keymakerConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
+            this.display.log(`Keymaker completed skill "${this.skillName}" execution`, { source: "Keymaker" });
+            return content;
+        }
+        catch (err) {
+            this.display.log(`Keymaker execution error: ${err.message}`, { source: "Keymaker", level: "error" });
+            throw err;
+        }
+    }
+}
+/**
+ * Factory function to create and execute a Keymaker task.
+ * Used by TaskWorker when routing keymaker tasks.
+ *
+ * @param skillName Name of the skill to execute
+ * @param objective User's task description
+ * @param taskContext Optional context for routing responses
+ */
+export async function executeKeymakerTask(skillName, objective, taskContext) {
+    const registry = SkillRegistry.getInstance();
+    const skillContent = registry.getContent(skillName);
+    if (!skillContent) {
+        throw new Error(`SKILL.md not found for skill: ${skillName}`);
+    }
+    const keymaker = new Keymaker(skillName, skillContent);
+    return keymaker.execute(objective, taskContext);
+}

package/dist/runtime/oracle.js

@@ -15,6 +15,7 @@ import { ApocDelegateTool } from "./tools/apoc-tool.js";
 import { TrinityDelegateTool } from "./tools/trinity-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { MCPManager } from "../config/mcp-manager.js";
+import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
 export class Oracle {
     provider;
     config;
@@ -143,7 +144,8 @@ export class Oracle {
             // Fail-open: Oracle can still initialize even if catalog refresh fails.
             await Neo.refreshDelegateCatalog().catch(() => { });
             await Trinity.refreshDelegateCatalog().catch(() => { });
-            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, timeVerifierTool, ...chronosTools]);
+            updateSkillToolDescriptions();
+            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools]);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -291,6 +293,8 @@ good:
 - Answer directly acknowledging the fact. Do NOT delegate.
 bad:
 - delegate to "neo_delegate" or "apoc_delegate" to save the fact. (Sati handles this automatically in the background)
+
+${SkillRegistry.getInstance().getSystemPromptSection()}
 `);
             // Load existing history from database in reverse order (most recent first)
             let previousMessages = await this.history.getMessages();
@@ -538,7 +542,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
         }
         await Neo.refreshDelegateCatalog().catch(() => { });
         await Trinity.refreshDelegateCatalog().catch(() => { });
-        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, ...chronosTools]);
+        updateSkillToolDescriptions();
+        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, ...chronosTools]);
         await Neo.getInstance().reload();
         this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }

package/dist/runtime/scaffold.js

@@ -1,10 +1,79 @@
 import fs from 'fs-extra';
+import path from 'path';
 import { PATHS } from '../config/paths.js';
 import { ConfigManager } from '../config/manager.js';
 import { DEFAULT_MCP_TEMPLATE } from '../types/mcp.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { migrateConfigFile } from './migration.js';
+const SKILLS_README = `# Morpheus Skills
+
+This folder contains custom skills for Morpheus.
+
+## Creating a Skill
+
+1. Create a folder with your skill name (lowercase, hyphens allowed):
+   \`\`\`
+   mkdir my-skill
+   \`\`\`
+
+2. Create \`SKILL.md\` with YAML frontmatter + instructions:
+   \`\`\`markdown
+   ---
+   name: my-skill
+   description: What this skill does (max 500 chars)
+   execution_mode: sync
+   version: 1.0.0
+   author: your-name
+   tags:
+     - category
+   examples:
+     - "Example request that triggers this skill"
+   ---
+
+   # My Skill
+
+   Instructions for Keymaker to follow when executing this skill.
+
+   ## Steps
+   1. First step
+   2. Second step
+
+   ## Output Format
+   How to format the result.
+   \`\`\`
+
+## Execution Modes
+
+| Mode | Tool | Description |
+|------|------|-------------|
+| sync | skill_execute | Result returned immediately (default) |
+| async | skill_delegate | Runs in background, notifies when done |
+
+**sync** (default): Best for quick tasks like code review, analysis.
+**async**: Best for long-running tasks like builds, deployments.
+
+## How It Works
+
+- Oracle lists available skills in its system prompt
+- When a request matches a sync skill, Oracle calls \`skill_execute\`
+- When a request matches an async skill, Oracle calls \`skill_delegate\`
+- Keymaker has access to ALL tools (filesystem, shell, git, MCP, databases)
+- Keymaker follows SKILL.md instructions to complete the task
+
+## Frontmatter Schema
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| name | Yes | - | Unique identifier (a-z, 0-9, hyphens) |
+| description | Yes | - | Short description (max 500 chars) |
+| execution_mode | No | sync | sync or async |
+| version | No | - | Semver (e.g., 1.0.0) |
+| author | No | - | Your name |
+| enabled | No | true | true/false |
+| tags | No | - | Array of tags (max 10) |
+| examples | No | - | Example requests (max 5) |
+`;
 export async function scaffold() {
     const spinner = ora('Ensuring Morpheus environment...').start();
     try {
@@ -15,6 +84,7 @@ export async function scaffold() {
             fs.ensureDir(PATHS.memory),
             fs.ensureDir(PATHS.cache),
             fs.ensureDir(PATHS.commands),
+            fs.ensureDir(PATHS.skills),
         ]);
         // Migrate config.yaml -> zaion.yaml if needed
         await migrateConfigFile();
@@ -30,6 +100,11 @@ export async function scaffold() {
         if (!(await fs.pathExists(PATHS.mcps))) {
             await fs.writeJson(PATHS.mcps, DEFAULT_MCP_TEMPLATE, { spaces: 2 });
         }
+        // Create skills README if not exists
+        const skillsReadme = path.join(PATHS.skills, 'README.md');
+        if (!(await fs.pathExists(skillsReadme))) {
+            await fs.writeFile(skillsReadme, SKILLS_README, 'utf-8');
+        }
         spinner.succeed('Morpheus environment ready at ' + chalk.cyan(PATHS.root));
     }
     catch (error) {