rulesync 3.19.0 → 3.20.0

package/dist/index.cjs

@@ -107,9 +107,9 @@ var logger = new Logger();
 // src/cli/commands/generate.ts
 var import_es_toolkit2 = require("es-toolkit");
 
-// src/commands/commands-processor.ts
-var import_node_path12 = require("path");
-var import_mini9 = require("zod/mini");
+// src/config/config-resolver.ts
+var import_node_path2 = require("path");
+var import_jsonc_parser = require("jsonc-parser");
 
 // src/utils/file.ts
 var import_node_fs = require("fs");
@@ -132,14 +132,24 @@ async function readOrInitializeFileContent(filePath, initialContent = "") {
     return initialContent;
   }
 }
-function resolvePath(relativePath, baseDir) {
-  if (!baseDir) return relativePath;
-  const resolved = (0, import_node_path.resolve)(baseDir, relativePath);
-  const rel = (0, import_node_path.relative)(baseDir, resolved);
+function checkPathTraversal({
+  relativePath,
+  intendedRootDir
+}) {
+  const segments = relativePath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new Error(`Path traversal detected: ${relativePath}`);
+  }
+  const resolved = (0, import_node_path.resolve)(intendedRootDir, relativePath);
+  const rel = (0, import_node_path.relative)(intendedRootDir, resolved);
   if (rel.startsWith("..") || (0, import_node_path.resolve)(resolved) !== resolved) {
     throw new Error(`Path traversal detected: ${relativePath}`);
   }
-  return resolved;
+}
+function resolvePath(relativePath, baseDir) {
+  if (!baseDir) return relativePath;
+  checkPathTraversal({ relativePath, intendedRootDir: baseDir });
+  return (0, import_node_path.resolve)(baseDir, relativePath);
 }
 async function directoryExists(dirPath) {
   try {
@@ -202,16 +212,252 @@ function validateBaseDir(baseDir) {
   if (baseDir.trim() === "") {
     throw new Error("baseDir cannot be an empty string");
   }
-  if (baseDir.includes("..")) {
-    throw new Error(`baseDir cannot contain directory traversal (..): ${baseDir}`);
+  checkPathTraversal({ relativePath: baseDir, intendedRootDir: process.cwd() });
+}
+
+// src/config/config.ts
+var import_mini3 = require("zod/mini");
+
+// 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/config/config.ts
+var ConfigParamsSchema = import_mini3.z.object({
+  baseDirs: import_mini3.z.array(import_mini3.z.string()),
+  targets: RulesyncTargetsSchema,
+  features: RulesyncFeaturesSchema,
+  verbose: import_mini3.z.boolean(),
+  delete: import_mini3.z.boolean(),
+  // New non-experimental options
+  global: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  simulatedCommands: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  simulatedSubagents: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  modularMcp: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  // Deprecated experimental options (for backward compatibility)
+  experimentalGlobal: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  experimentalSimulateCommands: (0, import_mini3.optional)(import_mini3.z.boolean()),
+  experimentalSimulateSubagents: (0, import_mini3.optional)(import_mini3.z.boolean())
+});
+var PartialConfigParamsSchema = import_mini3.z.partial(ConfigParamsSchema);
+var RequiredConfigParamsSchema = import_mini3.z.required(ConfigParamsSchema);
+var Config = class {
+  baseDirs;
+  targets;
+  features;
+  verbose;
+  delete;
+  global;
+  simulatedCommands;
+  simulatedSubagents;
+  modularMcp;
+  constructor({
+    baseDirs,
+    targets,
+    features,
+    verbose,
+    delete: isDelete,
+    global,
+    simulatedCommands,
+    simulatedSubagents,
+    modularMcp,
+    experimentalGlobal,
+    experimentalSimulateCommands,
+    experimentalSimulateSubagents
+  }) {
+    this.baseDirs = baseDirs;
+    this.targets = targets;
+    this.features = features;
+    this.verbose = verbose;
+    this.delete = isDelete;
+    this.global = global ?? experimentalGlobal ?? false;
+    this.simulatedCommands = simulatedCommands ?? experimentalSimulateCommands ?? false;
+    this.simulatedSubagents = simulatedSubagents ?? experimentalSimulateSubagents ?? false;
+    this.modularMcp = modularMcp ?? false;
+  }
+  getBaseDirs() {
+    return this.baseDirs;
+  }
+  getTargets() {
+    if (this.targets.includes("*")) {
+      return [...ALL_TOOL_TARGETS];
+    }
+    return this.targets.filter((target) => target !== "*");
+  }
+  getFeatures() {
+    if (this.features.includes("*")) {
+      return [...ALL_FEATURES];
+    }
+    return this.features.filter((feature) => feature !== "*");
+  }
+  getVerbose() {
+    return this.verbose;
+  }
+  getDelete() {
+    return this.delete;
+  }
+  getGlobal() {
+    return this.global;
+  }
+  getSimulatedCommands() {
+    return this.simulatedCommands;
+  }
+  getSimulatedSubagents() {
+    return this.simulatedSubagents;
+  }
+  getModularMcp() {
+    return this.modularMcp;
+  }
+  // Deprecated getters for backward compatibility
+  /** @deprecated Use getGlobal() instead */
+  getExperimentalGlobal() {
+    return this.global;
+  }
+  /** @deprecated Use getSimulatedCommands() instead */
+  getExperimentalSimulateCommands() {
+    return this.simulatedCommands;
+  }
+  /** @deprecated Use getSimulatedSubagents() instead */
+  getExperimentalSimulateSubagents() {
+    return this.simulatedSubagents;
+  }
+};
+
+// src/config/config-resolver.ts
+var defaults = {
+  targets: ["agentsmd"],
+  features: ["rules"],
+  verbose: false,
+  delete: false,
+  baseDirs: [process.cwd()],
+  configPath: "rulesync.jsonc",
+  global: false,
+  simulatedCommands: false,
+  simulatedSubagents: false,
+  modularMcp: false,
+  experimentalGlobal: false,
+  experimentalSimulateCommands: false,
+  experimentalSimulateSubagents: false
+};
+var ConfigResolver = class {
+  static async resolve({
+    targets,
+    features,
+    verbose,
+    delete: isDelete,
+    baseDirs,
+    configPath = defaults.configPath,
+    global,
+    simulatedCommands,
+    simulatedSubagents,
+    modularMcp,
+    experimentalGlobal,
+    experimentalSimulateCommands,
+    experimentalSimulateSubagents
+  }) {
+    const validatedConfigPath = resolvePath(configPath, process.cwd());
+    let configByFile = {};
+    if (await fileExists(validatedConfigPath)) {
+      try {
+        const fileContent = await readFileContent(validatedConfigPath);
+        const jsonData = (0, import_jsonc_parser.parse)(fileContent);
+        configByFile = PartialConfigParamsSchema.parse(jsonData);
+      } catch (error) {
+        logger.error(`Failed to load config file: ${formatError(error)}`);
+        throw error;
+      }
+    }
+    const deprecatedGlobal = experimentalGlobal ?? configByFile.experimentalGlobal;
+    const deprecatedCommands = experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands;
+    const deprecatedSubagents = experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents;
+    if (deprecatedGlobal !== void 0) {
+      warnDeprecatedOptions({ experimentalGlobal: deprecatedGlobal });
+    }
+    if (deprecatedCommands !== void 0) {
+      warnDeprecatedOptions({ experimentalSimulateCommands: deprecatedCommands });
+    }
+    if (deprecatedSubagents !== void 0) {
+      warnDeprecatedOptions({ experimentalSimulateSubagents: deprecatedSubagents });
+    }
+    const resolvedGlobal = global ?? configByFile.global ?? experimentalGlobal ?? configByFile.experimentalGlobal ?? defaults.global;
+    const resolvedSimulatedCommands = simulatedCommands ?? configByFile.simulatedCommands ?? experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands ?? defaults.simulatedCommands;
+    const resolvedSimulatedSubagents = simulatedSubagents ?? configByFile.simulatedSubagents ?? experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents ?? defaults.simulatedSubagents;
+    const configParams = {
+      targets: targets ?? configByFile.targets ?? defaults.targets,
+      features: features ?? configByFile.features ?? defaults.features,
+      verbose: verbose ?? configByFile.verbose ?? defaults.verbose,
+      delete: isDelete ?? configByFile.delete ?? defaults.delete,
+      baseDirs: getBaseDirsInLightOfGlobal({
+        baseDirs: baseDirs ?? configByFile.baseDirs ?? defaults.baseDirs,
+        global: resolvedGlobal
+      }),
+      global: resolvedGlobal,
+      simulatedCommands: resolvedSimulatedCommands,
+      simulatedSubagents: resolvedSimulatedSubagents,
+      modularMcp: modularMcp ?? configByFile.modularMcp ?? defaults.modularMcp
+    };
+    return new Config(configParams);
+  }
+};
+function warnDeprecatedOptions({
+  experimentalGlobal,
+  experimentalSimulateCommands,
+  experimentalSimulateSubagents
+}) {
+  if (experimentalGlobal !== void 0) {
+    logger.warn("'experimentalGlobal' option is deprecated. Please use 'global' instead.");
+  }
+  if (experimentalSimulateCommands !== void 0) {
+    logger.warn(
+      "'experimentalSimulateCommands' option is deprecated. Please use 'simulatedCommands' instead."
+    );
+  }
+  if (experimentalSimulateSubagents !== void 0) {
+    logger.warn(
+      "'experimentalSimulateSubagents' option is deprecated. Please use 'simulatedSubagents' instead."
+    );
   }
-  const normalized = (0, import_node_path.resolve)(baseDir);
-  const rel = (0, import_node_path.relative)(process.cwd(), normalized);
-  if (rel.startsWith("..")) {
-    throw new Error(`baseDir cannot contain directory traversal (..): ${baseDir}`);
+}
+function getBaseDirsInLightOfGlobal({
+  baseDirs,
+  global
+}) {
+  if (global) {
+    return [getHomeDirectory()];
   }
+  const resolvedBaseDirs = baseDirs.map((baseDir) => (0, import_node_path2.resolve)(baseDir));
+  resolvedBaseDirs.forEach((baseDir) => {
+    validateBaseDir(baseDir);
+  });
+  return resolvedBaseDirs;
 }
 
+// src/features/commands/commands-processor.ts
+var import_node_path13 = require("path");
+var import_mini10 = require("zod/mini");
+
 // src/types/feature-processor.ts
 var FeatureProcessor = class {
   baseDir;
@@ -242,8 +488,8 @@ var FeatureProcessor = class {
   }
 };
 
-// src/commands/agentsmd-command.ts
-var import_node_path4 = require("path");
+// src/features/commands/agentsmd-command.ts
+var import_node_path5 = require("path");
 
 // src/utils/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -294,12 +540,12 @@ function parseFrontmatter(content) {
   return { frontmatter, body };
 }
 
-// src/commands/simulated-command.ts
-var import_node_path3 = require("path");
-var import_mini2 = require("zod/mini");
+// src/features/commands/simulated-command.ts
+var import_node_path4 = require("path");
+var import_mini4 = require("zod/mini");
 
 // src/types/ai-file.ts
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var AiFile = class {
   /**
    * @example "."
@@ -354,11 +600,11 @@ var AiFile = class {
     return this.relativeFilePath;
   }
   getFilePath() {
-    const fullPath = import_node_path2.default.join(this.baseDir, this.relativeDirPath, this.relativeFilePath);
-    const resolvedFull = (0, import_node_path2.resolve)(fullPath);
-    const resolvedBase = (0, import_node_path2.resolve)(this.baseDir);
-    const rel = (0, import_node_path2.relative)(resolvedBase, resolvedFull);
-    if (rel.startsWith("..") || import_node_path2.default.isAbsolute(rel)) {
+    const fullPath = import_node_path3.default.join(this.baseDir, this.relativeDirPath, this.relativeFilePath);
+    const resolvedFull = (0, import_node_path3.resolve)(fullPath);
+    const resolvedBase = (0, import_node_path3.resolve)(this.baseDir);
+    const rel = (0, import_node_path3.relative)(resolvedBase, resolvedFull);
+    if (rel.startsWith("..") || import_node_path3.default.isAbsolute(rel)) {
       throw new Error(
         `Path traversal detected: Final path escapes baseDir. baseDir="${this.baseDir}", relativeDirPath="${this.relativeDirPath}", relativeFilePath="${this.relativeFilePath}"`
       );
@@ -369,14 +615,14 @@ var AiFile = class {
     return this.fileContent;
   }
   getRelativePathFromCwd() {
-    return import_node_path2.default.join(this.relativeDirPath, this.relativeFilePath);
+    return import_node_path3.default.join(this.relativeDirPath, this.relativeFilePath);
   }
   setFileContent(newFileContent) {
     this.fileContent = newFileContent;
   }
 };
 
-// src/commands/tool-command.ts
+// src/features/commands/tool-command.ts
 var ToolCommand = class extends AiFile {
   static getSettablePaths() {
     throw new Error("Please implement this method in the subclass.");
@@ -446,9 +692,9 @@ var ToolCommand = class extends AiFile {
   }
 };
 
-// src/commands/simulated-command.ts
-var SimulatedCommandFrontmatterSchema = import_mini2.z.object({
-  description: import_mini2.z.string()
+// src/features/commands/simulated-command.ts
+var SimulatedCommandFrontmatterSchema = import_mini4.z.object({
+  description: import_mini4.z.string()
 });
 var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
   frontmatter;
@@ -458,7 +704,7 @@ var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
       const result = SimulatedCommandFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path3.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path4.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -508,7 +754,7 @@ var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path3.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path4.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -518,7 +764,7 @@ var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
     relativeFilePath,
     validate = true
   }) {
-    const filePath = (0, import_node_path3.join)(
+    const filePath = (0, import_node_path4.join)(
       baseDir,
       _SimulatedCommand.getSettablePaths().relativeDirPath,
       relativeFilePath
@@ -532,7 +778,7 @@ var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
     return {
       baseDir,
       relativeDirPath: _SimulatedCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: (0, import_node_path3.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path4.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -540,11 +786,11 @@ var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
   }
 };
 
-// src/commands/agentsmd-command.ts
+// src/features/commands/agentsmd-command.ts
 var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path4.join)(".agents", "commands")
+      relativeDirPath: (0, import_node_path5.join)(".agents", "commands")
     };
   }
   static fromRulesyncCommand({
@@ -561,7 +807,7 @@ var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
     relativeFilePath,
     validate = true
   }) {
-    const filePath = (0, import_node_path4.join)(
+    const filePath = (0, import_node_path5.join)(
       baseDir,
       _AgentsmdCommand.getSettablePaths().relativeDirPath,
       relativeFilePath
@@ -575,7 +821,7 @@ var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
     return new _AgentsmdCommand({
       baseDir,
       relativeDirPath: _AgentsmdCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: (0, import_node_path4.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path5.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -589,14 +835,14 @@ var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
   }
 };
 
-// src/commands/claudecode-command.ts
+// src/features/commands/claudecode-command.ts
+var import_node_path7 = require("path");
+var import_mini6 = require("zod/mini");
+
+// src/features/commands/rulesync-command.ts
 var import_node_path6 = require("path");
 var import_mini5 = require("zod/mini");
 
-// src/commands/rulesync-command.ts
-var import_node_path5 = require("path");
-var import_mini4 = require("zod/mini");
-
 // src/types/rulesync-file.ts
 var RulesyncFile = class extends AiFile {
   static async fromFile(_params) {
@@ -607,36 +853,10 @@ var RulesyncFile = class extends AiFile {
   }
 };
 
-// src/types/tool-targets.ts
-var import_mini3 = 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_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));
-
-// src/commands/rulesync-command.ts
-var RulesyncCommandFrontmatterSchema = import_mini4.z.object({
+// src/features/commands/rulesync-command.ts
+var RulesyncCommandFrontmatterSchema = import_mini5.z.object({
   targets: RulesyncTargetsSchema,
-  description: import_mini4.z.string()
+  description: import_mini5.z.string()
 });
 var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
   frontmatter;
@@ -646,7 +866,7 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
       const result = RulesyncCommandFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path5.join)(rest.baseDir ?? process.cwd(), rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path6.join)(rest.baseDir ?? process.cwd(), rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -659,7 +879,7 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
   }
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path5.join)(".rulesync", "commands")
+      relativeDirPath: (0, import_node_path6.join)(".rulesync", "commands")
     };
   }
   getFrontmatter() {
@@ -679,7 +899,7 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path5.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path6.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -687,15 +907,18 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
   static async fromFile({
     relativeFilePath
   }) {
-    const fileContent = await readFileContent(
-      (0, import_node_path5.join)(_RulesyncCommand.getSettablePaths().relativeDirPath, relativeFilePath)
+    const filePath = (0, import_node_path6.join)(
+      process.cwd(),
+      _RulesyncCommand.getSettablePaths().relativeDirPath,
+      relativeFilePath
     );
+    const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncCommandFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
     }
-    const filename = (0, import_node_path5.basename)(relativeFilePath);
+    const filename = (0, import_node_path6.basename)(relativeFilePath);
     return new _RulesyncCommand({
       baseDir: process.cwd(),
       relativeDirPath: _RulesyncCommand.getSettablePaths().relativeDirPath,
@@ -707,9 +930,9 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
   }
 };
 
-// src/commands/claudecode-command.ts
-var ClaudecodeCommandFrontmatterSchema = import_mini5.z.object({
-  description: import_mini5.z.string()
+// src/features/commands/claudecode-command.ts
+var ClaudecodeCommandFrontmatterSchema = import_mini6.z.object({
+  description: import_mini6.z.string()
 });
 var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
   frontmatter;
@@ -719,7 +942,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       const result = ClaudecodeCommandFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path6.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path7.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -732,7 +955,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: (0, import_node_path6.join)(".claude", "commands")
+      relativeDirPath: (0, import_node_path7.join)(".claude", "commands")
     };
   }
   getBody() {
@@ -790,7 +1013,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path6.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path7.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -808,7 +1031,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path6.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path7.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeCommandFrontmatterSchema.safeParse(frontmatter);
@@ -818,7 +1041,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
     return new _ClaudecodeCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: (0, import_node_path6.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path7.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -826,15 +1049,15 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
   }
 };
 
-// src/commands/codexcli-command.ts
-var import_node_path7 = require("path");
+// src/features/commands/codexcli-command.ts
+var import_node_path8 = require("path");
 var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
   static getSettablePaths({ global } = {}) {
     if (!global) {
       throw new Error("CodexcliCommand only supports global mode. Please pass { global: true }.");
     }
     return {
-      relativeDirPath: (0, import_node_path7.join)(".codex", "prompts")
+      relativeDirPath: (0, import_node_path8.join)(".codex", "prompts")
     };
   }
   toRulesyncCommand() {
@@ -887,25 +1110,25 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path7.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path8.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { body: content } = parseFrontmatter(fileContent);
     return new _CodexcliCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: (0, import_node_path7.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path8.basename)(relativeFilePath),
       fileContent: content.trim(),
       validate
     });
   }
 };
 
-// src/commands/copilot-command.ts
-var import_node_path8 = require("path");
-var import_mini6 = require("zod/mini");
-var CopilotCommandFrontmatterSchema = import_mini6.z.object({
-  mode: import_mini6.z.literal("agent"),
-  description: import_mini6.z.string()
+// src/features/commands/copilot-command.ts
+var import_node_path9 = require("path");
+var import_mini7 = require("zod/mini");
+var CopilotCommandFrontmatterSchema = import_mini7.z.object({
+  mode: import_mini7.z.literal("agent"),
+  description: import_mini7.z.string()
 });
 var CopilotCommand = class _CopilotCommand extends ToolCommand {
   frontmatter;
@@ -915,7 +1138,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
       const result = CopilotCommandFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path8.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path9.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -928,7 +1151,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
   }
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path8.join)(".github", "prompts")
+      relativeDirPath: (0, import_node_path9.join)(".github", "prompts")
     };
   }
   getBody() {
@@ -965,7 +1188,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path8.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path9.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -999,7 +1222,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
     validate = true
   }) {
     const paths = this.getSettablePaths();
-    const filePath = (0, import_node_path8.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path9.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = CopilotCommandFrontmatterSchema.safeParse(frontmatter);
@@ -1009,7 +1232,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
     return new _CopilotCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: (0, import_node_path8.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path9.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -1023,12 +1246,12 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
   }
 };
 
-// src/commands/cursor-command.ts
-var import_node_path9 = require("path");
+// src/features/commands/cursor-command.ts
+var import_node_path10 = require("path");
 var CursorCommand = class _CursorCommand extends ToolCommand {
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: (0, import_node_path9.join)(".cursor", "commands")
+      relativeDirPath: (0, import_node_path10.join)(".cursor", "commands")
     };
   }
   toRulesyncCommand() {
@@ -1081,26 +1304,26 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path9.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path10.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { body: content } = parseFrontmatter(fileContent);
     return new _CursorCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: (0, import_node_path9.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path10.basename)(relativeFilePath),
       fileContent: content.trim(),
       validate
     });
   }
 };
 
-// src/commands/geminicli-command.ts
-var import_node_path10 = require("path");
+// src/features/commands/geminicli-command.ts
+var import_node_path11 = require("path");
 var import_smol_toml = require("smol-toml");
-var import_mini7 = require("zod/mini");
-var GeminiCliCommandFrontmatterSchema = import_mini7.z.object({
-  description: import_mini7.z.optional(import_mini7.z.string()),
-  prompt: import_mini7.z.string()
+var import_mini8 = require("zod/mini");
+var GeminiCliCommandFrontmatterSchema = import_mini8.z.object({
+  description: import_mini8.z.optional(import_mini8.z.string()),
+  prompt: import_mini8.z.string()
 });
 var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
   frontmatter;
@@ -1113,7 +1336,7 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: (0, import_node_path10.join)(".gemini", "commands")
+      relativeDirPath: (0, import_node_path11.join)(".gemini", "commands")
     };
   }
   parseTomlContent(content) {
@@ -1190,12 +1413,12 @@ ${geminiFrontmatter.prompt}
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path10.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path11.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     return new _GeminiCliCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: (0, import_node_path10.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path11.basename)(relativeFilePath),
       fileContent,
       validate
     });
@@ -1216,19 +1439,19 @@ ${geminiFrontmatter.prompt}
   }
 };
 
-// src/commands/roo-command.ts
-var import_node_path11 = require("path");
-var import_mini8 = require("zod/mini");
-var RooCommandFrontmatterSchema = import_mini8.z.object({
-  description: import_mini8.z.string(),
-  "argument-hint": (0, import_mini8.optional)(import_mini8.z.string())
+// src/features/commands/roo-command.ts
+var import_node_path12 = require("path");
+var import_mini9 = require("zod/mini");
+var RooCommandFrontmatterSchema = import_mini9.z.object({
+  description: import_mini9.z.string(),
+  "argument-hint": (0, import_mini9.optional)(import_mini9.z.string())
 });
 var RooCommand = class _RooCommand extends ToolCommand {
   frontmatter;
   body;
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path11.join)(".roo", "commands")
+      relativeDirPath: (0, import_node_path12.join)(".roo", "commands")
     };
   }
   constructor({ frontmatter, body, ...rest }) {
@@ -1236,7 +1459,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
       const result = RooCommandFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path11.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path12.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -1302,7 +1525,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path11.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path12.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -1318,7 +1541,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
     relativeFilePath,
     validate = true
   }) {
-    const filePath = (0, import_node_path11.join)(baseDir, _RooCommand.getSettablePaths().relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path12.join)(baseDir, _RooCommand.getSettablePaths().relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RooCommandFrontmatterSchema.safeParse(frontmatter);
@@ -1328,7 +1551,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
     return new _RooCommand({
       baseDir,
       relativeDirPath: _RooCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: (0, import_node_path11.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path12.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       fileContent,
@@ -1337,7 +1560,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
   }
 };
 
-// src/commands/commands-processor.ts
+// src/features/commands/commands-processor.ts
 var commandsProcessorToolTargets = [
   "agentsmd",
   "claudecode",
@@ -1346,7 +1569,7 @@ var commandsProcessorToolTargets = [
   "copilot",
   "cursor"
 ];
-var CommandsProcessorToolTargetSchema = import_mini9.z.enum(
+var CommandsProcessorToolTargetSchema = import_mini10.z.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   commandsProcessorToolTargets.concat("codexcli")
 );
@@ -1464,11 +1687,11 @@ var CommandsProcessor = class extends FeatureProcessor {
    */
   async loadRulesyncFiles() {
     const rulesyncCommandPaths = await findFilesByGlobs(
-      (0, import_node_path12.join)(RulesyncCommand.getSettablePaths().relativeDirPath, "*.md")
+      (0, import_node_path13.join)(RulesyncCommand.getSettablePaths().relativeDirPath, "*.md")
     );
     const rulesyncCommands = (await Promise.allSettled(
       rulesyncCommandPaths.map(
-        (path2) => RulesyncCommand.fromFile({ relativeFilePath: (0, import_node_path12.basename)(path2) })
+        (path2) => RulesyncCommand.fromFile({ relativeFilePath: (0, import_node_path13.basename)(path2) })
       )
     )).filter((result) => result.status === "fulfilled").map((result) => result.value);
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
@@ -1507,7 +1730,7 @@ var CommandsProcessor = class extends FeatureProcessor {
     extension
   }) {
     const commandFilePaths = await findFilesByGlobs(
-      (0, import_node_path12.join)(this.baseDir, relativeDirPath, `*.${extension}`)
+      (0, import_node_path13.join)(this.baseDir, relativeDirPath, `*.${extension}`)
     );
     const toolCommands = (await Promise.allSettled(
       commandFilePaths.map((path2) => {
@@ -1515,40 +1738,40 @@ var CommandsProcessor = class extends FeatureProcessor {
           case "agentsmd":
             return AgentsmdCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2)
+              relativeFilePath: (0, import_node_path13.basename)(path2)
             });
           case "claudecode":
             return ClaudecodeCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2),
+              relativeFilePath: (0, import_node_path13.basename)(path2),
               global: this.global
             });
           case "geminicli":
             return GeminiCliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2),
+              relativeFilePath: (0, import_node_path13.basename)(path2),
               global: this.global
             });
           case "roo":
             return RooCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2)
