rulesync 8.9.0 → 8.11.0

package/dist/cli/index.js

@@ -53,8 +53,10 @@ import {
   SKILL_FILE_NAME,
   SkillsProcessor,
   SubagentsProcessor,
+  ToolTargetSchema,
   checkPathTraversal,
   checkRulesyncDirExists,
+  convertFromTool,
   createTempDirectory,
   directoryExists,
   ensureDir,
@@ -77,7 +79,7 @@ import {
   stringifyFrontmatter,
   toPosixPath,
   writeFileContent
-} from "../chunk-EHXIVMY2.js";
+} from "../chunk-ZX2YPC22.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -85,6 +87,81 @@ import { Command } from "commander";
 // src/utils/parse-comma-separated-list.ts
 var parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 
+// src/utils/result.ts
+function calculateTotalCount(result) {
+  return result.rulesCount + result.ignoreCount + result.mcpCount + result.commandsCount + result.subagentsCount + result.skillsCount + result.hooksCount + result.permissionsCount;
+}
+
+// src/cli/commands/convert.ts
+function parseToolTarget(value, label) {
+  const result = ToolTargetSchema.safeParse(value);
+  if (!result.success) {
+    throw new CLIError(
+      `Invalid ${label} tool '${value}'. Must be one of: ${ALL_TOOL_TARGETS.join(", ")}`,
+      ErrorCodes.CONVERT_FAILED
+    );
+  }
+  return result.data;
+}
+async function convertCommand(logger5, options) {
+  const fromTool = parseToolTarget(options.from ?? "", "source");
+  const toToolsRaw = (options.to ?? []).map((t) => parseToolTarget(t, "destination"));
+  const toTools = Array.from(new Set(toToolsRaw));
+  if (toTools.includes(fromTool)) {
+    throw new CLIError(
+      `Destination tools must not include the source tool '${fromTool}'. Converting a tool onto itself is likely a mistake and may cause lossy round-trips.`,
+      ErrorCodes.CONVERT_FAILED
+    );
+  }
+  const config = await ConfigResolver.resolve({
+    ...options,
+    targets: [fromTool, ...toTools],
+    features: options.features ?? ["*"]
+  });
+  const isPreview = config.isPreviewMode();
+  const modePrefix = isPreview ? "[DRY RUN] " : "";
+  logger5.debug(`Converting files from ${fromTool} to ${toTools.join(", ")}...`);
+  const result = await convertFromTool({ config, fromTool, toTools, logger: logger5 });
+  const totalConverted = calculateTotalCount(result);
+  if (totalConverted === 0) {
+    const enabledFeatures = config.getFeatures(fromTool).join(", ");
+    logger5.warn(`No files converted for enabled features: ${enabledFeatures}`);
+    return;
+  }
+  if (logger5.jsonMode) {
+    logger5.captureData("from", fromTool);
+    logger5.captureData("to", toTools);
+    logger5.captureData("dryRun", isPreview);
+    logger5.captureData("features", {
+      rules: { count: result.rulesCount },
+      ignore: { count: result.ignoreCount },
+      mcp: { count: result.mcpCount },
+      commands: { count: result.commandsCount },
+      subagents: { count: result.subagentsCount },
+      skills: { count: result.skillsCount },
+      hooks: { count: result.hooksCount },
+      permissions: { count: result.permissionsCount }
+    });
+    logger5.captureData("totalFiles", totalConverted);
+  }
+  const parts = [];
+  if (result.rulesCount > 0) parts.push(`${result.rulesCount} rules`);
+  if (result.ignoreCount > 0) parts.push(`${result.ignoreCount} ignore files`);
+  if (result.mcpCount > 0) parts.push(`${result.mcpCount} MCP files`);
+  if (result.commandsCount > 0) parts.push(`${result.commandsCount} commands`);
+  if (result.subagentsCount > 0) parts.push(`${result.subagentsCount} subagents`);
+  if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
+  if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
+  if (result.permissionsCount > 0) parts.push(`${result.permissionsCount} permissions`);
+  const verbPhrase = isPreview ? "Would convert" : "Converted";
+  const summary = `${modePrefix}${verbPhrase} ${totalConverted} file(s) total from ${fromTool} to ${toTools.join(", ")} (${parts.join(" + ")})`;
+  if (isPreview) {
+    logger5.info(summary);
+  } else {
+    logger5.success(summary);
+  }
+}
+
 // src/lib/fetch.ts
 import { join, posix } from "path";
 import { Semaphore } from "es-toolkit/promise";
