rulesync 8.17.0 → 8.19.0

package/dist/index.cjs

@@ -1064,11 +1064,18 @@ var smolToml = __toESM(require("smol-toml"), 1);
 // src/utils/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
+
+// src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function isPlainObject(value) {
-  if (value === null || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+  if (!isRecord(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
 }
+
+// src/utils/frontmatter.ts
 function deepRemoveNullishValue(value) {
   if (value === null || value === void 0) {
     return void 0;
@@ -1659,11 +1666,6 @@ var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
 var import_node_path10 = require("path");
 var import_mini6 = require("zod/mini");
 
-// src/utils/type-guards.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // src/features/commands/rulesync-command.ts
 var import_node_path9 = require("path");
 var import_mini5 = require("zod/mini");
@@ -7666,7 +7668,7 @@ var ToolMcp = class extends ToolFile {
     super({
       ...rest,
       validate: true
-      // Skip validation during construction
+      // ToolMcp runs subclass validation below when requested
     });
     if (rest.validate) {
       const result = this.validate();
@@ -7724,17 +7726,26 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
     return this.json;
   }
   /**
-   * In global mode, ~/.claude/.claude.json should not be deleted
-   * as it may contain other user settings.
+   * In global mode, ~/.claude.json should not be deleted as it is the
+   * user's primary Claude Code config and contains many other settings
+   * managed by Claude Code itself (feature flags, project trust list,
+   * hooks, user settings, model selection, etc.).
    * In local mode, .mcp.json can be safely deleted.
    */
   isDeletable() {
     return !this.global;
   }
+  /**
+   * Legacy global path used by rulesync ≤ v8.17.0. The documented store
+   * is `~/.claude.json`; `fromFile` falls back here with a deprecation
+   * warning (mirrors PR #333). Never modified or removed by rulesync.
+   */
+  static LEGACY_GLOBAL_DIR = ".claude";
+  static LEGACY_GLOBAL_FILE = ".claude.json";
   static getSettablePaths({ global } = {}) {
     if (global) {
       return {
-        relativeDirPath: ".claude",
+        relativeDirPath: ".",
         relativeFilePath: ".claude.json"
       };
     }
@@ -7746,19 +7757,52 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
   static async fromFile({
     outputRoot = process.cwd(),
     validate = true,
-    global = false
+    global = false,
+    logger
   }) {
     const paths = this.getSettablePaths({ global });
-    const fileContent = await readFileContentOrNull(
-      (0, import_node_path52.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)
-    ) ?? '{"mcpServers":{}}';
-    const json = JSON.parse(fileContent);
-    const newJson = { ...json, mcpServers: json.mcpServers ?? {} };
+    const recommendedPath = (0, import_node_path52.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+    if (await fileExists(recommendedPath)) {
+      const fileContent = await readFileContent(recommendedPath);
+      const json = JSON.parse(fileContent);
+      const newJson = { ...json, mcpServers: json.mcpServers ?? {} };
+      return new _ClaudecodeMcp({
+        outputRoot,
+        relativeDirPath: paths.relativeDirPath,
+        relativeFilePath: paths.relativeFilePath,
+        fileContent: JSON.stringify(newJson, null, 2),
+        validate,
+        global
+      });
+    }
+    if (global) {
+      const legacyPath = (0, import_node_path52.join)(
+        outputRoot,
+        _ClaudecodeMcp.LEGACY_GLOBAL_DIR,
+        _ClaudecodeMcp.LEGACY_GLOBAL_FILE
+      );
+      if (await fileExists(legacyPath)) {
+        logger?.warn(
+          `Warning: using deprecated path "${legacyPath}". Please migrate to "${recommendedPath}"`
+        );
+        const fileContent = await readFileContent(legacyPath);
+        const json = JSON.parse(fileContent);
+        const newJson = { ...json, mcpServers: json.mcpServers ?? {} };
+        return new _ClaudecodeMcp({
+          outputRoot,
+          relativeDirPath: _ClaudecodeMcp.LEGACY_GLOBAL_DIR,
+          relativeFilePath: _ClaudecodeMcp.LEGACY_GLOBAL_FILE,
+          fileContent: JSON.stringify(newJson, null, 2),
+          validate,
+          global
+        });
+      }
+    }
     return new _ClaudecodeMcp({
       outputRoot,
       relativeDirPath: paths.relativeDirPath,
       relativeFilePath: paths.relativeFilePath,
-      fileContent: JSON.stringify(newJson, null, 2),
+      fileContent: JSON.stringify({ mcpServers: {} }, null, 2),
       validate,
       global
     });
@@ -7787,7 +7831,7 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
   }
   toRulesyncMcp() {
     return this.toRulesyncMcpDefault({
-      fileContent: JSON.stringify({ mcpServers: this.json.mcpServers }, null, 2)
+      fileContent: JSON.stringify({ mcpServers: this.json.mcpServers ?? {} }, null, 2)
     });
   }
   validate() {
@@ -7889,14 +7933,16 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
 // src/features/mcp/codexcli-mcp.ts
 var import_node_path54 = require("path");
 var smolToml3 = __toESM(require("smol-toml"), 1);
+var MAX_REMOVE_EMPTY_ENTRIES_DEPTH = 32;
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function convertFromCodexFormat(codexMcp) {
   const result = {};
   for (const [name, config] of Object.entries(codexMcp)) {
-    if (typeof config !== "object" || config === null || Array.isArray(config)) {
-      continue;
-    }
+    if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+    if (!isRecord(config)) continue;
     const converted = {};
     for (const [key, value] of Object.entries(config)) {
+      if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
       if (key === "enabled") {
         if (value === false) {
           converted["disabled"] = true;
@@ -7918,8 +7964,11 @@ function convertFromCodexFormat(codexMcp) {
 function convertToCodexFormat(mcpServers) {
   const result = {};
   for (const [name, config] of Object.entries(mcpServers)) {
+    if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+    if (!isRecord(config)) continue;
     const converted = {};
     for (const [key, value] of Object.entries(config)) {
+      if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
       if (key === "disabled") {
         if (value === true) {
           converted["enabled"] = false;
@@ -8001,6 +8050,14 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
     const mcpServers = rulesyncMcp.getJson().mcpServers;
     const converted = convertToCodexFormat(mcpServers);
     const filteredMcpServers = this.removeEmptyEntries(converted);
+    for (const name of Object.keys(converted)) {
+      if (!Object.hasOwn(filteredMcpServers, name)) {
+        warnWithFallback(
+          void 0,
+          `MCP server "${name}" had no non-empty configuration and was dropped from the codex CLI config`
+        );
+      }
+    }
     configToml["mcp_servers"] = filteredMcpServers;
     return new _CodexcliMcp({
       outputRoot,
@@ -8020,13 +8077,21 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
   validate() {
     return { success: true, error: null };
   }
-  static removeEmptyEntries(obj) {
+  static removeEmptyEntries(obj, depth = 0) {
     if (!obj) return {};
+    if (depth > MAX_REMOVE_EMPTY_ENTRIES_DEPTH) {
+      warnWithFallback(
+        void 0,
+        `removeEmptyEntries: maximum recursion depth (${MAX_REMOVE_EMPTY_ENTRIES_DEPTH}) exceeded; empty nested objects may remain`
+      );
+      return obj;
+    }
     const filtered = {};
     for (const [key, value] of Object.entries(obj)) {
+      if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
       if (value === null) continue;
-      if (typeof value === "object" && !Array.isArray(value)) {
-        const cleaned = this.removeEmptyEntries(value);
+      if (isPlainObject(value)) {
+        const cleaned = this.removeEmptyEntries(value, depth + 1);
         if (Object.keys(cleaned).length === 0) continue;
         filtered[key] = cleaned;
         continue;
@@ -9719,7 +9784,13 @@ var toolMcpFactories = /* @__PURE__ */ new Map([
       class: KiloMcp,
       meta: {
         supportsProject: true,
-        supportsGlobal: false,
+        // Kilo CLI reads global MCP from `~/.config/kilo/kilo.json` (or
+        // `kilo.jsonc`). The path machinery in `KiloMcp.getSettablePaths`
+        // already routes global mode to that location; only this flag
+        // was gating it off. Kilo is an OpenCode fork and uses an
+        // identical native MCP schema, so global parity with opencode
+        // is the natural state.
+        supportsGlobal: true,
         supportsEnabledTools: false,
         supportsDisabledTools: false
       }
@@ -9865,7 +9936,8 @@ var McpProcessor = class extends FeatureProcessor {
         await factory.class.fromFile({
           outputRoot: this.outputRoot,
           validate: true,
-          global: this.global
+          global: this.global,
+          logger: this.logger
         })
       ];
       this.logger.debug(`Successfully loaded ${toolMcps.length} ${this.toolTarget} MCP files`);
@@ -12840,7 +12912,7 @@ var PermissionsProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path154 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini79 = require("zod/mini");
+var import_mini80 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -17792,7 +17864,7 @@ var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path125 = require("path");
-var import_mini72 = require("zod/mini");
+var import_mini73 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path113 = require("path");
@@ -18952,6 +19024,7 @@ var JunieSubagent = class _JunieSubagent extends ToolSubagent {
 
 // src/features/subagents/kilo-subagent.ts
 var import_node_path121 = require("path");
+var import_mini71 = require("zod/mini");
 
 // src/features/subagents/opencode-style-subagent.ts
 var import_node_path120 = require("path");
@@ -19018,11 +19091,54 @@ var OpenCodeStyleSubagent = class extends ToolSubagent {
 };
 
 // src/features/subagents/kilo-subagent.ts
-var KiloSubagentFrontmatterSchema = OpenCodeStyleSubagentFrontmatterSchema;
+var KiloSubagentFrontmatterSchema = import_mini71.z.looseObject({
+  description: import_mini71.z.optional(import_mini71.z.string()),
+  mode: import_mini71.z._default(import_mini71.z.string(), "all"),
+  name: import_mini71.z.optional(import_mini71.z.string()),
+  displayName: import_mini71.z.optional(import_mini71.z.string()),
+  deprecated: import_mini71.z.optional(import_mini71.z.boolean()),
+  native: import_mini71.z.optional(import_mini71.z.boolean()),
+  hidden: import_mini71.z.optional(import_mini71.z.boolean()),
+  top_p: import_mini71.z.optional(import_mini71.z.number()),
+  temperature: import_mini71.z.optional(import_mini71.z.number()),
+  color: import_mini71.z.optional(import_mini71.z.string()),
+  permission: import_mini71.z.optional(import_mini71.z.string()),
+  model: import_mini71.z.optional(import_mini71.z.string()),
+  variant: import_mini71.z.optional(import_mini71.z.string()),
+  prompt: import_mini71.z.optional(import_mini71.z.string()),
+  options: import_mini71.z.optional(import_mini71.z.looseObject({})),
+  steps: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.looseObject({}))),
+  disable: import_mini71.z.optional(import_mini71.z.boolean())
+});
 var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
+  constructor(params) {
+    super(params);
+    if (params.validate !== false) {
+      const result = this.validate();
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+  }
   getToolTarget() {
     return "kilo";
   }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  validate() {
+    const result = KiloSubagentFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      this.frontmatter = result.data;
+      return { success: true, error: null };
+    }
+    return {
+      success: false,
+      error: new Error(
+        `Invalid frontmatter in ${(0, import_node_path121.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+      )
+    };
+  }
   static getSettablePaths({
     global = false
   } = {}) {
@@ -19038,12 +19154,17 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
   }) {
     const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
     const kiloSection = rulesyncFrontmatter.kilo ?? {};
-    const kiloFrontmatter = {
+    const parseResult = KiloSubagentFrontmatterSchema.safeParse({
       ...kiloSection,
       description: rulesyncFrontmatter.description,
-      mode: typeof kiloSection.mode === "string" ? kiloSection.mode : "subagent",
       ...rulesyncFrontmatter.name && { name: rulesyncFrontmatter.name }
-    };
+    });
+    if (!parseResult.success) {
+      throw new Error(
+        `Invalid frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(parseResult.error)}`
+      );
+    }
+    const kiloFrontmatter = parseResult.data;
     const body = rulesyncSubagent.getBody();
     const fileContent = stringifyFrontmatter(body, kiloFrontmatter);
     const paths = this.getSettablePaths({ global });
@@ -19092,38 +19213,40 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
   static forDeletion({
     outputRoot = process.cwd(),
     relativeDirPath,
-    relativeFilePath
+    relativeFilePath,
+    global = false
   }) {
     return new _KiloSubagent({
       outputRoot,
       relativeDirPath,
       relativeFilePath,
-      frontmatter: { description: "", mode: "subagent" },
+      frontmatter: { description: "", mode: "all" },
       body: "",
       fileContent: "",
-      validate: false
+      validate: false,
+      global
     });
   }
 };
 
 // src/features/subagents/kiro-subagent.ts
 var import_node_path122 = require("path");
-var import_mini71 = require("zod/mini");
-var KiroCliSubagentJsonSchema = import_mini71.z.looseObject({
-  name: import_mini71.z.string(),
-  description: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.string())),
-  prompt: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.string())),
-  tools: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.array(import_mini71.z.string()))),
-  toolAliases: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.record(import_mini71.z.string(), import_mini71.z.string()))),
-  toolSettings: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.unknown())),
-  toolSchema: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.unknown())),
-  hooks: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.record(import_mini71.z.string(), import_mini71.z.array(import_mini71.z.unknown())))),
-  model: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.string())),
-  mcpServers: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.record(import_mini71.z.string(), import_mini71.z.unknown()))),
-  useLegacyMcpJson: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.boolean())),
-  resources: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.array(import_mini71.z.string()))),
-  allowedTools: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.array(import_mini71.z.string()))),
-  includeMcpJson: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.boolean()))
+var import_mini72 = require("zod/mini");
+var KiroCliSubagentJsonSchema = import_mini72.z.looseObject({
+  name: import_mini72.z.string(),
+  description: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.string())),
+  prompt: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.string())),
+  tools: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.array(import_mini72.z.string()))),
+  toolAliases: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.string()))),
+  toolSettings: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.unknown())),
+  toolSchema: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.unknown())),
+  hooks: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.array(import_mini72.z.unknown())))),
+  model: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.string())),
+  mcpServers: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.unknown()))),
+  useLegacyMcpJson: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.boolean())),
+  resources: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.array(import_mini72.z.string()))),
+  allowedTools: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.array(import_mini72.z.string()))),
+  includeMcpJson: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -19352,7 +19475,8 @@ var OpenCodeSubagent = class _OpenCodeSubagent extends OpenCodeStyleSubagent {
   static forDeletion({
     outputRoot = process.cwd(),
     relativeDirPath,
-    relativeFilePath
+    relativeFilePath,
+    global = false
   }) {
     return new _OpenCodeSubagent({
       outputRoot,
@@ -19361,7 +19485,8 @@ var OpenCodeSubagent = class _OpenCodeSubagent extends OpenCodeStyleSubagent {
       frontmatter: { description: "", mode: "subagent" },
       body: "",
       fileContent: "",
-      validate: false
+      validate: false,
+      global
     });
   }
 };
@@ -19489,7 +19614,7 @@ var subagentsProcessorToolTargetTuple = [
   "rovodev",
   "takt"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini72.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini73.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -19818,48 +19943,48 @@ var import_node_path127 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path126 = require("path");
-var import_mini73 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini73.z.object({
-  root: import_mini73.z.optional(import_mini73.z.boolean()),
-  localRoot: import_mini73.z.optional(import_mini73.z.boolean()),
-  targets: import_mini73.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini73.z.optional(import_mini73.z.string()),
-  globs: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string())),
-  agentsmd: import_mini73.z.optional(
-    import_mini73.z.looseObject({
+var import_mini74 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini74.z.object({
+  root: import_mini74.z.optional(import_mini74.z.boolean()),
+  localRoot: import_mini74.z.optional(import_mini74.z.boolean()),
+  targets: import_mini74.z._default(RulesyncTargetsSchema, ["*"]),
+  description: import_mini74.z.optional(import_mini74.z.string()),
+  globs: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string())),
+  agentsmd: import_mini74.z.optional(
+    import_mini74.z.looseObject({
       // @example "path/to/subproject"
-      subprojectPath: import_mini73.z.optional(import_mini73.z.string())
+      subprojectPath: import_mini74.z.optional(import_mini74.z.string())
     })
   ),
-  claudecode: import_mini73.z.optional(
-    import_mini73.z.looseObject({
+  claudecode: import_mini74.z.optional(
+    import_mini74.z.looseObject({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string()))
+      paths: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string()))
     })
   ),
-  cursor: import_mini73.z.optional(
-    import_mini73.z.looseObject({
-      alwaysApply: import_mini73.z.optional(import_mini73.z.boolean()),
-      description: import_mini73.z.optional(import_mini73.z.string()),
-      globs: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string()))
+  cursor: import_mini74.z.optional(
+    import_mini74.z.looseObject({
+      alwaysApply: import_mini74.z.optional(import_mini74.z.boolean()),
+      description: import_mini74.z.optional(import_mini74.z.string()),
+      globs: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string()))
     })
   ),
-  copilot: import_mini73.z.optional(
-    import_mini73.z.looseObject({
-      excludeAgent: import_mini73.z.optional(import_mini73.z.union([import_mini73.z.literal("code-review"), import_mini73.z.literal("coding-agent")]))
+  copilot: import_mini74.z.optional(
+    import_mini74.z.looseObject({
+      excludeAgent: import_mini74.z.optional(import_mini74.z.union([import_mini74.z.literal("code-review"), import_mini74.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini73.z.optional(
-    import_mini73.z.looseObject({
-      trigger: import_mini73.z.optional(import_mini73.z.string()),
-      globs: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string()))
+  antigravity: import_mini74.z.optional(
+    import_mini74.z.looseObject({
+      trigger: import_mini74.z.optional(import_mini74.z.string()),
+      globs: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string()))
     })
   ),
-  takt: import_mini73.z.optional(
-    import_mini73.z.looseObject({
+  takt: import_mini74.z.optional(
+    import_mini74.z.looseObject({
       // Rename the emitted file stem (e.g. "coder.md" → "{name}.md").
-      name: import_mini73.z.optional(import_mini73.z.string())
+      name: import_mini74.z.optional(import_mini74.z.string())
     })
   )
 });
@@ -20160,20 +20285,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path129 = require("path");
-var import_mini74 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini74.z.looseObject({
-  trigger: import_mini74.z.optional(
-    import_mini74.z.union([
-      import_mini74.z.literal("always_on"),
-      import_mini74.z.literal("glob"),
-      import_mini74.z.literal("manual"),
-      import_mini74.z.literal("model_decision"),
-      import_mini74.z.string()
+var import_mini75 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini75.z.looseObject({
+  trigger: import_mini75.z.optional(
+    import_mini75.z.union([
+      import_mini75.z.literal("always_on"),
+      import_mini75.z.literal("glob"),
+      import_mini75.z.literal("manual"),
+      import_mini75.z.literal("model_decision"),
+      import_mini75.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini74.z.optional(import_mini74.z.string()),
-  description: import_mini74.z.optional(import_mini74.z.string())
+  globs: import_mini75.z.optional(import_mini75.z.string()),
+  description: import_mini75.z.optional(import_mini75.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -20760,9 +20885,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path133 = require("path");
-var import_mini75 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini75.z.object({
-  paths: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string()))
+var import_mini76 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini76.z.object({
+  paths: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -20978,9 +21103,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path134 = require("path");
-var import_mini76 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini76.z.object({
-  description: import_mini76.z.string()
+var import_mini77 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini77.z.object({
+  description: import_mini77.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -21159,14 +21284,14 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path136 = require("path");
-var import_mini77 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini77.z.object({
-  description: import_mini77.z.optional(import_mini77.z.string()),
-  applyTo: import_mini77.z.optional(import_mini77.z.string()),
-  excludeAgent: import_mini77.z.optional(import_mini77.z.union([import_mini77.z.literal("code-review"), import_mini77.z.literal("coding-agent")]))
+var import_mini78 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini78.z.object({
+  description: import_mini78.z.optional(import_mini78.z.string()),
+  applyTo: import_mini78.z.optional(import_mini78.z.string()),
+  excludeAgent: import_mini78.z.optional(import_mini78.z.union([import_mini78.z.literal("code-review"), import_mini78.z.literal("coding-agent")]))
 });
-var normalizeRelativePath = (path4) => path4.replace(/\\/g, "/").replace(/\/+/g, "/");
-var sameRelativePath = (leftDir, leftFile, rightDir, rightFile) => normalizeRelativePath((0, import_node_path136.join)(leftDir, leftFile)) === normalizeRelativePath((0, import_node_path136.join)(rightDir, rightFile));
+var normalizeRelativePath = (p) => toPosixPath(p).replace(/\/+/g, "/");
+var sameRelativePath = (left, right) => normalizeRelativePath((0, import_node_path136.join)(left.dir, left.file)) === normalizeRelativePath((0, import_node_path136.join)(right.dir, right.file));
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
   body;
@@ -21285,10 +21410,8 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   }) {
     const paths = this.getSettablePaths({ global });
     const isRoot = relativeDirPath ? sameRelativePath(
-      relativeDirPath,
-      relativeFilePath,
-      paths.root.relativeDirPath,
-      paths.root.relativeFilePath
+      { dir: relativeDirPath, file: relativeFilePath },
+      { dir: paths.root.relativeDirPath, file: paths.root.relativeFilePath }
     ) : relativeFilePath === paths.root.relativeFilePath;
     const resolvedRelativeDirPath = relativeDirPath ?? (isRoot ? paths.root.relativeDirPath : paths.nonRoot?.relativeDirPath ?? paths.root.relativeDirPath);
     if (isRoot) {
@@ -21334,10 +21457,8 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   }) {
     const paths = this.getSettablePaths({ global });
     const isRoot = sameRelativePath(
-      relativeDirPath,
-      relativeFilePath,
-      paths.root.relativeDirPath,
-      paths.root.relativeFilePath
+      { dir: relativeDirPath, file: relativeFilePath },
+      { dir: paths.root.relativeDirPath, file: paths.root.relativeFilePath }
     );
     return new _CopilotRule({
       outputRoot,
@@ -21417,11 +21538,11 @@ var CopilotcliRule = class _CopilotcliRule extends CopilotRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path137 = require("path");
-var import_mini78 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini78.z.object({
-  description: import_mini78.z.optional(import_mini78.z.string()),
-  globs: import_mini78.z.optional(import_mini78.z.string()),
-  alwaysApply: import_mini78.z.optional(import_mini78.z.boolean())
+var import_mini79 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini79.z.object({
+  description: import_mini79.z.optional(import_mini79.z.string()),
+  globs: import_mini79.z.optional(import_mini79.z.string()),
+  alwaysApply: import_mini79.z.optional(import_mini79.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -23304,11 +23425,11 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini79.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini80.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path154.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
-var RulesFeatureOptionsSchema = import_mini79.z.looseObject({
-  ruleDiscoveryMode: import_mini79.z.optional(import_mini79.z.enum(["none", "explicit"])),
-  includeLocalRoot: import_mini79.z.optional(import_mini79.z.boolean())
+var RulesFeatureOptionsSchema = import_mini80.z.looseObject({
+  ruleDiscoveryMode: import_mini80.z.optional(import_mini80.z.enum(["none", "explicit"])),
+  includeLocalRoot: import_mini80.z.optional(import_mini80.z.boolean())
 });
 var resolveRuleDiscoveryMode = ({
   defaultMode,
@@ -23329,8 +23450,8 @@ var resolveRuleDiscoveryMode = ({
   }
   return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
 };
-var IncludeLocalRootSchema = import_mini79.z.looseObject({
-  includeLocalRoot: import_mini79.z.optional(import_mini79.z.boolean())
+var IncludeLocalRootSchema = import_mini80.z.looseObject({
+  includeLocalRoot: import_mini80.z.optional(import_mini80.z.boolean())
 });
 var resolveIncludeLocalRoot = (options) => {
   if (!options) return true;

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   convertFromTool,
   generate,
   importFromTool
-} from "./chunk-RXCRO26Z.js";
+} from "./chunk-66SPWRYP.js";
 
 // src/index.ts
 async function generate2(options = {}) {