npm - rulesync - Versions diffs - 7.30.0 → 8.1.0 - Mend

rulesync 7.30.0 → 8.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +3 -3
package/dist/{chunk-IGW5DFPU.js → chunk-FLZZ3LEK.js} +1060 -584
package/dist/cli/index.cjs +736 -228
package/dist/cli/index.js +41 -7
package/dist/index.cjs +1084 -609
package/dist/index.js +1 -1
package/package.json +5 -5

package/dist/cli/index.cjs CHANGED Viewed

@@ -6501,7 +6501,8 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
       relativeDirPath: paths.relativeDirPath,
       relativeFilePath: paths.relativeFilePath,
       fileContent: JSON.stringify(newJson, null, 2),
-      validate
+      validate,
+      global
     });
   }
   static async fromRulesyncMcp({
@@ -6522,7 +6523,8 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
       relativeDirPath: paths.relativeDirPath,
       relativeFilePath: paths.relativeFilePath,
       fileContent: JSON.stringify(mcpJson, null, 2),
-      validate
+      validate,
+      global
     });
   }
   toRulesyncMcp() {
@@ -13493,12 +13495,16 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
     const body = rulesyncSubagent.getBody();
     const fileContent = stringifyFrontmatter(body, copilotFrontmatter);
     const paths = this.getSettablePaths({ global });
+    let relativeFilePath = rulesyncSubagent.getRelativeFilePath();
+    if (!relativeFilePath.endsWith(".agent.md")) {
+      relativeFilePath = relativeFilePath.replace(/\.md$/, ".agent.md");
+    }
     return new _CopilotSubagent({
       baseDir,
       frontmatter: copilotFrontmatter,
       body,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+      relativeFilePath,
       fileContent,
       validate,
       global
@@ -17931,14 +17937,21 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
     rulesyncRule,
     validate = true
   }) {
-    return new _WindsurfRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
+    const toolRuleParams = this.buildToolRuleParamsDefault({
+      baseDir,
+      rulesyncRule,
+      validate,
+      nonRootPath: this.getSettablePaths().nonRoot
+    });
+    const windsurfFrontmatter = this.buildWindsurfFrontmatter({
+      relativeFilePath: rulesyncRule.getRelativeFilePath(),
+      description: rulesyncRule.getFrontmatter().description,
+      globs: rulesyncRule.getFrontmatter().globs
+    });
+    return new _WindsurfRule({
+      ...toolRuleParams,
+      fileContent: stringifyFrontmatter(rulesyncRule.getBody(), windsurfFrontmatter)
+    });
   }
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -17965,6 +17978,18 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
       toolTarget: "windsurf"
     });
   }
+  static buildWindsurfFrontmatter({
+    relativeFilePath,
+    description,
+    globs
+  }) {
+    const hasSpecificGlobs = Boolean(globs && globs.length > 0 && !globs.includes("**/*"));
+    return {
+      title: description ?? relativeFilePath.replace(/\.md$/, ""),
+      trigger: hasSpecificGlobs ? "glob" : "always_on",
+      ...hasSpecificGlobs && { globs }
+    };
+  }
 };
 // src/features/rules/rules-processor.ts
@@ -17997,6 +18022,42 @@ var rulesProcessorToolTargets = [
 ];
 var RulesProcessorToolTargetSchema = import_mini65.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path131.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