@@ -1032,11 +1109,6 @@ async function fetchCommand(logger5, options) {
   }
 }
 
-// src/utils/result.ts
-function calculateTotalCount(result) {
-  return result.rulesCount + result.ignoreCount + result.mcpCount + result.commandsCount + result.subagentsCount + result.skillsCount + result.hooksCount + result.permissionsCount;
-}
-
 // src/cli/commands/generate.ts
 function logFeatureResult(logger5, params) {
   const { count, paths, featureName, isPreview, modePrefix } = params;
@@ -4110,7 +4182,7 @@ async function runGhInstall(logger5, options) {
 import { FastMCP } from "fastmcp";
 
 // src/mcp/tools.ts
-import { z as z18 } from "zod/mini";
+import { z as z19 } from "zod/mini";
 
 // src/mcp/commands.ts
 import { basename as basename2, join as join13 } from "path";
@@ -4299,16 +4371,118 @@ var commandTools = {
   }
 };
 
-// src/mcp/generate.ts
+// src/mcp/convert.ts
 import { z as z9 } from "zod/mini";
-var generateOptionsSchema = z9.object({
-  targets: z9.optional(z9.array(z9.string())),
+var convertOptionsSchema = z9.object({
+  from: z9.string(),
+  to: z9.array(z9.string()),
   features: z9.optional(z9.array(z9.string())),
-  delete: z9.optional(z9.boolean()),
   global: z9.optional(z9.boolean()),
-  simulateCommands: z9.optional(z9.boolean()),
-  simulateSubagents: z9.optional(z9.boolean()),
-  simulateSkills: z9.optional(z9.boolean())
+  dryRun: z9.optional(z9.boolean())
+});
+function parseToolTarget2(value, label) {
+  const result = ToolTargetSchema.safeParse(value);
+  if (!result.success) {
+    throw new Error(
+      `Invalid ${label} tool '${value}'. Must be one of: ${ALL_TOOL_TARGETS.join(", ")}`
+    );
+  }
+  return result.data;
+}
+async function executeConvert(options) {
+  try {
+    if (!options.from) {
+      return {
+        success: false,
+        error: "from is required. Please specify a source tool to convert from."
+      };
+    }
+    if (!options.to || options.to.length === 0) {
+      return {
+        success: false,
+        error: "to is required and must not be empty. Please specify destination tools."
+      };
+    }
+    const fromTool = parseToolTarget2(options.from, "source");
+    const toToolsRaw = options.to.map((t) => parseToolTarget2(t, "destination"));
+    const toTools = Array.from(new Set(toToolsRaw));
+    if (toTools.includes(fromTool)) {
+      return {
+        success: false,
+        error: `Destination tools must not include the source tool '${fromTool}'. Converting a tool onto itself is likely a mistake and may cause lossy round-trips.`
+      };
+    }
+    const config = await ConfigResolver.resolve({
+      targets: [fromTool, ...toTools],
+      // eslint-disable-next-line no-type-assertion/no-type-assertion
+      features: options.features ?? ["*"],
+      global: options.global,
+      dryRun: options.dryRun,
+      // Always use default baseDirs (process.cwd()) and configPath
+      // verbose and silent are meaningless in MCP context
+      verbose: false,
+      silent: true
+    });
+    const logger5 = new ConsoleLogger({ verbose: false, silent: true });
+    const convertResult = await convertFromTool({ config, fromTool, toTools, logger: logger5 });
+    return buildSuccessResponse({ convertResult, config, fromTool, toTools });
+  } catch (error) {
+    return {
+      success: false,
+      error: formatError(error)
+    };
+  }
+}
+function buildSuccessResponse(params) {
+  const { convertResult, config, fromTool, toTools } = params;
+  const totalCount = calculateTotalCount(convertResult);
+  return {
+    success: true,
+    result: {
+      rulesCount: convertResult.rulesCount,
+      ignoreCount: convertResult.ignoreCount,
+      mcpCount: convertResult.mcpCount,
+      commandsCount: convertResult.commandsCount,
+      subagentsCount: convertResult.subagentsCount,
+      skillsCount: convertResult.skillsCount,
+      hooksCount: convertResult.hooksCount,
+      permissionsCount: convertResult.permissionsCount,
+      totalCount
+    },
+    config: {
+      from: fromTool,
+      to: toTools,
+      features: config.getFeatures(),
+      global: config.getGlobal(),
+      dryRun: config.isPreviewMode()
+    }
+  };
+}
+var convertToolSchemas = {
+  executeConvert: convertOptionsSchema
+};
+var convertTools = {
+  executeConvert: {
+    name: "executeConvert",
+    description: "Execute the rulesync convert command to convert configuration files between AI tools without writing intermediate .rulesync/ files. Requires a source tool (from) and one or more destination tools (to).",
+    parameters: convertToolSchemas.executeConvert,
+    execute: async (options) => {
+      const result = await executeConvert(options);
+      return JSON.stringify(result, null, 2);
+    }
+  }
+};
+
+// src/mcp/generate.ts
+import { z as z10 } from "zod/mini";
+var generateOptionsSchema = z10.object({
+  targets: z10.optional(z10.array(z10.string())),
+  features: z10.optional(z10.array(z10.string())),
+  delete: z10.optional(z10.boolean()),
+  global: z10.optional(z10.boolean()),
+  simulateCommands: z10.optional(z10.boolean()),
+  simulateSubagents: z10.optional(z10.boolean()),
+  simulateSkills: z10.optional(z10.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -4336,7 +4510,7 @@ async function executeGenerate(options = {}) {
     });
     const logger5 = new ConsoleLogger({ verbose: false, silent: true });
     const generateResult = await generate({ config, logger: logger5 });
-    return buildSuccessResponse({ generateResult, config });
+    return buildSuccessResponse2({ generateResult, config });
   } catch (error) {
     return {
       success: false,
@@ -4344,7 +4518,7 @@ async function executeGenerate(options = {}) {
     };
   }
 }
-function buildSuccessResponse(params) {
+function buildSuccessResponse2(params) {
   const { generateResult, config } = params;
   const totalCount = calculateTotalCount(generateResult);
   return {
@@ -4388,7 +4562,7 @@ var generateTools = {
 
 // src/mcp/hooks.ts
 import { join as join14 } from "path";
-import { z as z10 } from "zod/mini";
+import { z as z11 } from "zod/mini";
 var maxHooksSizeBytes = 1024 * 1024;
 async function getHooksFile() {
   try {
@@ -4477,11 +4651,11 @@ async function deleteHooksFile() {
   }
 }
 var hooksToolSchemas = {
-  getHooksFile: z10.object({}),
-  putHooksFile: z10.object({
-    content: z10.string()
+  getHooksFile: z11.object({}),
+  putHooksFile: z11.object({
+    content: z11.string()
   }),
-  deleteHooksFile: z10.object({})
+  deleteHooksFile: z11.object({})
 };
 var hooksTools = {
   getHooksFile: {
@@ -4515,7 +4689,7 @@ var hooksTools = {
 
 // src/mcp/ignore.ts
 import { join as join15 } from "path";
-import { z as z11 } from "zod/mini";
+import { z as z12 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = join15(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -4578,11 +4752,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z11.object({}),
-  putIgnoreFile: z11.object({
-    content: z11.string()
+  getIgnoreFile: z12.object({}),
+  putIgnoreFile: z12.object({
+    content: z12.string()
   }),
-  deleteIgnoreFile: z11.object({})
+  deleteIgnoreFile: z12.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -4615,11 +4789,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-import { z as z12 } from "zod/mini";
-var importOptionsSchema = z12.object({
-  target: z12.string(),
-  features: z12.optional(z12.array(z12.string())),
-  global: z12.optional(z12.boolean())
+import { z as z13 } from "zod/mini";
+var importOptionsSchema = z13.object({
+  target: z13.string(),
+  features: z13.optional(z13.array(z13.string())),
+  global: z13.optional(z13.boolean())
 });
 async function executeImport(options) {
   try {
@@ -4643,7 +4817,7 @@ async function executeImport(options) {
     const tool = config.getTargets()[0];
     const logger5 = new ConsoleLogger({ verbose: false, silent: true });
     const importResult = await importFromTool({ config, tool, logger: logger5 });
-    return buildSuccessResponse2({ importResult, config, tool });
+    return buildSuccessResponse3({ importResult, config, tool });
   } catch (error) {
     return {
       success: false,
@@ -4651,7 +4825,7 @@ async function executeImport(options) {
     };
   }
 }
-function buildSuccessResponse2(params) {
+function buildSuccessResponse3(params) {
   const { importResult, config, tool } = params;
   const totalCount = calculateTotalCount(importResult);
   return {
@@ -4691,7 +4865,7 @@ var importTools = {
 
 // src/mcp/mcp.ts
 import { join as join16 } from "path";
-import { z as z13 } from "zod/mini";
+import { z as z14 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
@@ -4789,11 +4963,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z13.object({}),
-  putMcpFile: z13.object({
-    content: z13.string()
+  getMcpFile: z14.object({}),
+  putMcpFile: z14.object({
+    content: z14.string()
   }),
-  deleteMcpFile: z13.object({})
+  deleteMcpFile: z14.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -4827,7 +5001,7 @@ var mcpTools = {
 
 // src/mcp/permissions.ts
 import { join as join17 } from "path";
-import { z as z14 } from "zod/mini";
+import { z as z15 } from "zod/mini";
 var maxPermissionsSizeBytes = 1024 * 1024;
 async function getPermissionsFile() {
   try {
@@ -4916,11 +5090,11 @@ async function deletePermissionsFile() {
   }
 }
 var permissionsToolSchemas = {
-  getPermissionsFile: z14.object({}),
-  putPermissionsFile: z14.object({
-    content: z14.string()
+  getPermissionsFile: z15.object({}),
+  putPermissionsFile: z15.object({
+    content: z15.string()
   }),
-  deletePermissionsFile: z14.object({})
+  deletePermissionsFile: z15.object({})
 };
 var permissionsTools = {
   getPermissionsFile: {
@@ -4954,7 +5128,7 @@ var permissionsTools = {
 
 // src/mcp/rules.ts
 import { basename as basename3, join as join18 } from "path";
-import { z as z15 } from "zod/mini";
+import { z as z16 } from "zod/mini";
 var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
@@ -5078,17 +5252,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z15.object({}),
-  getRule: z15.object({
-    relativePathFromCwd: z15.string()
+  listRules: z16.object({}),
+  getRule: z16.object({
+    relativePathFromCwd: z16.string()
   }),
-  putRule: z15.object({
-    relativePathFromCwd: z15.string(),
+  putRule: z16.object({
+    relativePathFromCwd: z16.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z15.string()
+    body: z16.string()
   }),
-  deleteRule: z15.object({
-    relativePathFromCwd: z15.string()
+  deleteRule: z16.object({
+    relativePathFromCwd: z16.string()
   })
 };
 var ruleTools = {
@@ -5137,7 +5311,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 import { basename as basename4, dirname, join as join19 } from "path";
-import { z as z16 } from "zod/mini";
+import { z as z17 } from "zod/mini";
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -5310,23 +5484,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = z16.object({
-  name: z16.string(),
-  body: z16.string()
+var McpSkillFileSchema = z17.object({
+  name: z17.string(),
+  body: z17.string()
 });
 var skillToolSchemas = {
-  listSkills: z16.object({}),
-  getSkill: z16.object({
-    relativeDirPathFromCwd: z16.string()
+  listSkills: z17.object({}),
+  getSkill: z17.object({
+    relativeDirPathFromCwd: z17.string()
   }),
-  putSkill: z16.object({
-    relativeDirPathFromCwd: z16.string(),
+  putSkill: z17.object({
+    relativeDirPathFromCwd: z17.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: z16.string(),
-    otherFiles: z16.optional(z16.array(McpSkillFileSchema))
+    body: z17.string(),
+    otherFiles: z17.optional(z17.array(McpSkillFileSchema))
   }),
-  deleteSkill: z16.object({
-    relativeDirPathFromCwd: z16.string()
+  deleteSkill: z17.object({
+    relativeDirPathFromCwd: z17.string()
   })
 };
 var skillTools = {
@@ -5376,7 +5550,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 import { basename as basename5, join as join20 } from "path";
-import { z as z17 } from "zod/mini";
+import { z as z18 } from "zod/mini";
 var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
@@ -5505,17 +5679,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z17.object({}),
-  getSubagent: z17.object({
-    relativePathFromCwd: z17.string()
+  listSubagents: z18.object({}),
+  getSubagent: z18.object({
+    relativePathFromCwd: z18.string()
   }),
-  putSubagent: z17.object({
-    relativePathFromCwd: z17.string(),
+  putSubagent: z18.object({
+    relativePathFromCwd: z18.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z17.string()
+    body: z18.string()
   }),
-  deleteSubagent: z17.object({
-    relativePathFromCwd: z17.string()
+  deleteSubagent: z18.object({
+    relativePathFromCwd: z18.string()
   })
 };
 var subagentTools = {
@@ -5563,7 +5737,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = z18.enum([
+var rulesyncFeatureSchema = z19.enum([
   "rule",
   "command",
   "subagent",
@@ -5573,23 +5747,25 @@ var rulesyncFeatureSchema = z18.enum([
   "permissions",
   "hooks",
   "generate",
-  "import"
+  "import",
+  "convert"
 ]);
-var rulesyncOperationSchema = z18.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = z18.object({
-  name: z18.string(),
-  body: z18.string()
+var rulesyncOperationSchema = z19.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = z19.object({
+  name: z19.string(),
+  body: z19.string()
 });
-var rulesyncToolSchema = z18.object({
+var rulesyncToolSchema = z19.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: z18.optional(z18.string()),
-  frontmatter: z18.optional(z18.unknown()),
-  body: z18.optional(z18.string()),
-  otherFiles: z18.optional(z18.array(skillFileSchema)),
-  content: z18.optional(z18.string()),
-  generateOptions: z18.optional(generateOptionsSchema),
-  importOptions: z18.optional(importOptionsSchema)
+  targetPathFromCwd: z19.optional(z19.string()),
+  frontmatter: z19.optional(z19.unknown()),
+  body: z19.optional(z19.string()),
+  otherFiles: z19.optional(z19.array(skillFileSchema)),
+  content: z19.optional(z19.string()),
+  generateOptions: z19.optional(generateOptionsSchema),
+  importOptions: z19.optional(importOptionsSchema),
+  convertOptions: z19.optional(convertOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -5601,7 +5777,8 @@ var supportedOperationsByFeature = {
   permissions: ["get", "put", "delete"],
   hooks: ["get", "put", "delete"],
   generate: ["run"],
-  import: ["run"]
+  import: ["run"],
+  convert: ["run"]
 };
 function assertSupported({
   feature,
@@ -5649,7 +5826,7 @@ function ensureBody({ body, feature, operation }) {
 }
 var rulesyncTool = {
   name: "rulesyncTool",
-  description: "Manage Rulesync files through a single MCP tool. Features: rule/command/subagent/skill support list/get/put/delete; ignore/mcp/permissions/hooks support get/put/delete only; generate supports run only; import supports run only. Parameters: list requires no targetPathFromCwd (lists all items); get/delete require targetPathFromCwd; put requires targetPathFromCwd, frontmatter, and body (or content for ignore/mcp/permissions/hooks); generate/run uses generateOptions to configure generation; import/run uses importOptions to configure import.",
+  description: "Manage Rulesync files through a single MCP tool. Features: rule/command/subagent/skill support list/get/put/delete; ignore/mcp/permissions/hooks support get/put/delete only; generate supports run only; import supports run only; convert supports run only. Parameters: list requires no targetPathFromCwd (lists all items); get/delete require targetPathFromCwd; put requires targetPathFromCwd, frontmatter, and body (or content for ignore/mcp/permissions/hooks); generate/run uses generateOptions to configure generation; import/run uses importOptions to configure import; convert/run uses convertOptions to configure conversion.",
   parameters: rulesyncToolSchema,
   execute: async (args) => {
     const parsed = rulesyncToolSchema.parse(args);
@@ -5799,6 +5976,12 @@ var rulesyncTool = {
         }
         return importTools.executeImport.execute(parsed.importOptions);
       }
+      case "convert": {
+        if (!parsed.convertOptions) {
+          throw new Error("convertOptions is required for convert feature");
+        }
+        return convertTools.executeConvert.execute(parsed.convertOptions);
+      }
       default: {
         throw new Error(`Unknown feature: ${parsed.feature}`);
       }
@@ -6252,7 +6435,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.9.0";
+var getVersion = () => "8.11.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }
@@ -6313,6 +6496,21 @@ var main = async () => {
       await importCommand(logger5, options);
     })
   );
+  program.command("convert").description(
+    "Convert configurations from one AI tool to other AI tools without writing .rulesync/ files"
+  ).requiredOption("--from <tool>", "Source tool to convert from (e.g., 'cursor', 'claudecode')").requiredOption(
+    "--to <tools>",
+    "Comma-separated list of destination tools (e.g., 'copilot,claudecode')",
+    parseCommaSeparatedList
+  ).option(
+    "-f, --features <features>",
+    `Comma-separated list of features to convert (${ALL_FEATURES.join(",")}) or '*' for all`,
+    parseCommaSeparatedList
+  ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").option("-g, --global", "Convert for global(user scope) configuration files").option("--dry-run", "Dry run: show changes without writing files").action(
+    wrapCommand2("convert", "CONVERT_FAILED", async (logger5, options) => {
+      await convertCommand(logger5, options);
+    })
+  );
   program.command("mcp").description("Start MCP server for rulesync").action(
     wrapCommand2("mcp", "MCP_FAILED", async (logger5, _options) => {
       await mcpCommand(logger5, { version });