morpheus-cli 0.7.2 → 0.7.3

package/README.md

@@ -22,6 +22,7 @@ It runs as a daemon and orchestrates LLMs, MCP tools, DevKit tools, memory, and
 - `Sati`: long-term memory retrieval/evaluation.
 - `Trinity`: database specialist. Executes queries, introspects schemas, and manages registered databases (PostgreSQL, MySQL, SQLite, MongoDB).
 - `Chronos`: temporal scheduler. Runs Oracle prompts on a recurring or one-time schedule.
+- `Keymaker`: skill executor. Runs user-defined skills with full tool access (DevKit + MCP + internal tools).
 
 ## Installation
 
@@ -441,6 +442,124 @@ Precedence order:
 3. `zaion.yaml`
 4. Defaults
 
+## Skills
+
+Skills are user-defined capabilities that extend Morpheus. Each skill is a folder in `~/.morpheus/skills/` containing a single `SKILL.md` file with YAML frontmatter for metadata.
+
+### Execution Modes
+
+Skills support two execution modes:
+
+- **`sync`** (default) - Executes immediately via `skill_execute`, returns result inline
+- **`async`** - Runs as background task via `skill_delegate`, notifies when complete
+
+### Creating a Skill
+
+```bash
+mkdir -p ~/.morpheus/skills/my-skill
+```
+
+**SKILL.md:**
+```markdown
+---
+name: my-skill
+description: Brief description of what this skill does
+version: 1.0.0
+author: your-name
+enabled: true
+execution_mode: sync
+tags:
+  - automation
+  - example
+examples:
+  - "Example prompt that triggers this skill"
+---
+
+# My Skill
+
+You are an expert at [domain]. Follow these instructions...
+
+## Your Task
+[Instructions for Keymaker to execute]
+```
+
+### Async Skill Example
+
+For long-running tasks like deployments or builds:
+
+```markdown
+---
+name: deploy-staging
+description: Deploy application to staging environment
+execution_mode: async
+tags:
+  - deployment
+  - devops
+---
+
+# Deploy to Staging
+
+Execute a full deployment to the staging environment...
+```
+
+### Using Skills
+
+Once a skill is loaded, Oracle will automatically suggest delegating matching tasks to Keymaker:
+
+**Sync Skills (immediate result):**
+```
+User: "Review the code in src/auth.ts"
+Oracle: [executes code-reviewer skill via skill_execute]
+Keymaker: [returns detailed review immediately]
+```
+
+**Async Skills (background task):**
+```
+User: "Deploy to staging"
+Oracle: [delegates via skill_delegate, task queued]
+Morpheus: [notifies via Telegram/Discord when complete]
+```
+
+### Managing Skills
+
+**CLI Commands:**
+```bash
+# View loaded skills
+morpheus skills
+
+# Reload skills from disk
+morpheus skills --reload
+```
+
+**API Endpoints:**
+```
+GET    /api/skills           - List all skills
+GET    /api/skills/:name     - Get skill details
+POST   /api/skills/reload    - Reload from filesystem
+POST   /api/skills/:name/enable   - Enable skill
+POST   /api/skills/:name/disable  - Disable skill
+```
+
+**Telegram/Discord Commands:**
+```
+/skills              - List skills
+/skill_reload        - Reload skills
+/skill_enable <name> - Enable a skill
+/skill_disable <name> - Disable a skill
+```
+
+### Sample Skills
+
+Example skills are available in `examples/skills/`:
+- `code-reviewer` - Reviews code for issues and best practices (sync)
+- `git-helper` - Assists with Git operations (sync)
+- `deploy-staging` - Deploy to staging environment (async)
+
+Copy them to your skills directory:
+```bash
+cp -r examples/skills/* ~/.morpheus/skills/
+```
+
 ## MCP Configuration
 
 Configure MCP servers in `~/.morpheus/mcps.json`.

package/dist/channels/discord.js

@@ -56,6 +56,24 @@ const SLASH_COMMANDS = [
         .setDescription('Delete a Chronos job')
         .addStringOption(opt => opt.setName('id').setDescription('Job ID').setRequired(true))
         .setDMPermission(true),
+    new SlashCommandBuilder()
+        .setName('skills')
+        .setDescription('List all available skills')
+        .setDMPermission(true),
+    new SlashCommandBuilder()
+        .setName('skill_reload')
+        .setDescription('Reload skills from filesystem')
+        .setDMPermission(true),
+    new SlashCommandBuilder()
+        .setName('skill_enable')
+        .setDescription('Enable a skill')
+        .addStringOption(opt => opt.setName('name').setDescription('Skill name').setRequired(true))
+        .setDMPermission(true),
+    new SlashCommandBuilder()
+        .setName('skill_disable')
+        .setDescription('Disable a skill')
+        .addStringOption(opt => opt.setName('name').setDescription('Skill name').setRequired(true))
+        .setDMPermission(true),
 ].map(cmd => cmd.toJSON());
 // ─── Adapter ──────────────────────────────────────────────────────────────────
 export class DiscordAdapter {
@@ -337,6 +355,18 @@ export class DiscordAdapter {
             case 'chronos_delete':
                 await this.cmdChronosDelete(interaction);
                 break;
+            case 'skills':
+                await this.cmdSkills(interaction);
+                break;
+            case 'skill_reload':
+                await this.cmdSkillReload(interaction);
+                break;
+            case 'skill_enable':
+                await this.cmdSkillEnable(interaction);
+                break;
+            case 'skill_disable':
+                await this.cmdSkillDisable(interaction);
+                break;
         }
     }
     async cmdHelp(interaction) {
@@ -356,6 +386,12 @@ export class DiscordAdapter {
             '`/chronos_enable id:` — Enable a job',
             '`/chronos_delete id:` — Delete a job',
             '',
+            '**Skills**',
+            '`/skills` — List all available skills',
+            '`/skill_reload` — Reload skills from filesystem',
+            '`/skill_enable name:` — Enable a skill',
+            '`/skill_disable name:` — Disable a skill',
+            '',
             'You can also send text or voice messages to chat with the Oracle.',
         ].join('\n');
         await interaction.reply({ content });
@@ -548,6 +584,79 @@ export class DiscordAdapter {
             await interaction.reply({ content: `Error: ${err.message}` });
         }
     }
