rulesync 0.74.0 → 0.75.0

package/dist/index.js

@@ -8,98 +8,13 @@ import { Command } from "commander";
 // src/constants/announcements.ts
 var ANNOUNCEMENT = "".trim();
 
-// src/types/config-options.ts
-import { z as z2 } from "zod/mini";
-
-// src/types/tool-targets.ts
+// src/types/features.ts
 import { z } from "zod/mini";
-var ALL_TOOL_TARGETS = [
-  "agentsmd",
-  "amazonqcli",
-  "augmentcode",
-  "augmentcode-legacy",
-  "copilot",
-  "cursor",
-  "cline",
-  "claudecode",
-  "codexcli",
-  "opencode",
-  "qwencode",
-  "roo",
-  "geminicli",
-  "kiro",
-  "junie",
-  "warp",
-  "windsurf"
-];
-var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
-var ToolTargetSchema = z.enum(ALL_TOOL_TARGETS);
-var ToolTargetsSchema = z.array(ToolTargetSchema);
-var RulesyncTargetsSchema = z.array(z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
-
-// src/types/config-options.ts
-var FEATURE_TYPES = ["rules", "commands", "mcp", "ignore", "subagents"];
-var FeatureTypeSchema = z2.enum(FEATURE_TYPES);
-var FeaturesSchema = z2.union([z2.array(FeatureTypeSchema), z2.literal("*")]);
-var OutputPathsSchema = z2.object({
-  agentsmd: z2.optional(z2.string()),
-  amazonqcli: z2.optional(z2.string()),
-  augmentcode: z2.optional(z2.string()),
-  "augmentcode-legacy": z2.optional(z2.string()),
-  copilot: z2.optional(z2.string()),
-  cursor: z2.optional(z2.string()),
-  cline: z2.optional(z2.string()),
-  claudecode: z2.optional(z2.string()),
-  codexcli: z2.optional(z2.string()),
-  opencode: z2.optional(z2.string()),
-  qwencode: z2.optional(z2.string()),
-  roo: z2.optional(z2.string()),
-  geminicli: z2.optional(z2.string()),
-  kiro: z2.optional(z2.string()),
-  junie: z2.optional(z2.string()),
-  windsurf: z2.optional(z2.string())
-});
-var ConfigOptionsSchema = z2.object({
-  aiRulesDir: z2.optional(z2.string()),
-  outputPaths: z2.optional(OutputPathsSchema),
-  watchEnabled: z2.optional(z2.boolean()),
-  defaultTargets: z2.optional(ToolTargetsSchema),
-  targets: z2.optional(z2.array(ToolTargetSchema)),
-  exclude: z2.optional(z2.array(ToolTargetSchema)),
-  features: z2.optional(FeaturesSchema),
-  verbose: z2.optional(z2.boolean()),
-  delete: z2.optional(z2.boolean()),
-  baseDir: z2.optional(z2.union([z2.string(), z2.array(z2.string())])),
-  legacy: z2.optional(z2.boolean()),
-  watch: z2.optional(
-    z2.object({
-      enabled: z2.optional(z2.boolean()),
-      interval: z2.optional(z2.number()),
-      ignore: z2.optional(z2.array(z2.string()))
-    })
-  )
-});
-var MergedConfigSchema = z2.object({
-  aiRulesDir: z2.string(),
-  outputPaths: z2.record(ToolTargetSchema, z2.string()),
-  watchEnabled: z2.boolean(),
-  defaultTargets: ToolTargetsSchema,
-  targets: z2.optional(z2.array(ToolTargetSchema)),
-  exclude: z2.optional(z2.array(ToolTargetSchema)),
-  features: z2.optional(FeaturesSchema),
-  verbose: z2.optional(z2.boolean()),
-  delete: z2.optional(z2.boolean()),
-  baseDir: z2.optional(z2.union([z2.string(), z2.array(z2.string())])),
-  configPath: z2.optional(z2.string()),
-  legacy: z2.optional(z2.boolean()),
-  watch: z2.optional(
-    z2.object({
-      enabled: z2.optional(z2.boolean()),
-      interval: z2.optional(z2.number()),
-      ignore: z2.optional(z2.array(z2.string()))
-    })
-  )
-});
+var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
+var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
+var FeatureSchema = z.enum(ALL_FEATURES);
+var FeaturesSchema = z.array(FeatureSchema);
+var RulesyncFeaturesSchema = z.array(z.enum(ALL_FEATURES_WITH_WILDCARD));
 
 // src/utils/file.ts
 import { globSync } from "fs";
@@ -407,6 +322,32 @@ var RulesyncFile = class extends AiFile {
   }
 };
 
