morpheus-cli 0.7.2 → 0.7.4

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) {

package/dist/runtime/skills/__tests__/loader.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SkillLoader } from '../loader.js';
+import fs from 'fs-extra';
+import path from 'path';
+/**
+ * Helper to create SKILL.md with YAML frontmatter
+ */
+function createSkillMd(dir, frontmatter, content = '') {
+    const lines = [];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (Array.isArray(value)) {
+            lines.push(`${key}:`);
+            for (const item of value) {
+                lines.push(`  - ${item}`);
+            }
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    const yaml = lines.join('\n');
+    const md = `---\n${yaml}\n---\n${content}`;
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), md);
+}
+describe('SkillLoader', () => {
+    const testDir = path.join(process.cwd(), 'test-skills');
+    let loader;
+    beforeEach(() => {
+        fs.ensureDirSync(testDir);
+        loader = new SkillLoader(testDir);
+    });
+    afterEach(() => {
+        fs.removeSync(testDir);
+    });
+    describe('scan()', () => {
+        it('should return empty list for non-existent directory', async () => {
+            fs.removeSync(testDir);
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should return empty list for empty directory', async () => {
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should load valid skill with all metadata', async () => {
+            const skillDir = path.join(testDir, 'test-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'test-skill',
+                description: 'A test skill for unit testing',
+                version: '1.0.0',
+                author: 'Test Author',
+                enabled: true,
+                execution_mode: 'sync',
+                tags: ['test', 'unit'],
+                examples: ['do something', 'do another thing'],
+            }, '# Test Skill\n\nInstructions here.');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.errors).toHaveLength(0);
+            const skill = result.skills[0];
+            expect(skill.name).toBe('test-skill');
+            expect(skill.description).toBe('A test skill for unit testing');
+            expect(skill.version).toBe('1.0.0');
+            expect(skill.author).toBe('Test Author');
+            expect(skill.enabled).toBe(true);
+            expect(skill.execution_mode).toBe('sync');
+            expect(skill.tags).toEqual(['test', 'unit']);
+            expect(skill.examples).toEqual(['do something', 'do another thing']);
+            expect(skill.content).toBe('# Test Skill\n\nInstructions here.');
+        });
+        it('should load skill with minimal metadata (defaults)', async () => {
+            const skillDir = path.join(testDir, 'minimal-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'minimal-skill',
+                description: 'A minimal skill',
+            }, 'Minimal instructions');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.errors).toHaveLength(0);
+            const skill = result.skills[0];
+            expect(skill.name).toBe('minimal-skill');
+            expect(skill.enabled).toBe(true); // default
+            expect(skill.execution_mode).toBe('sync'); // default
+        });
+        it('should report error for missing SKILL.md', async () => {
+            const skillDir = path.join(testDir, 'no-md-skill');
+            fs.ensureDirSync(skillDir);
+            // No SKILL.md file created
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].directory).toBe('no-md-skill');
+            expect(result.errors[0].message).toContain('Missing SKILL.md');
+        });
+        it('should report error for SKILL.md without frontmatter', async () => {
+            const skillDir = path.join(testDir, 'no-frontmatter');
+            fs.ensureDirSync(skillDir);
+            fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# No Frontmatter\n\nJust plain markdown.');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].directory).toBe('no-frontmatter');
+            expect(result.errors[0].message).toContain('Invalid format');
+        });
+        it('should report error for schema validation failure', async () => {
+            const skillDir = path.join(testDir, 'bad-schema');
+            fs.ensureDirSync(skillDir);
+            // Missing required 'description' field
+            createSkillMd(skillDir, {
+                name: 'bad-schema',
+            }, 'No description provided');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].message).toContain('Schema validation failed');
+        });
+        it('should reject invalid skill name format', async () => {
+            const skillDir = path.join(testDir, 'invalid-name');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'Invalid Name With Spaces!',
+                description: 'Should fail validation',
+            }, 'Content');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].message).toContain('Schema validation failed');
+        });
+        it('should load multiple skills', async () => {
+            // Create skill 1
+            const skill1Dir = path.join(testDir, 'skill-one');
+            fs.ensureDirSync(skill1Dir);
+            createSkillMd(skill1Dir, { name: 'skill-one', description: 'First skill' }, 'Instructions 1');
+            // Create skill 2
+            const skill2Dir = path.join(testDir, 'skill-two');
+            fs.ensureDirSync(skill2Dir);
+            createSkillMd(skill2Dir, { name: 'skill-two', description: 'Second skill' }, 'Instructions 2');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(2);
+            expect(result.errors).toHaveLength(0);
+            const names = result.skills.map(s => s.name).sort();
+            expect(names).toEqual(['skill-one', 'skill-two']);
+        });
+        it('should ignore non-directory entries', async () => {
+            // Create a file instead of directory
+            fs.writeFileSync(path.join(testDir, 'not-a-dir.yaml'), 'name: test');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should load async skill correctly', async () => {
+            const skillDir = path.join(testDir, 'async-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'async-skill',
+                description: 'An async skill',
+                execution_mode: 'async',
+            }, 'Long-running task instructions');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.skills[0].execution_mode).toBe('async');
+        });
+    });
+    describe('content handling', () => {
+        it('should include content in skill object', async () => {
+            const skillDir = path.join(testDir, 'content-skill');
+            fs.ensureDirSync(skillDir);
+            const mdContent = '# Content Skill\n\nThis is the instruction content.';
+            createSkillMd(skillDir, { name: 'content-skill', description: 'Test' }, mdContent);
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.skills[0].content).toBe(mdContent);
+        });
+        it('should handle empty content after frontmatter', async () => {
+            const skillDir = path.join(testDir, 'empty-content');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'empty-content', description: 'Test' }, '');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.skills[0].content).toBe('');
+        });
+    });
+});

