prpm 1.1.20 → 1.1.21

package/dist/index.js

@@ -101,7 +101,8 @@ function addToLockfile(lockfile, packageId, packageInfo) {
     installedPath: packageInfo.installedPath,
     fromCollection: packageInfo.fromCollection,
     hookMetadata: packageInfo.hookMetadata,
-    progressiveDisclosure: packageInfo.progressiveDisclosure
+    progressiveDisclosure: packageInfo.progressiveDisclosure,
+    pluginMetadata: packageInfo.pluginMetadata
   };
   lockfile.generated = (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -518,6 +519,223 @@ var init_canonical = __esm({
   }
 });
 
+// ../converters/dist/cursor-hooks-constants.js
+function isValidCursorHookType(hookType) {
+  return VALID_CURSOR_HOOK_TYPES.includes(hookType);
+}
+function isValidHookMappingStrategy(strategy) {
+  return VALID_HOOK_MAPPING_STRATEGIES.includes(strategy);
+}
+function getScriptExtension(language) {
+  return SCRIPT_LANGUAGE_EXTENSIONS[language] || "sh";
+}
+var VALID_CURSOR_HOOK_TYPES, VALID_HOOK_MAPPING_STRATEGIES, SCRIPT_LANGUAGE_EXTENSIONS;
+var init_cursor_hooks_constants = __esm({
+  "../converters/dist/cursor-hooks-constants.js"() {
+    "use strict";
+    init_cjs_shims();
+    VALID_CURSOR_HOOK_TYPES = [
+      "beforeShellExecution",
+      "afterShellExecution",
+      "beforeMCPExecution",
+      "afterMCPExecution",
+      "beforeReadFile",
+      "afterFileEdit",
+      "beforeSubmitPrompt",
+      "stop",
+      "afterAgentResponse",
+      "afterAgentThought",
+      "beforeTabFileRead",
+      "afterTabFileEdit"
+    ];
+    VALID_HOOK_MAPPING_STRATEGIES = ["auto", "strict", "skip"];
+    SCRIPT_LANGUAGE_EXTENSIONS = {
+      bash: "sh",
+      python: "py",
+      javascript: "js",
+      typescript: "js",
+      // TypeScript compiles to JS
+      binary: "bin"
+    };
+  }
+});
+
+// ../converters/dist/hook-mappings.js
+function getQualityPenalty(quality) {
+  switch (quality) {
+    case "direct":
+      return 0;
+    case "semantic":
+      return 5;
+    case "none":
+      return 30;
+  }
+}
+function getHookMapping(sourceFormat, targetFormat, sourceHookType) {
+  const key = `${sourceFormat.toUpperCase()}_TO_${targetFormat.toUpperCase()}`;
+  switch (key) {
+    case "CLAUDE_TO_CURSOR":
+      return CLAUDE_TO_CURSOR[sourceHookType] || null;
+    case "CURSOR_TO_CLAUDE":
+      return CURSOR_TO_CLAUDE[sourceHookType] || null;
+    case "KIRO_TO_CURSOR":
+      return KIRO_TO_CURSOR[sourceHookType] || null;
+    case "CURSOR_TO_KIRO":
+      return CURSOR_TO_KIRO[sourceHookType] || null;
+    case "CLAUDE_TO_KIRO":
+      return CLAUDE_TO_KIRO[sourceHookType] || null;
+    case "KIRO_TO_CLAUDE":
+      return KIRO_TO_CLAUDE[sourceHookType] || null;
+    default:
+      return null;
+  }
+}
+function mapHook(sourceFormat, targetFormat, sourceHookType, strategy) {
+  if (sourceFormat === targetFormat) {
+    return {
+      mapped: true,
+      targetHookType: sourceHookType,
+      quality: "direct",
+      qualityPenalty: 0
+    };
+  }
+  if (strategy === "skip") {
+    return {
+      mapped: false,
+      targetHookType: null,
+      quality: "none",
+      warning: "Hook conversion skipped (--hook-mapping skip)",
+      qualityPenalty: 0
+    };
+  }
+  const mapping = getHookMapping(sourceFormat, targetFormat, sourceHookType);
+  if (!mapping) {
+    return {
+      mapped: false,
+      targetHookType: null,
+      quality: "none",
+      warning: `No mapping defined for ${sourceFormat} hook "${sourceHookType}" to ${targetFormat}`,
+      qualityPenalty: 30
+    };
+  }
+  if (strategy === "strict" && mapping.quality !== "direct") {
+    return {
+      mapped: false,
+      targetHookType: null,
+      quality: mapping.quality,
+      warning: `Hook "${sourceHookType}" not converted (strict mode requires direct match, found ${mapping.quality} match)`,
+      qualityPenalty: 30
+    };
+  }
+  if (!mapping.target) {
+    return {
+      mapped: false,
+      targetHookType: null,
+      quality: mapping.quality,
+      warning: `${sourceFormat} hook "${sourceHookType}" has no ${targetFormat} equivalent. ${mapping.notes}`,
+      qualityPenalty: getQualityPenalty(mapping.quality)
+    };
+  }
+  return {
+    mapped: true,
+    targetHookType: mapping.target,
+    quality: mapping.quality,
+    warning: mapping.quality === "semantic" ? `${sourceFormat} hook "${sourceHookType}" mapped to ${targetFormat} hook "${mapping.target}" (semantic match). ${mapping.notes}` : void 0,
+    qualityPenalty: getQualityPenalty(mapping.quality)
+  };
+}
+function mapHooks(sourceFormat, targetFormat, sourceHookTypes, strategy = "auto") {
+  const results = /* @__PURE__ */ new Map();
+  let totalQualityPenalty = 0;
+  const warnings = [];
+  for (const hookType of sourceHookTypes) {
+    const result = mapHook(sourceFormat, targetFormat, hookType, strategy);
+    results.set(hookType, result);
+    totalQualityPenalty += result.qualityPenalty;
+    if (result.warning) {
+      warnings.push(result.warning);
+    }
+  }
+  return { results, totalQualityPenalty, warnings };
+}
+var CLAUDE_TO_CURSOR, CURSOR_TO_CLAUDE, KIRO_TO_CURSOR, CURSOR_TO_KIRO, CLAUDE_TO_KIRO, KIRO_TO_CLAUDE;
+var init_hook_mappings = __esm({
+  "../converters/dist/hook-mappings.js"() {
+    "use strict";
+    init_cjs_shims();
+    CLAUDE_TO_CURSOR = {
+      "session-start": {
+        target: null,
+        quality: "none",
+        notes: "Cursor has no session start hook - no equivalent lifecycle event"
+      },
+      "user-prompt-submit": {
+        target: "beforeSubmitPrompt",
+        quality: "direct",
+        notes: "Direct semantic match - both run before prompt submission"
+      },
+      "tool-call": {
+        target: "beforeMCPExecution",
+        quality: "semantic",
+        notes: "Semantic match - Claude tool-call maps to Cursor MCP execution"
+      },
+      "assistant-response": {
+        target: "afterAgentResponse",
+        quality: "direct",
+        notes: "Direct semantic match - both run after agent generates response"
+      }
+    };
+    CURSOR_TO_CLAUDE = {
+      "beforeShellExecution": { target: null, quality: "none", notes: "Claude has no shell execution hooks" },
+      "afterShellExecution": { target: null, quality: "none", notes: "Claude has no shell execution hooks" },
+      "beforeMCPExecution": { target: "tool-call", quality: "semantic", notes: "Maps to Claude tool-call event" },
+      "afterMCPExecution": { target: null, quality: "none", notes: "Claude has no post-tool hook" },
+      "beforeReadFile": { target: null, quality: "none", notes: "Claude has no file read hooks" },
+      "afterFileEdit": { target: null, quality: "none", notes: "Claude has no file edit hooks" },
+      "beforeSubmitPrompt": { target: "user-prompt-submit", quality: "direct", notes: "Direct semantic match" },
+      "stop": { target: null, quality: "none", notes: "Claude has no stop hook" },
+      "afterAgentResponse": { target: "assistant-response", quality: "direct", notes: "Direct semantic match" },
+      "afterAgentThought": { target: null, quality: "none", notes: "Claude has no thought hooks" },
+      "beforeTabFileRead": { target: null, quality: "none", notes: "Tab hooks are Cursor-specific" },
+      "afterTabFileEdit": { target: null, quality: "none", notes: "Tab hooks are Cursor-specific" }
+    };
+    KIRO_TO_CURSOR = {
+      "agentSpawn": { target: null, quality: "none", notes: "Cursor has no agent spawn hook" },
+      "userPromptSubmit": { target: "beforeSubmitPrompt", quality: "direct", notes: "Direct semantic match" },
+      "preToolUse": { target: "beforeMCPExecution", quality: "semantic", notes: "Kiro tools map to Cursor MCP" },
+      "postToolUse": { target: "afterMCPExecution", quality: "semantic", notes: "Kiro tools map to Cursor MCP" },
+      "stop": { target: "stop", quality: "direct", notes: "Direct semantic match" }
+    };
+    CURSOR_TO_KIRO = {
+      "beforeShellExecution": { target: null, quality: "none", notes: "Kiro has no shell hooks" },
+      "afterShellExecution": { target: null, quality: "none", notes: "Kiro has no shell hooks" },
+      "beforeMCPExecution": { target: "preToolUse", quality: "semantic", notes: "Cursor MCP maps to Kiro tools" },
+      "afterMCPExecution": { target: "postToolUse", quality: "semantic", notes: "Cursor MCP maps to Kiro tools" },
+      "beforeReadFile": { target: null, quality: "none", notes: "Kiro has no file read hooks" },
+      "afterFileEdit": { target: null, quality: "none", notes: "Kiro has no file edit hooks" },
+      "beforeSubmitPrompt": { target: "userPromptSubmit", quality: "direct", notes: "Direct semantic match" },
+      "stop": { target: "stop", quality: "direct", notes: "Direct semantic match" },
+      "afterAgentResponse": { target: null, quality: "none", notes: "Kiro has no response hooks" },
+      "afterAgentThought": { target: null, quality: "none", notes: "Kiro has no thought hooks" },
+      "beforeTabFileRead": { target: null, quality: "none", notes: "Tab hooks are Cursor-specific" },
+      "afterTabFileEdit": { target: null, quality: "none", notes: "Tab hooks are Cursor-specific" }
+    };
+    CLAUDE_TO_KIRO = {
+      "session-start": { target: "agentSpawn", quality: "semantic", notes: "Session start maps to agent spawn" },
+      "user-prompt-submit": { target: "userPromptSubmit", quality: "direct", notes: "Direct semantic match" },
+      "tool-call": { target: "preToolUse", quality: "semantic", notes: "Tool call maps to pre-tool use" },
+      "assistant-response": { target: null, quality: "none", notes: "Kiro has no response hooks" }
+    };
+    KIRO_TO_CLAUDE = {
+      "agentSpawn": { target: "session-start", quality: "semantic", notes: "Agent spawn maps to session start" },
+      "userPromptSubmit": { target: "user-prompt-submit", quality: "direct", notes: "Direct semantic match" },
+      "preToolUse": { target: "tool-call", quality: "semantic", notes: "Pre-tool use maps to tool call" },
+      "postToolUse": { target: null, quality: "none", notes: "Claude has no post-tool hook" },
+      "stop": { target: null, quality: "none", notes: "Claude has no stop hook" }
+    };
+  }
+});
+
 // ../converters/dist/taxonomy-utils.js
 function detectSubtypeFromFrontmatter(frontmatter, explicitSubtype) {
   if (explicitSubtype) {
@@ -552,7 +770,7 @@ function normalizeFormat(sourceFormat) {
     return "copilot";
   if (normalized.includes("kiro"))
     return "kiro";
-  if (normalized.includes("agents.md") || normalized.includes("agentsmd"))
+  if (normalized.includes("agents.md") || normalized.includes("agentsmd") || normalized.includes("agents-md"))
     return "agents.md";
   if (normalized.includes("gemini"))
     return "gemini";
@@ -882,6 +1100,154 @@ var init_from_cursor = __esm({
   }
 });
 
+// ../converters/dist/from-cursor-hooks.js
+function fromCursorHooks(content, metadata) {
+  let hooksConfig;
+  try {
+    hooksConfig = JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Invalid Cursor hooks JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const hookSections = Object.entries(hooksConfig).map(([hookType, scriptPath]) => {
+    if (!isValidCursorHookType(hookType)) {
+      throw new Error(`Invalid hook type: ${hookType}. Valid types: ${VALID_CURSOR_HOOK_TYPES.join(", ")}`);
+    }
+    return {
+      type: "cursor-hook",
+      hookType,
+      scriptPath,
+      description: `Cursor ${hookType} hook`
+    };
+  });
+  const pkg = {
+    id: metadata.id,
+    version: metadata.version,
+    name: metadata.name,
+    description: metadata.description || `Cursor hooks configuration`,
+    author: metadata.author,
+    organization: metadata.organization,
+    tags: metadata.tags || ["cursor", "hooks"],
+    format: "cursor",
+    subtype: "hook",
+    // Additional metadata
+    license: metadata.license,
+    repository: metadata.repository,
+    homepage: metadata.homepage,
+    documentation: metadata.documentation,
+    keywords: metadata.keywords,
+    category: metadata.category,
+    dependencies: metadata.dependencies,
+    peerDependencies: metadata.peerDependencies,
+    engines: metadata.engines,
+    content: {
+      format: "canonical",
+      version: "1.0",
+      sections: hookSections
+    },
+    sourceFormat: "cursor"
+  };
+  return pkg;
+}
+var init_from_cursor_hooks = __esm({
+  "../converters/dist/from-cursor-hooks.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_cursor_hooks_constants();
+  }
+});
+
+// ../converters/dist/from-claude-plugin.js
+function fromClaudePlugin(pluginJson, contents, metadata) {
+  var _a, _b, _c;
+  const sections = [];
+  const metadataSection = {
+    type: "metadata",
+    data: {
+      title: pluginJson.name || metadata.name,
+      description: pluginJson.description || "",
+      version: pluginJson.version || metadata.version || "1.0.0",
+      author: pluginJson.author || metadata.author,
+      // Store MCP servers in metadata for later extraction
+      claudePlugin: {
+        mcpServers: pluginJson.mcpServers,
+        contents: {
+          agents: contents.agents || [],
+          skills: contents.skills || [],
+          commands: contents.commands || []
+        }
+      }
+    }
+  };
+  sections.push(metadataSection);
+  if (pluginJson.description) {
+    sections.push({
+      type: "instructions",
+      title: "Overview",
+      content: pluginJson.description
+    });
+  }
+  const contentsSummary = [];
+  if ((_a = contents.agents) == null ? void 0 : _a.length) {
+    contentsSummary.push(`- **Agents**: ${contents.agents.length} agents`);
+  }
+  if ((_b = contents.skills) == null ? void 0 : _b.length) {
+    contentsSummary.push(`- **Skills**: ${contents.skills.length} skills`);
+  }
+  if ((_c = contents.commands) == null ? void 0 : _c.length) {
+    contentsSummary.push(`- **Commands**: ${contents.commands.length} commands`);
+  }
+  if (pluginJson.mcpServers && Object.keys(pluginJson.mcpServers).length > 0) {
+    contentsSummary.push(`- **MCP Servers**: ${Object.keys(pluginJson.mcpServers).join(", ")}`);
+  }
+  if (contentsSummary.length > 0) {
+    sections.push({
+      type: "context",
+      title: "Plugin Contents",
+      content: contentsSummary.join("\n")
+    });
+  }
+  const pkg = {
+    id: metadata.id,
+    version: pluginJson.version || metadata.version || "1.0.0",
+    name: pluginJson.name || metadata.name,
+    description: pluginJson.description || "",
+    author: pluginJson.author || metadata.author || "unknown",
+    tags: pluginJson.keywords || metadata.tags || [],
+    content: {
+      format: "canonical",
+      version: "1.0",
+      sections
+    },
+    sourceFormat: "claude",
+    metadata: {
+      title: metadataSection.data.title,
+      description: metadataSection.data.description,
+      version: metadataSection.data.version,
+      author: metadataSection.data.author,
+      claudePlugin: metadataSection.data.claudePlugin
+    }
+  };
+  setTaxonomy(pkg, "claude", "plugin");
+  return pkg;
+}
+function parsePluginJson(content) {
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse plugin.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function extractMCPServers(pluginJson) {
+  return pluginJson.mcpServers || {};
+}
+var init_from_claude_plugin = __esm({
+  "../converters/dist/from-claude-plugin.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_taxonomy_utils();
+  }
+});
+
 // ../converters/dist/from-continue.js
 function fromContinue(content, metadata, explicitSubtype) {
   const pkg = fromClaude(content, metadata, "continue", explicitSubtype);
@@ -7946,6 +8312,105 @@ var init_from_replit = __esm({
   }
 });
 
+// ../converters/dist/from-mcp-server.js
+function fromMCPServer(mcpServerJson, metadata) {
+  var _a;
+  const pkg = {
+    id: metadata.id,
+    version: mcpServerJson.version || metadata.version,
+    name: mcpServerJson.name || metadata.name,
+    description: mcpServerJson.description || metadata.description || "MCP Server package",
+    author: mcpServerJson.author || metadata.author,
+    organization: metadata.organization,
+    tags: metadata.tags || ["mcp", "server"],
+    license: mcpServerJson.license || metadata.license,
+    repository: mcpServerJson.repository || metadata.repository,
+    homepage: mcpServerJson.homepage || metadata.homepage
+  };
+  setTaxonomy(pkg, "mcp", "server");
+  const sections = [];
+  sections.push({
+    type: "metadata",
+    data: {
+      title: pkg.name,
+      description: pkg.description
+    }
+  });
+  const serverDescriptions = [];
+  for (const [serverName, serverConfig] of Object.entries(mcpServerJson.mcpServers)) {
+    const serverType = serverConfig.type || "stdio";
+    if (serverType === "stdio" && serverConfig.command) {
+      const args = ((_a = serverConfig.args) == null ? void 0 : _a.join(" ")) || "";
+      serverDescriptions.push(`- **${serverName}**: \`${serverConfig.command} ${args}\``);
+    } else if ((serverType === "http" || serverType === "sse") && serverConfig.url) {
+      serverDescriptions.push(`- **${serverName}**: ${serverConfig.url} (${serverType})`);
+    }
+    if (serverConfig.env && Object.keys(serverConfig.env).length > 0) {
+      const envVars = Object.keys(serverConfig.env).join(", ");
+      serverDescriptions.push(`  - Environment: ${envVars}`);
+    }
+  }
+  if (serverDescriptions.length > 0) {
+    sections.push({
+      type: "instructions",
+      title: "MCP Servers",
+      content: `This package provides the following MCP servers:
+
+${serverDescriptions.join("\n")}`
+    });
+  }
+  pkg.metadata = {
+    title: pkg.name,
+    description: pkg.description,
+    claudePlugin: {
+      mcpServers: mcpServerJson.mcpServers
+    }
+  };
+  pkg.content = {
+    format: "canonical",
+    version: "1.0",
+    sections
+  };
+  return pkg;
+}
+function parseMCPServerJson(jsonString) {
+  const parsed = JSON.parse(jsonString);
+  if (!parsed.name) {
+    throw new Error("MCP server package must have a name");
+  }
+  if (!parsed.mcpServers || typeof parsed.mcpServers !== "object") {
+    throw new Error("MCP server package must have mcpServers configuration");
+  }
+  if (Object.keys(parsed.mcpServers).length === 0) {
+    throw new Error("MCP server package must define at least one server");
+  }
+  for (const [serverName, serverConfig] of Object.entries(parsed.mcpServers)) {
+    const config = serverConfig;
+    const serverType = config.type || "stdio";
+    if (serverType === "stdio" && !config.command) {
+      throw new Error(`MCP server '${serverName}' of type stdio must have a command`);
+    }
+    if ((serverType === "http" || serverType === "sse") && !config.url) {
+      throw new Error(`MCP server '${serverName}' of type ${serverType} must have a url`);
+    }
+  }
+  return parsed;
+}
+function extractMCPServers2(pkg) {
+  var _a, _b;
+  if ((_b = (_a = pkg.metadata) == null ? void 0 : _a.claudePlugin) == null ? void 0 : _b.mcpServers) {
+    return pkg.metadata.claudePlugin.mcpServers;
+  }
+  return null;
+}
+var init_from_mcp_server = __esm({
+  "../converters/dist/from-mcp-server.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_taxonomy_utils();
+  }
+});
+
 // ../converters/dist/validation.js
 function loadSchema(format, subtype) {
   const cacheKey = subtype ? `${format}:${subtype}` : format;
@@ -7960,6 +8425,8 @@ function loadSchema(format, subtype) {
       "claude:slash-command": "claude-slash-command.schema.json",
       "claude:hook": "claude-hook.schema.json",
       "cursor:slash-command": "cursor-command.schema.json",
+      "cursor:hook": "cursor-hooks.schema.json",
+      // cursor + hook subtype uses cursor-hooks schema
       "kiro:hook": "kiro-hooks.schema.json",
       "kiro:agent": "kiro-agent.schema.json",
       "droid:skill": "droid-skill.schema.json",
@@ -7977,7 +8444,7 @@ function loadSchema(format, subtype) {
       "windsurf": "windsurf.schema.json",
       "copilot": "copilot.schema.json",
       "kiro": "kiro-steering.schema.json",
-      "agents-md": "agents-md.schema.json",
+      "agents.md": "agents-md.schema.json",
       "gemini": "gemini.schema.json",
       "opencode": "opencode.schema.json",
       "ruler": "ruler.schema.json",
@@ -7987,6 +8454,7 @@ function loadSchema(format, subtype) {
       "zencoder": "zencoder.schema.json",
       "replit": "replit.schema.json",
       "canonical": "canonical.schema.json"
+      // generic and mcp don't have specific schemas, will use fallback
     };
     schemaFilename = schemaMap[format] || `${format}.schema.json`;
   }
@@ -8079,7 +8547,8 @@ function parseMarkdownWithFrontmatter(markdown) {
       content: markdown
     };
   }
-  const frontmatterText = lines.slice(1, closingIndex + 1).join("\n");
+  let frontmatterText = lines.slice(1, closingIndex + 1).join("\n");
+  frontmatterText = frontmatterText.replace(/^(argument-hint:\s*)(\[[\w-]+\](?:\s+\[[\w-]+\])+)\s*$/m, (_, prefix, value) => `${prefix}"${value}"`);
   let frontmatter = {};
   try {
     const parsed = jsYaml.load(frontmatterText);
@@ -8093,7 +8562,7 @@ function parseMarkdownWithFrontmatter(markdown) {
 }
 function validateMarkdown(format, markdown, subtype) {
   const { frontmatter, content } = parseMarkdownWithFrontmatter(markdown);
-  if (format === "windsurf" || format === "agents-md" || format === "ruler") {
+  if (format === "windsurf" || format === "agents.md" || format === "ruler") {
     return validateFormat(format, { content: markdown }, subtype);
   }
   return validateConversion(format, frontmatter, content, subtype);
@@ -8350,6 +8819,111 @@ var init_to_cursor = __esm({
   }
 });
 
+// ../converters/dist/to-cursor-hooks.js
+function toCursorHooks(pkg, options = {}) {
+  var _a, _b, _c, _d;
+  const warnings = [];
+  const extractedScripts = [];
+  let qualityScore = 100;
+  const hookMappingStrategy = options.hookMappingStrategy || "auto";
+  try {
+    const hooksConfig = {};
+    const cursorHookSections = pkg.content.sections.filter((section) => section.type === "cursor-hook");
+    for (const section of cursorHookSections) {
+      hooksConfig[section.hookType] = section.scriptPath;
+    }
+    const claudeHooks = pkg.content.sections.filter((section) => section.type === "hook");
+    if (claudeHooks.length > 0 && hookMappingStrategy !== "skip") {
+      for (const claudeHook of claudeHooks) {
+        const mappingResult = mapHook("claude", "cursor", claudeHook.event, hookMappingStrategy);
+        qualityScore -= mappingResult.qualityPenalty;
+        if (mappingResult.warning) {
+          warnings.push(mappingResult.warning);
+        }
+        if (mappingResult.mapped && mappingResult.targetHookType) {
+          const scriptExt = getScriptExtension(claudeHook.language);
+          const scriptPath = `./hooks/${claudeHook.event}.${scriptExt}`;
+          hooksConfig[mappingResult.targetHookType] = scriptPath;
+          extractedScripts.push({
+            path: scriptPath,
+            content: claudeHook.code,
+            language: claudeHook.language,
+            executable: true
+          });
+          warnings.push(`Mapped Claude hook "${claudeHook.event}" to Cursor hook "${mappingResult.targetHookType}". Script extracted to ${scriptPath}`);
+        }
+      }
+    } else if (claudeHooks.length > 0 && hookMappingStrategy === "skip") {
+      warnings.push(`${claudeHooks.length} Claude hook(s) skipped (--hook-mapping skip)`);
+    }
+    if (((_b = (_a = pkg.metadata) == null ? void 0 : _a.kiroAgent) == null ? void 0 : _b.hooks) && hookMappingStrategy !== "skip") {
+      const kiroHooks = pkg.metadata.kiroAgent.hooks;
+      for (const [kiroHookType, scriptPaths] of Object.entries(kiroHooks)) {
+        if (!scriptPaths || !Array.isArray(scriptPaths) || scriptPaths.length === 0)
+          continue;
+        const mappingResult = mapHook("kiro", "cursor", kiroHookType, hookMappingStrategy);
+        qualityScore -= mappingResult.qualityPenalty;
+        if (mappingResult.warning) {
+          warnings.push(mappingResult.warning);
+        }
+        if (mappingResult.mapped && mappingResult.targetHookType) {
+          hooksConfig[mappingResult.targetHookType] = scriptPaths[0];
+        }
+      }
+    } else if (((_d = (_c = pkg.metadata) == null ? void 0 : _c.kiroAgent) == null ? void 0 : _d.hooks) && hookMappingStrategy === "skip") {
+      const kiroHookTypes = Object.keys(pkg.metadata.kiroAgent.hooks);
+      warnings.push(`${kiroHookTypes.length} Kiro hook(s) skipped (--hook-mapping skip)`);
+    }
+    if (Object.keys(hooksConfig).length === 0) {
+      warnings.push("No hooks converted to Cursor hooks format");
+      qualityScore -= 50;
+    }
+    const unsupportedSections = pkg.content.sections.filter((section) => section.type !== "cursor-hook" && section.type !== "metadata" && section.type !== "hook");
+    if (unsupportedSections.length > 0) {
+      warnings.push(`${unsupportedSections.length} non-hook sections skipped (not supported in hooks.json format)`);
+      qualityScore -= 10;
+    }
+    const content = JSON.stringify(hooksConfig, null, 2);
+    return {
+      content,
+      format: "cursor",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion: warnings.length > 0,
+      qualityScore: Math.max(0, qualityScore),
+      extractedScripts: extractedScripts.length > 0 ? extractedScripts : void 0
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "{}",
+      format: "cursor",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function isCursorHooksFormat(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return false;
+    }
+    const keys = Object.keys(parsed);
+    return keys.length > 0 && keys.some((key) => VALID_CURSOR_HOOK_TYPES.includes(key));
+  } catch {
+    return false;
+  }
+}
+var init_to_cursor_hooks = __esm({
+  "../converters/dist/to-cursor-hooks.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_hook_mappings();
+    init_cursor_hooks_constants();
+  }
+});
+
 // ../converters/dist/to-claude.js
 function toClaude(pkg, options = {}) {
   const warnings = [];
@@ -8406,7 +8980,8 @@ function convertContent2(pkg, warnings, options, isSlashCommand = false) {
         lines.push(`allowed-tools: ${claudeSlashCommand.allowedTools}`);
       }
       if (claudeSlashCommand.argumentHint) {
-        lines.push(`argument-hint: ${claudeSlashCommand.argumentHint}`);
+        const hint = Array.isArray(claudeSlashCommand.argumentHint) ? `[${claudeSlashCommand.argumentHint.join(", ")}]` : claudeSlashCommand.argumentHint;
+        lines.push(`argument-hint: ${hint}`);
       }
       if (claudeSlashCommand.description) {
         lines.push(`description: ${claudeSlashCommand.description}`);
@@ -8630,6 +9205,88 @@ var init_to_claude = __esm({
   }
 });
 
+// ../converters/dist/to-claude-plugin.js
+function toClaudePlugin(pkg) {
+  var _a, _b, _c;
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const metadata = pkg.content.sections.find((s) => s.type === "metadata");
+    const storedPluginData = (metadata == null ? void 0 : metadata.type) === "metadata" ? metadata.data.claudePlugin : void 0;
+    const pluginJson = {
+      name: pkg.name || pkg.id,
+      version: pkg.version,
+      description: pkg.description || ((metadata == null ? void 0 : metadata.type) === "metadata" ? metadata.data.description : ""),
+      author: pkg.author
+    };
+    if ((storedPluginData == null ? void 0 : storedPluginData.mcpServers) && Object.keys(storedPluginData.mcpServers).length > 0) {
+      pluginJson.mcpServers = storedPluginData.mcpServers;
+    }
+    if (pkg.tags && pkg.tags.length > 0) {
+      pluginJson.keywords = pkg.tags;
+    }
+    const pluginContents = (storedPluginData == null ? void 0 : storedPluginData.contents) || {
+      agents: [],
+      skills: [],
+      commands: []
+    };
+    const content = JSON.stringify(pluginJson, null, 2);
+    if (!pluginJson.description) {
+      warnings.push("Missing description");
+      qualityScore -= 5;
+    }
+    if (!pluginJson.mcpServers || Object.keys(pluginJson.mcpServers).length === 0) {
+      warnings.push("No MCP servers configured");
+    }
+    const totalFiles = (((_a = pluginContents.agents) == null ? void 0 : _a.length) || 0) + (((_b = pluginContents.skills) == null ? void 0 : _b.length) || 0) + (((_c = pluginContents.commands) == null ? void 0 : _c.length) || 0);
+    if (totalFiles === 0 && (!pluginJson.mcpServers || Object.keys(pluginJson.mcpServers).length === 0)) {
+      warnings.push("Plugin has no agents, skills, commands, or MCP servers");
+      qualityScore -= 20;
+    }
+    return {
+      content,
+      format: "claude",
+      // format: claude + subtype: plugin
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion: false,
+      // Plugin format preserves all data
+      qualityScore,
+      pluginJson,
+      pluginContents
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "{}",
+      format: "claude",
+      // format: claude + subtype: plugin
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0,
+      pluginJson: { name: pkg.name || pkg.id },
+      pluginContents: {}
+    };
+  }
+}
+function generatePluginJson(pluginJson) {
+  return JSON.stringify(pluginJson, null, 2);
+}
+function createMinimalPluginJson(name, options) {
+  return {
+    name,
+    version: (options == null ? void 0 : options.version) || "1.0.0",
+    description: options == null ? void 0 : options.description,
+    author: options == null ? void 0 : options.author,
+    mcpServers: options == null ? void 0 : options.mcpServers
+  };
+}
+var init_to_claude_plugin = __esm({
+  "../converters/dist/to-claude-plugin.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/to-continue.js
 function toContinue(pkg) {
   var _a, _b;
@@ -10848,8 +11505,86 @@ var init_to_replit = __esm({
   }
 });
 
+// ../converters/dist/to-mcp-server.js
+function toMCPServer(pkg) {
+  var _a, _b;
+  const warnings = [];
+  let qualityScore = 100;
+  let mcpServers = {};
+  if ((_b = (_a = pkg.metadata) == null ? void 0 : _a.claudePlugin) == null ? void 0 : _b.mcpServers) {
+    mcpServers = pkg.metadata.claudePlugin.mcpServers;
+  } else {
+    warnings.push("No MCP servers defined in package metadata");
+    qualityScore -= 50;
+  }
+  const mcpServerJson = {
+    name: pkg.name,
+    description: pkg.description,
+    version: pkg.version,
+    author: pkg.author,
+    mcpServers
+  };
+  if (pkg.repository) {
+    mcpServerJson.repository = pkg.repository;
+  }
+  if (pkg.homepage) {
+    mcpServerJson.homepage = pkg.homepage;
+  }
+  if (pkg.license) {
+    mcpServerJson.license = pkg.license;
+  }
+  if (!mcpServerJson.description) {
+    warnings.push("Missing description");
+    qualityScore -= 10;
+  }
+  if (Object.keys(mcpServers).length === 0) {
+    warnings.push("No MCP servers defined - package will not add any servers");
+    qualityScore -= 30;
+  }
+  for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+    const serverType = serverConfig.type || "stdio";
+    if (serverType === "stdio" && !serverConfig.command) {
+      warnings.push(`Server '${serverName}' is missing command for stdio type`);
+      qualityScore -= 10;
+    }
+    if ((serverType === "http" || serverType === "sse") && !serverConfig.url) {
+      warnings.push(`Server '${serverName}' is missing url for ${serverType} type`);
+      qualityScore -= 10;
+    }
+  }
+  const content = JSON.stringify(mcpServerJson, null, 2);
+  return {
+    content,
+    format: "mcp",
+    warnings: warnings.length > 0 ? warnings : void 0,
+    lossyConversion: false,
+    qualityScore: Math.max(0, qualityScore),
+    mcpServerJson
+  };
+}
+function generateMCPServerPackage(name, servers, options = {}) {
+  const mcpServerJson = {
+    name,
+    description: options.description || `MCP server package: ${name}`,
+    version: options.version || "1.0.0",
+    author: options.author,
+    repository: options.repository,
+    homepage: options.homepage,
+    license: options.license,
+    mcpServers: servers
+  };
+  const cleaned = JSON.parse(JSON.stringify(mcpServerJson));
+  return JSON.stringify(cleaned, null, 2);
+}
+var init_to_mcp_server = __esm({
+  "../converters/dist/to-mcp-server.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/schema-files.js
-var import_module, import_path6, schemaRequire, convertersPackagePath, convertersDir, loadSchema2, formatRegistrySchema, agentsMdSchema, canonicalSchema, claudeSchema, continueSchema, copilotSchema, cursorSchema, droidSchema, geminiMdSchema, geminiSchema, kiroSteeringSchema, opencodeSchema, rulerSchema, windsurfSchema, traeSchema, aiderSchema, zencoderSchema, replitSchema, claudeAgentSchema, claudeHookSchema, claudeSkillSchema, claudeSlashCommandSchema, cursorCommandSchema, droidHookSchema, droidSkillSchema, droidSlashCommandSchema, kiroAgentSchema, kiroHookSchema, opencodeSlashCommandSchema;
+var import_module, import_path6, schemaRequire, convertersPackagePath, convertersDir, loadSchema2, formatRegistrySchema, agentsMdSchema, canonicalSchema, claudeSchema, continueSchema, copilotSchema, cursorSchema, droidSchema, geminiMdSchema, geminiSchema, kiroSteeringSchema, opencodeSchema, rulerSchema, windsurfSchema, traeSchema, aiderSchema, zencoderSchema, replitSchema, claudeAgentSchema, claudeHookSchema, claudeSkillSchema, claudeSlashCommandSchema, cursorCommandSchema, cursorHooksSchema, droidHookSchema, droidSkillSchema, droidSlashCommandSchema, kiroAgentSchema, kiroHookSchema, opencodeSlashCommandSchema;
 var init_schema_files = __esm({
   "../converters/dist/schema-files.js"() {
     "use strict";
@@ -10883,6 +11618,7 @@ var init_schema_files = __esm({
     claudeSkillSchema = loadSchema2("claude-skill.schema.json");
     claudeSlashCommandSchema = loadSchema2("claude-slash-command.schema.json");
     cursorCommandSchema = loadSchema2("cursor-command.schema.json");
+    cursorHooksSchema = loadSchema2("cursor-hooks.schema.json");
     droidHookSchema = loadSchema2("droid-hook.schema.json");
     droidSkillSchema = loadSchema2("droid-skill.schema.json");
     droidSlashCommandSchema = loadSchema2("droid-slash-command.schema.json");
@@ -10923,6 +11659,19 @@ var init_format_registry = __esm({
             }
           }
         },
+        "cursor-hooks": {
+          name: "Cursor Hooks",
+          description: "Cursor agent hooks configuration",
+          documentationUrl: "https://cursor.com/docs/agent/hooks",
+          rootFiles: ["hooks.json"],
+          subtypes: {
+            hook: {
+              directory: ".",
+              filePatterns: ["hooks.json"],
+              fileExtension: ".json"
+            }
+          }
+        },
         claude: {
           name: "Claude Code",
           description: "Claude AI skills, agents, commands, and hooks",
@@ -10958,6 +11707,21 @@ var init_format_registry = __esm({
             }
           }
         },
+        "claude-plugin": {
+          name: "Claude Plugin",
+          description: "Claude Code plugins containing agents, skills, commands, and MCP servers",
+          documentationUrl: "https://code.claude.com/docs",
+          rootFiles: [".claude-plugin/plugin.json"],
+          subtypes: {
+            plugin: {
+              directory: ".claude",
+              scanDirectory: ".claude-plugin",
+              filePatterns: ["plugin.json"],
+              nested: false,
+              fileExtension: ".json"
+            }
+          }
+        },
         continue: {
           name: "Continue",
           description: "Continue AI coding rules and prompts",
@@ -11237,8 +12001,14 @@ var init_format_registry = __esm({
         },
         mcp: {
           name: "MCP",
-          description: "Model Context Protocol tools",
+          description: "Model Context Protocol servers and tools",
+          defaultSubtype: "server",
           subtypes: {
+            server: {
+              directory: ".mcp",
+              filePatterns: ["*.json", "mcp-server.json"],
+              fileExtension: ".json"
+            },
             tool: {
               directory: ".mcp/tools",
               filePatterns: ["*.json"],
@@ -11336,6 +12106,15 @@ var init_format_registry2 = __esm({
 // ../converters/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  CLAUDE_TO_CURSOR: () => CLAUDE_TO_CURSOR,
+  CLAUDE_TO_KIRO: () => CLAUDE_TO_KIRO,
+  CURSOR_TO_CLAUDE: () => CURSOR_TO_CLAUDE,
+  CURSOR_TO_KIRO: () => CURSOR_TO_KIRO,
+  KIRO_TO_CLAUDE: () => KIRO_TO_CLAUDE,
+  KIRO_TO_CURSOR: () => KIRO_TO_CURSOR,
+  SCRIPT_LANGUAGE_EXTENSIONS: () => SCRIPT_LANGUAGE_EXTENSIONS,
+  VALID_CURSOR_HOOK_TYPES: () => VALID_CURSOR_HOOK_TYPES,
+  VALID_HOOK_MAPPING_STRATEGIES: () => VALID_HOOK_MAPPING_STRATEGIES,
   agentsMdSchema: () => agentsMdSchema,
   aiderSchema: () => aiderSchema,
   canonicalSchema: () => canonicalSchema,
@@ -11346,13 +12125,17 @@ __export(dist_exports, {
   claudeSlashCommandSchema: () => claudeSlashCommandSchema,
   continueSchema: () => continueSchema,
   copilotSchema: () => copilotSchema,
+  createMinimalPluginJson: () => createMinimalPluginJson,
   cursorCommandSchema: () => cursorCommandSchema,
+  cursorHooksSchema: () => cursorHooksSchema,
   cursorSchema: () => cursorSchema,
   detectSubtypeFromFrontmatter: () => detectSubtypeFromFrontmatter,
   droidHookSchema: () => droidHookSchema,
   droidSchema: () => droidSchema,
   droidSkillSchema: () => droidSkillSchema,
   droidSlashCommandSchema: () => droidSlashCommandSchema,
+  extractMCPServers: () => extractMCPServers,
+  extractMCPServersFromCanonical: () => extractMCPServers2,
   findFormatByRootFile: () => findFormatByRootFile,
   formatRegistry: () => formatRegistry,
   formatRegistrySchema: () => formatRegistrySchema,
@@ -11360,13 +12143,16 @@ __export(dist_exports, {
   fromAgentsMd: () => fromAgentsMd,
   fromAider: () => fromAider,
   fromClaude: () => fromClaude,
+  fromClaudePlugin: () => fromClaudePlugin,
   fromContinue: () => fromContinue,
   fromCopilot: () => fromCopilot,
   fromCursor: () => fromCursor,
+  fromCursorHooks: () => fromCursorHooks,
   fromDroid: () => fromDroid,
   fromGemini: () => fromGemini,
   fromKiro: () => fromKiro,
   fromKiroAgent: () => fromKiroAgent,
+  fromMCPServer: () => fromMCPServer,
   fromOpencode: () => fromOpencode,
   fromReplit: () => fromReplit,
   fromRuler: () => fromRuler,
@@ -11375,6 +12161,8 @@ __export(dist_exports, {
   fromZencoder: () => fromZencoder,
   geminiMdSchema: () => geminiMdSchema,
   geminiSchema: () => geminiSchema,
+  generateMCPServerPackage: () => generateMCPServerPackage,
+  generatePluginJson: () => generatePluginJson,
   getDefaultSubtype: () => getDefaultSubtype,
   getDestinationDirectory: () => getDestinationDirectory,
   getFileExtension: () => getFileExtension,
@@ -11382,9 +12170,12 @@ __export(dist_exports, {
   getFormatConfig: () => getFormatConfig,
   getFormatNames: () => getFormatNames,
   getFormatRegistry: () => getFormatRegistry,
+  getHookMapping: () => getHookMapping,
   getNestedIndicator: () => getNestedIndicator,
+  getQualityPenalty: () => getQualityPenalty,
   getRootFiles: () => getRootFiles,
   getScanDirectory: () => getScanDirectory,
+  getScriptExtension: () => getScriptExtension,
   getSubtypeConfig: () => getSubtypeConfig,
   getSubtypes: () => getSubtypes,
   isAgentsMdFormat: () => isAgentsMdFormat,
@@ -11393,20 +12184,27 @@ __export(dist_exports, {
   isContinueFormat: () => isContinueFormat,
   isCopilotFormat: () => isCopilotFormat,
   isCursorFormat: () => isCursorFormat,
+  isCursorHooksFormat: () => isCursorHooksFormat,
   isKiroAgentFormat: () => isKiroAgentFormat,
   isKiroFormat: () => isKiroFormat,
   isNestedPackage: () => isNestedPackage,
   isReplitFormat: () => isReplitFormat,
   isRulerFormat: () => isRulerFormat,
   isTraeFormat: () => isTraeFormat,
+  isValidCursorHookType: () => isValidCursorHookType,
+  isValidHookMappingStrategy: () => isValidHookMappingStrategy,
   isWindsurfFormat: () => isWindsurfFormat,
   isZencoderFormat: () => isZencoderFormat,
   kiroAgentSchema: () => kiroAgentSchema,
   kiroHookSchema: () => kiroHookSchema,
   kiroSteeringSchema: () => kiroSteeringSchema,
+  mapHook: () => mapHook,
+  mapHooks: () => mapHooks,
   normalizeFormat: () => normalizeFormat,
   opencodeSchema: () => opencodeSchema,
   opencodeSlashCommandSchema: () => opencodeSlashCommandSchema,
+  parseMCPServerJson: () => parseMCPServerJson,
+  parsePluginJson: () => parsePluginJson,
   replitSchema: () => replitSchema,
   rulerSchema: () => rulerSchema,
   setTaxonomy: () => setTaxonomy,
@@ -11414,13 +12212,16 @@ __export(dist_exports, {
   toAider: () => toAider,
   toClaude: () => toClaude,
   toClaudeMd: () => toClaudeMd,
+  toClaudePlugin: () => toClaudePlugin,
   toContinue: () => toContinue,
   toCopilot: () => toCopilot,
   toCursor: () => toCursor,
+  toCursorHooks: () => toCursorHooks,
   toDroid: () => toDroid,
   toGemini: () => toGemini,
   toKiro: () => toKiro,
   toKiroAgent: () => toKiroAgent,
+  toMCPServer: () => toMCPServer,
   toOpencode: () => toOpencode,
   toReplit: () => toReplit,
   toRuler: () => toRuler,
@@ -11439,8 +12240,12 @@ var init_dist = __esm({
     "use strict";
     init_cjs_shims();
     init_canonical();
+    init_cursor_hooks_constants();
+    init_hook_mappings();
     init_from_cursor();
+    init_from_cursor_hooks();
     init_from_claude();
+    init_from_claude_plugin();
     init_from_continue();
     init_from_copilot();
     init_from_kiro();
@@ -11455,8 +12260,11 @@ var init_dist = __esm({
     init_from_aider();
     init_from_zencoder();
     init_from_replit();
+    init_from_mcp_server();
     init_to_cursor();
+    init_to_cursor_hooks();
     init_to_claude();
+    init_to_claude_plugin();
     init_to_continue();
     init_to_copilot();
     init_to_kiro();
@@ -11471,6 +12279,7 @@ var init_dist = __esm({
     init_to_aider();
     init_to_zencoder();
     init_to_replit();
+    init_to_mcp_server();
     init_taxonomy_utils();
     init_validation();
     init_schema_files();
@@ -11829,6 +12638,123 @@ var init_agents_md_progressive = __esm({
   }
 });
 
+// src/core/mcp.ts
+function getMCPConfigPath(global2 = false, projectDir = process.cwd()) {
+  if (global2) {
+    return (0, import_path9.join)((0, import_os3.homedir)(), ".claude", "settings.json");
+  }
+  return (0, import_path9.join)(projectDir, ".mcp.json");
+}
+function readMCPConfig(configPath) {
+  if (!(0, import_fs8.existsSync)(configPath)) {
+    return { mcpServers: {} };
+  }
+  try {
+    const content = (0, import_fs8.readFileSync)(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return { mcpServers: {} };
+  }
+}
+function writeMCPConfig(configPath, config) {
+  const dir = (0, import_path9.dirname)(configPath);
+  if (!(0, import_fs8.existsSync)(dir)) {
+    (0, import_fs8.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_fs8.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function mergeMCPServers(servers, global2 = false, projectDir = process.cwd()) {
+  const result = {
+    added: [],
+    skipped: [],
+    warnings: []
+  };
+  if (!servers || Object.keys(servers).length === 0) {
+    return result;
+  }
+  const configPath = getMCPConfigPath(global2, projectDir);
+  const config = readMCPConfig(configPath);
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  for (const [name, server] of Object.entries(servers)) {
+    if (config.mcpServers[name]) {
+      result.skipped.push(name);
+      result.warnings.push(`MCP server '${name}' already exists, keeping existing configuration`);
+    } else {
+      config.mcpServers[name] = server;
+      result.added.push(name);
+    }
+  }
+  if (result.added.length > 0) {
+    writeMCPConfig(configPath, config);
+  }
+  return result;
+}
+function removeMCPServers(servers, global2 = false, projectDir = process.cwd()) {
+  const result = {
+    removed: [],
+    kept: [],
+    warnings: []
+  };
+  if (!servers || Object.keys(servers).length === 0) {
+    return result;
+  }
+  const configPath = getMCPConfigPath(global2, projectDir);
+  if (!(0, import_fs8.existsSync)(configPath)) {
+    return result;
+  }
+  const config = readMCPConfig(configPath);
+  if (!config.mcpServers) {
+    return result;
+  }
+  for (const [name, originalServer] of Object.entries(servers)) {
+    const currentServer = config.mcpServers[name];
+    if (!currentServer) {
+      continue;
+    }
+    if (serversEqual(currentServer, originalServer)) {
+      delete config.mcpServers[name];
+      result.removed.push(name);
+    } else {
+      result.kept.push(name);
+      result.warnings.push(`Keeping modified MCP server '${name}'`);
+    }
+  }
+  if (Object.keys(config.mcpServers).length === 0) {
+    delete config.mcpServers;
+  }
+  if (result.removed.length > 0) {
+    writeMCPConfig(configPath, config);
+  }
+  return result;
+}
+function serversEqual(a, b) {
+  return JSON.stringify(sortObject(a)) === JSON.stringify(sortObject(b));
+}
+function sortObject(obj) {
+  const sorted = {};
+  for (const key of Object.keys(obj).sort()) {
+    const value = obj[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      sorted[key] = sortObject(value);
+    } else {
+      sorted[key] = value;
+    }
+  }
+  return sorted;
+}
+var import_fs8, import_path9, import_os3;
+var init_mcp = __esm({
+  "src/core/mcp.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs8 = require("fs");
+    import_path9 = require("path");
+    import_os3 = require("os");
+  }
+});
+
 // ../../node_modules/color-name/index.js
 var require_color_name = __commonJS({
   "../../node_modules/color-name/index.js"(exports2, module2) {
@@ -14123,7 +15049,9 @@ function getPackageIcon2(format, subtype) {
     "tool": "\u{1F527}",
     "hook": "\u{1FA9D}",
     "workflow": "\u{1F504}",
-    "template": "\u{1F4C4}"
+    "template": "\u{1F4C4}",
+    "plugin": "\u{1F50C}",
+    "server": "\u{1F5A5}\uFE0F"
   };
   const formatIcons = {
     "claude": "\u{1F916}",
@@ -14181,7 +15109,9 @@ function getPackageLabel2(format, subtype) {
     "tool": "Tool",
     "hook": "Hook",
     "workflow": "Workflow",
-    "template": "Template"
+    "template": "Template",
+    "plugin": "Plugin",
+    "server": "Server"
   };
   const formatLabel = formatLabels[format];
   const subtypeLabel = subtypeLabels[subtype];
@@ -14194,7 +15124,7 @@ function findMainFile(files, format, subtype) {
   const nestedIndicator = getNestedIndicator(format, subtype);
   if (nestedIndicator) {
     const match = files.find((f) => {
-      const filename = import_path10.default.basename(f.name);
+      const filename = import_path11.default.basename(f.name);
       return filename.toLowerCase() === nestedIndicator.toLowerCase();
     });
     if (match) return match;
@@ -14203,7 +15133,7 @@ function findMainFile(files, format, subtype) {
   if (filePatterns) {
     for (const pattern of filePatterns) {
       for (const file of files) {
-        const filename = import_path10.default.basename(file.name);
+        const filename = import_path11.default.basename(file.name);
         if (pattern.startsWith("*")) {
           const extension = pattern.slice(1);
           if (filename.endsWith(extension)) {
@@ -14234,7 +15164,7 @@ function findMainFile(files, format, subtype) {
   ];
   for (const pattern of fallbackPatterns) {
     for (const file of files) {
-      const filename = import_path10.default.basename(file.name);
+      const filename = import_path11.default.basename(file.name);
       if (filename.toLowerCase() === pattern.toLowerCase()) {
         return file;
       }
@@ -14499,8 +15429,15 @@ This could indicate:
       try {
         switch (targetFormat2) {
           case "cursor":
-            const cursorResult = toCursor(canonicalPkg);
-            convertedContent = cursorResult.content;
+            if (effectiveSubtype === "hook") {
+              const cursorHooksResult = toCursorHooks(canonicalPkg, {
+                hookMappingStrategy: options.hookMapping || "auto"
+              });
+              convertedContent = cursorHooksResult.content;
+            } else {
+              const cursorResult = toCursor(canonicalPkg);
+              convertedContent = cursorResult.content;
+            }
             break;
           case "claude":
           case "claude.md":
@@ -14586,7 +15523,120 @@ This could indicate:
     let destDir = "";
     let fileCount = 0;
     let hookMetadata = void 0;
-    if (format === "claude-md") {
+    let pluginMetadata = void 0;
+    const isClaudePlugin = pkg.format === "claude" && pkg.subtype === "plugin";
+    if (isClaudePlugin) {
+      console.log(`   \u{1F50C} Installing Claude Plugin...`);
+      const pluginJsonFile = extractedFiles.find(
+        (f) => f.name === "plugin.json" || f.name === ".claude-plugin/plugin.json" || f.name.endsWith("/plugin.json")
+      );
+      let pluginConfig = {};
+      if (pluginJsonFile) {
+        try {
+          pluginConfig = parsePluginJson(pluginJsonFile.content);
+        } catch (err) {
+          console.log(`   \u26A0\uFE0F  Warning: Could not parse plugin.json: ${err}`);
+        }
+      }
+      const installedFiles = [];
+      const agentFiles = extractedFiles.filter(
+        (f) => f.name.startsWith("agents/") && f.name.endsWith(".md")
+      );
+      if (agentFiles.length > 0) {
+        await import_promises2.default.mkdir(".claude/agents", { recursive: true });
+        for (const file of agentFiles) {
+          const filename = import_path11.default.basename(file.name);
+          const destFile = `.claude/agents/${filename}`;
+          await saveFile(destFile, file.content);
+          installedFiles.push(destFile);
+        }
+        console.log(`   \u2713 Installed ${agentFiles.length} agents to .claude/agents/`);
+      }
+      const skillFiles = extractedFiles.filter(
+        (f) => f.name.startsWith("skills/") && (f.name.endsWith(".md") || f.name.includes("SKILL.md"))
+      );
+      if (skillFiles.length > 0) {
+        for (const file of skillFiles) {
+          const relativePath = file.name.replace(/^skills\//, "");
+          const destFile = `.claude/skills/${relativePath}`;
+          const destFileDir = import_path11.default.dirname(destFile);
+          await import_promises2.default.mkdir(destFileDir, { recursive: true });
+          await saveFile(destFile, file.content);
+          installedFiles.push(destFile);
+        }
+        console.log(`   \u2713 Installed ${skillFiles.length} skill files to .claude/skills/`);
+      }
+      const commandFiles = extractedFiles.filter(
+        (f) => f.name.startsWith("commands/") && f.name.endsWith(".md")
+      );
+      if (commandFiles.length > 0) {
+        await import_promises2.default.mkdir(".claude/commands", { recursive: true });
+        for (const file of commandFiles) {
+          const filename = import_path11.default.basename(file.name);
+          const destFile = `.claude/commands/${filename}`;
+          await saveFile(destFile, file.content);
+          installedFiles.push(destFile);
+        }
+        console.log(`   \u2713 Installed ${commandFiles.length} commands to .claude/commands/`);
+      }
+      if (pluginConfig.mcpServers && Object.keys(pluginConfig.mcpServers).length > 0) {
+        const mcpResult = mergeMCPServers(
+          pluginConfig.mcpServers,
+          options.global || false,
+          process.cwd()
+        );
+        if (mcpResult.added.length > 0) {
+          console.log(`   \u2713 Added MCP servers: ${mcpResult.added.join(", ")}`);
+        }
+        if (mcpResult.skipped.length > 0) {
+          console.log(`   \u26A0\uFE0F  Skipped existing MCP servers: ${mcpResult.skipped.join(", ")}`);
+        }
+        pluginMetadata = {
+          files: installedFiles,
+          mcpServers: pluginConfig.mcpServers,
+          mcpGlobal: options.global || false
+        };
+      } else {
+        pluginMetadata = {
+          files: installedFiles
+        };
+      }
+      destPath = ".claude/";
+      fileCount = installedFiles.length;
+    } else if (effectiveFormat === "mcp" && effectiveSubtype === "server") {
+      console.log(`   \u{1F527} Installing MCP Server...`);
+      const mcpServerFile = extractedFiles.find(
+        (f) => f.name === "mcp-server.json" || f.name.endsWith("/mcp-server.json") || f.name.endsWith(".json") && !f.name.includes("/")
+      );
+      if (!mcpServerFile) {
+        throw new Error("MCP server package must contain a JSON configuration file");
+      }
+      let mcpServerConfig;
+      try {
+        mcpServerConfig = parseMCPServerJson(mcpServerFile.content);
+      } catch (error2) {
+        throw new Error(`Failed to parse MCP server config: ${error2 instanceof Error ? error2.message : error2}`);
+      }
+      const mcpResult = mergeMCPServers(mcpServerConfig.mcpServers, options.global || false);
+      if (mcpResult.added.length > 0) {
+        const location = options.global ? "~/.claude/settings.json" : ".mcp.json";
+        console.log(`   \u2713 Added MCP servers to ${location}: ${mcpResult.added.join(", ")}`);
+      }
+      if (mcpResult.skipped.length > 0) {
+        console.log(`   \u26A0\uFE0F  Skipped existing MCP servers: ${mcpResult.skipped.join(", ")}`);
+      }
+      for (const warning of mcpResult.warnings) {
+        console.log(`   \u26A0\uFE0F  ${warning}`);
+      }
+      pluginMetadata = {
+        files: [],
+        // No files to track for MCP server packages
+        mcpServers: mcpServerConfig.mcpServers,
+        mcpGlobal: options.global || false
+      };
+      destPath = options.global ? "~/.claude/settings.json" : ".mcp.json";
+      fileCount = Object.keys(mcpServerConfig.mcpServers).length;
+    } else if (format === "claude-md") {
       if (extractedFiles.length !== 1) {
         throw new Error("CLAUDE.md format only supports single-file packages");
       }
@@ -14598,7 +15648,7 @@ This could indicate:
       destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
       if (locationOverride && effectiveFormat === "cursor") {
         const relativeDestDir = destDir.startsWith("./") ? destDir.slice(2) : destDir;
-        destDir = import_path10.default.join(locationOverride, relativeDestDir);
+        destDir = import_path11.default.join(locationOverride, relativeDestDir);
         console.log(`   \u{1F4C1} Installing Cursor package to custom location: ${destDir}`);
       }
       let mainFile = extractedFiles[0].content;
@@ -14619,7 +15669,7 @@ This could indicate:
           const manifestFilename = getManifestFilename(effectiveFormat);
           let targetPath = manifestFilename;
           if (locationOverride) {
-            targetPath = import_path10.default.join(locationOverride, `${manifestFilename.replace(".md", ".override.md")}`);
+            targetPath = import_path11.default.join(locationOverride, `${manifestFilename.replace(".md", ".override.md")}`);
             console.log(`   \u{1F4C1} Installing to custom location: ${targetPath}`);
           }
           destPath = targetPath;
@@ -14730,7 +15780,7 @@ This could indicate:
       destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
       if (locationOverride && effectiveFormat === "cursor") {
         const relativeDestDir = destDir.startsWith("./") ? destDir.slice(2) : destDir;
-        destDir = import_path10.default.join(locationOverride, relativeDestDir);
+        destDir = import_path11.default.join(locationOverride, relativeDestDir);
         console.log(`   \u{1F4C1} Installing Cursor package to custom location: ${destDir}`);
       }
       const packageName = stripAuthorNamespace2(packageId);
@@ -14856,7 +15906,9 @@ ${afterFrontmatter}`;
       fromCollection: options.fromCollection,
       hookMetadata,
       // Track hook installation metadata for uninstall
-      progressiveDisclosure: progressiveDisclosureMetadata
+      progressiveDisclosure: progressiveDisclosureMetadata,
+      pluginMetadata
+      // Track plugin installation metadata for uninstall
     });
     setPackageIntegrity(updatedLockfile, packageId, tarball, effectiveFormat);
     await writeLockfile(updatedLockfile);
@@ -14878,6 +15930,16 @@ ${afterFrontmatter}`;
       console.log(`   \u{1F4A1} The skill is available but not loaded into context by default`);
       console.log(`   \u26A1 Your AI agent will activate this skill automatically when relevant based on its description`);
     }
+    if (pluginMetadata) {
+      console.log(`
+\u{1F50C} Plugin installation complete`);
+      console.log(`   \u{1F4E6} Installed ${pluginMetadata.files.length} file(s)`);
+      if (pluginMetadata.mcpServers && Object.keys(pluginMetadata.mcpServers).length > 0) {
+        const serverCount = Object.keys(pluginMetadata.mcpServers).length;
+        const location = pluginMetadata.mcpGlobal ? "~/.claude/settings.json" : ".mcp.json";
+        console.log(`   \u{1F527} Configured ${serverCount} MCP server(s) in ${location}`);
+      }
+    }
     console.log(`
 \u{1F4A1} This package has been downloaded ${newDownloadCount.toLocaleString()} times`);
     success = true;
@@ -14905,9 +15967,9 @@ ${afterFrontmatter}`;
   }
 }
 function isPathSafe(targetDir, filePath) {
-  const resolvedPath = import_path10.default.resolve(targetDir, filePath);
-  const resolvedTarget = import_path10.default.resolve(targetDir);
-  return resolvedPath.startsWith(resolvedTarget + import_path10.default.sep) || resolvedPath === resolvedTarget;
+  const resolvedPath = import_path11.default.resolve(targetDir, filePath);
+  const resolvedTarget = import_path11.default.resolve(targetDir);
+  return resolvedPath.startsWith(resolvedTarget + import_path11.default.sep) || resolvedPath === resolvedTarget;
 }
 function hasUnsafePathPatterns(filePath) {
   if (filePath.includes("..")) return true;
@@ -14931,7 +15993,7 @@ async function extractTarball(tarball, packageId) {
   } catch (error) {
     throw new CLIError(`Package decompression failed: ${error.message}`);
   }
-  const tmpDir = await import_promises2.default.mkdtemp(import_path10.default.join(import_os3.default.tmpdir(), "prpm-"));
+  const tmpDir = await import_promises2.default.mkdtemp(import_path11.default.join(import_os4.default.tmpdir(), "prpm-"));
   const cleanup = async () => {
     try {
       await import_promises2.default.rm(tmpDir, { recursive: true, force: true });
@@ -15001,7 +16063,7 @@ async function collectExtractedFiles(rootDir, excludedNames, fs14) {
     if (!currentDir) continue;
     const entries = await fs14.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path10.default.join(currentDir, entry.name);
+      const fullPath = import_path11.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         dirs.push(fullPath);
         continue;
@@ -15013,7 +16075,7 @@ async function collectExtractedFiles(rootDir, excludedNames, fs14) {
         continue;
       }
       const content = await fs14.readFile(fullPath, "utf-8");
-      const relativePath = import_path10.default.relative(rootDir, fullPath).split(import_path10.default.sep).join("/");
+      const relativePath = import_path11.default.relative(rootDir, fullPath).split(import_path11.default.sep).join("/");
       files.push({
         name: relativePath,
         content
@@ -15047,11 +16109,11 @@ async function installFromLockfile(options) {
         console.log(`  Installing ${displayName}...`);
         let locationOverride = options.location;
         if (!locationOverride && lockEntry.format === "agents.md" && lockEntry.installedPath) {
-          const baseName = import_path10.default.basename(lockEntry.installedPath);
+          const baseName = import_path11.default.basename(lockEntry.installedPath);
           if (baseName === "AGENTS.override.md") {
-            locationOverride = import_path10.default.dirname(lockEntry.installedPath);
+            locationOverride = import_path11.default.dirname(lockEntry.installedPath);
           } else if (baseName !== "AGENTS.md") {
-            locationOverride = import_path10.default.dirname(lockEntry.installedPath);
+            locationOverride = import_path11.default.dirname(lockEntry.installedPath);
           }
         }
         const manifestFile = (_a = lockEntry.progressiveDisclosure) == null ? void 0 : _a.manifestPath;
@@ -15063,7 +16125,8 @@ async function installFromLockfile(options) {
           force: true,
           // Force reinstall when installing from lockfile
           location: locationOverride,
-          manifestFile
+          manifestFile,
+          hookMapping: options.hookMapping
         });
         successCount++;
       } catch (error) {
@@ -15094,7 +16157,7 @@ async function installFromLockfile(options) {
 }
 function createInstallCommand() {
   const command = new import_commander11.Command("install");
-  command.description("Install a package from the registry, or install all packages from prpm.lock if no package specified").argument("[package]", "Package to install (e.g., react-rules or react-rules@1.2.0). If omitted, installs all packages from prpm.lock").option("--version <version>", "Specific version to install").option("--as <format>", `Convert and install in specific format (${import_types.FORMATS.join(", ")})`).option("--format <format>", "Alias for --as").option("--location <path>", "Custom location for installed files (Agents.md or nested Cursor rules)").option("--subtype <subtype>", "Specify subtype when converting (skill, agent, rule, etc.)").option("--frozen-lockfile", "Fail if lock file needs to be updated (for CI)").option("--no-append", "Skip adding skill to manifest file (skill files only)").option("--manifest-file <filename>", "Custom manifest filename for progressive disclosure").action(async (packageSpec, options) => {
+  command.description("Install a package from the registry, or install all packages from prpm.lock if no package specified").argument("[package]", "Package to install (e.g., react-rules or react-rules@1.2.0). If omitted, installs all packages from prpm.lock").option("--version <version>", "Specific version to install").option("--as <format>", `Convert and install in specific format (${import_types.FORMATS.join(", ")})`).option("--format <format>", "Alias for --as").option("--location <path>", "Custom location for installed files (Agents.md or nested Cursor rules)").option("--subtype <subtype>", "Specify subtype when converting (skill, agent, rule, etc.)").option("--hook-mapping <strategy>", "Hook mapping strategy: auto (default), strict, skip", "auto").option("--frozen-lockfile", "Fail if lock file needs to be updated (for CI)").option("--no-append", "Skip adding skill to manifest file (skill files only)").option("--manifest-file <filename>", "Custom manifest filename for progressive disclosure").action(async (packageSpec, options) => {
     const convertTo = options.format || options.as;
     const validFormats = import_types.FORMATS;
     if (convertTo && !validFormats.includes(convertTo)) {
@@ -15109,12 +16172,20 @@ function createInstallCommand() {
    prpm install my-package --format gemini.md # Convert to Gemini format
    prpm install my-package                   # Install in native format`, 1);
     }
+    if (options.hookMapping && !isValidHookMappingStrategy(options.hookMapping)) {
+      throw new CLIError(
+        `Invalid hook mapping strategy: ${options.hookMapping}
+
+Valid strategies: ${VALID_HOOK_MAPPING_STRATEGIES.join(", ")}`
+      );
+    }
     if (!packageSpec) {
       await installFromLockfile({
         as: convertTo,
         subtype: options.subtype,
         frozenLockfile: options.frozenLockfile,
-        location: options.location
+        location: options.location,
+        hookMapping: options.hookMapping
       });
       return;
     }
@@ -15125,12 +16196,13 @@ function createInstallCommand() {
       frozenLockfile: options.frozenLockfile,
       location: options.location,
       noAppend: options.noAppend,
-      manifestFile: options.manifestFile
+      manifestFile: options.manifestFile,
+      hookMapping: options.hookMapping
     });
   });
   return command;
 }
-var import_commander11, import_chalk, import_registry_client5, import_stream, import_promises, tar, import_path10, import_zlib, import_promises2, import_os3, import_semver;
+var import_commander11, import_chalk, import_registry_client5, import_stream, import_promises, tar, import_path11, import_zlib, import_promises2, import_os4, import_semver;
 var init_install = __esm({
   "src/commands/install.ts"() {
     "use strict";
@@ -15147,16 +16219,17 @@ var init_install = __esm({
     tar = __toESM(require("tar"));
     init_errors();
     init_prompts();
-    import_path10 = __toESM(require("path"));
+    import_path11 = __toESM(require("path"));
     import_zlib = __toESM(require("zlib"));
     import_promises2 = __toESM(require("fs/promises"));
-    import_os3 = __toESM(require("os"));
+    import_os4 = __toESM(require("os"));
     import_semver = __toESM(require("semver"));
     init_collections();
     init_lockfile();
     init_cursor_config();
     init_claude_config();
     init_agents_md_progressive();
+    init_mcp();
     init_dist();
   }
 });
@@ -15185,7 +16258,7 @@ function buildScanConfigs() {
 }
 async function extractMetadata2(filePath) {
   try {
-    const content = await import_fs12.promises.readFile(filePath, "utf-8");
+    const content = await import_fs13.promises.readFile(filePath, "utf-8");
     const metadata = {};
     const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
     if (frontmatterMatch) {
@@ -15238,7 +16311,7 @@ function matchesPattern(filename, patterns) {
 }
 async function directoryExists2(dirPath) {
   try {
-    const stats = await import_fs12.promises.stat(dirPath);
+    const stats = await import_fs13.promises.stat(dirPath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -15246,7 +16319,7 @@ async function directoryExists2(dirPath) {
 }
 async function fileExists2(filePath) {
   try {
-    await import_fs12.promises.access(filePath);
+    await import_fs13.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -15254,21 +16327,21 @@ async function fileExists2(filePath) {
 }
 async function scanDirectory2(config, cwd) {
   const packages = [];
-  const fullDir = import_path16.default.join(cwd, config.directory);
+  const fullDir = import_path17.default.join(cwd, config.directory);
   if (!await directoryExists2(fullDir)) {
     return packages;
   }
-  const entries = await import_fs12.promises.readdir(fullDir, { withFileTypes: true });
+  const entries = await import_fs13.promises.readdir(fullDir, { withFileTypes: true });
   if (config.nested) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const packageDir = import_path16.default.join(fullDir, entry.name);
+      const packageDir = import_path17.default.join(fullDir, entry.name);
       if (config.nestedIndicator) {
-        const indicatorPath = import_path16.default.join(packageDir, config.nestedIndicator);
+        const indicatorPath = import_path17.default.join(packageDir, config.nestedIndicator);
         if (!await fileExists2(indicatorPath)) continue;
         const packageFiles = await collectPackageFiles(packageDir, config.directory, entry.name);
         const metadata = await extractMetadata2(indicatorPath);
-        const relativePath = import_path16.default.join(config.directory, entry.name, config.nestedIndicator);
+        const relativePath = import_path17.default.join(config.directory, entry.name, config.nestedIndicator);
         packages.push({
           name: metadata.name || filenameToPackageName(entry.name),
           format: config.format,
@@ -15279,12 +16352,12 @@ async function scanDirectory2(config, cwd) {
           primaryFile: relativePath
         });
       } else {
-        const subEntries = await import_fs12.promises.readdir(packageDir, { withFileTypes: true });
+        const subEntries = await import_fs13.promises.readdir(packageDir, { withFileTypes: true });
         for (const subEntry of subEntries) {
           if (!subEntry.isFile()) continue;
           if (!matchesPattern(subEntry.name, config.patterns)) continue;
-          const filePath = import_path16.default.join(packageDir, subEntry.name);
-          const relativePath = import_path16.default.join(config.directory, entry.name, subEntry.name);
+          const filePath = import_path17.default.join(packageDir, subEntry.name);
+          const relativePath = import_path17.default.join(config.directory, entry.name, subEntry.name);
           const metadata = await extractMetadata2(filePath);
           packages.push({
             name: metadata.name || filenameToPackageName(entry.name),
@@ -15302,8 +16375,8 @@ async function scanDirectory2(config, cwd) {
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (!matchesPattern(entry.name, config.patterns)) continue;
-      const filePath = import_path16.default.join(fullDir, entry.name);
-      const relativePath = import_path16.default.join(config.directory, entry.name);
+      const filePath = import_path17.default.join(fullDir, entry.name);
+      const relativePath = import_path17.default.join(config.directory, entry.name);
       const metadata = await extractMetadata2(filePath);
       packages.push({
         name: metadata.name || filenameToPackageName(entry.name),
@@ -15321,24 +16394,24 @@ async function scanDirectory2(config, cwd) {
 async function collectPackageFiles(packageDir, baseDir, packageName) {
   const files = [];
   async function walkDir(dir, relativeBase) {
-    const entries = await import_fs12.promises.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs13.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path16.default.join(dir, entry.name);
-      const relativePath = import_path16.default.join(relativeBase, entry.name);
+      const fullPath = import_path17.default.join(dir, entry.name);
+      const relativePath = import_path17.default.join(relativeBase, entry.name);
       if (entry.isDirectory()) {
         if (["node_modules", "dist", ".git", "coverage"].includes(entry.name)) {
           continue;
         }
         await walkDir(fullPath, relativePath);
       } else if (entry.isFile()) {
-        const ext = import_path16.default.extname(entry.name).toLowerCase();
+        const ext = import_path17.default.extname(entry.name).toLowerCase();
         if ([".md", ".json", ".js", ".ts", ".toml"].includes(ext)) {
           files.push(relativePath);
         }
       }
     }
   }
-  await walkDir(packageDir, import_path16.default.join(baseDir, packageName));
+  await walkDir(packageDir, import_path17.default.join(baseDir, packageName));
   return files;
 }
 function buildRootManifestFiles() {
@@ -15360,7 +16433,7 @@ async function scanForPackages(cwd = process.cwd()) {
     allPackages.push(...packages);
   }
   for (const { file, format } of ROOT_MANIFEST_FILES) {
-    const filePath = import_path16.default.join(cwd, file);
+    const filePath = import_path17.default.join(cwd, file);
     if (await fileExists2(filePath)) {
       const metadata = await extractMetadata2(filePath);
       allPackages.push({
@@ -15374,7 +16447,7 @@ async function scanForPackages(cwd = process.cwd()) {
       });
     }
   }
-  const copilotInstructionsPath = import_path16.default.join(cwd, ".github/copilot-instructions.md");
+  const copilotInstructionsPath = import_path17.default.join(cwd, ".github/copilot-instructions.md");
   if (await fileExists2(copilotInstructionsPath)) {
     const metadata = await extractMetadata2(copilotInstructionsPath);
     allPackages.push({
@@ -15389,13 +16462,13 @@ async function scanForPackages(cwd = process.cwd()) {
   }
   return allPackages;
 }
-var import_fs12, import_path16, SCAN_CONFIGS, ROOT_MANIFEST_FILES;
+var import_fs13, import_path17, SCAN_CONFIGS, ROOT_MANIFEST_FILES;
 var init_package_scanner = __esm({
   "src/core/package-scanner.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs12 = require("fs");
-    import_path16 = __toESM(require("path"));
+    import_fs13 = require("fs");
+    import_path17 = __toESM(require("path"));
     init_dist();
     SCAN_CONFIGS = buildScanConfigs();
     ROOT_MANIFEST_FILES = buildRootManifestFiles();
@@ -15405,8 +16478,8 @@ var init_package_scanner = __esm({
 // src/core/package-reconciler.ts
 async function readManifest(cwd = process.cwd()) {
   try {
-    const manifestPath = import_path17.default.join(cwd, "prpm.json");
-    const content = await import_fs13.promises.readFile(manifestPath, "utf-8");
+    const manifestPath = import_path18.default.join(cwd, "prpm.json");
+    const content = await import_fs14.promises.readFile(manifestPath, "utf-8");
     const raw = JSON.parse(content);
     if ("packages" in raw && Array.isArray(raw.packages)) {
       return {
@@ -15432,7 +16505,7 @@ async function readManifest(cwd = process.cwd()) {
 }
 async function fileExists3(filePath) {
   try {
-    await import_fs13.promises.access(filePath);
+    await import_fs14.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -15488,7 +16561,7 @@ async function reconcilePackages(detected, manifest, cwd = process.cwd()) {
     const manifestPkg = manifest[mi];
     let anyFileExists = false;
     for (const file of manifestPkg.files) {
-      const fullPath = import_path17.default.join(cwd, file);
+      const fullPath = import_path18.default.join(cwd, file);
       if (await fileExists3(fullPath)) {
         anyFileExists = true;
         break;
@@ -15557,7 +16630,7 @@ function createManifestFromDetected(packages, defaults) {
       files: pkg.files
     };
   }
-  const projectName = import_path17.default.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const projectName = import_path18.default.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
   return {
     name: `${projectName}-packages`,
     version: "1.0.0",
@@ -15568,13 +16641,13 @@ function createManifestFromDetected(packages, defaults) {
     packages: packages.map(detectedToManifest)
   };
 }
-var import_fs13, import_path17;
+var import_fs14, import_path18;
 var init_package_reconciler = __esm({
   "src/core/package-reconciler.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs13 = require("fs");
-    import_path17 = __toESM(require("path"));
+    import_fs14 = require("fs");
+    import_path18 = __toESM(require("path"));
   }
 });
 
@@ -15689,12 +16762,12 @@ function getDefaultAuthor() {
 async function createExampleFiles(format, files, packageName) {
   const templates = EXAMPLE_TEMPLATES[format] || {};
   for (const file of files) {
-    const filePath = (0, import_path18.join)(process.cwd(), file);
-    const dirPath = (0, import_path18.join)(filePath, "..");
-    if (!(0, import_fs14.existsSync)(dirPath)) {
+    const filePath = (0, import_path19.join)(process.cwd(), file);
+    const dirPath = (0, import_path19.join)(filePath, "..");
+    if (!(0, import_fs15.existsSync)(dirPath)) {
       await (0, import_promises8.mkdir)(dirPath, { recursive: true });
     }
-    if ((0, import_fs14.existsSync)(filePath)) {
+    if ((0, import_fs15.existsSync)(filePath)) {
       console.log(`  Skipping ${file} (already exists)`);
       continue;
     }
@@ -15708,8 +16781,8 @@ Add your content here.
   }
 }
 async function createReadme(config) {
-  const readmePath = (0, import_path18.join)(process.cwd(), "README.md");
-  if ((0, import_fs14.existsSync)(readmePath)) {
+  const readmePath = (0, import_path19.join)(process.cwd(), "README.md");
+  if ((0, import_fs15.existsSync)(readmePath)) {
     console.log("  Skipping README.md (already exists)");
     return;
   }
@@ -15818,8 +16891,8 @@ async function reviewMissingPackage(rl, pkg, index, total) {
   return await confirm(rl, "\n  Remove from prpm.json?", true);
 }
 async function smartInit(options) {
-  const manifestPath = (0, import_path18.join)(process.cwd(), "prpm.json");
-  const hasManifest = (0, import_fs14.existsSync)(manifestPath);
+  const manifestPath = (0, import_path19.join)(process.cwd(), "prpm.json");
+  const hasManifest = (0, import_fs15.existsSync)(manifestPath);
   console.log("\nScanning for packages...\n");
   const detected = await scanForPackages();
   const existingManifest = hasManifest ? await readManifest() : null;
@@ -15969,8 +17042,8 @@ Create multi-package prpm.json with these ${detected.length} packages?` : "\nCre
   }
 }
 async function classicInit(options) {
-  const manifestPath = (0, import_path18.join)(process.cwd(), "prpm.json");
-  if ((0, import_fs14.existsSync)(manifestPath) && !options.force) {
+  const manifestPath = (0, import_path19.join)(process.cwd(), "prpm.json");
+  if ((0, import_fs15.existsSync)(manifestPath) && !options.force) {
     throw new Error(
       "prpm.json already exists. Use --force to overwrite, or run this command in a different directory."
     );
@@ -16228,7 +17301,7 @@ async function scanMode(directories, options) {
     console.log("\u{1F50D} Dry run - no changes made\n");
     return;
   }
-  const prpmJsonPath = options.output || (0, import_path18.join)(process.cwd(), "prpm.json");
+  const prpmJsonPath = options.output || (0, import_path19.join)(process.cwd(), "prpm.json");
   let manifest;
   if (options.append) {
     try {
@@ -16330,15 +17403,15 @@ function createInitCommand() {
   });
   return command;
 }
-var import_commander12, import_promises8, import_path18, import_fs14, readline4, import_process, FORMAT_EXAMPLES, EXAMPLE_TEMPLATES;
+var import_commander12, import_promises8, import_path19, import_fs15, readline4, import_process, FORMAT_EXAMPLES, EXAMPLE_TEMPLATES;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_cjs_shims();
     import_commander12 = require("commander");
     import_promises8 = require("fs/promises");
-    import_path18 = require("path");
-    import_fs14 = require("fs");
+    import_path19 = require("path");
+    import_fs15 = require("fs");
     readline4 = __toESM(require("readline/promises"));
     import_process = require("process");
     init_types();
@@ -16355,6 +17428,16 @@ var init_init = __esm({
         description: "Claude AI skills and agents",
         files: [".claude/skills/example-skill/SKILL.md", "README.md"]
       },
+      "claude-plugin": {
+        description: "Claude Code plugins with agents, skills, commands, and MCP servers",
+        files: [
+          ".claude-plugin/plugin.json",
+          ".claude-plugin/agents/example.md",
+          ".claude-plugin/skills/example/SKILL.md",
+          ".claude-plugin/commands/example.md",
+          "README.md"
+        ]
+      },
       continue: {
         description: "Continue AI coding rules",
         files: [".continuerules", "README.md"]
@@ -16389,8 +17472,8 @@ var init_init = __esm({
         files: ["prompts/example.md", "README.md"]
       },
       mcp: {
-        description: "Model Context Protocol",
-        files: ["mcp.json", "README.md"]
+        description: "Model Context Protocol servers",
+        files: ["mcp-server.json", "README.md"]
       }
     };
     EXAMPLE_TEMPLATES = {
@@ -16434,6 +17517,69 @@ Explain when this skill should be invoked.
 ## Instructions
 
 Provide detailed instructions for the AI to follow when using this skill.
+`
+      },
+      "claude-plugin": {
+        ".claude-plugin/plugin.json": `{
+  "name": "Example Plugin",
+  "description": "An example Claude plugin - replace with your actual plugin",
+  "version": "1.0.0",
+  "author": "Your Name",
+  "mcpServers": {
+    "example-server": {
+      "command": "npx",
+      "args": ["-y", "@example/mcp-server"],
+      "env": {}
+    }
+  }
+}`,
+        ".claude-plugin/agents/example.md": `---
+name: example-agent
+description: Example agent - replace with your actual agent
+---
+
+# Example Agent
+
+This is an example Claude agent. Replace this content with your actual agent definition.
+
+## Role
+
+Describe the agent's role and responsibilities.
+
+## Instructions
+
+Provide detailed instructions for the agent to follow.
+`,
+        ".claude-plugin/skills/example/SKILL.md": `---
+name: example-skill
+description: Example skill - replace with your actual skill
+tags: example, template
+---
+
+# Example Skill
+
+This is an example skill bundled with the plugin.
+
+## What this skill does
+
+Describe what this skill helps the AI accomplish.
+
+## Instructions
+
+Provide detailed instructions for the AI to follow when using this skill.
+`,
+        ".claude-plugin/commands/example.md": `---
+name: example-command
+description: Example slash command - replace with your actual command
+---
+
+# Example Command
+
+This is an example slash command. It will be available as /example-command in Claude Code.
+
+## Usage
+
+Describe how to use this command.
 `
       },
       windsurf: {
@@ -16623,6 +17769,23 @@ Provide clear instructions for the AI.
 
 Include examples if helpful.
 `
+      },
+      mcp: {
+        "mcp-server.json": `{
+  "name": "Example MCP Server",
+  "description": "An example MCP server package - replace with your actual server configuration",
+  "version": "1.0.0",
+  "author": "Your Name",
+  "mcpServers": {
+    "example-server": {
+      "command": "npx",
+      "args": ["-y", "@example/mcp-server"],
+      "env": {
+        "API_KEY": "\${API_KEY}"
+      }
+    }
+  }
+}`
       }
     };
   }
@@ -16631,8 +17794,8 @@ Include examples if helpful.
 // src/index.ts
 init_cjs_shims();
 var import_commander29 = require("commander");
-var import_fs18 = require("fs");
-var import_path22 = require("path");
+var import_fs19 = require("fs");
+var import_path23 = require("path");
 
 // src/commands/list.ts
 init_cjs_shims();
@@ -16792,9 +17955,10 @@ var import_commander2 = require("commander");
 init_lockfile();
 init_filesystem();
 init_types();
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 init_errors();
 init_agents_md_progressive();
+init_mcp();
 var readline = __toESM(require("readline"));
 async function promptForFormat(packageId, formats) {
   console.log(`
@@ -16890,10 +18054,43 @@ async function handleUninstall(name, options = {}) {
           }
         }
       }
+      if (pkg.pluginMetadata) {
+        const isMCPServerOnly = pkg.pluginMetadata.files.length === 0 && pkg.pluginMetadata.mcpServers;
+        console.log(isMCPServerOnly ? `   \u{1F527} Uninstalling MCP server...` : `   \u{1F50C} Uninstalling Claude plugin...`);
+        const { files, mcpServers, mcpGlobal } = pkg.pluginMetadata;
+        let filesRemoved = 0;
+        for (const filePath of files) {
+          try {
+            await import_fs9.promises.unlink(filePath);
+            filesRemoved++;
+            console.log(`   \u{1F5D1}\uFE0F  Deleted: ${filePath}`);
+          } catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT") {
+              console.warn(`   \u26A0\uFE0F  Failed to delete ${filePath}: ${err.message}`);
+            }
+          }
+        }
+        if (filesRemoved > 0) {
+          console.log(`   \u{1F4E6} Removed ${filesRemoved} file(s)`);
+        }
+        if (mcpServers && Object.keys(mcpServers).length > 0) {
+          const mcpResult = removeMCPServers(mcpServers, mcpGlobal || false);
+          if (mcpResult.removed.length > 0) {
+            const location = mcpGlobal ? "~/.claude/settings.json" : ".mcp.json";
+            console.log(`   \u{1F527} Removed ${mcpResult.removed.length} MCP server(s) from ${location}`);
+          }
+          for (const warning of mcpResult.warnings) {
+            console.log(`   \u26A0\uFE0F  ${warning}`);
+          }
+        }
+        console.log(`\u2705 Successfully uninstalled ${name}${formatDisplay}`);
+        continue;
+      }
       if (pkg.format === "claude" && pkg.subtype === "hook" && pkg.hookMetadata) {
         const settingsPath = pkg.installedPath || ".claude/settings.json";
         try {
-          const settingsContent = await import_fs8.promises.readFile(settingsPath, "utf-8");
+          const settingsContent = await import_fs9.promises.readFile(settingsPath, "utf-8");
           const settings = JSON.parse(settingsContent);
           if (settings.hooks) {
             let removedCount = 0;
@@ -16910,7 +18107,7 @@ async function handleUninstall(name, options = {}) {
                 }
               }
             }
-            await import_fs8.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+            await import_fs9.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
             console.log(`   \u{1FA9D} Removed ${removedCount} hook(s) from ${settingsPath}`);
           }
         } catch (error) {
@@ -16935,12 +18132,12 @@ async function handleUninstall(name, options = {}) {
         throw new CLIError(`Cannot uninstall ${name}: installation path unknown`, 1);
       }
       try {
-        const stats = await import_fs8.promises.stat(targetPath);
+        const stats = await import_fs9.promises.stat(targetPath);
         if (stats.isDirectory()) {
-          await import_fs8.promises.rm(targetPath, { recursive: true, force: true });
+          await import_fs9.promises.rm(targetPath, { recursive: true, force: true });
           console.log(`   \u{1F5D1}\uFE0F  Deleted directory: ${targetPath}`);
         } else if (stats.isFile()) {
-          await import_fs8.promises.unlink(targetPath);
+          await import_fs9.promises.unlink(targetPath);
           console.log(`   \u{1F5D1}\uFE0F  Deleted file: ${targetPath}`);
         }
       } catch (error) {
@@ -16969,17 +18166,17 @@ function createUninstallCommand() {
 // src/commands/index.ts
 init_cjs_shims();
 var import_commander3 = require("commander");
-var import_fs9 = require("fs");
-var import_path9 = __toESM(require("path"));
+var import_fs10 = require("fs");
+var import_path10 = __toESM(require("path"));
 init_lockfile();
 init_filesystem();
 init_errors();
 async function scanDirectory(dirPath, format, subtype) {
   try {
-    const files = await import_fs9.promises.readdir(dirPath, { withFileTypes: true });
+    const files = await import_fs10.promises.readdir(dirPath, { withFileTypes: true });
     const results = [];
     for (const file of files) {
-      const fullPath = import_path9.default.join(dirPath, file.name);
+      const fullPath = import_path10.default.join(dirPath, file.name);
       if (file.isFile()) {
         const id = generateId(file.name);
         results.push({
@@ -16992,11 +18189,11 @@ async function scanDirectory(dirPath, format, subtype) {
         const isCursorAgent = format === "cursor" && subtype === "agent";
         if (isClaudeType || isCursorAgent) {
           try {
-            const subFiles = await import_fs9.promises.readdir(fullPath, { withFileTypes: true });
+            const subFiles = await import_fs10.promises.readdir(fullPath, { withFileTypes: true });
             for (const subFile of subFiles) {
               const isValidFile = subFile.isFile() && (subFile.name === "SKILL.md" || subFile.name === "AGENT.md" || subFile.name === "skill.md" || subFile.name === "agent.md");
               if (isValidFile) {
-                const subFilePath = import_path9.default.join(fullPath, subFile.name);
+                const subFilePath = import_path10.default.join(fullPath, subFile.name);
                 const id = file.name;
                 results.push({
                   filePath: subFilePath,
@@ -17058,7 +18255,7 @@ async function handleIndex(options = {}) {
             id: file.id,
             version: "0.0.0",
             // Local files don't have versions
-            tarballUrl: `file://${import_path9.default.resolve(file.filePath)}`,
+            tarballUrl: `file://${import_path10.default.resolve(file.filePath)}`,
             format: dir.format,
             subtype: dir.subtype
           });
@@ -17316,7 +18513,9 @@ function getPackageIcon(format, subtype) {
     "tool": "\u{1F527}",
     "hook": "\u{1FA9D}",
     "workflow": "\u{1F504}",
-    "template": "\u{1F4C4}"
+    "template": "\u{1F4C4}",
+    "plugin": "\u{1F50C}",
+    "server": "\u{1F5A5}\uFE0F"
   };
   const formatIcons = {
     "claude": "\u{1F916}",
@@ -17374,7 +18573,9 @@ function getPackageLabel(format, subtype) {
     "tool": "Tool",
     "hook": "Hook",
     "workflow": "Workflow",
-    "template": "Template"
+    "template": "Template",
+    "plugin": "Plugin",
+    "server": "Server"
   };
   const formatLabel = formatLabels[format];
   const subtypeLabel = subtypeLabels[subtype];
@@ -17885,8 +19086,8 @@ init_install();
 init_cjs_shims();
 var import_commander13 = require("commander");
 var import_promises9 = require("fs/promises");
-var import_path19 = require("path");
-var import_fs15 = require("fs");
+var import_path20 = require("path");
+var import_fs16 = require("fs");
 var import_registry_client6 = require("@pr-pm/registry-client");
 init_user_config();
 init_telemetry();
@@ -17895,8 +19096,8 @@ init_errors();
 // src/utils/license-extractor.ts
 init_cjs_shims();
 var import_promises3 = require("fs/promises");
-var import_path11 = require("path");
-var import_fs10 = require("fs");
+var import_path12 = require("path");
+var import_fs11 = require("fs");
 var LICENSE_FILE_PATTERNS = [
   "LICENSE",
   "LICENSE.md",
@@ -17945,9 +19146,9 @@ function generateLicenseUrl(repositoryUrl, fileName) {
 async function extractLicenseInfo(repositoryUrl) {
   const cwd = process.cwd();
   for (const fileName of LICENSE_FILE_PATTERNS) {
-    const filePath = (0, import_path11.join)(cwd, fileName);
+    const filePath = (0, import_path12.join)(cwd, fileName);
     try {
-      await (0, import_promises3.access)(filePath, import_fs10.constants.R_OK);
+      await (0, import_promises3.access)(filePath, import_fs11.constants.R_OK);
       const text = await (0, import_promises3.readFile)(filePath, "utf-8");
       const type2 = detectLicenseType(text);
       const url = generateLicenseUrl(repositoryUrl, fileName);
@@ -17981,7 +19182,7 @@ function validateLicenseInfo(licenseInfo, packageName) {
 // src/utils/snippet-extractor.ts
 init_cjs_shims();
 var import_promises4 = require("fs/promises");
-var import_path12 = require("path");
+var import_path13 = require("path");
 var MAX_SNIPPET_LENGTH = 2e3;
 async function extractSnippet(manifest) {
   const cwd = process.cwd();
@@ -17997,7 +19198,7 @@ async function extractSnippet(manifest) {
       const firstFile = manifest.files[0];
       fileName = typeof firstFile === "string" ? firstFile : firstFile.path;
     }
-    const fullPath = (0, import_path12.join)(cwd, fileName);
+    const fullPath = (0, import_path13.join)(cwd, fileName);
     const stats = await (0, import_promises4.stat)(fullPath);
     if (stats.isDirectory()) {
       console.warn(`\u26A0\uFE0F  Skipping snippet extraction: "${fullPath}" is a directory`);
@@ -18105,7 +19306,7 @@ function getFormatType(format) {
     "windsurf": "windsurf",
     "copilot": "copilot",
     "kiro": "kiro",
-    "agents-md": "agents-md",
+    "agents.md": "agents.md",
     "canonical": "canonical"
   };
   return formatMap[format] || null;
@@ -18201,7 +19402,7 @@ async function validatePackageFiles(manifest) {
       return filePath.includes(".continue/") && filePath.endsWith(".json");
     } else if (formatType === "windsurf") {
       return filePath.includes(".windsurf/rules");
-    } else if (formatType === "agents-md") {
+    } else if (formatType === "agents.md") {
       return filePath === "agents.md";
     } else if (formatType === "kiro") {
       return filePath.endsWith(".md") || filePath.endsWith(".json");
@@ -18217,7 +19418,7 @@ async function validatePackageFiles(manifest) {
         const result = await validateMarkdownFile(filePath, formatType);
         errors.push(...result.errors);
         warnings.push(...result.warnings);
-      } else if (formatType === "agents-md") {
+      } else if (formatType === "agents.md") {
         const result = await validateMarkdownFile(filePath, formatType);
         errors.push(...result.errors);
         warnings.push(...result.warnings);
@@ -18258,7 +19459,7 @@ async function validatePackageFiles(manifest) {
 // src/utils/manifest-loader.ts
 init_cjs_shims();
 var import_promises6 = require("fs/promises");
-var import_path14 = require("path");
+var import_path15 = require("path");
 
 // src/core/marketplace-converter.ts
 init_cjs_shims();
@@ -18424,19 +19625,19 @@ function validateMarketplaceJson(data) {
 init_cjs_shims();
 var import_ajv2 = __toESM(require("ajv"));
 var import_ajv_formats2 = __toESM(require("ajv-formats"));
-var import_fs11 = require("fs");
-var import_path13 = require("path");
+var import_fs12 = require("fs");
+var import_path14 = require("path");
 var schema2;
 var schemaCandidates = [
   // Source file layout (src/core → ../../schemas)
-  (0, import_path13.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
+  (0, import_path14.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
   // Bundled layout (dist/index.js → ../schemas)
-  (0, import_path13.join)(__dirname, "../schemas/prpm-manifest.schema.json")
+  (0, import_path14.join)(__dirname, "../schemas/prpm-manifest.schema.json")
 ];
 for (const candidate of schemaCandidates) {
   try {
-    if ((0, import_fs11.existsSync)(candidate)) {
-      schema2 = JSON.parse((0, import_fs11.readFileSync)(candidate, "utf-8"));
+    if ((0, import_fs12.existsSync)(candidate)) {
+      schema2 = JSON.parse((0, import_fs12.readFileSync)(candidate, "utf-8"));
       break;
     }
   } catch {
@@ -18490,7 +19691,7 @@ function getManifestSchema() {
 
 // src/utils/manifest-loader.ts
 async function findAndLoadManifests() {
-  const prpmJsonPath = (0, import_path14.join)(process.cwd(), "prpm.json");
+  const prpmJsonPath = (0, import_path15.join)(process.cwd(), "prpm.json");
   let prpmJsonExists = false;
   try {
     const content = await (0, import_promises6.readFile)(prpmJsonPath, "utf-8");
@@ -18551,7 +19752,7 @@ async function findAndLoadManifests() {
       throw error;
     }
   }
-  const marketplaceJsonPath = (0, import_path14.join)(
+  const marketplaceJsonPath = (0, import_path15.join)(
     process.cwd(),
     ".claude",
     "marketplace.json"
@@ -18571,7 +19772,7 @@ async function findAndLoadManifests() {
     return { manifests, collections: [], source: ".claude/marketplace.json" };
   } catch (error) {
   }
-  const marketplaceJsonPluginPath = (0, import_path14.join)(
+  const marketplaceJsonPluginPath = (0, import_path15.join)(
     process.cwd(),
     ".claude-plugin",
     "marketplace.json"
@@ -18721,13 +19922,13 @@ function getSafePackageName(manifest, userInfo, fallbackName) {
 // src/utils/tarball-creator.ts
 init_cjs_shims();
 var import_promises7 = require("fs/promises");
-var import_path15 = require("path");
+var import_path16 = require("path");
 var tar2 = __toESM(require("tar"));
-var import_os4 = require("os");
+var import_os5 = require("os");
 var import_crypto2 = require("crypto");
 async function createTarball(manifest) {
-  const tmpDir = (0, import_path15.join)((0, import_os4.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
-  const tarballPath = (0, import_path15.join)(tmpDir, "package.tar.gz");
+  const tmpDir = (0, import_path16.join)((0, import_os5.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
+  const tarballPath = (0, import_path16.join)(tmpDir, "package.tar.gz");
   try {
     await (0, import_promises7.mkdir)(tmpDir, { recursive: true });
     const filePaths = normalizeFilePaths2(manifest.files);
@@ -18856,22 +20057,22 @@ async function handlePublish(options) {
       throw new CLIError('\u274C Not logged in. Run "prpm login" first.', 1);
     }
     console.log("\u{1F4E6} Publishing package...\n");
-    const prpmJsonPath = (0, import_path19.join)(process.cwd(), "prpm.json");
-    const marketplaceJsonPath = (0, import_path19.join)(
+    const prpmJsonPath = (0, import_path20.join)(process.cwd(), "prpm.json");
+    const marketplaceJsonPath = (0, import_path20.join)(
       process.cwd(),
       ".claude",
       "marketplace.json"
     );
-    const marketplaceJsonPluginPath = (0, import_path19.join)(
+    const marketplaceJsonPluginPath = (0, import_path20.join)(
       process.cwd(),
       ".claude-plugin",
       "marketplace.json"
     );
-    const hasManifest = (0, import_fs15.existsSync)(prpmJsonPath) || (0, import_fs15.existsSync)(marketplaceJsonPath) || (0, import_fs15.existsSync)(marketplaceJsonPluginPath);
+    const hasManifest = (0, import_fs16.existsSync)(prpmJsonPath) || (0, import_fs16.existsSync)(marketplaceJsonPath) || (0, import_fs16.existsSync)(marketplaceJsonPluginPath);
     if (!hasManifest) {
       console.log("No prpm.json found. Let's create one first.\n");
       await smartInit({});
-      if (!(0, import_fs15.existsSync)(prpmJsonPath)) {
+      if (!(0, import_fs16.existsSync)(prpmJsonPath)) {
         throw new CLIError(
           "No prpm.json was created. Cannot publish without a manifest.",
           1
@@ -18883,7 +20084,7 @@ async function handlePublish(options) {
     const { manifests, collections, source } = await findAndLoadManifests();
     if (source === "prpm.json (multi-package)" || source === "prpm.json") {
       try {
-        const prpmJsonPath2 = (0, import_path19.join)(process.cwd(), "prpm.json");
+        const prpmJsonPath2 = (0, import_path20.join)(process.cwd(), "prpm.json");
         const prpmContent = await (0, import_promises9.readFile)(prpmJsonPath2, "utf-8");
         const prpmManifest = JSON.parse(prpmContent);
         if (prpmManifest.scripts) {
@@ -21408,57 +22609,60 @@ function createStarredCommand() {
 init_cjs_shims();
 var import_commander27 = require("commander");
 var import_promises10 = require("fs/promises");
-var import_path20 = require("path");
-var import_fs16 = require("fs");
+var import_path21 = require("path");
+var import_fs17 = require("fs");
 var import_readline = require("readline");
 var import_chalk2 = __toESM(require_source());
 init_errors();
 init_dist();
 function getDefaultPath(format, filename, subtype, customName) {
-  const baseName = customName || (0, import_path20.basename)(filename, (0, import_path20.extname)(filename));
+  const baseName = customName || (0, import_path21.basename)(filename, (0, import_path21.extname)(filename));
   switch (format) {
     case "cursor":
       if (subtype === "slash-command") {
-        return (0, import_path20.join)(process.cwd(), ".cursor", "commands", `${baseName}.md`);
+        return (0, import_path21.join)(process.cwd(), ".cursor", "commands", `${baseName}.md`);
+      }
+      if (subtype === "hook") {
+        return (0, import_path21.join)(process.cwd(), ".cursor", "hooks", "hooks.json");
       }
-      return (0, import_path20.join)(process.cwd(), ".cursor", "rules", `${baseName}.mdc`);
+      return (0, import_path21.join)(process.cwd(), ".cursor", "rules", `${baseName}.mdc`);
     case "claude":
       if (subtype === "skill") {
-        return (0, import_path20.join)(process.cwd(), ".claude", "skills", baseName, "SKILL.md");
+        return (0, import_path21.join)(process.cwd(), ".claude", "skills", baseName, "SKILL.md");
       } else if (subtype === "slash-command") {
-        return (0, import_path20.join)(process.cwd(), ".claude", "commands", `${baseName}.md`);
+        return (0, import_path21.join)(process.cwd(), ".claude", "commands", `${baseName}.md`);
       } else {
-        return (0, import_path20.join)(process.cwd(), ".claude", "agents", `${baseName}.md`);
+        return (0, import_path21.join)(process.cwd(), ".claude", "agents", `${baseName}.md`);
       }
     case "windsurf":
-      return (0, import_path20.join)(process.cwd(), ".windsurf", "rules", `${baseName}.md`);
+      return (0, import_path21.join)(process.cwd(), ".windsurf", "rules", `${baseName}.md`);
     case "kiro":
       if (subtype === "hook") {
-        return (0, import_path20.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
+        return (0, import_path21.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
       }
       if (subtype === "agent") {
-        return (0, import_path20.join)(process.cwd(), ".kiro", "agents", `${baseName}.json`);
+        return (0, import_path21.join)(process.cwd(), ".kiro", "agents", `${baseName}.json`);
       }
-      return (0, import_path20.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
+      return (0, import_path21.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
     case "copilot":
-      return (0, import_path20.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
+      return (0, import_path21.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
     case "continue":
       if (subtype === "slash-command" || subtype === "prompt") {
-        return (0, import_path20.join)(process.cwd(), ".continue", "prompts", `${baseName}.md`);
+        return (0, import_path21.join)(process.cwd(), ".continue", "prompts", `${baseName}.md`);
       }
-      return (0, import_path20.join)(process.cwd(), ".continue", "rules", `${baseName}.md`);
+      return (0, import_path21.join)(process.cwd(), ".continue", "rules", `${baseName}.md`);
     case "agents.md":
-      return (0, import_path20.join)(process.cwd(), "agents.md");
+      return (0, import_path21.join)(process.cwd(), "agents.md");
     case "gemini":
-      return (0, import_path20.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
+      return (0, import_path21.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
     case "ruler":
-      return (0, import_path20.join)(process.cwd(), ".ruler", `${baseName}.md`);
+      return (0, import_path21.join)(process.cwd(), ".ruler", `${baseName}.md`);
     default:
       throw new CLIError(`Unknown format: ${format}`);
   }
 }
 function detectFormat(content, filepath) {
-  const ext = (0, import_path20.extname)(filepath).toLowerCase();
+  const ext = (0, import_path21.extname)(filepath).toLowerCase();
   if (ext === ".mdc" || filepath.includes(".cursor/rules") || filepath.includes(".cursor/commands")) {
     return "cursor";
   }
@@ -21480,7 +22684,7 @@ function detectFormat(content, filepath) {
   if (filepath.includes(".continue/rules") || filepath.includes(".continue/prompts") || filepath.includes(".continuerules")) {
     return "continue";
   }
-  if ((0, import_path20.basename)(filepath) === "agents.md") {
+  if ((0, import_path21.basename)(filepath) === "agents.md") {
     return "agents.md";
   }
   if (ext === ".toml" || filepath.includes(".gemini/commands")) {
@@ -21489,6 +22693,7 @@ function detectFormat(content, filepath) {
   if (filepath.includes(".ruler/")) {
     return "ruler";
   }
+  if (isCursorHooksFormat(content)) return "cursor-hooks";
   if (isClaudeFormat(content)) {
     if (content.includes("type: skill")) return "claude-skill";
     if (content.includes("type: agent")) return "claude-agent";
@@ -21555,6 +22760,9 @@ async function handleConvert(sourcePath, options) {
       case "cursor":
         canonicalPkg = fromCursor(content, metadata);
         break;
+      case "cursor-hooks":
+        canonicalPkg = fromCursorHooks(content, metadata);
+        break;
       case "claude":
       case "claude-agent":
       case "claude-skill":
@@ -21597,7 +22805,13 @@ async function handleConvert(sourcePath, options) {
     let result;
     switch (options.to) {
       case "cursor":
-        result = toCursor(canonicalPkg);
+        if (options.subtype === "hook") {
+          result = toCursorHooks(canonicalPkg, {
+            hookMappingStrategy: options.hookMapping || "auto"
+          });
+        } else {
+          result = toCursor(canonicalPkg);
+        }
         break;
       case "claude":
         result = toClaude(canonicalPkg);
@@ -21638,14 +22852,14 @@ async function handleConvert(sourcePath, options) {
     }
     console.log(import_chalk2.default.green(`\u2713 Converted from ${sourceFormat} to ${options.to}`));
     const outputPath = options.output || getDefaultPath(options.to, sourcePath, options.subtype, options.name);
-    if ((0, import_fs16.existsSync)(outputPath) && !options.yes) {
+    if ((0, import_fs17.existsSync)(outputPath) && !options.yes) {
       const shouldOverwrite = await confirmOverwrite(outputPath);
       if (!shouldOverwrite) {
         console.log(import_chalk2.default.yellow("\n\u2716 Conversion cancelled"));
         return;
       }
     }
-    const outputDir = (0, import_path20.dirname)(outputPath);
+    const outputDir = (0, import_path21.dirname)(outputPath);
     await (0, import_promises10.mkdir)(outputDir, { recursive: true });
     console.log(import_chalk2.default.dim("Writing converted file..."));
     await (0, import_promises10.writeFile)(outputPath, result.content, "utf-8");
@@ -21670,7 +22884,7 @@ async function handleConvert(sourcePath, options) {
   }
 }
 function createConvertCommand() {
-  const command = new import_commander27.Command("convert").description("Convert AI prompt files between formats").argument("<source>", "Source file path to convert").option("-t, --to <format>", "Target format (cursor, claude, windsurf, kiro, copilot, continue, agents.md, gemini, ruler)").option("-s, --subtype <subtype>", "Target subtype (agent, skill, slash-command, rule, prompt, etc.)").option("-o, --output <path>", "Output path (defaults to format-specific location)").option("-n, --name <name>", 'Custom output filename (without extension, e.g., "my-rule")').option("-y, --yes", "Skip confirmation prompts").action(async (source, options) => {
+  const command = new import_commander27.Command("convert").description("Convert AI prompt files between formats").argument("<source>", "Source file path to convert").option("-t, --to <format>", "Target format (cursor, claude, windsurf, kiro, copilot, continue, agents.md, gemini, ruler)").option("-s, --subtype <subtype>", "Target subtype (agent, skill, slash-command, rule, hook, prompt, etc.)").option("-o, --output <path>", "Output path (defaults to format-specific location)").option("-n, --name <name>", 'Custom output filename (without extension, e.g., "my-rule")').option("--hook-mapping <strategy>", "Hook mapping strategy: auto (default), strict, skip", "auto").option("-y, --yes", "Skip confirmation prompts").action(async (source, options) => {
     try {
       if (!options.to) {
         throw new CLIError("Target format is required. Use --to <format>");
@@ -21680,7 +22894,16 @@ function createConvertCommand() {
         throw new CLIError(
           `Invalid format: ${options.to}
 
-Valid formats: ${validFormats.join(", ")}`
+Valid formats: ${validFormats.join(", ")}
+
+\u{1F4A1} For Cursor hooks, use: --to cursor --subtype hook`
+        );
+      }
+      if (options.hookMapping && !isValidHookMappingStrategy(options.hookMapping)) {
+        throw new CLIError(
+          `Invalid hook mapping strategy: ${options.hookMapping}
+
+Valid strategies: ${VALID_HOOK_MAPPING_STRATEGIES.join(", ")}`
         );
       }
       const validSubtypes = ["agent", "skill", "slash-command", "rule", "prompt", "workflow", "tool", "template", "collection", "chatmode", "hook"];
@@ -21696,7 +22919,8 @@ Valid subtypes: ${validSubtypes.join(", ")}`
         subtype: options.subtype,
         output: options.output,
         name: options.name,
-        yes: options.yes
+        yes: options.yes,
+        hookMapping: options.hookMapping
       });
     } catch (error) {
       if (error instanceof CLIError) {
@@ -21711,8 +22935,8 @@ Valid subtypes: ${validSubtypes.join(", ")}`
 // src/commands/export.ts
 init_cjs_shims();
 var import_commander28 = require("commander");
-var import_fs17 = require("fs");
-var import_path21 = require("path");
+var import_fs18 = require("fs");
+var import_path22 = require("path");
 var import_chalk3 = __toESM(require_source());
 init_errors();
 init_lockfile();
@@ -21728,17 +22952,17 @@ async function exportToRuler(options) {
   }
   console.log(import_chalk3.default.green(`\u2713 Found ${packages.length} installed package${packages.length === 1 ? "" : "s"}`));
   console.log();
-  const outputDir = options.output || (0, import_path21.join)(process.cwd(), ".ruler");
+  const outputDir = options.output || (0, import_path22.join)(process.cwd(), ".ruler");
   let rulerExists = false;
   try {
-    await import_fs17.promises.access(outputDir);
+    await import_fs18.promises.access(outputDir);
     rulerExists = true;
   } catch {
   }
   if (!rulerExists) {
     console.log(import_chalk3.default.yellow(`\u26A0 ${outputDir} directory not found`));
     console.log(import_chalk3.default.dim("Creating .ruler directory..."));
-    await import_fs17.promises.mkdir(outputDir, { recursive: true });
+    await import_fs18.promises.mkdir(outputDir, { recursive: true });
     console.log(import_chalk3.default.green(`\u2713 Created ${outputDir}/`));
     console.log();
   }
@@ -21752,11 +22976,11 @@ async function exportToRuler(options) {
       continue;
     }
     try {
-      const content = await import_fs17.promises.readFile(pkg.installedPath, "utf-8");
+      const content = await import_fs18.promises.readFile(pkg.installedPath, "utf-8");
       const rulerContent = createRulerFormat(pkg.id, pkg.version, content, pkg.format, pkg.subtype);
       const rulerFilename = `${packageName}.md`;
-      const rulerPath = (0, import_path21.join)(outputDir, rulerFilename);
-      await import_fs17.promises.writeFile(rulerPath, rulerContent, "utf-8");
+      const rulerPath = (0, import_path22.join)(outputDir, rulerFilename);
+      await import_fs18.promises.writeFile(rulerPath, rulerContent, "utf-8");
       console.log(import_chalk3.default.green(`\u2713 Exported ${pkg.id} \u2192 ${rulerFilename}`));
       exportedCount++;
     } catch (error) {
@@ -21795,9 +23019,9 @@ function createRulerFormat(packageId, version, content, format, subtype) {
   return frontmatter + contentWithoutFrontmatter;
 }
 async function ensureRulerConfig(rulerDir) {
-  const configPath = (0, import_path21.join)((0, import_path21.dirname)(rulerDir), "ruler.toml");
+  const configPath = (0, import_path22.join)((0, import_path22.dirname)(rulerDir), "ruler.toml");
   try {
-    await import_fs17.promises.access(configPath);
+    await import_fs18.promises.access(configPath);
     console.log(import_chalk3.default.dim("\u2139 ruler.toml already exists (not modified)"));
   } catch {
     const basicConfig = `# Ruler Configuration
@@ -21823,7 +23047,7 @@ async function ensureRulerConfig(rulerDir) {
 # [agents.github-copilot]
 # enabled = false
 `;
-    await import_fs17.promises.writeFile(configPath, basicConfig, "utf-8");
+    await import_fs18.promises.writeFile(configPath, basicConfig, "utf-8");
     console.log(import_chalk3.default.green(`\u2713 Created ruler.toml configuration template`));
   }
 }
@@ -21893,8 +23117,8 @@ init_telemetry();
 init_errors();
 function getVersion() {
   try {
-    const packageJsonPath = (0, import_path22.join)(__dirname, "../package.json");
-    const packageJson = JSON.parse((0, import_fs18.readFileSync)(packageJsonPath, "utf-8"));
+    const packageJsonPath = (0, import_path23.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, import_fs19.readFileSync)(packageJsonPath, "utf-8"));
     return packageJson.version || "0.0.0";
   } catch {
     return "0.0.0";