morpheus-cli 0.7.1 → 0.7.3

package/dist/runtime/skills/loader.js

@@ -0,0 +1,213 @@
+/**
+ * SkillLoader - Discovers and loads skills from filesystem
+ *
+ * Skills are SKILL.md files with YAML frontmatter containing metadata.
+ * Format:
+ * ---
+ * name: my-skill
+ * description: What this skill does
+ * execution_mode: sync
+ * ---
+ *
+ * # Skill Instructions...
+ */
+import fs from 'fs';
+import path from 'path';
+import { SkillMetadataSchema } from './schema.js';
+import { DisplayManager } from '../display.js';
+const SKILL_MD = 'SKILL.md';
+const MAX_SKILL_MD_SIZE = 50 * 1024; // 50KB
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Simple YAML frontmatter parser
+ * Handles basic key: value pairs and arrays
+ */
+function parseFrontmatter(yaml) {
+    const result = {};
+    const lines = yaml.split('\n');
+    let currentKey = null;
+    let currentArray = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        // Check for array item (indented with -)
+        if (trimmed.startsWith('- ') && currentKey && currentArray !== null) {
+            currentArray.push(trimmed.slice(2).trim().replace(/^["']|["']$/g, ''));
+            continue;
+        }
+        // Check for key: value
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            // Save previous array if exists
+            if (currentKey && currentArray !== null && currentArray.length > 0) {
+                result[currentKey] = currentArray;
+            }
+            currentArray = null;
+            const key = line.slice(0, colonIndex).trim();
+            const value = line.slice(colonIndex + 1).trim();
+            currentKey = key;
+            if (value === '') {
+                // Could be start of array
+                currentArray = [];
+            }
+            else if (value === 'true') {
+                result[key] = true;
+            }
+            else if (value === 'false') {
+                result[key] = false;
+            }
+            else if (/^\d+$/.test(value)) {
+                result[key] = parseInt(value, 10);
+            }
+            else if (/^\d+\.\d+$/.test(value)) {
+                result[key] = parseFloat(value);
+            }
+            else {
+                // Remove quotes if present
+                result[key] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+    // Save last array if exists
+    if (currentKey && currentArray !== null && currentArray.length > 0) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+export class SkillLoader {
+    skillsDir;
+    display = DisplayManager.getInstance();
+    constructor(skillsDir) {
+        this.skillsDir = skillsDir;
+    }
+    /**
+     * Scan skills directory and load all valid skills
+     */
+    async scan() {
+        const skills = [];
+        const errors = [];
+        // Check if skills directory exists
+        if (!fs.existsSync(this.skillsDir)) {
+            this.display.log(`Skills directory does not exist: ${this.skillsDir}`, {
+                source: 'SkillLoader',
+                level: 'debug',
+            });
+            return { skills, errors };
+        }
+        // Read directory contents
+        let entries;
+        try {
+            entries = fs.readdirSync(this.skillsDir, { withFileTypes: true });
+        }
+        catch (err) {
+            this.display.log(`Failed to read skills directory: ${err}`, {
+                source: 'SkillLoader',
+                level: 'error',
+            });
+            return { skills, errors };
+        }
+        // Process each subdirectory
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dirPath = path.join(this.skillsDir, entry.name);
+            const result = this.loadSkillFromDir(dirPath, entry.name);
+            if (result.skill) {
+                skills.push(result.skill);
+            }
+            else if (result.error) {
+                errors.push(result.error);
+            }
+        }
+        return { skills, errors };
+    }
+    /**
+     * Load a single skill from a directory
+     */
+    loadSkillFromDir(dirPath, dirName) {
+        const mdPath = path.join(dirPath, SKILL_MD);
+        // Check SKILL.md exists
+        if (!fs.existsSync(mdPath)) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Missing ${SKILL_MD}`,
+                },
+            };
+        }
+        // Read SKILL.md content
+        let rawContent;
+        try {
+            const stats = fs.statSync(mdPath);
+            if (stats.size > MAX_SKILL_MD_SIZE) {
+                this.display.log(`SKILL.md for "${dirName}" exceeds ${MAX_SKILL_MD_SIZE / 1024}KB`, { source: 'SkillLoader', level: 'warning' });
+            }
+            rawContent = fs.readFileSync(mdPath, 'utf-8').slice(0, MAX_SKILL_MD_SIZE);
+        }
+        catch (err) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Failed to read ${SKILL_MD}: ${err instanceof Error ? err.message : String(err)}`,
+                    error: err instanceof Error ? err : undefined,
+                },
+            };
+        }
+        // Parse frontmatter
+        const match = rawContent.match(FRONTMATTER_REGEX);
+        if (!match) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Invalid format: ${SKILL_MD} must start with YAML frontmatter (--- ... ---)`,
+                },
+            };
+        }
+        const [, frontmatterYaml, content] = match;
+        // Parse YAML frontmatter
+        let rawMeta;
+        try {
+            rawMeta = parseFrontmatter(frontmatterYaml);
+        }
+        catch (err) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Invalid YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`,
+                    error: err instanceof Error ? err : undefined,
+                },
+            };
+        }
+        // Validate against schema
+        const parseResult = SkillMetadataSchema.safeParse(rawMeta);
+        if (!parseResult.success) {
+            const issues = parseResult.error.issues
+                .map((i) => `${i.path.join('.')}: ${i.message}`)
+                .join('; ');
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Schema validation failed: ${issues}`,
+                },
+            };
+        }
+        const metadata = parseResult.data;
+        // Build Skill object
+        const skill = {
+            ...metadata,
+            path: mdPath,
+            dirName,
+            content: content.trim(),
+            enabled: metadata.enabled ?? true,
+            execution_mode: metadata.execution_mode ?? 'sync',
+        };
+        return { skill };
+    }
+    /**
+     * Read SKILL.md content for a skill (returns just the body, no frontmatter)
+     */
+    readContent(skill) {
+        return skill.content || null;
+    }
+}

package/dist/runtime/skills/registry.js

@@ -0,0 +1,141 @@
+/**
+ * SkillRegistry - Singleton registry for loaded skills
+ */
+import { PATHS } from '../../config/paths.js';
+import { DisplayManager } from '../display.js';
+import { SkillLoader } from './loader.js';
+export class SkillRegistry {
+    static instance = null;
+    skills = new Map();
+    loader;
+    display = DisplayManager.getInstance();
+    constructor() {
+        this.loader = new SkillLoader(PATHS.skills);
+    }
+    static getInstance() {
+        if (!SkillRegistry.instance) {
+            SkillRegistry.instance = new SkillRegistry();
+        }
+        return SkillRegistry.instance;
+    }
+    static resetInstance() {
+        SkillRegistry.instance = null;
+    }
+    /**
+     * Load skills from filesystem
+     */
+    async load() {
+        const result = await this.loader.scan();
+        this.skills.clear();
+        for (const skill of result.skills) {
+            if (this.skills.has(skill.name)) {
+                this.display.log(`Duplicate skill name "${skill.name}", overwriting`, {
+                    source: 'SkillRegistry',
+                    level: 'warning',
+                });
+            }
+            this.skills.set(skill.name, skill);
+        }
+        // Log errors
+        for (const error of result.errors) {
+            this.display.log(`Failed to load skill from "${error.directory}": ${error.message}`, {
+                source: 'SkillRegistry',
+                level: 'warning',
+            });
+        }
+        this.display.log(`Loaded ${this.skills.size} skills`, { source: 'SkillRegistry' });
+        return result;
+    }
+    /**
+     * Reload skills from filesystem
+     */
+    async reload() {
+        return this.load();
+    }
+    /**
+     * Get all loaded skills
+     */
+    getAll() {
+        return Array.from(this.skills.values());
+    }
+    /**
+     * Get only enabled skills
+     */
+    getEnabled() {
+        return this.getAll().filter((s) => s.enabled);
+    }
+    /**
+     * Get a skill by name
+     */
+    get(name) {
+        return this.skills.get(name);
+    }
+    /**
+     * Enable a skill (runtime only, doesn't persist to YAML)
+     */
+    enable(name) {
+        const skill = this.skills.get(name);
+        if (!skill)
+            return false;
+        skill.enabled = true;
+        return true;
+    }
+    /**
+     * Disable a skill (runtime only, doesn't persist to YAML)
+     */
+    disable(name) {
+        const skill = this.skills.get(name);
+        if (!skill)
+            return false;
+        skill.enabled = false;
+        return true;
+    }
+    /**
+     * Read SKILL.md content for a skill
+     */
+    getContent(name) {
+        const skill = this.skills.get(name);
+        if (!skill)
+            return null;
+        return skill.content || null;
+    }
+    /**
+     * Generate system prompt section listing available skills
+     */
+    getSystemPromptSection() {
+        const enabled = this.getEnabled();
+        if (enabled.length === 0) {
+            return '';
+        }
+        const syncSkills = enabled.filter((s) => s.execution_mode === 'sync');
+        const asyncSkills = enabled.filter((s) => s.execution_mode === 'async');
+        const lines = ['## Available Skills', ''];
+        if (syncSkills.length > 0) {
+            lines.push('### Sync Skills (immediate result via skill_execute)');
+            for (const s of syncSkills) {
+                lines.push(`- **${s.name}**: ${s.description}`);
+            }
+            lines.push('');
+        }
+        if (asyncSkills.length > 0) {
+            lines.push('### Async Skills (background task via skill_delegate)');
+            for (const s of asyncSkills) {
+                lines.push(`- **${s.name}**: ${s.description}`);
+            }
+            lines.push('');
+        }
+        lines.push('Use `skill_execute(skillName, objective)` for sync skills — result returned immediately.');
+        lines.push('Use `skill_delegate(skillName, objective)` for async skills — runs in background, notifies when done.');
+        return lines.join('\n');
+    }
+    /**
+     * Get skill names for tool description
+     */
+    getSkillNamesForTool() {
+        const enabled = this.getEnabled();
+        if (enabled.length === 0) {
+            return 'No skills available.';
+        }
+        return `Available skills: ${enabled.map((s) => s.name).join(', ')}`;
+    }
+}

package/dist/runtime/skills/schema.js

@@ -0,0 +1,30 @@
+/**
+ * Skills Zod Schema for SKILL.md frontmatter validation
+ */
+import { z } from 'zod';
+/**
+ * Schema for SKILL.md frontmatter metadata
+ */
+export const SkillMetadataSchema = z.object({
+    name: z
+        .string()
+        .min(1, 'Skill name is required')
+        .max(64, 'Skill name must be at most 64 characters')
+        .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/, 'Skill name must be lowercase alphanumeric with hyphens, cannot start/end with hyphen'),
+    description: z
+        .string()
+        .min(1, 'Description is required')
+        .max(500, 'Description must be at most 500 characters'),
+    execution_mode: z
+        .enum(['sync', 'async'])
+        .default('sync')
+        .describe('Execution mode: sync returns result inline, async creates background task'),
+    version: z
+        .string()
+        .regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format (e.g., 1.0.0)')
+        .optional(),
+    author: z.string().max(100).optional(),
+    enabled: z.boolean().optional().default(true),
+    tags: z.array(z.string().max(32)).max(10).optional(),
+    examples: z.array(z.string().max(200)).max(5).optional(),
+});

package/dist/runtime/skills/tool.js

@@ -0,0 +1,204 @@
+/**
+ * Skill Tools - skill_execute (sync) and skill_delegate (async)
+ */
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { DisplayManager } from "../display.js";
+import { SkillRegistry } from "./registry.js";
+import { executeKeymakerTask } from "../keymaker.js";
+// ============================================================================
+// skill_execute - Synchronous execution
+// ============================================================================
+/**
+ * Generates the skill_execute tool description dynamically with sync skills.
+ */
+export function getSkillExecuteDescription() {
+    const registry = SkillRegistry.getInstance();
+    const syncSkills = registry.getEnabled().filter((s) => s.execution_mode === 'sync');
+    const skillList = syncSkills.length > 0
+        ? syncSkills.map(s => `- ${s.name}: ${s.description}`).join('\n')
+        : '(no sync skills enabled)';
+    return `Execute a skill synchronously using Keymaker. The result is returned immediately.
+
+Keymaker has access to ALL tools (filesystem, shell, git, MCP, browser, etc.) and will execute the skill instructions.
+
+Available sync skills:
+${skillList}
+
+Use this for skills that need immediate results in the conversation.`;
+}
+/**
+ * Tool that Oracle uses to execute skills synchronously via Keymaker.
+ * Result is returned directly to Oracle for inclusion in the response.
+ */
+export const SkillExecuteTool = tool(async ({ skillName, objective }) => {
+    const display = DisplayManager.getInstance();
+    const registry = SkillRegistry.getInstance();
+    // Validate skill exists and is enabled
+    const skill = registry.get(skillName);
+    if (!skill) {
+        const available = registry.getEnabled().map(s => s.name).join(', ');
+        return `Error: Skill "${skillName}" not found. Available skills: ${available || 'none'}`;
+    }
+    if (!skill.enabled) {
+        return `Error: Skill "${skillName}" is disabled.`;
+    }
+    if (skill.execution_mode === 'async') {
+        return `Error: Skill "${skillName}" is async-only. Use skill_delegate instead.`;
+    }
+    display.log(`Executing skill "${skillName}" synchronously...`, {
+        source: "SkillExecuteTool",
+        level: "info",
+    });
+    try {
+        const ctx = TaskRequestContext.get();
+        const sessionId = ctx?.session_id ?? "default";
+        const taskContext = {
+            origin_channel: ctx?.origin_channel ?? "api",
+            session_id: sessionId,
+            origin_message_id: ctx?.origin_message_id,
+            origin_user_id: ctx?.origin_user_id,
+        };
+        // Execute Keymaker directly (synchronous)
+        const result = await executeKeymakerTask(skillName, objective, taskContext);
+        display.log(`Skill "${skillName}" completed successfully.`, {
+            source: "SkillExecuteTool",
+            level: "info",
+        });
+        return result;
+    }
+    catch (err) {
+        display.log(`Skill execution error: ${err.message}`, {
+            source: "SkillExecuteTool",
+            level: "error",
+        });
+        return `Skill execution failed: ${err.message}`;
+    }
+}, {
+    name: "skill_execute",
+    description: getSkillExecuteDescription(),
+    schema: z.object({
+        skillName: z.string().describe("Exact name of the sync skill to use"),
+        objective: z.string().describe("Clear description of what to accomplish"),
+    }),
+});
+// ============================================================================
+// skill_delegate - Asynchronous execution (background task)
+// ============================================================================
+/**
+ * Generates the skill_delegate tool description dynamically with async skills.
+ */
+export function getSkillDelegateDescription() {
+    const registry = SkillRegistry.getInstance();
+    const asyncSkills = registry.getEnabled().filter((s) => s.execution_mode === 'async');
+    const skillList = asyncSkills.length > 0
+        ? asyncSkills.map(s => `- ${s.name}: ${s.description}`).join('\n')
+        : '(no async skills enabled)';
+    return `Delegate a task to Keymaker as a background job. You will be notified when complete.
+
+Keymaker has access to ALL tools (filesystem, shell, git, MCP, browser, etc.) and will execute the skill instructions.
+
+Available async skills:
+${skillList}
+
+Use this for long-running skills like builds, deployments, or batch processing.`;
+}
+/**
+ * Tool that Oracle uses to delegate tasks to Keymaker via async task queue.
+ * Keymaker will execute the skill instructions in background.
+ */
+export const SkillDelegateTool = tool(async ({ skillName, objective }) => {
+    try {
+        const display = DisplayManager.getInstance();
+        const registry = SkillRegistry.getInstance();
+        // Validate skill exists and is enabled
+        const skill = registry.get(skillName);
+        if (!skill) {
+            const available = registry.getEnabled().map(s => s.name).join(', ');
+            return `Error: Skill "${skillName}" not found. Available skills: ${available || 'none'}`;
+        }
+        if (!skill.enabled) {
+            return `Error: Skill "${skillName}" is disabled.`;
+        }
+        if (skill.execution_mode !== 'async') {
+            return `Error: Skill "${skillName}" is sync. Use skill_execute instead for immediate results.`;
+        }
+        // Check for duplicate delegation
+        const existingAck = TaskRequestContext.findDuplicateDelegation("keymaker", `${skillName}:${objective}`);
+        if (existingAck) {
+            display.log(`Keymaker delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                source: "SkillDelegateTool",
+                level: "info",
+            });
+            return `Task ${existingAck.task_id} already queued for Keymaker (${skillName}) execution.`;
+        }
+        if (!TaskRequestContext.canEnqueueDelegation()) {
+            display.log(`Keymaker delegation blocked by per-turn limit.`, {
+                source: "SkillDelegateTool",
+                level: "warning",
+            });
+            return "Delegation limit reached for this user turn. Wait for current tasks to complete.";
+        }
+        const ctx = TaskRequestContext.get();
+        const repository = TaskRepository.getInstance();
+        // Store skill name in context as JSON
+        const taskContext = JSON.stringify({ skill: skillName });
+        const created = repository.createTask({
+            agent: "keymaker",
+            input: objective,
+            context: taskContext,
+            origin_channel: ctx?.origin_channel ?? "api",
+            session_id: ctx?.session_id ?? "default",
+            origin_message_id: ctx?.origin_message_id ?? null,
+            origin_user_id: ctx?.origin_user_id ?? null,
+            max_attempts: 3,
+        });
+        TaskRequestContext.setDelegationAck({
+            task_id: created.id,
+            agent: "keymaker",
+            task: `${skillName}:${objective}`,
+        });
+        display.log(`Keymaker task created: ${created.id} (skill: ${skillName})`, {
+            source: "SkillDelegateTool",
+            level: "info",
+            meta: {
+                agent: created.agent,
+                skill: skillName,
+                origin_channel: created.origin_channel,
+                session_id: created.session_id,
+                input: created.input,
+            }
+        });
+        return `Task ${created.id} queued for Keymaker (skill: ${skillName}). You will be notified when complete.`;
+    }
+    catch (err) {
+        const display = DisplayManager.getInstance();
+        display.log(`SkillDelegateTool error: ${err.message}`, {
+            source: "SkillDelegateTool",
+            level: "error",
+        });
+        return `Keymaker task enqueue failed: ${err.message}`;
+    }
+}, {
+    name: "skill_delegate",
+    description: getSkillDelegateDescription(),
+    schema: z.object({
+        skillName: z.string().describe("Exact name of the async skill to use"),
+        objective: z.string().describe("Clear description of what Keymaker should accomplish"),
+    }),
+});
+// ============================================================================
+// Utility functions
+// ============================================================================
+/**
+ * Updates both skill tool descriptions with current skill list.
+ * Should be called after skills are loaded/reloaded.
+ */
+export function updateSkillToolDescriptions() {
+    SkillExecuteTool.description = getSkillExecuteDescription();
+    SkillDelegateTool.description = getSkillDelegateDescription();
+}
+// Backwards compatibility alias
+export const updateSkillDelegateDescription = updateSkillToolDescriptions;

