rulesync 8.9.0 → 8.10.0

package/dist/cli/index.js

@@ -16,6 +16,7 @@ import {
   JsonLogger,
   MAX_FILE_SIZE,
   McpProcessor,
+  PermissionsProcessor,
   RULESYNC_AIIGNORE_FILE_NAME,
   RULESYNC_AIIGNORE_RELATIVE_FILE_PATH,
   RULESYNC_COMMANDS_RELATIVE_DIR_PATH,
@@ -53,6 +54,7 @@ import {
   SKILL_FILE_NAME,
   SkillsProcessor,
   SubagentsProcessor,
+  ToolTargetSchema,
   checkPathTraversal,
   checkRulesyncDirExists,
   createTempDirectory,
@@ -77,7 +79,7 @@ import {
   stringifyFrontmatter,
   toPosixPath,
   writeFileContent
-} from "../chunk-EHXIVMY2.js";
+} from "../chunk-RMITDFVW.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -85,6 +87,311 @@ 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;
+}
+
+// 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 +1339,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;
@@ -6252,7 +6554,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.9.0";
+var getVersion = () => "8.10.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }
@@ -6313,6 +6615,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 });

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   checkRulesyncDirExists,
   generate,
   importFromTool
-} from "./chunk-EHXIVMY2.js";
+} from "./chunk-RMITDFVW.js";
 
 // src/index.ts
 async function generate2(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "8.9.0",
+  "version": "8.10.0",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",