rulesync 4.2.0 → 4.3.0

package/dist/index.js

@@ -4706,7 +4706,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 import { basename as basename21, join as join84 } from "path";
 import { encode } from "@toon-format/toon";
-import { z as z38 } from "zod/mini";
+import { z as z39 } from "zod/mini";
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -5137,127 +5137,11 @@ var AgentsmdSkill = class _AgentsmdSkill extends SimulatedSkill {
 };
 
 // src/features/skills/cursor-skill.ts
-import { join as join43 } from "path";
-var CursorSkill = class _CursorSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("CursorSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: join43(".cursor", "skills")
-    };
-  }
-  static async fromDir(params) {
-    const baseParams = await this.fromDirDefault(params);
-    return new _CursorSkill(baseParams);
-  }
-  static fromRulesyncSkill(params) {
-    const baseParams = {
-      ...this.fromRulesyncSkillDefault(params),
-      relativeDirPath: this.getSettablePaths().relativeDirPath
-    };
-    return new _CursorSkill(baseParams);
-  }
-  static isTargetedByRulesyncSkill(rulesyncSkill) {
-    return this.isTargetedByRulesyncSkillDefault({
-      rulesyncSkill,
-      toolTarget: "cursor"
-    });
-  }
-  static forDeletion(params) {
-    const baseParams = this.forDeletionDefault(params);
-    return new _CursorSkill(baseParams);
-  }
-};
-
-// src/features/skills/geminicli-skill.ts
 import { join as join44 } from "path";
-var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("GeminiCliSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: join44(".gemini", "skills")
-    };
-  }
-  static async fromDir(params) {
-    const baseParams = await this.fromDirDefault(params);
-    return new _GeminiCliSkill(baseParams);
-  }
-  static fromRulesyncSkill(params) {
-    const baseParams = {
-      ...this.fromRulesyncSkillDefault(params),
-      relativeDirPath: this.getSettablePaths().relativeDirPath
-    };
-    return new _GeminiCliSkill(baseParams);
-  }
-  static isTargetedByRulesyncSkill(rulesyncSkill) {
-    return this.isTargetedByRulesyncSkillDefault({
-      rulesyncSkill,
-      toolTarget: "geminicli"
-    });
-  }
-  static forDeletion(params) {
-    const baseParams = this.forDeletionDefault(params);
-    return new _GeminiCliSkill(baseParams);
-  }
-};
-
-// src/features/skills/skills-processor.ts
-import { basename as basename14, join as join51 } from "path";
-import { z as z25 } from "zod/mini";
-
-// src/types/dir-feature-processor.ts
-import { join as join45 } 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 = join45(dirPath, mainFile.name);
-        const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
-        const contentWithNewline = addTrailingNewline(content);
-        await writeFileContent(mainFilePath, contentWithNewline);
-      }
-      const otherFiles = aiDir.getOtherFiles();
-      for (const file of otherFiles) {
-        const filePath = join45(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 join47 } from "path";
 import { z as z21 } from "zod/mini";
 
 // src/features/skills/rulesync-skill.ts
-import { join as join46 } from "path";
+import { join as join43 } from "path";
 import { z as z20 } from "zod/mini";
 var RulesyncSkillFrontmatterSchemaInternal = z20.looseObject({
   name: z20.string(),
@@ -5343,8 +5227,8 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
     dirName,
     global = false
   }) {
-    const skillDirPath = join46(baseDir, relativeDirPath, dirName);
-    const skillFilePath = join46(skillDirPath, SKILL_FILE_NAME);
+    const skillDirPath = join43(baseDir, relativeDirPath, dirName);
+    const skillFilePath = join43(skillDirPath, SKILL_FILE_NAME);
     if (!await fileExists(skillFilePath)) {
       throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
     }
@@ -5373,11 +5257,253 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
   }
 };
 
