prpm 2.1.0 → 2.1.1

package/dist/format-capabilities.json

@@ -0,0 +1,232 @@
+{
+  "$schema": "../../schemas/format-capabilities.schema.json",
+  "version": "1.0.2",
+  "description": "Format capability matrix for PRPM converters - defines which subtypes each format supports and progressive disclosure fallbacks",
+  "lastVerified": "2025-12-06",
+  "verificationSources": {
+    "claude": "https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview",
+    "copilot": "https://github.blog/changelog/2025-08-28-copilot-coding-agent-now-supports-agents-md-custom-instructions/",
+    "cursor": "https://docs.cursor.com/context/rules",
+    "continue": "https://docs.continue.dev/reference",
+    "windsurf": "https://docs.codeium.com/windsurf/cascade",
+    "gemini": "https://geminicli.com/docs/extensions/",
+    "aider": "https://aider.chat/docs/usage/conventions.html",
+    "replit": "https://docs.replit.com/replitai/agent",
+    "zed": "https://zed.dev/docs/assistant/assistant-settings"
+  },
+  "formats": {
+    "cursor": {
+      "name": "Cursor",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": true,
+      "supportsSlashCommands": true,
+      "markdownFallback": "cursor-rules.md",
+      "notes": "Cursor supports AGENTS.md files for project instructions. Custom slash commands in .cursor/commands/*.md (introduced v1.6, Sept 2025). Built-in /summarize command. Rules are appended automatically, slash commands are explicit prompts with more weight. No native agent/skill/plugin packages."
+    },
+    "claude": {
+      "name": "Claude Code",
+      "supportsSkills": true,
+      "supportsPlugins": true,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": false,
+      "markdownFallback": "CLAUDE.md",
+      "notes": "Claude Code supports skills, agents, and plugins. Uses CLAUDE.md (not AGENTS.md) for project-specific instructions. Feature request open for AGENTS.md support (Issue #6235)."
+    },
+    "continue": {
+      "name": "Continue",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "markdownFallback": "continue-prompts.md",
+      "notes": "Continue uses simple prompt files. No native support for advanced package types."
+    },
+    "windsurf": {
+      "name": "Windsurf",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "markdownFallback": "windsurf-rules.md",
+      "notes": "Windsurf uses markdown rules with 12K character limit. No advanced package support."
+    },
+    "copilot": {
+      "name": "GitHub Copilot",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "copilot-instructions.md",
+      "notes": "GitHub Copilot coding agent supports AGENTS.md, CLAUDE.md, GEMINI.md, and .instructions.md custom instructions (as of August 2025). Full agents.md support."
+    },
+    "kiro": {
+      "name": "Kiro AI",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "kiro-agent.md",
+      "notes": "Kiro supports agents in .kiro/agents/ directory. Full agents.md support."
+    },
+    "gemini": {
+      "name": "Gemini CLI",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": true,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "supportsSlashCommands": true,
+      "markdownFallback": "GEMINI.md",
+      "notes": "Gemini CLI uses extensions in gemini-extension.json. Custom slash commands in ~/.gemini/commands/ (user-scoped) or .gemini/commands/ (project-scoped). Built-in commands: /help, /copy, /mcp, /memory, /directory. Only supports GEMINI.md for project context. Does not support AGENT.md or AGENTS.md."
+    },
+    "opencode": {
+      "name": "OpenCode",
+      "supportsSkills": false,
+      "supportsPlugins": true,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "supportsSlashCommands": true,
+      "markdownFallback": "opencode-agent.md",
+      "notes": "OpenCode supports agents with mode/model/temperature config. Plugins are JavaScript/TypeScript modules in .opencode/plugin with 40+ event hooks. Slash commands available. Full agents.md support."
+    },
+    "ruler": {
+      "name": "Ruler",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "ruler-rules.md",
+      "notes": "Ruler supports agents in .ruler/agents/ directory. Full agents.md support."
+    },
+    "droid": {
+      "name": "Factory Droid",
+      "supportsSkills": true,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "droid-skill.md",
+      "notes": "Factory Droid supports both skills and agents. Full agents.md support."
+    },
+    "trae": {
+      "name": "Trae",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "markdownFallback": "trae-rules.md",
+      "notes": "Trae uses simple markdown rules. No advanced package support."
+    },
+    "aider": {
+      "name": "Aider",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "markdownFallback": "CONVENTIONS.md",
+      "notes": "Aider uses CONVENTIONS.md for coding standards. No advanced package support."
+    },
+    "zencoder": {
+      "name": "Zencoder",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "markdownFallback": "zencoder-rules.md",
+      "notes": "Zencoder uses simple rules with glob patterns. No advanced package support."
+    },
+    "replit": {
+      "name": "Replit Agent",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "AGENTS.md",
+      "notes": "Replit Agent supports AGENTS.md for custom agent instructions. Full agents.md support following the agent-rules.org standard."
+    },
+    "zed": {
+      "name": "Zed",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": true,
+      "supportsAgents": false,
+      "supportsAgentsMd": true,
+      "supportsSlashCommands": true,
+      "markdownFallback": ".rules",
+      "notes": "Zed supports .rules files (plain markdown, no frontmatter). Slash commands can be used in rules with /file, /diagnostics, /fetch, etc. Extensions written in Rust/WASM with extension.toml manifest. Also reads .cursorrules, .windsurfrules, .clinerules, AGENTS.md, CLAUDE.md, GEMINI.md in priority order. Extensions installed to ~/Library/Application Support/Zed/extensions (macOS). License required: MIT, Apache 2.0, BSD 3-Clause, or GPLv3."
+    },
+    "codex": {
+      "name": "OpenAI Codex CLI",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "supportsSlashCommands": false,
+      "slashCommandFallback": "agents.md",
+      "markdownFallback": "AGENTS.md",
+      "notes": "OpenAI Codex CLI uses AGENTS.md for project instructions. No native slash commands - slash commands are converted to named sections in AGENTS.md that users invoke by saying the command name (e.g., 'build-actions' not '/build-actions')."
+    },
+    "agents.md": {
+      "name": "agents.md (Universal)",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "agents.md",
+      "notes": "Universal agents.md format - works with OpenAI, Gemini, Claude, and most AI systems."
+    },
+    "mcp": {
+      "name": "Model Context Protocol",
+      "supportsSkills": false,
+      "supportsPlugins": true,
+      "supportsExtensions": false,
+      "supportsAgents": false,
+      "supportsAgentsMd": false,
+      "markdownFallback": "mcp-server.json",
+      "notes": "MCP is a server protocol, not a package format. Supports plugins via server configuration."
+    },
+    "generic": {
+      "name": "Generic (Markdown)",
+      "supportsSkills": false,
+      "supportsPlugins": false,
+      "supportsExtensions": false,
+      "supportsAgents": true,
+      "supportsAgentsMd": true,
+      "markdownFallback": "README.md",
+      "notes": "Generic markdown format for maximum compatibility. Supports agents.md convention."
+    }
+  },
+  "agentsMdSupport": {
+    "description": "Formats that intelligently support agents.md for progressive disclosure",
+    "formats": [
+      "cursor",
+      "copilot",
+      "kiro",
+      "opencode",
+      "ruler",
+      "droid",
+      "replit",
+      "zed",
+      "codex",
+      "agents.md",
+      "generic"
+    ],
+    "notes": "These formats can use AGENTS.md as a universal fallback. Claude Code uses CLAUDE.md instead (not AGENTS.md). Gemini uses GEMINI.md instead. Cursor added AGENTS.md support in version 1.6+. GitHub Copilot added AGENTS.md support in August 2025. Zed reads AGENTS.md along with other rule file formats."
+  }
+}

