rulesync 3.33.0 → 3.34.0

package/dist/index.cjs

@@ -102,7 +102,7 @@ var Logger = class {
 var logger = new Logger();
 
 // src/cli/commands/generate.ts
-var import_es_toolkit2 = require("es-toolkit");
+var import_es_toolkit3 = require("es-toolkit");
 
 // src/config/config-resolver.ts
 var import_node_path2 = require("path");
@@ -113,6 +113,7 @@ var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = require("path");
+var import_es_toolkit = require("es-toolkit");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises.stat)(dirPath);
@@ -240,6 +241,13 @@ function validateBaseDir(baseDir) {
   }
   checkPathTraversal({ relativePath: baseDir, intendedRootDir: process.cwd() });
 }
+function toKebabCaseFilename(filename) {
+  const lastDotIndex = filename.lastIndexOf(".");
+  const extension = lastDotIndex > 0 ? filename.slice(lastDotIndex) : "";
+  const nameWithoutExt = lastDotIndex > 0 ? filename.slice(0, lastDotIndex) : filename;
+  const kebabName = (0, import_es_toolkit.kebabCase)(nameWithoutExt);
+  return kebabName + extension;
+}
 
 // src/config/config.ts
 var import_mini3 = require("zod/mini");
@@ -2347,7 +2355,7 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
 
 // src/features/ignore/claudecode-ignore.ts
 var import_node_path20 = require("path");
