rulesync 8.10.0 → 8.12.0

package/dist/{chunk-RMITDFVW.js → chunk-643VJ2QM.js}

@@ -1039,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";
@@ -4200,7 +4196,8 @@ var CODEXCLI_HOOK_EVENTS = [
   "preToolUse",
   "postToolUse",
   "beforeSubmitPrompt",
-  "stop"
+  "stop",
+  "permissionRequest"
 ];
 var hooksRecordSchema = z17.record(z17.string(), z17.array(HookDefinitionSchema));
 var HooksConfigSchema = z17.looseObject({
@@ -4317,7 +4314,8 @@ var CANONICAL_TO_CODEXCLI_EVENT_NAMES = {
   preToolUse: "PreToolUse",
   postToolUse: "PostToolUse",
   beforeSubmitPrompt: "UserPromptSubmit",
-  stop: "Stop"
+  stop: "Stop",
+  permissionRequest: "PermissionRequest"
 };
 var CODEXCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(
   Object.entries(CANONICAL_TO_CODEXCLI_EVENT_NAMES).map(([k, v]) => [v, k])
@@ -19229,9 +19227,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 = {
@@ -19272,7 +19268,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     if (root) {
       return new _CopilotRule({
         baseDir,
-        frontmatter: copilotFrontmatter,
+        frontmatter: {},
         body,
         relativeDirPath: paths.root.relativeDirPath,
         relativeFilePath: paths.root.relativeFilePath,
@@ -19298,12 +19294,14 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   }
   static async fromFile({
     baseDir = process.cwd(),
+    relativeDirPath,
     relativeFilePath,
     validate = true,
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const isRoot = relativeFilePath === paths.root.relativeFilePath;
+    const isRoot = relativeDirPath ? join126(relativeDirPath, relativeFilePath) === join126(paths.root.relativeDirPath, paths.root.relativeFilePath) : relativeFilePath === paths.root.relativeFilePath;
+    const resolvedRelativeDirPath = relativeDirPath ?? (isRoot ? paths.root.relativeDirPath : paths.nonRoot?.relativeDirPath ?? paths.root.relativeDirPath);
     if (isRoot) {
       const relativePath2 = join126(paths.root.relativeDirPath, paths.root.relativeFilePath);
       const filePath2 = join126(baseDir, relativePath2);
@@ -19321,7 +19319,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     if (!paths.nonRoot) {
       throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
     }
-    const relativePath = join126(paths.nonRoot.relativeDirPath, relativeFilePath);
+    const relativePath = join126(resolvedRelativeDirPath, relativeFilePath);
     const filePath = join126(baseDir, relativePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
@@ -19331,7 +19329,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     }
     return new _CopilotRule({
       baseDir,
-      relativeDirPath: paths.nonRoot.relativeDirPath,
+      relativeDirPath: resolvedRelativeDirPath,
       relativeFilePath: relativeFilePath.endsWith(".instructions.md") ? relativeFilePath : relativeFilePath.replace(/\.md$/, ".instructions.md"),
       frontmatter: result.data,
       body: content.trim(),
@@ -19346,7 +19344,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const isRoot = relativeFilePath === paths.root.relativeFilePath;
+    const isRoot = join126(relativeDirPath, relativeFilePath) === join126(paths.root.relativeDirPath, paths.root.relativeFilePath);
     return new _CopilotRule({
       baseDir,
       relativeDirPath,
@@ -22301,7 +22299,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;
@@ -23054,7 +23284,6 @@ export {
   CLIError,
   ConsoleLogger,
   JsonLogger,
-  PermissionsProcessor,
   SKILL_FILE_NAME,
   RulesyncSkillFrontmatterSchema,
   RulesyncSkill,
@@ -23066,6 +23295,7 @@ export {
   RulesyncRuleFrontmatterSchema,
   RulesyncRule,
   RulesProcessor,
+  convertFromTool,
   checkRulesyncDirExists,
   generate,
   importFromTool