@elizaos/skills 2.0.0-alpha.10

package/dist/loader.js

@@ -0,0 +1,362 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { parseFrontmatter, resolveSkillInvocationPolicy, resolveSkillMetadata, } from "./frontmatter.js";
+import { getSkillsDir } from "./resolver.js";
+/** Maximum skill name length per Agent Skills spec */
+const MAX_NAME_LENGTH = 64;
+/** Maximum description length per Agent Skills spec */
+const MAX_DESCRIPTION_LENGTH = 1024;
+/** Default config directory name */
+const CONFIG_DIR_NAME = ".elizaos";
+/** Default agent directory for user skills */
+const DEFAULT_AGENT_DIR = join(homedir(), CONFIG_DIR_NAME);
+/**
+ * Validate skill name per Agent Skills spec.
+ * Returns array of validation error messages (empty if valid).
+ *
+ * @param name - The skill name to validate
+ * @param parentDirName - The parent directory name (should match)
+ * @returns Array of validation error messages
+ */
+function validateName(name, parentDirName) {
+    const errors = [];
+    if (name !== parentDirName) {
+        errors.push(`name "${name}" does not match parent directory "${parentDirName}"`);
+    }
+    if (name.length > MAX_NAME_LENGTH) {
+        errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+    }
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        errors.push(`name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)`);
+    }
+    if (name.startsWith("-") || name.endsWith("-")) {
+        errors.push(`name must not start or end with a hyphen`);
+    }
+    if (name.includes("--")) {
+        errors.push(`name must not contain consecutive hyphens`);
+    }
+    return errors;
+}
+/**
+ * Validate description per Agent Skills spec.
+ *
+ * @param description - The skill description to validate
+ * @returns Array of validation error messages
+ */
+function validateDescription(description) {
+    const errors = [];
+    if (!description || description.trim() === "") {
+        errors.push("description is required");
+    }
+    else if (description.length > MAX_DESCRIPTION_LENGTH) {
+        errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+    }
+    return errors;
+}
+/**
+ * Load a single skill from a SKILL.md file
+ *
+ * @param filePath - Absolute path to the SKILL.md file
+ * @param source - Source identifier for this skill
+ * @returns Loaded skill and diagnostics
+ */
+function loadSkillFromFile(filePath, source) {
+    const diagnostics = [];
+    const rawContent = readFileSync(filePath, "utf-8");
+    const { frontmatter } = parseFrontmatter(rawContent);
+    const skillDir = dirname(filePath);
+    const parentDirName = basename(skillDir);
+    // Validate description
+    const descErrors = validateDescription(frontmatter.description);
+    for (const error of descErrors) {
+        diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    // Use name from frontmatter, or fall back to parent directory name
+    const name = frontmatter.name || parentDirName;
+    // Validate name
+    const nameErrors = validateName(name, parentDirName);
+    for (const error of nameErrors) {
+        diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    // Don't load the skill if description is completely missing
+    if (!frontmatter.description || frontmatter.description.trim() === "") {
+        return { skill: null, diagnostics };
+    }
+    return {
+        skill: {
+            name,
+            description: frontmatter.description,
+            filePath,
+            baseDir: skillDir,
+            source,
+            disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        },
+        diagnostics,
+    };
+}
+/**
+ * Internal recursive skill loader
+ *
+ * @param dir - Directory to scan
+ * @param source - Source identifier
+ * @param includeRootFiles - Whether to include .md files at root level
+ * @returns Loaded skills and diagnostics
+ */
+function loadSkillsFromDirInternal(dir, source, includeRootFiles) {
+    const skills = [];
+    const diagnostics = [];
+    if (!existsSync(dir)) {
+        return { skills, diagnostics };
+    }
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        // Skip hidden files and directories
+        if (entry.name.startsWith(".")) {
+            continue;
+        }
+        // Skip node_modules to avoid scanning dependencies
+        if (entry.name === "node_modules") {
+            continue;
+        }
+        const fullPath = join(dir, entry.name);
+        // For symlinks, check if they point to a directory and follow them
+        let isDirectory = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+            const stats = statSync(fullPath);
+            isDirectory = stats.isDirectory();
+            isFile = stats.isFile();
+        }
+        if (isDirectory) {
+            const subResult = loadSkillsFromDirInternal(fullPath, source, false);
+            skills.push(...subResult.skills);
+            diagnostics.push(...subResult.diagnostics);
+            continue;
+        }
+        if (!isFile) {
+            continue;
+        }
+        const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+        const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+        if (!isRootMd && !isSkillMd) {
+            continue;
+        }
+        const result = loadSkillFromFile(fullPath, source);
+        if (result.skill) {
+            skills.push(result.skill);
+        }
+        diagnostics.push(...result.diagnostics);
+    }
+    return { skills, diagnostics };
+}
+/**
+ * Load skills from a single directory.
+ *
+ * Discovery rules:
+ * - Direct .md children in the root
+ * - Recursive SKILL.md under subdirectories
+ *
+ * @param options - Loading options
+ * @returns Loaded skills and diagnostics
+ */
+export function loadSkillsFromDir(options) {
+    const { dir, source } = options;
+    return loadSkillsFromDirInternal(dir, source, true);
+}
+/**
+ * Normalize a path, expanding ~ to home directory
+ *
+ * @param input - Path that may contain ~
+ * @returns Normalized absolute path
+ */
+function normalizePath(input) {
+    const trimmed = input.trim();
+    if (trimmed === "~")
+        return homedir();
+    if (trimmed.startsWith("~/"))
+        return join(homedir(), trimmed.slice(2));
+    if (trimmed.startsWith("~"))
+        return join(homedir(), trimmed.slice(1));
+    return trimmed;
+}
+/**
+ * Resolve a skill path relative to cwd
+ *
+ * @param p - Path to resolve
+ * @param cwd - Current working directory
+ * @returns Absolute path
+ */
+function resolveSkillPath(p, cwd) {
+    const normalized = normalizePath(p);
+    return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
+}
+/**
+ * Check if a target path is under a root path
+ *
+ * @param target - Path to check
+ * @param root - Root path
+ * @returns True if target is under root
+ */
+function isUnderPath(target, root) {
+    const normalizedRoot = resolve(root);
+    if (target === normalizedRoot) {
+        return true;
+    }
+    const prefix = normalizedRoot.endsWith(sep)
+        ? normalizedRoot
+        : `${normalizedRoot}${sep}`;
+    return target.startsWith(prefix);
+}
+/**
+ * Load skills from all configured locations.
+ *
+ * Sources are loaded in precedence order (later sources override earlier):
+ * 1. Bundled skills (from this package)
+ * 2. User/managed skills (~/.elizaos/skills)
+ * 3. Project skills (<cwd>/.elizaos/skills)
+ * 4. Explicit skill paths
+ *
+ * @param options - Loading options
+ * @returns Loaded skills and diagnostics
+ */
+export function loadSkills(options = {}) {
+    const { cwd = process.cwd(), agentDir, skillPaths = [], includeDefaults = true, bundledSkillsDir, managedSkillsDir, } = options;
+    // Resolve directories
+    const resolvedAgentDir = agentDir ?? DEFAULT_AGENT_DIR;
+    const resolvedBundledDir = bundledSkillsDir ?? getSkillsDir();
+    const resolvedManagedDir = managedSkillsDir ?? join(resolvedAgentDir, "skills");
+    const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
+    const userSkillsDir = join(resolvedAgentDir, "skills");
+    const skillMap = new Map();
+    const realPathSet = new Set();
+    const allDiagnostics = [];
+    const collisionDiagnostics = [];
+    function addSkills(result) {
+        allDiagnostics.push(...result.diagnostics);
+        for (const skill of result.skills) {
+            // Skip skills without file paths (inline skills) - they can't be deduplicated
+            if (!skill.filePath) {
+                const existing = skillMap.get(skill.name);
+                if (!existing) {
+                    skillMap.set(skill.name, skill);
+                }
+                continue;
+            }
+            // Resolve symlinks to detect duplicate files
+            let realPath;
+            try {
+                realPath = realpathSync(skill.filePath);
+            }
+            catch {
+                realPath = skill.filePath;
+            }
+            // Skip silently if we've already loaded this exact file (via symlink)
+            if (realPathSet.has(realPath)) {
+                continue;
+            }
+            const existing = skillMap.get(skill.name);
+            if (existing) {
+                collisionDiagnostics.push({
+                    type: "collision",
+                    message: `name "${skill.name}" collision`,
+                    path: skill.filePath,
+                    collision: {
+                        resourceType: "skill",
+                        name: skill.name,
+                        winnerPath: existing.filePath ?? "(inline)",
+                        loserPath: skill.filePath,
+                    },
+                });
+            }
+            else {
+                skillMap.set(skill.name, skill);
+                realPathSet.add(realPath);
+            }
+        }
+    }
+    if (includeDefaults) {
+        // Load in precedence order: bundled < managed < project
+        if (resolvedBundledDir) {
+            addSkills(loadSkillsFromDirInternal(resolvedBundledDir, "bundled", true));
+        }
+        addSkills(loadSkillsFromDirInternal(resolvedManagedDir, "managed", true));
+        addSkills(loadSkillsFromDirInternal(projectSkillsDir, "project", true));
+    }
+    // Determine source for explicit paths
+    const getSource = (resolvedPath) => {
+        if (!includeDefaults) {
+            if (isUnderPath(resolvedPath, userSkillsDir))
+                return "user";
+            if (isUnderPath(resolvedPath, projectSkillsDir))
+                return "project";
+        }
+        return "path";
+    };
+    // Load explicit skill paths
+    for (const rawPath of skillPaths) {
+        const resolvedPath = resolveSkillPath(rawPath, cwd);
+        if (!existsSync(resolvedPath)) {
+            allDiagnostics.push({
+                type: "warning",
+                message: "skill path does not exist",
+                path: resolvedPath,
+            });
+            continue;
+        }
+        const stats = statSync(resolvedPath);
+        const source = getSource(resolvedPath);
+        if (stats.isDirectory()) {
+            addSkills(loadSkillsFromDirInternal(resolvedPath, source, true));
+        }
+        else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+            const result = loadSkillFromFile(resolvedPath, source);
+            if (result.skill) {
+                addSkills({ skills: [result.skill], diagnostics: result.diagnostics });
+            }
+            else {
+                allDiagnostics.push(...result.diagnostics);
+            }
+        }
+        else {
+            allDiagnostics.push({
+                type: "warning",
+                message: "skill path is not a markdown file",
+                path: resolvedPath,
+            });
+        }
+    }
+    return {
+        skills: Array.from(skillMap.values()),
+        diagnostics: [...allDiagnostics, ...collisionDiagnostics],
+    };
+}
+/**
+ * Load skill entries with full metadata parsing
+ *
+ * @param options - Loading options
+ * @returns Skill entries with parsed metadata
+ */
+export function loadSkillEntries(options = {}) {
+    const { skills } = loadSkills(options);
+    return skills.map((skill) => {
+        let frontmatter = {};
+        // Only parse frontmatter for file-based skills
+        if (skill.filePath) {
+            try {
+                const raw = readFileSync(skill.filePath, "utf-8");
+                const parsed = parseFrontmatter(raw);
+                frontmatter = parsed.frontmatter;
+            }
+            catch {
+                // Use empty frontmatter if parsing fails
+            }
+        }
+        return {
+            skill,
+            frontmatter,
+            metadata: resolveSkillMetadata(frontmatter),
+            invocation: resolveSkillInvocationPolicy(frontmatter),
+        };
+    });
+}

