rulesync 8.0.0 → 8.2.0

package/dist/index.cjs

@@ -262,12 +262,13 @@ var FeaturesSchema = import_mini.z.array(FeatureSchema);
 var FeatureOptionsSchema = import_mini.z.record(import_mini.z.string(), import_mini.z.unknown());
 var FeatureValueSchema = import_mini.z.union([import_mini.z.boolean(), FeatureOptionsSchema]);
 var PerFeatureConfigSchema = import_mini.z.record(import_mini.z.string(), FeatureValueSchema);
+var PerTargetFeaturesValueSchema = import_mini.z.union([
+  import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)),
+  PerFeatureConfigSchema
+]);
 var RulesyncFeaturesSchema = import_mini.z.union([
   import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)),
-  import_mini.z.record(
-    import_mini.z.string(),
-    import_mini.z.union([import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)), PerFeatureConfigSchema])
-  )
+  import_mini.z.record(import_mini.z.string(), PerTargetFeaturesValueSchema)
 ]);
 var isFeatureValueEnabled = (value) => {
   if (value === true) return true;
@@ -310,6 +311,14 @@ 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));
+var RulesyncConfigTargetsObjectSchema = import_mini2.z.record(import_mini2.z.string(), PerTargetFeaturesValueSchema);
+var RulesyncConfigTargetsSchema = import_mini2.z.union([
+  RulesyncTargetsSchema,
+  RulesyncConfigTargetsObjectSchema
+]);
+var isRulesyncConfigTargetsObject = (value) => {
+  return !Array.isArray(value);
+};
 
 // src/utils/validation.ts
 function findControlCharacter(value) {
@@ -346,7 +355,7 @@ var SourceEntrySchema = import_mini3.z.object({
 });
 var ConfigParamsSchema = import_mini3.z.object({
   baseDirs: import_mini3.z.array(import_mini3.z.string()),
-  targets: RulesyncTargetsSchema,
+  targets: RulesyncConfigTargetsSchema,
   features: RulesyncFeaturesSchema,
   verbose: import_mini3.z.boolean(),
   delete: import_mini3.z.boolean(),
@@ -356,6 +365,7 @@ var ConfigParamsSchema = import_mini3.z.object({
   simulateCommands: (0, import_mini3.optional)(import_mini3.z.boolean()),
   simulateSubagents: (0, import_mini3.optional)(import_mini3.z.boolean()),
   simulateSkills: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  gitignoreTargetsOnly: (0, import_mini3.optional)(import_mini3.z.boolean()),
   dryRun: (0, import_mini3.optional)(import_mini3.z.boolean()),
   check: (0, import_mini3.optional)(import_mini3.z.boolean()),
   // Declarative skill sources
@@ -372,10 +382,42 @@ var CONFLICTING_TARGET_PAIRS = [
   ["claudecode", "claudecode-legacy"]
 ];
 var LEGACY_TARGETS = ["augmentcode-legacy", "claudecode-legacy"];
+var assertTargetsFeaturesExclusive = ({
+  targets,
+  features
+}) => {
+  const targetsIsObject = targets !== void 0 && !Array.isArray(targets);
+  const featuresIsObject = features !== void 0 && !Array.isArray(features);
+  if (targetsIsObject && features !== void 0) {
+    throw new Error(
+      "Invalid config: when 'targets' is in object form, 'features' must be omitted. Declare per-target features inside the 'targets' object instead."
+    );
+  }
+  if (featuresIsObject && targets !== void 0) {
+    throw new Error(
+      "Invalid config: when 'features' is in object form, 'targets' must be omitted. Migrate to the 'targets' object form, e.g. `targets: { claudecode: [...] }`."
+    );
+  }
+};
+var assertTargetsOrFeaturesProvided = ({
+  targets,
+  features
+}) => {
+  if (targets === void 0 && features === void 0) {
+    throw new Error("Invalid config: at least one of 'targets' or 'features' must be provided.");
+  }
+};
 var Config = class _Config {
   baseDirs;
   targets;
   features;
+  /**
+   * Cached list of validated `ToolTarget` keys for the object form of
+   * `targets`. Populated in the constructor after `validateObjectFormTargetKeys`
+   * so `getTargets()` does not rebuild the `ALL_TOOL_TARGETS` set on every call.
+   * Undefined when `this.targets` is in array form.
+   */
+  objectFormTargetKeys;
   verbose;
   delete;
   global;
@@ -383,6 +425,7 @@ var Config = class _Config {
   simulateCommands;
   simulateSubagents;
   simulateSkills;
+  gitignoreTargetsOnly;
   dryRun;
   check;
   sources;
@@ -397,17 +440,24 @@ var Config = class _Config {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
+    gitignoreTargetsOnly,
     dryRun,
     check,
     sources
   }) {
-    this.validateConflictingTargets(targets);
+    assertTargetsFeaturesExclusive({ targets, features });
+    assertTargetsOrFeaturesProvided({ targets, features });
+    const resolvedTargets = targets ?? [];
+    const resolvedFeatures = features ?? [];
+    this.validateObjectFormTargetKeys(resolvedTargets);
+    this.validateConflictingTargets(resolvedTargets);
     if (dryRun && check) {
       throw new Error("--dry-run and --check cannot be used together");
     }
     this.baseDirs = baseDirs;
-    this.targets = targets;
-    this.features = features;
+    this.targets = resolvedTargets;
+    this.features = resolvedFeatures;
+    this.objectFormTargetKeys = isRulesyncConfigTargetsObject(resolvedTargets) ? _Config.filterValidToolTargets(Object.keys(resolvedTargets)) : void 0;
     this.verbose = verbose;
     this.delete = isDelete;
     this.global = global ?? false;
@@ -415,15 +465,42 @@ var Config = class _Config {
     this.simulateCommands = simulateCommands ?? false;
     this.simulateSubagents = simulateSubagents ?? false;
     this.simulateSkills = simulateSkills ?? false;
+    this.gitignoreTargetsOnly = gitignoreTargetsOnly ?? true;
     this.dryRun = dryRun ?? false;
     this.check = check ?? false;
     this.sources = sources ?? [];
   }
+  /**
+   * Rejects unknown keys (and the special `*` key) in the object form of
+   * `targets`. For the array form this is already enforced at the Zod schema
+   * level via `z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD)`; for the object form
+   * `z.record(z.string(), ...)` intentionally accepts any string key (to work
+   * around zod's `z.record(z.enum(...))` requiring ALL enum members), so
+   * runtime validation lives here instead.
+   */
+  validateObjectFormTargetKeys(targets) {
+    if (Array.isArray(targets)) return;
+    const validTargets = new Set(ALL_TOOL_TARGETS);
+    for (const key of Object.keys(targets)) {
+      if (key === "*") {
+        throw new Error(
+          "Invalid target '*' in object form: wildcard is only supported in the array form `targets: ['*']`. Per-target options cannot be attached to a wildcard."
+        );
+      }
+      if (!validTargets.has(key)) {
+        throw new Error(`Unknown target '${key}'. Valid targets: ${ALL_TOOL_TARGETS.join(", ")}.`);
+      }
+    }
+  }
   validateConflictingTargets(targets) {
+    const has = (target) => {
+      if (Array.isArray(targets)) {
+        return targets.includes(target);
+      }
+      return Object.prototype.hasOwnProperty.call(targets, target);
+    };
     for (const [target1, target2] of CONFLICTING_TARGET_PAIRS) {
-      const hasTarget1 = targets.includes(target1);
-      const hasTarget2 = targets.includes(target2);
-      if (hasTarget1 && hasTarget2) {
+      if (has(target1) && has(target2)) {
         throw new Error(
           `Conflicting targets: '${target1}' and '${target2}' cannot be used together. Please choose one.`
         );
@@ -433,16 +510,45 @@ var Config = class _Config {
   getBaseDirs() {
     return this.baseDirs;
   }
+  /**
+   * Filter an arbitrary string-key list down to the known `ToolTarget` set,
+   * skipping `*` (which is only meaningful as an array element, not a key).
+   */
+  static filterValidToolTargets(keys) {
+    const validTargets = new Set(ALL_TOOL_TARGETS);
+    const result = [];
+    for (const key of keys) {
+      if (key === "*") continue;
+      if (!validTargets.has(key)) continue;
+      result.push(key);
+    }
+    return result;
+  }
   getTargets() {
-    if (this.targets.includes("*")) {
+    if (this.objectFormTargetKeys !== void 0) {
+      return this.objectFormTargetKeys;
+    }
+    const arrayTargets = Array.isArray(this.targets) ? this.targets : [];
+    if (!Array.isArray(this.features)) {
+      return _Config.filterValidToolTargets(Object.keys(this.features));
+    }
+    if (arrayTargets.includes("*")) {
       return ALL_TOOL_TARGETS.filter(
         // eslint-disable-next-line no-type-assertion/no-type-assertion
         (target) => !LEGACY_TARGETS.includes(target)
       );
     }
-    return this.targets.filter((target) => target !== "*");
+    return arrayTargets.filter((target) => target !== "*");
   }
   getFeatures(target) {
+    if (isRulesyncConfigTargetsObject(this.targets)) {
+      if (target) {
+        const value = this.targets[target];
+        if (!value) return [];
+        return _Config.normalizeTargetFeatures(value);
+      }
+      return _Config.collectAllFeatures(Object.values(this.targets));
+    }
     if (!Array.isArray(this.features)) {
       const perTargetFeatures = this.features;
       if (target) {
@@ -452,20 +558,7 @@ var Config = class _Config {
         }
         return _Config.normalizeTargetFeatures(targetFeatures);
       }
-      const allFeatures = [];
-      for (const features of Object.values(perTargetFeatures)) {
-        if (!features) continue;
-        const normalized = _Config.normalizeTargetFeatures(features);
-        for (const feature of normalized) {
-          if (!allFeatures.includes(feature)) {
-            allFeatures.push(feature);
-          }
-        }
-        if (allFeatures.length === ALL_FEATURES.length) {
-          return allFeatures;
-        }
-      }
-      return allFeatures;
+      return _Config.collectAllFeatures(Object.values(perTargetFeatures));
     }
     if (this.features.includes("*")) {
       return [...ALL_FEATURES];
@@ -493,23 +586,40 @@ var Config = class _Config {
     }
     return enabled;
   }
+  /**
+   * Collect the union of features across all per-target values.
+   * Used when `getFeatures()` is called without a target in object mode.
+   */
+  static collectAllFeatures(values) {
+    const allFeatures = [];
+    for (const value of values) {
+      if (!value) continue;
+      const normalized = _Config.normalizeTargetFeatures(value);
+      for (const feature of normalized) {
+        if (!allFeatures.includes(feature)) {
+          allFeatures.push(feature);
+        }
+      }
+      if (allFeatures.length === ALL_FEATURES.length) {
+        return allFeatures;
+      }
+    }
+    return allFeatures;
+  }
   /**
    * Returns the per-feature options object for a given target/feature, if any.
    * Returns `undefined` when no per-feature options were provided or when the
    * feature is not enabled for the given target.
    */
   getFeatureOptions(target, feature) {
-    if (Array.isArray(this.features)) {
+    const value = isRulesyncConfigTargetsObject(this.targets) ? this.targets[target] : !Array.isArray(this.features) ? this.features[target] : void 0;
+    if (!value || Array.isArray(value)) {
       return void 0;
     }
-    const targetFeatures = this.features[target];
-    if (!targetFeatures || Array.isArray(targetFeatures)) {
-      return void 0;
-    }
-    const perFeature = targetFeatures;
-    const value = perFeature[feature];
-    if (value && typeof value === "object" && isFeatureValueEnabled(value)) {
-      return value;
+    const perFeature = value;
+    const featureValue = perFeature[feature];
+    if (featureValue && typeof featureValue === "object" && isFeatureValueEnabled(featureValue)) {
+      return featureValue;
     }
     return void 0;
   }
@@ -517,6 +627,13 @@ var Config = class _Config {
    * Check if per-target features configuration is being used.
    */
   hasPerTargetFeatures() {
+    return isRulesyncConfigTargetsObject(this.targets) || !Array.isArray(this.features);
+  }
+  /**
+   * Returns true if the deprecated object form under `features` is in use.
+   * Callers can use this to emit a migration warning.
+   */
+  hasDeprecatedFeaturesObjectForm() {
     return !Array.isArray(this.features);
   }
   getVerbose() {
@@ -540,6 +657,9 @@ var Config = class _Config {
   getSimulateSkills() {
     return this.simulateSkills;
   }
+  getGitignoreTargetsOnly() {
+    return this.gitignoreTargetsOnly;
+  }
   getDryRun() {
     return this.dryRun;
   }
@@ -558,6 +678,17 @@ var Config = class _Config {
   }
 };
 
+// src/config/deprecation-warnings.ts
+var deprecationWarningEmitted = false;
+var emitFeaturesObjectFormDeprecationWarning = () => {
+  if (deprecationWarningEmitted) return;
+  if (process.env.RULESYNC_SILENT_DEPRECATION) return;
+  deprecationWarningEmitted = true;
+  console.warn(
+    "[rulesync] DEPRECATED: 'features' object form is deprecated. Use the new 'targets' object form instead: `targets: { claudecode: { rules: true, ignore: { fileMode: 'local' } } }`. See https://github.com/dyoshikawa/rulesync/blob/main/docs/guide/configuration.md for the migration guide."
+  );
+};
+
 // src/config/config-resolver.ts
 var getDefaults = () => ({
   targets: ["agentsmd"],
@@ -571,6 +702,7 @@ var getDefaults = () => ({
   simulateCommands: false,
   simulateSubagents: false,
   simulateSkills: false,
+  gitignoreTargetsOnly: true,
   dryRun: false,
   check: false,
   sources: []
@@ -583,6 +715,10 @@ var loadConfigFromFile = async (filePath) => {
   const jsonData = (0, import_jsonc_parser.parse)(fileContent);
   const parsed = ConfigFileSchema.parse(jsonData);
   const { $schema: _schema, ...configParams } = parsed;
+  assertTargetsFeaturesExclusive({
+    targets: configParams.targets,
+    features: configParams.features
+  });
   return configParams;
 };
 var mergeConfigs = (baseConfig, localConfig) => {
@@ -597,6 +733,7 @@ var mergeConfigs = (baseConfig, localConfig) => {
     simulateCommands: localConfig.simulateCommands ?? baseConfig.simulateCommands,
     simulateSubagents: localConfig.simulateSubagents ?? baseConfig.simulateSubagents,
     simulateSkills: localConfig.simulateSkills ?? baseConfig.simulateSkills,
+    gitignoreTargetsOnly: localConfig.gitignoreTargetsOnly ?? baseConfig.gitignoreTargetsOnly,
     dryRun: localConfig.dryRun ?? baseConfig.dryRun,
     check: localConfig.check ?? baseConfig.check,
     sources: localConfig.sources ?? baseConfig.sources
@@ -615,6 +752,7 @@ var ConfigResolver = class {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
+    gitignoreTargetsOnly,
     dryRun,
     check
   }) {
@@ -624,13 +762,35 @@ var ConfigResolver = class {
     const localConfigPath = (0, import_node_path4.join)(configDir, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
     const localConfig = await loadConfigFromFile(localConfigPath);
     const configByFile = mergeConfigs(baseConfig, localConfig);
+    try {
+      assertTargetsFeaturesExclusive({
+        targets: configByFile.targets,
+        features: configByFile.features
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `${detail} (detected after merging '${validatedConfigPath}' with '${localConfigPath}' \u2014 the two files combined produce the invalid combination; remove the conflicting field from one of them).`,
+        { cause: error }
+      );
+    }
     const resolvedGlobal = global ?? configByFile.global ?? getDefaults().global;
     const resolvedSimulateCommands = simulateCommands ?? configByFile.simulateCommands ?? getDefaults().simulateCommands;
     const resolvedSimulateSubagents = simulateSubagents ?? configByFile.simulateSubagents ?? getDefaults().simulateSubagents;
     const resolvedSimulateSkills = simulateSkills ?? configByFile.simulateSkills ?? getDefaults().simulateSkills;
+    const resolvedGitignoreTargetsOnly = gitignoreTargetsOnly ?? configByFile.gitignoreTargetsOnly ?? getDefaults().gitignoreTargetsOnly;
+    const userProvidedFeatures = features ?? configByFile.features;
+    const userProvidedTargets = targets ?? configByFile.targets;
+    const targetsIsObject = userProvidedTargets !== void 0 && !Array.isArray(userProvidedTargets);
+    const featuresIsObject = userProvidedFeatures !== void 0 && !Array.isArray(userProvidedFeatures);
+    if (featuresIsObject) {
+      emitFeaturesObjectFormDeprecationWarning();
+    }
+    const resolvedFeatures = userProvidedFeatures ?? (targetsIsObject ? void 0 : getDefaults().features);
+    const resolvedTargets = userProvidedTargets ?? (featuresIsObject ? void 0 : getDefaults().targets);
     const configParams = {
-      targets: targets ?? configByFile.targets ?? getDefaults().targets,
-      features: features ?? configByFile.features ?? getDefaults().features,
+      targets: resolvedTargets,
+      features: resolvedFeatures,
       verbose: verbose ?? configByFile.verbose ?? getDefaults().verbose,
       delete: isDelete ?? configByFile.delete ?? getDefaults().delete,
       baseDirs: getBaseDirsInLightOfGlobal({
@@ -642,6 +802,7 @@ var ConfigResolver = class {
       simulateCommands: resolvedSimulateCommands,
       simulateSubagents: resolvedSimulateSubagents,
       simulateSkills: resolvedSimulateSkills,
+      gitignoreTargetsOnly: resolvedGitignoreTargetsOnly,
       dryRun: dryRun ?? configByFile.dryRun ?? getDefaults().dryRun,
       check: check ?? configByFile.check ?? getDefaults().check,
       sources: configByFile.sources ?? getDefaults().sources
@@ -14807,12 +14968,16 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
     const body = rulesyncSubagent.getBody();
     const fileContent = stringifyFrontmatter(body, copilotFrontmatter);
     const paths = this.getSettablePaths({ global });
+    let relativeFilePath = rulesyncSubagent.getRelativeFilePath();
+    if (!relativeFilePath.endsWith(".agent.md")) {
+      relativeFilePath = relativeFilePath.replace(/\.md$/, ".agent.md");
+    }
     return new _CopilotSubagent({
       baseDir,
       frontmatter: copilotFrontmatter,
       body,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+      relativeFilePath,
       fileContent,
       validate,
       global
@@ -19331,7 +19496,8 @@ var rulesProcessorToolTargets = [
 var RulesProcessorToolTargetSchema = import_mini70.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path138.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
 var RulesFeatureOptionsSchema = import_mini70.z.looseObject({
-  ruleDiscoveryMode: import_mini70.z.optional(import_mini70.z.enum(["none", "explicit"]))
+  ruleDiscoveryMode: import_mini70.z.optional(import_mini70.z.enum(["none", "explicit"])),
+  includeLocalRoot: import_mini70.z.optional(import_mini70.z.boolean())
 });
 var resolveRuleDiscoveryMode = ({
   defaultMode,
@@ -19352,6 +19518,19 @@ var resolveRuleDiscoveryMode = ({
   }
   return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
 };
+var IncludeLocalRootSchema = import_mini70.z.looseObject({
+  includeLocalRoot: import_mini70.z.optional(import_mini70.z.boolean())
+});
+var resolveIncludeLocalRoot = (options) => {
+  if (!options) return true;
+  const parsed = IncludeLocalRootSchema.safeParse(options);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid options for rules feature: ${parsed.error.message}. \`includeLocalRoot\` must be a boolean.`
+    );
+  }
+  return parsed.data.includeLocalRoot ?? true;
+};
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -19715,7 +19894,8 @@ var RulesProcessor = class extends FeatureProcessor {
         global: this.global
       });
     }).filter((rule) => rule !== null);
-    if (localRootRules.length > 0 && !this.global) {
+    const includeLocalRoot = resolveIncludeLocalRoot(this.featureOptions);
+    if (localRootRules.length > 0 && !this.global && includeLocalRoot) {
       const localRootRule = localRootRules[0];
       if (localRootRule && factory.class.isTargetedByRulesyncRule(localRootRule)) {
         this.handleLocalRootRule(toolRules, localRootRule, factory);

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   checkRulesyncDirExists,
   generate,
   importFromTool
-} from "./chunk-GB6XLCGB.js";
+} from "./chunk-K4IN6URH.js";
 
 // src/index.ts
 async function generate2(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulesync",
-  "version": "8.0.0",
+  "version": "8.2.0",
   "description": "Unified AI rules management CLI tool that generates configuration files for various AI development tools",
   "keywords": [
     "ai",
@@ -96,6 +96,7 @@
     "tsx": "4.21.0",
     "typescript": "5.9.3",
     "typescript-eslint": "8.57.1",
+    "vite": "7.3.1",
     "vitepress": "1.6.4",
     "vitest": "4.1.0"
   },