rulesync 4.1.0 → 4.1.1

package/dist/index.cjs

@@ -4729,7 +4729,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path85 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini36 = require("zod/mini");
+var import_mini37 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -6478,39 +6478,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
   }
 };
 
-// src/features/subagents/copilot-subagent.ts
-var import_node_path57 = require("path");
-var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
-  static getSettablePaths() {
-    return {
-      relativeDirPath: (0, import_node_path57.join)(".github", "subagents")
-    };
-  }
-  static async fromFile(params) {
-    const baseParams = await this.fromFileDefault(params);
-    return new _CopilotSubagent(baseParams);
-  }
-  static fromRulesyncSubagent(params) {
-    const baseParams = this.fromRulesyncSubagentDefault(params);
-    return new _CopilotSubagent(baseParams);
-  }
-  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
-    return this.isTargetedByRulesyncSubagentDefault({
-      rulesyncSubagent,
-      toolTarget: "copilot"
-    });
-  }
-  static forDeletion(params) {
-    return new _CopilotSubagent(this.forDeletionDefault(params));
-  }
-};
-
 // src/features/subagents/cursor-subagent.ts
-var import_node_path58 = require("path");
+var import_node_path57 = require("path");
 var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path58.join)(".cursor", "subagents")
+      relativeDirPath: (0, import_node_path57.join)(".cursor", "subagents")
     };
   }
   static async fromFile(params) {
@@ -6533,11 +6506,11 @@ var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/geminicli-subagent.ts
-var import_node_path59 = require("path");
+var import_node_path58 = require("path");
 var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path59.join)(".gemini", "subagents")
+      relativeDirPath: (0, import_node_path58.join)(".gemini", "subagents")
     };
   }
   static async fromFile(params) {
@@ -6560,11 +6533,11 @@ var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/roo-subagent.ts
-var import_node_path60 = require("path");
+var import_node_path59 = require("path");
 var RooSubagent = class _RooSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path60.join)(".roo", "subagents")
