@codemcp/skills 1.8.0 → 2.0.0

package/dist/chunk-EQ5IFWEC.js

@@ -0,0 +1,1537 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../core/dist/config-generators.js
+var ConfigGeneratorRegistry = class {
+  generators = /* @__PURE__ */ new Map();
+  /**
+   * Register a config generator
+   */
+  register(generator) {
+    for (const agentType of generator.agentTypes) {
+      this.generators.set(agentType, generator);
+    }
+  }
+  /**
+   * Get a generator for an agent type
+   */
+  getGenerator(agentType) {
+    return this.generators.get(agentType);
+  }
+  /**
+   * Generate config for an agent
+   */
+  async generate(agentType, config, options) {
+    const generator = this.getGenerator(agentType);
+    if (!generator)
+      return null;
+    return generator.generate(config, options);
+  }
+  /**
+   * List all registered generators
+   */
+  listGenerators() {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const generator of this.generators.values()) {
+      const name = generator.getMetadata().name;
+      if (!seen.has(name)) {
+        result.push(generator.getMetadata());
+        seen.add(name);
+      }
+    }
+    return result;
+  }
+  /**
+   * Check if any generator supports an agent type
+   */
+  supports(agentType) {
+    return this.generators.has(agentType);
+  }
+  /**
+   * Get all supported agent types
+   */
+  getSupportedAgentTypes() {
+    return Array.from(this.generators.keys());
+  }
+  /**
+   * Clear all generators (mainly for testing)
+   */
+  clear() {
+    this.generators.clear();
+  }
+};
+
+// ../core/dist/generators/skills-agent-description.js
+var SKILLS_AGENT_DESCRIPTION_MARKDOWN = `# Skill Usage
+
+## Mandatory Workflow Before Every Response
+
+Before responding to a message, ALWAYS check:
+
+1. List available skills
+2. Ask yourself: "Does ONE skill fit this task?" (at just 1% probability \u2192 call the skill)
+3. If yes \u2192 load and execute skill via \`use_skill\` MCP tool
+4. Announce: "I'm using [Skill-Name] for [Purpose]."
+5. Follow skill instructions exactly
+
+## Rules
+
+- ALWAYS call skills via \`use_skill\` tool, never work from memory
+- If a skill contains a checklist \u2192 create EACH point as its own todo
+- Never rationalize that a skill is "not needed" or "overkill"
+- Answering without skill check = error`;
+
+// ../core/dist/generators/github-copilot-generator.js
+var GitHubCopilotGenerator = class {
+  agentTypes = [
+    "github-copilot",
+    "copilot-cli",
+    "copilot-coding-agent"
+  ];
+  async generate(config, options) {
+    const yaml = this.generateYamlFrontmatter(config);
+    const markdown = this.generateMarkdownContent();
+    return {
+      filePath: `${options.skillsDir}/.github/agents/skills-mcp.agent.md`,
+      content: `${yaml}
+
+${markdown}`,
+      format: "markdown"
+    };
+  }
+  supports(agentType) {
+    return this.agentTypes.includes(agentType);
+  }
+  getOutputPath(skillsDir) {
+    return `${skillsDir}/.github/agents/skills-mcp.agent.md`;
+  }
+  getMetadata() {
+    return {
+      name: "GitHub Copilot",
+      description: "Generates Markdown+YAML agent configs for GitHub Copilot CLI and coding agent",
+      agentTypes: this.agentTypes,
+      docsUrl: "https://docs.github.com/en/copilot/reference/custom-agents-configuration",
+      version: "1.0.0"
+    };
+  }
+  generateYamlFrontmatter(config) {
+    const tools = this.mapToolsToGitHubFormat(config.tools, config.mcp_servers);
+    const yamlObj = {
+      name: config.id,
+      description: config.description
+    };
+    if (tools.length > 0) {
+      yamlObj.tools = tools;
+    }
+    if (config.mcp_servers && Object.keys(config.mcp_servers).length > 0) {
+      yamlObj["mcp-servers"] = this.generateMcpServers(config.mcp_servers);
+    }
+    yamlObj["disable-model-invocation"] = false;
+    yamlObj["user-invocable"] = true;
+    let yaml = "---\n";
+    for (const [k, v] of Object.entries(yamlObj)) {
+      yaml += this.formatYamlEntry(k, v) + "\n";
+    }
+    yaml += "---";
+    return yaml;
+  }
+  generateMarkdownContent() {
+    return SKILLS_AGENT_DESCRIPTION_MARKDOWN;
+  }
+  generateMcpServers(servers) {
+    const result = {};
+    for (const [name, config] of Object.entries(servers)) {
+      const serverConfig = config;
+      const serverEntry = {};
+      if (serverConfig.type) {
+        serverEntry.type = serverConfig.type;
+      }
+      if (serverConfig.command) {
+        serverEntry.command = serverConfig.command;
+      }
+      if (serverConfig.args) {
+        serverEntry.args = serverConfig.args;
+      }
+      if (serverConfig.url) {
+        serverEntry.url = serverConfig.url;
+      }
+      if (serverConfig.headers) {
+        serverEntry.headers = serverConfig.headers;
+      }
+      if (serverConfig.env) {
+        serverEntry.env = serverConfig.env;
+      }
+      if (serverConfig.tools) {
+        serverEntry.tools = serverConfig.tools;
+      }
+      result[name] = serverEntry;
+    }
+    return result;
+  }
+  mapToolsToGitHubFormat(tools, servers) {
+    const result = [];
+    if (tools?.write)
+      result.push("edit");
+    if (tools?.read)
+      result.push("read");
+    if (tools?.bash)
+      result.push("execute");
+    if (tools?.use_skill)
+      result.push("use_skill");
+    if (servers) {
+      for (const [name, server] of Object.entries(servers)) {
+        const serverConfig = server;
+        if (serverConfig.tools && !serverConfig.tools.includes("*")) {
+          for (const tool of serverConfig.tools) {
+            result.push(`${name}/${tool}`);
+          }
+        } else {
+          result.push(`${name}/*`);
+        }
+      }
+    }
+    return result.length > 0 ? result : ["*"];
+  }
+  formatYamlEntry(key, value, indent = 0) {
+    const prefix = " ".repeat(indent);
+    if (Array.isArray(value)) {
+      return `${prefix}${key}:
+${value.map((v) => `${prefix}  - ${v}`).join("\n")}`;
+    }
+    if (typeof value === "object" && value !== null) {
+      const entries = Object.entries(value);
+      if (entries.length === 0)
+        return `${prefix}${key}: {}`;
+      let result = `${prefix}${key}:
+`;
+      for (const [k, v] of entries) {
+        const entry = this.formatYamlEntry(k, v, indent + 2);
+        result += entry + "\n";
+      }
+      return result.trimEnd();
+    }
+    if (typeof value === "boolean") {
+      return `${prefix}${key}: ${value}`;
+    }
+    return `${prefix}${key}: ${value}`;
+  }
+};
+
+// ../core/dist/generators/kiro-generator.js
+var KiroGenerator = class {
+  agentTypes = ["kiro", "kiro-cli"];
+  async generate(config, _options) {
+    const agentConfig = this.generateAgentConfig(config);
+    return {
+      filePath: `${_options.skillsDir}/.kiro/agents/skills-mcp.json`,
+      content: JSON.stringify(agentConfig, null, 2),
+      format: "json"
+    };
+  }
+  supports(agentType) {
+    return this.agentTypes.includes(agentType);
+  }
+  getOutputPath(skillsDir) {
+    return `${skillsDir}/.kiro/agents/skills-mcp.json`;
+  }
+  getMetadata() {
+    return {
+      name: "Kiro",
+      description: "Generates JSON agent configs for Kiro CLI",
+      agentTypes: this.agentTypes,
+      docsUrl: "https://kiro.dev/docs/cli/custom-agents/",
+      version: "1.0.0"
+    };
+  }
+  generateAgentConfig(config) {
+    const agentConfig = {
+      name: config.id,
+      prompt: SKILLS_AGENT_DESCRIPTION_MARKDOWN,
+      mcpServers: this.generateMcpServers(config.mcp_servers),
+      tools: this.generateTools(config),
+      allowedTools: this.generateAllowedTools(config)
+    };
+    return agentConfig;
+  }
+  generateMcpServers(servers) {
+    const result = {};
+    if (!servers)
+      return result;
+    for (const [name, config] of Object.entries(servers)) {
+      const serverConfig = config;
+      const serverEntry = {};
+      if (serverConfig.command) {
+        serverEntry.command = serverConfig.command;
+      }
+      if (serverConfig.args && Array.isArray(serverConfig.args)) {
+        serverEntry.args = serverConfig.args;
+      }
+      if (serverConfig.env) {
+        serverEntry.env = serverConfig.env;
+      }
+      result[name] = serverEntry;
+    }
+    return result;
+  }
+  generateTools(config) {
+    const tools = [
+      "execute_bash",
+      "fs_read",
+      "fs_write",
+      "report_issue",
+      "knowledge",
+      "thinking",
+      "use_aws"
+    ];
+    if (config.mcp_servers && Object.keys(config.mcp_servers).length > 0) {
+      for (const name of Object.keys(config.mcp_servers)) {
+        tools.push(`@${name}`);
+      }
+    }
+    return tools;
+  }
+  generateAllowedTools(config) {
+    const allowed = ["fs_read", "use_skill"];
+    if (config.mcp_servers) {
+      for (const [name, server] of Object.entries(config.mcp_servers)) {
+        if (server.tools && !server.tools.includes("*")) {
+          for (const tool of server.tools) {
+            allowed.push(`@${name}/${tool}`);
+          }
+        } else {
+          allowed.push(`@${name}/*`);
+        }
+      }
+    }
+    return allowed;
+  }
+};
+
+// ../core/dist/generators/opencode-generator.js
+var OpenCodeMcpGenerator = class {
+  agentTypes = ["opencode", "opencode-cli"];
+  async generate(config, options) {
+    const opencodeConfig = this.generateOpenCodeConfig(config);
+    return {
+      filePath: `${options.skillsDir}/opencode.json`,
+      content: JSON.stringify(opencodeConfig, null, 2),
+      format: "json"
+    };
+  }
+  supports(agentType) {
+    return this.agentTypes.includes(agentType);
+  }
+  getOutputPath(skillsDir) {
+    return `${skillsDir}/opencode.json`;
+  }
+  getMetadata() {
+    return {
+      name: "OpenCode MCP",
+      description: "Writes opencode.json with MCP server configurations for OpenCode",
+      agentTypes: this.agentTypes,
+      docsUrl: "https://opencode.ai/docs/mcp-servers/",
+      version: "1.0.0"
+    };
+  }
+  generateOpenCodeConfig(config) {
+    const opencodeConfig = {
+      $schema: "https://opencode.ai/config.json",
+      permission: {
+        skill: "deny"
+        // Disable native skill tool to avoid conflicts
+      },
+      mcp: {}
+    };
+    if (config.mcp_servers) {
+      const mcp = opencodeConfig.mcp;
+      for (const [name, serverConfig] of Object.entries(config.mcp_servers)) {
+        const entry = {
+          type: "local",
+          enabled: true,
+          environment: serverConfig.env || {}
+        };
+        if (serverConfig.command) {
+          entry.command = [serverConfig.command, ...serverConfig.args || []];
+        }
+        mcp[name] = entry;
+      }
+    }
+    return opencodeConfig;
+  }
+};
+var OpenCodeAgentGenerator = class {
+  agentTypes = ["opencode", "opencode-cli"];
+  async generate(config, options) {
+    const markdown = this.generateMarkdown(config);
+    return {
+      filePath: `${options.skillsDir}/.opencode/agents/skills-mcp.md`,
+      content: markdown,
+      format: "markdown"
+    };
+  }
+  supports(agentType) {
+    return this.agentTypes.includes(agentType);
+  }
+  getOutputPath(skillsDir) {
+    return `${skillsDir}/.opencode/agents/skills-mcp.md`;
+  }
+  getMetadata() {
+    return {
+      name: "OpenCode Agent",
+      description: "Generates Markdown agent configs for OpenCode",
+      agentTypes: this.agentTypes,
+      docsUrl: "https://opencode.ai/docs/agents/",
+      version: "1.0.0"
+    };
+  }
+  generateMarkdown(config) {
+    const frontmatter = this.generateFrontmatter(config);
+    const content = this.generateContent();
+    return `${frontmatter}
+
+${content}`;
+  }
+  generateFrontmatter(config) {
+    const permissions = this.mapPermissions(config.permissions);
+    const frontmatterObj = {
+      name: config.id,
+      description: config.description,
+      tools: this.mapTools(config.tools),
+      permission: permissions
+    };
+    if (config.mcp_servers && Object.keys(config.mcp_servers).length > 0) {
+      frontmatterObj.mcp = this.generateMcpServers(config.mcp_servers);
+    }
+    let yaml = "---\n";
+    for (const [key, value] of Object.entries(frontmatterObj)) {
+      yaml += this.formatYamlValue(key, value);
+    }
+    yaml += "---";
+    return yaml;
+  }
+  formatYamlValue(key, value, indent = 0) {
+    const prefix = " ".repeat(indent);
+    if (typeof value === "boolean" || typeof value === "number") {
+      return `${prefix}${key}: ${value}
+`;
+    }
+    if (Array.isArray(value)) {
+      let result = `${prefix}${key}:
+`;
+      for (const item of value) {
+        result += `${prefix}  - ${item}
+`;
+      }
+      return result;
+    }
+    if (typeof value === "object" && value !== null) {
+      let result = `${prefix}${key}:
+`;
+      for (const [k, v] of Object.entries(value)) {
+        result += this.formatYamlValue(k, v, indent + 2);
+      }
+      return result;
+    }
+    return `${prefix}${key}: ${value}
+`;
+  }
+  mapTools(tools) {
+    const mapped = {
+      read: true,
+      write: false,
+      edit: false,
+      bash: false,
+      use_skill: true
+    };
+    if (tools) {
+      Object.assign(mapped, tools);
+    }
+    return mapped;
+  }
+  mapPermissions(permissions) {
+    if (!permissions) {
+      return {
+        edit: "ask",
+        bash: "ask",
+        use_skill: "allow"
+      };
+    }
+    return permissions || {
+      edit: "ask",
+      bash: "ask",
+      use_skill: "allow"
+    };
+  }
+  generateMcpServers(servers) {
+    const result = {};
+    for (const [name, config] of Object.entries(servers)) {
+      const serverConfig = config;
+      const serverEntry = {};
+      if (serverConfig.type) {
+        serverEntry.type = serverConfig.type;
+      }
+      if (serverConfig.command) {
+        serverEntry.command = serverConfig.command;
+      }
+      if (serverConfig.args) {
+        serverEntry.args = serverConfig.args;
+      }
+      if (serverConfig.url) {
+        serverEntry.url = serverConfig.url;
+      }
+      if (serverConfig.env) {
+        serverEntry.env = serverConfig.env;
+      }
+      if (serverConfig.tools) {
+        serverEntry.tools = serverConfig.tools;
+      }
+      result[name] = serverEntry;
+    }
+    return result;
+  }
+  generateContent() {
+    return SKILLS_AGENT_DESCRIPTION_MARKDOWN;
+  }
+};
+
+// ../core/dist/generators/vscode-generator.js
+var VsCodeGenerator = class {
+  // github-copilot is the primary agent type; the others are aliases
+  // that also live inside VS Code and share the same MCP config file.
+  agentTypes = [
+    "github-copilot",
+    "copilot-cli",
+    "copilot-coding-agent"
+  ];
+  async generate(config, options) {
+    const vscodeConfig = this.generateVsCodeConfig(config);
+    return {
+      filePath: `${options.skillsDir}/.vscode/mcp.json`,
+      content: JSON.stringify(vscodeConfig, null, 2),
+      format: "json"
+    };
+  }
+  supports(agentType) {
+    return this.agentTypes.includes(agentType);
+  }
+  getOutputPath(skillsDir) {
+    return `${skillsDir}/.vscode/mcp.json`;
+  }
+  getMetadata() {
+    return {
+      name: "VS Code",
+      description: "Writes .vscode/mcp.json (servers format) so MCP servers are available to GitHub Copilot and other VS Code extensions",
+      agentTypes: this.agentTypes,
+      docsUrl: "https://code.visualstudio.com/docs/copilot/chat/mcp-servers",
+      version: "1.0.0"
+    };
+  }
+  generateVsCodeConfig(config) {
+    const servers = {};
+    if (config.mcp_servers) {
+      for (const [name, serverConfig] of Object.entries(config.mcp_servers)) {
+        const entry = {};
+        if (serverConfig.url) {
+          entry.type = serverConfig.type ?? "http";
+          entry.url = serverConfig.url;
+          if (serverConfig.headers)
+            entry.headers = serverConfig.headers;
+        } else if (serverConfig.command) {
+          entry.command = serverConfig.command;
+          if (serverConfig.args?.length)
+            entry.args = serverConfig.args;
+          if (serverConfig.env && Object.keys(serverConfig.env).length) {
+            entry.env = serverConfig.env;
+          }
+        }
+        servers[name] = entry;
+      }
+    }
+    return { servers };
+  }
+};
+
+// ../core/dist/parser.js
+import matter from "gray-matter";
+import { promises as fs } from "fs";
+var FIELD_MAP = {
+  name: "name",
+  description: "description",
+  license: "license",
+  compatibility: "compatibility",
+  metadata: "metadata",
+  "allowed-tools": "allowedTools",
+  "disable-model-invocation": "disableModelInvocation",
+  "user-invocable": "userInvocable",
+  "argument-hint": "argumentHint",
+  context: "context",
+  agent: "agent",
+  model: "model",
+  hooks: "hooks",
+  labels: "labels",
+  "requires-mcp-servers": "requiresMcpServers"
+};
+var REQUIRED_FIELDS = ["name", "description"];
+function createError(code, message, field) {
+  return {
+    success: false,
+    error: { code, message, ...field && { field } }
+  };
+}
+function mapFieldNames(data) {
+  const metadata = {};
+  for (const [key, value] of Object.entries(data)) {
+    const mappedKey = FIELD_MAP[key];
+    if (mappedKey !== void 0) {
+      if (mappedKey === "allowedTools" && typeof value === "string") {
+        metadata[mappedKey] = value.split(/\s+/).filter(Boolean);
+      } else {
+        metadata[mappedKey] = value;
+      }
+    }
+  }
+  return metadata;
+}
+function parseSkillContent(content) {
+  if (!content || content.trim().length === 0) {
+    return createError("EMPTY_FILE", "Skill file is empty");
+  }
+  let parsed;
+  try {
+    parsed = matter(content);
+  } catch (error) {
+    return createError("INVALID_YAML", `Failed to parse YAML frontmatter: ${error.message}`);
+  }
+  if (!parsed.data || Object.keys(parsed.data).length === 0) {
+    return createError("MISSING_FRONTMATTER", "Skill file must contain YAML frontmatter");
+  }
+  for (const field of REQUIRED_FIELDS) {
+    if (!(field in parsed.data)) {
+      return createError("MISSING_REQUIRED_FIELD", `required field '${field}' is missing from skill metadata`, field);
+    }
+  }
+  const metadata = mapFieldNames(parsed.data);
+  const skill = Object.freeze({
+    metadata: Object.freeze(metadata),
+    body: parsed.content
+  });
+  return {
+    success: true,
+    skill
+  };
+}
+async function parseSkill(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return parseSkillContent(content);
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code === "ENOENT") {
+      return createError("FILE_NOT_FOUND", `File not found: ${filePath}`);
+    }
+    if (nodeError.code === "EACCES" || nodeError.code === "EISDIR") {
+      return createError("FILE_READ_ERROR", `Failed to read file: ${nodeError.message}`);
+    }
+    return createError("FILE_READ_ERROR", `Failed to read file: ${nodeError.message}`);
+  }
+}
+
+// ../core/dist/validator.js
+import Ajv from "ajv";
+
+// ../core/dist/skill-frontmatter.schema.json
+var skill_frontmatter_schema_default = {
+  $schema: "https://json-schema.org/draft-07/schema#",
+  $id: "https://mrsimpson.github.io/agentskills-mcp/skill-frontmatter-schema.json",
+  title: "Agent Skill Frontmatter",
+  description: "YAML frontmatter schema for Agent Skills (SKILL.md files). See https://mrsimpson.github.io/agentskills-mcp/reference/skill-format for full documentation.",
+  type: "object",
+  required: ["name", "description"],
+  additionalProperties: false,
+  properties: {
+    name: {
+      type: "string",
+      description: "Unique skill identifier. Lowercase letters, numbers, and hyphens only. No leading/trailing/consecutive hyphens.",
+      minLength: 1,
+      maxLength: 64,
+      allOf: [
+        { pattern: "^[a-z0-9]([a-z0-9-]*[a-z0-9])?$" },
+        { not: { pattern: "--" } }
+      ]
+    },
+    description: {
+      type: "string",
+      description: "Short summary of the skill shown in tool descriptions.",
+      minLength: 1,
+      maxLength: 1024
+    },
+    license: {
+      type: "string",
+      description: "SPDX license identifier (e.g. MIT, Apache-2.0). Recommended for published skills."
+    },
+    compatibility: {
+      type: "string",
+      description: "Agent compatibility string.",
+      maxLength: 500
+    },
+    metadata: {
+      type: "object",
+      description: "Arbitrary key-value metadata.",
+      additionalProperties: true
+    },
+    "allowed-tools": {
+      type: "string",
+      description: "Space-delimited list of tools this skill is permitted to use. MCP server tools use the format '@server-name/tool-name'. When specified, only these tools are whitelisted in the generated agent config instead of allowing all tools from each MCP server."
+    },
+    "disable-model-invocation": {
+      type: "boolean",
+      description: "If true, the skill is excluded from the use_skill tool enum and cannot be invoked via MCP."
+    },
+    "user-invocable": {
+      type: "boolean",
+      description: "If true, the skill is designed for direct user invocation (e.g. via /skill-name)."
+    },
+    "argument-hint": {
+      type: "string",
+      description: 'Hint shown to users about expected arguments, e.g. "<pr-url>" or "<target> [options]".'
+    },
+    context: {
+      type: "string",
+      description: "Execution context hint for the agent."
+    },
+    agent: {
+      type: "string",
+      description: "Target agent identifier this skill is optimized for."
+    },
+    model: {
+      type: "string",
+      description: "Preferred model for executing this skill."
+    },
+    hooks: {
+      type: "object",
+      description: "Lifecycle hook definitions keyed by hook name.",
+      additionalProperties: {
+        type: "string"
+      }
+    },
+    labels: {
+      type: "array",
+      description: "Optional labels/tags for categorizing skills. Used with the SKILL_LABELS environment variable to filter which skills are loaded by the MCP server.",
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 64,
+        pattern: "^[a-z0-9]([a-z0-9-]*[a-z0-9])?$"
+      },
+      uniqueItems: true
+    },
+    "requires-mcp-servers": {
+      type: "array",
+      description: "MCP servers that must be configured for this skill to work. Used by 'agentskills install --agent' for validation and auto-configuration.",
+      items: {
+        $ref: "#/$defs/McpServerDependency"
+      }
+    }
+  },
+  $defs: {
+    McpServerDependency: {
+      type: "object",
+      description: "An MCP server that this skill depends on.",
+      required: ["name", "description", "command"],
+      additionalProperties: false,
+      properties: {
+        name: {
+          type: "string",
+          description: "Server identifier. Lowercase letters, numbers, and hyphens. Must start and end with alphanumeric.",
+          allOf: [
+            { pattern: "^[a-z0-9][a-z0-9-]*[a-z0-9]$" },
+            { not: { pattern: "--" } }
+          ]
+        },
+        package: {
+          type: "string",
+          description: 'npm package name used for auto-installation (e.g. "@modelcontextprotocol/server-filesystem").'
+        },
+        description: {
+          type: "string",
+          description: "Why this MCP server is needed by the skill."
+        },
+        command: {
+          type: "string",
+          description: 'Executable to run (e.g. "npx", "node", "/usr/local/bin/my-server").'
+        },
+        args: {
+          type: "array",
+          description: "Arguments passed to the command. May contain {{PARAM_NAME}} placeholders resolved at install time.",
+          items: {
+            type: "string"
+          }
+        },
+        env: {
+          type: "object",
+          description: "Environment variables to set when running the server.",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory for the server process."
+        },
+        parameters: {
+          type: "object",
+          description: "Parameter definitions for {{PARAM}} placeholders used in args or env.",
+          propertyNames: {
+            allOf: [
+              { pattern: "^[a-z0-9][a-z0-9-]*[a-z0-9]$" },
+              { not: { pattern: "--" } }
+            ]
+          },
+          additionalProperties: {
+            $ref: "#/$defs/McpParameterSpec"
+          }
+        }
+      }
+    },
+    McpParameterSpec: {
+      type: "object",
+      description: "Definition of a parameter placeholder used in an MCP server dependency.",
+      required: ["description", "required"],
+      additionalProperties: false,
+      properties: {
+        description: {
+          type: "string",
+          description: "What this parameter configures."
+        },
+        required: {
+          type: "boolean",
+          description: "Whether the user must supply this parameter."
+        },
+        sensitive: {
+          type: "boolean",
+          description: "If true, treat as a secret or credential (mask in output, do not log)."
+        },
+        default: {
+          type: "string",
+          description: "Default value used when the parameter is not supplied."
+        },
+        example: {
+          type: "string",
+          description: "Example value shown to guide users."
+        }
+      }
+    }
+  }
+};
+
+// ../core/dist/validator.js
+var ajv = new Ajv({ validateSchema: false });
+var validateFrontmatter = ajv.compile(skill_frontmatter_schema_default);
+var CAMEL_TO_KEBAB = {
+  allowedTools: "allowed-tools",
+  disableModelInvocation: "disable-model-invocation",
+  userInvocable: "user-invocable",
+  argumentHint: "argument-hint",
+  requiresMcpServers: "requires-mcp-servers"
+};
+function toRawYamlKeys(metadata) {
+  const result = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    const yamlKey = CAMEL_TO_KEBAB[key] ?? key;
+    if (key === "allowedTools" && Array.isArray(value)) {
+      result[yamlKey] = value.join(" ");
+    } else {
+      result[yamlKey] = value;
+    }
+  }
+  return result;
+}
+function validateSkill(skill) {
+  const rawData = toRawYamlKeys(skill.metadata);
+  const valid = validateFrontmatter(rawData);
+  return {
+    valid,
+    errors: valid ? [] : (validateFrontmatter.errors ?? []).map((e) => ({
+      message: e.message ?? "Validation error"
+    })),
+    warnings: []
+  };
+}
+
+// ../core/dist/registry.js
+import { promises as fs2 } from "fs";
+import { join, basename } from "path";
+function makeInvalidSkillPlaceholder(dirName, sourcePath, errors) {
+  return Object.freeze({
+    metadata: Object.freeze({
+      name: dirName,
+      description: "[INVALID] This skill failed validation and cannot be applied"
+    }),
+    body: `This skill is invalid and cannot be applied.
+
+Validation errors:
+${errors}
+
+Please inform the user that the skill at \`${sourcePath}\` is invalid and needs to be fixed before it can be used.`
+  });
+}
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  skillsDir = "";
+  skillsDirs = [];
+  lastLoaded;
+  /**
+   * Load skills from multiple directories with optional filtering
+   *
+   * Loads skills from each directory in order, with later directories
+   * overriding skills from earlier ones. Supports optional filtering
+   * to only include skills specified in an allow list.
+   *
+   * Expected structure: <skillsDir>/<skill-name>/SKILL.md (exactly 2 levels deep)
+   * - Throws on first required directory error (fail fast)
+   * - Skips non-existent optional directories (2nd onwards)
+   * - Ignores hidden directories (.git/, etc.)
+   * - Ignores non-directory files
+   * - Validates directory name matches skill name in SKILL.md
+   *
+   * @param skillsDirs - Array of directories containing skill subdirectories
+   * @param allowedSkills - Optional set of skill names to include. If provided, only these skills are loaded.
+   * @param requiredLabels - Optional set of labels. If provided, only skills that have at least one matching label are loaded.
+   * @returns Load result with count, directories, and timestamp
+   * @throws Error if first directory is invalid or any skill is invalid
+   */
+  async loadSkillsFromMultiple(skillsDirs, allowedSkills, requiredLabels) {
+    this.skills.clear();
+    this.skillsDir = "";
+    this.skillsDirs = [];
+    let totalLoaded = 0;
+    for (let i = 0; i < skillsDirs.length; i++) {
+      const skillsDir = skillsDirs[i];
+      const isRequired = i === 0;
+      totalLoaded += await this.loadSkillsFromDirectory(skillsDir, allowedSkills, isRequired, requiredLabels);
+    }
+    this.skillsDirs = skillsDirs;
+    this.skillsDir = skillsDirs[0] || "";
+    this.lastLoaded = /* @__PURE__ */ new Date();
+    return {
+      loaded: totalLoaded,
+      skillsDir: this.skillsDirs.join(":"),
+      timestamp: this.lastLoaded
+    };
+  }
+  /**
+   * Load skills from a single directory (internal helper)
+   *
+   * @param skillsDir - Directory containing skill subdirectories
+   * @param allowedSkills - Optional set of skill names to include
+   * @param isRequired - Whether this directory is required (first directory always is)
+   * @param requiredLabels - Optional set of labels. If provided, only skills with at least one matching label are loaded.
+   * @returns Number of skills loaded from this directory
+   * @throws Error if directory is invalid and required
+   */
+  async loadSkillsFromDirectory(skillsDir, allowedSkills, isRequired = true, requiredLabels) {
+    let stat;
+    try {
+      stat = await fs2.stat(skillsDir);
+    } catch {
+      if (isRequired) {
+        throw new Error(`Skills directory does not exist: ${skillsDir}`);
+      }
+      return 0;
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`Skills directory is not a directory: ${skillsDir}`);
+    }
+    const entries = await fs2.readdir(skillsDir, { withFileTypes: true });
+    let loadedCount = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      if (allowedSkills && !allowedSkills.has(entry.name)) {
+        continue;
+      }
+      const skillDir = join(skillsDir, entry.name);
+      const skillPath = join(skillDir, "SKILL.md");
+      let skillStat;
+      try {
+        skillStat = await fs2.stat(skillPath);
+      } catch {
+        throw new Error(`Missing SKILL.md in: ${skillDir}`);
+      }
+      if (!skillStat.isFile()) {
+        throw new Error(`Missing SKILL.md in: ${skillDir}`);
+      }
+      const parseResult = await parseSkill(skillPath);
+      if (!parseResult.success) {
+        throw new Error(`Failed to parse SKILL.md in ${skillDir}: ${parseResult.error.message}`);
+      }
+      const { skill } = parseResult;
+      const validationResult = validateSkill(skill);
+      if (!validationResult.valid) {
+        const errorMessages = validationResult.errors.map((e) => e.message).join(", ");
+        const dirName2 = basename(skillDir);
+        const placeholder = makeInvalidSkillPlaceholder(dirName2, skillPath, errorMessages);
+        this.skills.set(dirName2, { skill: placeholder, sourcePath: skillPath });
+        loadedCount++;
+        continue;
+      }
+      const dirName = basename(skillDir);
+      if (skill.metadata.name !== dirName) {
+        throw new Error(`Directory name '${dirName}' does not match skill name '${skill.metadata.name}' in ${skillPath}`);
+      }
+      if (requiredLabels && requiredLabels.size > 0) {
+        const skillLabels = skill.metadata.labels;
+        if (!skillLabels || !skillLabels.some((label) => requiredLabels.has(label))) {
+          continue;
+        }
+      }
+      this.skills.set(skill.metadata.name, { skill, sourcePath: skillPath });
+      loadedCount++;
+    }
+    return loadedCount;
+  }
+  /**
+   * Load skills from a single directory with strict error handling
+   *
+   * Expected structure: <skillsDir>/<skill-name>/SKILL.md (exactly 2 levels deep)
+   * - Throws on any error (fail fast)
+   * - Ignores hidden directories (.git/, etc.)
+   * - Ignores non-directory files
+   * - Validates directory name matches skill name in SKILL.md
+   *
+   * @param skillsDir - Directory containing skill subdirectories
+   * @returns Load result with count, directory, and timestamp
+   * @throws Error if directory doesn't exist, isn't a directory, or any skill is invalid
+   */
+  async loadSkills(skillsDir) {
+    this.skills.clear();
+    this.skillsDir = "";
+    this.skillsDirs = [];
+    let stat;
+    try {
+      stat = await fs2.stat(skillsDir);
+    } catch {
+      throw new Error(`Skills directory does not exist: ${skillsDir}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`Skills directory is not a directory: ${skillsDir}`);
+    }
+    const entries = await fs2.readdir(skillsDir, { withFileTypes: true });
+    let loadedCount = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const skillDir = join(skillsDir, entry.name);
+      const skillPath = join(skillDir, "SKILL.md");
+      let skillStat;
+      try {
+        skillStat = await fs2.stat(skillPath);
+      } catch {
+        throw new Error(`Missing SKILL.md in: ${skillDir}`);
+      }
+      if (!skillStat.isFile()) {
+        throw new Error(`Missing SKILL.md in: ${skillDir}`);
+      }
+      const parseResult = await parseSkill(skillPath);
+      if (!parseResult.success) {
+        throw new Error(`Failed to parse SKILL.md in ${skillDir}: ${parseResult.error.message}`);
+      }
+      const { skill } = parseResult;
+      const validationResult = validateSkill(skill);
+      if (!validationResult.valid) {
+        const errorMessages = validationResult.errors.map((e) => e.message).join(", ");
+        const dirName2 = basename(skillDir);
+        const placeholder = makeInvalidSkillPlaceholder(dirName2, skillPath, errorMessages);
+        this.skills.set(dirName2, { skill: placeholder, sourcePath: skillPath });
+        loadedCount++;
+        continue;
+      }
+      const dirName = basename(skillDir);
+      if (skill.metadata.name !== dirName) {
+        throw new Error(`Directory name '${dirName}' does not match skill name '${skill.metadata.name}' in ${skillPath}`);
+      }
+      this.skills.set(skill.metadata.name, { skill, sourcePath: skillPath });
+      loadedCount++;
+    }
+    this.skillsDir = skillsDir;
+    this.skillsDirs = [skillsDir];
+    this.lastLoaded = /* @__PURE__ */ new Date();
+    return {
+      loaded: loadedCount,
+      skillsDir,
+      timestamp: this.lastLoaded
+    };
+  }
+  /**
+   * Get a skill by name
+   *
+   * @param name - The skill name
+   * @returns The skill or undefined if not found
+   */
+  getSkill(name) {
+    const entry = this.skills.get(name);
+    if (!entry) {
+      return void 0;
+    }
+    return {
+      metadata: { ...entry.skill.metadata },
+      body: entry.skill.body
+    };
+  }
+  /**
+   * Get all loaded skills
+   *
+   * @returns Array of all skills
+   */
+  getAllSkills() {
+    return Array.from(this.skills.values()).map((entry) => ({
+      metadata: { ...entry.skill.metadata },
+      body: entry.skill.body
+    }));
+  }
+  /**
+   * Get skill metadata without body content
+   *
+   * @param name - The skill name
+   * @returns The skill metadata or undefined if not found
+   */
+  getSkillMetadata(name) {
+    const entry = this.skills.get(name);
+    if (!entry) {
+      return void 0;
+    }
+    return { ...entry.skill.metadata };
+  }
+  /**
+   * Get all skill metadata without body content
+   *
+   * @returns Array of all skill metadata
+   */
+  getAllMetadata() {
+    return Array.from(this.skills.values()).map((entry) => ({
+      ...entry.skill.metadata
+    }));
+  }
+  /**
+   * Get current registry state
+   *
+   * @returns Current state with counts and source info
+   */
+  getState() {
+    return {
+      skillCount: this.skills.size,
+      skillsDir: this.skillsDir,
+      lastLoaded: this.lastLoaded
+    };
+  }
+  /**
+   * Get the skills directory (base path for resolving relative references)
+   *
+   * @returns Absolute path to the skills directory, or empty string if no skills loaded
+   */
+  getSkillsDirectory() {
+    return this.skillsDir;
+  }
+};
+
+// ../core/dist/package-config.js
+import { promises as fs3 } from "fs";
+import { join as join2 } from "path";
+var PackageConfigManager = class {
+  projectRoot;
+  packageJsonPath;
+  constructor(projectRoot) {
+    if (!projectRoot) {
+      throw new Error("Project root directory is required");
+    }
+    this.projectRoot = projectRoot;
+    this.packageJsonPath = join2(projectRoot, "package.json");
+  }
+  /**
+   * Get default configuration with empty skills and standard defaults
+   */
+  getDefaultConfig() {
+    return {
+      skills: {},
+      config: {
+        skillsDirectory: ".agentskills/skills",
+        autoDiscover: [".claude/skills"],
+        maxSkillSize: 5e3,
+        logLevel: "info"
+      },
+      source: {
+        type: "defaults"
+      }
+    };
+  }
+  /**
+   * Load configuration from package.json
+   * Returns defaults if package.json doesn't exist
+   */
+  async loadConfig() {
+    try {
+      const content = await fs3.readFile(this.packageJsonPath, "utf-8");
+      let packageJson;
+      try {
+        packageJson = JSON.parse(content);
+      } catch (error) {
+        throw new Error(`Failed to parse package.json: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      const skills = this.validateAndExtractSkills(packageJson);
+      const config = this.validateAndExtractConfig(packageJson);
+      return {
+        skills,
+        config,
+        source: {
+          type: "file",
+          path: this.packageJsonPath
+        }
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return this.getDefaultConfig();
+      }
+      if (error.code === "EACCES") {
+        throw new Error(`Permission denied reading package.json at ${this.packageJsonPath}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate and extract skills from package.json
+   */
+  validateAndExtractSkills(packageJson) {
+    if (!packageJson.agentskills) {
+      return {};
+    }
+    const agentskills = packageJson.agentskills;
+    if (typeof agentskills !== "object" || agentskills === null || Array.isArray(agentskills)) {
+      throw new Error("agentskills must be an object");
+    }
+    for (const value of Object.values(agentskills)) {
+      if (typeof value !== "string") {
+        throw new Error("agentskills values must be strings");
+      }
+    }
+    return agentskills;
+  }
+  /**
+   * Validate and extract config from package.json
+   */
+  validateAndExtractConfig(packageJson) {
+    const defaultConfig = this.getDefaultConfig().config;
+    if (!packageJson.agentskillsConfig) {
+      return defaultConfig;
+    }
+    const agentskillsConfig = packageJson.agentskillsConfig;
+    if (typeof agentskillsConfig !== "object" || agentskillsConfig === null || Array.isArray(agentskillsConfig)) {
+      throw new Error("agentskillsConfig must be an object");
+    }
+    const configObj = agentskillsConfig;
+    const config = { ...defaultConfig };
+    if (configObj.skillsDirectory !== void 0) {
+      if (typeof configObj.skillsDirectory !== "string") {
+        throw new Error("skillsDirectory must be a string");
+      }
+      if (configObj.skillsDirectory === "") {
+        throw new Error("skillsDirectory cannot be empty");
+      }
+      config.skillsDirectory = configObj.skillsDirectory;
+    }
+    if (configObj.autoDiscover !== void 0) {
+      if (!Array.isArray(configObj.autoDiscover)) {
+        throw new Error("autoDiscover must be an array");
+      }
+      for (const item of configObj.autoDiscover) {
+        if (typeof item !== "string") {
+          throw new Error("autoDiscover must contain only strings");
+        }
+      }
+      config.autoDiscover = configObj.autoDiscover;
+    }
+    if (configObj.maxSkillSize !== void 0) {
+      if (typeof configObj.maxSkillSize !== "number") {
+        throw new Error("maxSkillSize must be a number");
+      }
+      if (configObj.maxSkillSize <= 0) {
+        throw new Error("maxSkillSize must be a positive number");
+      }
+      config.maxSkillSize = configObj.maxSkillSize;
+    }
+    if (configObj.logLevel !== void 0) {
+      if (typeof configObj.logLevel !== "string") {
+        throw new Error("logLevel must be a string");
+      }
+      const validLogLevels = ["error", "warn", "info", "debug"];
+      if (!validLogLevels.includes(configObj.logLevel)) {
+        throw new Error(`Invalid logLevel '${configObj.logLevel}'. Must be one of: error, warn, info, debug`);
+      }
+      config.logLevel = configObj.logLevel;
+    }
+    return config;
+  }
+  /**
+   * Save skills to package.json
+   * Creates package.json if it doesn't exist
+   * Preserves other fields
+   */
+  async saveSkills(skills) {
+    let packageJson;
+    try {
+      const content = await fs3.readFile(this.packageJsonPath, "utf-8");
+      packageJson = JSON.parse(content);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        packageJson = {
+          name: "agentskills-project"
+        };
+      } else {
+        throw error;
+      }
+    }
+    packageJson.agentskills = skills;
+    await fs3.writeFile(this.packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
+  }
+  /**
+   * Add a single skill to package.json
+   * Updates existing skill if name already exists
+   */
+  async addSkill(name, spec) {
+    if (!name) {
+      throw new Error("Skill name cannot be empty");
+    }
+    if (!spec) {
+      throw new Error("Skill spec cannot be empty");
+    }
+    let packageJson;
+    try {
+      const content = await fs3.readFile(this.packageJsonPath, "utf-8");
+      packageJson = JSON.parse(content);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        packageJson = {
+          name: "agentskills-project"
+        };
+      } else {
+        throw error;
+      }
+    }
+    if (!packageJson.agentskills) {
+      packageJson.agentskills = {};
+    }
+    const agentskills = packageJson.agentskills;
+    agentskills[name] = spec;
+    await fs3.writeFile(this.packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
+  }
+  /**
+   * Remove a skill from package.json
+   * Does not error if skill doesn't exist or file doesn't exist
+   */
+  async removeSkill(name) {
+    if (!name) {
+      throw new Error("Skill name cannot be empty");
+    }
+    try {
+      const content = await fs3.readFile(this.packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      if (!packageJson.agentskills) {
+        return;
+      }
+      delete packageJson.agentskills[name];
+      await fs3.writeFile(this.packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  }
+};
+
+// ../core/dist/skills-lock.js
+import { promises as fs4 } from "fs";
+import { join as join3 } from "path";
+async function loadSkillsLock(lockFilePath) {
+  try {
+    const content = await fs4.readFile(lockFilePath, "utf-8");
+    const lock = JSON.parse(content);
+    return lock;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function getAllowedSkills(lockFilePath) {
+  const lock = await loadSkillsLock(lockFilePath);
+  if (!lock) {
+    return void 0;
+  }
+  return new Set(Object.keys(lock.skills));
+}
+async function getAllowedSkillsFromProject(projectDir) {
+  const lockFilePath = join3(projectDir, "skills-lock.json");
+  return getAllowedSkills(lockFilePath);
+}
+async function getAllowedSkillsFromAgentskills(projectDir) {
+  const lockFilePath = join3(projectDir, "skills-lock.json");
+  return getAllowedSkills(lockFilePath);
+}
+
+// ../core/dist/mcp-config-adapters.js
+var StandardMcpConfigAdapter = class {
+  toStandard(clientConfig) {
+    const config = clientConfig;
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    return config;
+  }
+  toClient(mcpConfig) {
+    return mcpConfig;
+  }
+};
+var OpenCodeConfigAdapter = class {
+  toStandard(clientConfig) {
+    const config = clientConfig;
+    const mcpServers = {};
+    if (config.mcp) {
+      for (const [name, serverConfig] of Object.entries(config.mcp)) {
+        const server = serverConfig;
+        if (server.type === "local" && server.command) {
+          const [command, ...args] = server.command;
+          mcpServers[name] = {
+            command,
+            args,
+            env: server.environment || {}
+          };
+        }
+      }
+    }
+    return { mcpServers };
+  }
+  toClient(mcpConfig, existingConfig) {
+    const openCodeConfig = existingConfig || {
+      $schema: "https://opencode.ai/config.json"
+    };
+    openCodeConfig.permission = {
+      ...openCodeConfig.permission || {},
+      skill: "deny"
+    };
+    openCodeConfig.mcp = {};
+    for (const [name, serverConfig] of Object.entries(mcpConfig.mcpServers)) {
+      openCodeConfig.mcp[name] = {
+        type: "local",
+        command: [serverConfig.command, ...serverConfig.args || []],
+        enabled: true,
+        environment: serverConfig.env || {}
+      };
+    }
+    delete openCodeConfig.mcpServers;
+    return openCodeConfig;
+  }
+};
+var VsCodeConfigAdapter = class {
+  toStandard(clientConfig) {
+    const config = clientConfig;
+    const mcpServers = config.servers || {};
+    return { mcpServers };
+  }
+  toClient(mcpConfig, existingConfig) {
+    const vsCodeConfig = existingConfig || {
+      $schema: "https://opencode.ai/config.json"
+    };
+    return {
+      ...vsCodeConfig,
+      servers: mcpConfig.mcpServers
+    };
+  }
+};
+var McpConfigAdapterRegistry = class {
+  static adapters = /* @__PURE__ */ new Map();
+  static standardAdapter = new StandardMcpConfigAdapter();
+  /**
+   * Initialize the registry with default adapters
+   */
+  static initialize() {
+    this.register("opencode", new OpenCodeConfigAdapter());
+    this.register("github-copilot", new VsCodeConfigAdapter());
+  }
+  /**
+   * Register a custom adapter for a client type
+   */
+  static register(clientType, adapter) {
+    this.adapters.set(clientType, adapter);
+  }
+  /**
+   * Get the adapter for a client type
+   * Returns standard adapter if no custom adapter is registered
+   */
+  static getAdapter(clientType) {
+    return this.adapters.get(clientType) || this.standardAdapter;
+  }
+  /**
+   * Check if a client has a custom adapter
+   */
+  static hasCustomAdapter(clientType) {
+    return this.adapters.has(clientType);
+  }
+};
+McpConfigAdapterRegistry.initialize();
+
+export {
+  __commonJS,
+  __toESM,
+  ConfigGeneratorRegistry,
+  GitHubCopilotGenerator,
+  KiroGenerator,
+  OpenCodeMcpGenerator,
+  OpenCodeAgentGenerator,
+  VsCodeGenerator,
+  parseSkillContent,
+  parseSkill,
+  validateSkill,
+  SkillRegistry,
+  PackageConfigManager,
+  loadSkillsLock,
+  getAllowedSkills,
+  getAllowedSkillsFromProject,
+  getAllowedSkillsFromAgentskills,
+  StandardMcpConfigAdapter,
+  OpenCodeConfigAdapter,
+  VsCodeConfigAdapter,
+  McpConfigAdapterRegistry
+};