rulesync 3.23.6 → 3.24.0

package/dist/index.js

@@ -8,7 +8,7 @@ var ANNOUNCEMENT = "".trim();
 
 // src/types/features.ts
 import { z } from "zod/mini";
-var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
+var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands", "skills"];
 var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 var FeatureSchema = z.enum(ALL_FEATURES);
 var FeaturesSchema = z.array(FeatureSchema);
@@ -137,6 +137,10 @@ async function readFileContent(filepath) {
   logger.debug(`Reading file: ${filepath}`);
   return readFile(filepath, "utf-8");
 }
+async function readFileBuffer(filepath) {
+  logger.debug(`Reading file buffer: ${filepath}`);
+  return readFile(filepath);
+}
 function addTrailingNewline(content) {
   if (!content) {
     return "\n";
@@ -164,11 +168,32 @@ async function listDirectoryFiles(dir) {
   }
 }
 async function findFilesByGlobs(globs, options = {}) {
+  const { type = "all" } = options;
   const items = globSync(globs, { withFileTypes: true });
-  if (!options.fileOnly) {
-    return items.map((item) => join(item.parentPath, item.name));
+  switch (type) {
+    case "file":
+      return items.filter((item) => item.isFile()).map((item) => join(item.parentPath, item.name));
+    case "dir":
+      return items.filter((item) => item.isDirectory()).map((item) => join(item.parentPath, item.name));
+    case "all":
+      return items.map((item) => join(item.parentPath, item.name));
+    default:
+      throw new Error(`Invalid type: ${type}`);
+  }
+}
+async function removeDirectory(dirPath) {
+  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
+  if (dangerousPaths.includes(dirPath) || dirPath === "") {
+    logger.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    return;
+  }
+  try {
+    if (await fileExists(dirPath)) {
+      await rm(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    logger.warn(`Failed to remove directory ${dirPath}:`, error);
   }
-  return items.filter((item) => item.isFile()).map((item) => join(item.parentPath, item.name));
 }
 async function removeFile(filepath) {
   logger.debug(`Removing file: ${filepath}`);
@@ -1674,7 +1699,7 @@ var CommandsProcessor = class extends FeatureProcessor {
     );
     const rulesyncCommands = (await Promise.allSettled(
       rulesyncCommandPaths.map(
-        (path2) => RulesyncCommand.fromFile({ relativeFilePath: basename11(path2) })
+        (path3) => RulesyncCommand.fromFile({ relativeFilePath: basename11(path3) })
       )
     )).filter((result) => result.status === "fulfilled").map((result) => result.value);
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
@@ -1716,45 +1741,45 @@ var CommandsProcessor = class extends FeatureProcessor {
       join12(this.baseDir, relativeDirPath, `*.${extension}`)
     );
     const toolCommands = (await Promise.allSettled(
-      commandFilePaths.map((path2) => {
+      commandFilePaths.map((path3) => {
         switch (toolTarget) {
           case "agentsmd":
             return AgentsmdCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2)
+              relativeFilePath: basename11(path3)
             });
           case "claudecode":
             return ClaudecodeCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           case "geminicli":
             return GeminiCliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           case "roo":
             return RooCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2)
+              relativeFilePath: basename11(path3)
             });
           case "copilot":
             return CopilotCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2)
+              relativeFilePath: basename11(path3)
             });
           case "cursor":
             return CursorCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           case "codexcli":
             return CodexcliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           default:
@@ -4547,7 +4572,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
     fromFile
   }) {
     const paths = await findFilesByGlobs(join44(this.baseDir, relativeDirPath, "*.md"));
-    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename14(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+    const subagents = (await Promise.allSettled(paths.map((path3) => fromFile(basename14(path3))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
     logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
     return subagents;
   }
@@ -7069,6 +7094,614 @@ For example, if the user instructs \`Call planner subagent to plan the refactori
   }
 };
 
+// src/features/skills/skills-processor.ts
+import { basename as basename19, join as join69 } from "path";
+import { z as z27 } from "zod/mini";
+
+// src/types/dir-feature-processor.ts
+import { join as join65 } from "path";
+var DirFeatureProcessor = class {
+  baseDir;
+  constructor({ baseDir = process.cwd() }) {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Return tool targets that this feature supports.
+   */
+  static getToolTargets(_params = {}) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Once converted to rulesync/tool dirs, write them to the filesystem.
+   * Returns the number of directories written.
+   */
+  async writeAiDirs(aiDirs) {
+    for (const aiDir of aiDirs) {
+      const dirPath = aiDir.getDirPath();
+      await ensureDir(dirPath);
+      const mainFile = aiDir.getMainFile();
+      if (mainFile) {
+        const mainFilePath = join65(dirPath, mainFile.name);
+        const contentWithNewline = addTrailingNewline(mainFile.body);
+        await writeFileContent(mainFilePath, contentWithNewline);
+      }
+      const otherFiles = aiDir.getOtherFiles();
+      for (const file of otherFiles) {
+        const filePath = join65(dirPath, file.relativeFilePathToDirPath);
+        const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
+        await writeFileContent(filePath, contentWithNewline);
+      }
+    }
+    return aiDirs.length;
+  }
+  async removeAiDirs(aiDirs) {
+    for (const aiDir of aiDirs) {
+      await removeDirectory(aiDir.getDirPath());
+    }
+  }
+};
+
+// src/features/skills/claudecode-skill.ts
+import { join as join68 } from "path";
+import { z as z26 } from "zod/mini";
+
+// src/constants/general.ts
+var SKILL_FILE_NAME = "SKILL.md";
+
+// src/features/skills/rulesync-skill.ts
+import { join as join67 } from "path";
+import { z as z25 } from "zod/mini";
+
+// src/types/ai-dir.ts
+import path2, { basename as basename18, join as join66, relative as relative3, resolve as resolve4 } from "path";
+var AiDir = class {
+  /**
+   * @example "."
+   */
+  baseDir;
+  /**
+   * @example ".rulesync/skills"
+   */
+  relativeDirPath;
+  /**
+   * @example "my-skill"
+   */
+  dirName;
+  /**
+   * Optional main file with frontmatter support
+   */
+  mainFile;
+  /**
+   * Additional files in the directory
+   */
+  otherFiles;
+  /**
+   * @example false
+   */
+  global;
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    mainFile,
+    otherFiles = [],
+    global = false
+  }) {
+    if (dirName.includes(path2.sep) || dirName.includes("/") || dirName.includes("\\")) {
+      throw new Error(`Directory name cannot contain path separators: dirName="${dirName}"`);
+    }
+    this.baseDir = baseDir;
+    this.relativeDirPath = relativeDirPath;
+    this.dirName = dirName;
+    this.mainFile = mainFile;
+    this.otherFiles = otherFiles;
+    this.global = global;
+  }
+  static async fromDir(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  getBaseDir() {
+    return this.baseDir;
+  }
+  getRelativeDirPath() {
+    return this.relativeDirPath;
+  }
+  getDirName() {
+    return this.dirName;
+  }
+  getDirPath() {
+    const fullPath = path2.join(this.baseDir, this.relativeDirPath, this.dirName);
+    const resolvedFull = resolve4(fullPath);
+    const resolvedBase = resolve4(this.baseDir);
+    const rel = relative3(resolvedBase, resolvedFull);
+    if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+      throw new Error(
+        `Path traversal detected: Final path escapes baseDir. baseDir="${this.baseDir}", relativeDirPath="${this.relativeDirPath}", dirName="${this.dirName}"`
+      );
+    }
+    return fullPath;
+  }
+  getMainFile() {
+    return this.mainFile;
+  }
+  getOtherFiles() {
+    return this.otherFiles;
+  }
+  getRelativePathFromCwd() {
+    return path2.join(this.relativeDirPath, this.dirName);
+  }
+  getGlobal() {
+    return this.global;
+  }
+  setMainFile(name, body, frontmatter) {
+    this.mainFile = { name, body, frontmatter };
+  }
+  /**
+   * Recursively collects all files from a directory, excluding the specified main file.
+   * This is a common utility for loading additional files alongside the main file.
+   *
+   * @param baseDir - The base directory path
+   * @param relativeDirPath - The relative path to the directory containing the skill
+   * @param dirName - The name of the directory
+   * @param excludeFileName - The name of the file to exclude (typically the main file)
+   * @returns Array of files with their relative paths and buffers
+   */
+  static async collectOtherFiles(baseDir, relativeDirPath, dirName, excludeFileName) {
+    const dirPath = join66(baseDir, relativeDirPath, dirName);
+    const glob = join66(dirPath, "**", "*");
+    const filePaths = await findFilesByGlobs(glob, { type: "file" });
+    const filteredPaths = filePaths.filter((filePath) => basename18(filePath) !== excludeFileName);
+    const files = await Promise.all(
+      filteredPaths.map(async (filePath) => {
+        const fileBuffer = await readFileBuffer(filePath);
+        return {
+          relativeFilePathToDirPath: relative3(dirPath, filePath),
+          fileBuffer
+        };
+      })
+    );
+    return files;
+  }
+};
+
+// src/features/skills/rulesync-skill.ts
+var RulesyncSkillFrontmatterSchema = z25.object({
+  name: z25.string(),
+  description: z25.string(),
+  claudecode: z25.optional(
+    z25.object({
+      "allowed-tools": z25.optional(z25.array(z25.string()))
+    })
+  )
+});
+var RulesyncSkill = class _RulesyncSkill extends AiDir {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+    dirName,
+    frontmatter,
+    body,
+    otherFiles = [],
+    validate = true,
+    global = false
+  }) {
+    super({
+      baseDir,
+      relativeDirPath,
+      dirName,
+      mainFile: {
+        name: SKILL_FILE_NAME,
+        body,
+        frontmatter: { ...frontmatter }
+      },
+      otherFiles,
+      global
+    });
+    if (validate) {
+      const result = this.validate();
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+  }
+  static getSettablePaths() {
+    return {
+      relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH
+    };
+  }
+  getFrontmatter() {
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = RulesyncSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
+    return result;
+  }
+  getBody() {
+    return this.mainFile?.body ?? "";
+  }
+  validate() {
+    const result = RulesyncSkillFrontmatterSchema.safeParse(this.mainFile?.frontmatter);
+    if (!result.success) {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`
+        )
+      };
+    }
+    return { success: true, error: null };
+  }
+  static async fromDir({
+    baseDir = process.cwd(),
+    relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+    dirName,
+    global = false
+  }) {
+    const skillDirPath = join67(baseDir, relativeDirPath, dirName);
+    const skillFilePath = join67(skillDirPath, SKILL_FILE_NAME);
+    if (!await fileExists(skillFilePath)) {
+      throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+    }
+    const fileContent = await readFileContent(skillFilePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = RulesyncSkillFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
+    }
+    const otherFiles = await this.collectOtherFiles(
+      baseDir,
+      relativeDirPath,
+      dirName,
+      SKILL_FILE_NAME
+    );
+    return new _RulesyncSkill({
+      baseDir,
+      relativeDirPath,
+      dirName,
+      frontmatter: result.data,
+      body: content.trim(),
+      otherFiles,
+      validate: true,
+      global
+    });
+  }
+};
+
+// src/features/skills/tool-skill.ts
+var ToolSkill = class extends AiDir {
+  /**
+   * Get the settable paths for this tool's skill directories.
+   *
+   * @param options - Optional configuration including global mode
+   * @returns Object containing the relative directory path
+   */
+  static getSettablePaths(_options) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Load a skill from a tool-specific directory.
+   *
+   * This method should:
+   * 1. Read the SKILL.md file content
+   * 2. Parse tool-specific frontmatter format
+   * 3. Validate the parsed data
+   * 4. Collect other skill files in the directory
+   * 5. Return a concrete ToolSkill instance
+   *
+   * @param params - Parameters including the skill directory name
+   * @returns Promise resolving to a concrete ToolSkill instance
+   */
+  static async fromDir(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Convert a RulesyncSkill to the tool-specific skill format.
+   *
+   * This method should:
+   * 1. Extract relevant data from the RulesyncSkill
+   * 2. Transform frontmatter to tool-specific format
+   * 3. Transform body content if needed
+   * 4. Preserve other skill files
+   * 5. Return a concrete ToolSkill instance
+   *
+   * @param params - Parameters including the RulesyncSkill to convert
+   * @returns A concrete ToolSkill instance
+   */
+  static fromRulesyncSkill(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Check if this tool is targeted by a RulesyncSkill.
+   * Since skills don't have targets field like commands/subagents,
+   * the default behavior may vary by tool.
+   *
+   * @param rulesyncSkill - The RulesyncSkill to check
+   * @returns True if this tool should use the skill
+   */
+  static isTargetedByRulesyncSkill(_rulesyncSkill) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+};
+
+// src/features/skills/claudecode-skill.ts
+var ClaudecodeSkillFrontmatterSchema = z26.object({
+  name: z26.string(),
+  description: z26.string(),
+  "allowed-tools": z26.optional(z26.array(z26.string()))
+});
+var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = join68(".claude", "skills"),
+    dirName,
+    frontmatter,
+    body,
+    otherFiles = [],
+    validate = true,
+    global = false
+  }) {
+    super({
+      baseDir,
+      relativeDirPath,
+      dirName,
+      mainFile: {
+        name: SKILL_FILE_NAME,
+        body,
+        frontmatter: { ...frontmatter }
+      },
+      otherFiles,
+      global
+    });
+    if (validate) {
+      const result = this.validate();
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+  }
+  static getSettablePaths({
+    global: _global = false
+  } = {}) {
+    return {
+      relativeDirPath: join68(".claude", "skills")
+    };
+  }
+  getFrontmatter() {
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = ClaudecodeSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
+    return result;
+  }
+  getBody() {
+    return this.mainFile?.body ?? "";
+  }
+  validate() {
+    if (this.mainFile === void 0) {
+      return {
+        success: false,
+        error: new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+      };
+    }
+    const result = ClaudecodeSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+    if (!result.success) {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`
+        )
+      };
+    }
+    return { success: true, error: null };
+  }
+  toRulesyncSkill() {
+    const frontmatter = this.getFrontmatter();
+    const rulesyncFrontmatter = {
+      name: frontmatter.name,
+      description: frontmatter.description,
+      ...frontmatter["allowed-tools"] && {
+        claudecode: {
+          "allowed-tools": frontmatter["allowed-tools"]
+        }
+      }
+    };
+    return new RulesyncSkill({
+      baseDir: this.baseDir,
+      relativeDirPath: this.relativeDirPath,
+      dirName: this.getDirName(),
+      frontmatter: rulesyncFrontmatter,
+      body: this.getBody(),
+      otherFiles: this.getOtherFiles(),
+      validate: true,
+      global: this.global
+    });
+  }
+  static fromRulesyncSkill({
+    rulesyncSkill,
+    validate = true,
+    global = false
+  }) {
+    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+    const claudecodeFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description,
+      "allowed-tools": rulesyncFrontmatter.claudecode?.["allowed-tools"]
+    };
+    const settablePaths = _ClaudecodeSkill.getSettablePaths({ global });
+    return new _ClaudecodeSkill({
+      baseDir: rulesyncSkill.getBaseDir(),
+      relativeDirPath: settablePaths.relativeDirPath,
+      dirName: rulesyncSkill.getDirName(),
+      frontmatter: claudecodeFrontmatter,
+      body: rulesyncSkill.getBody(),
+      otherFiles: rulesyncSkill.getOtherFiles(),
+      validate,
+      global
+    });
+  }
+  static isTargetedByRulesyncSkill(_rulesyncSkill) {
+    return true;
+  }
+  static async fromDir({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    global = false
+  }) {
+    const settablePaths = this.getSettablePaths({ global });
+    const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
+    const skillDirPath = join68(baseDir, actualRelativeDirPath, dirName);
+    const skillFilePath = join68(skillDirPath, SKILL_FILE_NAME);
+    if (!await fileExists(skillFilePath)) {
+      throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+    }
+    const fileContent = await readFileContent(skillFilePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = ClaudecodeSkillFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
+    }
+    const otherFiles = await this.collectOtherFiles(
+      baseDir,
+      actualRelativeDirPath,
+      dirName,
+      SKILL_FILE_NAME
+    );
+    return new _ClaudecodeSkill({
+      baseDir,
+      relativeDirPath: actualRelativeDirPath,
+      dirName,
+      frontmatter: result.data,
+      body: content.trim(),
+      otherFiles,
+      validate: true,
+      global
+    });
+  }
+};
+
+// src/features/skills/skills-processor.ts
+var skillsProcessorToolTargets = ["claudecode"];
+var skillsProcessorToolTargetsGlobal = ["claudecode"];
+var SkillsProcessorToolTargetSchema = z27.enum(skillsProcessorToolTargets);
+var SkillsProcessor = class extends DirFeatureProcessor {
+  toolTarget;
+  global;
+  constructor({
+    baseDir = process.cwd(),
+    toolTarget,
+    global = false
+  }) {
+    super({ baseDir });
+    const result = SkillsProcessorToolTargetSchema.safeParse(toolTarget);
+    if (!result.success) {
+      throw new Error(
+        `Invalid tool target for SkillsProcessor: ${toolTarget}. ${formatError(result.error)}`
+      );
+    }
+    this.toolTarget = result.data;
+    this.global = global;
+  }
+  async convertRulesyncDirsToToolDirs(rulesyncDirs) {
+    const rulesyncSkills = rulesyncDirs.filter(
+      (dir) => dir instanceof RulesyncSkill
+    );
+    const toolSkills = rulesyncSkills.map((rulesyncSkill) => {
+      switch (this.toolTarget) {
+        case "claudecode":
+          if (!ClaudecodeSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            return null;
+          }
+          return ClaudecodeSkill.fromRulesyncSkill({
+            rulesyncSkill,
+            global: this.global
+          });
+        default:
+          throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+      }
+    }).filter((skill) => skill !== null);
+    return toolSkills;
+  }
+  async convertToolDirsToRulesyncDirs(toolDirs) {
+    const toolSkills = toolDirs.filter((dir) => dir instanceof ToolSkill);
+    const rulesyncSkills = toolSkills.map((toolSkill) => {
+      return toolSkill.toRulesyncSkill();
+    });
+    return rulesyncSkills;
+  }
+  /**
+   * Implementation of abstract method from DirFeatureProcessor
+   * Load and parse rulesync skill directories from .rulesync/skills/ directory
+   */
+  async loadRulesyncDirs() {
+    const paths = RulesyncSkill.getSettablePaths();
+    const rulesyncSkillsDirPath = join69(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs(join69(rulesyncSkillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => basename19(path3));
+    const results = await Promise.allSettled(
+      dirNames.map(
+        (dirName) => RulesyncSkill.fromDir({ baseDir: this.baseDir, dirName, global: this.global })
+      )
+    );
+    const rulesyncSkills = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        rulesyncSkills.push(result.value);
+      }
+    }
+    logger.info(`Successfully loaded ${rulesyncSkills.length} rulesync skills`);
+    return rulesyncSkills;
+  }
+  /**
+   * Implementation of abstract method from DirFeatureProcessor
+   * Load tool-specific skill configurations and parse them into ToolSkill instances
+   */
+  async loadToolDirs() {
+    switch (this.toolTarget) {
+      case "claudecode":
+        return await this.loadClaudecodeSkills();
+      default:
+        throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+    }
+  }
+  async loadToolDirsToDelete() {
+    return this.loadToolDirs();
+  }
+  /**
+   * Load Claude Code skill configurations from .claude/skills/ directory
+   */
+  async loadClaudecodeSkills() {
+    const paths = ClaudecodeSkill.getSettablePaths({ global: this.global });
+    const skillsDirPath = join69(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs(join69(skillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => basename19(path3));
+    const toolSkills = (await Promise.allSettled(
+      dirNames.map(
+        (dirName) => ClaudecodeSkill.fromDir({
+          baseDir: this.baseDir,
+          dirName,
+          global: this.global
+        })
+      )
+    )).filter((result) => result.status === "fulfilled").map((result) => result.value);
+    logger.info(`Successfully loaded ${toolSkills.length} ${paths.relativeDirPath} skills`);
+    return toolSkills;
+  }
+  /**
+   * Implementation of abstract method from DirFeatureProcessor
+   * Return the tool targets that this processor supports
+   */
+  static getToolTargets(_params = {}) {
+    return skillsProcessorToolTargets;
+  }
+  /**
+   * Return the tool targets that this processor supports in global mode
+   */
+  static getToolTargetsGlobal() {
+    return skillsProcessorToolTargetsGlobal;
+  }
+};
+
 // src/cli/commands/generate.ts
 async function generateCommand(options) {
   const config = await ConfigResolver.resolve(options);
@@ -7084,7 +7717,8 @@ async function generateCommand(options) {
   const totalMcpOutputs = await generateMcp(config);
   const totalCommandOutputs = await generateCommands(config);
   const totalSubagentOutputs = await generateSubagents(config);
-  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs;
+  const totalSkillOutputs = await generateSkills(config);
+  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs + totalSkillOutputs;
   if (totalGenerated === 0) {
     const enabledFeatures = config.getFeatures().join(", ");
     logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
@@ -7097,6 +7731,7 @@ async function generateCommand(options) {
     if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
     if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
     if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
+    if (totalSkillOutputs > 0) parts.push(`${totalSkillOutputs} skills`);
     logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
 }
@@ -7271,11 +7906,39 @@ async function generateSubagents(config) {
   }
   return totalSubagentOutputs;
 }
+async function generateSkills(config) {
+  if (!config.getFeatures().includes("skills")) {
+    logger.debug("Skipping skill generation (not in --features)");
+    return 0;
+  }
+  let totalSkillOutputs = 0;
+  logger.info("Generating skill files...");
+  const toolTargets = config.getGlobal() ? intersection(config.getTargets(), SkillsProcessor.getToolTargetsGlobal()) : intersection(config.getTargets(), SkillsProcessor.getToolTargets());
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of toolTargets) {
+      const processor = new SkillsProcessor({
+        baseDir,
+        toolTarget,
+        global: config.getGlobal()
+      });
+      if (config.getDelete()) {
+        const oldToolDirs = await processor.loadToolDirsToDelete();
+        await processor.removeAiDirs(oldToolDirs);
+      }
+      const rulesyncDirs = await processor.loadRulesyncDirs();
+      const toolDirs = await processor.convertRulesyncDirsToToolDirs(rulesyncDirs);
+      const writtenCount = await processor.writeAiDirs(toolDirs);
+      totalSkillOutputs += writtenCount;
+      logger.success(`Generated ${writtenCount} ${toolTarget} skill(s) in ${baseDir}`);
+    }
+  }
+  return totalSkillOutputs;
+}
 
 // src/cli/commands/gitignore.ts
-import { join as join65 } from "path";
+import { join as join70 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join65(process.cwd(), ".gitignore");
+  const gitignorePath = join70(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     // AGENTS.md
@@ -7292,6 +7955,7 @@ var gitignoreCommand = async () => {
     "**/.claude/memories/",
     "**/.claude/commands/",
     "**/.claude/agents/",
+    "**/.claude/skills/",
     "**/.claude/settings.local.json",
     "**/.mcp.json",
     // Cline
@@ -7385,6 +8049,7 @@ async function importCommand(options) {
   await importMcp(config, tool);
   await importCommands(config, tool);
   await importSubagents(config, tool);
+  await importSkills(config, tool);
 }
 async function importRules(config, tool) {
   if (!config.getFeatures().includes("rules")) {
@@ -7514,9 +8179,34 @@ async function importSubagents(config, tool) {
   }
   return writtenCount;
 }
+async function importSkills(config, tool) {
+  if (!config.getFeatures().includes("skills")) {
+    return 0;
+  }
+  const global = config.getGlobal();
+  const supportedTargets = SkillsProcessor.getToolTargets();
+  if (!supportedTargets.includes(tool)) {
+    return 0;
+  }
+  const skillsProcessor = new SkillsProcessor({
+    baseDir: config.getBaseDirs()[0] ?? ".",
+    toolTarget: tool,
+    global
+  });
+  const toolDirs = await skillsProcessor.loadToolDirs();
+  if (toolDirs.length === 0) {
+    return 0;
+  }
+  const rulesyncDirs = await skillsProcessor.convertToolDirsToRulesyncDirs(toolDirs);
+  const writtenCount = await skillsProcessor.writeAiDirs(rulesyncDirs);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} skill directories`);
+  }
+  return writtenCount;
+}
 
 // src/cli/commands/init.ts