package/dist/runtime/skills/types.js

@@ -0,0 +1,7 @@
+/**
+ * Skills System Type Definitions
+ *
+ * Skills are user-defined behavioral extensions loaded from ~/.morpheus/skills/
+ * Each skill is a SKILL.md file with YAML frontmatter containing metadata.
+ */
+export {};

package/dist/runtime/tasks/worker.js

@@ -3,6 +3,7 @@ import { DisplayManager } from '../display.js';
 import { Apoc } from '../apoc.js';
 import { Neo } from '../neo.js';
 import { Trinity } from '../trinity.js';
+import { executeKeymakerTask } from '../keymaker.js';
 import { TaskRepository } from './repository.js';
 export class TaskWorker {
     workerId;
@@ -71,6 +72,27 @@ export class TaskWorker {
                     output = await trinity.execute(task.input, task.context ?? undefined, task.session_id);
                     break;
                 }
+                case 'keymaker': {
+                    // Parse skill name from context JSON
+                    let skillName = 'unknown';
+                    if (task.context) {
+                        try {
+                            const parsed = JSON.parse(task.context);
+                            skillName = parsed.skill || 'unknown';
+                        }
+                        catch {
+                            // context is not JSON, use as skill name directly for backwards compat
+                            skillName = task.context;
+                        }
+                    }
+                    output = await executeKeymakerTask(skillName, task.input, {
+                        origin_channel: task.origin_channel,
+                        session_id: task.session_id,
+                        origin_message_id: task.origin_message_id ?? undefined,
+                        origin_user_id: task.origin_user_id ?? undefined,
+                    });
+                    break;
+                }
                 default: {
                     throw new Error(`Unknown task agent: ${task.agent}`);
                 }