+              relativeFilePath: (0, import_node_path13.basename)(path2)
             });
           case "copilot":
             return CopilotCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2)
+              relativeFilePath: (0, import_node_path13.basename)(path2)
             });
           case "cursor":
             return CursorCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2),
+              relativeFilePath: (0, import_node_path13.basename)(path2),
               global: this.global
             });
           case "codexcli":
             return CodexcliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: (0, import_node_path12.basename)(path2),
+              relativeFilePath: (0, import_node_path13.basename)(path2),
               global: this.global
             });
           default:
@@ -1655,353 +1878,138 @@ var CommandsProcessor = class extends FeatureProcessor {
   }
 };
 
-// src/config/config-resolver.ts
-var import_node_path13 = require("path");
-var import_jsonc_parser = require("jsonc-parser");
+// src/features/ignore/ignore-processor.ts
+var import_mini11 = require("zod/mini");
 
-// src/config/config.ts
-var import_mini10 = require("zod/mini");
-var ConfigParamsSchema = import_mini10.z.object({
-  baseDirs: import_mini10.z.array(import_mini10.z.string()),
-  targets: RulesyncTargetsSchema,
-  features: RulesyncFeaturesSchema,
-  verbose: import_mini10.z.boolean(),
-  delete: import_mini10.z.boolean(),
-  // New non-experimental options
-  global: (0, import_mini10.optional)(import_mini10.z.boolean()),
-  simulatedCommands: (0, import_mini10.optional)(import_mini10.z.boolean()),
-  simulatedSubagents: (0, import_mini10.optional)(import_mini10.z.boolean()),
-  modularMcp: (0, import_mini10.optional)(import_mini10.z.boolean()),
-  // Deprecated experimental options (for backward compatibility)
-  experimentalGlobal: (0, import_mini10.optional)(import_mini10.z.boolean()),
-  experimentalSimulateCommands: (0, import_mini10.optional)(import_mini10.z.boolean()),
-  experimentalSimulateSubagents: (0, import_mini10.optional)(import_mini10.z.boolean())
-});
-var PartialConfigParamsSchema = import_mini10.z.partial(ConfigParamsSchema);
-var RequiredConfigParamsSchema = import_mini10.z.required(ConfigParamsSchema);
-var Config = class {
-  baseDirs;
-  targets;
-  features;
-  verbose;
-  delete;
-  global;
-  simulatedCommands;
-  simulatedSubagents;
-  modularMcp;
-  constructor({
-    baseDirs,
-    targets,
-    features,
-    verbose,
-    delete: isDelete,
-    global,
-    simulatedCommands,
-    simulatedSubagents,
-    modularMcp,
-    experimentalGlobal,
-    experimentalSimulateCommands,
-    experimentalSimulateSubagents
-  }) {
-    this.baseDirs = baseDirs;
-    this.targets = targets;
-    this.features = features;
-    this.verbose = verbose;
-    this.delete = isDelete;
-    this.global = global ?? experimentalGlobal ?? false;
-    this.simulatedCommands = simulatedCommands ?? experimentalSimulateCommands ?? false;
-    this.simulatedSubagents = simulatedSubagents ?? experimentalSimulateSubagents ?? false;
-    this.modularMcp = modularMcp ?? false;
+// src/features/ignore/amazonqcli-ignore.ts
+var import_node_path15 = require("path");
+
+// src/types/tool-file.ts
+var ToolFile = class extends AiFile {
+};
+
+// src/features/ignore/rulesync-ignore.ts
+var import_node_path14 = require("path");
+var RulesyncIgnore = class _RulesyncIgnore extends RulesyncFile {
+  validate() {
+    return { success: true, error: null };
   }
-  getBaseDirs() {
-    return this.baseDirs;
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".",
+      relativeFilePath: ".rulesyncignore"
+    };
   }
-  getTargets() {
-    if (this.targets.includes("*")) {
-      return [...ALL_TOOL_TARGETS];
-    }
-    return this.targets.filter((target) => target !== "*");
+  static async fromFile() {
+    const baseDir = process.cwd();
+    const filePath = (0, import_node_path14.join)(baseDir, this.getSettablePaths().relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    return new _RulesyncIgnore({
+      baseDir,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      fileContent
+    });
   }
-  getFeatures() {
-    if (this.features.includes("*")) {
-      return [...ALL_FEATURES];
+};
+
+// src/features/ignore/tool-ignore.ts
+var ToolIgnore = class extends ToolFile {
+  patterns;
+  constructor(params) {
+    super({
+      ...params,
+      validate: true
+    });
+    this.patterns = this.fileContent.split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+    if (params.validate) {
+      const result = this.validate();
+      if (!result.success) {
+        throw result.error;
+      }
     }
-    return this.features.filter((feature) => feature !== "*");
   }
-  getVerbose() {
-    return this.verbose;
+  static getSettablePaths() {
+    throw new Error("Please implement this method in the subclass.");
   }
-  getDelete() {
-    return this.delete;
+  getPatterns() {
+    return this.patterns;
   }
-  getGlobal() {
-    return this.global;
+  validate() {
+    return { success: true, error: null };
   }
-  getSimulatedCommands() {
-    return this.simulatedCommands;
+  static fromRulesyncIgnore(_params) {
+    throw new Error("Please implement this method in the subclass.");
   }
-  getSimulatedSubagents() {
-    return this.simulatedSubagents;
+  toRulesyncIgnoreDefault() {
+    return new RulesyncIgnore({
+      baseDir: ".",
+      relativeDirPath: ".",
+      relativeFilePath: ".rulesyncignore",
+      fileContent: this.fileContent
+    });
   }
-  getModularMcp() {
-    return this.modularMcp;
+  static async fromFile(_params) {
+    throw new Error("Please implement this method in the subclass.");
   }
-  // Deprecated getters for backward compatibility
-  /** @deprecated Use getGlobal() instead */
-  getExperimentalGlobal() {
-    return this.global;
+};
+
+// src/features/ignore/amazonqcli-ignore.ts
+var AmazonqcliIgnore = class _AmazonqcliIgnore extends ToolIgnore {
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".",
+      relativeFilePath: ".amazonqignore"
+    };
   }
-  /** @deprecated Use getSimulatedCommands() instead */
-  getExperimentalSimulateCommands() {
-    return this.simulatedCommands;
+  /**
+   * Convert to RulesyncIgnore format
+   */
+  toRulesyncIgnore() {
+    return this.toRulesyncIgnoreDefault();
   }
-  /** @deprecated Use getSimulatedSubagents() instead */
-  getExperimentalSimulateSubagents() {
-    return this.simulatedSubagents;
+  /**
+   * Create AmazonqcliIgnore from RulesyncIgnore
+   * Supports conversion from unified rulesync format to Amazon Q CLI specific format
+   */
+  static fromRulesyncIgnore({
+    baseDir = process.cwd(),
+    rulesyncIgnore
+  }) {
+    const body = rulesyncIgnore.getFileContent();
+    return new _AmazonqcliIgnore({
+      baseDir,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      fileContent: body
+    });
+  }
+  /**
+   * Create AmazonqcliIgnore from file path
+   * Supports both proposed .q-ignore and .amazonqignore formats
+   */
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true
+  }) {
+    const fileContent = await readFileContent(
+      (0, import_node_path15.join)(
+        baseDir,
+        this.getSettablePaths().relativeDirPath,
+        this.getSettablePaths().relativeFilePath
+      )
+    );
+    return new _AmazonqcliIgnore({
+      baseDir,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      fileContent,
+      validate
+    });
   }
 };
 
-// src/config/config-resolver.ts
-var defaults = {
-  targets: ["agentsmd"],
-  features: ["rules"],
-  verbose: false,
-  delete: false,
-  baseDirs: [process.cwd()],
-  configPath: "rulesync.jsonc",
-  global: false,
-  simulatedCommands: false,
-  simulatedSubagents: false,
-  modularMcp: false,
-  experimentalGlobal: false,
-  experimentalSimulateCommands: false,
-  experimentalSimulateSubagents: false
-};
-var ConfigResolver = class {
-  static async resolve({
-    targets,
-    features,
-    verbose,
-    delete: isDelete,
-    baseDirs,
-    configPath = defaults.configPath,
-    global,
-    simulatedCommands,
-    simulatedSubagents,
-    modularMcp,
-    experimentalGlobal,
-    experimentalSimulateCommands,
-    experimentalSimulateSubagents
-  }) {
-    const validatedConfigPath = resolvePath(configPath, process.cwd());
-    let configByFile = {};
-    if (await fileExists(validatedConfigPath)) {
-      try {
-        const fileContent = await readFileContent(validatedConfigPath);
-        const jsonData = (0, import_jsonc_parser.parse)(fileContent);
-        configByFile = PartialConfigParamsSchema.parse(jsonData);
-      } catch (error) {
-        logger.error(`Failed to load config file: ${formatError(error)}`);
-        throw error;
-      }
-    }
-    const deprecatedGlobal = experimentalGlobal ?? configByFile.experimentalGlobal;
-    const deprecatedCommands = experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands;
-    const deprecatedSubagents = experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents;
-    if (deprecatedGlobal !== void 0) {
-      warnDeprecatedOptions({ experimentalGlobal: deprecatedGlobal });
-    }
-    if (deprecatedCommands !== void 0) {
-      warnDeprecatedOptions({ experimentalSimulateCommands: deprecatedCommands });
-    }
-    if (deprecatedSubagents !== void 0) {
-      warnDeprecatedOptions({ experimentalSimulateSubagents: deprecatedSubagents });
-    }
-    const resolvedGlobal = global ?? configByFile.global ?? experimentalGlobal ?? configByFile.experimentalGlobal ?? defaults.global;
-    const resolvedSimulatedCommands = simulatedCommands ?? configByFile.simulatedCommands ?? experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands ?? defaults.simulatedCommands;
-    const resolvedSimulatedSubagents = simulatedSubagents ?? configByFile.simulatedSubagents ?? experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents ?? defaults.simulatedSubagents;
-    const configParams = {
-      targets: targets ?? configByFile.targets ?? defaults.targets,
-      features: features ?? configByFile.features ?? defaults.features,
-      verbose: verbose ?? configByFile.verbose ?? defaults.verbose,
-      delete: isDelete ?? configByFile.delete ?? defaults.delete,
-      baseDirs: getBaseDirsInLightOfGlobal({
-        baseDirs: baseDirs ?? configByFile.baseDirs ?? defaults.baseDirs,
-        global: resolvedGlobal
-      }),
-      global: resolvedGlobal,
-      simulatedCommands: resolvedSimulatedCommands,
-      simulatedSubagents: resolvedSimulatedSubagents,
-      modularMcp: modularMcp ?? configByFile.modularMcp ?? defaults.modularMcp
-    };
-    return new Config(configParams);
-  }
-};
-function warnDeprecatedOptions({
-  experimentalGlobal,
-  experimentalSimulateCommands,
-  experimentalSimulateSubagents
-}) {
-  if (experimentalGlobal !== void 0) {
-    logger.warn("'experimentalGlobal' option is deprecated. Please use 'global' instead.");
-  }
-  if (experimentalSimulateCommands !== void 0) {
-    logger.warn(
-      "'experimentalSimulateCommands' option is deprecated. Please use 'simulatedCommands' instead."
-    );
-  }
-  if (experimentalSimulateSubagents !== void 0) {
-    logger.warn(
-      "'experimentalSimulateSubagents' option is deprecated. Please use 'simulatedSubagents' instead."
-    );
-  }
-}
-function getBaseDirsInLightOfGlobal({
-  baseDirs,
-  global
-}) {
-  if (global) {
-    return [getHomeDirectory()];
-  }
-  const resolvedBaseDirs = baseDirs.map((baseDir) => (0, import_node_path13.resolve)(baseDir));
-  resolvedBaseDirs.forEach((baseDir) => {
-    validateBaseDir(baseDir);
-  });
-  return resolvedBaseDirs;
-}
-
-// src/ignore/ignore-processor.ts
-var import_mini11 = require("zod/mini");
-
-// src/ignore/amazonqcli-ignore.ts
-var import_node_path15 = require("path");
-
-// src/types/tool-file.ts
-var ToolFile = class extends AiFile {
-};
-
-// src/ignore/rulesync-ignore.ts
-var import_node_path14 = require("path");
-var RulesyncIgnore = class _RulesyncIgnore extends RulesyncFile {
-  validate() {
-    return { success: true, error: null };
-  }
-  static getSettablePaths() {
-    return {
-      relativeDirPath: ".",
-      relativeFilePath: ".rulesyncignore"
-    };
-  }
-  static async fromFile() {
-    const baseDir = process.cwd();
-    const filePath = (0, import_node_path14.join)(baseDir, this.getSettablePaths().relativeFilePath);
-    const fileContent = await readFileContent(filePath);
-    return new _RulesyncIgnore({
-      baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
-      fileContent
-    });
-  }
-};
-
-// src/ignore/tool-ignore.ts
-var ToolIgnore = class extends ToolFile {
-  patterns;
-  constructor(params) {
-    super({
-      ...params,
-      validate: true
-    });
-    this.patterns = this.fileContent.split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
-    if (params.validate) {
-      const result = this.validate();
-      if (!result.success) {
-        throw result.error;
-      }
-    }
-  }
-  static getSettablePaths() {
-    throw new Error("Please implement this method in the subclass.");
-  }
-  getPatterns() {
-    return this.patterns;
-  }
-  validate() {
-    return { success: true, error: null };
-  }
-  static fromRulesyncIgnore(_params) {
-    throw new Error("Please implement this method in the subclass.");
-  }
-  toRulesyncIgnoreDefault() {
-    return new RulesyncIgnore({
-      baseDir: ".",
-      relativeDirPath: ".",
-      relativeFilePath: ".rulesyncignore",
-      fileContent: this.fileContent
-    });
-  }
-  static async fromFile(_params) {
-    throw new Error("Please implement this method in the subclass.");
-  }
-};
-
-// src/ignore/amazonqcli-ignore.ts
-var AmazonqcliIgnore = class _AmazonqcliIgnore extends ToolIgnore {
-  static getSettablePaths() {
-    return {
-      relativeDirPath: ".",
-      relativeFilePath: ".amazonqignore"
-    };
-  }
-  /**
-   * Convert to RulesyncIgnore format
-   */
-  toRulesyncIgnore() {
-    return this.toRulesyncIgnoreDefault();
-  }
-  /**
-   * Create AmazonqcliIgnore from RulesyncIgnore
-   * Supports conversion from unified rulesync format to Amazon Q CLI specific format
-   */
-  static fromRulesyncIgnore({
-    baseDir = process.cwd(),
-    rulesyncIgnore
-  }) {
-    const body = rulesyncIgnore.getFileContent();
-    return new _AmazonqcliIgnore({
-      baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
-      fileContent: body
-    });
-  }
-  /**
-   * Create AmazonqcliIgnore from file path
-   * Supports both proposed .q-ignore and .amazonqignore formats
-   */
-  static async fromFile({
-    baseDir = process.cwd(),
-    validate = true
-  }) {
-    const fileContent = await readFileContent(
-      (0, import_node_path15.join)(
-        baseDir,
-        this.getSettablePaths().relativeDirPath,
-        this.getSettablePaths().relativeFilePath
-      )
-    );
-    return new _AmazonqcliIgnore({
-      baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
-      fileContent,
-      validate
-    });
-  }
-};
-
-// src/ignore/augmentcode-ignore.ts
+// src/features/ignore/augmentcode-ignore.ts
 var import_node_path16 = require("path");
 var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2056,7 +2064,7 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/claudecode-ignore.ts
+// src/features/ignore/claudecode-ignore.ts
 var import_node_path17 = require("path");
 var import_es_toolkit = require("es-toolkit");
 var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
@@ -2137,7 +2145,7 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/cline-ignore.ts
+// src/features/ignore/cline-ignore.ts
 var import_node_path18 = require("path");
 var ClineIgnore = class _ClineIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2191,7 +2199,7 @@ var ClineIgnore = class _ClineIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/cursor-ignore.ts
+// src/features/ignore/cursor-ignore.ts
 var import_node_path19 = require("path");
 var CursorIgnore = class _CursorIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2241,7 +2249,7 @@ var CursorIgnore = class _CursorIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/geminicli-ignore.ts
+// src/features/ignore/geminicli-ignore.ts
 var import_node_path20 = require("path");
 var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2285,7 +2293,7 @@ var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/junie-ignore.ts
+// src/features/ignore/junie-ignore.ts
 var import_node_path21 = require("path");
 var JunieIgnore = class _JunieIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2329,7 +2337,7 @@ var JunieIgnore = class _JunieIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/kiro-ignore.ts
+// src/features/ignore/kiro-ignore.ts
 var import_node_path22 = require("path");
 var KiroIgnore = class _KiroIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2373,7 +2381,7 @@ var KiroIgnore = class _KiroIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/qwencode-ignore.ts
+// src/features/ignore/qwencode-ignore.ts
 var import_node_path23 = require("path");
 var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2417,7 +2425,7 @@ var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/roo-ignore.ts
+// src/features/ignore/roo-ignore.ts
 var import_node_path24 = require("path");
 var RooIgnore = class _RooIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2461,7 +2469,7 @@ var RooIgnore = class _RooIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/windsurf-ignore.ts
+// src/features/ignore/windsurf-ignore.ts
 var import_node_path25 = require("path");
 var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
   static getSettablePaths() {
@@ -2505,7 +2513,7 @@ var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
   }
 };
 
-// src/ignore/ignore-processor.ts
+// src/features/ignore/ignore-processor.ts
 var ignoreProcessorToolTargets = [
   "amazonqcli",
   "augmentcode",
@@ -2693,13 +2701,13 @@ var IgnoreProcessor = class extends FeatureProcessor {
   }
 };
 
-// src/mcp/mcp-processor.ts
+// src/features/mcp/mcp-processor.ts
 var import_mini13 = require("zod/mini");
 
-// src/mcp/amazonqcli-mcp.ts
+// src/features/mcp/amazonqcli-mcp.ts
 var import_node_path27 = require("path");
 
-// src/mcp/rulesync-mcp.ts
+// src/features/mcp/rulesync-mcp.ts
 var import_node_path26 = require("path");
 var import_object = require("es-toolkit/object");
 var import_mini12 = require("zod/mini");
@@ -2844,7 +2852,7 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   }
 };
 
-// src/mcp/tool-mcp.ts
+// src/features/mcp/tool-mcp.ts
 var ToolMcp = class extends ToolFile {
   constructor({ ...rest }) {
     super({
@@ -2883,7 +2891,7 @@ var ToolMcp = class extends ToolFile {
   }
 };
 
-// src/mcp/amazonqcli-mcp.ts
+// src/features/mcp/amazonqcli-mcp.ts
 var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
   json;
   constructor(params) {
@@ -2939,10 +2947,10 @@ var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
   }
 };
 
-// src/mcp/claudecode-mcp.ts
+// src/features/mcp/claudecode-mcp.ts
 var import_node_path29 = require("path");
 
-// src/mcp/modular-mcp.ts
+// src/features/mcp/modular-mcp.ts
 var import_node_path28 = require("path");
 var ModularMcp = class _ModularMcp extends AiFile {
   json;
@@ -3030,7 +3038,7 @@ var ModularMcp = class _ModularMcp extends AiFile {
   }
 };
 
-// src/mcp/claudecode-mcp.ts
+// src/features/mcp/claudecode-mcp.ts
 var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
   json;
   constructor(params) {
@@ -3111,7 +3119,7 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
   }
 };
 
-// src/mcp/cline-mcp.ts
+// src/features/mcp/cline-mcp.ts
 var import_node_path30 = require("path");
 var ClineMcp = class _ClineMcp extends ToolMcp {
   json;
@@ -3168,7 +3176,7 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
   }
 };
 
-// src/mcp/codexcli-mcp.ts
+// src/features/mcp/codexcli-mcp.ts
 var import_node_path31 = require("path");
 var smolToml = __toESM(require("smol-toml"), 1);
 var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
@@ -3262,7 +3270,7 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
   }
 };
 
-// src/mcp/copilot-mcp.ts
+// src/features/mcp/copilot-mcp.ts
 var import_node_path32 = require("path");
 var CopilotMcp = class _CopilotMcp extends ToolMcp {
   json;
@@ -3319,7 +3327,7 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
   }
 };
 
-// src/mcp/cursor-mcp.ts
+// src/features/mcp/cursor-mcp.ts
 var import_node_path33 = require("path");
 var CursorMcp = class _CursorMcp extends ToolMcp {
   json;
@@ -3387,7 +3395,7 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
   }
 };
 
-// src/mcp/geminicli-mcp.ts
+// src/features/mcp/geminicli-mcp.ts
 var import_node_path34 = require("path");
 var GeminiCliMcp = class _GeminiCliMcp extends ToolMcp {
   json;
@@ -3461,7 +3469,7 @@ var GeminiCliMcp = class _GeminiCliMcp extends ToolMcp {
   }
 };
 
-// src/mcp/roo-mcp.ts
+// src/features/mcp/roo-mcp.ts
 var import_node_path35 = require("path");
 var RooMcp = class _RooMcp extends ToolMcp {
   json;
@@ -3519,7 +3527,7 @@ var RooMcp = class _RooMcp extends ToolMcp {
   }
 };
 
-// src/mcp/mcp-processor.ts
+// src/features/mcp/mcp-processor.ts
 var mcpProcessorToolTargets = [
   "amazonqcli",
   "claudecode",
@@ -3765,19 +3773,19 @@ var McpProcessor = class extends FeatureProcessor {
   }
 };
 
-// src/rules/rules-processor.ts
+// src/features/rules/rules-processor.ts
 var import_node_path65 = require("path");
 var import_fast_xml_parser = require("fast-xml-parser");
 var import_mini22 = require("zod/mini");
 
-// src/subagents/agentsmd-subagent.ts
+// src/features/subagents/agentsmd-subagent.ts
 var import_node_path37 = require("path");
 
-// src/subagents/simulated-subagent.ts
+// src/features/subagents/simulated-subagent.ts
 var import_node_path36 = require("path");
 var import_mini14 = require("zod/mini");
 
-// src/subagents/tool-subagent.ts
+// src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
   static getSettablePaths() {
     throw new Error("Please implement this method in the subclass.");
@@ -3809,7 +3817,7 @@ var ToolSubagent = class extends ToolFile {
   }
 };
 
-// src/subagents/simulated-subagent.ts
+// src/features/subagents/simulated-subagent.ts
 var SimulatedSubagentFrontmatterSchema = import_mini14.z.object({
   name: import_mini14.z.string(),
   description: import_mini14.z.string()
@@ -3901,7 +3909,7 @@ var SimulatedSubagent = class extends ToolSubagent {
   }
 };
 
-// src/subagents/agentsmd-subagent.ts
+// src/features/subagents/agentsmd-subagent.ts
 var AgentsmdSubagent = class _AgentsmdSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
@@ -3924,7 +3932,7 @@ var AgentsmdSubagent = class _AgentsmdSubagent extends SimulatedSubagent {
   }
 };
 
-// src/subagents/codexcli-subagent.ts
+// src/features/subagents/codexcli-subagent.ts
 var import_node_path38 = require("path");
 var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
@@ -3948,7 +3956,7 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
   }
 };
 
-// src/subagents/copilot-subagent.ts
+// src/features/subagents/copilot-subagent.ts
 var import_node_path39 = require("path");
 var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
   static getSettablePaths() {
@@ -3972,7 +3980,7 @@ var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
   }
 };
 
