rulesync 8.0.0 → 8.2.0

package/dist/cli/index.cjs

@@ -44,12 +44,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;
@@ -951,6 +952,14 @@ var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
 var ToolTargetSchema = import_mini3.z.enum(ALL_TOOL_TARGETS);
 var ToolTargetsSchema = import_mini3.z.array(ToolTargetSchema);
 var RulesyncTargetsSchema = import_mini3.z.array(import_mini3.z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
+var RulesyncConfigTargetsObjectSchema = import_mini3.z.record(import_mini3.z.string(), PerTargetFeaturesValueSchema);
+var RulesyncConfigTargetsSchema = import_mini3.z.union([
+  RulesyncTargetsSchema,
+  RulesyncConfigTargetsObjectSchema
+]);
+var isRulesyncConfigTargetsObject = (value) => {
+  return !Array.isArray(value);
+};
 
 // src/features/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = import_mini4.z.looseObject({
@@ -13495,12 +13504,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
@@ -18019,7 +18032,8 @@ var rulesProcessorToolTargets = [
 var RulesProcessorToolTargetSchema = import_mini65.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path131.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
 var RulesFeatureOptionsSchema = import_mini65.z.looseObject({
-  ruleDiscoveryMode: import_mini65.z.optional(import_mini65.z.enum(["none", "explicit"]))
+  ruleDiscoveryMode: import_mini65.z.optional(import_mini65.z.enum(["none", "explicit"])),
+  includeLocalRoot: import_mini65.z.optional(import_mini65.z.boolean())
 });
 var resolveRuleDiscoveryMode = ({
   defaultMode,
@@ -18040,6 +18054,19 @@ var resolveRuleDiscoveryMode = ({
   }
   return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
 };
+var IncludeLocalRootSchema = import_mini65.z.looseObject({
+  includeLocalRoot: import_mini65.z.optional(import_mini65.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",
@@ -18403,7 +18430,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);
@@ -19975,7 +20003,7 @@ var SourceEntrySchema = import_mini69.z.object({
 });
 var ConfigParamsSchema = import_mini69.z.object({
   baseDirs: import_mini69.z.array(import_mini69.z.string()),
-  targets: RulesyncTargetsSchema,
+  targets: RulesyncConfigTargetsSchema,
   features: RulesyncFeaturesSchema,
   verbose: import_mini69.z.boolean(),
   delete: import_mini69.z.boolean(),
@@ -19985,6 +20013,7 @@ var ConfigParamsSchema = import_mini69.z.object({
   simulateCommands: (0, import_mini69.optional)(import_mini69.z.boolean()),
   simulateSubagents: (0, import_mini69.optional)(import_mini69.z.boolean()),
   simulateSkills: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  gitignoreTargetsOnly: (0, import_mini69.optional)(import_mini69.z.boolean()),
   dryRun: (0, import_mini69.optional)(import_mini69.z.boolean()),
   check: (0, import_mini69.optional)(import_mini69.z.boolean()),
   // Declarative skill sources
@@ -20001,10 +20030,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;
@@ -20012,6 +20073,7 @@ var Config = class _Config {
   simulateCommands;
   simulateSubagents;
   simulateSkills;
+  gitignoreTargetsOnly;
   dryRun;
   check;
   sources;
@@ -20026,17 +20088,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;
@@ -20044,15 +20113,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.`
         );
@@ -20062,16 +20158,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) {
@@ -20081,20 +20206,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];
@@ -20122,23 +20234,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)) {
-      return void 0;
-    }
-    const targetFeatures = this.features[target];
-    if (!targetFeatures || Array.isArray(targetFeatures)) {
+    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 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;
   }
@@ -20146,6 +20275,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() {
@@ -20169,6 +20305,9 @@ var Config = class _Config {
   getSimulateSkills() {
     return this.simulateSkills;
   }
+  getGitignoreTargetsOnly() {
+    return this.gitignoreTargetsOnly;
+  }
   getDryRun() {
     return this.dryRun;
   }
@@ -20187,6 +20326,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"],
@@ -20200,6 +20350,7 @@ var getDefaults = () => ({
   simulateCommands: false,
   simulateSubagents: false,
   simulateSkills: false,
+  gitignoreTargetsOnly: true,
   dryRun: false,
   check: false,
   sources: []
@@ -20212,6 +20363,10 @@ var loadConfigFromFile = async (filePath) => {
   const jsonData = (0, import_jsonc_parser4.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) => {
@@ -20226,6 +20381,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
@@ -20244,6 +20400,7 @@ var ConfigResolver = class {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
+    gitignoreTargetsOnly,
     dryRun,
     check
   }) {
@@ -20253,13 +20410,35 @@ var ConfigResolver = class {
     const localConfigPath = (0, import_node_path134.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({
@@ -20271,6 +20450,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
@@ -21860,6 +22040,7 @@ var GITIGNORE_ENTRY_REGISTRY = [
     feature: "general",
     entry: "**/.claude/settings.local.json"
   },
+  { target: "claudecode", feature: "general", entry: "**/.claude/*.lock" },
   // Cline
   { target: "cline", feature: "rules", entry: "**/.clinerules/" },
   { target: "cline", feature: "commands", entry: "**/.clinerules/workflows/" },
@@ -21968,6 +22149,11 @@ var GITIGNORE_ENTRY_REGISTRY = [
   { target: "opencode", feature: "skills", entry: "**/.opencode/skill/" },
   { target: "opencode", feature: "mcp", entry: "**/.opencode/plugins/" },
   { target: "opencode", feature: "general", entry: "**/.opencode/memories/" },
+  {
+    target: "opencode",
+    feature: "general",
+    entry: "**/.opencode/package-lock.json"
+  },
   // Qwen Code
   { target: "qwencode", feature: "rules", entry: "**/QWEN.md" },
   { target: "qwencode", feature: "general", entry: "**/.qwen/memories/" },
@@ -22473,6 +22659,12 @@ async function importCommand(logger5, options) {
   if (!options.targets) {
     throw new CLIError("No tools found in --targets", ErrorCodes.IMPORT_FAILED);
   }
+  if (!Array.isArray(options.targets)) {
+    throw new CLIError(
+      "--targets object form is not supported on the command line",
+      ErrorCodes.IMPORT_FAILED
+    );
+  }
   if (options.targets.length > 1) {
     throw new CLIError("Only one tool can be imported at a time", ErrorCodes.IMPORT_FAILED);
   }
@@ -22541,7 +22733,8 @@ async function createConfigFile() {
         global: false,
         simulateCommands: false,
         simulateSubagents: false,
-        simulateSkills: false
+        simulateSkills: false,
+        gitignoreTargetsOnly: true
       },
       null,
       2
@@ -25152,6 +25345,35 @@ async function mcpCommand(logger5, { version }) {
   });
 }
 
+// src/cli/commands/resolve-gitignore-targets.ts
+var import_node_path152 = require("path");
+var resolveGitignoreTargets = async ({
+  cliTargets,
+  cwd = process.cwd()
+}) => {
+  if (cliTargets !== void 0) {
+    return cliTargets;
+  }
+  const baseConfigPath = (0, import_node_path152.join)(cwd, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
+  const localConfigPath = (0, import_node_path152.join)(cwd, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
+  const [hasBase, hasLocal] = await Promise.all([
+    fileExists(baseConfigPath),
+    fileExists(localConfigPath)
+  ]);
+  if (!hasBase && !hasLocal) {
+    return void 0;
+  }
+  const config = await ConfigResolver.resolve({});
+  if (config.getGitignoreTargetsOnly()) {
+    const targets = config.getTargets();
+    if (targets.includes("agentsmd")) {
+      return targets;
+    }
+    return [...targets, "agentsmd"];
+  }
+  return void 0;
+};
+
 // src/lib/update.ts
 var crypto = __toESM(require("crypto"), 1);
 var fs = __toESM(require("fs"), 1);
@@ -25554,7 +25776,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.0.0";
+var getVersion = () => "8.2.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }
@@ -25577,11 +25799,12 @@ var main = async () => {
     parseCommaSeparatedList
   ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
     wrapCommand2("gitignore", "GITIGNORE_FAILED", async (logger5, options) => {
+      const cliTargets = options.targets;
+      const cliFeatures = options.features;
+      const resolvedTargets = await resolveGitignoreTargets({ cliTargets });
       await gitignoreCommand(logger5, {
-        // eslint-disable-next-line no-type-assertion/no-type-assertion
-        targets: options.targets,
-        // eslint-disable-next-line no-type-assertion/no-type-assertion
-        features: options.features
+        targets: resolvedTargets ? [...resolvedTargets] : void 0,
+        features: cliFeatures
       });
     })
   );

package/dist/cli/index.js

@@ -24,6 +24,7 @@ import {
   RULESYNC_HOOKS_FILE_NAME,
   RULESYNC_HOOKS_RELATIVE_FILE_PATH,
   RULESYNC_IGNORE_RELATIVE_FILE_PATH,
+  RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH,
   RULESYNC_MCP_FILE_NAME,
   RULESYNC_MCP_RELATIVE_FILE_PATH,
   RULESYNC_MCP_SCHEMA_URL,
@@ -72,7 +73,7 @@ import {
   stringifyFrontmatter,
   toPosixPath,
   writeFileContent
-} from "../chunk-GB6XLCGB.js";
+} from "../chunk-K4IN6URH.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1196,6 +1197,7 @@ var GITIGNORE_ENTRY_REGISTRY = [
     feature: "general",
     entry: "**/.claude/settings.local.json"
   },
+  { target: "claudecode", feature: "general", entry: "**/.claude/*.lock" },
   // Cline
   { target: "cline", feature: "rules", entry: "**/.clinerules/" },
   { target: "cline", feature: "commands", entry: "**/.clinerules/workflows/" },
@@ -1304,6 +1306,11 @@ var GITIGNORE_ENTRY_REGISTRY = [
   { target: "opencode", feature: "skills", entry: "**/.opencode/skill/" },
   { target: "opencode", feature: "mcp", entry: "**/.opencode/plugins/" },
   { target: "opencode", feature: "general", entry: "**/.opencode/memories/" },
+  {
+    target: "opencode",
+    feature: "general",
+    entry: "**/.opencode/package-lock.json"
+  },
   // Qwen Code
   { target: "qwencode", feature: "rules", entry: "**/QWEN.md" },
   { target: "qwencode", feature: "general", entry: "**/.qwen/memories/" },
@@ -1545,6 +1552,12 @@ async function importCommand(logger5, options) {
   if (!options.targets) {
     throw new CLIError("No tools found in --targets", ErrorCodes.IMPORT_FAILED);
   }
+  if (!Array.isArray(options.targets)) {
+    throw new CLIError(
+      "--targets object form is not supported on the command line",
+      ErrorCodes.IMPORT_FAILED
+    );
+  }
   if (options.targets.length > 1) {
     throw new CLIError("Only one tool can be imported at a time", ErrorCodes.IMPORT_FAILED);
   }
@@ -1613,7 +1626,8 @@ async function createConfigFile() {
         global: false,
         simulateCommands: false,
         simulateSubagents: false,
-        simulateSkills: false
+        simulateSkills: false,
+        gitignoreTargetsOnly: true
       },
       null,
       2
@@ -4078,6 +4092,35 @@ async function mcpCommand(logger5, { version }) {
   });
 }
 
+// src/cli/commands/resolve-gitignore-targets.ts
+import { join as join13 } from "path";
+var resolveGitignoreTargets = async ({
+  cliTargets,
+  cwd = process.cwd()
+}) => {
+  if (cliTargets !== void 0) {
+    return cliTargets;
+  }
+  const baseConfigPath = join13(cwd, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
+  const localConfigPath = join13(cwd, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
+  const [hasBase, hasLocal] = await Promise.all([
+    fileExists(baseConfigPath),
+    fileExists(localConfigPath)
+  ]);
+  if (!hasBase && !hasLocal) {
+    return void 0;
+  }
+  const config = await ConfigResolver.resolve({});
+  if (config.getGitignoreTargetsOnly()) {
+    const targets = config.getTargets();
+    if (targets.includes("agentsmd")) {
+      return targets;
+    }
+    return [...targets, "agentsmd"];
+  }
+  return void 0;
+};
+
 // src/lib/update.ts
 import * as crypto from "crypto";
 import * as fs from "fs";
@@ -4480,7 +4523,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.0.0";
+var getVersion = () => "8.2.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }
@@ -4503,11 +4546,12 @@ var main = async () => {
     parseCommaSeparatedList
   ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
     wrapCommand2("gitignore", "GITIGNORE_FAILED", async (logger5, options) => {
+      const cliTargets = options.targets;
+      const cliFeatures = options.features;
+      const resolvedTargets = await resolveGitignoreTargets({ cliTargets });
       await gitignoreCommand(logger5, {
-        // eslint-disable-next-line no-type-assertion/no-type-assertion
-        targets: options.targets,
-        // eslint-disable-next-line no-type-assertion/no-type-assertion
-        features: options.features
+        targets: resolvedTargets ? [...resolvedTargets] : void 0,
+        features: cliFeatures
       });
     })
   );