@elizaos/skills 2.0.0-alpha.10

package/README.md

@@ -0,0 +1,126 @@
+# @elizaos/skills
+
+Bundled skills and skill loading utilities for elizaOS agents.
+
+## Overview
+
+Skills are markdown files that provide specialized instructions for AI agents to perform specific tasks. Each skill contains:
+
+- **Frontmatter**: YAML metadata including name, description, and configuration
+- **Body**: Detailed instructions, examples, and references
+
+## Installation
+
+```bash
+npm install @elizaos/skills
+# or
+pnpm add @elizaos/skills
+```
+
+## Usage
+
+### Get Bundled Skills Path
+
+```typescript
+import { getSkillsDir } from "@elizaos/skills";
+
+const skillsPath = getSkillsDir();
+// Returns absolute path to bundled skills directory
+```
+
+### Load Skills
+
+```typescript
+import { loadSkills, loadSkillsFromDir } from "@elizaos/skills";
+
+// Load from all default locations (bundled + managed + project)
+const { skills, diagnostics } = loadSkills();
+
+// Load from a specific directory
+const result = loadSkillsFromDir({
+  dir: "/path/to/skills",
+  source: "custom",
+});
+```
+
+### Format for LLM Prompt
+
+```typescript
+import { formatSkillsForPrompt } from "@elizaos/skills";
+
+const prompt = formatSkillsForPrompt(skills);
+// Returns XML-formatted skills section for system prompt
+```
+
+### Build Command Specs
+
+```typescript
+import { loadSkillEntries, buildSkillCommandSpecs } from "@elizaos/skills";
+
+const entries = loadSkillEntries();
+const commands = buildSkillCommandSpecs(entries);
+// Returns array of command specs for chat interfaces
+```
+
+## Skill Discovery
+
+Skills are loaded from multiple locations in precedence order (later overrides earlier):
+
+1. **Bundled skills** - Included in this package (`skills/`)
+2. **Managed skills** - User-installed skills (`~/.elizaos/skills/`)
+3. **Project skills** - Project-local skills (`<cwd>/.elizaos/skills/`)
+4. **Explicit paths** - Via `skillPaths` option
+
+## Skill Format
+
+Skills are markdown files with YAML frontmatter:
+
+```markdown
+---
+name: my-skill
+description: A brief description of what this skill does
+primary-env: node
+required-bins:
+  - node
+  - npm
+---
+
+# My Skill
+
+Detailed instructions for the AI agent...
+```
+
+### Frontmatter Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Skill name (should match directory name) |
+| `description` | string | Human-readable description (required) |
+| `disable-model-invocation` | boolean | If true, skill won't appear in prompts |
+| `user-invocable` | boolean | If false, can't be invoked via commands |
+| `primary-env` | string | Primary runtime (node, python, etc.) |
+| `required-os` | string[] | Required operating systems |
+| `required-bins` | string[] | Required binaries in PATH |
+| `required-env` | string[] | Required environment variables |
+
+## API Reference
+
+### Types
+
+- `Skill` - Loaded skill with metadata
+- `SkillFrontmatter` - Parsed frontmatter
+- `SkillEntry` - Full skill entry with all metadata
+- `LoadSkillsResult` - Result from loading skills
+
+### Functions
+
+- `getSkillsDir()` - Get bundled skills path
+- `loadSkills(options?)` - Load from all locations
+- `loadSkillsFromDir(options)` - Load from single directory
+- `loadSkillEntries(options?)` - Load with full metadata
+- `formatSkillsForPrompt(skills)` - Format for LLM prompt
+- `buildSkillCommandSpecs(entries)` - Build command specs
+
+## License
+
+MIT

package/dist/formatter.d.ts