-// src/subagents/cursor-subagent.ts
+// src/features/subagents/cursor-subagent.ts
 var import_node_path40 = require("path");
 var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
   static getSettablePaths() {
@@ -3996,7 +4004,7 @@ var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
   }
 };
 
-// src/subagents/geminicli-subagent.ts
+// src/features/subagents/geminicli-subagent.ts
 var import_node_path41 = require("path");
 var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
@@ -4020,7 +4028,7 @@ var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
   }
 };
 
-// src/subagents/roo-subagent.ts
+// src/features/subagents/roo-subagent.ts
 var import_node_path42 = require("path");
 var RooSubagent = class _RooSubagent extends SimulatedSubagent {
   static getSettablePaths() {
@@ -4044,15 +4052,15 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
   }
 };
 
-// src/subagents/subagents-processor.ts
+// src/features/subagents/subagents-processor.ts
 var import_node_path45 = require("path");
 var import_mini17 = require("zod/mini");
 
-// src/subagents/claudecode-subagent.ts
+// src/features/subagents/claudecode-subagent.ts
 var import_node_path44 = require("path");
 var import_mini16 = require("zod/mini");
 
-// src/subagents/rulesync-subagent.ts
+// src/features/subagents/rulesync-subagent.ts
 var import_node_path43 = require("path");
 var import_mini15 = require("zod/mini");
 var RulesyncSubagentModelSchema = import_mini15.z.enum(["opus", "sonnet", "haiku", "inherit"]);
