rulesync 8.9.0 → 8.11.0

package/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   ALL_FEATURES: () => ALL_FEATURES,
   ALL_TOOL_TARGETS: () => ALL_TOOL_TARGETS,
+  convertFromTool: () => convertFromTool2,
   generate: () => generate2,
   importFromTool: () => importFromTool2
 });
@@ -876,10 +877,6 @@ function getBaseDirsInLightOfGlobal({
   return resolvedBaseDirs;
 }
 
-// src/lib/generate.ts
-var import_node_path148 = require("path");
-var import_es_toolkit5 = require("es-toolkit");
-
 // src/features/commands/commands-processor.ts
 var import_node_path25 = require("path");
 var import_mini16 = require("zod/mini");
@@ -19134,9 +19131,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 = {
@@ -22206,7 +22201,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
+var import_node_path148 = require("path");
+var import_es_toolkit5 = require("es-toolkit");
 async function processFeatureGeneration(params) {
   const { config, processor, toolFiles } = params;
   let totalCount = 0;
@@ -22922,10 +23149,35 @@ async function importFromTool2(options) {
   });
   return importFromTool({ config, tool: target, logger });
 }
+async function convertFromTool2(options) {
+  const { from, to, features, silent = true, verbose = false, ...rest } = options;
+  if (!from) {
+    throw new Error("from is required. Please specify a source tool to convert from.");
+  }
+  if (!to || to.length === 0) {
+    throw new Error("to is required and must not be empty. Please specify destination tools.");
+  }
+  const toTools = Array.from(new Set(to));
+  if (toTools.includes(from)) {
+    throw new Error(
+      `Destination tools must not include the source tool '${from}'. Converting a tool onto itself is likely a mistake and may cause lossy round-trips.`
+    );
+  }
+  const logger = new ConsoleLogger({ verbose, silent });
+  const config = await ConfigResolver.resolve({
+    ...rest,
+    targets: [from],
+    features: features ?? ["*"],
+    verbose,
+    silent
+  });
+  return convertFromTool({ config, fromTool: from, toTools, logger });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_FEATURES,
   ALL_TOOL_TARGETS,
+  convertFromTool,
   generate,
   importFromTool
 });

package/dist/index.d.cts

@@ -47,6 +47,17 @@ declare const FeatureSchema: z.ZodMiniEnum<{
 }>;
 type Feature = z.infer<typeof FeatureSchema>;
 
+type ConvertResult = {
+    rulesCount: number;
+    ignoreCount: number;
+    mcpCount: number;
+    commandsCount: number;
+    subagentsCount: number;
+    skillsCount: number;
+    hooksCount: number;
+    permissionsCount: number;
+};
+
 type ValidationResult = {
     success: true;
     error: undefined | null;
@@ -309,7 +320,14 @@ type ImportOptions = BaseOptions & {
     target: ToolTarget;
     features?: Feature[];
 };
+type ConvertOptions = BaseOptions & {
+    from: ToolTarget;
+    to: ToolTarget[];
+    features?: Feature[];
+    dryRun?: boolean;
+};
 declare function generate(options?: GenerateOptions): Promise<GenerateResult>;
 declare function importFromTool(options: ImportOptions): Promise<ImportResult>;
+declare function convertFromTool(options: ConvertOptions): Promise<ConvertResult>;
 
-export { ALL_FEATURES, ALL_TOOL_TARGETS, type Feature, type GenerateOptions, type GenerateResult, type ImportOptions, type ImportResult, type ToolTarget, generate, importFromTool };
+export { ALL_FEATURES, ALL_TOOL_TARGETS, type ConvertOptions, type ConvertResult, type Feature, type GenerateOptions, type GenerateResult, type ImportOptions, type ImportResult, type ToolTarget, convertFromTool, generate, importFromTool };

package/dist/index.d.ts

@@ -47,6 +47,17 @@ declare const FeatureSchema: z.ZodMiniEnum<{
 }>;
 type Feature = z.infer<typeof FeatureSchema>;
 
+type ConvertResult = {
+    rulesCount: number;
+    ignoreCount: number;
+    mcpCount: number;
+    commandsCount: number;
+    subagentsCount: number;
+    skillsCount: number;
+    hooksCount: number;
+    permissionsCount: number;
+};
+
 type ValidationResult = {
     success: true;
     error: undefined | null;
@@ -309,7 +320,14 @@ type ImportOptions = BaseOptions & {
     target: ToolTarget;
     features?: Feature[];
 };
+type ConvertOptions = BaseOptions & {
+    from: ToolTarget;
+    to: ToolTarget[];
+    features?: Feature[];
+    dryRun?: boolean;
+};
 declare function generate(options?: GenerateOptions): Promise<GenerateResult>;
 declare function importFromTool(options: ImportOptions): Promise<ImportResult>;
+declare function convertFromTool(options: ConvertOptions): Promise<ConvertResult>;
 
-export { ALL_FEATURES, ALL_TOOL_TARGETS, type Feature, type GenerateOptions, type GenerateResult, type ImportOptions, type ImportResult, type ToolTarget, generate, importFromTool };
+export { ALL_FEATURES, ALL_TOOL_TARGETS, type ConvertOptions, type ConvertResult, type Feature, type GenerateOptions, type GenerateResult, type ImportOptions, type ImportResult, type ToolTarget, convertFromTool, generate, importFromTool };

package/dist/index.js

@@ -4,9 +4,10 @@ import {
   ConfigResolver,
   ConsoleLogger,
   checkRulesyncDirExists,
+  convertFromTool,
   generate,
   importFromTool
-} from "./chunk-EHXIVMY2.js";
+} from "./chunk-ZX2YPC22.js";
 
 // src/index.ts
 async function generate2(options = {}) {
@@ -36,9 +37,34 @@ async function importFromTool2(options) {
   });
   return importFromTool({ config, tool: target, logger });
 }
+async function convertFromTool2(options) {
+  const { from, to, features, silent = true, verbose = false, ...rest } = options;
+  if (!from) {
+    throw new Error("from is required. Please specify a source tool to convert from.");
+  }
+  if (!to || to.length === 0) {
+    throw new Error("to is required and must not be empty. Please specify destination tools.");
+  }
+  const toTools = Array.from(new Set(to));
+  if (toTools.includes(from)) {
+    throw new Error(
+      `Destination tools must not include the source tool '${from}'. Converting a tool onto itself is likely a mistake and may cause lossy round-trips.`
+    );
+  }
+  const logger = new ConsoleLogger({ verbose, silent });
+  const config = await ConfigResolver.resolve({
+    ...rest,
+    targets: [from],
+    features: features ?? ["*"],
+    verbose,
+    silent
+  });
+  return convertFromTool({ config, fromTool: from, toTools, logger });
+}
 export {
   ALL_FEATURES,
   ALL_TOOL_TARGETS,
+  convertFromTool2 as convertFromTool,
   generate2 as generate,
   importFromTool2 as importFromTool
 };

package/package.json

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