@@ -0,0 +1,44 @@
+import type { Skill, SkillCommandSpec, SkillEntry } from "./types.js";
+/**
+ * Format skills for inclusion in a system prompt.
+ * Uses XML format per Agent Skills standard.
+ * See: https://agentskills.io/integrate-skills
+ *
+ * Skills with disableModelInvocation=true are excluded from the prompt
+ * (they can only be invoked explicitly via /skill:name commands).
+ *
+ * @param skills - Array of skills to format
+ * @returns Formatted skills prompt section
+ */
+export declare function formatSkillsForPrompt(skills: Skill[]): string;
+/**
+ * Format skill entries for prompt (filters by invocation policy)
+ *
+ * @param entries - Skill entries to format
+ * @returns Formatted skills prompt section
+ */
+export declare function formatSkillEntriesForPrompt(entries: SkillEntry[]): string;
+/**
+ * Build command specifications from skill entries.
+ * Creates sanitized, unique command names for each user-invocable skill.
+ *
+ * @param entries - Skill entries to process
+ * @param reservedNames - Set of reserved command names to avoid
+ * @returns Array of skill command specifications
+ */
+export declare function buildSkillCommandSpecs(entries: SkillEntry[], reservedNames?: Set<string>): SkillCommandSpec[];
+/**
+ * Format a single skill for display (minimal format)
+ *
+ * @param skill - Skill to format
+ * @returns Formatted skill string
+ */
+export declare function formatSkillSummary(skill: Skill): string;
+/**
+ * Format skills as a simple list
+ *
+ * @param skills - Skills to format
+ * @returns Newline-separated list of skills
+ */
+export declare function formatSkillsList(skills: Skill[]): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAkBtE;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CA8B7D;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,MAAM,CAMzE;AAyDD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,UAAU,EAAE,EACrB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,gBAAgB,EAAE,CAgEpB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAExD"}

package/dist/formatter.js