@@ -4079,7 +4087,8 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       }
     }
     super({
-      ...rest
+      ...rest,
+      fileContent: stringifyFrontmatter(body, frontmatter)
     });
     this.frontmatter = frontmatter;
     this.body = body;
@@ -4128,13 +4137,12 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       relativeDirPath: this.getSettablePaths().relativeDirPath,
       relativeFilePath: filename,
       frontmatter: result.data,
-      body: content.trim(),
-      fileContent
+      body: content.trim()
     });
   }
 };
 
-// src/subagents/claudecode-subagent.ts
+// src/features/subagents/claudecode-subagent.ts
 var ClaudecodeSubagentFrontmatterSchema = import_mini16.z.object({
   name: import_mini16.z.string(),
   description: import_mini16.z.string(),
@@ -4180,7 +4188,6 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
         }
       }
     };
-    const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
     return new RulesyncSubagent({
       baseDir: ".",
       // RulesyncCommand baseDir is always the project root directory
@@ -4188,7 +4195,6 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       body: this.body,
       relativeDirPath: (0, import_node_path44.join)(".rulesync", "subagents"),
       relativeFilePath: this.getRelativeFilePath(),
-      fileContent,
       validate: true
     });
   }
@@ -4265,7 +4271,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   }
 };
 
-// src/subagents/subagents-processor.ts
+// src/features/subagents/subagents-processor.ts
 var subagentsProcessorToolTargets = [
   "agentsmd",
   "claudecode",
@@ -4561,13 +4567,13 @@ var SubagentsProcessor = class extends FeatureProcessor {
   }
 };
 