+// src/types/tool-targets.ts
+import { z as z2 } from "zod/mini";
+var ALL_TOOL_TARGETS = [
+  "agentsmd",
+  "amazonqcli",
+  "augmentcode",
+  "augmentcode-legacy",
+  "copilot",
+  "cursor",
+  "cline",
+  "claudecode",
+  "codexcli",
+  "opencode",
+  "qwencode",
+  "roo",
+  "geminicli",
+  "kiro",
+  "junie",
+  "warp",
+  "windsurf"
+];
+var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
+var ToolTargetSchema = z2.enum(ALL_TOOL_TARGETS);
+var ToolTargetsSchema = z2.array(ToolTargetSchema);
+var RulesyncTargetsSchema = z2.array(z2.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
+
 // src/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = z3.object({
   targets: RulesyncTargetsSchema,
@@ -509,6 +450,39 @@ var ToolCommand = class extends AiFile {
   static fromRulesyncCommand(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
+  /**
+   * Check if this tool is targeted by a RulesyncCommand based on its targets field.
+   * Subclasses should override this to provide specific targeting logic.
+   *
+   * @param rulesyncCommand - The RulesyncCommand to check
+   * @returns True if this tool is targeted by the command
+   */
+  static isTargetedByRulesyncCommand(_rulesyncCommand) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Default implementation for checking if a tool is targeted by a RulesyncCommand.
+   * Checks if the command's targets include the tool target or a wildcard.
+   *
+   * @param params - Parameters including the RulesyncCommand and tool target
+   * @returns True if the tool target is included in the command's targets
+   */
+  static isTargetedByRulesyncCommandDefault({
+    rulesyncCommand,
+    toolTarget
+  }) {
+    const targets = rulesyncCommand.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/commands/claudecode-command.ts
@@ -589,6 +563,12 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       return { success: false, error: result.error };
     }
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "claudecode"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -749,6 +729,12 @@ var CodexCliCommand = class _CodexCliCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/commands/copilot-command.ts
@@ -793,6 +779,12 @@ var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/commands/cursor-command.ts
@@ -837,6 +829,12 @@ var CursorCommand = class _CursorCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "cursor"
+    });
+  }
 };
 
 // src/commands/geminicli-command.ts
@@ -873,17 +871,6 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
       throw new Error(`Failed to parse TOML command file: ${error}`);
     }
   }
-  parseCommandFile(content) {
-    const parsed = this.parseTomlContent(content);
-    return {
-      filename: "unknown.toml",
-      filepath: "unknown.toml",
-      frontmatter: {
-        description: parsed.description
-      },
-      content: parsed.prompt
-    };
-  }
   getBody() {
     return this.body;
   }
@@ -958,6 +945,12 @@ ${geminiFrontmatter.prompt}
       return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
     }
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "geminicli"
+    });
+  }
 };
 
 // src/commands/roo-command.ts
