prpm 1.1.1 → 1.1.3

package/dist/index.js

@@ -83,7 +83,8 @@ function addToLockfile(lockfile, packageId, packageInfo) {
     sourceSubtype: packageInfo.sourceSubtype,
     installedPath: packageInfo.installedPath,
     fromCollection: packageInfo.fromCollection,
-    hookMetadata: packageInfo.hookMetadata
+    hookMetadata: packageInfo.hookMetadata,
+    progressiveDisclosure: packageInfo.progressiveDisclosure
   };
   lockfile.generated = (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -494,10 +495,31 @@ function getDestinationDir2(format, subtype, name) {
       return ".github/instructions";
     case "kiro":
       if (subtype === "hook") return ".kiro/hooks";
+      if (subtype === "agent") return ".kiro/agents";
       return ".kiro/steering";
     case "gemini":
       return ".gemini/commands";
+    case "opencode":
+      if (subtype === "agent") return ".opencode/agent";
+      if (subtype === "slash-command") return ".opencode/command";
+      if (subtype === "tool") return ".opencode/tool";
+      return ".opencode/agent";
+    case "droid":
+      if (subtype === "skill" && packageName) return `.factory/skills/${packageName}`;
+      if (subtype === "skill") return ".factory/skills";
+      if (subtype === "slash-command") return ".factory/commands";
+      if (subtype === "hook") return ".factory/hooks";
+      return ".factory/skills";
+    // Default to skills
     case "agents.md":
+    case "gemini.md":
+    case "claude.md":
+      if (subtype === "skill" && packageName) {
+        return `.openskills/${packageName}`;
+      }
+      if (subtype === "agent" && packageName) {
+        return `.openagents/${packageName}`;
+      }
       return ".";
     case "generic":
       return ".prompts";
@@ -539,7 +561,25 @@ async function directoryExists(dirPath) {
     return false;
   }
 }
+function getManifestFilename(format) {
+  switch (format) {
+    case "agents.md":
+      return "AGENTS.md";
+    case "gemini.md":
+      return "GEMINI.md";
+    case "claude.md":
+      return "CLAUDE.md";
+    default:
+      return "AGENTS.md";
+  }
+}
 async function autoDetectFormat() {
+  if (await fileExists("GEMINI.md")) {
+    return "gemini.md";
+  }
+  if (await fileExists("CLAUDE.md")) {
+    return "claude.md";
+  }
   if (await fileExists("AGENTS.md")) {
     return "agents.md";
   }
@@ -551,6 +591,8 @@ async function autoDetectFormat() {
     { format: "copilot", dir: ".github/instructions" },
     { format: "kiro", dir: ".kiro" },
     { format: "gemini", dir: ".gemini" },
+    { format: "opencode", dir: ".opencode" },
+    { format: "droid", dir: ".factory" },
     { format: "agents.md", dir: ".agents" }
   ];
   for (const { format, dir } of formatDirs) {
@@ -581,6 +623,237 @@ var init_filesystem = __esm({
   }
 });
 
+// src/core/agents-md-progressive.ts
+function generateSkillXML(entry) {
+  const resourceType = entry.resourceType || "skill";
+  const tag = resourceType === "agent" ? "agent" : "skill";
+  const mainFile = entry.mainFile || (resourceType === "agent" ? "AGENT.md" : "SKILL.md");
+  const fullPath = import_path6.default.join(entry.skillPath, mainFile);
+  return `<${tag}>
+<name>${escapeXML(entry.name)}</name>
+<description>${escapeXML(entry.description)}</description>
+<path>${escapeXML(fullPath)}</path>
+</${tag}>`;
+}
+function generateSkillsSystemHeader() {
+  return `<!-- PRPM_MANIFEST_START -->
+
+<skills_system priority="1">
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills (loaded into main context):
+- Use the <path> from the skill entry below
+- Invoke: Bash("cat <path>")
+- The skill content will load into your current context
+- Example: Bash("cat .openskills/backend-architect/SKILL.md")
+
+Usage notes:
+- Skills share your context window
+- Do not invoke a skill that is already loaded in your context
+</usage>
+
+<available_skills>`;
+}
+function generateAgentsSystemHeader() {
+  return `<agents_system priority="1">
+<usage>
+Agents are specialized AI assistants that run in independent contexts for complex multi-step tasks.
+
+How to use agents (spawned with independent context):
+- The <path> from the agent entry contains the agent definition file
+- The agent definition will be automatically loaded into the subagent's context
+- Invoke: Task(subagent_type="<agent-name>", prompt="task description")
+- The agent runs in a separate context and returns results
+- Example: Task(subagent_type="code-reviewer", prompt="Review the authentication code in auth.ts")
+
+Usage notes:
+- Agents have independent context windows
+- Each agent invocation is stateless
+- Agents are spawned as subprocesses via the Task tool
+- The agent's AGENT.md file is loaded into the subagent's context automatically
+</usage>
+
+<available_agents>`;
+}
+function generateManifestFooter(hasAgents, agentsXML) {
+  let footer = "</available_skills>\n</skills_system>";
+  if (hasAgents && agentsXML) {
+    footer += "\n\n" + generateAgentsSystemHeader();
+    footer += `
+
+${agentsXML}
+
+`;
+    footer += "</available_agents>\n</agents_system>";
+  }
+  footer += "\n\n<!-- PRPM_MANIFEST_END -->";
+  return footer;
+}
+async function readAgentsMdManifest(agentsPath = "AGENTS.md") {
+  if (!await fileExists(agentsPath)) {
+    return {
+      beforeManifest: "",
+      manifest: "",
+      afterManifest: ""
+    };
+  }
+  const content = await import_fs6.promises.readFile(agentsPath, "utf-8");
+  let manifestStart = "<!-- PRPM_MANIFEST_START -->";
+  let manifestEnd = "<!-- PRPM_MANIFEST_END -->";
+  let startIdx = content.indexOf(manifestStart);
+  let endIdx = content.indexOf(manifestEnd);
+  if (startIdx === -1 || endIdx === -1) {
+    manifestStart = "<!-- SKILLS_TABLE_START -->";
+    manifestEnd = "<!-- SKILLS_TABLE_END -->";
+    startIdx = content.indexOf(manifestStart);
+    endIdx = content.indexOf(manifestEnd);
+  }
+  if (startIdx === -1 || endIdx === -1) {
+    manifestStart = "<!-- PRPM Manifest -->";
+    manifestEnd = "<!-- End PRPM Manifest -->";
+    startIdx = content.indexOf(manifestStart);
+    endIdx = content.indexOf(manifestEnd);
+  }
+  if (startIdx === -1 || endIdx === -1) {
+    return {
+      beforeManifest: content,
+      manifest: "",
+      afterManifest: ""
+    };
+  }
+  const beforeManifest = content.substring(0, startIdx);
+  const manifest = content.substring(
+    startIdx + manifestStart.length,
+    endIdx
+  ).trim();
+  const afterManifest = content.substring(endIdx + manifestEnd.length);
+  return {
+    beforeManifest,
+    manifest,
+    afterManifest
+  };
+}
+async function addSkillToManifest(entry, agentsPath = "AGENTS.md") {
+  const { beforeManifest, manifest, afterManifest } = await readAgentsMdManifest(agentsPath);
+  const existingResources = parseSkillsFromManifest(manifest);
+  const updatedResources = existingResources.filter((s) => s.name !== entry.name);
+  updatedResources.push(entry);
+  const skills = updatedResources.filter((r) => (r.resourceType || "skill") === "skill");
+  const agents = updatedResources.filter((r) => r.resourceType === "agent");
+  const skillsXML = skills.map((s) => generateSkillXML(s)).join("\n\n");
+  const agentsXML = agents.length > 0 ? agents.map((a) => generateSkillXML(a)).join("\n\n") : void 0;
+  let newContent = "";
+  if (!beforeManifest.trim() && !afterManifest.trim()) {
+    newContent = "";
+  } else {
+    newContent = beforeManifest;
+  }
+  const hasAgents = agents.length > 0;
+  newContent += generateSkillsSystemHeader();
+  newContent += "\n\n";
+  newContent += skillsXML;
+  newContent += "\n\n";
+  newContent += generateManifestFooter(hasAgents, agentsXML);
+  newContent += afterManifest;
+  await import_fs6.promises.writeFile(agentsPath, newContent.trim() + "\n", "utf-8");
+}
+async function removeSkillFromManifest(skillName, agentsPath = "AGENTS.md") {
+  const { beforeManifest, manifest, afterManifest } = await readAgentsMdManifest(agentsPath);
+  if (!manifest) {
+    return;
+  }
+  const existingResources = parseSkillsFromManifest(manifest);
+  const updatedResources = existingResources.filter((s) => s.name !== skillName);
+  if (updatedResources.length === 0) {
+    const newContent2 = (beforeManifest + afterManifest).trim();
+    if (newContent2) {
+      await import_fs6.promises.writeFile(agentsPath, newContent2 + "\n", "utf-8");
+    } else {
+      await import_fs6.promises.unlink(agentsPath);
+    }
+    return;
+  }
+  const skills = updatedResources.filter((r) => (r.resourceType || "skill") === "skill");
+  const agents = updatedResources.filter((r) => r.resourceType === "agent");
+  const skillsXML = skills.map((s) => generateSkillXML(s)).join("\n\n");
+  const agentsXML = agents.length > 0 ? agents.map((a) => generateSkillXML(a)).join("\n\n") : void 0;
+  const hasAgents = agents.length > 0;
+  let newContent = beforeManifest;
+  newContent += generateSkillsSystemHeader();
+  newContent += "\n\n";
+  newContent += skillsXML;
+  newContent += "\n\n";
+  newContent += generateManifestFooter(hasAgents, agentsXML);
+  newContent += afterManifest;
+  await import_fs6.promises.writeFile(agentsPath, newContent.trim() + "\n", "utf-8");
+}
+function parseSkillsFromManifest(manifestXML) {
+  const resources = [];
+  const skillFormatRegex = /<skill>\s*<name>([^<]+)<\/name>\s*<description>([^<]+)<\/description>\s*<path>([^<]+)<\/path>\s*<\/skill>/g;
+  let match;
+  while ((match = skillFormatRegex.exec(manifestXML)) !== null) {
+    const [, name, description, fullPath] = match;
+    const pathParts = fullPath.trim().split("/");
+    const mainFile = pathParts[pathParts.length - 1];
+    const dir = pathParts.slice(0, -1).join("/");
+    resources.push({
+      name: unescapeXML(name.trim()),
+      description: unescapeXML(description.trim()),
+      skillPath: dir,
+      mainFile,
+      resourceType: "skill"
+    });
+  }
+  const agentFormatRegex = /<agent>\s*<name>([^<]+)<\/name>\s*<description>([^<]+)<\/description>\s*<path>([^<]+)<\/path>\s*<\/agent>/g;
+  while ((match = agentFormatRegex.exec(manifestXML)) !== null) {
+    const [, name, description, fullPath] = match;
+    const pathParts = fullPath.trim().split("/");
+    const mainFile = pathParts[pathParts.length - 1];
+    const dir = pathParts.slice(0, -1).join("/");
+    resources.push({
+      name: unescapeXML(name.trim()),
+      description: unescapeXML(description.trim()),
+      skillPath: dir,
+      mainFile,
+      resourceType: "agent"
+    });
+  }
+  if (resources.length === 0) {
+    const legacyRegex = /<skill\s+name="([^"]+)"\s+path="([^"]+)">([^<]*)<\/skill>/g;
+    while ((match = legacyRegex.exec(manifestXML)) !== null) {
+      const [, name, skillPath, description] = match;
+      const pathParts = skillPath.split("/");
+      const mainFile = pathParts[pathParts.length - 1];
+      const dir = pathParts.slice(0, -1).join("/");
+      resources.push({
+        name: unescapeXML(name),
+        description: unescapeXML(description.trim()),
+        skillPath: dir,
+        mainFile,
+        resourceType: "skill"
+      });
+    }
+  }
+  return resources;
+}
+function escapeXML(str2) {
+  return str2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function unescapeXML(str2) {
+  return str2.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+var import_fs6, import_path6;
+var init_agents_md_progressive = __esm({
+  "src/core/agents-md-progressive.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs6 = require("fs");
+    import_path6 = __toESM(require("path"));
+    init_filesystem();
+  }
+});
+
 // ../../node_modules/color-name/index.js
 var require_color_name = __commonJS({
   "../../node_modules/color-name/index.js"(exports2, module2) {
@@ -1456,15 +1729,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path7 = [graph[toModel].parent, toModel];
+      const path8 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path7.unshift(graph[cur].parent);
+        path8.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path7;
+      fn.conversion = path8;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -1910,14 +2183,14 @@ var require_templates = __commonJS({
       }
       return results;
     }
-    function buildStyle(chalk3, styles) {
+    function buildStyle(chalk4, styles) {
       const enabled = {};
       for (const layer of styles) {
         for (const style of layer.styles) {
           enabled[style[0]] = layer.inverse ? null : style.slice(1);
         }
       }
-      let current = chalk3;
+      let current = chalk4;
       for (const [styleName, styles2] of Object.entries(enabled)) {
         if (!Array.isArray(styles2)) {
           continue;
@@ -1929,7 +2202,7 @@ var require_templates = __commonJS({
       }
       return current;
     }
-    module2.exports = (chalk3, temporary) => {
+    module2.exports = (chalk4, temporary) => {
       const styles = [];
       const chunks = [];
       let chunk = [];
@@ -1939,13 +2212,13 @@ var require_templates = __commonJS({
         } else if (style) {
           const string = chunk.join("");
           chunk = [];
-          chunks.push(styles.length === 0 ? string : buildStyle(chalk3, styles)(string));
+          chunks.push(styles.length === 0 ? string : buildStyle(chalk4, styles)(string));
           styles.push({ inverse, styles: parseStyle(style) });
         } else if (close) {
           if (styles.length === 0) {
             throw new Error("Found extraneous } in Chalk template literal");
           }
-          chunks.push(buildStyle(chalk3, styles)(chunk.join("")));
+          chunks.push(buildStyle(chalk4, styles)(chunk.join("")));
           chunk = [];
           styles.pop();
         } else {
@@ -1994,16 +2267,16 @@ var require_source = __commonJS({
       }
     };
     var chalkFactory = (options) => {
-      const chalk4 = {};
-      applyOptions(chalk4, options);
-      chalk4.template = (...arguments_) => chalkTag(chalk4.template, ...arguments_);
-      Object.setPrototypeOf(chalk4, Chalk.prototype);
-      Object.setPrototypeOf(chalk4.template, chalk4);
-      chalk4.template.constructor = () => {
+      const chalk5 = {};
+      applyOptions(chalk5, options);
+      chalk5.template = (...arguments_) => chalkTag(chalk5.template, ...arguments_);
+      Object.setPrototypeOf(chalk5, Chalk.prototype);
+      Object.setPrototypeOf(chalk5.template, chalk5);
+      chalk5.template.constructor = () => {
         throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
       };
-      chalk4.template.Instance = ChalkClass;
-      return chalk4.template;
+      chalk5.template.Instance = ChalkClass;
+      return chalk5.template;
     };
     function Chalk(options) {
       return chalkFactory(options);
@@ -2114,7 +2387,7 @@ var require_source = __commonJS({
       return openAll + string + closeAll;
     };
     var template;
-    var chalkTag = (chalk4, ...strings) => {
+    var chalkTag = (chalk5, ...strings) => {
       const [firstString] = strings;
       if (!isArray(firstString) || !isArray(firstString.raw)) {
         return strings.join(" ");
@@ -2130,14 +2403,14 @@ var require_source = __commonJS({
       if (template === void 0) {
         template = require_templates();
       }
-      return template(chalk4, parts.join(""));
+      return template(chalk5, parts.join(""));
     };
     Object.defineProperties(Chalk.prototype, styles);
-    var chalk3 = Chalk();
-    chalk3.supportsColor = stdoutColor;
-    chalk3.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
-    chalk3.stderr.supportsColor = stderrColor;
-    module2.exports = chalk3;
+    var chalk4 = Chalk();
+    chalk4.supportsColor = stdoutColor;
+    chalk4.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk4.stderr.supportsColor = stderrColor;
+    module2.exports = chalk4;
   }
 });
 
@@ -2491,8 +2764,8 @@ async function handleCollectionPublish(manifestPath = "./collection.json") {
       throw new CLIError("\n\u274C Authentication required. Run `prpm login` first.", 1);
     }
     console.log("\u{1F4E6} Publishing collection...\n");
-    const fs10 = await import("fs/promises");
-    const manifestContent = await fs10.readFile(manifestPath, "utf-8");
+    const fs12 = await import("fs/promises");
+    const manifestContent = await fs12.readFile(manifestPath, "utf-8");
     const manifest = JSON.parse(manifestContent);
     const required = ["id", "name", "description", "packages"];
     const missing = required.filter((field) => !manifest[field]);
@@ -6389,6 +6662,172 @@ var init_from_kiro = __esm({
   }
 });
 
+// ../converters/dist/from-kiro-agent.js
+function fromKiroAgent(jsonContent, options = {}) {
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const agentConfig = JSON.parse(jsonContent);
+    const content = {
+      format: "canonical",
+      version: "1.0",
+      sections: [
+        {
+          type: "metadata",
+          data: {
+            title: agentConfig.name || "Kiro Agent",
+            description: agentConfig.description || ""
+          }
+        }
+      ]
+    };
+    if (agentConfig.prompt) {
+      parsePromptIntoContent(agentConfig.prompt, content);
+    }
+    const pkg = {
+      id: agentConfig.name || "kiro-agent",
+      name: agentConfig.name || "kiro-agent",
+      version: "1.0.0",
+      description: agentConfig.description || "",
+      author: "",
+      tags: [],
+      format: "kiro",
+      subtype: "agent",
+      content,
+      sourceFormat: "kiro",
+      metadata: {
+        kiroConfig: {
+          inclusion: "always"
+        },
+        kiroAgent: {
+          tools: agentConfig.tools,
+          mcpServers: agentConfig.mcpServers,
+          toolAliases: agentConfig.toolAliases,
+          allowedTools: agentConfig.allowedTools,
+          toolsSettings: agentConfig.toolsSettings,
+          resources: agentConfig.resources,
+          hooks: agentConfig.hooks,
+          useLegacyMcpJson: agentConfig.useLegacyMcpJson,
+          model: agentConfig.model
+        }
+      }
+    };
+    return {
+      content: JSON.stringify(pkg, null, 2),
+      format: "canonical",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion: false,
+      qualityScore
+    };
+  } catch (error) {
+    warnings.push(`Parse error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "canonical",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function parsePromptIntoContent(prompt3, content) {
+  if (prompt3.startsWith("file://")) {
+    content.sections.push({
+      type: "instructions",
+      title: "Instructions",
+      content: `Loads instructions from: ${prompt3}`
+    });
+    return;
+  }
+  const sections = prompt3.split(/\n## /);
+  if (sections[0]) {
+    const intro = sections[0].trim();
+    if (intro) {
+      const metadataSection = content.sections[0];
+      if (metadataSection && metadataSection.type === "metadata") {
+        if (!metadataSection.data.description) {
+          metadataSection.data.description = intro;
+        }
+      }
+    }
+  }
+  for (let i = 1; i < sections.length; i++) {
+    const sectionText = sections[i];
+    const lines = sectionText.split("\n");
+    const title = lines[0].trim();
+    const sectionContent = lines.slice(1).join("\n").trim();
+    if (title.toLowerCase() === "instructions") {
+      content.sections.push({
+        type: "instructions",
+        title,
+        content: sectionContent
+      });
+    } else if (title.toLowerCase() === "rules") {
+      const rules = parseRules(sectionContent);
+      content.sections.push({
+        type: "rules",
+        title,
+        items: rules
+      });
+    } else if (title.toLowerCase() === "examples") {
+      const examples = parseExamples(sectionContent);
+      content.sections.push({
+        type: "examples",
+        title,
+        examples
+      });
+    } else {
+      content.sections.push({
+        type: "custom",
+        editorType: "kiro",
+        title,
+        content: sectionContent
+      });
+    }
+  }
+}
+function parseRules(text) {
+  const rules = [];
+  const ruleSections = text.split(/\n### /);
+  for (const ruleText of ruleSections) {
+    if (!ruleText.trim())
+      continue;
+    const lines = ruleText.split("\n");
+    const title = lines[0].trim();
+    const description = lines.slice(1).join("\n").trim();
+    rules.push({
+      content: `${title}: ${description}`
+    });
+  }
+  return rules;
+}
+function parseExamples(text) {
+  const examples = [];
+  const exampleSections = text.split(/\n### /);
+  for (const exampleText of exampleSections) {
+    if (!exampleText.trim())
+      continue;
+    const lines = exampleText.split("\n");
+    const title = lines[0].trim();
+    const content = lines.slice(1).join("\n");
+    const codeMatch = /```[\w]*\n([\s\S]*?)```/.exec(content);
+    const code = codeMatch ? codeMatch[1].trim() : content;
+    const descMatch = /^([\s\S]*?)(?:```|$)/.exec(content);
+    const description = descMatch && descMatch[1].trim() ? descMatch[1].trim() : title;
+    examples.push({
+      description,
+      code
+    });
+  }
+  return examples;
+}
+var init_from_kiro_agent = __esm({
+  "../converters/dist/from-kiro-agent.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/from-windsurf.js
 function fromWindsurf(content, metadata) {
   const sections = [];
@@ -8778,6 +9217,156 @@ var init_from_gemini = __esm({
   }
 });
 
+// ../converters/dist/from-opencode.js
+var init_from_opencode = __esm({
+  "../converters/dist/from-opencode.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_taxonomy_utils();
+    init_js_yaml();
+  }
+});
+
+// ../converters/dist/from-ruler.js
+function fromRuler(markdown, options = {}) {
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const cleanedMarkdown = markdown.replace(/<!--.*?-->/gs, "").trim();
+    const content = parseMarkdownContent(cleanedMarkdown, warnings);
+    const metadata = extractMetadata(markdown);
+    const metadataSection = content.sections.find((s) => s.type === "metadata");
+    const description = metadata.description || (metadataSection == null ? void 0 : metadataSection.data.description) || "";
+    const title = (metadataSection == null ? void 0 : metadataSection.data.title) || "Ruler Rule";
+    const pkg = {
+      id: metadata.name || "ruler-rule",
+      name: metadata.name || "ruler-rule",
+      version: "1.0.0",
+      author: metadata.author || "",
+      tags: [],
+      format: "generic",
+      subtype: "rule",
+      description,
+      content,
+      sourceFormat: "ruler",
+      metadata: {
+        title,
+        description
+      }
+    };
+    return {
+      content: JSON.stringify(pkg, null, 2),
+      format: "canonical",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion: false,
+      qualityScore
+    };
+  } catch (error) {
+    warnings.push(`Parse error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "canonical",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function extractMetadata(markdown) {
+  const metadata = {};
+  const nameMatch = /<!--\s*Package:\s*(.+?)\s*-->/i.exec(markdown);
+  if (nameMatch) {
+    metadata.name = nameMatch[1].trim();
+  }
+  const authorMatch = /<!--\s*Author:\s*(.+?)\s*-->/i.exec(markdown);
+  if (authorMatch) {
+    metadata.author = authorMatch[1].trim();
+  }
+  const descMatch = /<!--\s*Description:\s*(.+?)\s*-->/i.exec(markdown);
+  if (descMatch) {
+    metadata.description = descMatch[1].trim();
+  }
+  return metadata;
+}
+function parseMarkdownContent(markdown, warnings) {
+  const lines = markdown.split("\n");
+  const content = {
+    format: "canonical",
+    version: "1.0",
+    sections: []
+  };
+  let title = "";
+  let description = "";
+  let currentSection = null;
+  let inCodeBlock = false;
+  let buffer = [];
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      buffer.push(line);
+      continue;
+    }
+    if (!inCodeBlock && line.match(/^#+\s/)) {
+      if (currentSection) {
+        content.sections.push({
+          type: "custom",
+          title: currentSection.title,
+          content: buffer.join("\n").trim()
+        });
+        buffer = [];
+      }
+      const match = line.match(/^(#+)\s+(.+)$/);
+      if (match) {
+        const level = match[1].length;
+        const sectionTitle = match[2].trim();
+        if (level === 1 && !title) {
+          title = sectionTitle;
+          currentSection = null;
+        } else {
+          currentSection = { title: sectionTitle, content: "" };
+        }
+      }
+    } else if (currentSection) {
+      buffer.push(line);
+    } else if (!title) {
+      if (line.trim()) {
+        description += (description ? "\n" : "") + line;
+      }
+    }
+  }
+  if (currentSection && buffer.length > 0) {
+    content.sections.push({
+      type: "custom",
+      title: currentSection.title,
+      content: buffer.join("\n").trim()
+    });
+  }
+  content.sections.unshift({
+    type: "metadata",
+    data: {
+      title: title || "Ruler Rule",
+      description: description || ""
+    }
+  });
+  return content;
+}
+var init_from_ruler = __esm({
+  "../converters/dist/from-ruler.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// ../converters/dist/from-droid.js
+var init_from_droid = __esm({
+  "../converters/dist/from-droid.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_taxonomy_utils();
+    init_js_yaml();
+  }
+});
+
 // ../converters/dist/validation.js
 function loadSchema(format, subtype) {
   const cacheKey = subtype ? `${format}:${subtype}` : format;
@@ -8792,7 +9381,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",
-      "kiro:hook": "kiro-hooks.schema.json"
+      "kiro:hook": "kiro-hooks.schema.json",
+      "kiro:agent": "kiro-agent.schema.json"
     };
     schemaFilename = subtypeSchemaMap[cacheKey];
   }
@@ -8806,20 +9396,23 @@ function loadSchema(format, subtype) {
       "kiro": "kiro-steering.schema.json",
       "agents-md": "agents-md.schema.json",
       "gemini": "gemini.schema.json",
+      "opencode": "opencode.schema.json",
+      "ruler": "ruler.schema.json",
+      "droid": "droid.schema.json",
       "canonical": "canonical.schema.json"
     };
     schemaFilename = schemaMap[format] || `${format}.schema.json`;
   }
   const schemaDirectories = [
-    (0, import_path7.join)(currentDirname, "..", "schemas"),
-    (0, import_path7.join)(currentDirname, "schemas")
+    (0, import_path8.join)(currentDirname, "..", "schemas"),
+    (0, import_path8.join)(currentDirname, "schemas")
   ];
   let schemaContent = null;
   let schemaPath = null;
   for (const dir of schemaDirectories) {
-    const candidate = (0, import_path7.join)(dir, schemaFilename);
+    const candidate = (0, import_path8.join)(dir, schemaFilename);
     try {
-      schemaContent = (0, import_fs8.readFileSync)(candidate, "utf-8");
+      schemaContent = (0, import_fs9.readFileSync)(candidate, "utf-8");
       schemaPath = candidate;
       break;
     } catch (error) {
@@ -8845,11 +9438,11 @@ function validateFormat(format, data, subtype) {
     const warnings = [];
     if (!valid && validate.errors) {
       for (const error of validate.errors) {
-        const path7 = error.instancePath || "/" + error.params.missingProperty || "/";
+        const path8 = error.instancePath || "/" + error.params.missingProperty || "/";
         const message = error.message || "Validation error";
         const validationError = {
-          path: path7,
-          message: `${path7}: ${message}`,
+          path: path8,
+          message: `${path8}: ${message}`,
           value: error.data
         };
         if (error.keyword === "deprecated") {
@@ -8913,22 +9506,33 @@ function parseMarkdownWithFrontmatter(markdown) {
 }
 function validateMarkdown(format, markdown, subtype) {
   const { frontmatter, content } = parseMarkdownWithFrontmatter(markdown);
-  if (format === "windsurf" || format === "agents-md") {
+  if (format === "windsurf" || format === "agents-md" || format === "ruler") {
     return validateFormat(format, { content: markdown }, subtype);
   }
   return validateConversion(format, frontmatter, content, subtype);
 }
-var import_ajv, import_ajv_formats, import_fs8, import_path7, currentDirname, ajv, schemaCache;
+var import_ajv, import_ajv_formats, import_fs9, import_path8, import_url, currentDirname, ajv, schemaCache;
 var init_validation = __esm({
   "../converters/dist/validation.js"() {
     "use strict";
     init_cjs_shims();
     import_ajv = __toESM(require("ajv"), 1);
     import_ajv_formats = __toESM(require("ajv-formats"), 1);
-    import_fs8 = require("fs");
-    import_path7 = require("path");
+    import_fs9 = require("fs");
+    import_path8 = require("path");
+    import_url = require("url");
     init_js_yaml();
-    currentDirname = __dirname;
+    currentDirname = (() => {
+      if (typeof __dirname !== "undefined") {
+        return __dirname;
+      }
+      try {
+        const importMeta = (0, eval)("import.meta");
+        return (0, import_path8.dirname)((0, import_url.fileURLToPath)(importMeta.url));
+      } catch (e) {
+        return (0, import_path8.join)(process.cwd(), "packages", "converters", "dist");
+      }
+    })();
     ajv = new import_ajv.default({
       allErrors: true,
       verbose: true,
@@ -9835,6 +10439,171 @@ var init_to_kiro = __esm({
   }
 });
 
+// ../converters/dist/to-kiro-agent.js
+function toKiroAgent(pkg, options = {}) {
+  var _a;
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const agentConfig = {
+      name: pkg.name,
+      description: pkg.description
+    };
+    const prompt3 = convertToPrompt(pkg.content, warnings);
+    if (prompt3) {
+      agentConfig.prompt = prompt3;
+    }
+    if ((_a = pkg.metadata) == null ? void 0 : _a.kiroAgent) {
+      const kiroAgent = pkg.metadata.kiroAgent;
+      if (kiroAgent.tools) {
+        agentConfig.tools = kiroAgent.tools;
+      }
+      if (kiroAgent.mcpServers) {
+        agentConfig.mcpServers = kiroAgent.mcpServers;
+      }
+      if (kiroAgent.toolAliases) {
+        agentConfig.toolAliases = kiroAgent.toolAliases;
+      }
+      if (kiroAgent.allowedTools) {
+        agentConfig.allowedTools = kiroAgent.allowedTools;
+      }
+      if (kiroAgent.toolsSettings) {
+        agentConfig.toolsSettings = kiroAgent.toolsSettings;
+      }
+      if (kiroAgent.resources) {
+        agentConfig.resources = kiroAgent.resources;
+      }
+      if (kiroAgent.hooks) {
+        agentConfig.hooks = kiroAgent.hooks;
+      }
+      if (kiroAgent.useLegacyMcpJson !== void 0) {
+        agentConfig.useLegacyMcpJson = kiroAgent.useLegacyMcpJson;
+      }
+      if (kiroAgent.model) {
+        agentConfig.model = kiroAgent.model;
+      }
+    }
+    if (pkg.subtype === "slash-command") {
+      warnings.push("Slash commands are not directly supported by Kiro agents");
+      qualityScore -= 20;
+    }
+    if (pkg.subtype === "skill") {
+      warnings.push("Skills are converted to agent prompts - some features may be lost");
+      qualityScore -= 10;
+    }
+    const content = JSON.stringify(agentConfig, null, 2);
+    const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("may be lost"));
+    return {
+      content,
+      format: "kiro",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion,
+      qualityScore: Math.max(0, qualityScore)
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "kiro",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function convertToPrompt(content, warnings) {
+  const parts = [];
+  const metadataSection = content.sections.find((s) => s.type === "metadata");
+  if (metadataSection == null ? void 0 : metadataSection.data.description) {
+    parts.push(metadataSection.data.description);
+  }
+  const personaSection = content.sections.find((s) => s.type === "persona");
+  if (personaSection) {
+    const persona = personaSection.data;
+    let personaText = "";
+    if (persona.name) {
+      personaText += `You are ${persona.name}`;
+      if (persona.role) {
+        personaText += `, ${persona.role}`;
+      }
+      personaText += ". ";
+    }
+    if (persona.style && persona.style.length > 0) {
+      personaText += `Your communication style is ${persona.style.join(", ")}. `;
+    }
+    if (persona.expertise && persona.expertise.length > 0) {
+      personaText += `You specialize in: ${persona.expertise.join(", ")}. `;
+    }
+    if (personaText) {
+      parts.push(personaText.trim());
+    }
+  }
+  for (const section of content.sections) {
+    if (section.type === "instructions") {
+      const instructionsSection = section;
+      parts.push(`
+## ${instructionsSection.title}
+`);
+      parts.push(instructionsSection.content);
+    } else if (section.type === "rules") {
+      const rulesSection = section;
+      parts.push(`
+## ${rulesSection.title}
+`);
+      for (const rule of rulesSection.items) {
+        parts.push(`- ${rule.content}`);
+        if (rule.rationale) {
+          parts.push(`  *Rationale:* ${rule.rationale}`);
+        }
+      }
+    } else if (section.type === "examples") {
+      const examplesSection = section;
+      parts.push(`
+## ${examplesSection.title}
+`);
+      for (const example of examplesSection.examples) {
+        if (example.description) {
+          parts.push(`
+### ${example.description}
+`);
+        }
+        if (example.code) {
+          const lang = example.language || "";
+          parts.push(`\`\`\`${lang}
+${example.code}
+\`\`\``);
+        }
+      }
+    } else if (section.type === "custom") {
+      const customSection = section;
+      if (customSection.title) {
+        parts.push(`
+## ${customSection.title}
+`);
+      }
+      parts.push(customSection.content);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function isKiroAgentFormat(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.name && !parsed.description) {
+      return false;
+    }
+    return !!(parsed.prompt || parsed.tools || parsed.mcpServers);
+  } catch {
+    return false;
+  }
+}
+var init_to_kiro_agent = __esm({
+  "../converters/dist/to-kiro-agent.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/to-windsurf.js
 function toWindsurf(pkg) {
   var _a, _b, _c, _d;
@@ -10345,6 +11114,184 @@ var init_to_gemini = __esm({
   }
 });
 
+// ../converters/dist/to-opencode.js
+var init_to_opencode = __esm({
+  "../converters/dist/to-opencode.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_js_yaml();
+  }
+});
+
+// ../converters/dist/to-ruler.js
+function toRuler(pkg, options = {}) {
+  var _a, _b;
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    if ((_b = (_a = pkg.metadata) == null ? void 0 : _a.copilotConfig) == null ? void 0 : _b.applyTo) {
+      warnings.push("Path-specific configuration (applyTo) will be ignored by Ruler");
+    }
+    if (pkg.subtype === "agent" || pkg.subtype === "workflow") {
+      warnings.push(`Subtype "${pkg.subtype}" may not be fully supported by Ruler's simple rule format`);
+      qualityScore -= 10;
+    }
+    if (pkg.subtype === "slash-command") {
+      warnings.push("Slash commands are not supported by Ruler");
+      qualityScore -= 20;
+    }
+    if (pkg.subtype === "hook") {
+      warnings.push("Hooks are not supported by Ruler");
+      qualityScore -= 20;
+    }
+    const content = convertContent6(pkg.content, warnings);
+    const header = `<!-- Package: ${pkg.name} -->
+<!-- Author: ${pkg.author || "Unknown"} -->
+${pkg.description ? `<!-- Description: ${pkg.description} -->
+` : ""}`;
+    const fullContent = `${header}
+${content}`;
+    const validation = validateMarkdown("ruler", fullContent);
+    const validationErrors = validation.errors.map((e) => e.message);
+    const validationWarnings = validation.warnings.map((w) => w.message);
+    if (validationWarnings.length > 0) {
+      warnings.push(...validationWarnings);
+    }
+    const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("ignored"));
+    if (validationErrors.length > 0) {
+      qualityScore -= validationErrors.length * 5;
+    }
+    return {
+      content: fullContent,
+      format: "ruler",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      validationErrors: validationErrors.length > 0 ? validationErrors : void 0,
+      lossyConversion,
+      qualityScore: Math.max(0, qualityScore)
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "ruler",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function convertContent6(content, warnings) {
+  const parts = [];
+  const metadataSection = content.sections.find((s) => s.type === "metadata");
+  if (metadataSection) {
+    if (metadataSection.data.title) {
+      parts.push(`# ${metadataSection.data.title}
+`);
+    }
+    if (metadataSection.data.description) {
+      parts.push(`${metadataSection.data.description}
+`);
+    }
+  }
+  for (const section of content.sections) {
+    if (section.type === "metadata") {
+      continue;
+    } else if (section.type === "instructions") {
+      const instructionsSection = section;
+      parts.push(`## ${instructionsSection.title}
+`);
+      parts.push(`${instructionsSection.content}
+`);
+    } else if (section.type === "rules") {
+      const rulesSection = section;
+      parts.push(`## ${rulesSection.title}
+`);
+      for (const rule of rulesSection.items) {
+        parts.push(convertRule(rule));
+      }
+    } else if (section.type === "examples") {
+      const examplesSection = section;
+      parts.push(`## ${examplesSection.title}
+`);
+      for (const example of examplesSection.examples) {
+        parts.push(convertExample(example));
+      }
+    } else if (section.type === "custom") {
+      const customSection = section;
+      if (customSection.title) {
+        parts.push(`## ${customSection.title}
+`);
+      }
+      parts.push(`${customSection.content}
+`);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function convertRule(rule) {
+  const parts = [];
+  parts.push(`- ${rule.content}`);
+  if (rule.rationale) {
+    parts.push(`
+  *Rationale:* ${rule.rationale}`);
+  }
+  if (rule.examples && rule.examples.length > 0) {
+    parts.push(`
+  *Examples:*`);
+    for (const example of rule.examples) {
+      parts.push(`
+  \`\`\`
+  ${example}
+  \`\`\``);
+    }
+  }
+  parts.push("\n");
+  return parts.join("");
+}
+function convertExample(example) {
+  const parts = [];
+  if (example.description) {
+    parts.push(`### ${example.description}
+`);
+  }
+  if (example.good !== void 0) {
+    parts.push(`*${example.good ? "Good" : "Bad"} example*
+`);
+  }
+  if (example.code) {
+    const lang = example.language || "";
+    parts.push("```" + lang);
+    parts.push(example.code);
+    parts.push("```\n");
+  }
+  return parts.join("\n");
+}
+function isRulerFormat(content) {
+  const lines = content.trim().split("\n");
+  if (lines[0] === "---") {
+    return false;
+  }
+  const hasHeaders = /^#+\s/.test(content);
+  const hasRuleContent = /rule|instruction|guideline|convention/i.test(content);
+  return hasHeaders || hasRuleContent;
+}
+var init_to_ruler = __esm({
+  "../converters/dist/to-ruler.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_validation();
+  }
+});
+
+// ../converters/dist/to-droid.js
+var init_to_droid = __esm({
+  "../converters/dist/to-droid.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_js_yaml();
+  }
+});
+
 // ../converters/dist/index.js
 var init_dist = __esm({
   "../converters/dist/index.js"() {
@@ -10356,17 +11303,25 @@ var init_dist = __esm({
     init_from_continue();
     init_from_copilot();
     init_from_kiro();
+    init_from_kiro_agent();
     init_from_windsurf();
     init_from_agents_md();
     init_from_gemini();
+    init_from_opencode();
+    init_from_ruler();
+    init_from_droid();
     init_to_cursor();
     init_to_claude();
     init_to_continue();
     init_to_copilot();
     init_to_kiro();
+    init_to_kiro_agent();
     init_to_windsurf();
     init_to_agents_md();
     init_to_gemini();
+    init_to_opencode();
+    init_to_ruler();
+    init_to_droid();
     init_taxonomy_utils();
     init_validation();
   }
@@ -10395,8 +11350,13 @@ function getPackageIcon2(format, subtype) {
     "copilot": "\u2708\uFE0F",
     "kiro": "\u{1F3AF}",
     "gemini": "\u2728",
+    "gemini.md": "\u2728",
+    "claude.md": "\u{1F916}",
+    "opencode": "\u26A1",
+    "droid": "\u{1F3ED}",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
+    "ruler": "\u{1F4CF}",
     "generic": "\u{1F4E6}"
   };
   return subtypeIcons[subtype] || formatIcons[format] || "\u{1F4E6}";
@@ -10410,8 +11370,13 @@ function getPackageLabel2(format, subtype) {
     "copilot": "GitHub Copilot",
     "kiro": "Kiro",
     "gemini": "Gemini",
+    "gemini.md": "Gemini",
+    "claude.md": "Claude",
+    "opencode": "OpenCode",
+    "droid": "Factory Droid",
     "mcp": "MCP",
     "agents.md": "Agents.md",
+    "ruler": "Ruler",
     "generic": ""
   };
   const subtypeLabels = {
@@ -10596,10 +11561,13 @@ async function handleInstall(packageSpec, options) {
         throw new CLIError("Format conversion is only supported for single-file packages");
       }
       const sourceContent = extractedFiles[0].content;
+      const scopeMatch = packageId.match(/^@([^/]+)\//);
+      const author = scopeMatch ? scopeMatch[1] : "unknown";
       const metadata = {
         id: packageId,
         name: pkg.name || packageId,
         version: actualVersion,
+        author,
         tags: pkg.tags || []
       };
       let canonicalPkg;
@@ -10695,6 +11663,7 @@ async function handleInstall(packageSpec, options) {
       locationOverride = void 0;
     }
     let destPath;
+    let destDir = "";
     let fileCount = 0;
     let hookMetadata = void 0;
     if (format === "claude-md") {
@@ -10706,10 +11675,10 @@ async function handleInstall(packageSpec, options) {
       await saveFile(destPath, mainFile);
       fileCount = 1;
     } else if (extractedFiles.length === 1) {
-      let destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
+      destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
       if (locationOverride && effectiveFormat === "cursor") {
         const relativeDestDir = destDir.startsWith("./") ? destDir.slice(2) : destDir;
-        destDir = import_path8.default.join(locationOverride, relativeDestDir);
+        destDir = import_path9.default.join(locationOverride, relativeDestDir);
         console.log(`   \u{1F4C1} Installing Cursor package to custom location: ${destDir}`);
       }
       let mainFile = extractedFiles[0].content;
@@ -10719,26 +11688,35 @@ async function handleInstall(packageSpec, options) {
         destPath = `${destDir}/SKILL.md`;
       } else if (effectiveFormat === "claude" && effectiveSubtype === "hook") {
         destPath = `${destDir}/settings.json`;
-      } else if (effectiveFormat === "agents.md") {
-        let targetPath = "AGENTS.md";
-        if (locationOverride) {
-          targetPath = import_path8.default.join(locationOverride, "AGENTS.override.md");
-          console.log(`   \u{1F4C1} Installing Agents.md package to custom location: ${targetPath}`);
-        }
-        destPath = targetPath;
-        if (await fileExists(destPath)) {
-          if (options.force) {
-            console.log(`   \u26A0\uFE0F  ${destPath} already exists - overwriting (forced).`);
-          } else {
-            console.log(`   \u26A0\uFE0F  ${destPath} already exists.`);
-            const overwrite = await promptYesNo(
-              `   Overwrite existing ${destPath}? (y/N): `,
-              `   \u26A0\uFE0F  Non-interactive terminal detected. Remove or rename ${destPath} to continue.`
-            );
-            if (!overwrite) {
-              console.log(`   \u{1F6AB} Skipping install to avoid overwriting ${destPath}`);
-              success = true;
-              return;
+      } else if (effectiveFormat === "agents.md" || effectiveFormat === "gemini.md" || effectiveFormat === "claude.md") {
+        if (effectiveSubtype === "skill") {
+          destPath = `${destDir}/SKILL.md`;
+          console.log(`   \u{1F4E6} Installing skill to ${destDir}/ for progressive disclosure`);
+        } else if (effectiveSubtype === "agent") {
+          destPath = `${destDir}/AGENT.md`;
+          console.log(`   \u{1F916} Installing agent to ${destDir}/ for progressive disclosure`);
+        } else {
+          const manifestFilename = getManifestFilename(effectiveFormat);
+          let targetPath = manifestFilename;
+          if (locationOverride) {
+            targetPath = import_path9.default.join(locationOverride, `${manifestFilename.replace(".md", ".override.md")}`);
+            console.log(`   \u{1F4C1} Installing to custom location: ${targetPath}`);
+          }
+          destPath = targetPath;
+          if (await fileExists(destPath)) {
+            if (options.force) {
+              console.log(`   \u26A0\uFE0F  ${destPath} already exists - overwriting (forced).`);
+            } else {
+              console.log(`   \u26A0\uFE0F  ${destPath} already exists.`);
+              const overwrite = await promptYesNo(
+                `   Overwrite existing ${destPath}? (y/N): `,
+                `   \u26A0\uFE0F  Non-interactive terminal detected. Remove or rename ${destPath} to continue.`
+              );
+              if (!overwrite) {
+                console.log(`   \u{1F6AB} Skipping install to avoid overwriting ${destPath}`);
+                success = true;
+                return;
+              }
             }
           }
         }
@@ -10819,10 +11797,10 @@ async function handleInstall(packageSpec, options) {
       await saveFile(destPath, mainFile);
       fileCount = 1;
     } else {
-      let destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
+      destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
       if (locationOverride && effectiveFormat === "cursor") {
         const relativeDestDir = destDir.startsWith("./") ? destDir.slice(2) : destDir;
-        destDir = import_path8.default.join(locationOverride, relativeDestDir);
+        destDir = import_path9.default.join(locationOverride, relativeDestDir);
         console.log(`   \u{1F4C1} Installing Cursor package to custom location: ${destDir}`);
       }
       const packageName = stripAuthorNamespace2(packageId);
@@ -10905,6 +11883,35 @@ ${afterFrontmatter}`;
         }
       }
     }
+    let progressiveDisclosureMetadata;
+    if ((effectiveFormat === "agents.md" || effectiveFormat === "gemini.md" || effectiveFormat === "claude.md") && (effectiveSubtype === "skill" || effectiveSubtype === "agent") && !options.noAppend) {
+      if (!destDir) {
+        throw new Error("Internal error: destDir not set for progressive disclosure installation");
+      }
+      const manifestPath = options.manifestFile || getManifestFilename(effectiveFormat);
+      const resourceName = stripAuthorNamespace2(packageId);
+      const resourceType = effectiveSubtype;
+      const mainFile = resourceType === "agent" ? "AGENT.md" : "SKILL.md";
+      const manifestEntry = {
+        name: resourceName,
+        description: pkg.description || `${pkg.name} ${resourceType}`,
+        skillPath: destDir,
+        mainFile,
+        resourceType
+      };
+      await addSkillToManifest(manifestEntry, manifestPath);
+      console.log(`   \u2713 Added ${resourceType} to ${manifestPath} manifest`);
+      progressiveDisclosureMetadata = {
+        mode: "progressive",
+        resourceDir: destDir,
+        manifestPath,
+        resourceName,
+        resourceType,
+        // Legacy fields for backward compatibility
+        skillsDir: destDir,
+        skillName: resourceName
+      };
+    }
     const updatedLockfile = lockfile || createLockfile();
     addToLockfile(updatedLockfile, packageId, {
       version: actualVersion || version,
@@ -10917,8 +11924,9 @@ ${afterFrontmatter}`;
       sourceSubtype: pkg.subtype,
       installedPath: destPath,
       fromCollection: options.fromCollection,
-      hookMetadata
+      hookMetadata,
       // Track hook installation metadata for uninstall
+      progressiveDisclosure: progressiveDisclosureMetadata
     });
     setPackageIntegrity(updatedLockfile, packageId, tarball);
     await writeLockfile(updatedLockfile);
@@ -10932,6 +11940,14 @@ ${afterFrontmatter}`;
 \u2705 Successfully installed ${packageId}`);
     console.log(`   \u{1F4C1} Saved to: ${destPath}`);
     console.log(`   \u{1F512} Lock file updated`);
+    if (progressiveDisclosureMetadata && !options.noAppend) {
+      const manifestFile = progressiveDisclosureMetadata.manifestPath;
+      console.log(`
+\u{1F393} Skill installed with progressive disclosure`);
+      console.log(`   \u{1F4DD} Skill added to ${manifestFile} manifest`);
+      console.log(`   \u{1F4A1} The skill is available but not loaded into context by default`);
+      console.log(`   \u26A1 To activate: Add skill usage to your code or let the agent discover it`);
+    }
     console.log(`
 \u{1F4A1} This package has been downloaded ${newDownloadCount.toLocaleString()} times`);
     success = true;
@@ -10973,7 +11989,7 @@ async function extractTarball(tarball, packageId) {
   } catch (error) {
     throw new CLIError(`Package decompression failed: ${error.message}`);
   }
-  const tmpDir = await import_promises2.default.mkdtemp(import_path8.default.join(import_os3.default.tmpdir(), "prpm-"));
+  const tmpDir = await import_promises2.default.mkdtemp(import_path9.default.join(import_os3.default.tmpdir(), "prpm-"));
   const cleanup = async () => {
     try {
       await import_promises2.default.rm(tmpDir, { recursive: true, force: true });
@@ -11013,15 +12029,15 @@ async function extractTarball(tarball, packageId) {
     await cleanup();
   }
 }
-async function collectExtractedFiles(rootDir, excludedNames, fs10) {
+async function collectExtractedFiles(rootDir, excludedNames, fs12) {
   const files = [];
   const dirs = [rootDir];
   while (dirs.length > 0) {
     const currentDir = dirs.pop();
     if (!currentDir) continue;
-    const entries = await fs10.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs12.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path8.default.join(currentDir, entry.name);
+      const fullPath = import_path9.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         dirs.push(fullPath);
         continue;
@@ -11032,8 +12048,8 @@ async function collectExtractedFiles(rootDir, excludedNames, fs10) {
       if (excludedNames.has(entry.name)) {
         continue;
       }
-      const content = await fs10.readFile(fullPath, "utf-8");
-      const relativePath = import_path8.default.relative(rootDir, fullPath).split(import_path8.default.sep).join("/");
+      const content = await fs12.readFile(fullPath, "utf-8");
+      const relativePath = import_path9.default.relative(rootDir, fullPath).split(import_path9.default.sep).join("/");
       files.push({
         name: relativePath,
         content
@@ -11043,7 +12059,7 @@ async function collectExtractedFiles(rootDir, excludedNames, fs10) {
   return files;
 }
 async function installFromLockfile(options) {
-  var _a;
+  var _a, _b;
   try {
     const lockfile = await readLockfile();
     if (!lockfile) {
@@ -11065,13 +12081,14 @@ async function installFromLockfile(options) {
         console.log(`  Installing ${packageId}...`);
         let locationOverride = options.location;
         if (!locationOverride && lockEntry.format === "agents.md" && lockEntry.installedPath) {
-          const baseName = import_path8.default.basename(lockEntry.installedPath);
+          const baseName = import_path9.default.basename(lockEntry.installedPath);
           if (baseName === "AGENTS.override.md") {
-            locationOverride = import_path8.default.dirname(lockEntry.installedPath);
+            locationOverride = import_path9.default.dirname(lockEntry.installedPath);
           } else if (baseName !== "AGENTS.md") {
-            locationOverride = import_path8.default.dirname(lockEntry.installedPath);
+            locationOverride = import_path9.default.dirname(lockEntry.installedPath);
           }
         }
+        const manifestFile = (_a = lockEntry.progressiveDisclosure) == null ? void 0 : _a.manifestPath;
         await handleInstall(packageSpec, {
           version: lockEntry.version,
           as: options.as || lockEntry.format,
@@ -11079,7 +12096,8 @@ async function installFromLockfile(options) {
           frozenLockfile: options.frozenLockfile,
           force: true,
           // Force reinstall when installing from lockfile
-          location: locationOverride
+          location: locationOverride,
+          manifestFile
         });
         successCount++;
       } catch (error) {
@@ -11088,7 +12106,7 @@ async function installFromLockfile(options) {
         } else {
           failCount++;
           console.error(`  \u274C Failed to install ${packageId}:`);
-          console.error(`     Type: ${(_a = error == null ? void 0 : error.constructor) == null ? void 0 : _a.name}`);
+          console.error(`     Type: ${(_b = error == null ? void 0 : error.constructor) == null ? void 0 : _b.name}`);
           console.error(`     Message: ${error instanceof Error ? error.message : String(error)}`);
           if (error instanceof CLIError) {
             console.error(`     ExitCode: ${error.exitCode}`);
@@ -11110,9 +12128,9 @@ 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 (cursor, claude, continue, windsurf, copilot, kiro, agents.md, canonical)").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)").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 (cursor, claude, continue, windsurf, copilot, kiro, agents.md, gemini.md, claude.md, canonical)").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 (default: AGENTS.md)", "AGENTS.md").action(async (packageSpec, options) => {
     const convertTo = options.format || options.as;
-    if (convertTo && !["cursor", "claude", "continue", "windsurf", "copilot", "kiro", "agents.md", "canonical", "gemini"].includes(convertTo)) {
+    if (convertTo && !["cursor", "claude", "continue", "windsurf", "copilot", "kiro", "agents.md", "gemini.md", "claude.md", "canonical", "gemini"].includes(convertTo)) {
       throw new CLIError("\u274C Format must be one of: cursor, claude, continue, windsurf, copilot, kiro, agents.md, canonical, gemini\n\n\u{1F4A1} Examples:\n   prpm install my-package --as cursor       # Convert to Cursor format\n   prpm install my-package --format claude   # Convert to Claude format\n   prpm install my-package --format kiro     # Convert to Kiro format\n   prpm install my-package --format agents.md # Convert to Agents.md format\n   prpm install my-package                   # Install in native format", 1);
     }
     if (!packageSpec) {
@@ -11129,12 +12147,14 @@ function createInstallCommand() {
       as: convertTo,
       subtype: options.subtype,
       frozenLockfile: options.frozenLockfile,
-      location: options.location
+      location: options.location,
+      noAppend: options.noAppend,
+      manifestFile: options.manifestFile
     });
   });
   return command;
 }
-var import_commander11, import_chalk, import_registry_client5, import_stream, import_promises, tar, import_path8, import_zlib, import_promises2, import_os3;
+var import_commander11, import_chalk, import_registry_client5, import_stream, import_promises, tar, import_path9, import_zlib, import_promises2, import_os3;
 var init_install = __esm({
   "src/commands/install.ts"() {
     "use strict";
@@ -11150,7 +12170,7 @@ var init_install = __esm({
     tar = __toESM(require("tar"));
     init_errors();
     init_prompts();
-    import_path8 = __toESM(require("path"));
+    import_path9 = __toESM(require("path"));
     import_zlib = __toESM(require("zlib"));
     import_promises2 = __toESM(require("fs/promises"));
     import_os3 = __toESM(require("os"));
@@ -11158,15 +12178,16 @@ var init_install = __esm({
     init_lockfile();
     init_cursor_config();
     init_claude_config();
+    init_agents_md_progressive();
     init_dist();
   }
 });
 
 // src/index.ts
 init_cjs_shims();
-var import_commander28 = require("commander");
-var import_fs13 = require("fs");
-var import_path16 = require("path");
+var import_commander29 = require("commander");
+var import_fs15 = require("fs");
+var import_path18 = require("path");
 
 // src/commands/list.ts
 init_cjs_shims();
@@ -11325,8 +12346,9 @@ init_cjs_shims();
 var import_commander2 = require("commander");
 init_lockfile();
 init_filesystem();
-var import_fs6 = require("fs");
+var import_fs7 = require("fs");
 init_errors();
+init_agents_md_progressive();
 async function handleUninstall(name) {
   try {
     console.log(`\u{1F5D1}\uFE0F  Uninstalling package: ${name}`);
@@ -11334,10 +12356,22 @@ async function handleUninstall(name) {
     if (!pkg) {
       throw new CLIError(`\u274C Package "${name}" not found`, 1);
     }
+    if (pkg.progressiveDisclosure) {
+      const { manifestPath, resourceName, skillName } = pkg.progressiveDisclosure;
+      const name2 = resourceName || skillName;
+      if (name2) {
+        try {
+          await removeSkillFromManifest(name2, manifestPath);
+          console.log(`   \u{1F4DD} Removed from ${manifestPath} manifest`);
+        } catch (error) {
+          console.warn(`   \u26A0\uFE0F  Failed to remove from manifest: ${error}`);
+        }
+      }
+    }
     if (pkg.format === "claude" && pkg.subtype === "hook" && pkg.hookMetadata) {
       const settingsPath = pkg.installedPath || ".claude/settings.json";
       try {
-        const settingsContent = await import_fs6.promises.readFile(settingsPath, "utf-8");
+        const settingsContent = await import_fs7.promises.readFile(settingsPath, "utf-8");
         const settings = JSON.parse(settingsContent);
         if (settings.hooks) {
           let removedCount = 0;
@@ -11354,7 +12388,7 @@ async function handleUninstall(name) {
               }
             }
           }
-          await import_fs6.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+          await import_fs7.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
           console.log(`   \u{1FA9D} Removed ${removedCount} hook(s) from ${settingsPath}`);
         }
       } catch (error) {
@@ -11379,12 +12413,12 @@ async function handleUninstall(name) {
       throw new CLIError(`Cannot uninstall ${name}: installation path unknown`, 1);
     }
     try {
-      const stats = await import_fs6.promises.stat(targetPath);
+      const stats = await import_fs7.promises.stat(targetPath);
       if (stats.isDirectory()) {
-        await import_fs6.promises.rm(targetPath, { recursive: true, force: true });
+        await import_fs7.promises.rm(targetPath, { recursive: true, force: true });
         console.log(`   \u{1F5D1}\uFE0F  Deleted directory: ${targetPath}`);
       } else if (stats.isFile()) {
-        await import_fs6.promises.unlink(targetPath);
+        await import_fs7.promises.unlink(targetPath);
         console.log(`   \u{1F5D1}\uFE0F  Deleted file: ${targetPath}`);
       }
     } catch (error) {
@@ -11412,17 +12446,17 @@ function createUninstallCommand() {
 // src/commands/index.ts
 init_cjs_shims();
 var import_commander3 = require("commander");
-var import_fs7 = require("fs");
-var import_path6 = __toESM(require("path"));
+var import_fs8 = require("fs");
+var import_path7 = __toESM(require("path"));
 init_lockfile();
 init_filesystem();
 init_errors();
 async function scanDirectory(dirPath, format, subtype) {
   try {
-    const files = await import_fs7.promises.readdir(dirPath, { withFileTypes: true });
+    const files = await import_fs8.promises.readdir(dirPath, { withFileTypes: true });
     const results = [];
     for (const file of files) {
-      const fullPath = import_path6.default.join(dirPath, file.name);
+      const fullPath = import_path7.default.join(dirPath, file.name);
       if (file.isFile()) {
         const id = generateId(file.name);
         results.push({
@@ -11435,11 +12469,11 @@ async function scanDirectory(dirPath, format, subtype) {
         const isCursorAgent = format === "cursor" && subtype === "agent";
         if (isClaudeType || isCursorAgent) {
           try {
-            const subFiles = await import_fs7.promises.readdir(fullPath, { withFileTypes: true });
+            const subFiles = await import_fs8.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_path6.default.join(fullPath, subFile.name);
+                const subFilePath = import_path7.default.join(fullPath, subFile.name);
                 const id = file.name;
                 results.push({
                   filePath: subFilePath,
@@ -11501,7 +12535,7 @@ async function handleIndex(options = {}) {
             id: file.id,
             version: "0.0.0",
             // Local files don't have versions
-            tarballUrl: `file://${import_path6.default.resolve(file.filePath)}`,
+            tarballUrl: `file://${import_path7.default.resolve(file.filePath)}`,
             format: dir.format,
             subtype: dir.subtype
           });
@@ -11767,8 +12801,13 @@ function getPackageIcon(format, subtype) {
     "copilot": "\u2708\uFE0F",
     "kiro": "\u{1F3AF}",
     "gemini": "\u2728",
+    "gemini.md": "\u2728",
+    "claude.md": "\u{1F916}",
+    "opencode": "\u26A1",
+    "droid": "\u{1F3ED}",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
+    "ruler": "\u{1F4CF}",
     "generic": "\u{1F4E6}"
   };
   return subtypeIcons[subtype] || formatIcons[format] || "\u{1F4E6}";
@@ -11782,8 +12821,13 @@ function getPackageLabel(format, subtype) {
     "copilot": "GitHub Copilot",
     "kiro": "Kiro",
     "gemini": "Gemini",
+    "gemini.md": "Gemini",
+    "claude.md": "Claude",
+    "opencode": "OpenCode",
+    "droid": "Factory Droid",
     "mcp": "MCP",
     "agents.md": "Agents.md",
+    "ruler": "Ruler",
     "generic": ""
   };
   const subtypeLabels = {
@@ -11991,6 +13035,22 @@ Try:`);
 \u{1F310} View in browser: ${webappUrl}`);
       return;
     }
+    if (result.fallback) {
+      console.log("\n\u274C No packages found for your search");
+      let filterMsg = "";
+      if (options.subtype) {
+        filterMsg = ` (${options.subtype}`;
+        if (options.format) {
+          filterMsg += ` for ${options.format}`;
+        }
+        filterMsg += ")";
+      } else if (options.format) {
+        filterMsg = ` (${options.format} format)`;
+      }
+      console.log(`
+\u{1F4A1} Showing top 10 most popular packages${filterMsg} instead:
+`);
+    }
     const totalPages = Math.ceil(result.total / limit);
     const shouldPaginate = options.interactive !== false && totalPages > 1;
     if (!shouldPaginate) {
@@ -12292,7 +13352,7 @@ init_install();
 init_cjs_shims();
 var import_commander12 = require("commander");
 var import_promises6 = require("fs/promises");
-var import_path12 = require("path");
+var import_path13 = require("path");
 var tar2 = __toESM(require("tar"));
 var import_os4 = require("os");
 var import_crypto2 = require("crypto");
@@ -12465,19 +13525,19 @@ function validateMarketplaceJson(data) {
 init_cjs_shims();
 var import_ajv2 = __toESM(require("ajv"));
 var import_ajv_formats2 = __toESM(require("ajv-formats"));
-var import_fs9 = require("fs");
-var import_path9 = require("path");
+var import_fs10 = require("fs");
+var import_path10 = require("path");
 var schema2;
 var schemaCandidates = [
   // Source file layout (src/core → ../../schemas)
-  (0, import_path9.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
+  (0, import_path10.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
   // Bundled layout (dist/index.js → ../schemas)
-  (0, import_path9.join)(__dirname, "../schemas/prpm-manifest.schema.json")
+  (0, import_path10.join)(__dirname, "../schemas/prpm-manifest.schema.json")
 ];
 for (const candidate of schemaCandidates) {
   try {
-    if ((0, import_fs9.existsSync)(candidate)) {
-      schema2 = JSON.parse((0, import_fs9.readFileSync)(candidate, "utf-8"));
+    if ((0, import_fs10.existsSync)(candidate)) {
+      schema2 = JSON.parse((0, import_fs10.readFileSync)(candidate, "utf-8"));
       break;
     }
   } catch {
@@ -12499,27 +13559,27 @@ function validateManifestSchema(manifest) {
   const valid = validate(manifest);
   if (!valid && validate.errors) {
     const errors = validate.errors.map((err) => {
-      const path7 = err.instancePath || "manifest";
+      const path8 = err.instancePath || "manifest";
       const message = err.message || "validation failed";
       if (err.keyword === "required") {
         const missingProp = err.params.missingProperty;
         return `Missing required field: ${missingProp}`;
       }
       if (err.keyword === "pattern") {
-        return `${path7}: ${message}. Value does not match required pattern.`;
+        return `${path8}: ${message}. Value does not match required pattern.`;
       }
       if (err.keyword === "enum") {
         const allowedValues = err.params.allowedValues;
-        return `${path7}: ${message}. Allowed values: ${allowedValues.join(", ")}`;
+        return `${path8}: ${message}. Allowed values: ${allowedValues.join(", ")}`;
       }
       if (err.keyword === "minLength" || err.keyword === "maxLength") {
         const limit = err.params.limit;
-        return `${path7}: ${message} (${err.keyword}: ${limit})`;
+        return `${path8}: ${message} (${err.keyword}: ${limit})`;
       }
       if (err.keyword === "oneOf") {
-        return `${path7}: must match exactly one schema (check if files array uses either all strings or all objects, not mixed)`;
+        return `${path8}: must match exactly one schema (check if files array uses either all strings or all objects, not mixed)`;
       }
-      return `${path7}: ${message}`;
+      return `${path8}: ${message}`;
     });
     return { valid: false, errors };
   }
@@ -12532,8 +13592,8 @@ function getManifestSchema() {
 // src/utils/license-extractor.ts
 init_cjs_shims();
 var import_promises3 = require("fs/promises");
-var import_path10 = require("path");
-var import_fs10 = require("fs");
+var import_path11 = require("path");
+var import_fs11 = require("fs");
 var LICENSE_FILE_PATTERNS = [
   "LICENSE",
   "LICENSE.md",
@@ -12582,9 +13642,9 @@ function generateLicenseUrl(repositoryUrl, fileName) {
 async function extractLicenseInfo(repositoryUrl) {
   const cwd = process.cwd();
   for (const fileName of LICENSE_FILE_PATTERNS) {
-    const filePath = (0, import_path10.join)(cwd, fileName);
+    const filePath = (0, import_path11.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);
@@ -12618,7 +13678,7 @@ function validateLicenseInfo(licenseInfo, packageName) {
 // src/utils/snippet-extractor.ts
 init_cjs_shims();
 var import_promises4 = require("fs/promises");
-var import_path11 = require("path");
+var import_path12 = require("path");
 var MAX_SNIPPET_LENGTH = 2e3;
 async function extractSnippet(manifest) {
   const cwd = process.cwd();
@@ -12634,7 +13694,7 @@ async function extractSnippet(manifest) {
       const firstFile = manifest.files[0];
       fileName = typeof firstFile === "string" ? firstFile : firstFile.path;
     }
-    const fullPath = (0, import_path11.join)(cwd, fileName);
+    const fullPath = (0, import_path12.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`);
@@ -12860,13 +13920,13 @@ async function validatePackageFiles(manifest) {
     }
   }
   if (manifest.format === "claude" && manifest.subtype === "skill") {
-    const hasSkillMd = filePaths.some((path7) => path7.endsWith("/SKILL.md") || path7 === "SKILL.md");
+    const hasSkillMd = filePaths.some((path8) => path8.endsWith("/SKILL.md") || path8 === "SKILL.md");
     if (!hasSkillMd) {
       errors.push("Claude skills must contain a SKILL.md file");
     }
   }
   if (manifest.format === "windsurf") {
-    const hasWindsurfRules = filePaths.some((path7) => path7.includes(".windsurf/rules"));
+    const hasWindsurfRules = filePaths.some((path8) => path8.includes(".windsurf/rules"));
     if (!hasWindsurfRules) {
       warnings.push("Windsurf packages typically use .windsurf/rules filename");
     }
@@ -12876,7 +13936,7 @@ async function validatePackageFiles(manifest) {
 
 // src/commands/publish.ts
 async function findAndLoadManifests() {
-  const prpmJsonPath = (0, import_path12.join)(process.cwd(), "prpm.json");
+  const prpmJsonPath = (0, import_path13.join)(process.cwd(), "prpm.json");
   let prpmJsonExists = false;
   let prpmJsonError = null;
   try {
@@ -12928,7 +13988,7 @@ async function findAndLoadManifests() {
       throw error;
     }
   }
-  const marketplaceJsonPath = (0, import_path12.join)(process.cwd(), ".claude", "marketplace.json");
+  const marketplaceJsonPath = (0, import_path13.join)(process.cwd(), ".claude", "marketplace.json");
   try {
     const content = await (0, import_promises6.readFile)(marketplaceJsonPath, "utf-8");
     const marketplaceData = JSON.parse(content);
@@ -12944,7 +14004,7 @@ async function findAndLoadManifests() {
     return { manifests, collections: [], source: ".claude/marketplace.json" };
   } catch (error) {
   }
-  const marketplaceJsonPluginPath = (0, import_path12.join)(process.cwd(), ".claude-plugin", "marketplace.json");
+  const marketplaceJsonPluginPath = (0, import_path13.join)(process.cwd(), ".claude-plugin", "marketplace.json");
   try {
     const content = await (0, import_promises6.readFile)(marketplaceJsonPluginPath, "utf-8");
     const marketplaceData = JSON.parse(content);
@@ -12988,7 +14048,7 @@ function validateManifest(manifest, contextLabel) {
   }
   if (manifest.format === "claude" && manifest.subtype === "skill") {
     const filePaths = normalizeFilePaths2(manifest.files);
-    const hasSkillMd = filePaths.some((path7) => path7.endsWith("/SKILL.md") || path7 === "SKILL.md");
+    const hasSkillMd = filePaths.some((path8) => path8.endsWith("/SKILL.md") || path8 === "SKILL.md");
     if (!hasSkillMd) {
       throw new Error(
         `${prefix}Claude skills must contain a SKILL.md file.
@@ -13061,8 +14121,8 @@ function predictScopedPackageName(manifestName, username, organization) {
   return manifestName;
 }
 async function createTarball(manifest) {
-  const tmpDir = (0, import_path12.join)((0, import_os4.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
-  const tarballPath = (0, import_path12.join)(tmpDir, "package.tar.gz");
+  const tmpDir = (0, import_path13.join)((0, import_os4.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
+  const tarballPath = (0, import_path13.join)(tmpDir, "package.tar.gz");
   try {
     await (0, import_promises6.mkdir)(tmpDir, { recursive: true });
     const filePaths = normalizeFilePaths2(manifest.files);
@@ -13123,7 +14183,7 @@ async function handlePublish(options) {
     const { manifests, collections, source } = await findAndLoadManifests();
     if (source === "prpm.json (multi-package)" || source === "prpm.json") {
       try {
-        const prpmJsonPath = (0, import_path12.join)(process.cwd(), "prpm.json");
+        const prpmJsonPath = (0, import_path13.join)(process.cwd(), "prpm.json");
         const prpmContent = await (0, import_promises6.readFile)(prpmJsonPath, "utf-8");
         const prpmManifest = JSON.parse(prpmContent);
         if (prpmManifest.scripts) {
@@ -14117,8 +15177,8 @@ function createSchemaCommand() {
 init_cjs_shims();
 var import_commander19 = require("commander");
 var import_promises7 = require("fs/promises");
-var import_path13 = require("path");
-var import_fs11 = require("fs");
+var import_path14 = require("path");
+var import_fs12 = require("fs");
 var readline3 = __toESM(require("readline/promises"));
 var import_process = require("process");
 
@@ -14485,12 +15545,12 @@ function getDefaultAuthor() {
 async function createExampleFiles(format, files, packageName) {
   const templates = EXAMPLE_TEMPLATES[format] || {};
   for (const file of files) {
-    const filePath = (0, import_path13.join)(process.cwd(), file);
-    const dirPath = (0, import_path13.join)(filePath, "..");
-    if (!(0, import_fs11.existsSync)(dirPath)) {
+    const filePath = (0, import_path14.join)(process.cwd(), file);
+    const dirPath = (0, import_path14.join)(filePath, "..");
+    if (!(0, import_fs12.existsSync)(dirPath)) {
       await (0, import_promises7.mkdir)(dirPath, { recursive: true });
     }
-    if ((0, import_fs11.existsSync)(filePath)) {
+    if ((0, import_fs12.existsSync)(filePath)) {
       console.log(`  Skipping ${file} (already exists)`);
       continue;
     }
@@ -14504,8 +15564,8 @@ Add your content here.
   }
 }
 async function createReadme(config) {
-  const readmePath = (0, import_path13.join)(process.cwd(), "README.md");
-  if ((0, import_fs11.existsSync)(readmePath)) {
+  const readmePath = (0, import_path14.join)(process.cwd(), "README.md");
+  if ((0, import_fs12.existsSync)(readmePath)) {
     console.log("  Skipping README.md (already exists)");
     return;
   }
@@ -14539,8 +15599,8 @@ ${config.license}
   console.log("  Created README.md");
 }
 async function initPackage(options) {
-  const manifestPath = (0, import_path13.join)(process.cwd(), "prpm.json");
-  if ((0, import_fs11.existsSync)(manifestPath) && !options.force) {
+  const manifestPath = (0, import_path14.join)(process.cwd(), "prpm.json");
+  if ((0, import_fs12.existsSync)(manifestPath) && !options.force) {
     throw new Error(
       "prpm.json already exists. Use --force to overwrite, or run this command in a different directory."
     );
@@ -14839,15 +15899,15 @@ function createConfigCommand() {
 init_cjs_shims();
 var import_commander21 = require("commander");
 var import_promises8 = require("fs/promises");
-var import_path14 = require("path");
+var import_path15 = require("path");
 init_telemetry();
 init_lockfile();
 init_errors();
 function detectPackageInfo(filePath, content) {
-  const fileName = (0, import_path14.basename)(filePath);
+  const fileName = (0, import_path15.basename)(filePath);
   const lowerFileName = fileName.toLowerCase();
   if (fileName === "SKILL.md") {
-    const dirName = (0, import_path14.basename)((0, import_path14.join)(filePath, ".."));
+    const dirName = (0, import_path15.basename)((0, import_path15.join)(filePath, ".."));
     return {
       format: "claude",
       subtype: "skill",
@@ -14899,8 +15959,8 @@ async function scanDirectory2(dirPath, baseDir, scanDir, maxDepth = 5, currentDe
   try {
     const entries = await (0, import_promises8.readdir)(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_path14.join)(dirPath, entry.name);
-      const relativePath = (0, import_path14.relative)(baseDir, fullPath);
+      const fullPath = (0, import_path15.join)(dirPath, entry.name);
+      const relativePath = (0, import_path15.relative)(baseDir, fullPath);
       if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name === "build") {
         continue;
       }
@@ -15037,7 +16097,7 @@ async function handleCatalog(directories, options) {
       success = true;
       return;
     }
-    const prpmJsonPath = options.output || (0, import_path14.join)(process.cwd(), "prpm.json");
+    const prpmJsonPath = options.output || (0, import_path15.join)(process.cwd(), "prpm.json");
     let manifest;
     if (options.append) {
       try {
@@ -15075,7 +16135,7 @@ async function handleCatalog(directories, options) {
       }
       let description = `${discovered.format} ${discovered.subtype}`;
       try {
-        const firstFilePath = (0, import_path14.join)(process.cwd(), discovered.scanDir, discovered.files[0]);
+        const firstFilePath = (0, import_path15.join)(process.cwd(), discovered.scanDir, discovered.files[0]);
         const content = await (0, import_promises8.readFile)(firstFilePath, "utf-8");
         const extractedDesc = extractDescription2(content);
         if (extractedDesc) {
@@ -15140,8 +16200,8 @@ var import_commander22 = require("commander");
 init_user_config();
 init_telemetry();
 var readline4 = __toESM(require("readline"));
-var fs9 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 init_errors();
 function createReadline() {
   return readline4.createInterface({
@@ -15259,11 +16319,11 @@ async function runCustomPrompt(customPrompt, input2, options, sessionId) {
   return response.json();
 }
 function readPromptFile(filePath) {
-  const absolutePath = path6.resolve(filePath);
-  if (!fs9.existsSync(absolutePath)) {
+  const absolutePath = path7.resolve(filePath);
+  if (!fs10.existsSync(absolutePath)) {
     throw new Error(`Prompt file not found: ${filePath}`);
   }
-  return fs9.readFileSync(absolutePath, "utf-8");
+  return fs10.readFileSync(absolutePath, "utf-8");
 }
 function displayResponse(result, showStats = true) {
   const lastMessage = result.conversation[result.conversation.length - 1];
@@ -16326,52 +17386,57 @@ function createStarredCommand() {
 init_cjs_shims();
 var import_commander27 = require("commander");
 var import_promises9 = require("fs/promises");
-var import_path15 = require("path");
-var import_fs12 = require("fs");
+var import_path16 = require("path");
+var import_fs13 = require("fs");
 var import_readline = require("readline");
 var import_chalk2 = __toESM(require_source());
 init_errors();
 init_dist();
-function getDefaultPath(format, filename, subtype) {
-  const baseName = (0, import_path15.basename)(filename, (0, import_path15.extname)(filename));
+function getDefaultPath(format, filename, subtype, customName) {
+  const baseName = customName || (0, import_path16.basename)(filename, (0, import_path16.extname)(filename));
   switch (format) {
     case "cursor":
       if (subtype === "slash-command") {
-        return (0, import_path15.join)(process.cwd(), ".cursor", "commands", `${baseName}.md`);
+        return (0, import_path16.join)(process.cwd(), ".cursor", "commands", `${baseName}.md`);
       }
-      return (0, import_path15.join)(process.cwd(), ".cursor", "rules", `${baseName}.mdc`);
+      return (0, import_path16.join)(process.cwd(), ".cursor", "rules", `${baseName}.mdc`);
     case "claude":
       if (subtype === "skill") {
-        return (0, import_path15.join)(process.cwd(), ".claude", "skills", baseName, "SKILL.md");
+        return (0, import_path16.join)(process.cwd(), ".claude", "skills", baseName, "SKILL.md");
       } else if (subtype === "slash-command") {
-        return (0, import_path15.join)(process.cwd(), ".claude", "commands", `${baseName}.md`);
+        return (0, import_path16.join)(process.cwd(), ".claude", "commands", `${baseName}.md`);
       } else {
-        return (0, import_path15.join)(process.cwd(), ".claude", "agents", `${baseName}.md`);
+        return (0, import_path16.join)(process.cwd(), ".claude", "agents", `${baseName}.md`);
       }
     case "windsurf":
-      return (0, import_path15.join)(process.cwd(), ".windsurf", "rules", `${baseName}.md`);
+      return (0, import_path16.join)(process.cwd(), ".windsurf", "rules", `${baseName}.md`);
     case "kiro":
       if (subtype === "hook") {
-        return (0, import_path15.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
+        return (0, import_path16.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
       }
-      return (0, import_path15.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
+      if (subtype === "agent") {
+        return (0, import_path16.join)(process.cwd(), ".kiro", "agents", `${baseName}.json`);
+      }
+      return (0, import_path16.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
     case "copilot":
-      return (0, import_path15.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
+      return (0, import_path16.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
     case "continue":
       if (subtype === "slash-command" || subtype === "prompt") {
-        return (0, import_path15.join)(process.cwd(), ".continue", "prompts", `${baseName}.md`);
+        return (0, import_path16.join)(process.cwd(), ".continue", "prompts", `${baseName}.md`);
       }
-      return (0, import_path15.join)(process.cwd(), ".continue", "rules", `${baseName}.md`);
+      return (0, import_path16.join)(process.cwd(), ".continue", "rules", `${baseName}.md`);
     case "agents.md":
-      return (0, import_path15.join)(process.cwd(), "agents.md");
+      return (0, import_path16.join)(process.cwd(), "agents.md");
     case "gemini":
-      return (0, import_path15.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
+      return (0, import_path16.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
+    case "ruler":
+      return (0, import_path16.join)(process.cwd(), ".ruler", `${baseName}.md`);
     default:
       throw new CLIError(`Unknown format: ${format}`);
   }
 }
 function detectFormat(content, filepath) {
-  const ext = (0, import_path15.extname)(filepath).toLowerCase();
+  const ext = (0, import_path16.extname)(filepath).toLowerCase();
   if (ext === ".mdc" || filepath.includes(".cursor/rules") || filepath.includes(".cursor/commands")) {
     return "cursor";
   }
@@ -16393,12 +17458,15 @@ function detectFormat(content, filepath) {
   if (filepath.includes(".continue/rules") || filepath.includes(".continue/prompts") || filepath.includes(".continuerules")) {
     return "continue";
   }
-  if ((0, import_path15.basename)(filepath) === "agents.md") {
+  if ((0, import_path16.basename)(filepath) === "agents.md") {
     return "agents.md";
   }
   if (ext === ".toml" || filepath.includes(".gemini/commands")) {
     return "gemini";
   }
+  if (filepath.includes(".ruler/")) {
+    return "ruler";
+  }
   if (isClaudeFormat(content)) {
     if (content.includes("type: skill")) return "claude-skill";
     if (content.includes("type: agent")) return "claude-agent";
@@ -16411,6 +17479,7 @@ function detectFormat(content, filepath) {
   if (isCopilotFormat(content)) return "copilot";
   if (isContinueFormat(content)) return "continue";
   if (isAgentsMdFormat(content)) return "agents.md";
+  if (isRulerFormat(content)) return "ruler";
   return null;
 }
 async function confirmOverwrite(filepath) {
@@ -16474,7 +17543,12 @@ async function handleConvert(sourcePath, options) {
         canonicalPkg = fromWindsurf(content, metadata);
         break;
       case "kiro":
-        canonicalPkg = fromKiro(content, metadata);
+        if (isKiroAgentFormat(content)) {
+          const result2 = fromKiroAgent(content);
+          canonicalPkg = JSON.parse(result2.content);
+        } else {
+          canonicalPkg = fromKiro(content, metadata);
+        }
         break;
       case "copilot":
         canonicalPkg = fromCopilot(content, metadata);
@@ -16488,6 +17562,10 @@ async function handleConvert(sourcePath, options) {
       case "gemini":
         canonicalPkg = fromGemini(content, metadata);
         break;
+      case "ruler":
+        const rulerResult = fromRuler(content);
+        canonicalPkg = JSON.parse(rulerResult.content);
+        break;
       default:
         throw new CLIError(`Unsupported source format: ${sourceFormat}`);
     }
@@ -16512,10 +17590,14 @@ async function handleConvert(sourcePath, options) {
         result = toCopilot(canonicalPkg);
         break;
       case "kiro":
-        result = toKiro(canonicalPkg, {
-          kiroConfig: { inclusion: "always" }
-          // Default to always include
-        });
+        if (options.subtype === "agent") {
+          result = toKiroAgent(canonicalPkg);
+        } else {
+          result = toKiro(canonicalPkg, {
+            kiroConfig: { inclusion: "always" }
+            // Default to always include
+          });
+        }
         break;
       case "agents.md":
         result = toAgentsMd(canonicalPkg);
@@ -16523,6 +17605,9 @@ async function handleConvert(sourcePath, options) {
       case "gemini":
         result = toGemini(canonicalPkg);
         break;
+      case "ruler":
+        result = toRuler(canonicalPkg);
+        break;
       default:
         throw new CLIError(`Unsupported target format: ${options.to}`);
     }
@@ -16530,15 +17615,15 @@ async function handleConvert(sourcePath, options) {
       throw new CLIError("Conversion failed: No content generated");
     }
     console.log(import_chalk2.default.green(`\u2713 Converted from ${sourceFormat} to ${options.to}`));
-    const outputPath = options.output || getDefaultPath(options.to, sourcePath, options.subtype);
-    if ((0, import_fs12.existsSync)(outputPath) && !options.yes) {
+    const outputPath = options.output || getDefaultPath(options.to, sourcePath, options.subtype, options.name);
+    if ((0, import_fs13.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_path15.dirname)(outputPath);
+    const outputDir = (0, import_path16.dirname)(outputPath);
     await (0, import_promises9.mkdir)(outputDir, { recursive: true });
     console.log(import_chalk2.default.dim("Writing converted file..."));
     await (0, import_promises9.writeFile)(outputPath, result.content, "utf-8");
@@ -16554,6 +17639,8 @@ async function handleConvert(sourcePath, options) {
       console.log(import_chalk2.default.dim("\u{1F4A1} Kiro will automatically load steering files from .kiro/steering/"));
     } else if (options.to === "gemini") {
       console.log(import_chalk2.default.dim("\u{1F4A1} Gemini will automatically load commands from .gemini/commands/"));
+    } else if (options.to === "ruler") {
+      console.log(import_chalk2.default.dim("\u{1F4A1} Ruler will automatically load and distribute rules from .ruler/"));
     }
   } catch (error) {
     console.log(import_chalk2.default.red("\u2716 Conversion failed"));
@@ -16561,12 +17648,12 @@ 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)").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("-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, 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) => {
     try {
       if (!options.to) {
         throw new CLIError("Target format is required. Use --to <format>");
       }
-      const validFormats = ["cursor", "claude", "windsurf", "kiro", "copilot", "continue", "agents.md", "gemini"];
+      const validFormats = ["cursor", "claude", "windsurf", "kiro", "copilot", "continue", "agents.md", "gemini", "ruler"];
       if (!validFormats.includes(options.to)) {
         throw new CLIError(
           `Invalid format: ${options.to}
@@ -16586,6 +17673,187 @@ Valid subtypes: ${validSubtypes.join(", ")}`
         to: options.to,
         subtype: options.subtype,
         output: options.output,
+        name: options.name,
+        yes: options.yes
+      });
+    } catch (error) {
+      if (error instanceof CLIError) {
+        throw error;
+      }
+      throw new CLIError(error.message);
+    }
+  });
+  return command;
+}
+
+// src/commands/export.ts
+init_cjs_shims();
+var import_commander28 = require("commander");
+var import_fs14 = require("fs");
+var import_path17 = require("path");
+var import_chalk3 = __toESM(require_source());
+init_errors();
+init_lockfile();
+init_telemetry();
+async function exportToRuler(options) {
+  console.log(import_chalk3.default.dim("\u{1F4E6} Exporting installed packages to Ruler format..."));
+  console.log();
+  const packages = await listPackages();
+  if (packages.length === 0) {
+    console.log(import_chalk3.default.yellow("\u26A0 No packages installed"));
+    console.log(import_chalk3.default.dim("Install packages first with: prpm install <package>"));
+    return;
+  }
+  console.log(import_chalk3.default.green(`\u2713 Found ${packages.length} installed package${packages.length === 1 ? "" : "s"}`));
+  console.log();
+  const outputDir = options.output || (0, import_path17.join)(process.cwd(), ".ruler");
+  let rulerExists = false;
+  try {
+    await import_fs14.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_fs14.promises.mkdir(outputDir, { recursive: true });
+    console.log(import_chalk3.default.green(`\u2713 Created ${outputDir}/`));
+    console.log();
+  }
+  let exportedCount = 0;
+  let skippedCount = 0;
+  for (const pkg of packages) {
+    const packageName = pkg.id.split("/").pop() || pkg.id;
+    if (!pkg.installedPath) {
+      console.log(import_chalk3.default.yellow(`\u26A0 Skipping ${pkg.id} - no installation path found`));
+      skippedCount++;
+      continue;
+    }
+    try {
+      const content = await import_fs14.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_path17.join)(outputDir, rulerFilename);
+      await import_fs14.promises.writeFile(rulerPath, rulerContent, "utf-8");
+      console.log(import_chalk3.default.green(`\u2713 Exported ${pkg.id} \u2192 ${rulerFilename}`));
+      exportedCount++;
+    } catch (error) {
+      console.log(import_chalk3.default.red(`\u2716 Failed to export ${pkg.id}: ${error instanceof Error ? error.message : String(error)}`));
+      skippedCount++;
+    }
+  }
+  console.log();
+  console.log(import_chalk3.default.green(`\u2713 Export complete`));
+  console.log(import_chalk3.default.dim(`   Exported: ${exportedCount} package${exportedCount === 1 ? "" : "s"}`));
+  if (skippedCount > 0) {
+    console.log(import_chalk3.default.dim(`   Skipped: ${skippedCount} package${skippedCount === 1 ? "" : "s"}`));
+  }
+  console.log();
+  await ensureRulerConfig(outputDir);
+  console.log(import_chalk3.default.bold("\u{1F4CB} Next steps:"));
+  console.log(import_chalk3.default.dim("1. Review the exported files in .ruler/"));
+  console.log(import_chalk3.default.dim("2. Edit ruler.toml to configure which agents should use these rules"));
+  console.log(import_chalk3.default.dim("3. Run: ruler apply"));
+  console.log();
+  console.log(import_chalk3.default.dim("\u{1F4A1} Learn more about Ruler: https://okigu.com/ruler"));
+}
+function createRulerFormat(packageId, version, content, format, subtype) {
+  const contentWithoutFrontmatter = content.replace(/^---\n[\s\S]*?\n---\n/, "");
+  const frontmatter = [
+    "---",
+    `# Exported from PRPM`,
+    `# Package: ${packageId}`,
+    `# Version: ${version}`,
+    format ? `# Original Format: ${format}` : "",
+    subtype ? `# Subtype: ${subtype}` : "",
+    `# Exported: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "---",
+    ""
+  ].filter(Boolean).join("\n");
+  return frontmatter + contentWithoutFrontmatter;
+}
+async function ensureRulerConfig(rulerDir) {
+  const configPath = (0, import_path17.join)((0, import_path17.dirname)(rulerDir), "ruler.toml");
+  try {
+    await import_fs14.promises.access(configPath);
+    console.log(import_chalk3.default.dim("\u2139 ruler.toml already exists (not modified)"));
+  } catch {
+    const basicConfig = `# Ruler Configuration
+# Learn more: https://okigu.com/ruler
+
+# Define which agents should use these rules
+# Example:
+# [agents.cursor]
+# enabled = true
+# rules = ["*"]  # Apply all rules
+#
+# [agents.claude]
+# enabled = true
+# rules = ["*"]
+
+# Uncomment and configure the agents you use:
+# [agents.cursor]
+# enabled = false
+#
+# [agents.claude]
+# enabled = false
+#
+# [agents.github-copilot]
+# enabled = false
+`;
+    await import_fs14.promises.writeFile(configPath, basicConfig, "utf-8");
+    console.log(import_chalk3.default.green(`\u2713 Created ruler.toml configuration template`));
+  }
+}
+async function handleExport(options) {
+  const startTime = Date.now();
+  let success = false;
+  let error;
+  let packageCount = 0;
+  try {
+    if (options.to === "ruler") {
+      await exportToRuler(options);
+      const packages = await listPackages();
+      packageCount = packages.length;
+      success = true;
+    } else {
+      throw new CLIError(`Unsupported export target: ${options.to}`);
+    }
+  } catch (err) {
+    error = err instanceof Error ? err.message : String(err);
+    throw new CLIError(`\u274C Export failed: ${error}`, 1);
+  } finally {
+    await telemetry.track({
+      command: "export",
+      success,
+      error,
+      duration: Date.now() - startTime,
+      data: {
+        target: options.to,
+        packageCount
+      }
+    });
+    await telemetry.shutdown();
+  }
+}
+function createExportCommand() {
+  const command = new import_commander28.Command("export");
+  command.description("Export installed packages to external tools").option("--to <tool>", "Export target (currently supports: ruler)", "ruler").option("-o, --output <dir>", "Custom output directory").option("-y, --yes", "Skip confirmation prompts").action(async (options) => {
+    try {
+      if (!options.to) {
+        throw new CLIError("Export target is required. Use --to <tool>");
+      }
+      const validTargets = ["ruler"];
+      if (!validTargets.includes(options.to)) {
+        throw new CLIError(
+          `Invalid export target: ${options.to}
+
+Currently supported: ${validTargets.join(", ")}`
+        );
+      }
+      await handleExport({
+        to: options.to,
+        output: options.output,
         yes: options.yes
       });
     } catch (error) {
@@ -16603,14 +17871,14 @@ init_telemetry();
 init_errors();
 function getVersion() {
   try {
-    const packageJsonPath = (0, import_path16.join)(__dirname, "../package.json");
-    const packageJson = JSON.parse((0, import_fs13.readFileSync)(packageJsonPath, "utf-8"));
+    const packageJsonPath = (0, import_path18.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, import_fs15.readFileSync)(packageJsonPath, "utf-8"));
     return packageJson.version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
-var program = new import_commander28.Command();
+var program = new import_commander29.Command();
 program.name("prpm").description("Prompt Package Manager - Install and manage prompt-based files").version(getVersion());
 program.addCommand(createInitCommand());
 program.addCommand(createCatalogCommand());
@@ -16639,6 +17907,7 @@ program.addCommand(createBuyCreditsCommand());
 program.addCommand(createSchemaCommand());
 program.addCommand(createConfigCommand());
 program.addCommand(createConvertCommand());
+program.addCommand(createExportCommand());
 (async () => {
   try {
     await program.parseAsync();