-// src/rules/agentsmd-rule.ts
+// src/features/rules/agentsmd-rule.ts
 var import_node_path48 = require("path");
 
-// src/rules/tool-rule.ts
+// src/features/rules/tool-rule.ts
 var import_node_path47 = require("path");
 
-// src/rules/rulesync-rule.ts
+// src/features/rules/rulesync-rule.ts
 var import_node_path46 = require("path");
 var import_mini18 = require("zod/mini");
 var RulesyncRuleFrontmatterSchema = import_mini18.z.object({
@@ -4713,7 +4719,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
   }
 };
 
-// src/rules/tool-rule.ts
+// src/features/rules/tool-rule.ts
 var ToolRule = class extends ToolFile {
   root;
   description;
@@ -4834,7 +4840,7 @@ var ToolRule = class extends ToolFile {
   }
 };
 
-// src/rules/agentsmd-rule.ts
+// src/features/rules/agentsmd-rule.ts
 var AgentsMdRule = class _AgentsMdRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
     super({
@@ -4900,7 +4906,7 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
   }
 };
 
-// src/rules/amazonqcli-rule.ts
+// src/features/rules/amazonqcli-rule.ts
 var import_node_path49 = require("path");
 var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
   static getSettablePaths() {
@@ -4955,7 +4961,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
   }
 };
 