@@ -0,0 +1,182 @@
+/**
+ * Escape special XML characters
+ *
+ * @param str - String to escape
+ * @returns XML-escaped string
+ */
+function escapeXml(str) {
+    const s = typeof str === "string" ? str : String(str ?? "");
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Format skills for inclusion in a system prompt.
+ * Uses XML format per Agent Skills standard.
+ * See: https://agentskills.io/integrate-skills
+ *
+ * Skills with disableModelInvocation=true are excluded from the prompt
+ * (they can only be invoked explicitly via /skill:name commands).
+ *
+ * @param skills - Array of skills to format
+ * @returns Formatted skills prompt section
+ */
+export function formatSkillsForPrompt(skills) {
+    const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+    if (visibleSkills.length === 0) {
+        return "";
+    }
+    const lines = [
+        "\n\nThe following skills provide specialized instructions for specific tasks.",
+        "Use the read tool to load a skill's file when the task matches its description.",
+        "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+        "",
+        "<available_skills>",
+    ];
+    for (const skill of visibleSkills) {
+        lines.push("  <skill>");
+        lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+        lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+        if (skill.filePath) {
+            lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+        }
+        lines.push("  </skill>");
+    }
+    lines.push("</available_skills>");
+    return lines.join("\n");
+}
+/**
+ * Format skill entries for prompt (filters by invocation policy)
+ *
+ * @param entries - Skill entries to format
+ * @returns Formatted skills prompt section
+ */
+export function formatSkillEntriesForPrompt(entries) {
+    const visibleSkills = entries
+        .filter((entry) => entry.invocation?.disableModelInvocation !== true)
+        .map((entry) => entry.skill);
+    return formatSkillsForPrompt(visibleSkills);
+}
+/** Maximum length for skill command names */
+const SKILL_COMMAND_MAX_LENGTH = 32;
+/** Fallback command name if sanitization produces empty string */
+const SKILL_COMMAND_FALLBACK = "skill";
+/** Maximum length for command descriptions (Discord limit) */
+const SKILL_COMMAND_DESCRIPTION_MAX_LENGTH = 100;
+/**
+ * Sanitize a skill name for use as a command name.
+ * Converts to lowercase, replaces invalid characters with underscores.
+ *
+ * @param raw - Raw skill name
+ * @returns Sanitized command name
+ */
+function sanitizeSkillCommandName(raw) {
+    const normalized = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    const trimmed = normalized.slice(0, SKILL_COMMAND_MAX_LENGTH);
+    return trimmed || SKILL_COMMAND_FALLBACK;
+}
+/**
+ * Resolve a unique command name by appending a numeric suffix if needed.
+ *
+ * @param base - Base command name
+ * @param used - Set of already-used command names (lowercase)
+ * @returns Unique command name
+ */
+function resolveUniqueSkillCommandName(base, used) {
+    const normalizedBase = base.toLowerCase();
+    if (!used.has(normalizedBase)) {
+        return base;
+    }
+    for (let index = 2; index < 1000; index += 1) {
+        const suffix = `_${index}`;
+        const maxBaseLength = Math.max(1, SKILL_COMMAND_MAX_LENGTH - suffix.length);
+        const trimmedBase = base.slice(0, maxBaseLength);
+        const candidate = `${trimmedBase}${suffix}`;
+        const candidateKey = candidate.toLowerCase();
+        if (!used.has(candidateKey)) {
+            return candidate;
+        }
+    }
+    const fallback = `${base.slice(0, Math.max(1, SKILL_COMMAND_MAX_LENGTH - 2))}_x`;
+    return fallback;
+}
+/**
+ * Build command specifications from skill entries.
+ * Creates sanitized, unique command names for each user-invocable skill.
+ *
+ * @param entries - Skill entries to process
+ * @param reservedNames - Set of reserved command names to avoid
+ * @returns Array of skill command specifications
+ */
+export function buildSkillCommandSpecs(entries, reservedNames) {
+    // Filter to user-invocable skills
+    const userInvocable = entries.filter((entry) => entry.invocation?.userInvocable !== false);
+    const used = new Set();
+    for (const reserved of reservedNames ?? []) {
+        used.add(reserved.toLowerCase());
+    }
+    const specs = [];
+    for (const entry of userInvocable) {
+        const rawName = entry.skill.name;
+        const base = sanitizeSkillCommandName(rawName);
+        const unique = resolveUniqueSkillCommandName(base, used);
+        used.add(unique.toLowerCase());
+        const rawDescription = entry.skill.description?.trim() || rawName;
+        const description = rawDescription.length > SKILL_COMMAND_DESCRIPTION_MAX_LENGTH
+            ? `${rawDescription.slice(0, SKILL_COMMAND_DESCRIPTION_MAX_LENGTH - 1)}…`
+            : rawDescription;
+        // Parse dispatch configuration from frontmatter
+        const dispatch = (() => {
+            const kindRaw = (entry.frontmatter?.["command-dispatch"] ??
+                entry.frontmatter?.command_dispatch ??
+                "")
+                .toString()
+                .trim()
+                .toLowerCase();
+            if (!kindRaw || kindRaw !== "tool") {
+                return undefined;
+            }
+            const toolName = (entry.frontmatter?.["command-tool"] ??
+                entry.frontmatter?.command_tool ??
+                "")
+                .toString()
+                .trim();
+            if (!toolName) {
+                return undefined;
+            }
+            return { kind: "tool", toolName, argMode: "raw" };
+        })();
+        specs.push({
+            name: unique,
+            skillName: rawName,
+            description,
+            ...(dispatch ? { dispatch } : {}),
+        });
+    }
+    return specs;
+}
+/**
+ * Format a single skill for display (minimal format)
+ *
+ * @param skill - Skill to format
+ * @returns Formatted skill string
+ */
+export function formatSkillSummary(skill) {
+    return `${skill.name}: ${skill.description}`;
+}
+/**
+ * Format skills as a simple list
+ *
+ * @param skills - Skills to format
+ * @returns Newline-separated list of skills
+ */
+export function formatSkillsList(skills) {
+    return skills.map(formatSkillSummary).join("\n");
+}

package/dist/frontmatter.d.ts

@@ -0,0 +1,39 @@
+import type { SkillFrontmatter, SkillInvocationPolicy, SkillMetadata } from "./types.js";
+/**
+ * Result of parsing frontmatter from a file
+ */
+export interface ParsedFrontmatter<T extends Record<string, unknown>> {
+    /** Parsed frontmatter object */
+    frontmatter: T;
+    /** Remaining body content after frontmatter */
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from markdown content
+ *
+ * @param content - Raw file content with optional YAML frontmatter
+ * @returns Parsed frontmatter object and remaining body
+ */
+export declare function parseFrontmatter<T extends Record<string, unknown> = Record<string, unknown>>(content: string): ParsedFrontmatter<T>;
+/**
+ * Strip frontmatter from content and return only the body
+ *
+ * @param content - Raw file content with optional YAML frontmatter
+ * @returns Content without frontmatter
+ */
+export declare function stripFrontmatter(content: string): string;
+/**
+ * Resolve Otto-specific metadata from skill frontmatter
+ *
+ * @param frontmatter - Parsed skill frontmatter
+ * @returns Normalized metadata object
+ */
+export declare function resolveSkillMetadata(frontmatter: SkillFrontmatter): SkillMetadata;
+/**
+ * Resolve skill invocation policy from frontmatter
+ *
+ * @param frontmatter - Parsed skill frontmatter
+ * @returns Invocation policy
+ */
+export declare function resolveSkillInvocationPolicy(frontmatter: SkillFrontmatter): SkillInvocationPolicy;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../src/frontmatter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE,gCAAgC;IAChC,WAAW,EAAE,CAAC,CAAC;IACf,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;CACd;AAkCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAOvC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,gBAAgB,GAC5B,aAAa,CAmCf;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,gBAAgB,GAC5B,qBAAqB,CAmBvB"}

package/dist/frontmatter.js

@@ -0,0 +1,105 @@
+import { parse } from "yaml";
+/**
+ * Normalize line endings to Unix-style LF
+ */
+function normalizeNewlines(value) {
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+/**
+ * Extract YAML frontmatter block from content
+ * Frontmatter must start with --- on the first line and end with --- on its own line
+ */
+function extractFrontmatter(content) {
+    const normalized = normalizeNewlines(content);
+    if (!normalized.startsWith("---")) {
+        return { yamlString: null, body: normalized };
+    }
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1) {
+        return { yamlString: null, body: normalized };
+    }
+    return {
+        yamlString: normalized.slice(4, endIndex),
+        body: normalized.slice(endIndex + 4).trim(),
+    };
+}
+/**
+ * Parse YAML frontmatter from markdown content
+ *
+ * @param content - Raw file content with optional YAML frontmatter
+ * @returns Parsed frontmatter object and remaining body
+ */
+export function parseFrontmatter(content) {
+    const { yamlString, body } = extractFrontmatter(content);
+    if (!yamlString) {
+        return { frontmatter: {}, body };
+    }
+    const parsed = parse(yamlString);
+    return { frontmatter: (parsed ?? {}), body };
+}
+/**
+ * Strip frontmatter from content and return only the body
+ *
+ * @param content - Raw file content with optional YAML frontmatter
+ * @returns Content without frontmatter
+ */
+export function stripFrontmatter(content) {
+    return parseFrontmatter(content).body;
+}
+/**
+ * Resolve Otto-specific metadata from skill frontmatter
+ *
+ * @param frontmatter - Parsed skill frontmatter
+ * @returns Normalized metadata object
+ */
+export function resolveSkillMetadata(frontmatter) {
+    const metadata = {};
+    // Primary environment
+    const primaryEnv = frontmatter["primary-env"] ?? frontmatter.primary_env;
+    if (typeof primaryEnv === "string" && primaryEnv.trim()) {
+        metadata.primaryEnv = primaryEnv.trim();
+    }
+    // Required operating systems
+    const requiredOs = frontmatter["required-os"] ?? frontmatter.required_os;
+    if (Array.isArray(requiredOs)) {
+        metadata.requiredOs = requiredOs
+            .filter((os) => typeof os === "string")
+            .map((os) => os.trim().toLowerCase());
+    }
+    // Required binaries
+    const requiredBins = frontmatter["required-bins"] ?? frontmatter.required_bins;
+    if (Array.isArray(requiredBins)) {
+        metadata.requiredBins = requiredBins
+            .filter((bin) => typeof bin === "string")
+            .map((bin) => bin.trim());
+    }
+    // Required environment variables
+    const requiredEnv = frontmatter["required-env"] ?? frontmatter.required_env;
+    if (Array.isArray(requiredEnv)) {
+        metadata.requiredEnv = requiredEnv
+            .filter((env) => typeof env === "string")
+            .map((env) => env.trim());
+    }
+    return metadata;
+}
+/**
+ * Resolve skill invocation policy from frontmatter
+ *
+ * @param frontmatter - Parsed skill frontmatter
+ * @returns Invocation policy
+ */
+export function resolveSkillInvocationPolicy(frontmatter) {
+    const policy = {};
+    // Disable model invocation (snake_case and kebab-case)
+    const disableModelInvocation = frontmatter["disable-model-invocation"] ??
+        frontmatter.disable_model_invocation;
+    if (disableModelInvocation === true) {
+        policy.disableModelInvocation = true;
+    }
+    // User invocable (snake_case and kebab-case)
+    const userInvocable = frontmatter["user-invocable"] ?? frontmatter.user_invocable;
+    if (userInvocable === false) {
+        policy.userInvocable = false;
+    }
+    return policy;
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @elizaos/skills - Bundled skills and skill loading utilities for elizaOS agents
+ *
+ * This package provides:
+ * - Bundled skills (markdown files with instructions for specific tasks)
+ * - Skill loading and discovery utilities
+ * - Prompt formatting for LLM integration
+ * - Command specification building for chat interfaces
+ *
+ * @example
+ * ```typescript
+ * import { getSkillsDir, loadSkills, formatSkillsForPrompt } from "@elizaos/skills";
+ *
+ * // Get path to bundled skills
+ * const skillsPath = getSkillsDir();
+ *
+ * // Load all skills from default locations
+ * const { skills, diagnostics } = loadSkills();
+ *
+ * // Format for LLM prompt
+ * const prompt = formatSkillsForPrompt(skills);
+ * ```
+ */
+export { buildSkillCommandSpecs, formatSkillEntriesForPrompt, formatSkillSummary, formatSkillsForPrompt, formatSkillsList, } from "./formatter.js";
+export { type ParsedFrontmatter, parseFrontmatter, resolveSkillInvocationPolicy, resolveSkillMetadata, stripFrontmatter, } from "./frontmatter.js";
+export { loadSkillEntries, loadSkills, loadSkillsFromDir } from "./loader.js";
+export { clearSkillsDirCache, getSkillsDir } from "./resolver.js";
+export type { LoadSkillsFromDirOptions, LoadSkillsOptions, LoadSkillsResult, Skill, SkillActionDefinition, SkillCommandSpec, SkillDiagnostic, SkillEntry, SkillFrontmatter, SkillInvocationPolicy, SkillMetadata, SkillProviderDefinition, SkillToolDefinition, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EACL,sBAAsB,EACtB,2BAA2B,EAC3B,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,4BAA4B,EAC5B,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE9E,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElE,YAAY,EACV,wBAAwB,EACxB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,EACb,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * @elizaos/skills - Bundled skills and skill loading utilities for elizaOS agents
+ *
+ * This package provides:
+ * - Bundled skills (markdown files with instructions for specific tasks)
+ * - Skill loading and discovery utilities
+ * - Prompt formatting for LLM integration
+ * - Command specification building for chat interfaces
+ *
+ * @example
+ * ```typescript
+ * import { getSkillsDir, loadSkills, formatSkillsForPrompt } from "@elizaos/skills";
+ *
+ * // Get path to bundled skills
+ * const skillsPath = getSkillsDir();
+ *
+ * // Load all skills from default locations
+ * const { skills, diagnostics } = loadSkills();
+ *
+ * // Format for LLM prompt
+ * const prompt = formatSkillsForPrompt(skills);
+ * ```
+ */
+// Prompt formatting
+export { buildSkillCommandSpecs, formatSkillEntriesForPrompt, formatSkillSummary, formatSkillsForPrompt, formatSkillsList, } from "./formatter.js";
+// Frontmatter parsing
+export { parseFrontmatter, resolveSkillInvocationPolicy, resolveSkillMetadata, stripFrontmatter, } from "./frontmatter.js";
+// Skill loading
+export { loadSkillEntries, loadSkills, loadSkillsFromDir } from "./loader.js";
+// Path resolution
+export { clearSkillsDirCache, getSkillsDir } from "./resolver.js";

package/dist/loader.d.ts

@@ -0,0 +1,33 @@
+import type { LoadSkillsFromDirOptions, LoadSkillsOptions, LoadSkillsResult, SkillEntry } from "./types.js";
+/**
+ * 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 declare function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkillsResult;
+/**
+ * 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 declare function loadSkills(options?: LoadSkillsOptions): LoadSkillsResult;
+/**
+ * Load skill entries with full metadata parsing
+ *
+ * @param options - Loading options
+ * @returns Skill entries with parsed metadata
+ */
+export declare function loadSkillEntries(options?: LoadSkillsOptions): SkillEntry[];
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,wBAAwB,EACxB,iBAAiB,EACjB,gBAAgB,EAGhB,UAAU,EAEX,MAAM,YAAY,CAAC;AAkMpB;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,wBAAwB,GAChC,gBAAgB,CAGlB;AA8CD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CA0H5E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,iBAAsB,GAC9B,UAAU,EAAE,CAuBd"}