rulesync 3.23.0 → 3.23.3

package/dist/index.cjs

@@ -581,7 +581,6 @@ var AiFile = class {
     relativeDirPath,
     relativeFilePath,
     fileContent,
-    validate = true,
     global = false
   }) {
     this.baseDir = baseDir;
@@ -589,12 +588,6 @@ var AiFile = class {
     this.relativeFilePath = relativeFilePath;
     this.fileContent = fileContent;
     this.global = global;
-    if (validate) {
-      const result = this.validate();
-      if (!result.success) {
-        throw result.error;
-      }
-    }
   }
   static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
@@ -2711,7 +2704,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/features/mcp/mcp-processor.ts
-var import_mini13 = require("zod/mini");
+var import_mini15 = require("zod/mini");
 
 // src/features/mcp/amazonqcli-mcp.ts
 var import_node_path28 = require("path");
@@ -2719,9 +2712,11 @@ var import_node_path28 = require("path");
 // src/features/mcp/rulesync-mcp.ts
 var import_node_path27 = require("path");
 var import_object = require("es-toolkit/object");
+var import_mini13 = require("zod/mini");
+
+// src/types/mcp.ts
 var import_mini12 = require("zod/mini");
-var McpTransportTypeSchema = import_mini12.z.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = import_mini12.z.object({
+var McpServerSchema = import_mini12.z.object({
   type: import_mini12.z.optional(import_mini12.z.enum(["stdio", "sse", "http"])),
   command: import_mini12.z.optional(import_mini12.z.union([import_mini12.z.string(), import_mini12.z.array(import_mini12.z.string())])),
   args: import_mini12.z.optional(import_mini12.z.array(import_mini12.z.string())),
@@ -2733,27 +2728,30 @@ var McpServerBaseSchema = import_mini12.z.object({
   timeout: import_mini12.z.optional(import_mini12.z.number()),
   trust: import_mini12.z.optional(import_mini12.z.boolean()),
   cwd: import_mini12.z.optional(import_mini12.z.string()),
-  transport: import_mini12.z.optional(McpTransportTypeSchema),
+  transport: import_mini12.z.optional(import_mini12.z.enum(["stdio", "sse", "http"])),
   alwaysAllow: import_mini12.z.optional(import_mini12.z.array(import_mini12.z.string())),
   tools: import_mini12.z.optional(import_mini12.z.array(import_mini12.z.string())),
   kiroAutoApprove: import_mini12.z.optional(import_mini12.z.array(import_mini12.z.string())),
   kiroAutoBlock: import_mini12.z.optional(import_mini12.z.array(import_mini12.z.string())),
   headers: import_mini12.z.optional(import_mini12.z.record(import_mini12.z.string(), import_mini12.z.string()))
 });
-var RulesyncMcpServersSchema = import_mini12.z.union([
-  import_mini12.z.extend(McpServerBaseSchema, {
-    targets: import_mini12.z.optional(RulesyncTargetsSchema),
-    description: import_mini12.z.optional(import_mini12.z.string()),
-    exposed: import_mini12.z.optional(import_mini12.z.literal(false))
+var McpServersSchema = import_mini12.z.record(import_mini12.z.string(), McpServerSchema);
+
+// src/features/mcp/rulesync-mcp.ts
+var RulesyncMcpServerSchema = import_mini13.z.union([
+  import_mini13.z.extend(McpServerSchema, {
+    targets: import_mini13.z.optional(RulesyncTargetsSchema),
+    description: import_mini13.z.optional(import_mini13.z.string()),
+    exposed: import_mini13.z.optional(import_mini13.z.literal(false))
   }),
-  import_mini12.z.extend(McpServerBaseSchema, {
-    targets: import_mini12.z.optional(RulesyncTargetsSchema),
-    description: import_mini12.z.undefined(),
-    exposed: import_mini12.z.literal(true)
+  import_mini13.z.extend(McpServerSchema, {
+    targets: import_mini13.z.optional(RulesyncTargetsSchema),
+    description: import_mini13.z.undefined(),
+    exposed: import_mini13.z.literal(true)
   })
 ]);
-var RulesyncMcpConfigSchema = import_mini12.z.object({
-  mcpServers: import_mini12.z.record(import_mini12.z.string(), RulesyncMcpServersSchema)
+var RulesyncMcpConfigSchema = import_mini13.z.object({
+  mcpServers: import_mini13.z.record(import_mini13.z.string(), RulesyncMcpServerSchema)
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
@@ -2782,6 +2780,10 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
     };
   }
   validate() {
+    const result = RulesyncMcpConfigSchema.safeParse(this.json);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
     return { success: true, error: null };
   }
   static async fromFile({
@@ -2831,46 +2833,25 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
       modularMcp
     });
   }
-  getExposedServers() {
-    if (!this.json || typeof this.json !== "object") {
-      return {};
-    }
-    if (!this.json.mcpServers || typeof this.json.mcpServers !== "object") {
-      return {};
-    }
+  getExposedMcpServers() {
     return Object.fromEntries(
-      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => serverConfig.exposed === true).map(([serverName, serverConfig]) => [
+      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => !this.modularMcp || serverConfig.exposed).map(([serverName, serverConfig]) => [
         serverName,
-        (0, import_object.omit)(serverConfig, ["description", "exposed"])
+        (0, import_object.omit)(serverConfig, ["targets", "description", "exposed"])
       ])
     );
   }
-  getJson({ modularMcp = false } = {}) {
-    if (!this.json || typeof this.json !== "object") {
-      return this.json;
-    }
-    if (!this.json.mcpServers || typeof this.json.mcpServers !== "object") {
-      return this.json;
-    }
-    if (modularMcp) {
-      const mcpServersForModularMcp = Object.fromEntries(
-        Object.entries(this.json.mcpServers).filter(([, serverConfig]) => !serverConfig.exposed).map(([serverName, serverConfig]) => [serverName, (0, import_object.omit)(serverConfig, ["exposed"])])
-      );
-      return {
-        ...this.json,
-        mcpServers: mcpServersForModularMcp
-      };
-    }
-    const mcpServersWithoutDescription = Object.fromEntries(
-      Object.entries(this.json.mcpServers).map(([serverName, serverConfig]) => [
+  getModularizedMcpServers() {
+    return Object.fromEntries(
+      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => this.modularMcp && !serverConfig.exposed).map(([serverName, serverConfig]) => [
         serverName,
-        (0, import_object.omit)(serverConfig, ["description", "exposed"])
+        // description is required for modular-mcp servers
+        (0, import_object.omit)(serverConfig, ["targets", "exposed"])
       ])
     );
-    return {
-      ...this.json,
-      mcpServers: mcpServersWithoutDescription
-    };
+  }
+  getJson() {
+    return this.json;
   }
 };
 
@@ -2974,6 +2955,14 @@ var import_node_path30 = require("path");
 
 // src/features/mcp/modular-mcp.ts
 var import_node_path29 = require("path");
+var import_mini14 = require("zod/mini");
+var ModularMcpServerSchema = import_mini14.z.extend(McpServerSchema, {
+  description: import_mini14.z.string()
+  // Required for modular-mcp
+});
+var ModularMcpConfigSchema = import_mini14.z.object({
+  mcpServers: import_mini14.z.record(import_mini14.z.string(), ModularMcpServerSchema)
+});
 var ModularMcp = class _ModularMcp extends AiFile {
   json;
   constructor(params) {
@@ -3045,7 +3034,7 @@ var ModularMcp = class _ModularMcp extends AiFile {
       global && relativeDirPath ? { global: true, relativeDirPath } : { global: false, relativeDirPath: void 0 }
     );
     const modularMcpJson = {
-      mcpServers: rulesyncMcp.getJson({ modularMcp: true }).mcpServers
+      mcpServers: rulesyncMcp.getModularizedMcpServers()
     };
     return new _ModularMcp({
       baseDir,
@@ -3056,6 +3045,10 @@ var ModularMcp = class _ModularMcp extends AiFile {
     });
   }
   validate() {
+    const result = ModularMcpConfigSchema.safeParse(this.json);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
     return { success: true, error: null };
   }
 };
@@ -3124,9 +3117,9 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
           relativeDirPath: this.getSettablePaths({ global: true }).relativeDirPath
         }) : ModularMcp.getMcpServers({ baseDir, global: false }),
         // Merge exposed servers
-        ...rulesyncMcp.getExposedServers()
+        ...rulesyncMcp.getExposedMcpServers()
       }
-    } : { ...json, mcpServers: rulesyncMcp.getJson({ modularMcp: false }).mcpServers };
+    } : { ...json, mcpServers: rulesyncMcp.getExposedMcpServers() };
     return new _ClaudecodeMcp({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
@@ -3262,7 +3255,7 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
       smolToml.stringify({})
     );
     const configToml = smolToml.parse(configTomlFileContent);
-    const mcpServers = rulesyncMcp.getJson({ modularMcp: false }).mcpServers;
+    const mcpServers = rulesyncMcp.getJson().mcpServers;
     const filteredMcpServers = this.removeEmptyEntries(mcpServers);
     configToml["mcp_servers"] = filteredMcpServers;
     return new _CodexcliMcp({
@@ -3394,7 +3387,7 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
     rulesyncMcp,
     validate = true
   }) {
-    const json = rulesyncMcp.getJson({ modularMcp: false });
+    const json = rulesyncMcp.getJson();
     const cursorConfig = {
       mcpServers: json.mcpServers || {}
     };
@@ -3476,7 +3469,7 @@ var GeminiCliMcp = class _GeminiCliMcp extends ToolMcp {
       JSON.stringify({ mcpServers: {} }, null, 2)
     );
     const json = JSON.parse(fileContent);
-    const newJson = { ...json, mcpServers: rulesyncMcp.getJson({ modularMcp: false }).mcpServers };
+    const newJson = { ...json, mcpServers: rulesyncMcp.getJson().mcpServers };
     return new _GeminiCliMcp({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
@@ -3563,7 +3556,7 @@ var mcpProcessorToolTargets = [
   "geminicli",
   "roo"
 ];
-var McpProcessorToolTargetSchema = import_mini13.z.enum(
+var McpProcessorToolTargetSchema = import_mini15.z.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   mcpProcessorToolTargets.concat("codexcli")
 );
@@ -3802,14 +3795,14 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path66 = require("path");
 var import_fast_xml_parser = require("fast-xml-parser");
-var import_mini22 = require("zod/mini");
+var import_mini24 = require("zod/mini");
 
 // src/features/subagents/agentsmd-subagent.ts
 var import_node_path38 = require("path");
 
 // src/features/subagents/simulated-subagent.ts
 var import_node_path37 = require("path");
-var import_mini14 = require("zod/mini");
+var import_mini16 = require("zod/mini");
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -3844,9 +3837,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = import_mini14.z.object({
-  name: import_mini14.z.string(),
-  description: import_mini14.z.string()
+var SimulatedSubagentFrontmatterSchema = import_mini16.z.object({
+  name: import_mini16.z.string(),
+  description: import_mini16.z.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -4080,22 +4073,22 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path46 = require("path");
-var import_mini17 = require("zod/mini");
+var import_mini19 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path45 = require("path");
-var import_mini16 = require("zod/mini");
+var import_mini18 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
 var import_node_path44 = require("path");
-var import_mini15 = require("zod/mini");
-var RulesyncSubagentModelSchema = import_mini15.z.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = import_mini15.z.object({
+var import_mini17 = require("zod/mini");
+var RulesyncSubagentModelSchema = import_mini17.z.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = import_mini17.z.object({
   targets: RulesyncTargetsSchema,
-  name: import_mini15.z.string(),
-  description: import_mini15.z.string(),
-  claudecode: import_mini15.z.optional(
-    import_mini15.z.object({
+  name: import_mini17.z.string(),
+  description: import_mini17.z.string(),
+  claudecode: import_mini17.z.optional(
+    import_mini17.z.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -4169,10 +4162,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = import_mini16.z.object({
-  name: import_mini16.z.string(),
-  description: import_mini16.z.string(),
-  model: import_mini16.z.optional(import_mini16.z.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = import_mini18.z.object({
+  name: import_mini18.z.string(),
+  description: import_mini18.z.string(),
+  model: import_mini18.z.optional(import_mini18.z.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -4316,7 +4309,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "roo"
 ];
 var subagentsProcessorToolTargetsGlobal = ["claudecode"];
-var SubagentsProcessorToolTargetSchema = import_mini17.z.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = import_mini19.z.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   global;
@@ -4601,23 +4594,23 @@ var import_node_path48 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path47 = require("path");
-var import_mini18 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini18.z.object({
-  root: import_mini18.z.optional(import_mini18.z.optional(import_mini18.z.boolean())),
-  targets: import_mini18.z.optional(RulesyncTargetsSchema),
-  description: import_mini18.z.optional(import_mini18.z.string()),
-  globs: import_mini18.z.optional(import_mini18.z.array(import_mini18.z.string())),
-  agentsmd: import_mini18.z.optional(
-    import_mini18.z.object({
+var import_mini20 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini20.z.object({
+  root: import_mini20.z.optional(import_mini20.z.optional(import_mini20.z.boolean())),
+  targets: import_mini20.z.optional(RulesyncTargetsSchema),
+  description: import_mini20.z.optional(import_mini20.z.string()),
+  globs: import_mini20.z.optional(import_mini20.z.array(import_mini20.z.string())),
+  agentsmd: import_mini20.z.optional(
+    import_mini20.z.object({
       // @example "path/to/subproject"
-      subprojectPath: import_mini18.z.optional(import_mini18.z.string())
+      subprojectPath: import_mini20.z.optional(import_mini20.z.string())
     })
   ),
-  cursor: import_mini18.z.optional(
-    import_mini18.z.object({
-      alwaysApply: import_mini18.z.optional(import_mini18.z.boolean()),
-      description: import_mini18.z.optional(import_mini18.z.string()),
-      globs: import_mini18.z.optional(import_mini18.z.array(import_mini18.z.string()))
+  cursor: import_mini20.z.optional(
+    import_mini20.z.object({
+      alwaysApply: import_mini20.z.optional(import_mini20.z.boolean()),
+      description: import_mini20.z.optional(import_mini20.z.string()),
+      globs: import_mini20.z.optional(import_mini20.z.array(import_mini20.z.string()))
     })
   )
 });
@@ -5209,9 +5202,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path54 = require("path");
-var import_mini19 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini19.z.object({
-  description: import_mini19.z.string()
+var import_mini21 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini21.z.object({
+  description: import_mini21.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -5358,10 +5351,10 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path56 = require("path");
-var import_mini20 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini20.z.object({
-  description: import_mini20.z.optional(import_mini20.z.string()),
-  applyTo: import_mini20.z.optional(import_mini20.z.string())
+var import_mini22 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini22.z.object({
+  description: import_mini22.z.optional(import_mini22.z.string()),
+  applyTo: import_mini22.z.optional(import_mini22.z.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -5528,11 +5521,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path57 = require("path");
-var import_mini21 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini21.z.object({
-  description: import_mini21.z.optional(import_mini21.z.string()),
-  globs: import_mini21.z.optional(import_mini21.z.string()),
-  alwaysApply: import_mini21.z.optional(import_mini21.z.boolean())
+var import_mini23 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini23.z.object({
+  description: import_mini23.z.optional(import_mini23.z.string()),
+  globs: import_mini23.z.optional(import_mini23.z.string()),
+  alwaysApply: import_mini23.z.optional(import_mini23.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -6248,7 +6241,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini22.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini24.z.enum(rulesProcessorToolTargets);
 var rulesProcessorToolTargetsGlobal = [
   "claudecode",
   "codexcli",
@@ -7744,7 +7737,7 @@ var import_fastmcp = require("fastmcp");
 
 // src/mcp/commands.ts
 var import_node_path69 = require("path");
-var import_mini23 = require("zod/mini");
+var import_mini25 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -7863,17 +7856,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini23.z.object({}),
-  getCommand: import_mini23.z.object({
-    relativePathFromCwd: import_mini23.z.string()
+  listCommands: import_mini25.z.object({}),
+  getCommand: import_mini25.z.object({
+    relativePathFromCwd: import_mini25.z.string()
   }),
-  putCommand: import_mini23.z.object({
-    relativePathFromCwd: import_mini23.z.string(),
+  putCommand: import_mini25.z.object({
+    relativePathFromCwd: import_mini25.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini23.z.string()
+    body: import_mini25.z.string()
   }),
-  deleteCommand: import_mini23.z.object({
-    relativePathFromCwd: import_mini23.z.string()
+  deleteCommand: import_mini25.z.object({
+    relativePathFromCwd: import_mini25.z.string()
   })
 };
 var commandTools = {
@@ -7922,7 +7915,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 var import_node_path70 = require("path");
-var import_mini24 = require("zod/mini");
+var import_mini26 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path70.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
@@ -7973,11 +7966,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini24.z.object({}),
-  putIgnoreFile: import_mini24.z.object({
-    content: import_mini24.z.string()
+  getIgnoreFile: import_mini26.z.object({}),
+  putIgnoreFile: import_mini26.z.object({
+    content: import_mini26.z.string()
   }),
-  deleteIgnoreFile: import_mini24.z.object({})
+  deleteIgnoreFile: import_mini26.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -8011,7 +8004,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 var import_node_path71 = require("path");
-var import_mini25 = require("zod/mini");
+var import_mini27 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
@@ -8099,11 +8092,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini25.z.object({}),
-  putMcpFile: import_mini25.z.object({
-    content: import_mini25.z.string()
+  getMcpFile: import_mini27.z.object({}),
+  putMcpFile: import_mini27.z.object({
+    content: import_mini27.z.string()
   }),
-  deleteMcpFile: import_mini25.z.object({})
+  deleteMcpFile: import_mini27.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -8137,7 +8130,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path72 = require("path");
-var import_mini26 = require("zod/mini");
+var import_mini28 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -8256,17 +8249,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini26.z.object({}),
-  getRule: import_mini26.z.object({
-    relativePathFromCwd: import_mini26.z.string()
+  listRules: import_mini28.z.object({}),
+  getRule: import_mini28.z.object({
+    relativePathFromCwd: import_mini28.z.string()
   }),
-  putRule: import_mini26.z.object({
-    relativePathFromCwd: import_mini26.z.string(),
+  putRule: import_mini28.z.object({
+    relativePathFromCwd: import_mini28.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini26.z.string()
+    body: import_mini28.z.string()
   }),
-  deleteRule: import_mini26.z.object({
-    relativePathFromCwd: import_mini26.z.string()
+  deleteRule: import_mini28.z.object({
+    relativePathFromCwd: import_mini28.z.string()
   })
 };
 var ruleTools = {
@@ -8315,7 +8308,7 @@ var ruleTools = {
 
 // src/mcp/subagents.ts
 var import_node_path73 = require("path");
-var import_mini27 = require("zod/mini");
+var import_mini29 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -8439,17 +8432,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini27.z.object({}),
-  getSubagent: import_mini27.z.object({
-    relativePathFromCwd: import_mini27.z.string()
+  listSubagents: import_mini29.z.object({}),
+  getSubagent: import_mini29.z.object({
+    relativePathFromCwd: import_mini29.z.string()
   }),
-  putSubagent: import_mini27.z.object({
-    relativePathFromCwd: import_mini27.z.string(),
+  putSubagent: import_mini29.z.object({
+    relativePathFromCwd: import_mini29.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini27.z.string()
+    body: import_mini29.z.string()
   }),
-  deleteSubagent: import_mini27.z.object({
-    relativePathFromCwd: import_mini27.z.string()
+  deleteSubagent: import_mini29.z.object({
+    relativePathFromCwd: import_mini29.z.string()
   })
 };
 var subagentTools = {
@@ -8529,7 +8522,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.23.0";
+var getVersion = () => "3.23.3";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();

package/dist/index.js

@@ -558,7 +558,6 @@ var AiFile = class {
     relativeDirPath,
     relativeFilePath,
     fileContent,
-    validate = true,
     global = false
   }) {
     this.baseDir = baseDir;
@@ -566,12 +565,6 @@ var AiFile = class {
     this.relativeFilePath = relativeFilePath;
     this.fileContent = fileContent;
     this.global = global;
-    if (validate) {
-      const result = this.validate();
-      if (!result.success) {
-        throw result.error;
-      }
-    }
   }
   static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
@@ -2688,7 +2681,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/features/mcp/mcp-processor.ts
-import { z as z13 } from "zod/mini";
+import { z as z15 } from "zod/mini";
 
 // src/features/mcp/amazonqcli-mcp.ts
 import { join as join26 } from "path";
@@ -2696,9 +2689,11 @@ import { join as join26 } from "path";
 // src/features/mcp/rulesync-mcp.ts
 import { join as join25 } from "path";
 import { omit } from "es-toolkit/object";
+import { z as z13 } from "zod/mini";
+
+// src/types/mcp.ts
 import { z as z12 } from "zod/mini";
-var McpTransportTypeSchema = z12.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = z12.object({
+var McpServerSchema = z12.object({
   type: z12.optional(z12.enum(["stdio", "sse", "http"])),
   command: z12.optional(z12.union([z12.string(), z12.array(z12.string())])),
   args: z12.optional(z12.array(z12.string())),
@@ -2710,27 +2705,30 @@ var McpServerBaseSchema = z12.object({
   timeout: z12.optional(z12.number()),
   trust: z12.optional(z12.boolean()),
   cwd: z12.optional(z12.string()),
-  transport: z12.optional(McpTransportTypeSchema),
+  transport: z12.optional(z12.enum(["stdio", "sse", "http"])),
   alwaysAllow: z12.optional(z12.array(z12.string())),
   tools: z12.optional(z12.array(z12.string())),
   kiroAutoApprove: z12.optional(z12.array(z12.string())),
   kiroAutoBlock: z12.optional(z12.array(z12.string())),
   headers: z12.optional(z12.record(z12.string(), z12.string()))
 });
-var RulesyncMcpServersSchema = z12.union([
-  z12.extend(McpServerBaseSchema, {
-    targets: z12.optional(RulesyncTargetsSchema),
-    description: z12.optional(z12.string()),
-    exposed: z12.optional(z12.literal(false))
+var McpServersSchema = z12.record(z12.string(), McpServerSchema);
+
+// src/features/mcp/rulesync-mcp.ts
+var RulesyncMcpServerSchema = z13.union([
+  z13.extend(McpServerSchema, {
+    targets: z13.optional(RulesyncTargetsSchema),
+    description: z13.optional(z13.string()),
+    exposed: z13.optional(z13.literal(false))
   }),
-  z12.extend(McpServerBaseSchema, {
-    targets: z12.optional(RulesyncTargetsSchema),
-    description: z12.undefined(),
-    exposed: z12.literal(true)
+  z13.extend(McpServerSchema, {
+    targets: z13.optional(RulesyncTargetsSchema),
+    description: z13.undefined(),
+    exposed: z13.literal(true)
   })
 ]);
-var RulesyncMcpConfigSchema = z12.object({
-  mcpServers: z12.record(z12.string(), RulesyncMcpServersSchema)
+var RulesyncMcpConfigSchema = z13.object({
+  mcpServers: z13.record(z13.string(), RulesyncMcpServerSchema)
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
@@ -2759,6 +2757,10 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
     };
   }
   validate() {
+    const result = RulesyncMcpConfigSchema.safeParse(this.json);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
     return { success: true, error: null };
   }
   static async fromFile({
@@ -2808,46 +2810,25 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
       modularMcp
     });
   }
-  getExposedServers() {
-    if (!this.json || typeof this.json !== "object") {
-      return {};
-    }
-    if (!this.json.mcpServers || typeof this.json.mcpServers !== "object") {
-      return {};
-    }
+  getExposedMcpServers() {
     return Object.fromEntries(
-      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => serverConfig.exposed === true).map(([serverName, serverConfig]) => [
+      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => !this.modularMcp || serverConfig.exposed).map(([serverName, serverConfig]) => [
         serverName,
-        omit(serverConfig, ["description", "exposed"])
+        omit(serverConfig, ["targets", "description", "exposed"])
       ])
     );
   }
-  getJson({ modularMcp = false } = {}) {
-    if (!this.json || typeof this.json !== "object") {
-      return this.json;
-    }
-    if (!this.json.mcpServers || typeof this.json.mcpServers !== "object") {
-      return this.json;
-    }
-    if (modularMcp) {
-      const mcpServersForModularMcp = Object.fromEntries(
-        Object.entries(this.json.mcpServers).filter(([, serverConfig]) => !serverConfig.exposed).map(([serverName, serverConfig]) => [serverName, omit(serverConfig, ["exposed"])])
-      );
-      return {
-        ...this.json,
-        mcpServers: mcpServersForModularMcp
-      };
-    }
-    const mcpServersWithoutDescription = Object.fromEntries(
-      Object.entries(this.json.mcpServers).map(([serverName, serverConfig]) => [
+  getModularizedMcpServers() {
+    return Object.fromEntries(
+      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => this.modularMcp && !serverConfig.exposed).map(([serverName, serverConfig]) => [
         serverName,
-        omit(serverConfig, ["description", "exposed"])
+        // description is required for modular-mcp servers
+        omit(serverConfig, ["targets", "exposed"])
       ])
     );
-    return {
-      ...this.json,
-      mcpServers: mcpServersWithoutDescription
-    };
+  }
+  getJson() {
+    return this.json;
   }
 };
 
@@ -2951,6 +2932,14 @@ import { join as join28 } from "path";
 
 // src/features/mcp/modular-mcp.ts
 import { join as join27 } from "path";
+import { z as z14 } from "zod/mini";
+var ModularMcpServerSchema = z14.extend(McpServerSchema, {
+  description: z14.string()
+  // Required for modular-mcp
+});
+var ModularMcpConfigSchema = z14.object({
+  mcpServers: z14.record(z14.string(), ModularMcpServerSchema)
+});
 var ModularMcp = class _ModularMcp extends AiFile {
   json;
   constructor(params) {
@@ -3022,7 +3011,7 @@ var ModularMcp = class _ModularMcp extends AiFile {
       global && relativeDirPath ? { global: true, relativeDirPath } : { global: false, relativeDirPath: void 0 }
     );
     const modularMcpJson = {
-      mcpServers: rulesyncMcp.getJson({ modularMcp: true }).mcpServers
+      mcpServers: rulesyncMcp.getModularizedMcpServers()
     };
     return new _ModularMcp({
       baseDir,
@@ -3033,6 +3022,10 @@ var ModularMcp = class _ModularMcp extends AiFile {
     });
   }
   validate() {
+    const result = ModularMcpConfigSchema.safeParse(this.json);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
     return { success: true, error: null };
   }
 };
@@ -3101,9 +3094,9 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
           relativeDirPath: this.getSettablePaths({ global: true }).relativeDirPath
         }) : ModularMcp.getMcpServers({ baseDir, global: false }),
         // Merge exposed servers
-        ...rulesyncMcp.getExposedServers()
+        ...rulesyncMcp.getExposedMcpServers()
       }
-    } : { ...json, mcpServers: rulesyncMcp.getJson({ modularMcp: false }).mcpServers };
+    } : { ...json, mcpServers: rulesyncMcp.getExposedMcpServers() };
     return new _ClaudecodeMcp({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
@@ -3239,7 +3232,7 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
       smolToml.stringify({})
     );
     const configToml = smolToml.parse(configTomlFileContent);
-    const mcpServers = rulesyncMcp.getJson({ modularMcp: false }).mcpServers;
+    const mcpServers = rulesyncMcp.getJson().mcpServers;
     const filteredMcpServers = this.removeEmptyEntries(mcpServers);
     configToml["mcp_servers"] = filteredMcpServers;
     return new _CodexcliMcp({
@@ -3371,7 +3364,7 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
     rulesyncMcp,
     validate = true
   }) {
-    const json = rulesyncMcp.getJson({ modularMcp: false });
+    const json = rulesyncMcp.getJson();
     const cursorConfig = {
       mcpServers: json.mcpServers || {}
     };
@@ -3453,7 +3446,7 @@ var GeminiCliMcp = class _GeminiCliMcp extends ToolMcp {
       JSON.stringify({ mcpServers: {} }, null, 2)
     );
     const json = JSON.parse(fileContent);
-    const newJson = { ...json, mcpServers: rulesyncMcp.getJson({ modularMcp: false }).mcpServers };
+    const newJson = { ...json, mcpServers: rulesyncMcp.getJson().mcpServers };
     return new _GeminiCliMcp({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
@@ -3540,7 +3533,7 @@ var mcpProcessorToolTargets = [
   "geminicli",
   "roo"
 ];
-var McpProcessorToolTargetSchema = z13.enum(
+var McpProcessorToolTargetSchema = z15.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   mcpProcessorToolTargets.concat("codexcli")
 );
@@ -3779,14 +3772,14 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 import { basename as basename17, join as join64 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
-import { z as z22 } from "zod/mini";
+import { z as z24 } from "zod/mini";
 
 // src/features/subagents/agentsmd-subagent.ts
 import { join as join36 } from "path";
 
 // src/features/subagents/simulated-subagent.ts
 import { basename as basename12, join as join35 } from "path";
-import { z as z14 } from "zod/mini";
+import { z as z16 } from "zod/mini";
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -3821,9 +3814,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z14.object({
-  name: z14.string(),
-  description: z14.string()
+var SimulatedSubagentFrontmatterSchema = z16.object({
+  name: z16.string(),
+  description: z16.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -4057,22 +4050,22 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 import { basename as basename14, join as join44 } from "path";
-import { z as z17 } from "zod/mini";
+import { z as z19 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
 import { join as join43 } from "path";
-import { z as z16 } from "zod/mini";
+import { z as z18 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
 import { basename as basename13, join as join42 } from "path";
-import { z as z15 } from "zod/mini";
-var RulesyncSubagentModelSchema = z15.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = z15.object({
+import { z as z17 } from "zod/mini";
+var RulesyncSubagentModelSchema = z17.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = z17.object({
   targets: RulesyncTargetsSchema,
-  name: z15.string(),
-  description: z15.string(),
-  claudecode: z15.optional(
-    z15.object({
+  name: z17.string(),
+  description: z17.string(),
+  claudecode: z17.optional(
+    z17.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -4146,10 +4139,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z16.object({
-  name: z16.string(),
-  description: z16.string(),
-  model: z16.optional(z16.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = z18.object({
+  name: z18.string(),
+  description: z18.string(),
+  model: z18.optional(z18.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -4293,7 +4286,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "roo"
 ];
 var subagentsProcessorToolTargetsGlobal = ["claudecode"];
-var SubagentsProcessorToolTargetSchema = z17.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = z19.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   global;
@@ -4578,23 +4571,23 @@ import { join as join46 } from "path";
 
 // src/features/rules/rulesync-rule.ts
 import { basename as basename15, join as join45 } from "path";
-import { z as z18 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z18.object({
-  root: z18.optional(z18.optional(z18.boolean())),
-  targets: z18.optional(RulesyncTargetsSchema),
-  description: z18.optional(z18.string()),
-  globs: z18.optional(z18.array(z18.string())),
-  agentsmd: z18.optional(
-    z18.object({
+import { z as z20 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z20.object({
+  root: z20.optional(z20.optional(z20.boolean())),
+  targets: z20.optional(RulesyncTargetsSchema),
+  description: z20.optional(z20.string()),
+  globs: z20.optional(z20.array(z20.string())),
+  agentsmd: z20.optional(
+    z20.object({
       // @example "path/to/subproject"
-      subprojectPath: z18.optional(z18.string())
+      subprojectPath: z20.optional(z20.string())
     })
   ),
-  cursor: z18.optional(
-    z18.object({
-      alwaysApply: z18.optional(z18.boolean()),
-      description: z18.optional(z18.string()),
-      globs: z18.optional(z18.array(z18.string()))
+  cursor: z20.optional(
+    z20.object({
+      alwaysApply: z20.optional(z20.boolean()),
+      description: z20.optional(z20.string()),
+      globs: z20.optional(z20.array(z20.string()))
     })
   )
 });
@@ -5186,9 +5179,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 import { join as join52 } from "path";
-import { z as z19 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z19.object({
-  description: z19.string()
+import { z as z21 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z21.object({
+  description: z21.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -5335,10 +5328,10 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 import { join as join54 } from "path";
-import { z as z20 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z20.object({
-  description: z20.optional(z20.string()),
-  applyTo: z20.optional(z20.string())
+import { z as z22 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z22.object({
+  description: z22.optional(z22.string()),
+  applyTo: z22.optional(z22.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -5505,11 +5498,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 import { basename as basename16, join as join55 } from "path";
-import { z as z21 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z21.object({
-  description: z21.optional(z21.string()),
-  globs: z21.optional(z21.string()),
-  alwaysApply: z21.optional(z21.boolean())
+import { z as z23 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z23.object({
+  description: z23.optional(z23.string()),
+  globs: z23.optional(z23.string()),
+  alwaysApply: z23.optional(z23.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -6225,7 +6218,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z22.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z24.enum(rulesProcessorToolTargets);
 var rulesProcessorToolTargetsGlobal = [
   "claudecode",
   "codexcli",
@@ -7721,7 +7714,7 @@ import { FastMCP } from "fastmcp";
 
 // src/mcp/commands.ts
 import { basename as basename18, join as join67 } from "path";
-import { z as z23 } from "zod/mini";
+import { z as z25 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -7840,17 +7833,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z23.object({}),
-  getCommand: z23.object({
-    relativePathFromCwd: z23.string()
+  listCommands: z25.object({}),
+  getCommand: z25.object({
+    relativePathFromCwd: z25.string()
   }),
-  putCommand: z23.object({
-    relativePathFromCwd: z23.string(),
+  putCommand: z25.object({
+    relativePathFromCwd: z25.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z23.string()
+    body: z25.string()
   }),
-  deleteCommand: z23.object({
-    relativePathFromCwd: z23.string()
+  deleteCommand: z25.object({
+    relativePathFromCwd: z25.string()
   })
 };
 var commandTools = {
@@ -7899,7 +7892,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 import { join as join68 } from "path";
-import { z as z24 } from "zod/mini";
+import { z as z26 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
@@ -7950,11 +7943,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z24.object({}),
-  putIgnoreFile: z24.object({
-    content: z24.string()
+  getIgnoreFile: z26.object({}),
+  putIgnoreFile: z26.object({
+    content: z26.string()
   }),
-  deleteIgnoreFile: z24.object({})
+  deleteIgnoreFile: z26.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -7988,7 +7981,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 import { join as join69 } from "path";
-import { z as z25 } from "zod/mini";
+import { z as z27 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
@@ -8076,11 +8069,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z25.object({}),
-  putMcpFile: z25.object({
-    content: z25.string()
+  getMcpFile: z27.object({}),
+  putMcpFile: z27.object({
+    content: z27.string()
   }),
-  deleteMcpFile: z25.object({})
+  deleteMcpFile: z27.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -8114,7 +8107,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 import { basename as basename19, join as join70 } from "path";
-import { z as z26 } from "zod/mini";
+import { z as z28 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -8233,17 +8226,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z26.object({}),
-  getRule: z26.object({
-    relativePathFromCwd: z26.string()
+  listRules: z28.object({}),
+  getRule: z28.object({
+    relativePathFromCwd: z28.string()
   }),
-  putRule: z26.object({
-    relativePathFromCwd: z26.string(),
+  putRule: z28.object({
+    relativePathFromCwd: z28.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z26.string()
+    body: z28.string()
   }),
-  deleteRule: z26.object({
-    relativePathFromCwd: z26.string()
+  deleteRule: z28.object({
+    relativePathFromCwd: z28.string()
   })
 };
 var ruleTools = {
@@ -8292,7 +8285,7 @@ var ruleTools = {
 
 // src/mcp/subagents.ts
 import { basename as basename20, join as join71 } from "path";
-import { z as z27 } from "zod/mini";
+import { z as z29 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -8416,17 +8409,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z27.object({}),
-  getSubagent: z27.object({
-    relativePathFromCwd: z27.string()
+  listSubagents: z29.object({}),
+  getSubagent: z29.object({
+    relativePathFromCwd: z29.string()
   }),
-  putSubagent: z27.object({
-    relativePathFromCwd: z27.string(),
+  putSubagent: z29.object({
+    relativePathFromCwd: z29.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z27.string()
+    body: z29.string()
   }),
-  deleteSubagent: z27.object({
-    relativePathFromCwd: z27.string()
+  deleteSubagent: z29.object({
+    relativePathFromCwd: z29.string()
   })
 };
 var subagentTools = {
@@ -8506,7 +8499,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.23.0";
+var getVersion = () => "3.23.3";
 var main = async () => {
   const program = new Command();
   const version = getVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "3.23.0",
+  "version": "3.23.3",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",
@@ -36,7 +36,6 @@
     "pre-commit": "pnpm exec lint-staged"
   },
   "dependencies": {
-    "@kimuson/modular-mcp": "0.0.5",
     "@modelcontextprotocol/sdk": "1.21.2",
     "chokidar": "4.0.3",
     "commander": "14.0.2",