-import { join as join66 } from "path";
+import { join as join71 } from "path";
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
@@ -7679,14 +8369,14 @@ Attention, again, you are just the planner, so though you can read any files and
   await ensureDir(commandPaths.relativeDirPath);
   await ensureDir(subagentPaths.relativeDirPath);
   await ensureDir(ignorePaths.relativeDirPath);
-  const ruleFilepath = join66(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = join71(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   if (!await fileExists(ruleFilepath)) {
     await writeFileContent(ruleFilepath, sampleRuleFile.content);
     logger.success(`Created ${ruleFilepath}`);
   } else {
     logger.info(`Skipped ${ruleFilepath} (already exists)`);
   }
-  const mcpFilepath = join66(
+  const mcpFilepath = join71(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
@@ -7696,21 +8386,21 @@ Attention, again, you are just the planner, so though you can read any files and
   } else {
     logger.info(`Skipped ${mcpFilepath} (already exists)`);
   }
-  const commandFilepath = join66(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = join71(commandPaths.relativeDirPath, sampleCommandFile.filename);
   if (!await fileExists(commandFilepath)) {
     await writeFileContent(commandFilepath, sampleCommandFile.content);
     logger.success(`Created ${commandFilepath}`);
   } else {
     logger.info(`Skipped ${commandFilepath} (already exists)`);
   }
-  const subagentFilepath = join66(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = join71(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   if (!await fileExists(subagentFilepath)) {
     await writeFileContent(subagentFilepath, sampleSubagentFile.content);
     logger.success(`Created ${subagentFilepath}`);
   } else {
     logger.info(`Skipped ${subagentFilepath} (already exists)`);
   }
-  const ignoreFilepath = join66(ignorePaths.relativeDirPath, ignorePaths.relativeFilePath);
+  const ignoreFilepath = join71(ignorePaths.relativeDirPath, ignorePaths.relativeFilePath);
   if (!await fileExists(ignoreFilepath)) {
     await writeFileContent(ignoreFilepath, sampleIgnoreFile.content);
     logger.success(`Created ${ignoreFilepath}`);
@@ -7723,12 +8413,12 @@ Attention, again, you are just the planner, so though you can read any files and
 import { FastMCP } from "fastmcp";
 
 // src/mcp/commands.ts
-import { basename as basename18, join as join67 } from "path";
-import { z as z25 } from "zod/mini";
+import { basename as basename20, join as join72 } from "path";
+import { z as z28 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = join67(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = join72(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -7740,7 +8430,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join72(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -7760,13 +8450,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename18(relativePathFromCwd);
+  const filename = basename20(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join72(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -7785,7 +8475,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename18(relativePathFromCwd);
+  const filename = basename20(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -7795,7 +8485,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === join72(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(`Maximum number of commands (${maxCommandsCount}) reached`);
@@ -7810,11 +8500,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = join67(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = join72(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join72(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -7829,12 +8519,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename18(relativePathFromCwd);
-  const fullPath = join67(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = basename20(relativePathFromCwd);
+  const fullPath = join72(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join72(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -7843,23 +8533,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z25.object({}),
-  getCommand: z25.object({
-    relativePathFromCwd: z25.string()
+  listCommands: z28.object({}),
+  getCommand: z28.object({
+    relativePathFromCwd: z28.string()
   }),
-  putCommand: z25.object({
-    relativePathFromCwd: z25.string(),
+  putCommand: z28.object({
+    relativePathFromCwd: z28.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z25.string()
+    body: z28.string()
   }),
-  deleteCommand: z25.object({
-    relativePathFromCwd: z25.string()
+  deleteCommand: z28.object({
+    relativePathFromCwd: z28.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${join72(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -7901,11 +8591,11 @@ var commandTools = {
 };
 
 // src/mcp/ignore.ts
-import { join as join68 } from "path";
-import { z as z26 } from "zod/mini";
+import { join as join73 } from "path";
+import { z as z29 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join73(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -7919,7 +8609,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join73(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -7940,7 +8630,7 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join73(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await removeFile(ignoreFilePath);
     return {
@@ -7953,11 +8643,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z26.object({}),
-  putIgnoreFile: z26.object({
-    content: z26.string()
+  getIgnoreFile: z29.object({}),
+  putIgnoreFile: z29.object({
+    content: z29.string()
   }),
-  deleteIgnoreFile: z26.object({})
+  deleteIgnoreFile: z29.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -7990,8 +8680,8 @@ var ignoreTools = {
 };
 
 // src/mcp/mcp.ts
-import { join as join69 } from "path";
-import { z as z27 } from "zod/mini";
+import { join as join74 } from "path";
+import { z as z30 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -8000,7 +8690,7 @@ async function getMcpFile() {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    const relativePathFromCwd = join69(
+    const relativePathFromCwd = join74(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -8033,7 +8723,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = join69(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = join74(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -8042,9 +8732,9 @@ async function putMcpFile({ content }) {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    await ensureDir(join69(baseDir, relativeDirPath));
+    await ensureDir(join74(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = join69(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = join74(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -8059,15 +8749,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = join69(
+    const recommendedPath = join74(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = join69(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = join74(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = join69(
+    const relativePathFromCwd = join74(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -8081,11 +8771,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z27.object({}),
-  putMcpFile: z27.object({
-    content: z27.string()
+  getMcpFile: z30.object({}),
+  putMcpFile: z30.object({
+    content: z30.string()
   }),
-  deleteMcpFile: z27.object({})
+  deleteMcpFile: z30.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -8118,12 +8808,12 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-import { basename as basename19, join as join70 } from "path";
-import { z as z28 } from "zod/mini";
+import { basename as basename21, join as join75 } from "path";
+import { z as z31 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = join70(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = join75(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -8136,7 +8826,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join75(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -8156,14 +8846,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename19(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join75(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -8182,7 +8872,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename19(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -8192,7 +8882,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === join75(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(`Maximum number of rules (${maxRulesCount}) reached`);
@@ -8205,11 +8895,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = join70(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = join75(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join75(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -8224,12 +8914,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename19(relativePathFromCwd);
-  const fullPath = join70(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = basename21(relativePathFromCwd);
+  const fullPath = join75(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join75(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -8238,23 +8928,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z28.object({}),
-  getRule: z28.object({
-    relativePathFromCwd: z28.string()
+  listRules: z31.object({}),
+  getRule: z31.object({
+    relativePathFromCwd: z31.string()
   }),
-  putRule: z28.object({
-    relativePathFromCwd: z28.string(),
+  putRule: z31.object({
+    relativePathFromCwd: z31.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z28.string()
+    body: z31.string()
   }),
-  deleteRule: z28.object({
-    relativePathFromCwd: z28.string()
+  deleteRule: z31.object({
+    relativePathFromCwd: z31.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${join70(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${join75(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -8296,12 +8986,12 @@ var ruleTools = {
 };
 
 // src/mcp/subagents.ts
-import { basename as basename20, join as join71 } from "path";
-import { z as z29 } from "zod/mini";
+import { basename as basename22, join as join76 } from "path";
+import { z as z32 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = join71(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = join76(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -8314,7 +9004,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join76(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -8336,14 +9026,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename20(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join76(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -8362,7 +9052,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename20(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -8372,7 +9062,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === join76(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(`Maximum number of subagents (${maxSubagentsCount}) reached`);
@@ -8385,11 +9075,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = join71(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = join76(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join76(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -8404,12 +9094,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename20(relativePathFromCwd);
-  const fullPath = join71(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = basename22(relativePathFromCwd);
+  const fullPath = join76(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join76(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -8421,23 +9111,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z29.object({}),
-  getSubagent: z29.object({
-    relativePathFromCwd: z29.string()
+  listSubagents: z32.object({}),
+  getSubagent: z32.object({
+    relativePathFromCwd: z32.string()
   }),
-  putSubagent: z29.object({
-    relativePathFromCwd: z29.string(),
+  putSubagent: z32.object({
+    relativePathFromCwd: z32.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z29.string()
+    body: z32.string()
   }),
-  deleteSubagent: z29.object({
-    relativePathFromCwd: z29.string()
+  deleteSubagent: z32.object({
+    relativePathFromCwd: z32.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${join76(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -8511,7 +9201,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.23.6";
+var getVersion = () => "3.24.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();