rulesync 8.2.0 → 8.4.0

package/dist/cli/index.cjs

@@ -13262,6 +13262,17 @@ var CodexCliSubagentTomlSchema = import_mini51.z.looseObject({
   model_reasoning_effort: import_mini51.z.optional(import_mini51.z.string()),
   sandbox_mode: import_mini51.z.optional(import_mini51.z.string())
 });
+function stringifyCodexCliSubagentToml(tomlObj) {
+  const { developer_instructions, ...restFields } = tomlObj;
+  const restToml = smolToml4.stringify(restFields).trimEnd();
+  if (developer_instructions === void 0) {
+    return restToml;
+  }
+  const developerInstructionsToml = developer_instructions.includes("\n") ? developer_instructions.includes("'''") ? smolToml4.stringify({ developer_instructions }).trimEnd() : `developer_instructions = '''
+${developer_instructions}
+'''` : smolToml4.stringify({ developer_instructions }).trimEnd();
+  return [restToml, developerInstructionsToml].filter((value) => value.length > 0).join("\n");
+}
 var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
   body;
   constructor({ body, ...rest }) {
@@ -13338,7 +13349,7 @@ var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
       ...rulesyncSubagent.getBody() ? { developer_instructions: rulesyncSubagent.getBody() } : {},
       ...codexcliSection
     };