package/dist/index.js

@@ -815,7 +815,8 @@ var init_taxonomy_utils = __esm({
       "trae",
       "replit",
       "zencoder",
-      "droid"
+      "droid",
+      "codex"
     ];
   }
 });
@@ -852,6 +853,25 @@ function fromClaude(content, metadata, sourceFormat = "claude", explicitSubtype)
     }
     metadataSection.data.claudeAgent.model = frontmatter.model;
   }
+  const argumentHint = frontmatter["argument-hint"];
+  const hasSlashCommandFields = argumentHint || frontmatter["allowed-tools"] || frontmatter["disable-model-invocation"];
+  if (hasSlashCommandFields) {
+    metadataSection.data.claudeSlashCommand = {
+      description: frontmatter.description
+    };
+    if (argumentHint) {
+      metadataSection.data.claudeSlashCommand.argumentHint = argumentHint;
+    }
+    if (frontmatter["allowed-tools"]) {
+      metadataSection.data.claudeSlashCommand.allowedTools = frontmatter["allowed-tools"];
+    }
+    if (frontmatter.model) {
+      metadataSection.data.claudeSlashCommand.model = frontmatter.model;
+    }
+    if (frontmatter["disable-model-invocation"] !== void 0) {
+      metadataSection.data.claudeSlashCommand.disableModelInvocation = frontmatter["disable-model-invocation"] === "true" || frontmatter["disable-model-invocation"] === true;
+    }
+  }
   const { sections: bodySections, h1Title, h1Icon } = parseMarkdownBody(body);
   if (h1Title) {
     metadataSection.data.title = h1Title;
@@ -10564,7 +10584,11 @@ function toGemini(pkg, options = {}) {
   const warnings = [];
   let qualityScore = 100;
   try {
-    const prompt3 = buildPrompt(pkg.content, warnings);
+    let prompt3 = buildPrompt(pkg.content, warnings);
+    const argumentHint = extractArgumentHint(pkg);
+    if (argumentHint) {
+      prompt3 = integrateArgumentsIntoPrompt(prompt3, argumentHint, warnings);
+    }
     const geminiCommand = {
       prompt: prompt3
     };
@@ -10723,6 +10747,89 @@ function convertContext7(section) {
   lines.push(section.content);
   return lines.join("\n");
 }
+function extractArgumentHint(pkg) {
+  var _a, _b, _c, _d, _e;
+  const metadataSection = pkg.content.sections.find((s) => s.type === "metadata");
+  if (metadataSection && metadataSection.type === "metadata") {
+    if ((_a = metadataSection.data.claudeSlashCommand) == null ? void 0 : _a.argumentHint) {
+      return metadataSection.data.claudeSlashCommand.argumentHint;
+    }
+    if ((_b = metadataSection.data.opencodeSlashCommand) == null ? void 0 : _b.argumentHint) {
+      return metadataSection.data.opencodeSlashCommand.argumentHint;
+    }
+    if ((_c = metadataSection.data.droid) == null ? void 0 : _c.argumentHint) {
+      return metadataSection.data.droid.argumentHint;
+    }
+  }
+  if ((_e = (_d = pkg.metadata) == null ? void 0 : _d.droid) == null ? void 0 : _e.argumentHint) {
+    return pkg.metadata.droid.argumentHint;
+  }
+  return void 0;
+}
+function parseArgumentHint(hint) {
+  if (Array.isArray(hint)) {
+    return hint;
+  }
+  const bracketMatches = hint.match(/\[([^\]]+)\]/g);
+  if (bracketMatches) {
+    return bracketMatches.map((m) => m.replace(/^\[|\]$/g, ""));
+  }
+  return hint.split(/\s+/).filter(Boolean);
+}
+function integrateArgumentsIntoPrompt(prompt3, argumentHint, warnings) {
+  const args = parseArgumentHint(argumentHint);
+  if (args.length === 0) {
+    return prompt3;
+  }
+  let translatedPrompt = translatePositionalArgs(prompt3, args, warnings);
+  const usageFormat = args.map((arg) => `<${arg}>`).join(" ");
+  const usageSection = `**Expected Arguments:** ${usageFormat}
+
+The user will provide these arguments which are available via {{args}}.
+
+`;
+  if (translatedPrompt.includes("{{args}}")) {
+    return usageSection + translatedPrompt;
+  }
+  const instructionHeaders = /^(#+\s*(?:Instructions?|Overview|Task):?\s*\n)/im;
+  const match = translatedPrompt.match(instructionHeaders);
+  if (match) {
+    const insertPoint = match.index + match[0].length;
+    const before = translatedPrompt.slice(0, insertPoint);
+    const after = translatedPrompt.slice(insertPoint);
+    return usageSection + before + `
+**Arguments provided:** {{args}}
+
+` + after;
+  }
+  return usageSection + `**Arguments provided:** {{args}}
+
+` + translatedPrompt;
+}
+function translatePositionalArgs(prompt3, argNames, warnings) {
+  let result = prompt3;
+  const hasPositionalArgs = /\$\d+/.test(prompt3);
+  if (!hasPositionalArgs) {
+    return result;
+  }
+  for (let i = 0; i < argNames.length; i++) {
+    const positionalArg = `$${i + 1}`;
+    const namedPlaceholder = `{{${argNames[i]}}}`;
+    const regex = new RegExp(`\\$${i + 1}(?![0-9])`, "g");
+    result = result.replace(regex, namedPlaceholder);
+  }
+  const remainingArgs = result.match(/\$(\d+)/g);
+  if (remainingArgs) {
+    const unmappedArgs = remainingArgs.filter((arg) => {
+      const num = parseInt(arg.slice(1), 10);
+      return num > argNames.length;
+    });
+    if (unmappedArgs.length > 0) {
+      warnings.push(`Positional arguments ${unmappedArgs.join(", ")} found but no corresponding argumentHint names provided`);
+    }
+  }
+  return result;
+}
 var TOML2;
 var init_to_gemini = __esm({
   "../converters/dist/to-gemini.js"() {
@@ -12043,6 +12150,261 @@ var init_to_zed = __esm({
   }
 });
 
+// ../converters/dist/to-codex.js
+function toCodex(pkg, options = {}) {
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const config = options.codexConfig || {};
+    const isSlashCommand = pkg.subtype === "slash-command";
+    let content;
+    if (isSlashCommand) {
+      content = convertSlashCommandToSection(pkg, warnings);
+      if (config.appendMode && config.existingContent) {
+        content = appendToExistingAgentsMd(config.existingContent, content, pkg.name);
+      }
+    } else {
+      content = convertToAgentsMd(pkg, warnings);
+    }
+    const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
+    if (lossyConversion) {
+      qualityScore -= 10;
+    }
+    return {
+      content,
+      format: "codex",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion,
+      qualityScore
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "codex",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function convertSlashCommandToSection(pkg, warnings) {
+  const lines = [];
+  const commandName = pkg.name.replace(/^\//, "");
+  const metadataSection = pkg.content.sections.find((s) => s.type === "metadata");
+  let argumentHint;
+  let description = pkg.description;
+  if (metadataSection && metadataSection.type === "metadata") {
+    const claudeSlashCommand = metadataSection.data.claudeSlashCommand;
+    if (claudeSlashCommand) {
+      argumentHint = claudeSlashCommand.argumentHint;
+      if (claudeSlashCommand.description) {
+        description = claudeSlashCommand.description;
+      }
+    }
+  }
+  lines.push(`## ${commandName}`);
+  lines.push("");
+  if (argumentHint) {
+    const args = formatArgumentHint(argumentHint);
+    lines.push(`**Usage:** Say "${commandName} ${args}" to invoke this command`);
+  } else {
+    lines.push(`**Usage:** Say "${commandName}" to invoke this command`);
+  }
+  lines.push("");
+  if (description) {
+    lines.push(`**Description:** ${description}`);
+    lines.push("");
+  }
+  if (argumentHint) {
+    const argNames = parseArgumentHint2(argumentHint);
+    if (argNames.length > 0) {
+      lines.push("**Arguments:**");
+      argNames.forEach((arg, i) => {
+        lines.push(`- \`${arg}\` - Argument ${i + 1}`);
+      });
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(`When the user says "${commandName}" or asks to "${commandName.replace(/-/g, " ")}", follow these instructions:`);
+  lines.push("");
+  for (const section of pkg.content.sections) {
+    if (section.type === "metadata")
+      continue;
+    if (section.type === "tools") {
+      warnings.push("Tools section skipped (not supported by Codex AGENTS.md)");
+      continue;
+    }
+    if (section.type === "persona") {
+      warnings.push("Persona section skipped (not supported by Codex AGENTS.md)");
+      continue;
+    }
+    const sectionContent = convertSection13(section, warnings);
+    if (sectionContent) {
+      lines.push(sectionContent);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function convertToAgentsMd(pkg, warnings) {
+  var _a;
+  const lines = [];
+  const title = ((_a = pkg.metadata) == null ? void 0 : _a.title) || pkg.name;
+  lines.push(`# ${title}`);
+  lines.push("");
+  if (pkg.description) {
+    lines.push(pkg.description);
+    lines.push("");
+  }
+  for (const section of pkg.content.sections) {
+    if (section.type === "metadata")
+      continue;
+    if (section.type === "tools") {
+      warnings.push("Tools section skipped (not supported by Codex AGENTS.md)");
+      continue;
+    }
+    if (section.type === "persona") {
+      warnings.push("Persona section skipped (not supported by Codex AGENTS.md)");
+      continue;
+    }
+    const sectionContent = convertSection13(section, warnings);
+    if (sectionContent) {
+      lines.push(sectionContent);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function appendToExistingAgentsMd(existingContent, newSection, commandName) {
+  const sectionHeader = `## ${commandName.replace(/^\//, "")}`;
+  if (existingContent.includes(sectionHeader)) {
+    const regex = new RegExp(`## ${commandName.replace(/^\//, "")}[\\s\\S]*?(?=## |$)`, "g");
+    return existingContent.replace(regex, newSection + "\n\n");
+  }
+  const trimmedExisting = existingContent.trim();
+  return `${trimmedExisting}
+
+${newSection}`;
+}
+function convertSection13(section, warnings) {
+  switch (section.type) {
+    case "instructions":
+      return convertInstructions13(section);
+    case "rules":
+      return convertRules13(section);
+    case "examples":
+      return convertExamples13(section);
+    case "context":
+      return convertContext13(section);
+    case "hook":
+      warnings.push("Hook section skipped (not supported by Codex)");
+      return "";
+    case "cursor-hook":
+      warnings.push("Cursor hook section skipped (not supported by Codex)");
+      return "";
+    case "file-reference":
+      warnings.push("File reference section skipped (not supported by Codex)");
+      return "";
+    case "custom":
+      if (!section.editorType || section.editorType === "codex") {
+        return section.content;
+      }
+      warnings.push(`Custom ${section.editorType} section skipped`);
+      return "";
+    default:
+      return "";
+  }
+}
+function convertInstructions13(section) {
+  const lines = [];
+  lines.push(`### ${section.title}`);
+  lines.push("");
+  if (section.priority === "high") {
+    lines.push("**Important:**");
+    lines.push("");
+  }
+  lines.push(section.content);
+  return lines.join("\n");
+}
+function convertRules13(section) {
+  const lines = [];
+  lines.push(`### ${section.title}`);
+  lines.push("");
+  section.items.forEach((rule, index) => {
+    const prefix = section.ordered ? `${index + 1}.` : "-";
+    lines.push(`${prefix} ${rule.content}`);
+    if (rule.rationale) {
+      lines.push(`   - Rationale: ${rule.rationale}`);
+    }
+    if (rule.examples && rule.examples.length > 0) {
+      rule.examples.forEach((example) => {
+        lines.push(`   - Example: \`${example}\``);
+      });
+    }
+  });
+  return lines.join("\n");
+}
+function convertExamples13(section) {
+  const lines = [];
+  lines.push(`### ${section.title}`);
+  lines.push("");
+  section.examples.forEach((example) => {
+    if (example.good === false) {
+      lines.push(`#### \u274C Avoid: ${example.description}`);
+    } else if (example.good === true) {
+      lines.push(`#### \u2705 Preferred: ${example.description}`);
+    } else {
+      lines.push(`#### ${example.description}`);
+    }
+    lines.push("");
+    const lang = example.language || "";
+    lines.push("```" + lang);
+    lines.push(example.code);
+    lines.push("```");
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+function convertContext13(section) {
+  const lines = [];
+  lines.push(`### ${section.title}`);
+  lines.push("");
+  lines.push(section.content);
+  return lines.join("\n");
+}
+function formatArgumentHint(hint) {
+  if (Array.isArray(hint)) {
+    return hint.map((arg) => `<${arg}>`).join(" ");
+  }
+  const bracketMatches = hint.match(/\[([^\]]+)\]/g);
+  if (bracketMatches) {
+    return bracketMatches.map((m) => `<${m.replace(/^\[|\]$/g, "")}>`).join(" ");
+  }
+  return hint.split(/\s+/).filter(Boolean).map((arg) => `<${arg}>`).join(" ");
+}
+function parseArgumentHint2(hint) {
+  if (Array.isArray(hint)) {
+    return hint;
+  }
+  const bracketMatches = hint.match(/\[([^\]]+)\]/g);
+  if (bracketMatches) {
+    return bracketMatches.map((m) => m.replace(/^\[|\]$/g, ""));
+  }
+  return hint.split(/\s+/).filter(Boolean);
+}
+function generateFilename2() {
+  return "AGENTS.md";
+}
+var init_to_codex = __esm({
+  "../converters/dist/to-codex.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/to-mcp-server.js
 function toMCPServer(pkg) {
   var _a, _b;
@@ -12457,6 +12819,36 @@ var init_format_registry = __esm({
             }
           }
         },
+        codex: {
+          name: "OpenAI Codex CLI",
+          description: "OpenAI Codex CLI using AGENTS.md for project instructions",
+          subtypes: {
+            rule: {
+              directory: ".",
+              filePatterns: ["AGENTS.md"],
+              fileExtension: ".md"
+            },
+            "slash-command": {
+              directory: ".",
+              filePatterns: ["AGENTS.md"],
+              fileExtension: ".md"
+            },
+            skill: {
+              directory: ".openskills",
+              filePatterns: ["*.md"],
+              nested: true,
+              usesPackageSubdirectory: true,
+              fileExtension: ".md"
+            },
+            agent: {
+              directory: ".openagents",
+              filePatterns: ["*.md"],
+              nested: true,
+              usesPackageSubdirectory: true,
+              fileExtension: ".md"
+            }
+          }
+        },
         "gemini.md": {
           name: "GEMINI.md",
           description: "Gemini GEMINI.md project instructions",
@@ -12926,6 +13318,7 @@ __export(dist_exports, {
   fromZencoder: () => fromZencoder,
   geminiMdSchema: () => geminiMdSchema,
   geminiSchema: () => geminiSchema,
+  generateCodexFilename: () => generateFilename2,
   generateMCPServerPackage: () => generateMCPServerPackage,
   generatePluginJson: () => generatePluginJson,
   generateZedFilename: () => generateFilename,
@@ -12990,6 +13383,7 @@ __export(dist_exports, {
   toClaude: () => toClaude,
   toClaudeMd: () => toClaudeMd,
   toClaudePlugin: () => toClaudePlugin,
+  toCodex: () => toCodex,
   toContinue: () => toContinue,
   toCopilot: () => toCopilot,
   toCursor: () => toCursor,
@@ -13063,6 +13457,7 @@ var init_dist = __esm({
     init_to_zencoder();
     init_to_replit();
     init_to_zed();
+    init_to_codex();
     init_to_mcp_server();
     init_taxonomy_utils();
     init_validation();
@@ -15904,6 +16299,7 @@ function getPackageIcon2(format, subtype) {
     "copilot": "\u2708\uFE0F",
     "kiro": "\u{1F3AF}",
     "gemini": "\u2728",
+    "gemini-extension": "\u2728",
     "gemini.md": "\u2728",
     "claude.md": "\u{1F916}",
     "opencode": "\u26A1",
@@ -15913,6 +16309,7 @@ function getPackageIcon2(format, subtype) {
     "zencoder": "\u26A1",
     "replit": "\u{1F52E}",
     "zed": "\u26A1",
+    "codex": "\u{1F9E0}",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
     "ruler": "\u{1F4CF}",
@@ -15929,6 +16326,7 @@ function getPackageLabel2(format, subtype) {
     "copilot": "GitHub Copilot",
     "kiro": "Kiro",
     "gemini": "Gemini",
+    "gemini-extension": "Gemini Extension",
     "gemini.md": "Gemini",
     "claude.md": "Claude",
     "opencode": "OpenCode",
@@ -15938,6 +16336,7 @@ function getPackageLabel2(format, subtype) {
     "zencoder": "Zencoder",
     "replit": "Replit",
     "zed": "Zed",
+    "codex": "Codex",
     "mcp": "MCP",
     "agents.md": "Agents.md",
     "ruler": "Ruler",
@@ -16358,6 +16757,9 @@ This could indicate:
           case "replit":
             convertedContent = toReplit(canonicalPkg).content;
             break;
+          case "codex":
+            convertedContent = toCodex(canonicalPkg).content;
+            break;
           case "generic":
             convertedContent = toCursor(canonicalPkg).content;
             break;
@@ -19416,6 +19818,7 @@ function getPackageIcon(format, subtype) {
     "copilot": "\u2708\uFE0F",
     "kiro": "\u{1F3AF}",
     "gemini": "\u2728",
+    "gemini-extension": "\u2728",
     "gemini.md": "\u2728",
     "claude.md": "\u{1F916}",
     "opencode": "\u26A1",
@@ -19425,6 +19828,7 @@ function getPackageIcon(format, subtype) {
     "zencoder": "\u26A1",
     "replit": "\u{1F52E}",
     "zed": "\u26A1",
+    "codex": "\u{1F9E0}",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
     "ruler": "\u{1F4CF}",
@@ -19441,6 +19845,7 @@ function getPackageLabel(format, subtype) {
     "copilot": "GitHub Copilot",
     "kiro": "Kiro",
     "gemini": "Gemini",
+    "gemini-extension": "Gemini Extension",
     "gemini.md": "Gemini",
     "claude.md": "Claude",
     "opencode": "OpenCode",
@@ -19450,6 +19855,7 @@ function getPackageLabel(format, subtype) {
     "zencoder": "Zencoder",
     "replit": "Replit",
     "zed": "Zed",
+    "codex": "Codex",
     "mcp": "MCP",
     "agents.md": "Agents.md",
     "ruler": "Ruler",
@@ -23568,6 +23974,8 @@ function getDefaultPath(format, filename, subtype, customName) {
       return (0, import_path23.join)(process.cwd(), ".zencoder", `${baseName}.md`);
     case "droid":
       return (0, import_path23.join)(process.cwd(), ".factory", `${baseName}.md`);
+    case "codex":
+      return (0, import_path23.join)(process.cwd(), "AGENTS.md");
     default:
       throw new CLIError(`Unknown format: ${format}`);
   }
@@ -23819,6 +24227,9 @@ async function handleConvert(sourcePath, options) {
       case "droid":
         result = toDroid(canonicalPkg);
         break;
+      case "codex":
+        result = toCodex(canonicalPkg);
+        break;
       default:
         throw new CLIError(`Unsupported target format: ${options.to}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Prompt Package Manager CLI - Install and manage prompt-based files",
   "main": "dist/index.js",
   "bin": {
@@ -45,9 +45,9 @@
   "license": "MIT",
   "dependencies": {
     "@octokit/rest": "^22.0.0",
-    "@pr-pm/converters": "^2.1.0",
-    "@pr-pm/registry-client": "^2.3.0",
-    "@pr-pm/types": "^2.1.0",
+    "@pr-pm/converters": "^2.1.1",
+    "@pr-pm/registry-client": "^2.3.1",
+    "@pr-pm/types": "^2.1.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",