rulesync 3.23.6 → 3.24.0

package/dist/index.cjs

@@ -31,7 +31,7 @@ var ANNOUNCEMENT = "".trim();
 
 // src/types/features.ts
 var import_mini = require("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 = import_mini.z.enum(ALL_FEATURES);
 var FeaturesSchema = import_mini.z.array(FeatureSchema);
@@ -160,6 +160,10 @@ async function readFileContent(filepath) {
   logger.debug(`Reading file: ${filepath}`);
   return (0, import_promises.readFile)(filepath, "utf-8");
 }
+async function readFileBuffer(filepath) {
+  logger.debug(`Reading file buffer: ${filepath}`);
+  return (0, import_promises.readFile)(filepath);
+}
 function addTrailingNewline(content) {
   if (!content) {
     return "\n";
@@ -187,11 +191,32 @@ async function listDirectoryFiles(dir) {
   }
 }
 async function findFilesByGlobs(globs, options = {}) {
+  const { type = "all" } = options;
   const items = (0, import_node_fs.globSync)(globs, { withFileTypes: true });
-  if (!options.fileOnly) {
-    return items.map((item) => (0, import_node_path.join)(item.parentPath, item.name));
+  switch (type) {
+    case "file":
+      return items.filter((item) => item.isFile()).map((item) => (0, import_node_path.join)(item.parentPath, item.name));
+    case "dir":
+      return items.filter((item) => item.isDirectory()).map((item) => (0, import_node_path.join)(item.parentPath, item.name));
+    case "all":
+      return items.map((item) => (0, import_node_path.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 (0, import_promises.rm)(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    logger.warn(`Failed to remove directory ${dirPath}:`, error);
   }
-  return items.filter((item) => item.isFile()).map((item) => (0, import_node_path.join)(item.parentPath, item.name));
 }
 async function removeFile(filepath) {
   logger.debug(`Removing file: ${filepath}`);
@@ -1697,7 +1722,7 @@ var CommandsProcessor = class extends FeatureProcessor {
     );
     const rulesyncCommands = (await Promise.allSettled(
       rulesyncCommandPaths.map(
-        (path2) => RulesyncCommand.fromFile({ relativeFilePath: (0, import_node_path14.basename)(path2) })
+        (path3) => RulesyncCommand.fromFile({ relativeFilePath: (0, import_node_path14.basename)(path3) })
       )
     )).filter((result) => result.status === "fulfilled").map((result) => result.value);
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
@@ -1739,45 +1764,45 @@ var CommandsProcessor = class extends FeatureProcessor {
       (0, import_node_path14.join)(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: (0, import_node_path14.basename)(path2)
+              relativeFilePath: (0, import_node_path14.basename)(path3)
             });
           case "claudecode":
             return ClaudecodeCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path14.basename)(path2),
+              relativeFilePath: (0, import_node_path14.basename)(path3),
               global: this.global
             });
           case "geminicli":
             return GeminiCliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path14.basename)(path2),
+              relativeFilePath: (0, import_node_path14.basename)(path3),
               global: this.global
             });
           case "roo":
             return RooCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path14.basename)(path2)
+              relativeFilePath: (0, import_node_path14.basename)(path3)
             });
           case "copilot":
             return CopilotCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path14.basename)(path2)
+              relativeFilePath: (0, import_node_path14.basename)(path3)
             });
           case "cursor":
             return CursorCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path14.basename)(path2),
+              relativeFilePath: (0, import_node_path14.basename)(path3),
               global: this.global
             });
           case "codexcli":
             return CodexcliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path14.basename)(path2),
+              relativeFilePath: (0, import_node_path14.basename)(path3),
               global: this.global
             });
           default:
@@ -4570,7 +4595,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
     fromFile
   }) {
     const paths = await findFilesByGlobs((0, import_node_path46.join)(this.baseDir, relativeDirPath, "*.md"));
-    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile((0, import_node_path46.basename)(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+    const subagents = (await Promise.allSettled(paths.map((path3) => fromFile((0, import_node_path46.basename)(path3))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
     logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
     return subagents;
   }
@@ -7092,6 +7117,614 @@ For example, if the user instructs \`Call planner subagent to plan the refactori
   }
 };
 
+// src/features/skills/skills-processor.ts
+var import_node_path71 = require("path");
+var import_mini27 = require("zod/mini");
+
+// src/types/dir-feature-processor.ts
+var import_node_path67 = require("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 = (0, import_node_path67.join)(dirPath, mainFile.name);
+        const contentWithNewline = addTrailingNewline(mainFile.body);
+        await writeFileContent(mainFilePath, contentWithNewline);
+      }
+      const otherFiles = aiDir.getOtherFiles();
+      for (const file of otherFiles) {
+        const filePath = (0, import_node_path67.join)(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
+var import_node_path70 = require("path");
+var import_mini26 = require("zod/mini");
+
+// src/constants/general.ts
+var SKILL_FILE_NAME = "SKILL.md";
+
+// src/features/skills/rulesync-skill.ts
+var import_node_path69 = require("path");
+var import_mini25 = require("zod/mini");
+
+// src/types/ai-dir.ts
+var import_node_path68 = __toESM(require("path"), 1);
+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(import_node_path68.default.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 = import_node_path68.default.join(this.baseDir, this.relativeDirPath, this.dirName);
+    const resolvedFull = (0, import_node_path68.resolve)(fullPath);
+    const resolvedBase = (0, import_node_path68.resolve)(this.baseDir);
+    const rel = (0, import_node_path68.relative)(resolvedBase, resolvedFull);
+    if (rel.startsWith("..") || import_node_path68.default.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 import_node_path68.default.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 = (0, import_node_path68.join)(baseDir, relativeDirPath, dirName);
+    const glob = (0, import_node_path68.join)(dirPath, "**", "*");
+    const filePaths = await findFilesByGlobs(glob, { type: "file" });
+    const filteredPaths = filePaths.filter((filePath) => (0, import_node_path68.basename)(filePath) !== excludeFileName);
+    const files = await Promise.all(
+      filteredPaths.map(async (filePath) => {
+        const fileBuffer = await readFileBuffer(filePath);
+        return {
+          relativeFilePathToDirPath: (0, import_node_path68.relative)(dirPath, filePath),
+          fileBuffer
+        };
+      })
+    );
+    return files;
+  }
+};
+
+// src/features/skills/rulesync-skill.ts
+var RulesyncSkillFrontmatterSchema = import_mini25.z.object({
+  name: import_mini25.z.string(),
+  description: import_mini25.z.string(),
+  claudecode: import_mini25.z.optional(
+    import_mini25.z.object({
+      "allowed-tools": import_mini25.z.optional(import_mini25.z.array(import_mini25.z.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 = (0, import_node_path69.join)(baseDir, relativeDirPath, dirName);
+    const skillFilePath = (0, import_node_path69.join)(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 = import_mini26.z.object({
+  name: import_mini26.z.string(),
+  description: import_mini26.z.string(),
+  "allowed-tools": import_mini26.z.optional(import_mini26.z.array(import_mini26.z.string()))
+});
+var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = (0, import_node_path70.join)(".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: (0, import_node_path70.join)(".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 = (0, import_node_path70.join)(baseDir, actualRelativeDirPath, dirName);
+    const skillFilePath = (0, import_node_path70.join)(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 = import_mini27.z.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 = (0, import_node_path71.join)(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs((0, import_node_path71.join)(rulesyncSkillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => (0, import_node_path71.basename)(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 = (0, import_node_path71.join)(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs((0, import_node_path71.join)(skillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => (0, import_node_path71.basename)(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);
@@ -7107,7 +7740,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}`);
@@ -7120,6 +7754,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(" + ")})`);
   }
 }
@@ -7294,11 +7929,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() ? (0, import_es_toolkit2.intersection)(config.getTargets(), SkillsProcessor.getToolTargetsGlobal()) : (0, import_es_toolkit2.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
-var import_node_path67 = require("path");
+var import_node_path72 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path67.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path72.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     // AGENTS.md
@@ -7315,6 +7978,7 @@ var gitignoreCommand = async () => {
     "**/.claude/memories/",
     "**/.claude/commands/",
     "**/.claude/agents/",
+    "**/.claude/skills/",
     "**/.claude/settings.local.json",
     "**/.mcp.json",
     // Cline
@@ -7408,6 +8072,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")) {
@@ -7537,9 +8202,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
-var import_node_path68 = require("path");
+var import_node_path73 = require("path");
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
@@ -7702,14 +8392,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 = (0, import_node_path68.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path73.join)(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 = (0, import_node_path68.join)(
+  const mcpFilepath = (0, import_node_path73.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
@@ -7719,21 +8409,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 = (0, import_node_path68.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path73.join)(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 = (0, import_node_path68.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path73.join)(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 = (0, import_node_path68.join)(ignorePaths.relativeDirPath, ignorePaths.relativeFilePath);
+  const ignoreFilepath = (0, import_node_path73.join)(ignorePaths.relativeDirPath, ignorePaths.relativeFilePath);
   if (!await fileExists(ignoreFilepath)) {
     await writeFileContent(ignoreFilepath, sampleIgnoreFile.content);
     logger.success(`Created ${ignoreFilepath}`);
@@ -7746,12 +8436,12 @@ Attention, again, you are just the planner, so though you can read any files and
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/commands.ts
-var import_node_path69 = require("path");
-var import_mini25 = require("zod/mini");
+var import_node_path74 = require("path");
+var import_mini28 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path69.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path74.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -7763,7 +8453,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path69.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path74.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -7783,13 +8473,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path69.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path74.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path69.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path74.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -7808,7 +8498,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path69.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path74.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -7818,7 +8508,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path69.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path74.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(`Maximum number of commands (${maxCommandsCount}) reached`);
@@ -7833,11 +8523,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path69.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path74.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path69.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path74.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -7852,12 +8542,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path69.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path69.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path74.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path74.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path69.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path74.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -7866,23 +8556,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini25.z.object({}),
-  getCommand: import_mini25.z.object({
-    relativePathFromCwd: import_mini25.z.string()
+  listCommands: import_mini28.z.object({}),
+  getCommand: import_mini28.z.object({
+    relativePathFromCwd: import_mini28.z.string()
   }),
-  putCommand: import_mini25.z.object({
-    relativePathFromCwd: import_mini25.z.string(),
+  putCommand: import_mini28.z.object({
+    relativePathFromCwd: import_mini28.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini25.z.string()
+    body: import_mini28.z.string()
   }),
-  deleteCommand: import_mini25.z.object({
-    relativePathFromCwd: import_mini25.z.string()
+  deleteCommand: import_mini28.z.object({
+    relativePathFromCwd: import_mini28.z.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path69.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path74.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -7924,11 +8614,11 @@ var commandTools = {
 };
 
 // src/mcp/ignore.ts
-var import_node_path70 = require("path");
-var import_mini26 = require("zod/mini");
+var import_node_path75 = require("path");
+var import_mini29 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path70.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path75.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -7942,7 +8632,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path70.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path75.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -7963,7 +8653,7 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path70.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path75.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await removeFile(ignoreFilePath);
     return {
@@ -7976,11 +8666,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini26.z.object({}),
-  putIgnoreFile: import_mini26.z.object({
-    content: import_mini26.z.string()
+  getIgnoreFile: import_mini29.z.object({}),
+  putIgnoreFile: import_mini29.z.object({
+    content: import_mini29.z.string()
   }),
-  deleteIgnoreFile: import_mini26.z.object({})
+  deleteIgnoreFile: import_mini29.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -8013,8 +8703,8 @@ var ignoreTools = {
 };
 
 // src/mcp/mcp.ts
-var import_node_path71 = require("path");
-var import_mini27 = require("zod/mini");
+var import_node_path76 = require("path");
+var import_mini30 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -8023,7 +8713,7 @@ async function getMcpFile() {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    const relativePathFromCwd = (0, import_node_path71.join)(
+    const relativePathFromCwd = (0, import_node_path76.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -8056,7 +8746,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path71.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path76.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -8065,9 +8755,9 @@ async function putMcpFile({ content }) {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    await ensureDir((0, import_node_path71.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path76.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path71.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path76.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -8082,15 +8772,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path71.join)(
+    const recommendedPath = (0, import_node_path76.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path71.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path76.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path71.join)(
+    const relativePathFromCwd = (0, import_node_path76.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -8104,11 +8794,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini27.z.object({}),
-  putMcpFile: import_mini27.z.object({
-    content: import_mini27.z.string()
+  getMcpFile: import_mini30.z.object({}),
+  putMcpFile: import_mini30.z.object({
+    content: import_mini30.z.string()
   }),
-  deleteMcpFile: import_mini27.z.object({})
+  deleteMcpFile: import_mini30.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -8141,12 +8831,12 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-var import_node_path72 = require("path");
-var import_mini28 = require("zod/mini");
+var import_node_path77 = require("path");
+var import_mini31 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = (0, import_node_path72.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path77.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -8159,7 +8849,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path72.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path77.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -8179,14 +8869,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path72.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path77.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path72.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path77.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -8205,7 +8895,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path72.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path77.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -8215,7 +8905,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path72.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path77.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(`Maximum number of rules (${maxRulesCount}) reached`);
@@ -8228,11 +8918,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path72.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path77.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path72.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path77.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -8247,12 +8937,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path72.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path72.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path77.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path77.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path72.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path77.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -8261,23 +8951,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini28.z.object({}),
-  getRule: import_mini28.z.object({
-    relativePathFromCwd: import_mini28.z.string()
+  listRules: import_mini31.z.object({}),
+  getRule: import_mini31.z.object({
+    relativePathFromCwd: import_mini31.z.string()
   }),
-  putRule: import_mini28.z.object({
-    relativePathFromCwd: import_mini28.z.string(),
+  putRule: import_mini31.z.object({
+    relativePathFromCwd: import_mini31.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini28.z.string()
+    body: import_mini31.z.string()
   }),
-  deleteRule: import_mini28.z.object({
-    relativePathFromCwd: import_mini28.z.string()
+  deleteRule: import_mini31.z.object({
+    relativePathFromCwd: import_mini31.z.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path72.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path77.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -8319,12 +9009,12 @@ var ruleTools = {
 };
 
 // src/mcp/subagents.ts
-var import_node_path73 = require("path");
-var import_mini29 = require("zod/mini");
+var import_node_path78 = require("path");
+var import_mini32 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = (0, import_node_path73.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path78.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -8337,7 +9027,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path73.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path78.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -8359,14 +9049,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path73.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path78.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path73.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path78.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -8385,7 +9075,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path73.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path78.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -8395,7 +9085,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path73.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path78.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(`Maximum number of subagents (${maxSubagentsCount}) reached`);
@@ -8408,11 +9098,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path73.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path78.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path73.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path78.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -8427,12 +9117,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path73.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path73.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path78.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path78.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path73.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path78.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -8444,23 +9134,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini29.z.object({}),
-  getSubagent: import_mini29.z.object({
-    relativePathFromCwd: import_mini29.z.string()
+  listSubagents: import_mini32.z.object({}),
+  getSubagent: import_mini32.z.object({
+    relativePathFromCwd: import_mini32.z.string()
   }),
-  putSubagent: import_mini29.z.object({
-    relativePathFromCwd: import_mini29.z.string(),
+  putSubagent: import_mini32.z.object({
+    relativePathFromCwd: import_mini32.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini29.z.string()
+    body: import_mini32.z.string()
   }),
-  deleteSubagent: import_mini29.z.object({
-    relativePathFromCwd: import_mini29.z.string()
+  deleteSubagent: import_mini32.z.object({
+    relativePathFromCwd: import_mini32.z.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path73.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path78.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -8534,7 +9224,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 import_commander.Command();
   const version = getVersion();