package/dist/resolver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Get the absolute path to the bundled skills directory.
+ *
+ * Resolution order:
+ * 1. ELIZAOS_BUNDLED_SKILLS_DIR environment variable
+ * 2. Sibling `skills/` next to the executable (for compiled binaries)
+ * 3. Package's own `skills/` directory (relative to this module)
+ *
+ * @returns Absolute path to the skills directory
+ * @throws Error if skills directory cannot be found
+ */
+export declare function getSkillsDir(): string;
+/**
+ * Clear the cached skills directory path.
+ * Useful for testing or when the directory may have changed.
+ */
+export declare function clearSkillsDirCache(): void;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,IAAI,MAAM,CA6CrC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}

package/dist/resolver.js

@@ -0,0 +1,90 @@
+import { existsSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Cached skills directory path
+ */
+let cachedSkillsDir;
+/**
+ * Check if a directory looks like a skills directory
+ * (contains subdirectories with SKILL.md files or .md files directly)
+ *
+ * @param dir - Directory to check
+ * @returns True if directory appears to contain skills
+ */
+function looksLikeSkillsDir(dir) {
+    if (!existsSync(dir)) {
+        return false;
+    }
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name.startsWith(".")) {
+            continue;
+        }
+        const fullPath = join(dir, entry.name);
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+            return true;
+        }
+        if (entry.isDirectory()) {
+            if (existsSync(join(fullPath, "SKILL.md"))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Get the absolute path to the bundled skills directory.
+ *
+ * Resolution order:
+ * 1. ELIZAOS_BUNDLED_SKILLS_DIR environment variable
+ * 2. Sibling `skills/` next to the executable (for compiled binaries)
+ * 3. Package's own `skills/` directory (relative to this module)
+ *
+ * @returns Absolute path to the skills directory
+ * @throws Error if skills directory cannot be found
+ */
+export function getSkillsDir() {
+    // Return cached value if available
+    if (cachedSkillsDir !== undefined) {
+        return cachedSkillsDir;
+    }
+    // Check environment variable override
+    const override = process.env.ELIZAOS_BUNDLED_SKILLS_DIR?.trim();
+    if (override && existsSync(override)) {
+        cachedSkillsDir = override;
+        return cachedSkillsDir;
+    }
+    // For compiled binaries: check sibling skills/ next to executable
+    const execDir = dirname(process.execPath);
+    const siblingSkills = join(execDir, "skills");
+    if (looksLikeSkillsDir(siblingSkills)) {
+        cachedSkillsDir = siblingSkills;
+        return cachedSkillsDir;
+    }
+    // Resolve relative to this module (packages/skills/dist/resolver.js -> packages/skills/skills)
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    // In development: packages/skills/src/resolver.ts -> packages/skills/skills
+    // In production: packages/skills/dist/resolver.js -> packages/skills/skills
+    const packageRoot = dirname(__dirname); // Go up from src/ or dist/
+    const packageSkills = join(packageRoot, "skills");
+    if (looksLikeSkillsDir(packageSkills)) {
+        cachedSkillsDir = packageSkills;
+        return cachedSkillsDir;
+    }
+    // Also check one more level up in case we're in a nested dist structure
+    const parentPackageSkills = join(dirname(packageRoot), "skills");
+    if (looksLikeSkillsDir(parentPackageSkills)) {
+        cachedSkillsDir = parentPackageSkills;
+        return cachedSkillsDir;
+    }
+    throw new Error("Could not find bundled skills directory. Set ELIZAOS_BUNDLED_SKILLS_DIR environment variable or ensure skills/ directory exists in package.");
+}
+/**
+ * Clear the cached skills directory path.
+ * Useful for testing or when the directory may have changed.
+ */
+export function clearSkillsDirCache() {
+    cachedSkillsDir = undefined;
+}

package/dist/types.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Skill frontmatter parsed from SKILL.md YAML header
+ */
+export interface SkillFrontmatter {
+    /** Skill name (should match parent directory name) */
+    name?: string;
+    /** Human-readable description of what the skill does */
+    description?: string;
+    /** If true, skill won't be included in model prompts (command-only) */
+    "disable-model-invocation"?: boolean;
+    /** Required operating systems (e.g., ["macos", "linux"]) */
+    "required-os"?: string[];
+    /** Required binaries that must be available in PATH */
+    "required-bins"?: string[];
+    /** Required environment variables */
+    "required-env"?: string[];
+    /** Primary environment for the skill (e.g., "node", "python") */
+    "primary-env"?: string;
+    /** Command dispatch mode */
+    "command-dispatch"?: string;
+    /** Command dispatch mode (underscore variant) */
+    command_dispatch?: string;
+    /** Tool name for command dispatch */
+    "command-tool"?: string;
+    /** Tool name for command dispatch (underscore variant) */
+    command_tool?: string;
+    /** Argument mode for command dispatch */
+    "command-arg-mode"?: string;
+    /** Whether skill can be invoked by users via commands */
+    "user-invocable"?: boolean;
+    /** Additional arbitrary metadata */
+    [key: string]: unknown;
+}
+/**
+ * Loaded skill with parsed metadata.
+ *
+ * Core fields (filePath, baseDir, source, disableModelInvocation) are for file-based skills.
+ * Optional runtime fields (instructions, actions, providers, tools, etc.) support inline definitions.
+ */
+export interface Skill {
+    /** Skill name (from frontmatter or directory name) */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Absolute path to the SKILL.md file (optional for inline skills) */
+    filePath?: string;
+    /** Absolute path to the skill's base directory (optional for inline skills) */
+    baseDir?: string;
+    /** Source identifier (e.g., "bundled", "workspace", "managed", "inline") */
+    source?: string;
+    /** If true, skill won't be included in model prompts */
+    disableModelInvocation?: boolean;
+    /** Unique slug identifier for the skill */
+    slug?: string;
+    /** Skill version */
+    version?: string;
+    /** Skill instructions/content */
+    instructions?: string;
+    /** System prompt for the skill */
+    systemPrompt?: string;
+    /** Example usages */
+    examples?: string[];
+    /** Whether the skill is enabled */
+    enabled?: boolean;
+    /** Actions the skill provides */
+    actions?: SkillActionDefinition[];
+    /** Providers the skill provides */
+    providers?: SkillProviderDefinition[];
+    /** Tools available to the skill */
+    tools?: SkillToolDefinition[];
+}
+/**
+ * Skill action definition for inline skills
+ */
+export interface SkillActionDefinition {
+    name: string;
+    description: string;
+    handler: string;
+}
+/**
+ * Skill provider definition for inline skills
+ */
+export interface SkillProviderDefinition {
+    name: string;
+    description: string;
+    get: string;
+}
+/**
+ * Skill tool definition for inline skills (generic, specific implementations can extend)
+ */
+export interface SkillToolDefinition {
+    name: string;
+    description?: string;
+    [key: string]: unknown;
+}
+/**
+ * Diagnostic information from skill loading
+ */
+export interface SkillDiagnostic {
+    /** Diagnostic type */
+    type: "warning" | "error" | "collision";
+    /** Human-readable message */
+    message: string;
+    /** Path to the file that generated this diagnostic */
+    path: string;
+    /** Collision details (only for type="collision") */
+    collision?: {
+        resourceType: "skill";
+        name: string;
+        winnerPath: string;
+        loserPath: string;
+    };
+}
+/**
+ * Result from loading skills from a directory
+ */
+export interface LoadSkillsResult {
+    /** Successfully loaded skills */
+    skills: Skill[];
+    /** Diagnostics from loading process */
+    diagnostics: SkillDiagnostic[];
+}
+/**
+ * Options for loadSkillsFromDir
+ */
+export interface LoadSkillsFromDirOptions {
+    /** Directory to scan for skills */
+    dir: string;
+    /** Source identifier for these skills */
+    source: string;
+}
+/**
+ * Options for loadSkills (multi-directory loading)
+ */
+export interface LoadSkillsOptions {
+    /** Working directory for project-local skills. Default: process.cwd() */
+    cwd?: string;
+    /** Agent config directory for global skills */
+    agentDir?: string;
+    /** Explicit skill paths (files or directories) */
+    skillPaths?: string[];
+    /** Include default skills directories. Default: true */
+    includeDefaults?: boolean;
+    /** Path to bundled skills directory. Default: package's skills/ */
+    bundledSkillsDir?: string;
+    /** Path to managed skills directory. Default: ~/.elizaos/skills */
+    managedSkillsDir?: string;
+}
+/**
+ * Parsed skill entry with frontmatter and metadata
+ */
+export interface SkillEntry {
+    /** The loaded skill */
+    skill: Skill;
+    /** Raw parsed frontmatter */
+    frontmatter: SkillFrontmatter;
+    /** Resolved Otto-specific metadata */
+    metadata: SkillMetadata;
+    /** Invocation policy */
+    invocation: SkillInvocationPolicy;
+}
+/**
+ * Otto-specific skill metadata
+ */
+export interface SkillMetadata {
+    /** Primary environment (node, python, etc.) */
+    primaryEnv?: string;
+    /** Required operating systems */
+    requiredOs?: string[];
+    /** Required binaries */
+    requiredBins?: string[];
+    /** Required environment variables */
+    requiredEnv?: string[];
+}
+/**
+ * Skill invocation policy
+ */
+export interface SkillInvocationPolicy {
+    /** If true, skill won't be included in model prompts */
+    disableModelInvocation?: boolean;
+    /** If false, skill cannot be invoked via user commands */
+    userInvocable?: boolean;
+}
+/**
+ * Skill command specification for chat commands
+ */
+export interface SkillCommandSpec {
+    /** Command name (sanitized, unique) */
+    name: string;
+    /** Original skill name */
+    skillName: string;
+    /** Command description */
+    description: string;
+    /** Optional dispatch configuration */
+    dispatch?: {
+        kind: "tool";
+        toolName: string;
+        argMode: "raw";
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

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