-    const body = smolToml4.stringify(tomlObj);
+    const body = stringifyCodexCliSubagentToml(tomlObj);
     const paths = this.getSettablePaths({ global });
     const relativeFilePath = rulesyncSubagent.getRelativeFilePath().replace(/\.md$/, ".toml");
     return new _CodexCliSubagent({
@@ -20473,11 +20484,11 @@ function getBaseDirsInLightOfGlobal({
 }
 
 // src/lib/generate.ts
-var import_node_path140 = require("path");
+var import_node_path141 = require("path");
 var import_es_toolkit5 = require("es-toolkit");
 
 // src/features/permissions/permissions-processor.ts
-var import_mini73 = require("zod/mini");
+var import_mini74 = require("zod/mini");
 
 // src/features/permissions/claudecode-permissions.ts
 var import_node_path136 = require("path");
@@ -20806,6 +20817,7 @@ function convertClaudeToRulesyncPermissions(params) {
 var import_node_path137 = require("path");
 var smolToml5 = __toESM(require("smol-toml"), 1);
 var RULESYNC_PROFILE_NAME = "rulesync";
+var RULESYNC_BASH_RULES_FILE_NAME = "rulesync.rules";
 var CodexcliPermissions = class _CodexcliPermissions extends ToolPermissions {
   static getSettablePaths(_options = {}) {
     return {
@@ -20895,6 +20907,22 @@ var CodexcliPermissions = class _CodexcliPermissions extends ToolPermissions {
     });
   }
 };
+var CodexcliRulesFile = class extends ToolFile {
+  validate() {
+    return { success: true, error: null };
+  }
+};
+function createCodexcliBashRulesFile({
+  baseDir = process.cwd(),
+  config
+}) {
+  return new CodexcliRulesFile({
+    baseDir,
+    relativeDirPath: (0, import_node_path137.join)(".codex", "rules"),
+    relativeFilePath: RULESYNC_BASH_RULES_FILE_NAME,
+    fileContent: buildCodexBashRulesContent(config)
+  });
+}
 function convertRulesyncToCodexProfile({
   config,
   logger: logger5
@@ -21003,6 +21031,46 @@ function mapReadAction(action) {
 function mapWriteAction(action) {
   return action === "allow" ? "write" : "none";
 }
+function buildCodexBashRulesContent(config) {
+  const bashRules = config.permission.bash ?? {};
+  const entries = Object.entries(bashRules);
+  const header = [
+    "# Generated by Rulesync from .rulesync/permissions.json (permission.bash)",
+    "# https://developers.openai.com/codex/rules"
+  ];
+  if (entries.length === 0) {
+    return [...header, "# No bash permission rules were configured."].join("\n");
+  }
+  const ruleBlocks = entries.map(([pattern, action]) => {
+    const tokens = toCommandPatternTokens(pattern);
+    if (tokens.length === 0) {
+      return null;
+    }
+    const serializedTokens = tokens.map((token) => JSON.stringify(token)).join(", ");
+    const decision = mapBashActionToDecision(action);
+    return [
+      "",
+      `# ${pattern}`,
+      "prefix_rule(",
+      `    pattern = [${serializedTokens}],`,
+      `    decision = ${JSON.stringify(decision)},`,
+      `    justification = ${JSON.stringify(`Generated from Rulesync permission.bash: ${pattern}`)},`,
+      ")"
+    ].join("\n");
+  }).filter((block) => block !== null);
+  if (ruleBlocks.length === 0) {
+    return [...header, "# No valid bash patterns were found."].join("\n");
+  }
+  return [...header, ...ruleBlocks].join("\n");
+}
+function toCommandPatternTokens(commandPattern) {
+  return commandPattern.trim().split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
+}
+function mapBashActionToDecision(action) {
+  if (action === "allow") return "allow";
+  if (action === "ask") return "prompt";
+  return "forbidden";
+}
 
 // src/features/permissions/geminicli-permissions.ts
 var import_node_path138 = require("path");
@@ -21168,16 +21236,200 @@ function parseGeminicliToolEntry({ entry }) {
   };
 }
 
-// src/features/permissions/opencode-permissions.ts
+// src/features/permissions/kiro-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 KiroAgentSchema = import_mini72.z.looseObject({
+  allowedTools: import_mini72.z.optional(import_mini72.z.array(import_mini72.z.string())),
+  toolsSettings: import_mini72.z.optional(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.unknown()))
+});
+var UnknownRecordSchema = import_mini72.z.record(import_mini72.z.string(), import_mini72.z.unknown());
+var KiroPermissions = class _KiroPermissions extends ToolPermissions {
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: (0, import_node_path139.join)(".kiro", "agents"),
+      relativeFilePath: "default.json"
+    };
+  }
+  isDeletable() {
+    return false;
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true
+  }) {
+    const paths = this.getSettablePaths();
+    const filePath = (0, import_node_path139.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    return new _KiroPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    validate = true,
+    logger: logger5
+  }) {
+    const paths = this.getSettablePaths();
+    const filePath = (0, import_node_path139.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    const parsedResult = KiroAgentSchema.safeParse(JSON.parse(existingContent));
+    if (!parsedResult.success) {
+      throw new Error(
+        `Failed to parse existing Kiro agent config at ${filePath}: ${formatError(parsedResult.error)}`
+      );
+    }
+    const config = rulesyncPermissions.getJson();
+    const next = buildKiroPermissionsFromRulesync({ config, logger: logger5, existing: parsedResult.data });
+    return new _KiroPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(next, null, 2),
+      validate
+    });
+  }
+  toRulesyncPermissions() {
+    let parsed;
+    try {
+      parsed = KiroAgentSchema.parse(JSON.parse(this.getFileContent()));
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Kiro permissions content in ${(0, import_node_path139.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const permission = {};
+    const toolsSettings = parsed.toolsSettings ?? {};
+    const shellSettings = asRecord(toolsSettings.shell);
+    const shellAllow = asStringArray(shellSettings.allowedCommands);
+    const shellDeny = asStringArray(shellSettings.deniedCommands);
+    if (shellAllow.length > 0 || shellDeny.length > 0) {
+      permission.bash = {};
+      for (const pattern of shellAllow) permission.bash[pattern] = "allow";
+      for (const pattern of shellDeny) permission.bash[pattern] = "deny";
+    }
+    const readSettings = asRecord(toolsSettings.read);
+    const readAllow = asStringArray(readSettings.allowedPaths);
+    const readDeny = asStringArray(readSettings.deniedPaths);
+    if (readAllow.length > 0 || readDeny.length > 0) {
+      permission.read = {};
+      for (const pattern of readAllow) permission.read[pattern] = "allow";
+      for (const pattern of readDeny) permission.read[pattern] = "deny";
+    }
+    const writeSettings = asRecord(toolsSettings.write);
+    const writeAllow = asStringArray(writeSettings.allowedPaths);
+    const writeDeny = asStringArray(writeSettings.deniedPaths);
+    if (writeAllow.length > 0 || writeDeny.length > 0) {
+      permission.write = {};
+      for (const pattern of writeAllow) permission.write[pattern] = "allow";
+      for (const pattern of writeDeny) permission.write[pattern] = "deny";
+    }
+    const allowedTools = new Set(parsed.allowedTools ?? []);
+    if (allowedTools.has("web_fetch")) {
+      permission.webfetch = { "*": "allow" };
+    }
+    if (allowedTools.has("web_search")) {
+      permission.websearch = { "*": "allow" };
+    }
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify({ permission }, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _KiroPermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify({}, null, 2),
+      validate: false
+    });
+  }
+};
+function buildKiroPermissionsFromRulesync({
+  config,
+  logger: logger5,
+  existing
+}) {
+  const nextAllowedTools = new Set(existing.allowedTools ?? []);
+  const nextToolsSettings = { ...asRecord(existing.toolsSettings) };
+  const shell = {
+    allowedCommands: [],
+    deniedCommands: []
+  };
+  const read = {
+    allowedPaths: [],
+    deniedPaths: []
+  };
+  const write = {
+    allowedPaths: [],
+    deniedPaths: []
+  };
+  for (const [category, rules] of Object.entries(config.permission)) {
+    for (const [pattern, action] of Object.entries(rules)) {
+      if (action === "ask") {
+        logger5?.warn(`Kiro permissions do not support "ask". Skipping ${category}:${pattern}`);
+        continue;
+      }
+      if (category === "bash") {
+        (action === "allow" ? shell.allowedCommands : shell.deniedCommands).push(pattern);
+      } else if (category === "read") {
+        (action === "allow" ? read.allowedPaths : read.deniedPaths).push(pattern);
+      } else if (category === "edit" || category === "write") {
+        (action === "allow" ? write.allowedPaths : write.deniedPaths).push(pattern);
+      } else if (category === "webfetch" || category === "websearch") {
+        if (pattern !== "*") {
+          logger5?.warn(
+            `Kiro ${category} supports only wildcard (*) via allowedTools. Skipping rule: ${pattern}`
+          );
+          continue;
+        }
+        if (action === "allow")
+          nextAllowedTools.add(category === "webfetch" ? "web_fetch" : "web_search");
+      } else {
+        logger5?.warn(`Kiro permissions do not support category: ${category}. Skipping.`);
+      }
+    }
+  }
+  nextToolsSettings.shell = shell;
+  nextToolsSettings.read = read;
+  nextToolsSettings.write = write;
+  return {
+    ...existing,
+    allowedTools: [...nextAllowedTools].toSorted(),
+    toolsSettings: nextToolsSettings
+  };
+}
+function asRecord(value) {
+  const result = UnknownRecordSchema.safeParse(value);
+  return result.success ? result.data : {};
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+// src/features/permissions/opencode-permissions.ts
+var import_node_path140 = require("path");
+var import_jsonc_parser5 = require("jsonc-parser");
+var import_mini73 = require("zod/mini");
+var OpencodePermissionSchema = import_mini73.z.union([
+  import_mini73.z.enum(["allow", "ask", "deny"]),
+  import_mini73.z.record(import_mini73.z.string(), import_mini73.z.enum(["allow", "ask", "deny"]))
 ]);
-var OpencodePermissionsConfigSchema = import_mini72.z.looseObject({
-  permission: import_mini72.z.optional(import_mini72.z.record(import_mini72.z.string(), OpencodePermissionSchema))
+var OpencodePermissionsConfigSchema = import_mini73.z.looseObject({
+  permission: import_mini73.z.optional(import_mini73.z.record(import_mini73.z.string(), OpencodePermissionSchema))
 });
 var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   json;
@@ -21194,7 +21446,7 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   static getSettablePaths({
     global = false
   } = {}) {
-    return global ? { relativeDirPath: (0, import_node_path139.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
+    return global ? { relativeDirPath: (0, import_node_path140.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
   }
   static async fromFile({
     baseDir = process.cwd(),
@@ -21202,9 +21454,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    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");
+    const jsonDir = (0, import_node_path140.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path140.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path140.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -21229,9 +21481,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    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");
+    const jsonDir = (0, import_node_path140.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path140.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path140.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -21305,9 +21557,10 @@ var permissionsProcessorToolTargetTuple = [
   "claudecode",
   "codexcli",
   "geminicli",
+  "kiro",
   "opencode"
 ];
-var PermissionsProcessorToolTargetSchema = import_mini73.z.enum(permissionsProcessorToolTargetTuple);
+var PermissionsProcessorToolTargetSchema = import_mini74.z.enum(permissionsProcessorToolTargetTuple);
 var toolPermissionsFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -21315,7 +21568,7 @@ var toolPermissionsFactories = /* @__PURE__ */ new Map([
       class: ClaudecodePermissions,
       meta: {
         supportsProject: true,
-        supportsGlobal: false,
+        supportsGlobal: true,
         supportsImport: true
       }
     }
@@ -21342,6 +21595,17 @@ var toolPermissionsFactories = /* @__PURE__ */ new Map([
       }
     }
   ],
+  [
+    "kiro",
+    {
+      class: KiroPermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: false,
+        supportsImport: true
+      }
+    }
+  ],
   [
     "opencode",
     {
@@ -21437,7 +21701,14 @@ var PermissionsProcessor = class extends FeatureProcessor {
       logger: this.logger,
       global: this.global
     });
-    return [toolPermissions];
+    if (this.toolTarget !== "codexcli") {
+      return [toolPermissions];
+    }
+    const bashRulesFile = createCodexcliBashRulesFile({
+      baseDir: this.baseDir,
+      config: rulesyncPermissions.getJson()
+    });
+    return [toolPermissions, bashRulesFile];
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
     const permissions = toolFiles.filter((f) => f instanceof ToolPermissions);
@@ -21524,7 +21795,7 @@ function warnUnsupportedTargets(params) {
   }
 }
 async function checkRulesyncDirExists(params) {
-  return fileExists((0, import_node_path140.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
+  return fileExists((0, import_node_path141.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
 async function generate(params) {
   const { config, logger: logger5 } = params;
@@ -21994,7 +22265,7 @@ async function generateCommand(logger5, options) {
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_path141 = require("path");
+var import_node_path142 = require("path");
 
 // src/cli/commands/gitignore-entries.ts
 var normalizeGitignoreEntryTargets = (target) => {
@@ -22338,7 +22609,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async (logger5, options) => {
-  const gitignorePath = (0, import_node_path141.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path142.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -22705,7 +22976,7 @@ async function importCommand(logger5, options) {
 }
 
 // src/lib/init.ts
-var import_node_path142 = require("path");
+var import_node_path143 = require("path");
 async function init() {
   const sampleFiles = await createSampleFiles();
   const configFile = await createConfigFile();
@@ -22898,27 +23169,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_path142.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path143.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   results.push(await writeIfNotExists(ruleFilepath, sampleRuleFile.content));
-  const mcpFilepath = (0, import_node_path142.join)(
+  const mcpFilepath = (0, import_node_path143.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(mcpFilepath, sampleMcpFile.content));
-  const commandFilepath = (0, import_node_path142.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path143.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
   results.push(await writeIfNotExists(commandFilepath, sampleCommandFile.content));
-  const subagentFilepath = (0, import_node_path142.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path143.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   results.push(await writeIfNotExists(subagentFilepath, sampleSubagentFile.content));
-  const skillDirPath = (0, import_node_path142.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = (0, import_node_path143.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = (0, import_node_path142.join)(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = (0, import_node_path143.join)(skillDirPath, SKILL_FILE_NAME);
   results.push(await writeIfNotExists(skillFilepath, sampleSkillFile.content));
-  const ignoreFilepath = (0, import_node_path142.join)(
+  const ignoreFilepath = (0, import_node_path143.join)(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(ignoreFilepath, sampleIgnoreFile.content));
-  const hooksFilepath = (0, import_node_path142.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
+  const hooksFilepath = (0, import_node_path143.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
   results.push(await writeIfNotExists(hooksFilepath, sampleHooksFile.content));
   return results;
 }
@@ -22966,12 +23237,12 @@ async function initCommand(logger5) {
 }
 
 // src/lib/sources.ts
-var import_node_path145 = require("path");
+var import_node_path146 = 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_path143 = require("path");
+var import_node_path144 = 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;
@@ -23059,7 +23330,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_path143.isAbsolute)(skillsPath)) {
+  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path144.isAbsolute)(skillsPath)) {
     throw new GitClientError(
       `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
     );
@@ -23093,7 +23364,7 @@ async function fetchSkillFiles(params) {
       timeout: GIT_TIMEOUT_MS
     });
     await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
-    const skillsDir = (0, import_node_path143.join)(tmpDir, skillsPath);
+    const skillsDir = (0, import_node_path144.join)(tmpDir, skillsPath);
     if (!await directoryExists(skillsDir)) return [];
     return await walkDirectory(skillsDir, skillsDir, 0, { totalFiles: 0, totalSize: 0 }, logger5);
   } catch (error) {
@@ -23115,7 +23386,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_path143.join)(dir, name);
+    const fullPath = (0, import_node_path144.join)(dir, name);
     if (await isSymlink(fullPath)) {
       logger5?.warn(`Skipping symlink "${fullPath}".`);
       continue;
@@ -23143,7 +23414,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
         );
       }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: (0, import_node_path143.relative)(baseDir, fullPath), content, size });
+      results.push({ relativePath: (0, import_node_path144.relative)(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -23151,28 +23422,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_path144 = require("path");
-var import_mini74 = require("zod/mini");
+var import_node_path145 = require("path");
+var import_mini75 = require("zod/mini");
 var LOCKFILE_VERSION = 1;
-var LockedSkillSchema = import_mini74.z.object({
-  integrity: import_mini74.z.string()
+var LockedSkillSchema = import_mini75.z.object({
+  integrity: import_mini75.z.string()
 });
-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 LockedSourceSchema = import_mini75.z.object({
+  requestedRef: (0, import_mini75.optional)(import_mini75.z.string()),
+  resolvedRef: import_mini75.z.string().check((0, import_mini75.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
+  resolvedAt: (0, import_mini75.optional)(import_mini75.z.string()),
+  skills: import_mini75.z.record(import_mini75.z.string(), LockedSkillSchema)
 });
-var SourcesLockSchema = import_mini74.z.object({
-  lockfileVersion: import_mini74.z.number(),
-  sources: import_mini74.z.record(import_mini74.z.string(), LockedSourceSchema)
+var SourcesLockSchema = import_mini75.z.object({
+  lockfileVersion: import_mini75.z.number(),
+  sources: import_mini75.z.record(import_mini75.z.string(), LockedSourceSchema)
 });
-var LegacyLockedSourceSchema = import_mini74.z.object({
-  resolvedRef: import_mini74.z.string(),
-  skills: import_mini74.z.array(import_mini74.z.string())
+var LegacyLockedSourceSchema = import_mini75.z.object({
+  resolvedRef: import_mini75.z.string(),
+  skills: import_mini75.z.array(import_mini75.z.string())
 });
-var LegacySourcesLockSchema = import_mini74.z.object({
-  sources: import_mini74.z.record(import_mini74.z.string(), LegacyLockedSourceSchema)
+var LegacySourcesLockSchema = import_mini75.z.object({
+  sources: import_mini75.z.record(import_mini75.z.string(), LegacyLockedSourceSchema)
 });
 function migrateLegacyLock(params) {
   const { legacy, logger: logger5 } = params;
@@ -23197,7 +23468,7 @@ function createEmptyLock() {
 }
 async function readLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path145.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
     logger5.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
@@ -23226,7 +23497,7 @@ async function readLockFile(params) {
 }
 async function writeLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path145.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}`);
@@ -23400,7 +23671,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_path145.join)(curatedDir, name))) {
+    if (!await directoryExists((0, import_node_path146.join)(curatedDir, name))) {
       return false;
     }
   }
@@ -23408,10 +23679,10 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
 }
 async function cleanPreviousCuratedSkills(params) {
   const { curatedDir, lockedSkillNames, logger: logger5 } = params;
-  const resolvedCuratedDir = (0, import_node_path145.resolve)(curatedDir);
+  const resolvedCuratedDir = (0, import_node_path146.resolve)(curatedDir);
   for (const prevSkill of lockedSkillNames) {
-    const prevDir = (0, import_node_path145.join)(curatedDir, prevSkill);
-    if (!(0, import_node_path145.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path145.sep)) {
+    const prevDir = (0, import_node_path146.join)(curatedDir, prevSkill);
+    if (!(0, import_node_path146.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path146.sep)) {
       logger5.warn(
         `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
       );
@@ -23450,9 +23721,9 @@ async function writeSkillAndComputeIntegrity(params) {
   for (const file of files) {
     checkPathTraversal({
       relativePath: file.relativePath,
-      intendedRootDir: (0, import_node_path145.join)(curatedDir, skillName)
+      intendedRootDir: (0, import_node_path146.join)(curatedDir, skillName)
     });
-    await writeFileContent((0, import_node_path145.join)(curatedDir, skillName, file.relativePath), file.content);
+    await writeFileContent((0, import_node_path146.join)(curatedDir, skillName, file.relativePath), file.content);
     written.push({ path: file.relativePath, content: file.content });
   }
   const integrity = computeSkillIntegrity(written);
@@ -23529,7 +23800,7 @@ async function fetchSource(params) {
     ref = resolvedSha;
     logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
-  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path146.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
@@ -23654,7 +23925,7 @@ async function fetchSourceViaGit(params) {
     requestedRef = def.ref;
     resolvedSha = def.sha;
   }
-  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path146.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 };
@@ -23770,11 +24041,11 @@ async function installCommand(logger5, options) {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini83 = require("zod/mini");
+var import_mini84 = require("zod/mini");
 
 // src/mcp/commands.ts
-var import_node_path146 = require("path");
-var import_mini75 = require("zod/mini");
+var import_node_path147 = require("path");
+var import_mini76 = require("zod/mini");
 
 // src/utils/logger.ts
 var BaseLogger = class {
@@ -23925,7 +24196,7 @@ var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23941,7 +24212,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23963,13 +24234,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23988,7 +24259,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -23998,7 +24269,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(
@@ -24015,11 +24286,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -24034,12 +24305,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path147.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -24048,23 +24319,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini75.z.object({}),
-  getCommand: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string()
+  listCommands: import_mini76.z.object({}),
+  getCommand: import_mini76.z.object({
+    relativePathFromCwd: import_mini76.z.string()
   }),
-  putCommand: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string(),
+  putCommand: import_mini76.z.object({
+    relativePathFromCwd: import_mini76.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini75.z.string()
+    body: import_mini76.z.string()
   }),
-  deleteCommand: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string()
+  deleteCommand: import_mini76.z.object({
+    relativePathFromCwd: import_mini76.z.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -24106,15 +24377,15 @@ var commandTools = {
 };
 
 // src/mcp/generate.ts
-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())
+var import_mini77 = require("zod/mini");
+var generateOptionsSchema = import_mini77.z.object({
+  targets: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
+  features: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
+  delete: import_mini77.z.optional(import_mini77.z.boolean()),
+  global: import_mini77.z.optional(import_mini77.z.boolean()),
+  simulateCommands: import_mini77.z.optional(import_mini77.z.boolean()),
+  simulateSubagents: import_mini77.z.optional(import_mini77.z.boolean()),
+  simulateSkills: import_mini77.z.optional(import_mini77.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -24193,11 +24464,11 @@ var generateTools = {
 };
 
 // src/mcp/ignore.ts
-var import_node_path147 = require("path");
-var import_mini77 = require("zod/mini");
+var import_node_path148 = require("path");
+var import_mini78 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -24214,7 +24485,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -24238,8 +24509,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  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);
+  const aiignorePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -24257,11 +24528,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini77.z.object({}),
-  putIgnoreFile: import_mini77.z.object({
-    content: import_mini77.z.string()
+  getIgnoreFile: import_mini78.z.object({}),
+  putIgnoreFile: import_mini78.z.object({
+    content: import_mini78.z.string()
   }),
-  deleteIgnoreFile: import_mini77.z.object({})
+  deleteIgnoreFile: import_mini78.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -24294,11 +24565,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-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())
+var import_mini79 = require("zod/mini");
+var importOptionsSchema = import_mini79.z.object({
+  target: import_mini79.z.string(),
+  features: import_mini79.z.optional(import_mini79.z.array(import_mini79.z.string())),
+  global: import_mini79.z.optional(import_mini79.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -24369,15 +24640,15 @@ var importTools = {
 };
 
 // src/mcp/mcp.ts
-var import_node_path148 = require("path");
-var import_mini79 = require("zod/mini");
+var import_node_path149 = require("path");
+var import_mini80 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
     const rulesyncMcp = await RulesyncMcp.fromFile({
       validate: true
     });
-    const relativePathFromCwd = (0, import_node_path148.join)(
+    const relativePathFromCwd = (0, import_node_path149.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -24415,7 +24686,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path148.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path149.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -24423,9 +24694,9 @@ async function putMcpFile({ content }) {
       fileContent: content,
       validate: true
     });
-    await ensureDir((0, import_node_path148.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path149.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path148.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path149.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -24443,15 +24714,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path148.join)(
+    const recommendedPath = (0, import_node_path149.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path148.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path149.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path148.join)(
+    const relativePathFromCwd = (0, import_node_path149.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -24468,11 +24739,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini79.z.object({}),
-  putMcpFile: import_mini79.z.object({
-    content: import_mini79.z.string()
+  getMcpFile: import_mini80.z.object({}),
+  putMcpFile: import_mini80.z.object({
+    content: import_mini80.z.string()
   }),
-  deleteMcpFile: import_mini79.z.object({})
+  deleteMcpFile: import_mini80.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -24505,13 +24776,13 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-var import_node_path149 = require("path");
-var import_mini80 = require("zod/mini");
+var import_node_path150 = require("path");
+var import_mini81 = 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_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -24524,7 +24795,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -24546,14 +24817,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path150.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -24572,7 +24843,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path150.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -24582,7 +24853,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(
@@ -24597,11 +24868,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -24616,12 +24887,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path150.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -24630,23 +24901,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini80.z.object({}),
-  getRule: import_mini80.z.object({
-    relativePathFromCwd: import_mini80.z.string()
+  listRules: import_mini81.z.object({}),
+  getRule: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string()
   }),
-  putRule: import_mini80.z.object({
-    relativePathFromCwd: import_mini80.z.string(),
+  putRule: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini80.z.string()
+    body: import_mini81.z.string()
   }),
-  deleteRule: import_mini80.z.object({
-    relativePathFromCwd: import_mini80.z.string()
+  deleteRule: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -24688,8 +24959,8 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-var import_node_path150 = require("path");
-var import_mini81 = require("zod/mini");
+var import_node_path151 = require("path");
+var import_mini82 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -24706,19 +24977,19 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = (0, import_node_path150.basename)(relativeDirPathFromCwd);
+  const dirName = (0, import_node_path151.basename)(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs((0, import_node_path150.join)(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs((0, import_node_path151.join)(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = (0, import_node_path150.basename)(dirPath);
+        const dirName = (0, import_node_path151.basename)(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -24726,7 +24997,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -24754,7 +25025,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24788,7 +25059,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(
@@ -24805,9 +25076,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = (0, import_node_path150.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = (0, import_node_path151.join)(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -24815,15 +25086,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      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));
+      const filePath = (0, import_node_path151.join)(skillDirPath, file.name);
+      const fileDir = (0, import_node_path151.join)(skillDirPath, (0, import_node_path151.dirname)(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24845,13 +25116,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -24862,29 +25133,29 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini81.z.object({
-  name: import_mini81.z.string(),
-  body: import_mini81.z.string()
+var McpSkillFileSchema = import_mini82.z.object({
+  name: import_mini82.z.string(),
+  body: import_mini82.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini81.z.object({}),
-  getSkill: import_mini81.z.object({
-    relativeDirPathFromCwd: import_mini81.z.string()
+  listSkills: import_mini82.z.object({}),
+  getSkill: import_mini82.z.object({
+    relativeDirPathFromCwd: import_mini82.z.string()
   }),
-  putSkill: import_mini81.z.object({
-    relativeDirPathFromCwd: import_mini81.z.string(),
+  putSkill: import_mini82.z.object({
+    relativeDirPathFromCwd: import_mini82.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini81.z.string(),
-    otherFiles: import_mini81.z.optional(import_mini81.z.array(McpSkillFileSchema))
+    body: import_mini82.z.string(),
+    otherFiles: import_mini82.z.optional(import_mini82.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini81.z.object({
-    relativeDirPathFromCwd: import_mini81.z.string()
+  deleteSkill: import_mini82.z.object({
+    relativeDirPathFromCwd: import_mini82.z.string()
   })
 };
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${(0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${(0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -24927,13 +25198,13 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-var import_node_path151 = require("path");
-var import_mini82 = require("zod/mini");
+var import_node_path152 = require("path");
+var import_mini83 = 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_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path152.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -24946,7 +25217,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -24970,14 +25241,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path152.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24996,7 +25267,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path152.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -25006,7 +25277,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(
@@ -25021,11 +25292,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path152.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -25040,12 +25311,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path152.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path152.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -25057,23 +25328,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini82.z.object({}),
-  getSubagent: import_mini82.z.object({
-    relativePathFromCwd: import_mini82.z.string()
+  listSubagents: import_mini83.z.object({}),
+  getSubagent: import_mini83.z.object({
+    relativePathFromCwd: import_mini83.z.string()
   }),
-  putSubagent: import_mini82.z.object({
-    relativePathFromCwd: import_mini82.z.string(),
+  putSubagent: import_mini83.z.object({
+    relativePathFromCwd: import_mini83.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini82.z.string()
+    body: import_mini83.z.string()
   }),
-  deleteSubagent: import_mini82.z.object({
-    relativePathFromCwd: import_mini82.z.string()
+  deleteSubagent: import_mini83.z.object({
+    relativePathFromCwd: import_mini83.z.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -25115,7 +25386,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini83.z.enum([
+var rulesyncFeatureSchema = import_mini84.z.enum([
   "rule",
   "command",
   "subagent",
@@ -25125,21 +25396,21 @@ var rulesyncFeatureSchema = import_mini83.z.enum([
   "generate",
   "import"
 ]);
-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 rulesyncOperationSchema = import_mini84.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini84.z.object({
+  name: import_mini84.z.string(),
+  body: import_mini84.z.string()
 });
-var rulesyncToolSchema = import_mini83.z.object({
+var rulesyncToolSchema = import_mini84.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  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)
+  targetPathFromCwd: import_mini84.z.optional(import_mini84.z.string()),
+  frontmatter: import_mini84.z.optional(import_mini84.z.unknown()),
+  body: import_mini84.z.optional(import_mini84.z.string()),
+  otherFiles: import_mini84.z.optional(import_mini84.z.array(skillFileSchema)),
+  content: import_mini84.z.optional(import_mini84.z.string()),
+  generateOptions: import_mini84.z.optional(generateOptionsSchema),
+  importOptions: import_mini84.z.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -25346,7 +25617,7 @@ async function mcpCommand(logger5, { version }) {
 }
 
 // src/cli/commands/resolve-gitignore-targets.ts
-var import_node_path152 = require("path");
+var import_node_path153 = require("path");
 var resolveGitignoreTargets = async ({
   cliTargets,
   cwd = process.cwd()
@@ -25354,8 +25625,8 @@ var resolveGitignoreTargets = async ({
   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 baseConfigPath = (0, import_node_path153.join)(cwd, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
+  const localConfigPath = (0, import_node_path153.join)(cwd, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
   const [hasBase, hasLocal] = await Promise.all([
     fileExists(baseConfigPath),
     fileExists(localConfigPath)
@@ -25776,7 +26047,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.2.0";
+var getVersion = () => "8.4.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }