rulesync 0.74.0 → 0.75.0

package/dist/index.cjs

@@ -31,98 +31,13 @@ var import_commander = require("commander");
 // src/constants/announcements.ts
 var ANNOUNCEMENT = "".trim();
 
-// src/types/config-options.ts
-var import_mini2 = require("zod/mini");
-
-// src/types/tool-targets.ts
+// src/types/features.ts
 var import_mini = require("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 = import_mini.z.enum(ALL_TOOL_TARGETS);
-var ToolTargetsSchema = import_mini.z.array(ToolTargetSchema);
-var RulesyncTargetsSchema = import_mini.z.array(import_mini.z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
-
-// src/types/config-options.ts
-var FEATURE_TYPES = ["rules", "commands", "mcp", "ignore", "subagents"];
-var FeatureTypeSchema = import_mini2.z.enum(FEATURE_TYPES);
-var FeaturesSchema = import_mini2.z.union([import_mini2.z.array(FeatureTypeSchema), import_mini2.z.literal("*")]);
-var OutputPathsSchema = import_mini2.z.object({
-  agentsmd: import_mini2.z.optional(import_mini2.z.string()),
-  amazonqcli: import_mini2.z.optional(import_mini2.z.string()),
-  augmentcode: import_mini2.z.optional(import_mini2.z.string()),
-  "augmentcode-legacy": import_mini2.z.optional(import_mini2.z.string()),
-  copilot: import_mini2.z.optional(import_mini2.z.string()),
-  cursor: import_mini2.z.optional(import_mini2.z.string()),
-  cline: import_mini2.z.optional(import_mini2.z.string()),
-  claudecode: import_mini2.z.optional(import_mini2.z.string()),
-  codexcli: import_mini2.z.optional(import_mini2.z.string()),
-  opencode: import_mini2.z.optional(import_mini2.z.string()),
-  qwencode: import_mini2.z.optional(import_mini2.z.string()),
-  roo: import_mini2.z.optional(import_mini2.z.string()),
-  geminicli: import_mini2.z.optional(import_mini2.z.string()),
-  kiro: import_mini2.z.optional(import_mini2.z.string()),
-  junie: import_mini2.z.optional(import_mini2.z.string()),
-  windsurf: import_mini2.z.optional(import_mini2.z.string())
-});
-var ConfigOptionsSchema = import_mini2.z.object({
-  aiRulesDir: import_mini2.z.optional(import_mini2.z.string()),
-  outputPaths: import_mini2.z.optional(OutputPathsSchema),
-  watchEnabled: import_mini2.z.optional(import_mini2.z.boolean()),
-  defaultTargets: import_mini2.z.optional(ToolTargetsSchema),
-  targets: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
-  exclude: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
-  features: import_mini2.z.optional(FeaturesSchema),
-  verbose: import_mini2.z.optional(import_mini2.z.boolean()),
-  delete: import_mini2.z.optional(import_mini2.z.boolean()),
-  baseDir: import_mini2.z.optional(import_mini2.z.union([import_mini2.z.string(), import_mini2.z.array(import_mini2.z.string())])),
-  legacy: import_mini2.z.optional(import_mini2.z.boolean()),
-  watch: import_mini2.z.optional(
-    import_mini2.z.object({
-      enabled: import_mini2.z.optional(import_mini2.z.boolean()),
-      interval: import_mini2.z.optional(import_mini2.z.number()),
-      ignore: import_mini2.z.optional(import_mini2.z.array(import_mini2.z.string()))
-    })
-  )
-});
-var MergedConfigSchema = import_mini2.z.object({
-  aiRulesDir: import_mini2.z.string(),
-  outputPaths: import_mini2.z.record(ToolTargetSchema, import_mini2.z.string()),
-  watchEnabled: import_mini2.z.boolean(),
-  defaultTargets: ToolTargetsSchema,
-  targets: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
-  exclude: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
-  features: import_mini2.z.optional(FeaturesSchema),
-  verbose: import_mini2.z.optional(import_mini2.z.boolean()),
-  delete: import_mini2.z.optional(import_mini2.z.boolean()),
-  baseDir: import_mini2.z.optional(import_mini2.z.union([import_mini2.z.string(), import_mini2.z.array(import_mini2.z.string())])),
-  configPath: import_mini2.z.optional(import_mini2.z.string()),
-  legacy: import_mini2.z.optional(import_mini2.z.boolean()),
-  watch: import_mini2.z.optional(
-    import_mini2.z.object({
-      enabled: import_mini2.z.optional(import_mini2.z.boolean()),
-      interval: import_mini2.z.optional(import_mini2.z.number()),
-      ignore: import_mini2.z.optional(import_mini2.z.array(import_mini2.z.string()))
-    })
-  )
-});
+var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
+var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
+var FeatureSchema = import_mini.z.enum(ALL_FEATURES);
+var FeaturesSchema = import_mini.z.array(FeatureSchema);
+var RulesyncFeaturesSchema = import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD));
 
 // src/utils/file.ts
 var import_node_fs = require("fs");
@@ -430,6 +345,32 @@ var RulesyncFile = class extends AiFile {
   }
 };
 
+// src/types/tool-targets.ts
+var import_mini2 = require("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 = import_mini2.z.enum(ALL_TOOL_TARGETS);
+var ToolTargetsSchema = import_mini2.z.array(ToolTargetSchema);
+var RulesyncTargetsSchema = import_mini2.z.array(import_mini2.z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
+
 // src/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = import_mini3.z.object({
   targets: RulesyncTargetsSchema,
@@ -532,6 +473,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
@@ -612,6 +586,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,
@@ -772,6 +752,12 @@ var CodexCliCommand = class _CodexCliCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/commands/copilot-command.ts
@@ -816,6 +802,12 @@ var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/commands/cursor-command.ts
@@ -860,6 +852,12 @@ var CursorCommand = class _CursorCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "cursor"
+    });
+  }
 };
 
 // src/commands/geminicli-command.ts
@@ -896,17 +894,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;
   }
@@ -981,6 +968,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
@@ -1066,6 +1059,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,
@@ -1117,31 +1116,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
@@ -1149,7 +1166,9 @@ var CommandsProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
+    }).filter(
+      (command) => command !== null
+    );
     return toolCommands;
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -1309,14 +1328,6 @@ var CommandsProcessor = class extends FeatureProcessor {
 // src/config/config-resolver.ts
 var import_c12 = require("c12");
 
-// src/types/features.ts
-var import_mini9 = require("zod/mini");
-var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
-var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
-var FeatureSchema = import_mini9.z.enum(ALL_FEATURES);
-var FeaturesSchema2 = import_mini9.z.array(FeatureSchema);
-var RulesyncFeaturesSchema = import_mini9.z.array(import_mini9.z.enum(ALL_FEATURES_WITH_WILDCARD));
-
 // src/config/config.ts
 var Config = class {
   baseDirs;
@@ -1431,7 +1442,7 @@ var ConfigResolver = class {
 };
 
 // src/ignore/ignore-processor.ts
-var import_mini10 = require("zod/mini");
+var import_mini9 = require("zod/mini");
 
 // src/ignore/amazonqcli-ignore.ts
 var import_node_path12 = require("path");
@@ -2043,7 +2054,7 @@ var ignoreProcessorToolTargets = [
   "roo",
   "windsurf"
 ];
-var IgnoreProcessorToolTargetSchema = import_mini10.z.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = import_mini9.z.enum(ignoreProcessorToolTargets);
 var IgnoreProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2205,47 +2216,40 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-var import_mini12 = require("zod/mini");
+var import_mini11 = require("zod/mini");
 
 // src/mcp/amazonqcli-mcp.ts
 var import_node_path24 = require("path");
 
 // src/mcp/rulesync-mcp.ts
 var import_node_path23 = require("path");
-
-// src/types/mcp.ts
-var import_mini11 = require("zod/mini");
-var McpTransportTypeSchema = import_mini11.z.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = import_mini11.z.object({
-  type: import_mini11.z.optional(import_mini11.z.enum(["stdio", "sse", "http"])),
-  command: import_mini11.z.optional(import_mini11.z.union([import_mini11.z.string(), import_mini11.z.array(import_mini11.z.string())])),
-  args: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
-  url: import_mini11.z.optional(import_mini11.z.string()),
-  httpUrl: import_mini11.z.optional(import_mini11.z.string()),
-  env: import_mini11.z.optional(import_mini11.z.record(import_mini11.z.string(), import_mini11.z.string())),
-  disabled: import_mini11.z.optional(import_mini11.z.boolean()),
-  networkTimeout: import_mini11.z.optional(import_mini11.z.number()),
-  timeout: import_mini11.z.optional(import_mini11.z.number()),
-  trust: import_mini11.z.optional(import_mini11.z.boolean()),
-  cwd: import_mini11.z.optional(import_mini11.z.string()),
-  transport: import_mini11.z.optional(McpTransportTypeSchema),
-  alwaysAllow: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
-  tools: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
-  kiroAutoApprove: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
-  kiroAutoBlock: import_mini11.z.optional(import_mini11.z.array(import_mini11.z.string())),
-  headers: import_mini11.z.optional(import_mini11.z.record(import_mini11.z.string(), import_mini11.z.string()))
-});
-var RulesyncMcpServerSchema = import_mini11.z.extend(McpServerBaseSchema, {
-  targets: import_mini11.z.optional(RulesyncTargetsSchema)
+var import_mini10 = require("zod/mini");
+var McpTransportTypeSchema = import_mini10.z.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = import_mini10.z.object({
+  type: import_mini10.z.optional(import_mini10.z.enum(["stdio", "sse", "http"])),
+  command: import_mini10.z.optional(import_mini10.z.union([import_mini10.z.string(), import_mini10.z.array(import_mini10.z.string())])),
+  args: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
+  url: import_mini10.z.optional(import_mini10.z.string()),
+  httpUrl: import_mini10.z.optional(import_mini10.z.string()),
+  env: import_mini10.z.optional(import_mini10.z.record(import_mini10.z.string(), import_mini10.z.string())),
+  disabled: import_mini10.z.optional(import_mini10.z.boolean()),
+  networkTimeout: import_mini10.z.optional(import_mini10.z.number()),
+  timeout: import_mini10.z.optional(import_mini10.z.number()),
+  trust: import_mini10.z.optional(import_mini10.z.boolean()),
+  cwd: import_mini10.z.optional(import_mini10.z.string()),
+  transport: import_mini10.z.optional(McpTransportTypeSchema),
+  alwaysAllow: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
+  tools: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
+  kiroAutoApprove: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
+  kiroAutoBlock: import_mini10.z.optional(import_mini10.z.array(import_mini10.z.string())),
+  headers: import_mini10.z.optional(import_mini10.z.record(import_mini10.z.string(), import_mini10.z.string()))
 });
-var McpConfigSchema = import_mini11.z.object({
-  mcpServers: import_mini11.z.record(import_mini11.z.string(), McpServerBaseSchema)
+var RulesyncMcpServerSchema = import_mini10.z.extend(McpServerBaseSchema, {
+  targets: import_mini10.z.optional(RulesyncTargetsSchema)
 });
-var RulesyncMcpConfigSchema = import_mini11.z.object({
-  mcpServers: import_mini11.z.record(import_mini11.z.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = import_mini10.z.object({
+  mcpServers: import_mini10.z.record(import_mini10.z.string(), RulesyncMcpServerSchema)
 });
-
-// src/mcp/rulesync-mcp.ts
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
   constructor({ ...rest }) {
@@ -2637,7 +2641,7 @@ var mcpProcessorToolTargets = [
   "cursor",
   "roo"
 ];
-var McpProcessorToolTargetSchema = import_mini12.z.enum(mcpProcessorToolTargets);
+var McpProcessorToolTargetSchema = import_mini11.z.enum(mcpProcessorToolTargets);
 var McpProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2798,7 +2802,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/rules/rules-processor.ts
 var import_node_path50 = require("path");
 var import_fast_xml_parser = require("fast-xml-parser");
-var import_mini18 = require("zod/mini");
+var import_mini17 = require("zod/mini");
 
 // src/constants/paths.ts
 var import_node_path30 = require("path");
@@ -2810,7 +2814,7 @@ var RULESYNC_SUBAGENTS_DIR = (0, import_node_path30.join)(".rulesync", "subagent
 
 // src/subagents/simulated-subagent.ts
 var import_node_path31 = require("path");
-var import_mini13 = require("zod/mini");
+var import_mini12 = require("zod/mini");
 
 // src/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -2823,12 +2827,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 = import_mini13.z.object({
-  name: import_mini13.z.string(),
-  description: import_mini13.z.string()
+var SimulatedSubagentFrontmatterSchema = import_mini12.z.object({
+  name: import_mini12.z.string(),
+  description: import_mini12.z.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -2925,6 +2948,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
@@ -2942,6 +2971,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
@@ -2959,6 +2994,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
@@ -2966,17 +3007,17 @@ var import_node_path33 = require("path");
 
 // src/rules/rulesync-rule.ts
 var import_node_path32 = require("path");
-var import_mini14 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini14.z.object({
-  root: import_mini14.z.optional(import_mini14.z.optional(import_mini14.z.boolean())),
-  targets: import_mini14.z.optional(RulesyncTargetsSchema),
-  description: import_mini14.z.optional(import_mini14.z.string()),
-  globs: import_mini14.z.optional(import_mini14.z.array(import_mini14.z.string())),
-  cursor: import_mini14.z.optional(
-    import_mini14.z.object({
-      alwaysApply: import_mini14.z.optional(import_mini14.z.boolean()),
-      description: import_mini14.z.optional(import_mini14.z.string()),
-      globs: import_mini14.z.optional(import_mini14.z.array(import_mini14.z.string()))
+var import_mini13 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini13.z.object({
+  root: import_mini13.z.optional(import_mini13.z.optional(import_mini13.z.boolean())),
+  targets: import_mini13.z.optional(RulesyncTargetsSchema),
+  description: import_mini13.z.optional(import_mini13.z.string()),
+  globs: import_mini13.z.optional(import_mini13.z.array(import_mini13.z.string())),
+  cursor: import_mini13.z.optional(
+    import_mini13.z.object({
+      alwaysApply: import_mini13.z.optional(import_mini13.z.boolean()),
+      description: import_mini13.z.optional(import_mini13.z.string()),
+      globs: import_mini13.z.optional(import_mini13.z.array(import_mini13.z.string()))
     })
   )
 });
@@ -3129,6 +3170,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
@@ -3189,6 +3249,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
@@ -3238,6 +3304,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
@@ -3288,6 +3360,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,
@@ -3355,6 +3433,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
@@ -3409,13 +3493,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
 var import_node_path38 = require("path");
-var import_mini15 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini15.z.object({
-  description: import_mini15.z.string()
+var import_mini14 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini14.z.object({
+  description: import_mini14.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -3445,6 +3535,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,
@@ -3515,14 +3611,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
 var import_node_path40 = require("path");
-var import_mini16 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini16.z.object({
-  description: import_mini16.z.optional(import_mini16.z.string()),
-  applyTo: import_mini16.z.optional(import_mini16.z.string())
+var import_mini15 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini15.z.object({
+  description: import_mini15.z.optional(import_mini15.z.string()),
+  applyTo: import_mini15.z.optional(import_mini15.z.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -3663,15 +3765,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
 var import_node_path41 = require("path");
-var import_mini17 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini17.z.object({
-  description: import_mini17.z.optional(import_mini17.z.string()),
-  globs: import_mini17.z.optional(import_mini17.z.string()),
-  alwaysApply: import_mini17.z.optional(import_mini17.z.boolean())
+var import_mini16 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini16.z.object({
+  description: import_mini16.z.optional(import_mini16.z.string()),
+  globs: import_mini16.z.optional(import_mini16.z.string()),
+  alwaysApply: import_mini16.z.optional(import_mini16.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -3831,6 +3939,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
@@ -3885,6 +3999,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
@@ -3939,6 +4059,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
@@ -3988,6 +4114,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
@@ -4042,6 +4174,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
@@ -4093,6 +4231,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
@@ -4157,6 +4301,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
@@ -4218,6 +4368,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
@@ -4266,6 +4422,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
@@ -4288,7 +4450,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini18.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini17.z.enum(rulesProcessorToolTargets);
 var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
@@ -4311,102 +4473,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,
@@ -4415,7 +4628,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({
@@ -5005,22 +5218,22 @@ When users call a simulated subagent, it will look for the corresponding markdow
 
 // src/subagents/subagents-processor.ts
 var import_node_path53 = require("path");
-var import_mini21 = require("zod/mini");
+var import_mini20 = require("zod/mini");
 
 // src/subagents/claudecode-subagent.ts
 var import_node_path52 = require("path");
-var import_mini20 = require("zod/mini");
+var import_mini19 = require("zod/mini");
 
 // src/subagents/rulesync-subagent.ts
 var import_node_path51 = require("path");
-var import_mini19 = require("zod/mini");
-var RulesyncSubagentModelSchema = import_mini19.z.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = import_mini19.z.object({
+var import_mini18 = require("zod/mini");
+var RulesyncSubagentModelSchema = import_mini18.z.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = import_mini18.z.object({
   targets: RulesyncTargetsSchema,
-  name: import_mini19.z.string(),
-  description: import_mini19.z.string(),
-  claudecode: import_mini19.z.optional(
-    import_mini19.z.object({
+  name: import_mini18.z.string(),
+  description: import_mini18.z.string(),
+  claudecode: import_mini18.z.optional(
+    import_mini18.z.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -5085,10 +5298,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = import_mini20.z.object({
-  name: import_mini20.z.string(),
-  description: import_mini20.z.string(),
-  model: import_mini20.z.optional(import_mini20.z.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = import_mini19.z.object({
+  name: import_mini19.z.string(),
+  description: import_mini19.z.string(),
+  model: import_mini19.z.optional(import_mini19.z.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -5173,6 +5386,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,
@@ -5208,7 +5427,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "cursor",
   "codexcli"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini21.z.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = import_mini20.z.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -5225,24 +5444,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,
@@ -5251,7 +5482,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
+    }).filter((subagent) => subagent !== null);
     return toolSubagents;
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -5558,7 +5789,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(" + ")})`);
@@ -5829,7 +6060,7 @@ var getVersion = async () => {
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.74.0";
+    return "0.75.0";
   }
 };
 var main = async () => {
@@ -5851,7 +6082,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());
     }
@@ -5876,7 +6107,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());
     }