-// src/rules/augmentcode-legacy-rule.ts
+// src/features/rules/augmentcode-legacy-rule.ts
 var import_node_path50 = require("path");
 var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   toRulesyncRule() {
@@ -5030,7 +5036,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   }
 };
 
-// src/rules/augmentcode-rule.ts
+// src/features/rules/augmentcode-rule.ts
 var import_node_path51 = require("path");
 var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   toRulesyncRule() {
@@ -5085,7 +5091,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   }
 };
 
-// src/rules/claudecode-rule.ts
+// src/features/rules/claudecode-rule.ts
 var import_node_path52 = require("path");
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   static getSettablePaths({
@@ -5176,7 +5182,7 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   }
 };
 
-// src/rules/cline-rule.ts
+// src/features/rules/cline-rule.ts
 var import_node_path53 = require("path");
 var import_mini19 = require("zod/mini");
 var ClineRuleFrontmatterSchema = import_mini19.z.object({
@@ -5234,7 +5240,7 @@ var ClineRule = class _ClineRule extends ToolRule {
   }
 };
 
-// src/rules/codexcli-rule.ts
+// src/features/rules/codexcli-rule.ts
 var import_node_path54 = require("path");
 var CodexcliRule = class _CodexcliRule extends ToolRule {
   static getSettablePaths({
@@ -5325,7 +5331,7 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
   }
 };
 
-// src/rules/copilot-rule.ts
+// src/features/rules/copilot-rule.ts
 var import_node_path55 = require("path");
 var import_mini20 = require("zod/mini");
 var CopilotRuleFrontmatterSchema = import_mini20.z.object({
@@ -5495,7 +5501,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   }
 };
 
-// src/rules/cursor-rule.ts
+// src/features/rules/cursor-rule.ts
 var import_node_path56 = require("path");
 var import_mini21 = require("zod/mini");
 var CursorRuleFrontmatterSchema = import_mini21.z.object({
@@ -5683,7 +5689,7 @@ var CursorRule = class _CursorRule extends ToolRule {
   }
 };
 
-// src/rules/geminicli-rule.ts
+// src/features/rules/geminicli-rule.ts
 var import_node_path57 = require("path");
 var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   static getSettablePaths({
@@ -5774,7 +5780,7 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   }
 };
 
-// src/rules/junie-rule.ts
+// src/features/rules/junie-rule.ts
 var import_node_path58 = require("path");
 var JunieRule = class _JunieRule extends ToolRule {
   static getSettablePaths() {
@@ -5834,7 +5840,7 @@ var JunieRule = class _JunieRule extends ToolRule {
   }
 };
 
-// src/rules/kiro-rule.ts
+// src/features/rules/kiro-rule.ts
 var import_node_path59 = require("path");
 var KiroRule = class _KiroRule extends ToolRule {
   static getSettablePaths() {
@@ -5889,7 +5895,7 @@ var KiroRule = class _KiroRule extends ToolRule {
   }
 };
 
-// src/rules/opencode-rule.ts
+// src/features/rules/opencode-rule.ts
 var import_node_path60 = require("path");
 var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   static getSettablePaths() {
@@ -5949,7 +5955,7 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   }
 };
 
-// src/rules/qwencode-rule.ts
+// src/features/rules/qwencode-rule.ts
 var import_node_path61 = require("path");
 var QwencodeRule = class _QwencodeRule extends ToolRule {
   static getSettablePaths() {
@@ -6006,7 +6012,7 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
   }
 };
 
-// src/rules/roo-rule.ts
+// src/features/rules/roo-rule.ts
 var import_node_path62 = require("path");
 var RooRule = class _RooRule extends ToolRule {
   static getSettablePaths() {
@@ -6076,7 +6082,7 @@ var RooRule = class _RooRule extends ToolRule {
   }
 };
 
-// src/rules/warp-rule.ts
+// src/features/rules/warp-rule.ts
 var import_node_path63 = require("path");
 var WarpRule = class _WarpRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
@@ -6143,7 +6149,7 @@ var WarpRule = class _WarpRule extends ToolRule {
   }
 };
 
-// src/rules/windsurf-rule.ts
+// src/features/rules/windsurf-rule.ts
 var import_node_path64 = require("path");
 var WindsurfRule = class _WindsurfRule extends ToolRule {
   static getSettablePaths() {
@@ -6197,7 +6203,7 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
   }
 };
 
-// src/rules/rules-processor.ts
+// src/features/rules/rules-processor.ts
 var rulesProcessorToolTargets = [
   "agentsmd",
   "amazonqcli",
@@ -7707,68 +7713,448 @@ Attention, again, you are just the planner, so though you can read any files and
 }
 
 // src/cli/commands/mcp.ts
-var import_node_path68 = require("path");
 var import_fastmcp = require("fastmcp");
+
+// src/mcp/commands.ts
+var import_node_path68 = require("path");
 var import_mini23 = require("zod/mini");
-var MAX_RULE_SIZE_BYTES = 1024 * 1024;
-var MAX_RULES_COUNT = 1e3;
-var RULES_DIR_PREFIX = ".rulesync/rules";
-function validateRulePath(relativePathFromCwd) {
-  const normalizedPath = relativePathFromCwd.replace(/\\/g, "/");
-  if (!normalizedPath.startsWith(`${RULES_DIR_PREFIX}/`)) {
-    throw new Error(`Invalid rule path: must be within ${RULES_DIR_PREFIX}/ directory`);
-  }
-  try {
-    resolvePath(normalizedPath, process.cwd());
-  } catch (error) {
-    throw new Error(`Path validation failed: ${formatError(error)}`, { cause: error });
-  }
-  const filename = (0, import_node_path68.basename)(normalizedPath);
-  if (!/^[a-zA-Z0-9_-]+\.md$/.test(filename)) {
-    throw new Error(
-      `Invalid filename: ${filename}. Must match pattern [a-zA-Z0-9_-]+.md (alphanumeric, hyphens, underscores only)`
-    );
-  }
-}
-async function listRules() {
-  const rulesDir = (0, import_node_path68.join)(process.cwd(), ".rulesync", "rules");
+var maxCommandSizeBytes = 1024 * 1024;
+var maxCommandsCount = 1e3;
+async function listCommands() {
+  const commandsDir = (0, import_node_path68.join)(process.cwd(), ".rulesync", "commands");
   try {
-    const files = await listDirectoryFiles(rulesDir);
+    const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
-    const rules = await Promise.all(
+    const commands = await Promise.all(
       mdFiles.map(async (file) => {
         try {
-          const rule = await RulesyncRule.fromFile({
-            relativeFilePath: file,
-            validate: true
+          const command = await RulesyncCommand.fromFile({
+            relativeFilePath: file
           });
-          const frontmatter = rule.getFrontmatter();
+          const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", file),
+            relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "commands", file),
             frontmatter
           };
         } catch (error) {
-          logger.error(`Failed to read rule file ${file}: ${formatError(error)}`);
+          logger.error(`Failed to read command file ${file}: ${formatError(error)}`);
           return null;
         }
       })
     );
-    return rules.filter((rule) => rule !== null);
+    return commands.filter((command) => command !== null);
   } catch (error) {
-    logger.error(`Failed to read rules directory: ${formatError(error)}`);
+    logger.error(`Failed to read commands directory: ${formatError(error)}`);
     return [];
   }
 }
-async function getRule({ relativePathFromCwd }) {
-  validateRulePath(relativePathFromCwd);
+async function getCommand({ relativePathFromCwd }) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
   const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  try {
+    const command = await RulesyncCommand.fromFile({
+      relativeFilePath: filename
+    });
+    return {
+      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "commands", filename),
+      frontmatter: command.getFrontmatter(),
+      body: command.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to read command file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function putCommand({
+  relativePathFromCwd,
+  frontmatter,
+  body
+}) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  const estimatedSize = JSON.stringify(frontmatter).length + body.length;
+  if (estimatedSize > maxCommandSizeBytes) {
+    throw new Error(
+      `Command size ${estimatedSize} bytes exceeds maximum ${maxCommandSizeBytes} bytes (1MB)`
+    );
+  }
+  try {
+    const existingCommands = await listCommands();
+    const isUpdate = existingCommands.some(
+      (command2) => command2.relativePathFromCwd === (0, import_node_path68.join)(".rulesync", "commands", filename)
+    );
+    if (!isUpdate && existingCommands.length >= maxCommandsCount) {
+      throw new Error(`Maximum number of commands (${maxCommandsCount}) reached`);
+    }
+    const fileContent = stringifyFrontmatter(body, frontmatter);
+    const command = new RulesyncCommand({
+      baseDir: process.cwd(),
+      relativeDirPath: (0, import_node_path68.join)(".rulesync", "commands"),
+      relativeFilePath: filename,
+      frontmatter,
+      body,
+      fileContent,
+      validate: true
+    });
+    const commandsDir = (0, import_node_path68.join)(process.cwd(), ".rulesync", "commands");
+    await ensureDir(commandsDir);
+    await writeFileContent(command.getFilePath(), command.getFileContent());
+    return {
+      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "commands", filename),
+      frontmatter: command.getFrontmatter(),
+      body: command.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to write command file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function deleteCommand({ relativePathFromCwd }) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path68.join)(process.cwd(), ".rulesync", "commands", filename);
+  try {
+    await removeFile(fullPath);
+    return {
+      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "commands", filename)
+    };
+  } catch (error) {
+    throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+var commandToolSchemas = {
+  listCommands: import_mini23.z.object({}),
+  getCommand: import_mini23.z.object({
+    relativePathFromCwd: import_mini23.z.string()
+  }),
+  putCommand: import_mini23.z.object({
+    relativePathFromCwd: import_mini23.z.string(),
+    frontmatter: RulesyncCommandFrontmatterSchema,
+    body: import_mini23.z.string()
+  }),
+  deleteCommand: import_mini23.z.object({
+    relativePathFromCwd: import_mini23.z.string()
+  })
+};
+var commandTools = {
+  listCommands: {
+    name: "listCommands",
+    description: `List all commands from ${(0, import_node_path68.join)(".rulesync", "commands", "*.md")} with their frontmatter.`,
+    parameters: commandToolSchemas.listCommands,
+    execute: async () => {
+      const commands = await listCommands();
+      const output = { commands };
+      return JSON.stringify(output, null, 2);
+    }
+  },
+  getCommand: {
+    name: "getCommand",
+    description: "Get detailed information about a specific command. relativePathFromCwd parameter is required.",
+    parameters: commandToolSchemas.getCommand,
+    execute: async (args) => {
+      const result = await getCommand({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  putCommand: {
+    name: "putCommand",
+    description: "Create or update a command (upsert operation). relativePathFromCwd, frontmatter, and body parameters are required.",
+    parameters: commandToolSchemas.putCommand,
+    execute: async (args) => {
+      const result = await putCommand({
+        relativePathFromCwd: args.relativePathFromCwd,
+        frontmatter: args.frontmatter,
+        body: args.body
+      });
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  deleteCommand: {
+    name: "deleteCommand",
+    description: "Delete a command file. relativePathFromCwd parameter is required.",
+    parameters: commandToolSchemas.deleteCommand,
+    execute: async (args) => {
+      const result = await deleteCommand({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  }
+};
+
+// src/mcp/ignore.ts
+var import_node_path69 = require("path");
+var import_mini24 = require("zod/mini");
+var maxIgnoreFileSizeBytes = 100 * 1024;
+async function getIgnoreFile() {
+  const ignoreFilePath = (0, import_node_path69.join)(process.cwd(), ".rulesyncignore");
+  try {
+    const content = await readFileContent(ignoreFilePath);
+    return {
+      relativePathFromCwd: ".rulesyncignore",
+      content
+    };
+  } catch (error) {
+    throw new Error(`Failed to read .rulesyncignore file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function putIgnoreFile({ content }) {
+  const ignoreFilePath = (0, import_node_path69.join)(process.cwd(), ".rulesyncignore");
+  const contentSizeBytes = Buffer.byteLength(content, "utf8");
+  if (contentSizeBytes > maxIgnoreFileSizeBytes) {
+    throw new Error(
+      `Ignore file size ${contentSizeBytes} bytes exceeds maximum ${maxIgnoreFileSizeBytes} bytes (100KB)`
+    );
+  }
+  try {
+    await ensureDir(process.cwd());
+    await writeFileContent(ignoreFilePath, content);
+    return {
+      relativePathFromCwd: ".rulesyncignore",
+      content
+    };
+  } catch (error) {
+    throw new Error(`Failed to write .rulesyncignore file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function deleteIgnoreFile() {
+  const ignoreFilePath = (0, import_node_path69.join)(process.cwd(), ".rulesyncignore");
+  try {
+    await removeFile(ignoreFilePath);
+    return {
+      relativePathFromCwd: ".rulesyncignore"
+    };
+  } catch (error) {
+    throw new Error(`Failed to delete .rulesyncignore file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+var ignoreToolSchemas = {
+  getIgnoreFile: import_mini24.z.object({}),
+  putIgnoreFile: import_mini24.z.object({
+    content: import_mini24.z.string()
+  }),
+  deleteIgnoreFile: import_mini24.z.object({})
+};
+var ignoreTools = {
+  getIgnoreFile: {
+    name: "getIgnoreFile",
+    description: "Get the content of the .rulesyncignore file from the project root.",
+    parameters: ignoreToolSchemas.getIgnoreFile,
+    execute: async () => {
+      const result = await getIgnoreFile();
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  putIgnoreFile: {
+    name: "putIgnoreFile",
+    description: "Create or update the .rulesyncignore file (upsert operation). content parameter is required.",
+    parameters: ignoreToolSchemas.putIgnoreFile,
+    execute: async (args) => {
+      const result = await putIgnoreFile({ content: args.content });
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  deleteIgnoreFile: {
+    name: "deleteIgnoreFile",
+    description: "Delete the .rulesyncignore file from the project root.",
+    parameters: ignoreToolSchemas.deleteIgnoreFile,
+    execute: async () => {
+      const result = await deleteIgnoreFile();
+      return JSON.stringify(result, null, 2);
+    }
+  }
+};
+
+// src/mcp/mcp.ts
+var import_node_path70 = require("path");
+var import_mini25 = require("zod/mini");
+var maxMcpSizeBytes = 1024 * 1024;
+async function getMcpFile() {
+  try {
+    const rulesyncMcp = await RulesyncMcp.fromFile({
+      validate: true,
+      modularMcp: false
+    });
+    const relativePathFromCwd = (0, import_node_path70.join)(
+      rulesyncMcp.getRelativeDirPath(),
+      rulesyncMcp.getRelativeFilePath()
+    );
+    return {
+      relativePathFromCwd,
+      content: rulesyncMcp.getFileContent()
+    };
+  } catch (error) {
+    throw new Error(`Failed to read MCP file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function putMcpFile({ content }) {
+  if (content.length > maxMcpSizeBytes) {
+    throw new Error(
+      `MCP file size ${content.length} bytes exceeds maximum ${maxMcpSizeBytes} bytes (1MB)`
+    );
+  }
+  try {
+    JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Invalid JSON format in MCP file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+  try {
+    const baseDir = process.cwd();
+    const paths = RulesyncMcp.getSettablePaths();
+    const relativeDirPath = paths.recommended.relativeDirPath;
+    const relativeFilePath = paths.recommended.relativeFilePath;
+    const fullPath = (0, import_node_path70.join)(baseDir, relativeDirPath, relativeFilePath);
+    const rulesyncMcp = new RulesyncMcp({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: content,
+      validate: true,
+      modularMcp: false
+    });
+    await ensureDir((0, import_node_path70.join)(baseDir, relativeDirPath));
+    await writeFileContent(fullPath, content);
+    const relativePathFromCwd = (0, import_node_path70.join)(relativeDirPath, relativeFilePath);
+    return {
+      relativePathFromCwd,
+      content: rulesyncMcp.getFileContent()
+    };
+  } catch (error) {
+    throw new Error(`Failed to write MCP file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function deleteMcpFile() {
+  try {
+    const baseDir = process.cwd();
+    const paths = RulesyncMcp.getSettablePaths();
+    const recommendedPath = (0, import_node_path70.join)(
+      baseDir,
+      paths.recommended.relativeDirPath,
+      paths.recommended.relativeFilePath
+    );
+    const legacyPath = (0, import_node_path70.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    await removeFile(recommendedPath);
+    await removeFile(legacyPath);
+    const relativePathFromCwd = (0, import_node_path70.join)(
+      paths.recommended.relativeDirPath,
+      paths.recommended.relativeFilePath
+    );
+    return {
+      relativePathFromCwd
+    };
+  } catch (error) {
+    throw new Error(`Failed to delete MCP file: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+var mcpToolSchemas = {
+  getMcpFile: import_mini25.z.object({}),
+  putMcpFile: import_mini25.z.object({
+    content: import_mini25.z.string()
+  }),
+  deleteMcpFile: import_mini25.z.object({})
+};
+var mcpTools = {
+  getMcpFile: {
+    name: "getMcpFile",
+    description: `Get the MCP configuration file (${(0, import_node_path70.join)(".rulesync", "mcp.json")}).`,
+    parameters: mcpToolSchemas.getMcpFile,
+    execute: async () => {
+      const result = await getMcpFile();
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  putMcpFile: {
+    name: "putMcpFile",
+    description: "Create or update the MCP configuration file (upsert operation). content parameter is required and must be valid JSON.",
+    parameters: mcpToolSchemas.putMcpFile,
+    execute: async (args) => {
+      const result = await putMcpFile({ content: args.content });
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  deleteMcpFile: {
+    name: "deleteMcpFile",
+    description: "Delete the MCP configuration file.",
+    parameters: mcpToolSchemas.deleteMcpFile,
+    execute: async () => {
+      const result = await deleteMcpFile();
+      return JSON.stringify(result, null, 2);
+    }
+  }
+};
+
+// src/mcp/rules.ts
+var import_node_path71 = require("path");
+var import_mini26 = require("zod/mini");
+var maxRuleSizeBytes = 1024 * 1024;
+var maxRulesCount = 1e3;
+async function listRules() {
+  const rulesDir = (0, import_node_path71.join)(process.cwd(), ".rulesync", "rules");
+  try {
+    const files = await listDirectoryFiles(rulesDir);
+    const mdFiles = files.filter((file) => file.endsWith(".md"));
+    const rules = await Promise.all(
+      mdFiles.map(async (file) => {
+        try {
+          const rule = await RulesyncRule.fromFile({
+            relativeFilePath: file,
+            validate: true
+          });
+          const frontmatter = rule.getFrontmatter();
+          return {
+            relativePathFromCwd: (0, import_node_path71.join)(".rulesync", "rules", file),
+            frontmatter
+          };
+        } catch (error) {
+          logger.error(`Failed to read rule file ${file}: ${formatError(error)}`);
+          return null;
+        }
+      })
+    );
+    return rules.filter((rule) => rule !== null);
+  } catch (error) {
+    logger.error(`Failed to read rules directory: ${formatError(error)}`);
+    return [];
+  }
+}
+async function getRule({ relativePathFromCwd }) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path71.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", filename),
+      relativePathFromCwd: (0, import_node_path71.join)(".rulesync", "rules", filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -7783,35 +8169,38 @@ async function putRule({
   frontmatter,
   body
 }) {
-  validateRulePath(relativePathFromCwd);
-  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path71.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
-  if (estimatedSize > MAX_RULE_SIZE_BYTES) {
+  if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
-      `Rule size ${estimatedSize} bytes exceeds maximum ${MAX_RULE_SIZE_BYTES} bytes (1MB)`
+      `Rule size ${estimatedSize} bytes exceeds maximum ${maxRuleSizeBytes} bytes (1MB)`
     );
   }
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path68.join)(".rulesync", "rules", filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path71.join)(".rulesync", "rules", filename)
     );
-    if (!isUpdate && existingRules.length >= MAX_RULES_COUNT) {
-      throw new Error(`Maximum number of rules (${MAX_RULES_COUNT}) reached`);
+    if (!isUpdate && existingRules.length >= maxRulesCount) {
+      throw new Error(`Maximum number of rules (${maxRulesCount}) reached`);
     }
     const rule = new RulesyncRule({
       baseDir: process.cwd(),
-      relativeDirPath: ".rulesync/rules",
+      relativeDirPath: (0, import_node_path71.join)(".rulesync", "rules"),
       relativeFilePath: filename,
       frontmatter,
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path68.join)(process.cwd(), ".rulesync", "rules");
+    const rulesDir = (0, import_node_path71.join)(process.cwd(), ".rulesync", "rules");
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", filename),
+      relativePathFromCwd: (0, import_node_path71.join)(".rulesync", "rules", filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -7822,13 +8211,16 @@ async function putRule({
   }
 }
 async function deleteRule({ relativePathFromCwd }) {
-  validateRulePath(relativePathFromCwd);
-  const filename = (0, import_node_path68.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path68.join)(process.cwd(), ".rulesync", "rules", filename);
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path71.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path71.join)(process.cwd(), ".rulesync", "rules", filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path68.join)(".rulesync", "rules", filename)
+      relativePathFromCwd: (0, import_node_path71.join)(".rulesync", "rules", filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -7836,42 +8228,44 @@ async function deleteRule({ relativePathFromCwd }) {
     });
   }
 }
-async function mcpCommand({ version }) {
-  const server = new import_fastmcp.FastMCP({
-    name: "rulesync-mcp-server",
-    // Type assertion is safe here because version comes from package.json which follows semver
-    // eslint-disable-next-line no-type-assertion/no-type-assertion
-    version
-  });
-  server.addTool({
+var ruleToolSchemas = {
+  listRules: import_mini26.z.object({}),
+  getRule: import_mini26.z.object({
+    relativePathFromCwd: import_mini26.z.string()
+  }),
+  putRule: import_mini26.z.object({
+    relativePathFromCwd: import_mini26.z.string(),
+    frontmatter: RulesyncRuleFrontmatterSchema,
+    body: import_mini26.z.string()
+  }),
+  deleteRule: import_mini26.z.object({
+    relativePathFromCwd: import_mini26.z.string()
+  })
+};
+var ruleTools = {
+  listRules: {
     name: "listRules",
-    description: "List all rules from .rulesync/rules/*.md with their frontmatter",
-    parameters: import_mini23.z.object({}),
+    description: `List all rules from ${(0, import_node_path71.join)(".rulesync", "rules", "*.md")} with their frontmatter.`,
+    parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
       const output = { rules };
       return JSON.stringify(output, null, 2);
     }
-  });
-  server.addTool({
+  },
+  getRule: {
     name: "getRule",
     description: "Get detailed information about a specific rule. relativePathFromCwd parameter is required.",
-    parameters: import_mini23.z.object({
-      relativePathFromCwd: import_mini23.z.string()
-    }),
+    parameters: ruleToolSchemas.getRule,
     execute: async (args) => {
       const result = await getRule({ relativePathFromCwd: args.relativePathFromCwd });
       return JSON.stringify(result, null, 2);
     }
-  });
-  server.addTool({
+  },
+  putRule: {
     name: "putRule",
     description: "Create or update a rule (upsert operation). relativePathFromCwd, frontmatter, and body parameters are required.",
-    parameters: import_mini23.z.object({
-      relativePathFromCwd: import_mini23.z.string(),
-      frontmatter: RulesyncRuleFrontmatterSchema,
-      body: import_mini23.z.string()
-    }),
+    parameters: ruleToolSchemas.putRule,
     execute: async (args) => {
       const result = await putRule({
         relativePathFromCwd: args.relativePathFromCwd,
@@ -7880,18 +8274,227 @@ async function mcpCommand({ version }) {
       });
       return JSON.stringify(result, null, 2);
     }
-  });
-  server.addTool({
+  },
+  deleteRule: {
     name: "deleteRule",
     description: "Delete a rule file. relativePathFromCwd parameter is required.",
-    parameters: import_mini23.z.object({
-      relativePathFromCwd: import_mini23.z.string()
-    }),
+    parameters: ruleToolSchemas.deleteRule,
     execute: async (args) => {
       const result = await deleteRule({ relativePathFromCwd: args.relativePathFromCwd });
       return JSON.stringify(result, null, 2);
     }
+  }
+};
+
+// src/mcp/subagents.ts
+var import_node_path72 = require("path");
+var import_mini27 = require("zod/mini");
+var maxSubagentSizeBytes = 1024 * 1024;
+var maxSubagentsCount = 1e3;
+async function listSubagents() {
+  const subagentsDir = (0, import_node_path72.join)(process.cwd(), ".rulesync", "subagents");
+  try {
+    const files = await listDirectoryFiles(subagentsDir);
+    const mdFiles = files.filter((file) => file.endsWith(".md"));
+    const subagents = await Promise.all(
+      mdFiles.map(async (file) => {
+        try {
+          const subagent = await RulesyncSubagent.fromFile({
+            relativeFilePath: file,
+            validate: true
+          });
+          const frontmatter = subagent.getFrontmatter();
+          return {
+            relativePathFromCwd: (0, import_node_path72.join)(".rulesync", "subagents", file),
+            frontmatter
+          };
+        } catch (error) {
+          logger.error(`Failed to read subagent file ${file}: ${formatError(error)}`);
+          return null;
+        }
+      })
+    );
+    return subagents.filter(
+      (subagent) => subagent !== null
+    );
+  } catch (error) {
+    logger.error(`Failed to read subagents directory: ${formatError(error)}`);
+    return [];
+  }
+}
+async function getSubagent({ relativePathFromCwd }) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path72.basename)(relativePathFromCwd);
+  try {
+    const subagent = await RulesyncSubagent.fromFile({
+      relativeFilePath: filename,
+      validate: true
+    });
+    return {
+      relativePathFromCwd: (0, import_node_path72.join)(".rulesync", "subagents", filename),
+      frontmatter: subagent.getFrontmatter(),
+      body: subagent.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to read subagent file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function putSubagent({
+  relativePathFromCwd,
+  frontmatter,
+  body
+}) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path72.basename)(relativePathFromCwd);
+  const estimatedSize = JSON.stringify(frontmatter).length + body.length;
+  if (estimatedSize > maxSubagentSizeBytes) {
+    throw new Error(
+      `Subagent size ${estimatedSize} bytes exceeds maximum ${maxSubagentSizeBytes} bytes (1MB)`
+    );
+  }
+  try {
+    const existingSubagents = await listSubagents();
+    const isUpdate = existingSubagents.some(
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path72.join)(".rulesync", "subagents", filename)
+    );
+    if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
+      throw new Error(`Maximum number of subagents (${maxSubagentsCount}) reached`);
+    }
+    const subagent = new RulesyncSubagent({
+      baseDir: process.cwd(),
+      relativeDirPath: (0, import_node_path72.join)(".rulesync", "subagents"),
+      relativeFilePath: filename,
+      frontmatter,
+      body,
+      validate: true
+    });
+    const subagentsDir = (0, import_node_path72.join)(process.cwd(), ".rulesync", "subagents");
+    await ensureDir(subagentsDir);
+    await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
+    return {
+      relativePathFromCwd: (0, import_node_path72.join)(".rulesync", "subagents", filename),
+      frontmatter: subagent.getFrontmatter(),
+      body: subagent.getBody()
+    };
+  } catch (error) {
+    throw new Error(`Failed to write subagent file ${relativePathFromCwd}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function deleteSubagent({ relativePathFromCwd }) {
+  checkPathTraversal({
+    relativePath: relativePathFromCwd,
+    intendedRootDir: process.cwd()
+  });
+  const filename = (0, import_node_path72.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path72.join)(process.cwd(), ".rulesync", "subagents", filename);
+  try {
+    await removeFile(fullPath);
+    return {
+      relativePathFromCwd: (0, import_node_path72.join)(".rulesync", "subagents", filename)
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to delete subagent file ${relativePathFromCwd}: ${formatError(error)}`,
+      {
+        cause: error
+      }
+    );
+  }
+}
+var subagentToolSchemas = {
+  listSubagents: import_mini27.z.object({}),
+  getSubagent: import_mini27.z.object({
+    relativePathFromCwd: import_mini27.z.string()
+  }),
+  putSubagent: import_mini27.z.object({
+    relativePathFromCwd: import_mini27.z.string(),
+    frontmatter: RulesyncSubagentFrontmatterSchema,
+    body: import_mini27.z.string()
+  }),
+  deleteSubagent: import_mini27.z.object({
+    relativePathFromCwd: import_mini27.z.string()
+  })
+};
+var subagentTools = {
+  listSubagents: {
+    name: "listSubagents",
+    description: `List all subagents from ${(0, import_node_path72.join)(".rulesync", "subagents", "*.md")} with their frontmatter.`,
+    parameters: subagentToolSchemas.listSubagents,
+    execute: async () => {
+      const subagents = await listSubagents();
+      const output = { subagents };
+      return JSON.stringify(output, null, 2);
+    }
+  },
+  getSubagent: {
+    name: "getSubagent",
+    description: "Get detailed information about a specific subagent. relativePathFromCwd parameter is required.",
+    parameters: subagentToolSchemas.getSubagent,
+    execute: async (args) => {
+      const result = await getSubagent({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  putSubagent: {
+    name: "putSubagent",
+    description: "Create or update a subagent (upsert operation). relativePathFromCwd, frontmatter, and body parameters are required.",
+    parameters: subagentToolSchemas.putSubagent,
+    execute: async (args) => {
+      const result = await putSubagent({
+        relativePathFromCwd: args.relativePathFromCwd,
+        frontmatter: args.frontmatter,
+        body: args.body
+      });
+      return JSON.stringify(result, null, 2);
+    }
+  },
+  deleteSubagent: {
+    name: "deleteSubagent",
+    description: "Delete a subagent file. relativePathFromCwd parameter is required.",
+    parameters: subagentToolSchemas.deleteSubagent,
+    execute: async (args) => {
+      const result = await deleteSubagent({ relativePathFromCwd: args.relativePathFromCwd });
+      return JSON.stringify(result, null, 2);
+    }
+  }
+};
+
+// src/cli/commands/mcp.ts
+async function mcpCommand({ version }) {
+  const server = new import_fastmcp.FastMCP({
+    name: "Rulesync MCP Server",
+    // eslint-disable-next-line no-type-assertion/no-type-assertion
+    version,
+    instructions: "This server handles Rulesync files including rules, commands, MCP, ignore files, and subagents for any AI agents. It should be used when you need those files."
   });
+  server.addTool(ruleTools.listRules);
+  server.addTool(ruleTools.getRule);
+  server.addTool(ruleTools.putRule);
+  server.addTool(ruleTools.deleteRule);
+  server.addTool(commandTools.listCommands);
+  server.addTool(commandTools.getCommand);
+  server.addTool(commandTools.putCommand);
+  server.addTool(commandTools.deleteCommand);
+  server.addTool(subagentTools.listSubagents);
+  server.addTool(subagentTools.getSubagent);
+  server.addTool(subagentTools.putSubagent);
+  server.addTool(subagentTools.deleteSubagent);
+  server.addTool(ignoreTools.getIgnoreFile);
+  server.addTool(ignoreTools.putIgnoreFile);
+  server.addTool(ignoreTools.deleteIgnoreFile);
+  server.addTool(mcpTools.getMcpFile);
+  server.addTool(mcpTools.putMcpFile);
+  server.addTool(mcpTools.deleteMcpFile);
   logger.info("Rulesync MCP server started via stdio");
   void server.start({
     transportType: "stdio"
@@ -7899,7 +8502,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.19.0";
+var getVersion = () => "3.20.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();