-// src/features/skills/claudecode-skill.ts
-var ClaudecodeSkillFrontmatterSchema = z21.looseObject({
+// src/features/skills/cursor-skill.ts
+var CursorSkillFrontmatterSchema = z21.looseObject({
   name: z21.string(),
-  description: z21.string(),
-  "allowed-tools": z21.optional(z21.array(z21.string()))
+  description: z21.string()
+});
+var CursorSkill = class _CursorSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = join44(".cursor", "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(options) {
+    if (options?.global) {
+      throw new Error("CursorSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: join44(".cursor", "skills")
+    };
+  }
+  getFrontmatter() {
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = CursorSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
+    return result;
+  }
+  getBody() {
+    return this.mainFile?.body ?? "";
+  }
+  validate() {
+    if (!this.mainFile) {
+      return {
+        success: false,
+        error: new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+      };
+    }
+    const result = CursorSkillFrontmatterSchema.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,
+      targets: ["*"]
+    };
+    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 settablePaths = _CursorSkill.getSettablePaths({ global });
+    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+    const cursorFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description
+    };
+    return new _CursorSkill({
+      baseDir: rulesyncSkill.getBaseDir(),
+      relativeDirPath: settablePaths.relativeDirPath,
+      dirName: rulesyncSkill.getDirName(),
+      frontmatter: cursorFrontmatter,
+      body: rulesyncSkill.getBody(),
+      otherFiles: rulesyncSkill.getOtherFiles(),
+      validate,
+      global
+    });
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    const targets = rulesyncSkill.getFrontmatter().targets;
+    return targets.includes("*") || targets.includes("cursor");
+  }
+  static async fromDir(params) {
+    const loaded = await this.loadSkillDirContent({
+      ...params,
+      getSettablePaths: _CursorSkill.getSettablePaths
+    });
+    const result = CursorSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+    if (!result.success) {
+      const skillDirPath = join44(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      throw new Error(
+        `Invalid frontmatter in ${join44(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+      );
+    }
+    return new _CursorSkill({
+      baseDir: loaded.baseDir,
+      relativeDirPath: loaded.relativeDirPath,
+      dirName: loaded.dirName,
+      frontmatter: result.data,
+      body: loaded.body,
+      otherFiles: loaded.otherFiles,
+      validate: true,
+      global: loaded.global
+    });
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    global = false
+  }) {
+    const settablePaths = _CursorSkill.getSettablePaths({ global });
+    return new _CursorSkill({
+      baseDir,
+      relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
+      dirName,
+      frontmatter: { name: "", description: "" },
+      body: "",
+      otherFiles: [],
+      validate: false,
+      global
+    });
+  }
+};
+
+// src/features/skills/geminicli-skill.ts
+import { join as join45 } from "path";
+var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("GeminiCliSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: join45(".gemini", "skills")
+    };
+  }
+  static async fromDir(params) {
+    const baseParams = await this.fromDirDefault(params);
+    return new _GeminiCliSkill(baseParams);
+  }
+  static fromRulesyncSkill(params) {
+    const baseParams = {
+      ...this.fromRulesyncSkillDefault(params),
+      relativeDirPath: this.getSettablePaths().relativeDirPath
+    };
+    return new _GeminiCliSkill(baseParams);
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    return this.isTargetedByRulesyncSkillDefault({
+      rulesyncSkill,
+      toolTarget: "geminicli"
+    });
+  }
+  static forDeletion(params) {
+    const baseParams = this.forDeletionDefault(params);
+    return new _GeminiCliSkill(baseParams);
+  }
+};
+
+// src/features/skills/skills-processor.ts
+import { basename as basename14, join as join51 } from "path";
+import { z as z26 } from "zod/mini";
+
+// src/types/dir-feature-processor.ts
+import { join as join46 } 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 = join46(dirPath, mainFile.name);
+        const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
+        const contentWithNewline = addTrailingNewline(content);
+        await writeFileContent(mainFilePath, contentWithNewline);
+      }
+      const otherFiles = aiDir.getOtherFiles();
+      for (const file of otherFiles) {
+        const filePath = join46(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 join47 } from "path";
+import { z as z22 } from "zod/mini";
+var ClaudecodeSkillFrontmatterSchema = z22.looseObject({
+  name: z22.string(),
+  description: z22.string(),
+  "allowed-tools": z22.optional(z22.array(z22.string()))
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -5538,10 +5664,10 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 
 // src/features/skills/codexcli-skill.ts
 import { join as join48 } from "path";
-import { z as z22 } from "zod/mini";
-var CodexCliSkillFrontmatterSchema = z22.looseObject({
-  name: z22.string(),
-  description: z22.string()
+import { z as z23 } from "zod/mini";
+var CodexCliSkillFrontmatterSchema = z23.looseObject({
+  name: z23.string(),
+  description: z23.string()
 });
 var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
   constructor({
@@ -5697,11 +5823,11 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 
 // src/features/skills/copilot-skill.ts
 import { join as join49 } from "path";
-import { z as z23 } from "zod/mini";
-var CopilotSkillFrontmatterSchema = z23.looseObject({
-  name: z23.string(),
-  description: z23.string(),
-  license: z23.optional(z23.string())
+import { z as z24 } from "zod/mini";
+var CopilotSkillFrontmatterSchema = z24.looseObject({
+  name: z24.string(),
+  description: z24.string(),
+  license: z24.optional(z24.string())
 });
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
@@ -5864,11 +5990,11 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 import { join as join50 } from "path";
-import { z as z24 } from "zod/mini";
-var OpenCodeSkillFrontmatterSchema = z24.looseObject({
-  name: z24.string(),
-  description: z24.string(),
-  "allowed-tools": z24.optional(z24.array(z24.string()))
+import { z as z25 } from "zod/mini";
+var OpenCodeSkillFrontmatterSchema = z25.looseObject({
+  name: z25.string(),
+  description: z25.string(),
+  "allowed-tools": z25.optional(z25.array(z25.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -6035,7 +6161,7 @@ var skillsProcessorToolTargetTuple = [
   "geminicli",
   "opencode"
 ];
-var SkillsProcessorToolTargetSchema = z25.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = z26.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -6069,7 +6195,7 @@ var toolSkillFactories = /* @__PURE__ */ new Map([
     "cursor",
     {
       class: CursorSkill,
-      meta: { supportsProject: true, supportsSimulated: true, supportsGlobal: false }
+      meta: { supportsProject: true, supportsSimulated: false, supportsGlobal: false }
     }
   ],
   [
@@ -6254,7 +6380,7 @@ import { join as join53 } from "path";
 
 // src/features/subagents/simulated-subagent.ts
 import { basename as basename15, join as join52 } from "path";
-import { z as z26 } from "zod/mini";
+import { z as z27 } from "zod/mini";
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -6297,9 +6423,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z26.object({
-  name: z26.string(),
-  description: z26.string()
+var SimulatedSubagentFrontmatterSchema = z27.object({
+  name: z27.string(),
+  description: z27.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -6538,19 +6664,19 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 import { basename as basename18, join as join62 } from "path";
-import { z as z31 } from "zod/mini";
+import { z as z32 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
 import { join as join59 } from "path";
-import { z as z28 } from "zod/mini";
+import { z as z29 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
 import { basename as basename16, join as join58 } from "path";
-import { z as z27 } from "zod/mini";
-var RulesyncSubagentFrontmatterSchema = z27.looseObject({
+import { z as z28 } from "zod/mini";
+var RulesyncSubagentFrontmatterSchema = z28.looseObject({
   targets: RulesyncTargetsSchema,
-  name: z27.string(),
-  description: z27.string()
+  name: z28.string(),
+  description: z28.string()
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -6621,13 +6747,13 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z28.looseObject({
-  name: z28.string(),
-  description: z28.string(),
-  model: z28.optional(z28.string()),
-  tools: z28.optional(z28.union([z28.string(), z28.array(z28.string())])),
-  permissionMode: z28.optional(z28.string()),
-  skills: z28.optional(z28.union([z28.string(), z28.array(z28.string())]))
+var ClaudecodeSubagentFrontmatterSchema = z29.looseObject({
+  name: z29.string(),
+  description: z29.string(),
+  model: z29.optional(z29.string()),
+  tools: z29.optional(z29.union([z29.string(), z29.array(z29.string())])),
+  permissionMode: z29.optional(z29.string()),
+  skills: z29.optional(z29.union([z29.string(), z29.array(z29.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -6777,12 +6903,12 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 import { join as join60 } from "path";
-import { z as z29 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = z29.looseObject({
-  name: z29.string(),
-  description: z29.string(),
-  tools: z29.optional(z29.union([z29.string(), z29.array(z29.string())]))
+var CopilotSubagentFrontmatterSchema = z30.looseObject({
+  name: z30.string(),
+  description: z30.string(),
+  tools: z30.optional(z30.union([z30.string(), z30.array(z30.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -6943,11 +7069,11 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/opencode-subagent.ts
 import { basename as basename17, join as join61 } from "path";
-import { z as z30 } from "zod/mini";
-var OpenCodeSubagentFrontmatterSchema = z30.looseObject({
-  description: z30.string(),
-  mode: z30.literal("subagent"),
-  name: z30.optional(z30.string())
+import { z as z31 } from "zod/mini";
+var OpenCodeSubagentFrontmatterSchema = z31.looseObject({
+  description: z31.string(),
+  mode: z31.literal("subagent"),
+  name: z31.optional(z31.string())
 });
 var OpenCodeSubagent = class _OpenCodeSubagent extends ToolSubagent {
   frontmatter;
@@ -7100,7 +7226,7 @@ var subagentsProcessorToolTargetTuple = [
   "opencode",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = z31.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = z32.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -7312,41 +7438,41 @@ import { join as join64 } from "path";
 
 // src/features/rules/rulesync-rule.ts
 import { basename as basename19, join as join63 } from "path";
-import { z as z32 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z32.object({
-  root: z32.optional(z32.optional(z32.boolean())),
-  targets: z32.optional(RulesyncTargetsSchema),
-  description: z32.optional(z32.string()),
-  globs: z32.optional(z32.array(z32.string())),
-  agentsmd: z32.optional(
-    z32.object({
+import { z as z33 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z33.object({
+  root: z33.optional(z33.optional(z33.boolean())),
+  targets: z33.optional(RulesyncTargetsSchema),
+  description: z33.optional(z33.string()),
+  globs: z33.optional(z33.array(z33.string())),
+  agentsmd: z33.optional(
+    z33.object({
       // @example "path/to/subproject"
-      subprojectPath: z32.optional(z32.string())
+      subprojectPath: z33.optional(z33.string())
     })
   ),
-  claudecode: z32.optional(
-    z32.object({
+  claudecode: z33.optional(
+    z33.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example "src/**/*.ts, tests/**/*.test.ts"
-      paths: z32.optional(z32.string())
+      paths: z33.optional(z33.string())
     })
   ),
-  cursor: z32.optional(
-    z32.object({
-      alwaysApply: z32.optional(z32.boolean()),
-      description: z32.optional(z32.string()),
-      globs: z32.optional(z32.array(z32.string()))
+  cursor: z33.optional(
+    z33.object({
+      alwaysApply: z33.optional(z33.boolean()),
+      description: z33.optional(z33.string()),
+      globs: z33.optional(z33.array(z33.string()))
     })
   ),
-  copilot: z32.optional(
-    z32.object({
-      excludeAgent: z32.optional(z32.union([z32.literal("code-review"), z32.literal("coding-agent")]))
+  copilot: z33.optional(
+    z33.object({
+      excludeAgent: z33.optional(z33.union([z33.literal("code-review"), z33.literal("coding-agent")]))
     })
   ),
-  antigravity: z32.optional(
-    z32.looseObject({
-      trigger: z32.optional(z32.string()),
-      globs: z32.optional(z32.array(z32.string()))
+  antigravity: z33.optional(
+    z33.looseObject({
+      trigger: z33.optional(z33.string()),
+      globs: z33.optional(z33.array(z33.string()))
     })
   )
 });
@@ -7754,20 +7880,20 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 import { join as join67 } from "path";
-import { z as z33 } from "zod/mini";
-var AntigravityRuleFrontmatterSchema = z33.looseObject({
-  trigger: z33.optional(
-    z33.union([
-      z33.literal("always_on"),
-      z33.literal("glob"),
-      z33.literal("manual"),
-      z33.literal("model_decision"),
-      z33.string()
+import { z as z34 } from "zod/mini";
+var AntigravityRuleFrontmatterSchema = z34.looseObject({
+  trigger: z34.optional(
+    z34.union([
+      z34.literal("always_on"),
+      z34.literal("glob"),
+      z34.literal("manual"),
+      z34.literal("model_decision"),
+      z34.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: z33.optional(z33.string()),
-  description: z33.optional(z33.string())
+  globs: z34.optional(z34.string()),
+  description: z34.optional(z34.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -8345,9 +8471,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 import { join as join71 } from "path";
-import { z as z34 } from "zod/mini";
-var ClaudecodeRuleFrontmatterSchema = z34.object({
-  paths: z34.optional(z34.string())
+import { z as z35 } from "zod/mini";
+var ClaudecodeRuleFrontmatterSchema = z35.object({
+  paths: z35.optional(z35.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -8555,9 +8681,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 import { join as join72 } from "path";
-import { z as z35 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z35.object({
-  description: z35.string()
+import { z as z36 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z36.object({
+  description: z36.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -8734,11 +8860,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 import { join as join74 } from "path";
-import { z as z36 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z36.object({
-  description: z36.optional(z36.string()),
-  applyTo: z36.optional(z36.string()),
-  excludeAgent: z36.optional(z36.union([z36.literal("code-review"), z36.literal("coding-agent")]))
+import { z as z37 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z37.object({
+  description: z37.optional(z37.string()),
+  applyTo: z37.optional(z37.string()),
+  excludeAgent: z37.optional(z37.union([z37.literal("code-review"), z37.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -8922,11 +9048,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 import { basename as basename20, join as join75 } from "path";
-import { z as z37 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z37.object({
-  description: z37.optional(z37.string()),
-  globs: z37.optional(z37.string()),
-  alwaysApply: z37.optional(z37.boolean())
+import { z as z38 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z38.object({
+  description: z38.optional(z38.string()),
+  globs: z38.optional(z38.string()),
+  alwaysApply: z38.optional(z38.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -9776,7 +9902,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z38.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z39.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -11133,9 +11259,12 @@ Attention, again, you are just the planner, so though you can read any files and
 // src/cli/commands/mcp.ts
 import { FastMCP } from "fastmcp";
 
+// src/mcp/tools.ts
+import { z as z46 } from "zod/mini";
+
 // src/mcp/commands.ts
 import { basename as basename22, join as join87 } from "path";
-import { z as z39 } from "zod/mini";
+import { z as z40 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -11254,17 +11383,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z39.object({}),
-  getCommand: z39.object({
-    relativePathFromCwd: z39.string()
+  listCommands: z40.object({}),
+  getCommand: z40.object({
+    relativePathFromCwd: z40.string()
   }),
-  putCommand: z39.object({
-    relativePathFromCwd: z39.string(),
+  putCommand: z40.object({
+    relativePathFromCwd: z40.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z39.string()
+    body: z40.string()
   }),
-  deleteCommand: z39.object({
-    relativePathFromCwd: z39.string()
+  deleteCommand: z40.object({
+    relativePathFromCwd: z40.string()
   })
 };
 var commandTools = {
@@ -11313,7 +11442,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 import { join as join88 } from "path";
-import { z as z40 } from "zod/mini";
+import { z as z41 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = join88(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -11370,11 +11499,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z40.object({}),
-  putIgnoreFile: z40.object({
-    content: z40.string()
+  getIgnoreFile: z41.object({}),
+  putIgnoreFile: z41.object({
+    content: z41.string()
   }),
-  deleteIgnoreFile: z40.object({})
+  deleteIgnoreFile: z41.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -11408,7 +11537,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 import { join as join89 } from "path";
-import { z as z41 } from "zod/mini";
+import { z as z42 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -11498,11 +11627,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z41.object({}),
-  putMcpFile: z41.object({
-    content: z41.string()
+  getMcpFile: z42.object({}),
+  putMcpFile: z42.object({
+    content: z42.string()
   }),
-  deleteMcpFile: z41.object({})
+  deleteMcpFile: z42.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -11536,7 +11665,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 import { basename as basename23, join as join90 } from "path";
-import { z as z42 } from "zod/mini";
+import { z as z43 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -11655,17 +11784,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z42.object({}),
-  getRule: z42.object({
-    relativePathFromCwd: z42.string()
+  listRules: z43.object({}),
+  getRule: z43.object({
+    relativePathFromCwd: z43.string()
   }),
-  putRule: z42.object({
-    relativePathFromCwd: z42.string(),
+  putRule: z43.object({
+    relativePathFromCwd: z43.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z42.string()
+    body: z43.string()
   }),
-  deleteRule: z42.object({
-    relativePathFromCwd: z42.string()
+  deleteRule: z43.object({
+    relativePathFromCwd: z43.string()
   })
 };
 var ruleTools = {
@@ -11714,7 +11843,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 import { basename as basename24, dirname as dirname2, join as join91 } from "path";
-import { z as z43 } from "zod/mini";
+import { z as z44 } from "zod/mini";
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -11882,23 +12011,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = z43.object({
-  name: z43.string(),
-  body: z43.string()
+var McpSkillFileSchema = z44.object({
+  name: z44.string(),
+  body: z44.string()
 });
 var skillToolSchemas = {
-  listSkills: z43.object({}),
-  getSkill: z43.object({
-    relativeDirPathFromCwd: z43.string()
+  listSkills: z44.object({}),
+  getSkill: z44.object({
+    relativeDirPathFromCwd: z44.string()
   }),
-  putSkill: z43.object({
-    relativeDirPathFromCwd: z43.string(),
+  putSkill: z44.object({
+    relativeDirPathFromCwd: z44.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: z43.string(),
-    otherFiles: z43.optional(z43.array(McpSkillFileSchema))
+    body: z44.string(),
+    otherFiles: z44.optional(z44.array(McpSkillFileSchema))
   }),
-  deleteSkill: z43.object({
-    relativeDirPathFromCwd: z43.string()
+  deleteSkill: z44.object({
+    relativeDirPathFromCwd: z44.string()
   })
 };
 var skillTools = {
@@ -11948,7 +12077,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 import { basename as basename25, join as join92 } from "path";
-import { z as z44 } from "zod/mini";
+import { z as z45 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -12072,17 +12201,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z44.object({}),
-  getSubagent: z44.object({
-    relativePathFromCwd: z44.string()
+  listSubagents: z45.object({}),
+  getSubagent: z45.object({
+    relativePathFromCwd: z45.string()
   }),
-  putSubagent: z44.object({
-    relativePathFromCwd: z44.string(),
+  putSubagent: z45.object({
+    relativePathFromCwd: z45.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z44.string()
+    body: z45.string()
   }),
-  deleteSubagent: z44.object({
-    relativePathFromCwd: z44.string()
+  deleteSubagent: z45.object({
+    relativePathFromCwd: z45.string()
   })
 };
 var subagentTools = {
@@ -12129,6 +12258,200 @@ var subagentTools = {
   }
 };
 
+// src/mcp/tools.ts
+var rulesyncFeatureSchema = z46.enum(["rule", "command", "subagent", "skill", "ignore", "mcp"]);
+var rulesyncOperationSchema = z46.enum(["list", "get", "put", "delete"]);
+var skillFileSchema = z46.object({
+  name: z46.string(),
+  body: z46.string()
+});
+var rulesyncToolSchema = z46.object({
+  feature: rulesyncFeatureSchema,
+  operation: rulesyncOperationSchema,
+  targetPathFromCwd: z46.optional(z46.string()),
+  frontmatter: z46.optional(z46.unknown()),
+  body: z46.optional(z46.string()),
+  otherFiles: z46.optional(z46.array(skillFileSchema)),
+  content: z46.optional(z46.string())
+});
+var supportedOperationsByFeature = {
+  rule: ["list", "get", "put", "delete"],
+  command: ["list", "get", "put", "delete"],
+  subagent: ["list", "get", "put", "delete"],
+  skill: ["list", "get", "put", "delete"],
+  ignore: ["get", "put", "delete"],
+  mcp: ["get", "put", "delete"]
+};
+function assertSupported({
+  feature,
+  operation
+}) {
+  const supportedOperations = supportedOperationsByFeature[feature];
+  if (!supportedOperations.includes(operation)) {
+    throw new Error(
+      `Operation ${operation} is not supported for feature ${feature}. Supported operations: ${supportedOperations.join(
+        ", "
+      )}`
+    );
+  }
+}
+function requireTargetPath({ targetPathFromCwd, feature, operation }) {
+  if (!targetPathFromCwd) {
+    throw new Error(`targetPathFromCwd is required for ${feature} ${operation} operation`);
+  }
+  return targetPathFromCwd;
+}
+function parseFrontmatter2({
+  feature,
+  frontmatter
+}) {
+  switch (feature) {
+    case "rule": {
+      return RulesyncRuleFrontmatterSchema.parse(frontmatter);
+    }
+    case "command": {
+      return RulesyncCommandFrontmatterSchema.parse(frontmatter);
+    }
+    case "subagent": {
+      return RulesyncSubagentFrontmatterSchema.parse(frontmatter);
+    }
+    case "skill": {
+      return RulesyncSkillFrontmatterSchema.parse(frontmatter);
+    }
+  }
+}
+function ensureBody({ body, feature, operation }) {
+  if (!body) {
+    throw new Error(`body is required for ${feature} ${operation} operation`);
+  }
+  return body;
+}
+var rulesyncTool = {
+  name: "rulesyncTool",
+  description: "Manage Rulesync files through a single MCP tool. Features: rule/command/subagent/skill support list/get/put/delete; ignore/mcp support get/put/delete only. Parameters: list requires no targetPathFromCwd (lists all items); get/delete require targetPathFromCwd; put requires targetPathFromCwd, frontmatter, and body (or content for ignore/mcp).",
+  parameters: rulesyncToolSchema,
+  execute: async (args) => {
+    const parsed = rulesyncToolSchema.parse(args);
+    assertSupported({ feature: parsed.feature, operation: parsed.operation });
+    switch (parsed.feature) {
+      case "rule": {
+        if (parsed.operation === "list") {
+          return ruleTools.listRules.execute();
+        }
+        if (parsed.operation === "get") {
+          return ruleTools.getRule.execute({ relativePathFromCwd: requireTargetPath(parsed) });
+        }
+        if (parsed.operation === "put") {
+          return ruleTools.putRule.execute({
+            relativePathFromCwd: requireTargetPath(parsed),
+            frontmatter: parseFrontmatter2({
+              feature: "rule",
+              frontmatter: parsed.frontmatter ?? {}
+            }),
+            body: ensureBody(parsed)
+          });
+        }
+        return ruleTools.deleteRule.execute({ relativePathFromCwd: requireTargetPath(parsed) });
+      }
+      case "command": {
+        if (parsed.operation === "list") {
+          return commandTools.listCommands.execute();
+        }
+        if (parsed.operation === "get") {
+          return commandTools.getCommand.execute({
+            relativePathFromCwd: requireTargetPath(parsed)
+          });
+        }
+        if (parsed.operation === "put") {
+          return commandTools.putCommand.execute({
+            relativePathFromCwd: requireTargetPath(parsed),
+            frontmatter: parseFrontmatter2({
+              feature: "command",
+              frontmatter: parsed.frontmatter ?? {}
+            }),
+            body: ensureBody(parsed)
+          });
+        }
+        return commandTools.deleteCommand.execute({
+          relativePathFromCwd: requireTargetPath(parsed)
+        });
+      }
+      case "subagent": {
+        if (parsed.operation === "list") {
+          return subagentTools.listSubagents.execute();
+        }
+        if (parsed.operation === "get") {
+          return subagentTools.getSubagent.execute({
+            relativePathFromCwd: requireTargetPath(parsed)
+          });
+        }
+        if (parsed.operation === "put") {
+          return subagentTools.putSubagent.execute({
+            relativePathFromCwd: requireTargetPath(parsed),
+            frontmatter: parseFrontmatter2({
+              feature: "subagent",
+              frontmatter: parsed.frontmatter ?? {}
+            }),
+            body: ensureBody(parsed)
+          });
+        }
+        return subagentTools.deleteSubagent.execute({
+          relativePathFromCwd: requireTargetPath(parsed)
+        });
+      }
+      case "skill": {
+        if (parsed.operation === "list") {
+          return skillTools.listSkills.execute();
+        }
+        if (parsed.operation === "get") {
+          return skillTools.getSkill.execute({ relativeDirPathFromCwd: requireTargetPath(parsed) });
+        }
+        if (parsed.operation === "put") {
+          return skillTools.putSkill.execute({
+            relativeDirPathFromCwd: requireTargetPath(parsed),
+            frontmatter: parseFrontmatter2({
+              feature: "skill",
+              frontmatter: parsed.frontmatter ?? {}
+            }),
+            body: ensureBody(parsed),
+            otherFiles: parsed.otherFiles ?? []
+          });
+        }
+        return skillTools.deleteSkill.execute({
+          relativeDirPathFromCwd: requireTargetPath(parsed)
+        });
+      }
+      case "ignore": {
+        if (parsed.operation === "get") {
+          return ignoreTools.getIgnoreFile.execute();
+        }
+        if (parsed.operation === "put") {
+          if (!parsed.content) {
+            throw new Error("content is required for ignore put operation");
+          }
+          return ignoreTools.putIgnoreFile.execute({ content: parsed.content });
+        }
+        return ignoreTools.deleteIgnoreFile.execute();
+      }
+      case "mcp": {
+        if (parsed.operation === "get") {
+          return mcpTools.getMcpFile.execute();
+        }
+        if (parsed.operation === "put") {
+          if (!parsed.content) {
+            throw new Error("content is required for mcp put operation");
+          }
+          return mcpTools.putMcpFile.execute({ content: parsed.content });
+        }
+        return mcpTools.deleteMcpFile.execute();
+      }
+      default: {
+        throw new Error(`Unknown feature: ${parsed.feature}`);
+      }
+    }
+  }
+};
+
 // src/cli/commands/mcp.ts
 async function mcpCommand({ version }) {
   const server = new FastMCP({
@@ -12137,28 +12460,7 @@ async function mcpCommand({ version }) {
     version,
     instructions: "This server handles Rulesync files including rules, commands, MCP, ignore files, subagents and skills for any AI agents. It should be used when you need those files."
   });
-  server.addTool(ruleTools.listRules);
-  server.addTool(ruleTools.getRule);
-  server.addTool(ruleTools.putRule);
-  server.addTool(ruleTools.deleteRule);
-  server.addTool(commandTools.listCommands);
-  server.addTool(commandTools.getCommand);
-  server.addTool(commandTools.putCommand);
-  server.addTool(commandTools.deleteCommand);
-  server.addTool(subagentTools.listSubagents);
-  server.addTool(subagentTools.getSubagent);
-  server.addTool(subagentTools.putSubagent);
-  server.addTool(subagentTools.deleteSubagent);
-  server.addTool(skillTools.listSkills);
-  server.addTool(skillTools.getSkill);
-  server.addTool(skillTools.putSkill);
-  server.addTool(skillTools.deleteSkill);
-  server.addTool(ignoreTools.getIgnoreFile);
-  server.addTool(ignoreTools.putIgnoreFile);
-  server.addTool(ignoreTools.deleteIgnoreFile);
-  server.addTool(mcpTools.getMcpFile);
-  server.addTool(mcpTools.putMcpFile);
-  server.addTool(mcpTools.deleteMcpFile);
+  server.addTool(rulesyncTool);
   logger.info("Rulesync MCP server started via stdio");
   void server.start({
     transportType: "stdio"
@@ -12166,7 +12468,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "4.2.0";
+var getVersion = () => "4.3.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();