rulesync 8.9.0 → 8.11.0

package/README.md

@@ -58,6 +58,14 @@ rulesync import --targets cursor        # From .cursorrules
 rulesync import --targets copilot       # From .github/copilot-instructions.md
 ```
 
+Want to convert configuration from one AI tool to another directly, without
+adopting the `.rulesync/` source-of-truth workflow?
+
+```bash
+# Convert Cursor rules to Copilot and Claude Code in one shot (no .rulesync/ files written)
+rulesync convert --from cursor --to copilot,claudecode
+```
+
 See [Quick Start guide](https://dyoshikawa.github.io/rulesync/getting-started/quick-start) for more details.
 
 ## Supported Tools and Features

package/dist/{chunk-EHXIVMY2.js → chunk-ZX2YPC22.js}

@@ -878,6 +878,7 @@ var ErrorCodes = {
   VALIDATION_FAILED: "VALIDATION_FAILED",
   GENERATION_FAILED: "GENERATION_FAILED",
   IMPORT_FAILED: "IMPORT_FAILED",
+  CONVERT_FAILED: "CONVERT_FAILED",
   INSTALL_FAILED: "INSTALL_FAILED",
   UPDATE_FAILED: "UPDATE_FAILED",
   GITIGNORE_FAILED: "GITIGNORE_FAILED",
@@ -1038,10 +1039,6 @@ var JsonLogger = class extends BaseLogger {
   }
 };
 
-// src/lib/generate.ts
-import { join as join145 } from "path";
-import { intersection } from "es-toolkit";
-
 // src/features/commands/commands-processor.ts
 import { basename as basename2, join as join22, relative as relative3 } from "path";
 import { z as z16 } from "zod/mini";
@@ -19228,9 +19225,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   }
   toRulesyncRule() {
     let globs;
-    if (this.isRoot()) {
-      globs = ["**/*"];
-    } else if (this.frontmatter.applyTo) {
+    if (this.frontmatter.applyTo) {
       globs = this.frontmatter.applyTo.split(",").map((g) => g.trim());
     }
     const rulesyncFrontmatter = {
@@ -22300,7 +22295,239 @@ ${toonContent}`;
   }
 };
 
+// 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 } = 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)) {
+    logger.warn(`Source tool '${fromTool}' does not support feature '${feature}'. Skipping.`);
+    return 0;
+  }
+  if (!importableTargets.includes(fromTool)) {
+    logger.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) {
+    logger.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)) {
+      logger.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";
+      logger.success(`${verb} ${count} ${itemLabel} for ${toTool}`);
+    }
+  }
+  return totalCount;
+}
+function getBaseDir(config) {
+  return config.getBaseDirs()[0] ?? ".";
+}
+function buildRulesStrategy(ctx) {
+  const { config, logger } = 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 }),
+    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 } = ctx;
+  if (config.getGlobal()) {
+    logger.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,
+      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 } = 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 }),
+    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 } = 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 }),
+    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 } = 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 }),
+    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 } = 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 }),
+    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 } = 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 }),
+    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 } = 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 }),
+    loadSource: (p) => p.loadToolFiles(),
+    toRulesync: (p, files) => p.convertToolFilesToRulesyncFiles(files),
+    fromRulesync: (p, files) => p.convertRulesyncFilesToToolFiles(files),
+    write: (p, files) => p.writeAiFiles(files)
+  };
+}
+
 // src/lib/generate.ts
+import { join as join145 } from "path";
+import { intersection } from "es-toolkit";
 async function processFeatureGeneration(params) {
   const { config, processor, toolFiles } = params;
   let totalCount = 0;
@@ -23034,6 +23261,7 @@ export {
   isFeatureValueEnabled,
   ALL_TOOL_TARGETS,
   ALL_TOOL_TARGETS_WITH_WILDCARD,
+  ToolTargetSchema,
   findControlCharacter,
   GITIGNORE_DESTINATION_KEY,
   ConfigResolver,
@@ -23063,6 +23291,7 @@ export {
   RulesyncRuleFrontmatterSchema,
   RulesyncRule,
   RulesProcessor,
+  convertFromTool,
   checkRulesyncDirExists,
   generate,
   importFromTool