+    // ─── Skills Commands ─────────────────────────────────────────────────────
+    async cmdSkills(interaction) {
+        try {
+            const { SkillRegistry } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const skills = registry.getAll();
+            if (!skills.length) {
+                await interaction.reply({ content: 'No skills found. Add skills to `~/.morpheus/skills/`' });
+                return;
+            }
+            const lines = skills.map(s => {
+                const status = s.enabled ? '🟢' : '🔴';
+                const tags = s.tags?.length ? ` [${s.tags.join(', ')}]` : '';
+                return `${status} **${s.name}**${tags}\n    _${s.description.slice(0, 50)}${s.description.length > 50 ? '…' : ''}_`;
+            });
+            const enabled = skills.filter(s => s.enabled).length;
+            await interaction.reply({
+                content: `**Skills** (${enabled}/${skills.length} enabled)\n\n${lines.join('\n')}`
+            });
+        }
+        catch (err) {
+            await interaction.reply({ content: `Error: ${err.message}` });
+        }
+    }
+    async cmdSkillReload(interaction) {
+        try {
+            const { SkillRegistry, updateSkillDelegateDescription } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const result = await registry.reload();
+            updateSkillDelegateDescription();
+            const msg = result.errors.length > 0
+                ? `Reloaded ${result.skills.length} skills with ${result.errors.length} error(s).`
+                : `Reloaded ${result.skills.length} skill(s).`;
+            await interaction.reply({ content: msg });
+        }
+        catch (err) {
+            await interaction.reply({ content: `Error: ${err.message}` });
+        }
+    }
+    async cmdSkillEnable(interaction) {
+        const name = interaction.options.getString('name', true);
+        try {
+            const { SkillRegistry, updateSkillDelegateDescription } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const success = registry.enable(name);
+            if (!success) {
+                await interaction.reply({ content: `Skill "${name}" not found.` });
+                return;
+            }
+            updateSkillDelegateDescription();
+            await interaction.reply({ content: `Skill \`${name}\` enabled.` });
+        }
+        catch (err) {
+            await interaction.reply({ content: `Error: ${err.message}` });
+        }
+    }
+    async cmdSkillDisable(interaction) {
+        const name = interaction.options.getString('name', true);
+        try {
+            const { SkillRegistry, updateSkillDelegateDescription } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const success = registry.disable(name);
+            if (!success) {
+                await interaction.reply({ content: `Skill "${name}" not found.` });
+                return;
+            }
+            updateSkillDelegateDescription();
+            await interaction.reply({ content: `Skill \`${name}\` disabled.` });
+        }
+        catch (err) {
+            await interaction.reply({ content: `Error: ${err.message}` });
+        }
+    }
     // ─── Helpers ──────────────────────────────────────────────────────────────
     isAuthorized(userId) {
         return this.allowedUsers.includes(userId);

package/dist/channels/telegram.js

@@ -801,6 +801,22 @@ export class TelegramAdapter {
                 await this.handleChronosDelete(ctx, id);
                 break;
             }
+            case '/skills':
+                await this.handleSkillsList(ctx);
+                break;
+            case '/skill_reload':
+                await this.handleSkillsReload(ctx);
+                break;
+            case '/skill_enable': {
+                const name = args[0] ?? '';
+                await this.handleSkillEnable(ctx, name);
+                break;
+            }
+            case '/skill_disable': {
+                const name = args[0] ?? '';
+                await this.handleSkillDisable(ctx, name);
+                break;
+            }
             default:
                 await this.handleDefaultCommand(ctx, user, command);
         }
@@ -1000,6 +1016,84 @@ export class TelegramAdapter {
         }
     }
     // ─── End Chronos ──────────────────────────────────────────────────────────────
