rulesync 8.10.0 → 8.11.0

package/dist/cli/index.cjs

@@ -19258,9 +19258,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 = {
@@ -27345,7 +27343,7 @@ async function runGhInstall(logger5, options) {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini91 = require("zod/mini");
+var import_mini92 = require("zod/mini");
 
 // src/mcp/commands.ts
 var import_node_path161 = require("path");
@@ -27534,16 +27532,118 @@ var commandTools = {
   }
 };
 
-// src/mcp/generate.ts
+// src/mcp/convert.ts
 var import_mini82 = require("zod/mini");
-var generateOptionsSchema = import_mini82.z.object({
-  targets: import_mini82.z.optional(import_mini82.z.array(import_mini82.z.string())),
+var convertOptionsSchema = import_mini82.z.object({
+  from: import_mini82.z.string(),
+  to: import_mini82.z.array(import_mini82.z.string()),
   features: import_mini82.z.optional(import_mini82.z.array(import_mini82.z.string())),
-  delete: import_mini82.z.optional(import_mini82.z.boolean()),
   global: import_mini82.z.optional(import_mini82.z.boolean()),
-  simulateCommands: import_mini82.z.optional(import_mini82.z.boolean()),
-  simulateSubagents: import_mini82.z.optional(import_mini82.z.boolean()),
-  simulateSkills: import_mini82.z.optional(import_mini82.z.boolean())
+  dryRun: import_mini82.z.optional(import_mini82.z.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
+var import_mini83 = require("zod/mini");
+var generateOptionsSchema = import_mini83.z.object({
+  targets: import_mini83.z.optional(import_mini83.z.array(import_mini83.z.string())),
+  features: import_mini83.z.optional(import_mini83.z.array(import_mini83.z.string())),
+  delete: import_mini83.z.optional(import_mini83.z.boolean()),
+  global: import_mini83.z.optional(import_mini83.z.boolean()),
+  simulateCommands: import_mini83.z.optional(import_mini83.z.boolean()),
+  simulateSubagents: import_mini83.z.optional(import_mini83.z.boolean()),
+  simulateSkills: import_mini83.z.optional(import_mini83.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -27571,7 +27671,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,
@@ -27579,7 +27679,7 @@ async function executeGenerate(options = {}) {
     };
   }
 }
-function buildSuccessResponse(params) {
+function buildSuccessResponse2(params) {
   const { generateResult, config } = params;
   const totalCount = calculateTotalCount(generateResult);
   return {
@@ -27623,7 +27723,7 @@ var generateTools = {
 
 // src/mcp/hooks.ts
 var import_node_path162 = require("path");
-var import_mini83 = require("zod/mini");
+var import_mini84 = require("zod/mini");
 var maxHooksSizeBytes = 1024 * 1024;
 async function getHooksFile() {
   try {
@@ -27712,11 +27812,11 @@ async function deleteHooksFile() {
   }
 }
 var hooksToolSchemas = {
-  getHooksFile: import_mini83.z.object({}),
-  putHooksFile: import_mini83.z.object({
-    content: import_mini83.z.string()
+  getHooksFile: import_mini84.z.object({}),
+  putHooksFile: import_mini84.z.object({
+    content: import_mini84.z.string()
   }),
-  deleteHooksFile: import_mini83.z.object({})
+  deleteHooksFile: import_mini84.z.object({})
 };
 var hooksTools = {
   getHooksFile: {
@@ -27750,7 +27850,7 @@ var hooksTools = {
 
 // src/mcp/ignore.ts
 var import_node_path163 = require("path");
-var import_mini84 = require("zod/mini");
+var import_mini85 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path163.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -27813,11 +27913,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini84.z.object({}),
-  putIgnoreFile: import_mini84.z.object({
-    content: import_mini84.z.string()
+  getIgnoreFile: import_mini85.z.object({}),
+  putIgnoreFile: import_mini85.z.object({
+    content: import_mini85.z.string()
   }),
-  deleteIgnoreFile: import_mini84.z.object({})
+  deleteIgnoreFile: import_mini85.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -27850,11 +27950,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-var import_mini85 = require("zod/mini");
-var importOptionsSchema = import_mini85.z.object({
-  target: import_mini85.z.string(),
-  features: import_mini85.z.optional(import_mini85.z.array(import_mini85.z.string())),
-  global: import_mini85.z.optional(import_mini85.z.boolean())
+var import_mini86 = require("zod/mini");
+var importOptionsSchema = import_mini86.z.object({
+  target: import_mini86.z.string(),
+  features: import_mini86.z.optional(import_mini86.z.array(import_mini86.z.string())),
+  global: import_mini86.z.optional(import_mini86.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -27878,7 +27978,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,
@@ -27886,7 +27986,7 @@ async function executeImport(options) {
     };
   }
 }
-function buildSuccessResponse2(params) {
+function buildSuccessResponse3(params) {
   const { importResult, config, tool } = params;
   const totalCount = calculateTotalCount(importResult);
   return {
@@ -27926,7 +28026,7 @@ var importTools = {
 
 // src/mcp/mcp.ts
 var import_node_path164 = require("path");
-var import_mini86 = require("zod/mini");
+var import_mini87 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
@@ -28024,11 +28124,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini86.z.object({}),
-  putMcpFile: import_mini86.z.object({
-    content: import_mini86.z.string()
+  getMcpFile: import_mini87.z.object({}),
+  putMcpFile: import_mini87.z.object({
+    content: import_mini87.z.string()
   }),
-  deleteMcpFile: import_mini86.z.object({})
+  deleteMcpFile: import_mini87.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -28062,7 +28162,7 @@ var mcpTools = {
 
 // src/mcp/permissions.ts
 var import_node_path165 = require("path");
-var import_mini87 = require("zod/mini");
+var import_mini88 = require("zod/mini");
 var maxPermissionsSizeBytes = 1024 * 1024;
 async function getPermissionsFile() {
   try {
@@ -28151,11 +28251,11 @@ async function deletePermissionsFile() {
   }
 }
 var permissionsToolSchemas = {
-  getPermissionsFile: import_mini87.z.object({}),
-  putPermissionsFile: import_mini87.z.object({
-    content: import_mini87.z.string()
+  getPermissionsFile: import_mini88.z.object({}),
+  putPermissionsFile: import_mini88.z.object({
+    content: import_mini88.z.string()
   }),
-  deletePermissionsFile: import_mini87.z.object({})
+  deletePermissionsFile: import_mini88.z.object({})
 };
 var permissionsTools = {
   getPermissionsFile: {
@@ -28189,7 +28289,7 @@ var permissionsTools = {
 
 // src/mcp/rules.ts
 var import_node_path166 = require("path");
-var import_mini88 = require("zod/mini");
+var import_mini89 = require("zod/mini");
 var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
@@ -28313,17 +28413,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini88.z.object({}),
-  getRule: import_mini88.z.object({
-    relativePathFromCwd: import_mini88.z.string()
+  listRules: import_mini89.z.object({}),
+  getRule: import_mini89.z.object({
+    relativePathFromCwd: import_mini89.z.string()
   }),
-  putRule: import_mini88.z.object({
-    relativePathFromCwd: import_mini88.z.string(),
+  putRule: import_mini89.z.object({
+    relativePathFromCwd: import_mini89.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini88.z.string()
+    body: import_mini89.z.string()
   }),
-  deleteRule: import_mini88.z.object({
-    relativePathFromCwd: import_mini88.z.string()
+  deleteRule: import_mini89.z.object({
+    relativePathFromCwd: import_mini89.z.string()
   })
 };
 var ruleTools = {
@@ -28372,7 +28472,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path167 = require("path");
-var import_mini89 = require("zod/mini");
+var import_mini90 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -28545,23 +28645,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini89.z.object({
-  name: import_mini89.z.string(),
-  body: import_mini89.z.string()
+var McpSkillFileSchema = import_mini90.z.object({
+  name: import_mini90.z.string(),
+  body: import_mini90.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini89.z.object({}),
-  getSkill: import_mini89.z.object({
-    relativeDirPathFromCwd: import_mini89.z.string()
+  listSkills: import_mini90.z.object({}),
+  getSkill: import_mini90.z.object({
+    relativeDirPathFromCwd: import_mini90.z.string()
   }),
-  putSkill: import_mini89.z.object({
-    relativeDirPathFromCwd: import_mini89.z.string(),
+  putSkill: import_mini90.z.object({
+    relativeDirPathFromCwd: import_mini90.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini89.z.string(),
-    otherFiles: import_mini89.z.optional(import_mini89.z.array(McpSkillFileSchema))
+    body: import_mini90.z.string(),
+    otherFiles: import_mini90.z.optional(import_mini90.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini89.z.object({
-    relativeDirPathFromCwd: import_mini89.z.string()
+  deleteSkill: import_mini90.z.object({
+    relativeDirPathFromCwd: import_mini90.z.string()
   })
 };
 var skillTools = {
@@ -28611,7 +28711,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path168 = require("path");
-var import_mini90 = require("zod/mini");
+var import_mini91 = require("zod/mini");
 var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
@@ -28740,17 +28840,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini90.z.object({}),
-  getSubagent: import_mini90.z.object({
-    relativePathFromCwd: import_mini90.z.string()
+  listSubagents: import_mini91.z.object({}),
+  getSubagent: import_mini91.z.object({
+    relativePathFromCwd: import_mini91.z.string()
   }),
-  putSubagent: import_mini90.z.object({
-    relativePathFromCwd: import_mini90.z.string(),
+  putSubagent: import_mini91.z.object({
+    relativePathFromCwd: import_mini91.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini90.z.string()
+    body: import_mini91.z.string()
   }),
-  deleteSubagent: import_mini90.z.object({
-    relativePathFromCwd: import_mini90.z.string()
+  deleteSubagent: import_mini91.z.object({
+    relativePathFromCwd: import_mini91.z.string()
   })
 };
 var subagentTools = {
@@ -28798,7 +28898,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini91.z.enum([
+var rulesyncFeatureSchema = import_mini92.z.enum([
   "rule",
   "command",
   "subagent",
@@ -28808,23 +28908,25 @@ var rulesyncFeatureSchema = import_mini91.z.enum([
   "permissions",
   "hooks",
   "generate",
-  "import"
+  "import",
+  "convert"
 ]);
-var rulesyncOperationSchema = import_mini91.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini91.z.object({
-  name: import_mini91.z.string(),
-  body: import_mini91.z.string()
+var rulesyncOperationSchema = import_mini92.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini92.z.object({
+  name: import_mini92.z.string(),
+  body: import_mini92.z.string()
 });
-var rulesyncToolSchema = import_mini91.z.object({
+var rulesyncToolSchema = import_mini92.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini91.z.optional(import_mini91.z.string()),
-  frontmatter: import_mini91.z.optional(import_mini91.z.unknown()),
-  body: import_mini91.z.optional(import_mini91.z.string()),
-  otherFiles: import_mini91.z.optional(import_mini91.z.array(skillFileSchema)),
-  content: import_mini91.z.optional(import_mini91.z.string()),
-  generateOptions: import_mini91.z.optional(generateOptionsSchema),
-  importOptions: import_mini91.z.optional(importOptionsSchema)
+  targetPathFromCwd: import_mini92.z.optional(import_mini92.z.string()),
+  frontmatter: import_mini92.z.optional(import_mini92.z.unknown()),
+  body: import_mini92.z.optional(import_mini92.z.string()),
+  otherFiles: import_mini92.z.optional(import_mini92.z.array(skillFileSchema)),
+  content: import_mini92.z.optional(import_mini92.z.string()),
+  generateOptions: import_mini92.z.optional(generateOptionsSchema),
+  importOptions: import_mini92.z.optional(importOptionsSchema),
+  convertOptions: import_mini92.z.optional(convertOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -28836,7 +28938,8 @@ var supportedOperationsByFeature = {
   permissions: ["get", "put", "delete"],
   hooks: ["get", "put", "delete"],
   generate: ["run"],
-  import: ["run"]
+  import: ["run"],
+  convert: ["run"]
 };
 function assertSupported({
   feature,
@@ -28884,7 +28987,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);
@@ -29034,6 +29137,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}`);
       }
@@ -29487,7 +29596,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 });
 }