package/dist/runtime/skills/__tests__/registry.test.js

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+// Define test directory as a static string path
+const TEST_DIR = process.cwd() + '/test-skills-registry';
+// Mock PATHS to use test directory
+vi.mock('../../../config/paths.js', () => ({
+    PATHS: {
+        skills: process.cwd() + '/test-skills-registry',
+    },
+}));
+// Import after mock setup
+import { SkillRegistry } from '../registry.js';
+/**
+ * Helper to create SKILL.md with YAML frontmatter
+ */
+function createSkillMd(dir, frontmatter, content = '') {
+    const lines = [];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (Array.isArray(value)) {
+            lines.push(`${key}:`);
+            for (const item of value) {
+                lines.push(`  - ${item}`);
+            }
+        }
+        else if (typeof value === 'boolean') {
+            lines.push(`${key}: ${value ? 'true' : 'false'}`);
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    const yaml = lines.join('\n');
+    const md = `---\n${yaml}\n---\n${content}`;
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), md);
+}
+describe('SkillRegistry', () => {
+    beforeEach(() => {
+        SkillRegistry.resetInstance();
+        fs.ensureDirSync(TEST_DIR);
+    });
+    afterEach(() => {
+        fs.removeSync(TEST_DIR);
+    });
+    describe('singleton pattern', () => {
+        it('should return the same instance', () => {
+            const instance1 = SkillRegistry.getInstance();
+            const instance2 = SkillRegistry.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+        it('should reset instance correctly', () => {
+            const instance1 = SkillRegistry.getInstance();
+            SkillRegistry.resetInstance();
+            const instance2 = SkillRegistry.getInstance();
+            expect(instance1).not.toBe(instance2);
+        });
+    });
+    describe('load()', () => {
+        it('should load skills from directory', async () => {
+            const skillDir = path.join(TEST_DIR, 'test-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'test-skill', description: 'Test skill' }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.getAll()).toHaveLength(1);
+            expect(registry.get('test-skill')).toBeDefined();
+        });
+        it('should clear previous skills on reload', async () => {
+            const skillDir = path.join(TEST_DIR, 'skill-a');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'skill-a', description: 'Skill A' }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.getAll()).toHaveLength(1);
+            // Remove the skill and reload
+            fs.removeSync(skillDir);
+            await registry.reload();
+            expect(registry.getAll()).toHaveLength(0);
+        });
+    });
+    describe('enable() / disable()', () => {
+        it('should enable a disabled skill', async () => {
+            const skillDir = path.join(TEST_DIR, 'toggle-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'toggle-skill', description: 'Toggle test', enabled: false }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.get('toggle-skill')?.enabled).toBe(false);
+            expect(registry.getEnabled()).toHaveLength(0);
+            const result = registry.enable('toggle-skill');
+            expect(result).toBe(true);
+            expect(registry.get('toggle-skill')?.enabled).toBe(true);
+            expect(registry.getEnabled()).toHaveLength(1);
+        });
+        it('should disable an enabled skill', async () => {
+            const skillDir = path.join(TEST_DIR, 'toggle-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'toggle-skill', description: 'Toggle test', enabled: true }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.get('toggle-skill')?.enabled).toBe(true);
+            const result = registry.disable('toggle-skill');
+            expect(result).toBe(true);
+            expect(registry.get('toggle-skill')?.enabled).toBe(false);
+            expect(registry.getEnabled()).toHaveLength(0);
+        });
+        it('should return false for non-existent skill', async () => {
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.enable('non-existent')).toBe(false);
+            expect(registry.disable('non-existent')).toBe(false);
+        });
+    });
+    describe('getEnabled()', () => {
+        it('should return only enabled skills', async () => {
+            // Create enabled skill
+            const enabledDir = path.join(TEST_DIR, 'enabled-skill');
+            fs.ensureDirSync(enabledDir);
+            createSkillMd(enabledDir, { name: 'enabled-skill', description: 'Enabled', enabled: true }, 'Instructions');
+            // Create disabled skill
+            const disabledDir = path.join(TEST_DIR, 'disabled-skill');
+            fs.ensureDirSync(disabledDir);
+            createSkillMd(disabledDir, { name: 'disabled-skill', description: 'Disabled', enabled: false }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.getAll()).toHaveLength(2);
+            expect(registry.getEnabled()).toHaveLength(1);
+            expect(registry.getEnabled()[0].name).toBe('enabled-skill');
+        });
+    });
+    describe('getSystemPromptSection()', () => {
+        it('should generate prompt section with sync skills', async () => {
+            const skillDir = path.join(TEST_DIR, 'prompt-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'prompt-skill',
+                description: 'A skill for prompts',
+                execution_mode: 'sync',
+                examples: ['example usage'],
+            }, 'Instructions for prompt skill');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            expect(section).toContain('Available Skills');
+            expect(section).toContain('prompt-skill');
+            expect(section).toContain('A skill for prompts');
+            expect(section).toContain('skill_execute');
+        });
+        it('should generate prompt section with async skills', async () => {
+            const skillDir = path.join(TEST_DIR, 'async-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'async-skill',
+                description: 'An async skill',
+                execution_mode: 'async',
+            }, 'Instructions for async skill');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            expect(section).toContain('Async Skills');
+            expect(section).toContain('async-skill');
+            expect(section).toContain('skill_delegate');
+        });
+        it('should return empty string when no skills', async () => {
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            expect(section).toBe('');
+        });
+        it('should not include disabled skills', async () => {
+            const skillDir = path.join(TEST_DIR, 'disabled-prompt');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'disabled-prompt',
+                description: 'Disabled skill',
+                enabled: false,
+            }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            expect(section).toBe('');
+        });
+    });
+    describe('getContent()', () => {
+        it('should return skill content from loaded skill', async () => {
+            const skillDir = path.join(TEST_DIR, 'content-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'content-skill', description: 'Test' }, '# Instructions\n\nDo the thing.');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const content = registry.getContent('content-skill');
+            expect(content).toBe('# Instructions\n\nDo the thing.');
+        });
+        it('should return null for non-existent skill', async () => {
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const content = registry.getContent('non-existent');
+            expect(content).toBeNull();
+        });
+    });
+});