+var RulesFeatureOptionsSchema = import_mini65.z.looseObject({
+  ruleDiscoveryMode: import_mini65.z.optional(import_mini65.z.enum(["none", "explicit"])),
+  includeLocalRoot: import_mini65.z.optional(import_mini65.z.boolean())
+});
+var resolveRuleDiscoveryMode = ({
+  defaultMode,
+  options
+}) => {
+  if (defaultMode === "claudecode-legacy") {
+    return defaultMode;
+  }
+  if (!options) return defaultMode;
+  const parsed = RulesFeatureOptionsSchema.safeParse(options);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid options for rules feature: ${parsed.error.message}. \`ruleDiscoveryMode\` must be either "none" or "explicit".`
+    );
+  }
+  if (!parsed.data.ruleDiscoveryMode) {
+    return defaultMode;
+  }
+  return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
+};
+var IncludeLocalRootSchema = import_mini65.z.looseObject({
+  includeLocalRoot: import_mini65.z.optional(import_mini65.z.boolean())
+});
+var resolveIncludeLocalRoot = (options) => {
+  if (!options) return true;
+  const parsed = IncludeLocalRootSchema.safeParse(options);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid options for rules feature: ${parsed.error.message}. \`includeLocalRoot\` must be a boolean.`
+    );
+  }
+  return parsed.data.includeLocalRoot ?? true;
+};
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -18311,6 +18372,7 @@ var RulesProcessor = class extends FeatureProcessor {
   global;
   getFactory;
   skills;
+  featureOptions;
   constructor({
     baseDir = process.cwd(),
     toolTarget,
@@ -18320,6 +18382,7 @@ var RulesProcessor = class extends FeatureProcessor {
     global = false,
     getFactory = defaultGetFactory6,
     skills,
+    featureOptions,
     dryRun = false,
     logger: logger5
   }) {
@@ -18337,6 +18400,7 @@ var RulesProcessor = class extends FeatureProcessor {
     this.simulateSkills = simulateSkills;
     this.getFactory = getFactory;
     this.skills = skills;
+    this.featureOptions = featureOptions;
   }
   async convertRulesyncFilesToToolFiles(rulesyncFiles) {
     const rulesyncRules = rulesyncFiles.filter(
@@ -18357,7 +18421,8 @@ var RulesProcessor = class extends FeatureProcessor {
         global: this.global
       });
     }).filter((rule) => rule !== null);
-    if (localRootRules.length > 0 && !this.global) {
+    const includeLocalRoot = resolveIncludeLocalRoot(this.featureOptions);
+    if (localRootRules.length > 0 && !this.global && includeLocalRoot) {
       const localRootRule = localRootRules[0];
       if (localRootRule && factory.class.isTargetedByRulesyncRule(localRootRule)) {
         this.handleLocalRootRule(toolRules, localRootRule, factory);
@@ -18494,7 +18559,11 @@ var RulesProcessor = class extends FeatureProcessor {
    * Generate reference section based on meta configuration.
    */
   generateReferenceSectionFromMeta(meta, toolRules) {
-    switch (meta.ruleDiscoveryMode) {
+    const mode = resolveRuleDiscoveryMode({
+      defaultMode: meta.ruleDiscoveryMode,
+      options: this.featureOptions
+    });
+    switch (mode) {
       case "toon":
         return this.generateToonReferencesSection(toolRules);
       case "claudecode-legacy":
@@ -19935,6 +20004,7 @@ var ConfigParamsSchema = import_mini69.z.object({
   simulateCommands: (0, import_mini69.optional)(import_mini69.z.boolean()),
   simulateSubagents: (0, import_mini69.optional)(import_mini69.z.boolean()),
   simulateSkills: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  gitignoreTargetsOnly: (0, import_mini69.optional)(import_mini69.z.boolean()),
   dryRun: (0, import_mini69.optional)(import_mini69.z.boolean()),
   check: (0, import_mini69.optional)(import_mini69.z.boolean()),
   // Declarative skill sources
@@ -19962,6 +20032,7 @@ var Config = class _Config {
   simulateCommands;
   simulateSubagents;
   simulateSkills;
+  gitignoreTargetsOnly;
   dryRun;
   check;
   sources;
@@ -19976,6 +20047,7 @@ var Config = class _Config {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
+    gitignoreTargetsOnly,
     dryRun,
     check,
     sources
@@ -19994,6 +20066,7 @@ var Config = class _Config {
     this.simulateCommands = simulateCommands ?? false;
     this.simulateSubagents = simulateSubagents ?? false;
     this.simulateSkills = simulateSkills ?? false;
+    this.gitignoreTargetsOnly = gitignoreTargetsOnly ?? true;
     this.dryRun = dryRun ?? false;
     this.check = check ?? false;
     this.sources = sources ?? [];
@@ -20119,6 +20192,9 @@ var Config = class _Config {
   getSimulateSkills() {
     return this.simulateSkills;
   }
+  getGitignoreTargetsOnly() {
+    return this.gitignoreTargetsOnly;
+  }
   getDryRun() {
     return this.dryRun;
   }
@@ -20150,6 +20226,7 @@ var getDefaults = () => ({
   simulateCommands: false,
   simulateSubagents: false,
   simulateSkills: false,
+  gitignoreTargetsOnly: true,
   dryRun: false,
   check: false,
   sources: []
@@ -20176,6 +20253,7 @@ var mergeConfigs = (baseConfig, localConfig) => {
     simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
     simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
     simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+    gitignoreTargetsOnly: localConfig.gitignoreTargetsOnly ?? baseConfig.gitignoreTargetsOnly,
     dryRun: localConfig.dryRun ?? baseConfig.dryRun,
     check: localConfig.check ?? baseConfig.check,
     sources: localConfig.sources ?? baseConfig.sources
@@ -20194,6 +20272,7 @@ var ConfigResolver = class {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
+    gitignoreTargetsOnly,
     dryRun,
     check
   }) {
@@ -20207,6 +20286,7 @@ var ConfigResolver = class {
     const resolvedSimulateCommands = simulateCommands ?? configByFile.simulateCommands ?? getDefaults().simulateCommands;
     const resolvedSimulateSubagents = simulateSubagents ?? configByFile.simulateSubagents ?? getDefaults().simulateSubagents;
     const resolvedSimulateSkills = simulateSkills ?? configByFile.simulateSkills ?? getDefaults().simulateSkills;
+    const resolvedGitignoreTargetsOnly = gitignoreTargetsOnly ?? configByFile.gitignoreTargetsOnly ?? getDefaults().gitignoreTargetsOnly;
     const configParams = {
       targets: targets ?? configByFile.targets ?? getDefaults().targets,
       features: features ?? configByFile.features ?? getDefaults().features,
@@ -20221,6 +20301,7 @@ var ConfigResolver = class {
       simulateCommands: resolvedSimulateCommands,
       simulateSubagents: resolvedSimulateSubagents,
       simulateSkills: resolvedSimulateSkills,
+      gitignoreTargetsOnly: resolvedGitignoreTargetsOnly,
       dryRun: dryRun ?? configByFile.dryRun ?? getDefaults().dryRun,
       check: check ?? configByFile.check ?? getDefaults().check,
       sources: configByFile.sources ?? getDefaults().sources
@@ -20243,11 +20324,11 @@ function getBaseDirsInLightOfGlobal({
 }
 // src/lib/generate.ts
-var import_node_path138 = require("path");
+var import_node_path140 = require("path");
 var import_es_toolkit5 = require("es-toolkit");
 // src/features/permissions/permissions-processor.ts
-var import_mini72 = require("zod/mini");
+var import_mini73 = require("zod/mini");
 // src/features/permissions/claudecode-permissions.ts
 var import_node_path136 = require("path");
@@ -20572,16 +20653,382 @@ function convertClaudeToRulesyncPermissions(params) {
   return { permission };
 }
-// src/features/permissions/opencode-permissions.ts
+// src/features/permissions/codexcli-permissions.ts
 var import_node_path137 = require("path");
-var import_jsonc_parser5 = require("jsonc-parser");
+var smolToml5 = __toESM(require("smol-toml"), 1);
+var RULESYNC_PROFILE_NAME = "rulesync";
+var CodexcliPermissions = class _CodexcliPermissions extends ToolPermissions {
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: ".codex",
+      relativeFilePath: "config.toml"
+    };
+  }
+  isDeletable() {
+    return false;
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path137.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? smolToml5.stringify({});
+    return new _CodexcliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    validate = true,
+    logger: logger5,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path137.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readFileContentOrNull(filePath) ?? smolToml5.stringify({});
+    const parsed = toMutableTable(smolToml5.parse(existingContent));
+    const profile = convertRulesyncToCodexProfile({
+      config: rulesyncPermissions.getJson(),
+      logger: logger5
+    });
+    const permissionsTable = toMutableTable(parsed.permissions);
+    permissionsTable[RULESYNC_PROFILE_NAME] = profile;
+    parsed.permissions = permissionsTable;
+    parsed.default_permissions = RULESYNC_PROFILE_NAME;
+    return new _CodexcliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: smolToml5.stringify(parsed),
+      validate
+    });
+  }
+  toRulesyncPermissions() {
+    let parsed;
+    try {
+      parsed = smolToml5.parse(this.getFileContent());
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Codex CLI permissions content in ${(0, import_node_path137.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const table = toMutableTable(parsed);
+    const defaultProfile = typeof table.default_permissions === "string" ? table.default_permissions : void 0;
+    const permissionsTable = toMutableTable(table.permissions);
+    const profile = toCodexProfile(permissionsTable[defaultProfile ?? RULESYNC_PROFILE_NAME]) ?? toCodexProfile(permissionsTable[RULESYNC_PROFILE_NAME]);
+    const config = convertCodexProfileToRulesync(profile);
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify(config, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _CodexcliPermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: smolToml5.stringify({}),
+      validate: false
+    });
+  }
+};
+function convertRulesyncToCodexProfile({
+  config,
+  logger: logger5
+}) {
+  const filesystem = {};
+  const domains = {};
+  for (const [toolName, rules] of Object.entries(config.permission)) {
+    if (toolName === "read") {
+      for (const [pattern, action] of Object.entries(rules)) {
+        filesystem[pattern] = mapReadAction(action);
+      }
+      continue;
+    }
+    if (toolName === "edit" || toolName === "write") {
+      for (const [pattern, action] of Object.entries(rules)) {
+        filesystem[pattern] = mapWriteAction(action);
+      }
+      continue;
+    }
+    if (toolName === "webfetch") {
+      for (const [pattern, action] of Object.entries(rules)) {
+        if (action === "ask") {
+          logger5?.warn(
+            `Codex CLI does not support "ask" for network domain permissions. Skipping webfetch rule: ${pattern}`
+          );
+          continue;
+        }
+        domains[pattern] = action;
+      }
+      continue;
+    }
+    logger5?.warn(
+      `Codex CLI permissions support only read/edit/write/webfetch categories. Skipping: ${toolName}`
+    );
+  }
+  return {
+    ...Object.keys(filesystem).length > 0 ? { filesystem } : {},
+    ...Object.keys(domains).length > 0 ? { network: { domains } } : {}
+  };
+}
+function convertCodexProfileToRulesync(profile) {
+  const permission = {};
+  if (profile?.filesystem) {
+    permission.read = {};
+    permission.edit = {};
+    for (const [pattern, access] of Object.entries(profile.filesystem)) {
+      if (access === "none") {
+        permission.read[pattern] = "deny";
+        permission.edit[pattern] = "deny";
+      } else if (access === "read") {
+        permission.read[pattern] = "allow";
+      } else {
+        permission.edit[pattern] = "allow";
+      }
+    }
+  }
+  if (profile?.network?.domains) {
+    permission.webfetch = {};
+    for (const [domain, value] of Object.entries(profile.network.domains)) {
+      permission.webfetch[domain] = value;
+    }
+  }
+  return { permission };
+}
+function toCodexProfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const table = toMutableTable(value);
+  const filesystem = toFilesystemRecord(table.filesystem);
+  const networkRaw = toMutableTable(table.network);
+  const domains = toDomainRecord(networkRaw.domains);
+  return {
+    ...filesystem ? { filesystem } : {},
+    ...domains ? { network: { domains } } : {}
+  };
+}
+function toMutableTable(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+function toFilesystemRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw !== "string") continue;
+    if (raw === "read" || raw === "write" || raw === "none") {
+      result[key] = raw;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function toDomainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (raw === "allow" || raw === "deny") {
+      result[key] = raw;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function mapReadAction(action) {
+  return action === "allow" ? "read" : "none";
+}
+function mapWriteAction(action) {
+  return action === "allow" ? "write" : "none";
+}
+// src/features/permissions/geminicli-permissions.ts
+var import_node_path138 = require("path");
 var import_mini71 = require("zod/mini");
-var OpencodePermissionSchema = import_mini71.z.union([
-  import_mini71.z.enum(["allow", "ask", "deny"]),
-  import_mini71.z.record(import_mini71.z.string(), import_mini71.z.enum(["allow", "ask", "deny"]))
+var GeminiCliSettingsSchema = import_mini71.z.looseObject({
+  tools: import_mini71.z.optional(
+    import_mini71.z.looseObject({
+      allowed: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.string())),
+      exclude: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.string()))
+    })
+  )
+});
+var RULESYNC_TO_GEMINICLI_TOOL_NAME = {
+  bash: "run_shell_command",
+  read: "read_file",
+  edit: "replace",
+  write: "write_file",
+  webfetch: "web_fetch"
+};
+var GeminicliPermissions = class _GeminicliPermissions extends ToolPermissions {
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: ".gemini",
+      relativeFilePath: "settings.json"
+    };
+  }
+  isDeletable() {
+    return false;
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path138.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    return new _GeminicliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    validate = true,
+    logger: logger5,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path138.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    const settingsResult = GeminiCliSettingsSchema.safeParse(JSON.parse(existingContent));
+    if (!settingsResult.success) {
+      throw new Error(
+        `Failed to parse existing Gemini CLI settings at ${filePath}: ${formatError(settingsResult.error)}`
+      );
+    }
+    const { allowed, exclude } = convertRulesyncToGeminicliTools({
+      config: rulesyncPermissions.getJson(),
+      logger: logger5
+    });
+    const merged = {
+      ...settingsResult.data,
+      tools: {
+        ...settingsResult.data.tools,
+        ...allowed.length > 0 ? { allowed } : {},
+        ...exclude.length > 0 ? { exclude } : {}
+      }
+    };
+    return new _GeminicliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(merged, null, 2),
+      validate
+    });
+  }
+  toRulesyncPermissions() {
+    let settings;
+    try {
+      const parsed = JSON.parse(this.getFileContent());
+      settings = GeminiCliSettingsSchema.parse(parsed);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Gemini CLI permissions content in ${(0, import_node_path138.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const permission = {};
+    for (const toolEntry of settings.tools?.allowed ?? []) {
+      const mapped = parseGeminicliToolEntry({ entry: toolEntry });
+      const rules = permission[mapped.category] ??= {};
+      rules[mapped.pattern] = "allow";
+    }
+    for (const toolEntry of settings.tools?.exclude ?? []) {
+      const mapped = parseGeminicliToolEntry({ entry: toolEntry });
+      const rules = permission[mapped.category] ??= {};
+      rules[mapped.pattern] = "deny";
+    }
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify({ permission }, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _GeminicliPermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify({}, null, 2),
+      validate: false
+    });
+  }
+};
+function convertRulesyncToGeminicliTools({
+  config,
+  logger: logger5
+}) {
+  const allowed = [];
+  const exclude = [];
+  for (const [toolName, rules] of Object.entries(config.permission)) {
+    const mappedToolName = RULESYNC_TO_GEMINICLI_TOOL_NAME[toolName] ?? toolName;
+    if (!RULESYNC_TO_GEMINICLI_TOOL_NAME[toolName]) {
+      logger5?.warn(`Gemini CLI permissions use direct tool names. Mapping as-is: ${toolName}`);
+    }
+    for (const [pattern, action] of Object.entries(rules)) {
+      if (action === "ask") {
+        logger5?.warn(
+          `Gemini CLI does not support explicit "ask" rules in settings. Skipping ${toolName}:${pattern}`
+        );
+        continue;
+      }
+      const geminiEntry = pattern === "*" ? mappedToolName : `${mappedToolName}(${pattern})`;
+      if (action === "allow") {
+        allowed.push(geminiEntry);
+      } else {
+        exclude.push(geminiEntry);
+      }
+    }
+  }
+  return { allowed, exclude };
+}
+function parseGeminicliToolEntry({ entry }) {
+  const match = /^([^()]+?)(?:\((.*)\))?$/.exec(entry);
+  if (!match) return { category: entry, pattern: "*" };
+  const rawToolName = match[1]?.trim() ?? entry;
+  const mappedCategory = Object.entries(RULESYNC_TO_GEMINICLI_TOOL_NAME).find(
+    ([, value]) => value === rawToolName
+  )?.[0];
+  return {
+    category: mappedCategory ?? rawToolName,
+    pattern: (match[2] ?? "*").trim()
+  };
+}
+// src/features/permissions/opencode-permissions.ts
+var import_node_path139 = require("path");
+var import_jsonc_parser5 = require("jsonc-parser");
+var import_mini72 = require("zod/mini");
+var OpencodePermissionSchema = import_mini72.z.union([
+  import_mini72.z.enum(["allow", "ask", "deny"]),
+  import_mini72.z.record(import_mini72.z.string(), import_mini72.z.enum(["allow", "ask", "deny"]))
 ]);
-var OpencodePermissionsConfigSchema = import_mini71.z.looseObject({
-  permission: import_mini71.z.optional(import_mini71.z.record(import_mini71.z.string(), OpencodePermissionSchema))
+var OpencodePermissionsConfigSchema = import_mini72.z.looseObject({
+  permission: import_mini72.z.optional(import_mini72.z.record(import_mini72.z.string(), OpencodePermissionSchema))
 });
 var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   json;
@@ -20598,7 +21045,7 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   static getSettablePaths({
     global = false
   } = {}) {
-    return global ? { relativeDirPath: (0, import_node_path137.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
+    return global ? { relativeDirPath: (0, import_node_path139.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
   }
   static async fromFile({
     baseDir = process.cwd(),
@@ -20606,9 +21053,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    const jsonDir = (0, import_node_path137.join)(baseDir, basePaths.relativeDirPath);
-    const jsoncPath = (0, import_node_path137.join)(jsonDir, "opencode.jsonc");
-    const jsonPath = (0, import_node_path137.join)(jsonDir, "opencode.json");
+    const jsonDir = (0, import_node_path139.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path139.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path139.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -20633,9 +21080,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    const jsonDir = (0, import_node_path137.join)(baseDir, basePaths.relativeDirPath);
-    const jsoncPath = (0, import_node_path137.join)(jsonDir, "opencode.jsonc");
-    const jsonPath = (0, import_node_path137.join)(jsonDir, "opencode.json");
+    const jsonDir = (0, import_node_path139.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path139.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path139.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -20705,8 +21152,13 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
 };
 // src/features/permissions/permissions-processor.ts
-var permissionsProcessorToolTargetTuple = ["claudecode", "opencode"];
-var PermissionsProcessorToolTargetSchema = import_mini72.z.enum(permissionsProcessorToolTargetTuple);
+var permissionsProcessorToolTargetTuple = [
+  "claudecode",
+  "codexcli",
+  "geminicli",
+  "opencode"
+];
+var PermissionsProcessorToolTargetSchema = import_mini73.z.enum(permissionsProcessorToolTargetTuple);
 var toolPermissionsFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -20719,6 +21171,28 @@ var toolPermissionsFactories = /* @__PURE__ */ new Map([
       }
     }
   ],
+  [
+    "codexcli",
+    {
+      class: CodexcliPermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: true,
+        supportsImport: true
+      }
+    }
+  ],
+  [
+    "geminicli",
+    {
+      class: GeminicliPermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: true,
+        supportsImport: true
+      }
+    }
+  ],
   [
     "opencode",
     {
@@ -20901,7 +21375,7 @@ function warnUnsupportedTargets(params) {
   }
 }
 async function checkRulesyncDirExists(params) {
-  return fileExists((0, import_node_path138.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
+  return fileExists((0, import_node_path140.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
 async function generate(params) {
   const { config, logger: logger5 } = params;
@@ -20956,6 +21430,7 @@ async function generateRulesCore(params) {
         simulateSubagents: config.getSimulateSubagents(),
         simulateSkills: config.getSimulateSkills(),
         skills,
+        featureOptions: config.getFeatureOptions(toolTarget, "rules"),
         dryRun: config.isPreviewMode(),
         logger: logger5
       });
@@ -21370,7 +21845,7 @@ async function generateCommand(logger5, options) {
 }
 // src/cli/commands/gitignore.ts
-var import_node_path139 = require("path");
+var import_node_path141 = require("path");
 // src/cli/commands/gitignore-entries.ts
 var normalizeGitignoreEntryTargets = (target) => {
@@ -21416,6 +21891,7 @@ var GITIGNORE_ENTRY_REGISTRY = [
     feature: "general",
     entry: "**/.claude/settings.local.json"
   },
+  { target: "claudecode", feature: "general", entry: "**/.claude/*.lock" },
   // Cline
   { target: "cline", feature: "rules", entry: "**/.clinerules/" },
   { target: "cline", feature: "commands", entry: "**/.clinerules/workflows/" },
@@ -21524,6 +22000,11 @@ var GITIGNORE_ENTRY_REGISTRY = [
   { target: "opencode", feature: "skills", entry: "**/.opencode/skill/" },
   { target: "opencode", feature: "mcp", entry: "**/.opencode/plugins/" },
   { target: "opencode", feature: "general", entry: "**/.opencode/memories/" },
+  {
+    target: "opencode",
+    feature: "general",
+    entry: "**/.opencode/package-lock.json"
+  },
   // Qwen Code
   { target: "qwencode", feature: "rules", entry: "**/QWEN.md" },
   { target: "qwencode", feature: "general", entry: "**/.qwen/memories/" },
@@ -21708,7 +22189,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async (logger5, options) => {
-  const gitignorePath = (0, import_node_path139.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path141.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -22069,7 +22550,7 @@ async function importCommand(logger5, options) {
 }
 // src/lib/init.ts
-var import_node_path140 = require("path");
+var import_node_path142 = require("path");
 async function init() {
   const sampleFiles = await createSampleFiles();
   const configFile = await createConfigFile();
@@ -22097,7 +22578,8 @@ async function createConfigFile() {
         global: false,
         simulateCommands: false,
         simulateSubagents: false,
-        simulateSkills: false
+        simulateSkills: false,
+        gitignoreTargetsOnly: true
       },
       null,
       2
@@ -22261,27 +22743,27 @@ Keep the summary concise and ready to reuse in future tasks.`
   await ensureDir(subagentPaths.relativeDirPath);
   await ensureDir(skillPaths.relativeDirPath);
   await ensureDir(ignorePaths.recommended.relativeDirPath);
-  const ruleFilepath = (0, import_node_path140.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path142.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   results.push(await writeIfNotExists(ruleFilepath, sampleRuleFile.content));
-  const mcpFilepath = (0, import_node_path140.join)(
+  const mcpFilepath = (0, import_node_path142.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(mcpFilepath, sampleMcpFile.content));
-  const commandFilepath = (0, import_node_path140.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path142.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
   results.push(await writeIfNotExists(commandFilepath, sampleCommandFile.content));
-  const subagentFilepath = (0, import_node_path140.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path142.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   results.push(await writeIfNotExists(subagentFilepath, sampleSubagentFile.content));
-  const skillDirPath = (0, import_node_path140.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = (0, import_node_path142.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = (0, import_node_path140.join)(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = (0, import_node_path142.join)(skillDirPath, SKILL_FILE_NAME);
   results.push(await writeIfNotExists(skillFilepath, sampleSkillFile.content));
-  const ignoreFilepath = (0, import_node_path140.join)(
+  const ignoreFilepath = (0, import_node_path142.join)(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(ignoreFilepath, sampleIgnoreFile.content));
-  const hooksFilepath = (0, import_node_path140.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
+  const hooksFilepath = (0, import_node_path142.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
   results.push(await writeIfNotExists(hooksFilepath, sampleHooksFile.content));
   return results;
 }
@@ -22329,12 +22811,12 @@ async function initCommand(logger5) {
 }
 // src/lib/sources.ts
-var import_node_path143 = require("path");
+var import_node_path145 = require("path");
 var import_promise2 = require("es-toolkit/promise");
 // src/lib/git-client.ts
 var import_node_child_process = require("child_process");
-var import_node_path141 = require("path");
+var import_node_path143 = require("path");
 var import_node_util2 = require("util");
 var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process.execFile);
 var GIT_TIMEOUT_MS = 6e4;
@@ -22422,7 +22904,7 @@ async function fetchSkillFiles(params) {
   const { url, ref, skillsPath, logger: logger5 } = params;
   validateGitUrl(url, { logger: logger5 });
   validateRef(ref);
-  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path141.isAbsolute)(skillsPath)) {
+  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path143.isAbsolute)(skillsPath)) {
     throw new GitClientError(
       `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
     );
@@ -22456,7 +22938,7 @@ async function fetchSkillFiles(params) {
       timeout: GIT_TIMEOUT_MS
     });
     await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
-    const skillsDir = (0, import_node_path141.join)(tmpDir, skillsPath);
+    const skillsDir = (0, import_node_path143.join)(tmpDir, skillsPath);
     if (!await directoryExists(skillsDir)) return [];
     return await walkDirectory(skillsDir, skillsDir, 0, { totalFiles: 0, totalSize: 0 }, logger5);
   } catch (error) {
@@ -22478,7 +22960,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
   const results = [];
   for (const name of await listDirectoryFiles(dir)) {
     if (name === ".git") continue;
-    const fullPath = (0, import_node_path141.join)(dir, name);
+    const fullPath = (0, import_node_path143.join)(dir, name);
     if (await isSymlink(fullPath)) {
       logger5?.warn(`Skipping symlink "${fullPath}".`);
       continue;
@@ -22506,7 +22988,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
         );
       }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: (0, import_node_path141.relative)(baseDir, fullPath), content, size });
+      results.push({ relativePath: (0, import_node_path143.relative)(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -22514,28 +22996,28 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
 // src/lib/sources-lock.ts
 var import_node_crypto = require("crypto");
-var import_node_path142 = require("path");
-var import_mini73 = require("zod/mini");
+var import_node_path144 = require("path");
+var import_mini74 = require("zod/mini");
 var LOCKFILE_VERSION = 1;
-var LockedSkillSchema = import_mini73.z.object({
-  integrity: import_mini73.z.string()
+var LockedSkillSchema = import_mini74.z.object({
+  integrity: import_mini74.z.string()
 });
-var LockedSourceSchema = import_mini73.z.object({
-  requestedRef: (0, import_mini73.optional)(import_mini73.z.string()),
-  resolvedRef: import_mini73.z.string().check((0, import_mini73.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
-  resolvedAt: (0, import_mini73.optional)(import_mini73.z.string()),
-  skills: import_mini73.z.record(import_mini73.z.string(), LockedSkillSchema)
+var LockedSourceSchema = import_mini74.z.object({
+  requestedRef: (0, import_mini74.optional)(import_mini74.z.string()),
+  resolvedRef: import_mini74.z.string().check((0, import_mini74.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
+  resolvedAt: (0, import_mini74.optional)(import_mini74.z.string()),
+  skills: import_mini74.z.record(import_mini74.z.string(), LockedSkillSchema)
 });
-var SourcesLockSchema = import_mini73.z.object({
-  lockfileVersion: import_mini73.z.number(),
-  sources: import_mini73.z.record(import_mini73.z.string(), LockedSourceSchema)
+var SourcesLockSchema = import_mini74.z.object({
+  lockfileVersion: import_mini74.z.number(),
+  sources: import_mini74.z.record(import_mini74.z.string(), LockedSourceSchema)
 });
-var LegacyLockedSourceSchema = import_mini73.z.object({
-  resolvedRef: import_mini73.z.string(),
-  skills: import_mini73.z.array(import_mini73.z.string())
+var LegacyLockedSourceSchema = import_mini74.z.object({
+  resolvedRef: import_mini74.z.string(),
+  skills: import_mini74.z.array(import_mini74.z.string())
 });
-var LegacySourcesLockSchema = import_mini73.z.object({
-  sources: import_mini73.z.record(import_mini73.z.string(), LegacyLockedSourceSchema)
+var LegacySourcesLockSchema = import_mini74.z.object({
+  sources: import_mini74.z.record(import_mini74.z.string(), LegacyLockedSourceSchema)
 });
 function migrateLegacyLock(params) {
   const { legacy, logger: logger5 } = params;
@@ -22560,7 +23042,7 @@ function createEmptyLock() {
 }
 async function readLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path142.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
     logger5.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
@@ -22589,7 +23071,7 @@ async function readLockFile(params) {
 }
 async function writeLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path142.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   const content = JSON.stringify(params.lock, null, 2) + "\n";
   await writeFileContent(lockPath, content);
   logger5.debug(`Wrote sources lockfile to ${lockPath}`);
@@ -22763,7 +23245,7 @@ function logGitClientHints(params) {
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
-    if (!await directoryExists((0, import_node_path143.join)(curatedDir, name))) {
+    if (!await directoryExists((0, import_node_path145.join)(curatedDir, name))) {
       return false;
     }
   }
@@ -22771,10 +23253,10 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
 }
 async function cleanPreviousCuratedSkills(params) {
   const { curatedDir, lockedSkillNames, logger: logger5 } = params;
-  const resolvedCuratedDir = (0, import_node_path143.resolve)(curatedDir);
+  const resolvedCuratedDir = (0, import_node_path145.resolve)(curatedDir);
   for (const prevSkill of lockedSkillNames) {
-    const prevDir = (0, import_node_path143.join)(curatedDir, prevSkill);
-    if (!(0, import_node_path143.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path143.sep)) {
+    const prevDir = (0, import_node_path145.join)(curatedDir, prevSkill);
+    if (!(0, import_node_path145.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path145.sep)) {
       logger5.warn(
         `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
       );
@@ -22813,9 +23295,9 @@ async function writeSkillAndComputeIntegrity(params) {
   for (const file of files) {
     checkPathTraversal({
       relativePath: file.relativePath,
-      intendedRootDir: (0, import_node_path143.join)(curatedDir, skillName)
+      intendedRootDir: (0, import_node_path145.join)(curatedDir, skillName)
     });
-    await writeFileContent((0, import_node_path143.join)(curatedDir, skillName, file.relativePath), file.content);
+    await writeFileContent((0, import_node_path145.join)(curatedDir, skillName, file.relativePath), file.content);
     written.push({ path: file.relativePath, content: file.content });
   }
   const integrity = computeSkillIntegrity(written);
@@ -22892,7 +23374,7 @@ async function fetchSource(params) {
     ref = resolvedSha;
     logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
-  const curatedDir = (0, import_node_path143.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
@@ -23017,7 +23499,7 @@ async function fetchSourceViaGit(params) {
     requestedRef = def.ref;
     resolvedSha = def.sha;
   }
-  const curatedDir = (0, import_node_path143.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     if (await checkLockedSkillsExist(curatedDir, lockedSkillNames)) {
       return { skillCount: 0, fetchedSkillNames: lockedSkillNames, updatedLock: lock };
@@ -23133,11 +23615,11 @@ async function installCommand(logger5, options) {
 var import_fastmcp = require("fastmcp");
 // src/mcp/tools.ts
-var import_mini82 = require("zod/mini");
+var import_mini83 = require("zod/mini");
 // src/mcp/commands.ts
-var import_node_path144 = require("path");
-var import_mini74 = require("zod/mini");
+var import_node_path146 = require("path");
+var import_mini75 = require("zod/mini");
 // src/utils/logger.ts
 var BaseLogger = class {
@@ -23288,7 +23770,7 @@ var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23304,7 +23786,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23326,13 +23808,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23351,7 +23833,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -23361,7 +23843,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(
@@ -23378,11 +23860,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23397,12 +23879,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -23411,23 +23893,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini74.z.object({}),
-  getCommand: import_mini74.z.object({
-    relativePathFromCwd: import_mini74.z.string()
+  listCommands: import_mini75.z.object({}),
+  getCommand: import_mini75.z.object({
+    relativePathFromCwd: import_mini75.z.string()
   }),
-  putCommand: import_mini74.z.object({
-    relativePathFromCwd: import_mini74.z.string(),
+  putCommand: import_mini75.z.object({
+    relativePathFromCwd: import_mini75.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini74.z.string()
+    body: import_mini75.z.string()
   }),
-  deleteCommand: import_mini74.z.object({
-    relativePathFromCwd: import_mini74.z.string()
+  deleteCommand: import_mini75.z.object({
+    relativePathFromCwd: import_mini75.z.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -23469,15 +23951,15 @@ var commandTools = {
 };
 // src/mcp/generate.ts
-var import_mini75 = require("zod/mini");
-var generateOptionsSchema = import_mini75.z.object({
-  targets: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string())),
-  features: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string())),
-  delete: import_mini75.z.optional(import_mini75.z.boolean()),
-  global: import_mini75.z.optional(import_mini75.z.boolean()),
-  simulateCommands: import_mini75.z.optional(import_mini75.z.boolean()),
-  simulateSubagents: import_mini75.z.optional(import_mini75.z.boolean()),
-  simulateSkills: import_mini75.z.optional(import_mini75.z.boolean())
+var import_mini76 = require("zod/mini");
+var generateOptionsSchema = import_mini76.z.object({
+  targets: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string())),
+  features: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string())),
+  delete: import_mini76.z.optional(import_mini76.z.boolean()),
+  global: import_mini76.z.optional(import_mini76.z.boolean()),
+  simulateCommands: import_mini76.z.optional(import_mini76.z.boolean()),
+  simulateSubagents: import_mini76.z.optional(import_mini76.z.boolean()),
+  simulateSkills: import_mini76.z.optional(import_mini76.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -23556,11 +24038,11 @@ var generateTools = {
 };
 // src/mcp/ignore.ts
-var import_node_path145 = require("path");
-var import_mini76 = require("zod/mini");
+var import_node_path147 = require("path");
+var import_mini77 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -23577,7 +24059,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -23601,8 +24083,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -23620,11 +24102,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini76.z.object({}),
-  putIgnoreFile: import_mini76.z.object({
-    content: import_mini76.z.string()
+  getIgnoreFile: import_mini77.z.object({}),
+  putIgnoreFile: import_mini77.z.object({
+    content: import_mini77.z.string()
   }),
-  deleteIgnoreFile: import_mini76.z.object({})
+  deleteIgnoreFile: import_mini77.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -23657,11 +24139,11 @@ var ignoreTools = {
 };
 // src/mcp/import.ts
-var import_mini77 = require("zod/mini");
-var importOptionsSchema = import_mini77.z.object({
-  target: import_mini77.z.string(),
-  features: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
-  global: import_mini77.z.optional(import_mini77.z.boolean())
+var import_mini78 = require("zod/mini");
+var importOptionsSchema = import_mini78.z.object({
+  target: import_mini78.z.string(),
+  features: import_mini78.z.optional(import_mini78.z.array(import_mini78.z.string())),
+  global: import_mini78.z.optional(import_mini78.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -23732,15 +24214,15 @@ var importTools = {
 };
 // src/mcp/mcp.ts
-var import_node_path146 = require("path");
-var import_mini78 = require("zod/mini");
+var import_node_path148 = require("path");
+var import_mini79 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
     const rulesyncMcp = await RulesyncMcp.fromFile({
       validate: true
     });
-    const relativePathFromCwd = (0, import_node_path146.join)(
+    const relativePathFromCwd = (0, import_node_path148.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -23778,7 +24260,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path146.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path148.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -23786,9 +24268,9 @@ async function putMcpFile({ content }) {
       fileContent: content,
       validate: true
     });
-    await ensureDir((0, import_node_path146.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path148.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path146.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path148.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -23806,15 +24288,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path146.join)(
+    const recommendedPath = (0, import_node_path148.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path146.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path148.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path146.join)(
+    const relativePathFromCwd = (0, import_node_path148.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -23831,11 +24313,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini78.z.object({}),
-  putMcpFile: import_mini78.z.object({
-    content: import_mini78.z.string()
+  getMcpFile: import_mini79.z.object({}),
+  putMcpFile: import_mini79.z.object({
+    content: import_mini79.z.string()
   }),
-  deleteMcpFile: import_mini78.z.object({})
+  deleteMcpFile: import_mini79.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -23868,13 +24350,13 @@ var mcpTools = {
 };
 // src/mcp/rules.ts
-var import_node_path147 = require("path");
-var import_mini79 = require("zod/mini");
+var import_node_path149 = require("path");
+var import_mini80 = require("zod/mini");
 var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23887,7 +24369,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23909,14 +24391,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -23935,7 +24417,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -23945,7 +24427,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(
@@ -23960,11 +24442,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -23979,12 +24461,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -23993,23 +24475,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini79.z.object({}),
-  getRule: import_mini79.z.object({
-    relativePathFromCwd: import_mini79.z.string()
+  listRules: import_mini80.z.object({}),
+  getRule: import_mini80.z.object({
+    relativePathFromCwd: import_mini80.z.string()
   }),
-  putRule: import_mini79.z.object({
-    relativePathFromCwd: import_mini79.z.string(),
+  putRule: import_mini80.z.object({
+    relativePathFromCwd: import_mini80.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini79.z.string()
+    body: import_mini80.z.string()
   }),
-  deleteRule: import_mini79.z.object({
-    relativePathFromCwd: import_mini79.z.string()
+  deleteRule: import_mini80.z.object({
+    relativePathFromCwd: import_mini80.z.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -24051,8 +24533,8 @@ var ruleTools = {
 };
 // src/mcp/skills.ts
-var import_node_path148 = require("path");
-var import_mini80 = require("zod/mini");
+var import_node_path150 = require("path");
+var import_mini81 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -24069,19 +24551,19 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = (0, import_node_path148.basename)(relativeDirPathFromCwd);
+  const dirName = (0, import_node_path150.basename)(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs((0, import_node_path148.join)(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs((0, import_node_path150.join)(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = (0, import_node_path148.basename)(dirPath);
+        const dirName = (0, import_node_path150.basename)(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -24089,7 +24571,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -24117,7 +24599,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24151,7 +24633,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(
@@ -24168,9 +24650,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = (0, import_node_path148.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = (0, import_node_path150.join)(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -24178,15 +24660,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = (0, import_node_path148.join)(skillDirPath, file.name);
-      const fileDir = (0, import_node_path148.join)(skillDirPath, (0, import_node_path148.dirname)(file.name));
+      const filePath = (0, import_node_path150.join)(skillDirPath, file.name);
+      const fileDir = (0, import_node_path150.join)(skillDirPath, (0, import_node_path150.dirname)(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24208,13 +24690,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -24225,29 +24707,29 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini80.z.object({
-  name: import_mini80.z.string(),
-  body: import_mini80.z.string()
+var McpSkillFileSchema = import_mini81.z.object({
+  name: import_mini81.z.string(),
+  body: import_mini81.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini80.z.object({}),
-  getSkill: import_mini80.z.object({
-    relativeDirPathFromCwd: import_mini80.z.string()
+  listSkills: import_mini81.z.object({}),
+  getSkill: import_mini81.z.object({
+    relativeDirPathFromCwd: import_mini81.z.string()
   }),
-  putSkill: import_mini80.z.object({
-    relativeDirPathFromCwd: import_mini80.z.string(),
+  putSkill: import_mini81.z.object({
+    relativeDirPathFromCwd: import_mini81.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini80.z.string(),
-    otherFiles: import_mini80.z.optional(import_mini80.z.array(McpSkillFileSchema))
+    body: import_mini81.z.string(),
+    otherFiles: import_mini81.z.optional(import_mini81.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini80.z.object({
-    relativeDirPathFromCwd: import_mini80.z.string()
+  deleteSkill: import_mini81.z.object({
+    relativeDirPathFromCwd: import_mini81.z.string()
   })
 };
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${(0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${(0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -24290,13 +24772,13 @@ var skillTools = {
 };
 // src/mcp/subagents.ts
-var import_node_path149 = require("path");
-var import_mini81 = require("zod/mini");
+var import_node_path151 = require("path");
+var import_mini82 = require("zod/mini");
 var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -24309,7 +24791,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -24333,14 +24815,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24359,7 +24841,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -24369,7 +24851,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(
@@ -24384,11 +24866,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24403,12 +24885,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -24420,23 +24902,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini81.z.object({}),
-  getSubagent: import_mini81.z.object({
-    relativePathFromCwd: import_mini81.z.string()
+  listSubagents: import_mini82.z.object({}),
+  getSubagent: import_mini82.z.object({
+    relativePathFromCwd: import_mini82.z.string()
   }),
-  putSubagent: import_mini81.z.object({
-    relativePathFromCwd: import_mini81.z.string(),
+  putSubagent: import_mini82.z.object({
+    relativePathFromCwd: import_mini82.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini81.z.string()
+    body: import_mini82.z.string()
   }),
-  deleteSubagent: import_mini81.z.object({
-    relativePathFromCwd: import_mini81.z.string()
+  deleteSubagent: import_mini82.z.object({
+    relativePathFromCwd: import_mini82.z.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -24478,7 +24960,7 @@ var subagentTools = {
 };
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini82.z.enum([
+var rulesyncFeatureSchema = import_mini83.z.enum([
   "rule",
   "command",
   "subagent",
@@ -24488,21 +24970,21 @@ var rulesyncFeatureSchema = import_mini82.z.enum([
   "generate",
   "import"
 ]);
-var rulesyncOperationSchema = import_mini82.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini82.z.object({
-  name: import_mini82.z.string(),
-  body: import_mini82.z.string()
+var rulesyncOperationSchema = import_mini83.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini83.z.object({
+  name: import_mini83.z.string(),
+  body: import_mini83.z.string()
 });
-var rulesyncToolSchema = import_mini82.z.object({
+var rulesyncToolSchema = import_mini83.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini82.z.optional(import_mini82.z.string()),
-  frontmatter: import_mini82.z.optional(import_mini82.z.unknown()),
-  body: import_mini82.z.optional(import_mini82.z.string()),
-  otherFiles: import_mini82.z.optional(import_mini82.z.array(skillFileSchema)),
-  content: import_mini82.z.optional(import_mini82.z.string()),
-  generateOptions: import_mini82.z.optional(generateOptionsSchema),
-  importOptions: import_mini82.z.optional(importOptionsSchema)
+  targetPathFromCwd: import_mini83.z.optional(import_mini83.z.string()),
+  frontmatter: import_mini83.z.optional(import_mini83.z.unknown()),
+  body: import_mini83.z.optional(import_mini83.z.string()),
+  otherFiles: import_mini83.z.optional(import_mini83.z.array(skillFileSchema)),
+  content: import_mini83.z.optional(import_mini83.z.string()),
+  generateOptions: import_mini83.z.optional(generateOptionsSchema),
+  importOptions: import_mini83.z.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -24708,6 +25190,31 @@ async function mcpCommand(logger5, { version }) {
   });
 }
+// src/cli/commands/resolve-gitignore-targets.ts
+var import_node_path152 = require("path");
+var resolveGitignoreTargets = async ({
+  cliTargets,
+  cwd = process.cwd()
+}) => {
+  if (cliTargets !== void 0) {
+    return cliTargets;
+  }
+  const baseConfigPath = (0, import_node_path152.join)(cwd, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
+  const localConfigPath = (0, import_node_path152.join)(cwd, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
+  const [hasBase, hasLocal] = await Promise.all([
+    fileExists(baseConfigPath),
+    fileExists(localConfigPath)
+  ]);
+  if (!hasBase && !hasLocal) {
+    return void 0;
+  }
+  const config = await ConfigResolver.resolve({});
+  if (config.getGitignoreTargetsOnly()) {
+    return config.getTargets();
+  }
+  return void 0;
+};
 // src/lib/update.ts
 var crypto = __toESM(require("crypto"), 1);
 var fs = __toESM(require("fs"), 1);
@@ -25110,7 +25617,7 @@ function wrapCommand({
 }
 // src/cli/index.ts
-var getVersion = () => "7.30.0";
+var getVersion = () => "8.1.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }
@@ -25133,11 +25640,12 @@ var main = async () => {
     parseCommaSeparatedList
   ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
     wrapCommand2("gitignore", "GITIGNORE_FAILED", async (logger5, options) => {
+      const cliTargets = options.targets;
+      const cliFeatures = options.features;
+      const resolvedTargets = await resolveGitignoreTargets({ cliTargets });
       await gitignoreCommand(logger5, {
-        // eslint-disable-next-line no-type-assertion/no-type-assertion
-        targets: options.targets,
-        // eslint-disable-next-line no-type-assertion/no-type-assertion
-        features: options.features
+        targets: resolvedTargets ? [...resolvedTargets] : void 0,
+        features: cliFeatures
       });
     })
   );