rulesync 8.10.0 → 8.11.0

package/dist/cli/index.js

@@ -16,7 +16,6 @@ import {
   JsonLogger,
   MAX_FILE_SIZE,
   McpProcessor,
-  PermissionsProcessor,
   RULESYNC_AIIGNORE_FILE_NAME,
   RULESYNC_AIIGNORE_RELATIVE_FILE_PATH,
   RULESYNC_COMMANDS_RELATIVE_DIR_PATH,
@@ -57,6 +56,7 @@ import {
   ToolTargetSchema,
   checkPathTraversal,
   checkRulesyncDirExists,
+  convertFromTool,
   createTempDirectory,
   directoryExists,
   ensureDir,
@@ -79,7 +79,7 @@ import {
   stringifyFrontmatter,
   toPosixPath,
   writeFileContent
-} from "../chunk-RMITDFVW.js";
+} from "../chunk-ZX2YPC22.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -87,236 +87,6 @@ import { Command } from "commander";
 // src/utils/parse-comma-separated-list.ts
 var parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
 
-// src/lib/convert.ts
-async function convertFromTool(params) {
-  const ctx = params;
-  const [
-    rulesCount,
-    ignoreCount,
-    mcpCount,
-    commandsCount,
-    subagentsCount,
-    skillsCount,
-    hooksCount,
-    permissionsCount
-  ] = [
-    await runFeatureConvert(ctx, buildRulesStrategy(ctx)),
-    await runFeatureConvert(ctx, buildIgnoreStrategy(ctx)),
-    await runFeatureConvert(ctx, buildMcpStrategy(ctx)),
-    await runFeatureConvert(ctx, buildCommandsStrategy(ctx)),
-    await runFeatureConvert(ctx, buildSubagentsStrategy(ctx)),
-    await runFeatureConvert(ctx, buildSkillsStrategy(ctx)),
-    await runFeatureConvert(ctx, buildHooksStrategy(ctx)),
-    await runFeatureConvert(ctx, buildPermissionsStrategy(ctx))
-  ];
-  return {
-    rulesCount,
-    ignoreCount,
-    mcpCount,
-    commandsCount,
-    subagentsCount,
-    skillsCount,
-    hooksCount,
-    permissionsCount
-  };
-}
-async function runFeatureConvert(ctx, strategy) {
-  if (!strategy) return 0;
-  const { config, fromTool, toTools, logger: logger5 } = ctx;
-  const {
-    feature,
-    itemLabel,
-    allTargets,
-    importableTargets = allTargets,
-    createProcessor,
-    loadSource,
-    toRulesync,
-    fromRulesync,
-    write
-  } = strategy;
-  if (!config.getFeatures(fromTool).includes(feature)) {
-    return 0;
-  }
-  if (!allTargets.includes(fromTool)) {
-    logger5.warn(`Source tool '${fromTool}' does not support feature '${feature}'. Skipping.`);
-    return 0;
-  }
-  if (!importableTargets.includes(fromTool)) {
-    logger5.warn(`Conversion from ${fromTool} ${feature} is not supported. Skipping.`);
-    return 0;
-  }
-  const sourceProcessor = createProcessor({ toolTarget: fromTool, dryRun: false });
-  const sourceItems = await loadSource(sourceProcessor);
-  if (sourceItems.length === 0) {
-    logger5.warn(`No ${feature} files found for ${fromTool}. Skipping ${feature} conversion.`);
-    return 0;
-  }
-  const rulesyncItems = await toRulesync(sourceProcessor, sourceItems);
-  let totalCount = 0;
-  for (const toTool of toTools) {
-    if (!allTargets.includes(toTool)) {
-      logger5.warn(`Destination tool '${toTool}' does not support feature '${feature}'. Skipping.`);
-      continue;
-    }
-    const destProcessor = createProcessor({
-      toolTarget: toTool,
-      dryRun: config.isPreviewMode()
-    });
-    const destItems = await fromRulesync(destProcessor, rulesyncItems);
-    const { count } = await write(destProcessor, destItems);
-    totalCount += count;
-    if (config.getVerbose() && count > 0) {
-      const verb = config.isPreviewMode() ? "Would convert" : "Converted";
-      logger5.success(`${verb} ${count} ${itemLabel} for ${toTool}`);
-    }
-  }
-  return totalCount;
-}
-function getBaseDir(config) {
-  return config.getBaseDirs()[0] ?? ".";
-}
-function buildRulesStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = RulesProcessor.getToolTargets({ global });
-  return {
-    feature: "rules",
-    itemLabel: "rule file(s)",
-    allTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new RulesProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-function buildIgnoreStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  if (config.getGlobal()) {
-    logger5.debug("Skipping ignore conversion (not supported in global mode)");
-    return null;
-  }
-  const baseDir = getBaseDir(config);
-  const allTargets = IgnoreProcessor.getToolTargets();
-  return {
-    feature: "ignore",
-    itemLabel: "ignore file(s)",
-    allTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new IgnoreProcessor({
-      baseDir,
-      toolTarget,
-      dryRun,
-      logger: logger5,
-      featureOptions: config.getFeatureOptions(toolTarget, "ignore")
-    }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-function buildMcpStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = McpProcessor.getToolTargets({ global });
-  return {
-    feature: "mcp",
-    itemLabel: "MCP file(s)",
-    allTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new McpProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-function buildCommandsStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = CommandsProcessor.getToolTargets({ global, includeSimulated: false });
-  return {
-    feature: "commands",
-    itemLabel: "command file(s)",
-    allTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new CommandsProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-function buildSubagentsStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = SubagentsProcessor.getToolTargets({ global, includeSimulated: false });
-  return {
-    feature: "subagents",
-    itemLabel: "subagent file(s)",
-    allTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new SubagentsProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-function buildSkillsStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = SkillsProcessor.getToolTargets({ global });
-  return {
-    feature: "skills",
-    itemLabel: "skill(s)",
-    allTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new SkillsProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolDirs(),
-    toRulesync: (p, dirs) => p.convertToolDirsToRulesyncDirs(dirs),
-    fromRulesync: (p, dirs) => p.convertRulesyncDirsToToolDirs(dirs),
-    write: (p, dirs) => p.writeAiDirs(dirs)
-  };
-}
-function buildHooksStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = HooksProcessor.getToolTargets({ global });
-  const importableTargets = HooksProcessor.getToolTargets({ global, importOnly: true });
-  return {
-    feature: "hooks",
-    itemLabel: "hooks file(s)",
-    allTargets,
-    importableTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new HooksProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-function buildPermissionsStrategy(ctx) {
-  const { config, logger: logger5 } = ctx;
-  const global = config.getGlobal();
-  const baseDir = getBaseDir(config);
-  const allTargets = PermissionsProcessor.getToolTargets({ global });
-  const importableTargets = PermissionsProcessor.getToolTargets({ global, importOnly: true });
-  return {
-    feature: "permissions",
-    itemLabel: "permissions file(s)",
-    allTargets,
-    importableTargets,
-    createProcessor: ({ toolTarget, dryRun }) => new PermissionsProcessor({ baseDir, toolTarget, global, dryRun, logger: logger5 }),
-    loadSource: (p) => p.loadToolFiles(),
-    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
-    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
-    write: (p, files) => p.writeAiFiles(files)
-  };
-}
-
 // src/utils/result.ts
 function calculateTotalCount(result) {
   return result.rulesCount + result.ignoreCount + result.mcpCount + result.commandsCount + result.subagentsCount + result.skillsCount + result.hooksCount + result.permissionsCount;
@@ -4412,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";
@@ -4601,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 {
@@ -4638,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,
@@ -4646,7 +4518,7 @@ async function executeGenerate(options = {}) {
     };
   }
 }
-function buildSuccessResponse(params) {
+function buildSuccessResponse2(params) {
   const { generateResult, config } = params;
   const totalCount = calculateTotalCount(generateResult);
   return {
@@ -4690,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 {
@@ -4779,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: {
@@ -4817,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);
@@ -4880,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: {
@@ -4917,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 {
@@ -4945,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,
@@ -4953,7 +4825,7 @@ async function executeImport(options) {
     };
   }
 }
-function buildSuccessResponse2(params) {
+function buildSuccessResponse3(params) {
   const { importResult, config, tool } = params;
   const totalCount = calculateTotalCount(importResult);
   return {
@@ -4993,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 {
@@ -5091,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: {
@@ -5129,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 {
@@ -5218,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: {
@@ -5256,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;
@@ -5380,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 = {
@@ -5439,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;
@@ -5612,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 = {
@@ -5678,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;
@@ -5807,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 = {
@@ -5865,7 +5737,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = z18.enum([
+var rulesyncFeatureSchema = z19.enum([
   "rule",
   "command",
   "subagent",
@@ -5875,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"],
@@ -5903,7 +5777,8 @@ var supportedOperationsByFeature = {
   permissions: ["get", "put", "delete"],
   hooks: ["get", "put", "delete"],
   generate: ["run"],
-  import: ["run"]
+  import: ["run"],
+  convert: ["run"]
 };
 function assertSupported({
   feature,
@@ -5951,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);
@@ -6101,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}`);
       }
@@ -6554,7 +6435,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.10.0";
+var getVersion = () => "8.11.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }