@codemcp/skills 2.1.0 → 2.2.0

package/dist/chunk-OAWSLH2D.js

@@ -1,1294 +0,0 @@
-// ../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/skills-lock.js
-import { promises as fs3 } from "fs";
-import { join as join2 } from "path";
-async function loadSkillsLock(lockFilePath) {
-  try {
-    const content = await fs3.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 = join2(projectDir, "skills-lock.json");
-  return getAllowedSkills(lockFilePath);
-}
-async function getAllowedSkillsFromAgentskills(projectDir) {
-  const lockFilePath = join2(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 {
-  ConfigGeneratorRegistry,
-  GitHubCopilotGenerator,
-  KiroGenerator,
-  OpenCodeMcpGenerator,
-  OpenCodeAgentGenerator,
-  VsCodeGenerator,
-  parseSkillContent,
-  parseSkill,
-  validateSkill,
-  SkillRegistry,
-  loadSkillsLock,
-  getAllowedSkills,
-  getAllowedSkillsFromProject,
-  getAllowedSkillsFromAgentskills,
-  StandardMcpConfigAdapter,
-  OpenCodeConfigAdapter,
-  VsCodeConfigAdapter,
-  McpConfigAdapterRegistry
-};