+    // ─── Skills Command Handlers ─────────────────────────────────────────────────
+    async handleSkillsList(ctx) {
+        try {
+            const { SkillRegistry } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const skills = registry.getAll();
+            if (!skills.length) {
+                await ctx.reply('No skills found. Add skills to `~/.morpheus/skills/`', { parse_mode: 'Markdown' });
+                return;
+            }
+            const lines = skills.map(s => {
+                const status = s.enabled ? '🟢' : '🔴';
+                const tags = s.tags?.length ? ` [${s.tags.join(', ')}]` : '';
+                return `${status} *${s.name}*${tags}\n    _${s.description.slice(0, 50)}${s.description.length > 50 ? '…' : ''}_`;
+            });
+            const enabled = skills.filter(s => s.enabled).length;
+            await ctx.reply(`*Skills* (${enabled}/${skills.length} enabled)\n\n${lines.join('\n')}`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleSkillsReload(ctx) {
+        try {
+            const { SkillRegistry, updateSkillDelegateDescription } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const result = await registry.reload();
+            updateSkillDelegateDescription();
+            const msg = result.errors.length > 0
+                ? `Reloaded ${result.skills.length} skills with ${result.errors.length} error(s).`
+                : `Reloaded ${result.skills.length} skill(s).`;
+            await ctx.reply(msg);
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleSkillEnable(ctx, name) {
+        if (!name) {
+            await ctx.reply('Usage: /skill_enable <name>');
+            return;
+        }
+        try {
+            const { SkillRegistry, updateSkillDelegateDescription } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const success = registry.enable(name);
+            if (!success) {
+                await ctx.reply(`Skill "${name}" not found.`);
+                return;
+            }
+            updateSkillDelegateDescription();
+            await ctx.reply(`Skill \`${name}\` enabled.`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    async handleSkillDisable(ctx, name) {
+        if (!name) {
+            await ctx.reply('Usage: /skill_disable <name>');
+            return;
+        }
+        try {
+            const { SkillRegistry, updateSkillDelegateDescription } = await import('../runtime/skills/index.js');
+            const registry = SkillRegistry.getInstance();
+            const success = registry.disable(name);
+            if (!success) {
+                await ctx.reply(`Skill "${name}" not found.`);
+                return;
+            }
+            updateSkillDelegateDescription();
+            await ctx.reply(`Skill \`${name}\` disabled.`, { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err.message}`);
+        }
+    }
+    // ─── End Skills ───────────────────────────────────────────────────────────────
     async handleNewSessionCommand(ctx, user) {
         try {
             await ctx.reply("Are you ready to start a new session\\? Please confirm\\.", {

package/dist/cli/commands/start.js

@@ -22,6 +22,7 @@ import { TaskWorker } from '../../runtime/tasks/worker.js';
 import { TaskNotifier } from '../../runtime/tasks/notifier.js';
 import { ChronosWorker } from '../../runtime/chronos/worker.js';
 import { ChronosRepository } from '../../runtime/chronos/repository.js';
+import { SkillRegistry } from '../../runtime/skills/index.js';
 // Load .env file explicitly in start command
 const envPath = path.join(process.cwd(), '.env');
 if (fs.existsSync(envPath)) {
@@ -126,6 +127,17 @@ export const startCommand = new Command('start')
         if (options.ui) {
             display.log(chalk.blue(`Web UI enabled to port ${options.port}`), { source: 'Zaion' });
         }
+        // Initialize SkillRegistry before Oracle (so skills are available in system prompt)
+        try {
+            const skillRegistry = SkillRegistry.getInstance();
+            await skillRegistry.load();
+            const loadedSkills = skillRegistry.getAll();
+            const enabledCount = skillRegistry.getEnabled().length;
+            display.log(chalk.green(`✓ Skills loaded: ${loadedSkills.length} total, ${enabledCount} enabled`), { source: 'Skills' });
+        }
+        catch (err) {
+            display.log(chalk.yellow(`Skills initialization warning: ${err.message}`), { source: 'Skills' });
+        }
         // Initialize Oracle
         const oracle = new Oracle(config);
         try {

package/dist/config/paths.js

@@ -14,4 +14,5 @@ export const PATHS = {
     browser: path.join(MORPHEUS_ROOT, 'cache', 'browser'),
     commands: path.join(MORPHEUS_ROOT, 'commands'),
     mcps: path.join(MORPHEUS_ROOT, 'mcps.json'),
+    skills: path.join(MORPHEUS_ROOT, 'skills'),
 };

package/dist/config/schemas.js

@@ -28,6 +28,9 @@ export const ApocConfigSchema = LLMConfigSchema.extend({
 });
 export const NeoConfigSchema = LLMConfigSchema;
 export const TrinityConfigSchema = LLMConfigSchema;
+export const KeymakerConfigSchema = LLMConfigSchema.extend({
+    skills_dir: z.string().optional(),
+});
 export const WebhookConfigSchema = z.object({
     telegram_notify_all: z.boolean().optional(),
 }).optional();
@@ -47,6 +50,7 @@ export const ConfigSchema = z.object({
     neo: NeoConfigSchema.optional(),
     apoc: ApocConfigSchema.optional(),
     trinity: TrinityConfigSchema.optional(),
+    keymaker: KeymakerConfigSchema.optional(),
     webhooks: WebhookConfigSchema,
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({

package/dist/http/api.js

@@ -18,6 +18,7 @@ import { Trinity } from '../runtime/trinity.js';
 import { ChronosRepository } from '../runtime/chronos/repository.js';
 import { ChronosWorker } from '../runtime/chronos/worker.js';
 import { createChronosJobRouter, createChronosConfigRouter } from './routers/chronos.js';
+import { createSkillsRouter } from './routers/skills.js';
 import { getActiveEnvOverrides } from '../config/precedence.js';
 async function readLastLines(filePath, n) {
     try {
@@ -41,6 +42,8 @@ export function createApiRouter(oracle, chronosWorker) {
         router.use('/chronos', createChronosJobRouter(chronosRepo, worker));
         router.use('/config/chronos', createChronosConfigRouter(worker));
     }
+    // Mount Skills router
+    router.use('/skills', createSkillsRouter());
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {

package/dist/http/routers/skills.js

@@ -0,0 +1,127 @@
+import { Router } from 'express';
+import { SkillRegistry, updateSkillDelegateDescription } from '../../runtime/skills/index.js';
+import { DisplayManager } from '../../runtime/display.js';
+/**
+ * Create the skills API router
+ *
+ * Endpoints:
+ * - GET /api/skills - List all skills
+ * - GET /api/skills/:name - Get single skill with content
+ * - POST /api/skills/reload - Reload skills from filesystem
+ * - POST /api/skills/:name/enable - Enable a skill
+ * - POST /api/skills/:name/disable - Disable a skill
+ */
+export function createSkillsRouter() {
+    const router = Router();
+    const display = DisplayManager.getInstance();
+    // GET /api/skills - List all skills
+    router.get('/', (_req, res) => {
+        try {
+            const registry = SkillRegistry.getInstance();
+            const skills = registry.getAll();
+            const response = skills.map(skill => ({
+                name: skill.name,
+                description: skill.description,
+                version: skill.version,
+                author: skill.author,
+                enabled: skill.enabled,
+                tags: skill.tags,
+                examples: skill.examples,
+                path: skill.path,
+            }));
+            res.json({
+                skills: response,
+                total: skills.length,
+                enabled: skills.filter(s => s.enabled).length,
+            });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/reload - Reload from filesystem
+    // Must be before /:name routes
+    router.post('/reload', async (_req, res) => {
+        try {
+            const registry = SkillRegistry.getInstance();
+            const result = await registry.reload();
+            // Update skill_delegate tool description with new skills
+            updateSkillDelegateDescription();
+            display.log(`Skills reloaded: ${result.skills.length} loaded, ${result.errors.length} errors`, {
+                source: 'SkillsAPI',
+            });
+            res.json({
+                success: true,
+                loaded: result.skills.length,
+                errors: result.errors.map(e => ({
+                    directory: e.directory,
+                    message: e.message,
+                })),
+            });
+        }
+        catch (err) {
+            display.log(`Skills reload error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/skills/:name - Get single skill with content
+    router.get('/:name', (req, res) => {
+        try {
+            const { name } = req.params;
+            const registry = SkillRegistry.getInstance();
+            const skill = registry.get(name);
+            if (!skill) {
+                return res.status(404).json({ error: `Skill "${name}" not found` });
+            }
+            const content = registry.getContent(name);
+            res.json({
+                ...skill,
+                content: content || null,
+            });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/:name/enable - Enable a skill
+    router.post('/:name/enable', (req, res) => {
+        try {
+            const { name } = req.params;
+            const registry = SkillRegistry.getInstance();
+            const success = registry.enable(name);
+            if (!success) {
+                return res.status(404).json({ error: `Skill "${name}" not found` });
+            }
+            // Update skill_delegate tool description
+            updateSkillDelegateDescription();
+            display.log(`Skill "${name}" enabled`, { source: 'SkillsAPI' });
+            res.json({ success: true, name, enabled: true });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/:name/disable - Disable a skill
+    router.post('/:name/disable', (req, res) => {
+        try {
+            const { name } = req.params;
+            const registry = SkillRegistry.getInstance();
+            const success = registry.disable(name);
+            if (!success) {
+                return res.status(404).json({ error: `Skill "${name}" not found` });
+            }
+            // Update skill_delegate tool description
+            updateSkillDelegateDescription();
+            display.log(`Skill "${name}" disabled`, { source: 'SkillsAPI' });
+            res.json({ success: true, name, enabled: false });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}