prpm 1.1.1 → 1.1.2

package/dist/index.js

@@ -494,6 +494,7 @@ 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";
@@ -1910,14 +1911,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 +1930,7 @@ var require_templates = __commonJS({
       }
       return current;
     }
-    module2.exports = (chalk3, temporary) => {
+    module2.exports = (chalk4, temporary) => {
       const styles = [];
       const chunks = [];
       let chunk = [];
@@ -1939,13 +1940,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 +1995,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 +2115,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 +2131,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 +2492,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 fs11 = await import("fs/promises");
+    const manifestContent = await fs11.readFile(manifestPath, "utf-8");
     const manifest = JSON.parse(manifestContent);
     const required = ["id", "name", "description", "packages"];
     const missing = required.filter((field) => !manifest[field]);
@@ -6389,6 +6390,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 +8945,136 @@ var init_from_gemini = __esm({
   }
 });
 
+// ../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/validation.js
 function loadSchema(format, subtype) {
   const cacheKey = subtype ? `${format}:${subtype}` : format;
@@ -8792,7 +9089,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,6 +9104,7 @@ function loadSchema(format, subtype) {
       "kiro": "kiro-steering.schema.json",
       "agents-md": "agents-md.schema.json",
       "gemini": "gemini.schema.json",
+      "ruler": "ruler.schema.json",
       "canonical": "canonical.schema.json"
     };
     schemaFilename = schemaMap[format] || `${format}.schema.json`;
@@ -8913,12 +9212,12 @@ 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_fs8, import_path7, import_url, currentDirname, ajv, schemaCache;
 var init_validation = __esm({
   "../converters/dist/validation.js"() {
     "use strict";
@@ -8927,8 +9226,14 @@ var init_validation = __esm({
     import_ajv_formats = __toESM(require("ajv-formats"), 1);
     import_fs8 = require("fs");
     import_path7 = require("path");
+    import_url = require("url");
     init_js_yaml();
-    currentDirname = __dirname;
+    if (typeof __dirname !== "undefined") {
+      currentDirname = __dirname;
+    } else {
+      const getModuleUrl = new Function("return import.meta.url");
+      currentDirname = (0, import_path7.dirname)((0, import_url.fileURLToPath)(getModuleUrl()));
+    }
     ajv = new import_ajv.default({
       allErrors: true,
       verbose: true,
@@ -9835,6 +10140,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 +10815,166 @@ var init_to_gemini = __esm({
   }
 });
 
+// ../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/index.js
 var init_dist = __esm({
   "../converters/dist/index.js"() {
@@ -10356,17 +10986,21 @@ 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_ruler();
     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_ruler();
     init_taxonomy_utils();
     init_validation();
   }
@@ -10397,6 +11031,7 @@ function getPackageIcon2(format, subtype) {
     "gemini": "\u2728",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
+    "ruler": "\u{1F4CF}",
     "generic": "\u{1F4E6}"
   };
   return subtypeIcons[subtype] || formatIcons[format] || "\u{1F4E6}";
@@ -10412,6 +11047,7 @@ function getPackageLabel2(format, subtype) {
     "gemini": "Gemini",
     "mcp": "MCP",
     "agents.md": "Agents.md",
+    "ruler": "Ruler",
     "generic": ""
   };
   const subtypeLabels = {
@@ -10596,10 +11232,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;
@@ -11013,13 +11652,13 @@ async function extractTarball(tarball, packageId) {
     await cleanup();
   }
 }
-async function collectExtractedFiles(rootDir, excludedNames, fs10) {
+async function collectExtractedFiles(rootDir, excludedNames, fs11) {
   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 fs11.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = import_path8.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -11032,7 +11671,7 @@ async function collectExtractedFiles(rootDir, excludedNames, fs10) {
       if (excludedNames.has(entry.name)) {
         continue;
       }
-      const content = await fs10.readFile(fullPath, "utf-8");
+      const content = await fs11.readFile(fullPath, "utf-8");
       const relativePath = import_path8.default.relative(rootDir, fullPath).split(import_path8.default.sep).join("/");
       files.push({
         name: relativePath,
@@ -11164,9 +11803,9 @@ var init_install = __esm({
 
 // 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_fs14 = require("fs");
+var import_path17 = require("path");
 
 // src/commands/list.ts
 init_cjs_shims();
@@ -11769,6 +12408,7 @@ function getPackageIcon(format, subtype) {
     "gemini": "\u2728",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
+    "ruler": "\u{1F4CF}",
     "generic": "\u{1F4E6}"
   };
   return subtypeIcons[subtype] || formatIcons[format] || "\u{1F4E6}";
@@ -11784,6 +12424,7 @@ function getPackageLabel(format, subtype) {
     "gemini": "Gemini",
     "mcp": "MCP",
     "agents.md": "Agents.md",
+    "ruler": "Ruler",
     "generic": ""
   };
   const subtypeLabels = {
@@ -11991,6 +12632,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) {
@@ -16332,8 +16989,8 @@ 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_path15.basename)(filename, (0, import_path15.extname)(filename));
   switch (format) {
     case "cursor":
       if (subtype === "slash-command") {
@@ -16354,6 +17011,9 @@ function getDefaultPath(format, filename, subtype) {
       if (subtype === "hook") {
         return (0, import_path15.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
       }
+      if (subtype === "agent") {
+        return (0, import_path15.join)(process.cwd(), ".kiro", "agents", `${baseName}.json`);
+      }
       return (0, import_path15.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
     case "copilot":
       return (0, import_path15.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
@@ -16366,6 +17026,8 @@ function getDefaultPath(format, filename, subtype) {
       return (0, import_path15.join)(process.cwd(), "agents.md");
     case "gemini":
       return (0, import_path15.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
+    case "ruler":
+      return (0, import_path15.join)(process.cwd(), ".ruler", `${baseName}.md`);
     default:
       throw new CLIError(`Unknown format: ${format}`);
   }
@@ -16399,6 +17061,9 @@ function detectFormat(content, filepath) {
   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 +17076,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 +17140,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 +17159,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 +17187,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 +17202,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,7 +17212,7 @@ 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);
+    const outputPath = options.output || getDefaultPath(options.to, sourcePath, options.subtype, options.name);
     if ((0, import_fs12.existsSync)(outputPath) && !options.yes) {
       const shouldOverwrite = await confirmOverwrite(outputPath);
       if (!shouldOverwrite) {
@@ -16554,6 +17236,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 +17245,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 +17270,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_fs13 = require("fs");
+var import_path16 = 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_path16.join)(process.cwd(), ".ruler");
+  let rulerExists = false;
+  try {
+    await import_fs13.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_fs13.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_fs13.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_path16.join)(outputDir, rulerFilename);
+      await import_fs13.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_path16.join)((0, import_path16.dirname)(rulerDir), "ruler.toml");
+  try {
+    await import_fs13.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_fs13.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 +17468,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_path17.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, import_fs14.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 +17504,7 @@ program.addCommand(createBuyCreditsCommand());
 program.addCommand(createSchemaCommand());
 program.addCommand(createConfigCommand());
 program.addCommand(createConvertCommand());
+program.addCommand(createExportCommand());
 (async () => {
   try {
     await program.parseAsync();