rulesync 4.2.0 → 4.3.0

package/dist/index.cjs

@@ -4729,7 +4729,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path86 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini38 = require("zod/mini");
+var import_mini39 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -5160,127 +5160,11 @@ var AgentsmdSkill = class _AgentsmdSkill extends SimulatedSkill {
 };
 
 // src/features/skills/cursor-skill.ts
-var import_node_path45 = require("path");
-var CursorSkill = class _CursorSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("CursorSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: (0, import_node_path45.join)(".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
 var import_node_path46 = require("path");
-var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("GeminiCliSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: (0, import_node_path46.join)(".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
-var import_node_path53 = require("path");
-var import_mini25 = require("zod/mini");
-
-// src/types/dir-feature-processor.ts
-var import_node_path47 = 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_path47.join)(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 = (0, import_node_path47.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_path49 = require("path");
 var import_mini21 = require("zod/mini");
 
 // src/features/skills/rulesync-skill.ts
-var import_node_path48 = require("path");
+var import_node_path45 = require("path");
 var import_mini20 = require("zod/mini");
 var RulesyncSkillFrontmatterSchemaInternal = import_mini20.z.looseObject({
   name: import_mini20.z.string(),
@@ -5366,8 +5250,8 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
     dirName,
     global = false
   }) {
-    const skillDirPath = (0, import_node_path48.join)(baseDir, relativeDirPath, dirName);
-    const skillFilePath = (0, import_node_path48.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillDirPath = (0, import_node_path45.join)(baseDir, relativeDirPath, dirName);
+    const skillFilePath = (0, import_node_path45.join)(skillDirPath, SKILL_FILE_NAME);
     if (!await fileExists(skillFilePath)) {
       throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
     }
@@ -5396,11 +5280,253 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
   }
 };
 
-// src/features/skills/claudecode-skill.ts
-var ClaudecodeSkillFrontmatterSchema = import_mini21.z.looseObject({
+// src/features/skills/cursor-skill.ts
+var CursorSkillFrontmatterSchema = import_mini21.z.looseObject({
   name: import_mini21.z.string(),
-  description: import_mini21.z.string(),
-  "allowed-tools": import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string()))
+  description: import_mini21.z.string()
+});
+var CursorSkill = class _CursorSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = (0, import_node_path46.join)(".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: (0, import_node_path46.join)(".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 = (0, import_node_path46.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      throw new Error(
+        `Invalid frontmatter in ${(0, import_node_path46.join)(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
+var import_node_path47 = require("path");
+var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("GeminiCliSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: (0, import_node_path47.join)(".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
+var import_node_path53 = require("path");
+var import_mini26 = require("zod/mini");
+
+// src/types/dir-feature-processor.ts
+var import_node_path48 = 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_path48.join)(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 = (0, import_node_path48.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_path49 = require("path");
+var import_mini22 = require("zod/mini");
+var ClaudecodeSkillFrontmatterSchema = import_mini22.z.looseObject({
+  name: import_mini22.z.string(),
+  description: import_mini22.z.string(),
+  "allowed-tools": import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string()))
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -5561,10 +5687,10 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 
 // src/features/skills/codexcli-skill.ts
 var import_node_path50 = require("path");
-var import_mini22 = require("zod/mini");
-var CodexCliSkillFrontmatterSchema = import_mini22.z.looseObject({
-  name: import_mini22.z.string(),
-  description: import_mini22.z.string()
+var import_mini23 = require("zod/mini");
+var CodexCliSkillFrontmatterSchema = import_mini23.z.looseObject({
+  name: import_mini23.z.string(),
+  description: import_mini23.z.string()
 });
 var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
   constructor({
@@ -5720,11 +5846,11 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 
 // src/features/skills/copilot-skill.ts
 var import_node_path51 = require("path");
-var import_mini23 = require("zod/mini");
-var CopilotSkillFrontmatterSchema = import_mini23.z.looseObject({
-  name: import_mini23.z.string(),
-  description: import_mini23.z.string(),
-  license: import_mini23.z.optional(import_mini23.z.string())
+var import_mini24 = require("zod/mini");
+var CopilotSkillFrontmatterSchema = import_mini24.z.looseObject({
+  name: import_mini24.z.string(),
+  description: import_mini24.z.string(),
+  license: import_mini24.z.optional(import_mini24.z.string())
 });
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
@@ -5887,11 +6013,11 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 var import_node_path52 = require("path");
-var import_mini24 = require("zod/mini");
-var OpenCodeSkillFrontmatterSchema = import_mini24.z.looseObject({
-  name: import_mini24.z.string(),
-  description: import_mini24.z.string(),
-  "allowed-tools": import_mini24.z.optional(import_mini24.z.array(import_mini24.z.string()))
+var import_mini25 = require("zod/mini");
+var OpenCodeSkillFrontmatterSchema = import_mini25.z.looseObject({
+  name: import_mini25.z.string(),
+  description: import_mini25.z.string(),
+  "allowed-tools": import_mini25.z.optional(import_mini25.z.array(import_mini25.z.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -6058,7 +6184,7 @@ var skillsProcessorToolTargetTuple = [
   "geminicli",
   "opencode"
 ];
-var SkillsProcessorToolTargetSchema = import_mini25.z.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = import_mini26.z.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -6092,7 +6218,7 @@ var toolSkillFactories = /* @__PURE__ */ new Map([
     "cursor",
     {
       class: CursorSkill,
-      meta: { supportsProject: true, supportsSimulated: true, supportsGlobal: false }
+      meta: { supportsProject: true, supportsSimulated: false, supportsGlobal: false }
     }
   ],
   [
@@ -6277,7 +6403,7 @@ var import_node_path55 = require("path");
 
 // src/features/subagents/simulated-subagent.ts
 var import_node_path54 = require("path");
-var import_mini26 = require("zod/mini");
+var import_mini27 = require("zod/mini");
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -6320,9 +6446,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = import_mini26.z.object({
-  name: import_mini26.z.string(),
-  description: import_mini26.z.string()
+var SimulatedSubagentFrontmatterSchema = import_mini27.z.object({
+  name: import_mini27.z.string(),
+  description: import_mini27.z.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -6561,19 +6687,19 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path64 = require("path");
-var import_mini31 = require("zod/mini");
+var import_mini32 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path61 = require("path");
-var import_mini28 = require("zod/mini");
+var import_mini29 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
 var import_node_path60 = require("path");
-var import_mini27 = require("zod/mini");
-var RulesyncSubagentFrontmatterSchema = import_mini27.z.looseObject({
+var import_mini28 = require("zod/mini");
+var RulesyncSubagentFrontmatterSchema = import_mini28.z.looseObject({
   targets: RulesyncTargetsSchema,
-  name: import_mini27.z.string(),
-  description: import_mini27.z.string()
+  name: import_mini28.z.string(),
+  description: import_mini28.z.string()
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -6644,13 +6770,13 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = import_mini28.z.looseObject({
-  name: import_mini28.z.string(),
-  description: import_mini28.z.string(),
-  model: import_mini28.z.optional(import_mini28.z.string()),
-  tools: import_mini28.z.optional(import_mini28.z.union([import_mini28.z.string(), import_mini28.z.array(import_mini28.z.string())])),
-  permissionMode: import_mini28.z.optional(import_mini28.z.string()),
-  skills: import_mini28.z.optional(import_mini28.z.union([import_mini28.z.string(), import_mini28.z.array(import_mini28.z.string())]))
+var ClaudecodeSubagentFrontmatterSchema = import_mini29.z.looseObject({
+  name: import_mini29.z.string(),
+  description: import_mini29.z.string(),
+  model: import_mini29.z.optional(import_mini29.z.string()),
+  tools: import_mini29.z.optional(import_mini29.z.union([import_mini29.z.string(), import_mini29.z.array(import_mini29.z.string())])),
+  permissionMode: import_mini29.z.optional(import_mini29.z.string()),
+  skills: import_mini29.z.optional(import_mini29.z.union([import_mini29.z.string(), import_mini29.z.array(import_mini29.z.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -6800,12 +6926,12 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 var import_node_path62 = require("path");
-var import_mini29 = require("zod/mini");
+var import_mini30 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = import_mini29.z.looseObject({
-  name: import_mini29.z.string(),
-  description: import_mini29.z.string(),
-  tools: import_mini29.z.optional(import_mini29.z.union([import_mini29.z.string(), import_mini29.z.array(import_mini29.z.string())]))
+var CopilotSubagentFrontmatterSchema = import_mini30.z.looseObject({
+  name: import_mini30.z.string(),
+  description: import_mini30.z.string(),
+  tools: import_mini30.z.optional(import_mini30.z.union([import_mini30.z.string(), import_mini30.z.array(import_mini30.z.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -6966,11 +7092,11 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/opencode-subagent.ts
 var import_node_path63 = require("path");
-var import_mini30 = require("zod/mini");
-var OpenCodeSubagentFrontmatterSchema = import_mini30.z.looseObject({
-  description: import_mini30.z.string(),
-  mode: import_mini30.z.literal("subagent"),
-  name: import_mini30.z.optional(import_mini30.z.string())
+var import_mini31 = require("zod/mini");
+var OpenCodeSubagentFrontmatterSchema = import_mini31.z.looseObject({
+  description: import_mini31.z.string(),
+  mode: import_mini31.z.literal("subagent"),
+  name: import_mini31.z.optional(import_mini31.z.string())
 });
 var OpenCodeSubagent = class _OpenCodeSubagent extends ToolSubagent {
   frontmatter;
@@ -7123,7 +7249,7 @@ var subagentsProcessorToolTargetTuple = [
   "opencode",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini31.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini32.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -7335,41 +7461,41 @@ var import_node_path66 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path65 = require("path");
-var import_mini32 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini32.z.object({
-  root: import_mini32.z.optional(import_mini32.z.optional(import_mini32.z.boolean())),
-  targets: import_mini32.z.optional(RulesyncTargetsSchema),
-  description: import_mini32.z.optional(import_mini32.z.string()),
-  globs: import_mini32.z.optional(import_mini32.z.array(import_mini32.z.string())),
-  agentsmd: import_mini32.z.optional(
-    import_mini32.z.object({
+var import_mini33 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini33.z.object({
+  root: import_mini33.z.optional(import_mini33.z.optional(import_mini33.z.boolean())),
+  targets: import_mini33.z.optional(RulesyncTargetsSchema),
+  description: import_mini33.z.optional(import_mini33.z.string()),
+  globs: import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string())),
+  agentsmd: import_mini33.z.optional(
+    import_mini33.z.object({
       // @example "path/to/subproject"
-      subprojectPath: import_mini32.z.optional(import_mini32.z.string())
+      subprojectPath: import_mini33.z.optional(import_mini33.z.string())
     })
   ),
-  claudecode: import_mini32.z.optional(
-    import_mini32.z.object({
+  claudecode: import_mini33.z.optional(
+    import_mini33.z.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example "src/**/*.ts, tests/**/*.test.ts"
-      paths: import_mini32.z.optional(import_mini32.z.string())
+      paths: import_mini33.z.optional(import_mini33.z.string())
     })
   ),
-  cursor: import_mini32.z.optional(
-    import_mini32.z.object({
-      alwaysApply: import_mini32.z.optional(import_mini32.z.boolean()),
-      description: import_mini32.z.optional(import_mini32.z.string()),
-      globs: import_mini32.z.optional(import_mini32.z.array(import_mini32.z.string()))
+  cursor: import_mini33.z.optional(
+    import_mini33.z.object({
+      alwaysApply: import_mini33.z.optional(import_mini33.z.boolean()),
+      description: import_mini33.z.optional(import_mini33.z.string()),
+      globs: import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string()))
     })
   ),
-  copilot: import_mini32.z.optional(
-    import_mini32.z.object({
-      excludeAgent: import_mini32.z.optional(import_mini32.z.union([import_mini32.z.literal("code-review"), import_mini32.z.literal("coding-agent")]))
+  copilot: import_mini33.z.optional(
+    import_mini33.z.object({
+      excludeAgent: import_mini33.z.optional(import_mini33.z.union([import_mini33.z.literal("code-review"), import_mini33.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini32.z.optional(
-    import_mini32.z.looseObject({
-      trigger: import_mini32.z.optional(import_mini32.z.string()),
-      globs: import_mini32.z.optional(import_mini32.z.array(import_mini32.z.string()))
+  antigravity: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      trigger: import_mini33.z.optional(import_mini33.z.string()),
+      globs: import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string()))
     })
   )
 });
@@ -7777,20 +7903,20 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path69 = require("path");
-var import_mini33 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini33.z.looseObject({
-  trigger: import_mini33.z.optional(
-    import_mini33.z.union([
-      import_mini33.z.literal("always_on"),
-      import_mini33.z.literal("glob"),
-      import_mini33.z.literal("manual"),
-      import_mini33.z.literal("model_decision"),
-      import_mini33.z.string()
+var import_mini34 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini34.z.looseObject({
+  trigger: import_mini34.z.optional(
+    import_mini34.z.union([
+      import_mini34.z.literal("always_on"),
+      import_mini34.z.literal("glob"),
+      import_mini34.z.literal("manual"),
+      import_mini34.z.literal("model_decision"),
+      import_mini34.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini33.z.optional(import_mini33.z.string()),
-  description: import_mini33.z.optional(import_mini33.z.string())
+  globs: import_mini34.z.optional(import_mini34.z.string()),
+  description: import_mini34.z.optional(import_mini34.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -8368,9 +8494,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path73 = require("path");
-var import_mini34 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini34.z.object({
-  paths: import_mini34.z.optional(import_mini34.z.string())
+var import_mini35 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini35.z.object({
+  paths: import_mini35.z.optional(import_mini35.z.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -8578,9 +8704,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path74 = require("path");
-var import_mini35 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini35.z.object({
-  description: import_mini35.z.string()
+var import_mini36 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini36.z.object({
+  description: import_mini36.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -8757,11 +8883,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path76 = require("path");
-var import_mini36 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini36.z.object({
-  description: import_mini36.z.optional(import_mini36.z.string()),
-  applyTo: import_mini36.z.optional(import_mini36.z.string()),
-  excludeAgent: import_mini36.z.optional(import_mini36.z.union([import_mini36.z.literal("code-review"), import_mini36.z.literal("coding-agent")]))
+var import_mini37 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini37.z.object({
+  description: import_mini37.z.optional(import_mini37.z.string()),
+  applyTo: import_mini37.z.optional(import_mini37.z.string()),
+  excludeAgent: import_mini37.z.optional(import_mini37.z.union([import_mini37.z.literal("code-review"), import_mini37.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -8945,11 +9071,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path77 = require("path");
-var import_mini37 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini37.z.object({
-  description: import_mini37.z.optional(import_mini37.z.string()),
-  globs: import_mini37.z.optional(import_mini37.z.string()),
-  alwaysApply: import_mini37.z.optional(import_mini37.z.boolean())
+var import_mini38 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini38.z.object({
+  description: import_mini38.z.optional(import_mini38.z.string()),
+  globs: import_mini38.z.optional(import_mini38.z.string()),
+  alwaysApply: import_mini38.z.optional(import_mini38.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -9799,7 +9925,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini38.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini39.z.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -11156,9 +11282,12 @@ Attention, again, you are just the planner, so though you can read any files and
 // src/cli/commands/mcp.ts
 var import_fastmcp = require("fastmcp");
 
+// src/mcp/tools.ts
+var import_mini46 = require("zod/mini");
+
 // src/mcp/commands.ts
 var import_node_path89 = require("path");
-var import_mini39 = require("zod/mini");
+var import_mini40 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -11277,17 +11406,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini39.z.object({}),
-  getCommand: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string()
+  listCommands: import_mini40.z.object({}),
+  getCommand: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string()
   }),
-  putCommand: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string(),
+  putCommand: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini39.z.string()
+    body: import_mini40.z.string()
   }),
-  deleteCommand: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string()
+  deleteCommand: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string()
   })
 };
 var commandTools = {
@@ -11336,7 +11465,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 var import_node_path90 = require("path");
-var import_mini40 = require("zod/mini");
+var import_mini41 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path90.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -11393,11 +11522,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini40.z.object({}),
-  putIgnoreFile: import_mini40.z.object({
-    content: import_mini40.z.string()
+  getIgnoreFile: import_mini41.z.object({}),
+  putIgnoreFile: import_mini41.z.object({
+    content: import_mini41.z.string()
   }),
-  deleteIgnoreFile: import_mini40.z.object({})
+  deleteIgnoreFile: import_mini41.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -11431,7 +11560,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 var import_node_path91 = require("path");
-var import_mini41 = require("zod/mini");
+var import_mini42 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -11521,11 +11650,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini41.z.object({}),
-  putMcpFile: import_mini41.z.object({
-    content: import_mini41.z.string()
+  getMcpFile: import_mini42.z.object({}),
+  putMcpFile: import_mini42.z.object({
+    content: import_mini42.z.string()
   }),
-  deleteMcpFile: import_mini41.z.object({})
+  deleteMcpFile: import_mini42.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -11559,7 +11688,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path92 = require("path");
-var import_mini42 = require("zod/mini");
+var import_mini43 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -11678,17 +11807,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini42.z.object({}),
-  getRule: import_mini42.z.object({
-    relativePathFromCwd: import_mini42.z.string()
+  listRules: import_mini43.z.object({}),
+  getRule: import_mini43.z.object({
+    relativePathFromCwd: import_mini43.z.string()
   }),
-  putRule: import_mini42.z.object({
-    relativePathFromCwd: import_mini42.z.string(),
+  putRule: import_mini43.z.object({
+    relativePathFromCwd: import_mini43.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini42.z.string()
+    body: import_mini43.z.string()
   }),
-  deleteRule: import_mini42.z.object({
-    relativePathFromCwd: import_mini42.z.string()
+  deleteRule: import_mini43.z.object({
+    relativePathFromCwd: import_mini43.z.string()
   })
 };
 var ruleTools = {
@@ -11737,7 +11866,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path93 = require("path");
-var import_mini43 = require("zod/mini");
+var import_mini44 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -11905,23 +12034,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini43.z.object({
-  name: import_mini43.z.string(),
-  body: import_mini43.z.string()
+var McpSkillFileSchema = import_mini44.z.object({
+  name: import_mini44.z.string(),
+  body: import_mini44.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini43.z.object({}),
-  getSkill: import_mini43.z.object({
-    relativeDirPathFromCwd: import_mini43.z.string()
+  listSkills: import_mini44.z.object({}),
+  getSkill: import_mini44.z.object({
+    relativeDirPathFromCwd: import_mini44.z.string()
   }),
-  putSkill: import_mini43.z.object({
-    relativeDirPathFromCwd: import_mini43.z.string(),
+  putSkill: import_mini44.z.object({
+    relativeDirPathFromCwd: import_mini44.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini43.z.string(),
-    otherFiles: import_mini43.z.optional(import_mini43.z.array(McpSkillFileSchema))
+    body: import_mini44.z.string(),
+    otherFiles: import_mini44.z.optional(import_mini44.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini43.z.object({
-    relativeDirPathFromCwd: import_mini43.z.string()
+  deleteSkill: import_mini44.z.object({
+    relativeDirPathFromCwd: import_mini44.z.string()
   })
 };
 var skillTools = {
@@ -11971,7 +12100,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path94 = require("path");
-var import_mini44 = require("zod/mini");
+var import_mini45 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -12095,17 +12224,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini44.z.object({}),
-  getSubagent: import_mini44.z.object({
-    relativePathFromCwd: import_mini44.z.string()
+  listSubagents: import_mini45.z.object({}),
+  getSubagent: import_mini45.z.object({
+    relativePathFromCwd: import_mini45.z.string()
   }),
-  putSubagent: import_mini44.z.object({
-    relativePathFromCwd: import_mini44.z.string(),
+  putSubagent: import_mini45.z.object({
+    relativePathFromCwd: import_mini45.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini44.z.string()
+    body: import_mini45.z.string()
   }),
-  deleteSubagent: import_mini44.z.object({
-    relativePathFromCwd: import_mini44.z.string()
+  deleteSubagent: import_mini45.z.object({
+    relativePathFromCwd: import_mini45.z.string()
   })
 };
 var subagentTools = {
@@ -12152,6 +12281,200 @@ var subagentTools = {
   }
 };
 
+// src/mcp/tools.ts
+var rulesyncFeatureSchema = import_mini46.z.enum(["rule", "command", "subagent", "skill", "ignore", "mcp"]);
+var rulesyncOperationSchema = import_mini46.z.enum(["list", "get", "put", "delete"]);
+var skillFileSchema = import_mini46.z.object({
+  name: import_mini46.z.string(),
+  body: import_mini46.z.string()
+});
+var rulesyncToolSchema = import_mini46.z.object({
+  feature: rulesyncFeatureSchema,
+  operation: rulesyncOperationSchema,
+  targetPathFromCwd: import_mini46.z.optional(import_mini46.z.string()),
+  frontmatter: import_mini46.z.optional(import_mini46.z.unknown()),
+  body: import_mini46.z.optional(import_mini46.z.string()),
+  otherFiles: import_mini46.z.optional(import_mini46.z.array(skillFileSchema)),
+  content: import_mini46.z.optional(import_mini46.z.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 import_fastmcp.FastMCP({
@@ -12160,28 +12483,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"
@@ -12189,7 +12491,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 import_commander.Command();
   const version = getVersion();