-var import_es_toolkit = require("es-toolkit");
+var import_es_toolkit2 = require("es-toolkit");
 var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
   constructor(params) {
     super(params);
@@ -2397,11 +2405,19 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
     const exists = await fileExists(filePath);
     const existingFileContent = exists ? await readFileContent(filePath) : "{}";
     const existingJsonValue = JSON.parse(existingFileContent);
+    const existingDenies = existingJsonValue.permissions?.deny ?? [];
+    const preservedDenies = existingDenies.filter((deny) => {
+      const isReadPattern = deny.startsWith("Read(") && deny.endsWith(")");
+      if (isReadPattern) {
+        return deniedValues.includes(deny);
+      }
+      return true;
+    });
     const jsonValue = {
       ...existingJsonValue,
       permissions: {
         ...existingJsonValue.permissions,
-        deny: (0, import_es_toolkit.uniq)([...existingJsonValue.permissions?.deny ?? [], ...deniedValues].toSorted())
+        deny: (0, import_es_toolkit2.uniq)([...preservedDenies, ...deniedValues].toSorted())
       }
     };
     return new _ClaudecodeIgnore({
@@ -4307,7 +4323,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path84 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini33 = require("zod/mini");
+var import_mini34 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -6173,6 +6189,12 @@ var RulesyncRuleFrontmatterSchema = import_mini28.z.object({
     import_mini28.z.object({
       excludeAgent: import_mini28.z.optional(import_mini28.z.union([import_mini28.z.literal("code-review"), import_mini28.z.literal("coding-agent")]))
     })
+  ),
+  antigravity: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      trigger: import_mini28.z.optional(import_mini28.z.string()),
+      globs: import_mini28.z.optional(import_mini28.z.array(import_mini28.z.string()))
+    })
   )
 });
 var RulesyncRule = class _RulesyncRule extends RulesyncFile {
@@ -6542,7 +6564,176 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path67 = require("path");
+var import_mini29 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini29.z.looseObject({
+  trigger: import_mini29.z.optional(
+    import_mini29.z.union([
+      import_mini29.z.literal("always_on"),
+      import_mini29.z.literal("glob"),
+      import_mini29.z.literal("manual"),
+      import_mini29.z.literal("model_decision"),
+      import_mini29.z.string()
+      // accepts any string for forward compatibility
+    ])
+  ),
+  globs: import_mini29.z.optional(import_mini29.z.string()),
+  description: import_mini29.z.optional(import_mini29.z.string())
+});
+function parseGlobsString(globs) {
+  if (!globs) {
+    return [];
+  }
+  if (Array.isArray(globs)) {
+    return globs;
+  }
+  if (globs.trim() === "") {
+    return [];
+  }
+  return globs.split(",").map((g) => g.trim());
+}
+function stringifyGlobs(globs) {
+  if (!globs || globs.length === 0) {
+    return void 0;
+  }
+  return globs.join(",");
+}
+function normalizeStoredAntigravity(stored) {
+  if (!stored) {
+    return void 0;
+  }
+  const { globs, ...rest } = stored;
+  return {
+    ...rest,
+    globs: Array.isArray(globs) ? stringifyGlobs(globs) : globs
+  };
+}
+var globStrategy = {
+  canHandle: (trigger) => trigger === "glob",
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => {
+    const effectiveGlobsArray = normalized?.globs ? parseGlobsString(normalized.globs) : rulesyncFrontmatter.globs ?? [];
+    return {
+      ...normalized,
+      trigger: "glob",
+      globs: stringifyGlobs(effectiveGlobsArray)
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: parseGlobsString(frontmatter.globs),
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var manualStrategy = {
+  canHandle: (trigger) => trigger === "manual",
+  generateFrontmatter: (normalized) => ({
+    ...normalized,
+    trigger: "manual"
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: [],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var alwaysOnStrategy = {
+  canHandle: (trigger) => trigger === "always_on",
+  generateFrontmatter: (normalized) => ({
+    ...normalized,
+    trigger: "always_on"
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var modelDecisionStrategy = {
+  canHandle: (trigger) => trigger === "model_decision",
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => ({
+    ...normalized,
+    trigger: "model_decision",
+    description: rulesyncFrontmatter.description
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: [],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var unknownStrategy = {
+  canHandle: (trigger) => trigger !== void 0,
+  generateFrontmatter: (normalized) => {
+    const trigger = typeof normalized?.trigger === "string" ? normalized.trigger : "manual";
+    return {
+      ...normalized,
+      trigger
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var inferenceStrategy = {
+  canHandle: (trigger) => trigger === void 0,
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => {
+    const effectiveGlobsArray = normalized?.globs ? parseGlobsString(normalized.globs) : rulesyncFrontmatter.globs ?? [];
+    if (effectiveGlobsArray.length > 0 && !effectiveGlobsArray.includes("**/*") && !effectiveGlobsArray.includes("*")) {
+      return {
+        ...normalized,
+        trigger: "glob",
+        globs: stringifyGlobs(effectiveGlobsArray)
+      };
+    }
+    return {
+      ...normalized,
+      trigger: "always_on"
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var STRATEGIES = [
+  globStrategy,
+  manualStrategy,
+  alwaysOnStrategy,
+  modelDecisionStrategy,
+  unknownStrategy,
+  inferenceStrategy
+];
 var AntigravityRule = class _AntigravityRule extends ToolRule {
+  frontmatter;
+  body;
+  /**
+   * Creates an AntigravityRule instance.
+   *
+   * @param params - Rule parameters including frontmatter and body
+   * @param params.frontmatter - Antigravity-specific frontmatter configuration
+   * @param params.body - The markdown body content (without frontmatter)
+   *
+   * Note: Files without frontmatter will default to always_on trigger during fromFile().
+   */
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${(0, import_node_path67.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    super({
+      ...rest,
+      // Ensure fileContent includes frontmatter when constructed directly
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
   static getSettablePaths() {
     return {
       nonRoot: {
@@ -6555,36 +6746,121 @@ var AntigravityRule = class _AntigravityRule extends ToolRule {
     relativeFilePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(
-      (0, import_node_path67.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+    const filePath = (0, import_node_path67.join)(
+      baseDir,
+      this.getSettablePaths().nonRoot.relativeDirPath,
+      relativeFilePath
     );
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body } = parseFrontmatter(fileContent);
+    let parsedFrontmatter;
+    if (validate) {
+      const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+      if (result.success) {
+        parsedFrontmatter = result.data;
+      } else {
+        throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+      }
+    } else {
+      parsedFrontmatter = frontmatter;
+    }
     return new _AntigravityRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
       relativeFilePath,
-      fileContent,
+      body,
+      frontmatter: parsedFrontmatter,
       validate,
       root: false
     });
   }
+  /**
+   * Converts a RulesyncRule to an AntigravityRule.
+   *
+   * Trigger inference:
+   * - If antigravity.trigger is set, it's preserved
+   * - If specific globs are set, infers "glob" trigger
+   * - Otherwise, infers "always_on" trigger
+   */
   static fromRulesyncRule({
     baseDir = process.cwd(),
     rulesyncRule,
     validate = true
   }) {
-    return new _AntigravityRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
+    const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+    const storedAntigravity = rulesyncFrontmatter.antigravity;
+    const normalized = normalizeStoredAntigravity(storedAntigravity);
+    const storedTrigger = storedAntigravity?.trigger;
+    const strategy = STRATEGIES.find((s) => s.canHandle(storedTrigger));
+    if (!strategy) {
+      throw new Error(`No strategy found for trigger: ${storedTrigger}`);
+    }
+    const frontmatter = strategy.generateFrontmatter(normalized, rulesyncFrontmatter);
+    const paths = this.getSettablePaths();
+    const kebabCaseFilename = toKebabCaseFilename(rulesyncRule.getRelativeFilePath());
+    return new _AntigravityRule({
+      baseDir,
+      relativeDirPath: paths.nonRoot.relativeDirPath,
+      relativeFilePath: kebabCaseFilename,
+      frontmatter,
+      body: rulesyncRule.getBody(),
+      validate,
+      root: false
+    });
   }
+  /**
+   * Converts this AntigravityRule to a RulesyncRule.
+   *
+   * The Antigravity configuration is preserved in the RulesyncRule's
+   * frontmatter.antigravity field for round-trip compatibility.
+   *
+   * Note: All Antigravity rules are treated as non-root (root: false),
+   * as they are all placed in the .agent/rules directory.
+   *
+   * @returns RulesyncRule instance with Antigravity config preserved
+   */
   toRulesyncRule() {
-    return this.toRulesyncRuleDefault();
+    const strategy = STRATEGIES.find((s) => s.canHandle(this.frontmatter.trigger));
+    let rulesyncData = {
+      globs: [],
+      description: "",
+      antigravity: this.frontmatter
+    };
+    if (strategy) {
+      rulesyncData = strategy.exportRulesyncData(this.frontmatter);
+    }
+    const antigravityForRulesync = {
+      ...rulesyncData.antigravity,
+      globs: this.frontmatter.globs ? parseGlobsString(this.frontmatter.globs) : void 0
+    };
+    return new RulesyncRule({
+      baseDir: process.cwd(),
+      relativeDirPath: RulesyncRule.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: this.getRelativeFilePath(),
+      frontmatter: {
+        root: false,
+        targets: ["*"],
+        ...rulesyncData,
+        antigravity: antigravityForRulesync
+      },
+      // When converting back, we only want the body content
+      body: this.body
+    });
+  }
+  getBody() {
+    return this.body;
+  }
+  // Helper to access raw file content including frontmatter is `this.fileContent` (from ToolFile)
+  // But we might want `body` only for some operations?
+  // ToolFile.getFileContent() returns the whole string.
+  getFrontmatter() {
+    return this.frontmatter;
   }
   validate() {
+    const result = AntigravityRuleFrontmatterSchema.safeParse(this.frontmatter);
+    if (!result.success) {
+      return { success: false, error: new Error(formatError(result.error)) };
+    }
     return { success: true, error: null };
   }
   static isTargetedByRulesyncRule(rulesyncRule) {
@@ -6818,9 +7094,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path71 = require("path");
-var import_mini29 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini29.z.object({
-  paths: import_mini29.z.optional(import_mini29.z.string())
+var import_mini30 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini30.z.object({
+  paths: import_mini30.z.optional(import_mini30.z.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -7010,9 +7286,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path72 = require("path");
-var import_mini30 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini30.z.object({
-  description: import_mini30.z.string()
+var import_mini31 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini31.z.object({
+  description: import_mini31.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -7159,11 +7435,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path74 = require("path");
-var import_mini31 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini31.z.object({
-  description: import_mini31.z.optional(import_mini31.z.string()),
-  applyTo: import_mini31.z.optional(import_mini31.z.string()),
-  excludeAgent: import_mini31.z.optional(import_mini31.z.union([import_mini31.z.literal("code-review"), import_mini31.z.literal("coding-agent")]))
+var import_mini32 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini32.z.object({
+  description: import_mini32.z.optional(import_mini32.z.string()),
+  applyTo: import_mini32.z.optional(import_mini32.z.string()),
+  excludeAgent: import_mini32.z.optional(import_mini32.z.union([import_mini32.z.literal("code-review"), import_mini32.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -7331,11 +7607,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path75 = require("path");
-var import_mini32 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini32.z.object({
-  description: import_mini32.z.optional(import_mini32.z.string()),
-  globs: import_mini32.z.optional(import_mini32.z.string()),
-  alwaysApply: import_mini32.z.optional(import_mini32.z.boolean())
+var import_mini33 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini33.z.object({
+  description: import_mini33.z.optional(import_mini33.z.string()),
+  globs: import_mini33.z.optional(import_mini33.z.string()),
+  alwaysApply: import_mini33.z.optional(import_mini33.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -8053,7 +8329,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini33.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini34.z.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -8653,7 +8929,7 @@ async function generateRules(config, options) {
   }
   let totalRulesOutputs = 0;
   logger.info("Generating rule files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     RulesProcessor.getToolTargets({ global: config.getGlobal() })
   );
@@ -8695,7 +8971,7 @@ async function generateIgnore(config) {
   }
   let totalIgnoreOutputs = 0;
   logger.info("Generating ignore files...");
-  for (const toolTarget of (0, import_es_toolkit2.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
+  for (const toolTarget of (0, import_es_toolkit3.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
     for (const baseDir of config.getBaseDirs()) {
       try {
         const processor = new IgnoreProcessor({
@@ -8734,7 +9010,7 @@ async function generateMcp(config) {
   if (config.getModularMcp()) {
     logger.info("\u2139\uFE0F  Modular MCP support is experimental.");
   }
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     McpProcessor.getToolTargets({ global: config.getGlobal() })
   );
@@ -8766,7 +9042,7 @@ async function generateCommands(config) {
   }
   let totalCommandOutputs = 0;
   logger.info("Generating command files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     CommandsProcessor.getToolTargets({
       global: config.getGlobal(),
@@ -8800,7 +9076,7 @@ async function generateSubagents(config) {
   }
   let totalSubagentOutputs = 0;
   logger.info("Generating subagent files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     SubagentsProcessor.getToolTargets({
       global: config.getGlobal(),
@@ -8835,7 +9111,7 @@ async function generateSkills(config) {
   let totalSkillOutputs = 0;
   const allSkills = [];
   logger.info("Generating skill files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     SkillsProcessor.getToolTargets({
       global: config.getGlobal(),
@@ -9402,7 +9678,7 @@ var import_fastmcp = require("fastmcp");
 
 // src/mcp/commands.ts
 var import_node_path87 = require("path");
-var import_mini34 = require("zod/mini");
+var import_mini35 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -9521,17 +9797,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini34.z.object({}),
-  getCommand: import_mini34.z.object({
-    relativePathFromCwd: import_mini34.z.string()
+  listCommands: import_mini35.z.object({}),
+  getCommand: import_mini35.z.object({
+    relativePathFromCwd: import_mini35.z.string()
   }),
-  putCommand: import_mini34.z.object({
-    relativePathFromCwd: import_mini34.z.string(),
+  putCommand: import_mini35.z.object({
+    relativePathFromCwd: import_mini35.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini34.z.string()
+    body: import_mini35.z.string()
   }),
-  deleteCommand: import_mini34.z.object({
-    relativePathFromCwd: import_mini34.z.string()
+  deleteCommand: import_mini35.z.object({
+    relativePathFromCwd: import_mini35.z.string()
   })
 };
 var commandTools = {
@@ -9580,7 +9856,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 var import_node_path88 = require("path");
-var import_mini35 = require("zod/mini");
+var import_mini36 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path88.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -9637,11 +9913,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini35.z.object({}),
-  putIgnoreFile: import_mini35.z.object({
-    content: import_mini35.z.string()
+  getIgnoreFile: import_mini36.z.object({}),
+  putIgnoreFile: import_mini36.z.object({
+    content: import_mini36.z.string()
   }),
-  deleteIgnoreFile: import_mini35.z.object({})
+  deleteIgnoreFile: import_mini36.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -9675,7 +9951,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 var import_node_path89 = require("path");
-var import_mini36 = require("zod/mini");
+var import_mini37 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -9765,11 +10041,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini36.z.object({}),
-  putMcpFile: import_mini36.z.object({
-    content: import_mini36.z.string()
+  getMcpFile: import_mini37.z.object({}),
+  putMcpFile: import_mini37.z.object({
+    content: import_mini37.z.string()
   }),
-  deleteMcpFile: import_mini36.z.object({})
+  deleteMcpFile: import_mini37.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -9803,7 +10079,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path90 = require("path");
-var import_mini37 = require("zod/mini");
+var import_mini38 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -9922,17 +10198,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini37.z.object({}),
-  getRule: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string()
+  listRules: import_mini38.z.object({}),
+  getRule: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string()
   }),
-  putRule: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string(),
+  putRule: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini37.z.string()
+    body: import_mini38.z.string()
   }),
-  deleteRule: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string()
+  deleteRule: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string()
   })
 };
 var ruleTools = {
@@ -9981,7 +10257,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path91 = require("path");
-var import_mini38 = require("zod/mini");
+var import_mini39 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -10149,23 +10425,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini38.z.object({
-  name: import_mini38.z.string(),
-  body: import_mini38.z.string()
+var McpSkillFileSchema = import_mini39.z.object({
+  name: import_mini39.z.string(),
+  body: import_mini39.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini38.z.object({}),
-  getSkill: import_mini38.z.object({
-    relativeDirPathFromCwd: import_mini38.z.string()
+  listSkills: import_mini39.z.object({}),
+  getSkill: import_mini39.z.object({
+    relativeDirPathFromCwd: import_mini39.z.string()
   }),
-  putSkill: import_mini38.z.object({
-    relativeDirPathFromCwd: import_mini38.z.string(),
+  putSkill: import_mini39.z.object({
+    relativeDirPathFromCwd: import_mini39.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini38.z.string(),
-    otherFiles: import_mini38.z.optional(import_mini38.z.array(McpSkillFileSchema))
+    body: import_mini39.z.string(),
+    otherFiles: import_mini39.z.optional(import_mini39.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini38.z.object({
-    relativeDirPathFromCwd: import_mini38.z.string()
+  deleteSkill: import_mini39.z.object({
+    relativeDirPathFromCwd: import_mini39.z.string()
   })
 };
 var skillTools = {
@@ -10215,7 +10491,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path92 = require("path");
-var import_mini39 = require("zod/mini");
+var import_mini40 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -10339,17 +10615,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini39.z.object({}),
-  getSubagent: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string()
+  listSubagents: import_mini40.z.object({}),
+  getSubagent: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string()
   }),
-  putSubagent: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string(),
+  putSubagent: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini39.z.string()
+    body: import_mini40.z.string()
   }),
-  deleteSubagent: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string()
+  deleteSubagent: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string()
   })
 };
 var subagentTools = {
@@ -10433,7 +10709,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.33.0";
+var getVersion = () => "3.34.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();