+      relativeDirPath: (0, import_node_path59.join)(".roo", "subagents")
     };
   }
   static async fromFile(params) {
@@ -6588,14 +6561,14 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path63 = require("path");
-var import_mini29 = require("zod/mini");
+var import_mini30 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
-var import_node_path62 = require("path");
+var import_node_path61 = require("path");
 var import_mini28 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
-var import_node_path61 = require("path");
+var import_node_path60 = require("path");
 var import_mini27 = require("zod/mini");
 var RulesyncSubagentFrontmatterSchema = import_mini27.z.looseObject({
   targets: RulesyncTargetsSchema,
@@ -6610,7 +6583,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path61.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path60.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -6643,7 +6616,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path61.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path60.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -6652,14 +6625,14 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
     relativeFilePath
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path61.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
+      (0, import_node_path60.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
     );
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
     }
-    const filename = (0, import_node_path61.basename)(relativeFilePath);
+    const filename = (0, import_node_path60.basename)(relativeFilePath);
     return new _RulesyncSubagent({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().relativeDirPath,
@@ -6687,7 +6660,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path62.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path61.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -6699,7 +6672,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: (0, import_node_path62.join)(".claude", "agents")
+      relativeDirPath: (0, import_node_path61.join)(".claude", "agents")
     };
   }
   getFrontmatter() {
@@ -6773,7 +6746,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path62.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path61.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -6791,7 +6764,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path62.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path61.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -6825,6 +6798,172 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   }
 };
 
+// src/features/subagents/copilot-subagent.ts
+var import_node_path62 = require("path");
+var import_mini29 = require("zod/mini");
+var REQUIRED_TOOL = "agent/runSubagent";
+var CopilotSubagentFrontmatterSchema = import_mini29.z.looseObject({
+  name: import_mini29.z.string(),
+  description: import_mini29.z.string(),
+  tools: import_mini29.z.optional(import_mini29.z.union([import_mini29.z.string(), import_mini29.z.array(import_mini29.z.string())]))
+});
+var normalizeTools = (tools) => {
+  if (!tools) {
+    return [];
+  }
+  return Array.isArray(tools) ? tools : [tools];
+};
+var ensureRequiredTool = (tools) => {
+  const mergedTools = /* @__PURE__ */ new Set([REQUIRED_TOOL, ...tools]);
+  return Array.from(mergedTools);
+};
+var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = CopilotSubagentFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${(0, import_node_path62.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    super({
+      ...rest
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: (0, import_node_path62.join)(".github", "agents")
+    };
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  getBody() {
+    return this.body;
+  }
+  toRulesyncSubagent() {
+    const { name, description, tools, ...rest } = this.frontmatter;
+    const rulesyncFrontmatter = {
+      targets: ["copilot"],
+      name,
+      description,
+      copilot: {
+        ...tools && { tools },
+        ...rest
+      }
+    };
+    return new RulesyncSubagent({
+      baseDir: ".",
+      // RulesyncCommand baseDir is always the project root directory
+      frontmatter: rulesyncFrontmatter,
+      body: this.body,
+      relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+      relativeFilePath: this.getRelativeFilePath(),
+      validate: true
+    });
+  }
+  static fromRulesyncSubagent({
+    baseDir = process.cwd(),
+    rulesyncSubagent,
+    validate = true,
+    global = false
+  }) {
+    const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+    const copilotSection = rulesyncFrontmatter.copilot ?? {};
+    const toolsField = copilotSection.tools;
+    const userTools = normalizeTools(
+      Array.isArray(toolsField) || typeof toolsField === "string" ? toolsField : void 0
+    );
+    const mergedTools = ensureRequiredTool(userTools);
+    const copilotFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description,
+      ...copilotSection,
+      ...mergedTools.length > 0 && { tools: mergedTools }
+    };
+    const body = rulesyncSubagent.getBody();
+    const fileContent = stringifyFrontmatter(body, copilotFrontmatter);
+    const paths = this.getSettablePaths({ global });
+    return new _CopilotSubagent({
+      baseDir,
+      frontmatter: copilotFrontmatter,
+      body,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+      fileContent,
+      validate,
+      global
+    });
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = CopilotSubagentFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${(0, import_node_path62.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+        )
+      };
+    }
+  }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "copilot"
+    });
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    relativeFilePath,
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path62.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = CopilotSubagentFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+    }
+    return new _CopilotSubagent({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath,
+      frontmatter: result.data,
+      body: content.trim(),
+      fileContent,
+      validate,
+      global
+    });
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _CopilotSubagent({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      frontmatter: { name: "", description: "" },
+      body: "",
+      fileContent: "",
+      validate: false
+    });
+  }
+};
+
 // src/features/subagents/subagents-processor.ts
 var subagentsProcessorToolTargetTuple = [
   "agentsmd",
@@ -6835,7 +6974,7 @@ var subagentsProcessorToolTargetTuple = [
   "geminicli",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini29.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini30.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -6849,7 +6988,10 @@ var toolSubagentFactories = /* @__PURE__ */ new Map([
     "codexcli",
     { class: CodexCliSubagent, meta: { supportsSimulated: true, supportsGlobal: false } }
   ],
-  ["copilot", { class: CopilotSubagent, meta: { supportsSimulated: true, supportsGlobal: false } }],
+  [
+    "copilot",
+    { class: CopilotSubagent, meta: { supportsSimulated: false, supportsGlobal: false } }
+  ],
   ["cursor", { class: CursorSubagent, meta: { supportsSimulated: true, supportsGlobal: false } }],
   [
     "geminicli",
@@ -7040,41 +7182,41 @@ var import_node_path65 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path64 = require("path");
-var import_mini30 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini30.z.object({
-  root: import_mini30.z.optional(import_mini30.z.optional(import_mini30.z.boolean())),
-  targets: import_mini30.z.optional(RulesyncTargetsSchema),
-  description: import_mini30.z.optional(import_mini30.z.string()),
-  globs: import_mini30.z.optional(import_mini30.z.array(import_mini30.z.string())),
-  agentsmd: import_mini30.z.optional(
-    import_mini30.z.object({
+var import_mini31 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini31.z.object({
+  root: import_mini31.z.optional(import_mini31.z.optional(import_mini31.z.boolean())),
+  targets: import_mini31.z.optional(RulesyncTargetsSchema),
+  description: import_mini31.z.optional(import_mini31.z.string()),
+  globs: import_mini31.z.optional(import_mini31.z.array(import_mini31.z.string())),
+  agentsmd: import_mini31.z.optional(
+    import_mini31.z.object({
       // @example "path/to/subproject"
-      subprojectPath: import_mini30.z.optional(import_mini30.z.string())
+      subprojectPath: import_mini31.z.optional(import_mini31.z.string())
     })
   ),
-  claudecode: import_mini30.z.optional(
-    import_mini30.z.object({
+  claudecode: import_mini31.z.optional(
+    import_mini31.z.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example "src/**/*.ts, tests/**/*.test.ts"
-      paths: import_mini30.z.optional(import_mini30.z.string())
+      paths: import_mini31.z.optional(import_mini31.z.string())
     })
   ),
-  cursor: import_mini30.z.optional(
-    import_mini30.z.object({
-      alwaysApply: import_mini30.z.optional(import_mini30.z.boolean()),
-      description: import_mini30.z.optional(import_mini30.z.string()),
-      globs: import_mini30.z.optional(import_mini30.z.array(import_mini30.z.string()))
+  cursor: import_mini31.z.optional(
+    import_mini31.z.object({
+      alwaysApply: import_mini31.z.optional(import_mini31.z.boolean()),
+      description: import_mini31.z.optional(import_mini31.z.string()),
+      globs: import_mini31.z.optional(import_mini31.z.array(import_mini31.z.string()))
     })
   ),
-  copilot: import_mini30.z.optional(
-    import_mini30.z.object({
-      excludeAgent: import_mini30.z.optional(import_mini30.z.union([import_mini30.z.literal("code-review"), import_mini30.z.literal("coding-agent")]))
+  copilot: import_mini31.z.optional(
+    import_mini31.z.object({
+      excludeAgent: import_mini31.z.optional(import_mini31.z.union([import_mini31.z.literal("code-review"), import_mini31.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini30.z.optional(
-    import_mini30.z.looseObject({
-      trigger: import_mini30.z.optional(import_mini30.z.string()),
-      globs: import_mini30.z.optional(import_mini30.z.array(import_mini30.z.string()))
+  antigravity: import_mini31.z.optional(
+    import_mini31.z.looseObject({
+      trigger: import_mini31.z.optional(import_mini31.z.string()),
+      globs: import_mini31.z.optional(import_mini31.z.array(import_mini31.z.string()))
     })
   )
 });
@@ -7482,20 +7624,20 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path68 = require("path");
-var import_mini31 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini31.z.looseObject({
-  trigger: import_mini31.z.optional(
-    import_mini31.z.union([
-      import_mini31.z.literal("always_on"),
-      import_mini31.z.literal("glob"),
-      import_mini31.z.literal("manual"),
-      import_mini31.z.literal("model_decision"),
-      import_mini31.z.string()
+var import_mini32 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini32.z.looseObject({
+  trigger: import_mini32.z.optional(
+    import_mini32.z.union([
+      import_mini32.z.literal("always_on"),
+      import_mini32.z.literal("glob"),
+      import_mini32.z.literal("manual"),
+      import_mini32.z.literal("model_decision"),
+      import_mini32.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini31.z.optional(import_mini31.z.string()),
-  description: import_mini31.z.optional(import_mini31.z.string())
+  globs: import_mini32.z.optional(import_mini32.z.string()),
+  description: import_mini32.z.optional(import_mini32.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -8073,9 +8215,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path72 = require("path");
-var import_mini32 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini32.z.object({
-  paths: import_mini32.z.optional(import_mini32.z.string())
+var import_mini33 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini33.z.object({
+  paths: import_mini33.z.optional(import_mini33.z.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -8283,9 +8425,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path73 = require("path");
-var import_mini33 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini33.z.object({
-  description: import_mini33.z.string()
+var import_mini34 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini34.z.object({
+  description: import_mini34.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -8462,11 +8604,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path75 = require("path");
-var import_mini34 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini34.z.object({
-  description: import_mini34.z.optional(import_mini34.z.string()),
-  applyTo: import_mini34.z.optional(import_mini34.z.string()),
-  excludeAgent: import_mini34.z.optional(import_mini34.z.union([import_mini34.z.literal("code-review"), import_mini34.z.literal("coding-agent")]))
+var import_mini35 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini35.z.object({
+  description: import_mini35.z.optional(import_mini35.z.string()),
+  applyTo: import_mini35.z.optional(import_mini35.z.string()),
+  excludeAgent: import_mini35.z.optional(import_mini35.z.union([import_mini35.z.literal("code-review"), import_mini35.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -8650,11 +8792,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path76 = require("path");
-var import_mini35 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini35.z.object({
-  description: import_mini35.z.optional(import_mini35.z.string()),
-  globs: import_mini35.z.optional(import_mini35.z.string()),
-  alwaysApply: import_mini35.z.optional(import_mini35.z.boolean())
+var import_mini36 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini36.z.object({
+  description: import_mini36.z.optional(import_mini36.z.string()),
+  globs: import_mini36.z.optional(import_mini36.z.string()),
+  alwaysApply: import_mini36.z.optional(import_mini36.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -9504,7 +9646,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini36.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini37.z.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -9592,10 +9734,7 @@ var toolRuleFactories = /* @__PURE__ */ new Map([
       meta: {
         extension: "md",
         supportsGlobal: false,
-        ruleDiscoveryMode: "auto",
-        additionalConventions: {
-          subagents: { subagentClass: CopilotSubagent }
-        }
+        ruleDiscoveryMode: "auto"
       }
     }
   ],
@@ -10376,7 +10515,7 @@ var RULESYNC_IGNORE_ENTRIES = [
   "**/.github/copilot-instructions.md",
   "**/.github/instructions/",
   "**/.github/prompts/",
-  "**/.github/subagents/",
+  "**/.github/agents/",
   "**/.github/skills/",
   "**/.vscode/mcp.json",
   // Junie
@@ -10865,7 +11004,7 @@ var import_fastmcp = require("fastmcp");
 
 // src/mcp/commands.ts
 var import_node_path88 = require("path");
-var import_mini37 = require("zod/mini");
+var import_mini38 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -10984,17 +11123,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini37.z.object({}),
-  getCommand: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string()
+  listCommands: import_mini38.z.object({}),
+  getCommand: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string()
   }),
-  putCommand: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string(),
+  putCommand: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini37.z.string()
+    body: import_mini38.z.string()
   }),
-  deleteCommand: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string()
+  deleteCommand: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string()
   })
 };
 var commandTools = {
@@ -11043,7 +11182,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 var import_node_path89 = require("path");
-var import_mini38 = require("zod/mini");
+var import_mini39 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path89.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -11100,11 +11239,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini38.z.object({}),
-  putIgnoreFile: import_mini38.z.object({
-    content: import_mini38.z.string()
+  getIgnoreFile: import_mini39.z.object({}),
+  putIgnoreFile: import_mini39.z.object({
+    content: import_mini39.z.string()
   }),
-  deleteIgnoreFile: import_mini38.z.object({})
+  deleteIgnoreFile: import_mini39.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -11138,7 +11277,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 var import_node_path90 = require("path");
-var import_mini39 = require("zod/mini");
+var import_mini40 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -11228,11 +11367,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini39.z.object({}),
-  putMcpFile: import_mini39.z.object({
-    content: import_mini39.z.string()
+  getMcpFile: import_mini40.z.object({}),
+  putMcpFile: import_mini40.z.object({
+    content: import_mini40.z.string()
   }),
-  deleteMcpFile: import_mini39.z.object({})
+  deleteMcpFile: import_mini40.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -11266,7 +11405,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path91 = require("path");
-var import_mini40 = require("zod/mini");
+var import_mini41 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -11385,17 +11524,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini40.z.object({}),
-  getRule: import_mini40.z.object({
-    relativePathFromCwd: import_mini40.z.string()
+  listRules: import_mini41.z.object({}),
+  getRule: import_mini41.z.object({
+    relativePathFromCwd: import_mini41.z.string()
   }),
-  putRule: import_mini40.z.object({
-    relativePathFromCwd: import_mini40.z.string(),
+  putRule: import_mini41.z.object({
+    relativePathFromCwd: import_mini41.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini40.z.string()
+    body: import_mini41.z.string()
   }),
-  deleteRule: import_mini40.z.object({
-    relativePathFromCwd: import_mini40.z.string()
+  deleteRule: import_mini41.z.object({
+    relativePathFromCwd: import_mini41.z.string()
   })
 };
 var ruleTools = {
@@ -11444,7 +11583,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path92 = require("path");
-var import_mini41 = require("zod/mini");
+var import_mini42 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -11612,23 +11751,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini41.z.object({
-  name: import_mini41.z.string(),
-  body: import_mini41.z.string()
+var McpSkillFileSchema = import_mini42.z.object({
+  name: import_mini42.z.string(),
+  body: import_mini42.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini41.z.object({}),
-  getSkill: import_mini41.z.object({
-    relativeDirPathFromCwd: import_mini41.z.string()
+  listSkills: import_mini42.z.object({}),
+  getSkill: import_mini42.z.object({
+    relativeDirPathFromCwd: import_mini42.z.string()
   }),
-  putSkill: import_mini41.z.object({
-    relativeDirPathFromCwd: import_mini41.z.string(),
+  putSkill: import_mini42.z.object({
+    relativeDirPathFromCwd: import_mini42.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini41.z.string(),
-    otherFiles: import_mini41.z.optional(import_mini41.z.array(McpSkillFileSchema))
+    body: import_mini42.z.string(),
+    otherFiles: import_mini42.z.optional(import_mini42.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini41.z.object({
-    relativeDirPathFromCwd: import_mini41.z.string()
+  deleteSkill: import_mini42.z.object({
+    relativeDirPathFromCwd: import_mini42.z.string()
   })
 };
 var skillTools = {
@@ -11678,7 +11817,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path93 = require("path");
-var import_mini42 = require("zod/mini");
+var import_mini43 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -11802,17 +11941,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini42.z.object({}),
-  getSubagent: import_mini42.z.object({
-    relativePathFromCwd: import_mini42.z.string()
+  listSubagents: import_mini43.z.object({}),
+  getSubagent: import_mini43.z.object({
+    relativePathFromCwd: import_mini43.z.string()
   }),
-  putSubagent: import_mini42.z.object({
-    relativePathFromCwd: import_mini42.z.string(),
+  putSubagent: import_mini43.z.object({
+    relativePathFromCwd: import_mini43.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini42.z.string()
+    body: import_mini43.z.string()
   }),
-  deleteSubagent: import_mini42.z.object({
-    relativePathFromCwd: import_mini42.z.string()
+  deleteSubagent: import_mini43.z.object({
+    relativePathFromCwd: import_mini43.z.string()
   })
 };
 var subagentTools = {
@@ -11896,7 +12035,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "4.1.0";
+var getVersion = () => "4.1.1";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();