@@ -1043,6 +1036,12 @@ var RooCommand = class _RooCommand extends ToolCommand {
       return { success: false, error: result.error };
     }
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "roo"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -1094,31 +1093,49 @@ var CommandsProcessor = class extends FeatureProcessor {
     const toolCommands = rulesyncCommands.map((rulesyncCommand) => {
       switch (this.toolTarget) {
         case "claudecode":
+          if (!ClaudecodeCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return ClaudecodeCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "geminicli":
+          if (!GeminiCliCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return GeminiCliCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "roo":
+          if (!RooCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return RooCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "copilot":
+          if (!CopilotCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return CopilotCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "cursor":
+          if (!CursorCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return CursorCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "codexcli":
+          if (!CodexCliCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return CodexCliCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
@@ -1126,7 +1143,9 @@ var CommandsProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
+    }).filter(
+      (command) => command !== null
+    );
     return toolCommands;
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -1286,14 +1305,6 @@ var CommandsProcessor = class extends FeatureProcessor {
 // src/config/config-resolver.ts
 import { loadConfig } from "c12";
 
-// src/types/features.ts
-import { z as z9 } from "zod/mini";
-var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
-var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
-var FeatureSchema = z9.enum(ALL_FEATURES);
-var FeaturesSchema2 = z9.array(FeatureSchema);
-var RulesyncFeaturesSchema = z9.array(z9.enum(ALL_FEATURES_WITH_WILDCARD));
-
 // src/config/config.ts
 var Config = class {
   baseDirs;
@@ -1408,7 +1419,7 @@ var ConfigResolver = class {
 };
 
 // src/ignore/ignore-processor.ts
-import { z as z10 } from "zod/mini";
+import { z as z9 } from "zod/mini";
 
 // src/ignore/amazonqcli-ignore.ts
 import { join as join11 } from "path";
@@ -2020,7 +2031,7 @@ var ignoreProcessorToolTargets = [
   "roo",
   "windsurf"
 ];
-var IgnoreProcessorToolTargetSchema = z10.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = z9.enum(ignoreProcessorToolTargets);
 var IgnoreProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2182,47 +2193,40 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-import { z as z12 } from "zod/mini";
+import { z as z11 } from "zod/mini";
 
 // src/mcp/amazonqcli-mcp.ts
 import { join as join23 } from "path";
 
 // src/mcp/rulesync-mcp.ts
 import { join as join22 } from "path";
-
-// src/types/mcp.ts
-import { z as z11 } from "zod/mini";
-var McpTransportTypeSchema = z11.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = z11.object({
-  type: z11.optional(z11.enum(["stdio", "sse", "http"])),
-  command: z11.optional(z11.union([z11.string(), z11.array(z11.string())])),
-  args: z11.optional(z11.array(z11.string())),
-  url: z11.optional(z11.string()),
-  httpUrl: z11.optional(z11.string()),
-  env: z11.optional(z11.record(z11.string(), z11.string())),
-  disabled: z11.optional(z11.boolean()),
-  networkTimeout: z11.optional(z11.number()),
-  timeout: z11.optional(z11.number()),
-  trust: z11.optional(z11.boolean()),
-  cwd: z11.optional(z11.string()),
-  transport: z11.optional(McpTransportTypeSchema),
-  alwaysAllow: z11.optional(z11.array(z11.string())),
-  tools: z11.optional(z11.array(z11.string())),
-  kiroAutoApprove: z11.optional(z11.array(z11.string())),
-  kiroAutoBlock: z11.optional(z11.array(z11.string())),
-  headers: z11.optional(z11.record(z11.string(), z11.string()))
-});
-var RulesyncMcpServerSchema = z11.extend(McpServerBaseSchema, {
-  targets: z11.optional(RulesyncTargetsSchema)
+import { z as z10 } from "zod/mini";
+var McpTransportTypeSchema = z10.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = z10.object({
+  type: z10.optional(z10.enum(["stdio", "sse", "http"])),
+  command: z10.optional(z10.union([z10.string(), z10.array(z10.string())])),
+  args: z10.optional(z10.array(z10.string())),
+  url: z10.optional(z10.string()),
+  httpUrl: z10.optional(z10.string()),
+  env: z10.optional(z10.record(z10.string(), z10.string())),
+  disabled: z10.optional(z10.boolean()),
+  networkTimeout: z10.optional(z10.number()),
+  timeout: z10.optional(z10.number()),
+  trust: z10.optional(z10.boolean()),
+  cwd: z10.optional(z10.string()),
+  transport: z10.optional(McpTransportTypeSchema),
+  alwaysAllow: z10.optional(z10.array(z10.string())),
+  tools: z10.optional(z10.array(z10.string())),
+  kiroAutoApprove: z10.optional(z10.array(z10.string())),
+  kiroAutoBlock: z10.optional(z10.array(z10.string())),
+  headers: z10.optional(z10.record(z10.string(), z10.string()))
 });
-var McpConfigSchema = z11.object({
-  mcpServers: z11.record(z11.string(), McpServerBaseSchema)
+var RulesyncMcpServerSchema = z10.extend(McpServerBaseSchema, {
+  targets: z10.optional(RulesyncTargetsSchema)
 });
-var RulesyncMcpConfigSchema = z11.object({
-  mcpServers: z11.record(z11.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = z10.object({
+  mcpServers: z10.record(z10.string(), RulesyncMcpServerSchema)
 });
-
-// src/mcp/rulesync-mcp.ts
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
   constructor({ ...rest }) {
@@ -2614,7 +2618,7 @@ var mcpProcessorToolTargets = [
   "cursor",
   "roo"
 ];
-var McpProcessorToolTargetSchema = z12.enum(mcpProcessorToolTargets);
+var McpProcessorToolTargetSchema = z11.enum(mcpProcessorToolTargets);
 var McpProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2775,7 +2779,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/rules/rules-processor.ts
 import { basename as basename14, join as join49 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
-import { z as z18 } from "zod/mini";
+import { z as z17 } from "zod/mini";
 
 // src/constants/paths.ts
 import { join as join29 } from "path";
@@ -2787,7 +2791,7 @@ var RULESYNC_SUBAGENTS_DIR = join29(".rulesync", "subagents");
 
 // src/subagents/simulated-subagent.ts
 import { basename as basename11, join as join30 } from "path";
-import { z as z13 } from "zod/mini";
+import { z as z12 } from "zod/mini";
 
 // src/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -2800,12 +2804,31 @@ var ToolSubagent = class extends ToolFile {
   static fromRulesyncSubagent(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
+  static isTargetedByRulesyncSubagent(_rulesyncSubagent) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static isTargetedByRulesyncSubagentDefault({
+    rulesyncSubagent,
+    toolTarget
+  }) {
+    const targets = rulesyncSubagent.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z13.object({
-  name: z13.string(),
-  description: z13.string()
+var SimulatedSubagentFrontmatterSchema = z12.object({
+  name: z12.string(),
+  description: z12.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -2902,6 +2925,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
     const baseParams = this.fromRulesyncSubagentDefault(params);
     return new _CodexCliSubagent(baseParams);
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/subagents/copilot-subagent.ts
@@ -2919,6 +2948,12 @@ var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
     const baseParams = this.fromRulesyncSubagentDefault(params);
     return new _CopilotSubagent(baseParams);
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/subagents/cursor-subagent.ts
@@ -2936,6 +2971,12 @@ var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
     const baseParams = this.fromRulesyncSubagentDefault(params);
     return new _CursorSubagent(baseParams);
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "cursor"
+    });
+  }
 };
 
 // src/rules/agentsmd-rule.ts
@@ -2943,17 +2984,17 @@ import { join as join32 } from "path";
 
 // src/rules/rulesync-rule.ts
 import { basename as basename12, join as join31 } from "path";
-import { z as z14 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z14.object({
-  root: z14.optional(z14.optional(z14.boolean())),
-  targets: z14.optional(RulesyncTargetsSchema),
-  description: z14.optional(z14.string()),
-  globs: z14.optional(z14.array(z14.string())),
-  cursor: z14.optional(
-    z14.object({
-      alwaysApply: z14.optional(z14.boolean()),
-      description: z14.optional(z14.string()),
-      globs: z14.optional(z14.array(z14.string()))
+import { z as z13 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z13.object({
+  root: z13.optional(z13.optional(z13.boolean())),
+  targets: z13.optional(RulesyncTargetsSchema),
+  description: z13.optional(z13.string()),
+  globs: z13.optional(z13.array(z13.string())),
+  cursor: z13.optional(
+    z13.object({
+      alwaysApply: z13.optional(z13.boolean()),
+      description: z13.optional(z13.string()),
+      globs: z13.optional(z13.array(z13.string()))
     })
   )
 });
@@ -3106,6 +3147,25 @@ var ToolRule = class extends ToolFile {
   isRoot() {
     return this.root;
   }
+  static isTargetedByRulesyncRule(_rulesyncRule) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static isTargetedByRulesyncRuleDefault({
+    rulesyncRule,
+    toolTarget
+  }) {
+    const targets = rulesyncRule.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/rules/agentsmd-rule.ts
@@ -3166,6 +3226,12 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "agentsmd"
+    });
+  }
 };
 
 // src/rules/amazonqcli-rule.ts
@@ -3215,6 +3281,12 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "amazonqcli"
+    });
+  }
 };
 
 // src/rules/augmentcode-legacy-rule.ts
@@ -3265,6 +3337,12 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "augmentcode-legacy"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -3332,6 +3410,12 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "augmentcode"
+    });
+  }
 };
 
 // src/rules/claudecode-rule.ts
@@ -3386,13 +3470,19 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "claudecode"
+    });
+  }
 };
 
 // src/rules/cline-rule.ts
 import { join as join37 } from "path";
-import { z as z15 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z15.object({
-  description: z15.string()
+import { z as z14 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z14.object({
+  description: z14.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -3422,6 +3512,12 @@ var ClineRule = class _ClineRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "cline"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -3492,14 +3588,20 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/rules/copilot-rule.ts
 import { join as join39 } from "path";
-import { z as z16 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z16.object({
-  description: z16.optional(z16.string()),
-  applyTo: z16.optional(z16.string())
+import { z as z15 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z15.object({
+  description: z15.optional(z15.string()),
+  applyTo: z15.optional(z15.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -3640,15 +3742,21 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   getBody() {
     return this.body;
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/rules/cursor-rule.ts
 import { basename as basename13, join as join40 } from "path";
-import { z as z17 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z17.object({
-  description: z17.optional(z17.string()),
-  globs: z17.optional(z17.string()),
-  alwaysApply: z17.optional(z17.boolean())
+import { z as z16 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z16.object({
+  description: z16.optional(z16.string()),
+  globs: z16.optional(z16.string()),
+  alwaysApply: z16.optional(z16.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -3808,6 +3916,12 @@ var CursorRule = class _CursorRule extends ToolRule {
   getBody() {
     return this.body;
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "cursor"
+    });
+  }
 };
 
 // src/rules/geminicli-rule.ts
@@ -3862,6 +3976,12 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "geminicli"
+    });
+  }
 };
 
 // src/rules/junie-rule.ts
@@ -3916,6 +4036,12 @@ var JunieRule = class _JunieRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "junie"
+    });
+  }
 };
 
 // src/rules/kiro-rule.ts
@@ -3965,6 +4091,12 @@ var KiroRule = class _KiroRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "kiro"
+    });
+  }
 };
 
 // src/rules/opencode-rule.ts
@@ -4019,6 +4151,12 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "opencode"
+    });
+  }
 };
 
 // src/rules/qwencode-rule.ts
@@ -4070,6 +4208,12 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "qwencode"
+    });
+  }
 };
 
 // src/rules/roo-rule.ts
@@ -4134,6 +4278,12 @@ var RooRule = class _RooRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "roo"
+    });
+  }
 };
 
 // src/rules/warp-rule.ts
@@ -4195,6 +4345,12 @@ var WarpRule = class _WarpRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "warp"
+    });
+  }
 };
 
 // src/rules/windsurf-rule.ts
@@ -4243,6 +4399,12 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "windsurf"
+    });
+  }
 };
 
 // src/rules/rules-processor.ts
@@ -4265,7 +4427,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z18.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z17.enum(rulesProcessorToolTargets);
 var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
@@ -4288,102 +4450,153 @@ var RulesProcessor = class extends FeatureProcessor {
     const toolRules = rulesyncRules.map((rulesyncRule) => {
       switch (this.toolTarget) {
         case "agentsmd":
+          if (!AgentsMdRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AgentsMdRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "amazonqcli":
+          if (!AmazonQCliRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AmazonQCliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "augmentcode":
+          if (!AugmentcodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AugmentcodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "augmentcode-legacy":
+          if (!AugmentcodeLegacyRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AugmentcodeLegacyRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "claudecode":
+          if (!ClaudecodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return ClaudecodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "cline":
+          if (!ClineRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return ClineRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "codexcli":
+          if (!CodexcliRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return CodexcliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "copilot":
+          if (!CopilotRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return CopilotRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "cursor":
+          if (!CursorRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return CursorRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "geminicli":
+          if (!GeminiCliRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return GeminiCliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "junie":
+          if (!JunieRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return JunieRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "kiro":
+          if (!KiroRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return KiroRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "opencode":
+          if (!OpenCodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return OpenCodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "qwencode":
+          if (!QwencodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return QwencodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "roo":
+          if (!RooRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return RooRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "warp":
+          if (!WarpRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return WarpRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "windsurf":
+          if (!WindsurfRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return WindsurfRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
@@ -4392,7 +4605,7 @@ var RulesProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
+    }).filter((rule) => rule !== null);
     if (this.toolTarget === "cursor" && (this.simulateCommands || this.simulateSubagents)) {
       toolRules.push(
         new CursorRule({
@@ -4982,22 +5195,22 @@ When users call a simulated subagent, it will look for the corresponding markdow
 
 // src/subagents/subagents-processor.ts
 import { basename as basename16, join as join52 } from "path";
-import { z as z21 } from "zod/mini";
+import { z as z20 } from "zod/mini";
 
 // src/subagents/claudecode-subagent.ts
 import { join as join51 } from "path";
-import { z as z20 } from "zod/mini";
+import { z as z19 } from "zod/mini";
 
 // src/subagents/rulesync-subagent.ts
 import { basename as basename15, join as join50 } from "path";
-import { z as z19 } from "zod/mini";
-var RulesyncSubagentModelSchema = z19.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = z19.object({
+import { z as z18 } from "zod/mini";
+var RulesyncSubagentModelSchema = z18.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = z18.object({
   targets: RulesyncTargetsSchema,
-  name: z19.string(),
-  description: z19.string(),
-  claudecode: z19.optional(
-    z19.object({
+  name: z18.string(),
+  description: z18.string(),
+  claudecode: z18.optional(
+    z18.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -5062,10 +5275,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z20.object({
-  name: z20.string(),
-  description: z20.string(),
-  model: z20.optional(z20.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = z19.object({
+  name: z19.string(),
+  description: z19.string(),
+  model: z19.optional(z19.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -5150,6 +5363,12 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       return { success: false, error: result.error };
     }
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "claudecode"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -5185,7 +5404,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "cursor",
   "codexcli"
 ];
-var SubagentsProcessorToolTargetSchema = z21.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = z20.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -5202,24 +5421,36 @@ var SubagentsProcessor = class extends FeatureProcessor {
     const toolSubagents = rulesyncSubagents.map((rulesyncSubagent) => {
       switch (this.toolTarget) {
         case "claudecode":
+          if (!ClaudecodeSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
           return ClaudecodeSubagent.fromRulesyncSubagent({
             baseDir: this.baseDir,
             relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
             rulesyncSubagent
           });
         case "copilot":
+          if (!CopilotSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
           return CopilotSubagent.fromRulesyncSubagent({
             baseDir: this.baseDir,
             relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
             rulesyncSubagent
           });
         case "cursor":
+          if (!CursorSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
           return CursorSubagent.fromRulesyncSubagent({
             baseDir: this.baseDir,
             relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
             rulesyncSubagent
           });
         case "codexcli":
+          if (!CodexCliSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
           return CodexCliSubagent.fromRulesyncSubagent({
             baseDir: this.baseDir,
             relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
@@ -5228,7 +5459,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
+    }).filter((subagent) => subagent !== null);
     return toolSubagents;
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -5535,7 +5766,7 @@ async function generateCommand(options) {
     const parts = [];
     if (totalRulesOutputs > 0) parts.push(`${totalRulesOutputs} rules`);
     if (totalIgnoreOutputs > 0) parts.push(`${totalIgnoreOutputs} ignore files`);
-    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCPs`);
+    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
     if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
     if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
     logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
@@ -5805,7 +6036,7 @@ var getVersion = async () => {
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.74.0";
+    return "0.75.0";
   }
 };
 var main = async () => {
@@ -5827,7 +6058,7 @@ var main = async () => {
     }
   ).option(
     "-f, --features <features>",
-    `Comma-separated list of features to import (${FEATURE_TYPES.join(",")}) or '*' for all`,
+    `Comma-separated list of features to import (${ALL_FEATURES.join(",")}) or '*' for all`,
     (value) => {
       return value.split(",").map((f) => f.trim());
     }
@@ -5852,7 +6083,7 @@ var main = async () => {
     }
   ).option(
     "-f, --features <features>",
-    `Comma-separated list of features to generate (${FEATURE_TYPES.join(",")}) or '*' for all`,
+    `Comma-separated list of features to generate (${ALL_FEATURES.join(",")}) or '*' for all`,
     (value) => {
       return value.split(",").map((f) => f.trim());
     }