rulesync 0.68.1 → 0.70.0

package/dist/index.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/index.ts
-var import_node_path17 = require("path");
+var import_node_path50 = require("path");
 var import_node_url = require("url");
 var import_commander = require("commander");
 
@@ -52,6 +52,7 @@ var ALL_TOOL_TARGETS = [
   "geminicli",
   "kiro",
   "junie",
+  "warp",
   "windsurf"
 ];
 var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
@@ -216,14 +217,6 @@ async function listDirectoryFiles(dir) {
     return [];
   }
 }
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await (0, import_promises.readdir)(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path.join)(dir, file));
-  } catch {
-    return [];
-  }
-}
 async function findFilesByGlobs(globs) {
   return (0, import_node_fs.globSync)(globs);
 }
@@ -273,7 +266,7 @@ async function initConfig() {
 var import_es_toolkit = require("es-toolkit");
 
 // src/commands/commands-processor.ts
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var import_mini7 = require("zod/mini");
 
 // src/types/feature-processor.ts
@@ -306,15 +299,48 @@ var FeatureProcessor = class {
 };
 
 // src/commands/claudecode-command.ts
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 var import_mini4 = require("zod/mini");
 
 // src/utils/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function deepRemoveNullishValue(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const cleanedArray = value.map((item) => deepRemoveNullishValue(item)).filter((item) => item !== void 0);
+    return cleanedArray;
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      const cleaned = deepRemoveNullishValue(val);
+      if (cleaned !== void 0) {
+        result[key] = cleaned;
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function deepRemoveNullishObject(obj) {
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    const cleaned = deepRemoveNullishValue(val);
+    if (cleaned !== void 0) {
+      result[key] = cleaned;
+    }
+  }
+  return result;
+}
 function stringifyFrontmatter(body, frontmatter) {
-  const cleanFrontmatter = Object.fromEntries(
-    Object.entries(frontmatter).filter(([, value]) => value !== null && value !== void 0)
-  );
+  const cleanFrontmatter = deepRemoveNullishObject(frontmatter);
   return import_gray_matter.default.stringify(body, cleanFrontmatter);
 }
 function parseFrontmatter(content) {
@@ -323,11 +349,20 @@ function parseFrontmatter(content) {
 }
 
 // src/commands/rulesync-command.ts
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 var import_mini3 = require("zod/mini");
 
+// src/constants/paths.ts
+var import_node_path2 = require("path");
+var RULESYNC_DIR = ".rulesync";
+var RULESYNC_RULES_DIR = (0, import_node_path2.join)(".rulesync", "rules");
+var RULESYNC_RULES_DIR_LEGACY = ".rulesync";
+var RULESYNC_MCP_FILE = (0, import_node_path2.join)(".rulesync", ".mcp.json");
+var RULESYNC_COMMANDS_DIR = (0, import_node_path2.join)(".rulesync", "commands");
+var RULESYNC_SUBAGENTS_DIR = (0, import_node_path2.join)(".rulesync", "subagents");
+
 // 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 "."
@@ -363,7 +398,7 @@ var AiFile = class {
       }
     }
   }
-  static async fromFilePath(_params) {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   getBaseDir() {
@@ -376,13 +411,13 @@ var AiFile = class {
     return this.relativeFilePath;
   }
   getFilePath() {
-    return import_node_path2.default.join(this.baseDir, this.relativeDirPath, this.relativeFilePath);
+    return import_node_path3.default.join(this.baseDir, this.relativeDirPath, this.relativeFilePath);
   }
   getFileContent() {
     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;
@@ -391,13 +426,10 @@ var AiFile = class {
 
 // src/types/rulesync-file.ts
 var RulesyncFile = class extends AiFile {
-  static async fromFilePath(_params) {
-    throw new Error("Please implement this method in the subclass.");
-  }
   static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
-  static async fromLegacyFile(_params) {
+  static async fromFileLegacy(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
 };
@@ -441,14 +473,16 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
       return { success: false, error: result.error };
     }
   }
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    relativeFilePath
+  }) {
+    const fileContent = await readFileContent((0, import_node_path4.join)(RULESYNC_COMMANDS_DIR, relativeFilePath));
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncCommandFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
     }
-    const filename = (0, import_node_path3.basename)(filePath);
+    const filename = (0, import_node_path4.basename)(relativeFilePath);
     return new _RulesyncCommand({
       baseDir: ".",
       relativeDirPath: ".rulesync/commands",
@@ -474,7 +508,7 @@ var ToolCommand = class extends AiFile {
    * @param params - Parameters including the file path to load
    * @returns Promise resolving to a concrete ToolCommand instance
    */
-  static async fromFilePath(_params) {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   /**
@@ -551,7 +585,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       baseDir,
       frontmatter: claudecodeFrontmatter,
       body,
-      relativeDirPath: (0, import_node_path4.join)(".claude", "commands"),
+      relativeDirPath: (0, import_node_path5.join)(".claude", "commands"),
       relativeFilePath: rulesyncCommand.getRelativeFilePath(),
       validate
     });
@@ -567,11 +601,12 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       return { success: false, error: result.error };
     }
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    filePath,
+    relativeFilePath,
     validate = true
   }) {
+    const filePath = (0, import_node_path5.join)(baseDir, ".claude", "commands", relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeCommandFrontmatterSchema.safeParse(frontmatter);
@@ -581,7 +616,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
     return new _ClaudecodeCommand({
       baseDir,
       relativeDirPath: ".claude/commands",
-      relativeFilePath: (0, import_node_path4.basename)(filePath),
+      relativeFilePath: (0, import_node_path5.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -590,7 +625,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
 };
 
 // src/commands/geminicli-command.ts
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 var import_smol_toml = require("smol-toml");
 var import_mini5 = require("zod/mini");
 var GeminiCliCommandFrontmatterSchema = import_mini5.z.object({
@@ -676,16 +711,17 @@ ${geminiFrontmatter.prompt}
       validate
     });
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    filePath,
+    relativeFilePath,
     validate = true
   }) {
+    const filePath = (0, import_node_path6.join)(baseDir, ".gemini", "commands", relativeFilePath);
     const fileContent = await readFileContent(filePath);
     return new _GeminiCliCommand({
       baseDir,
       relativeDirPath: ".gemini/commands",
-      relativeFilePath: (0, import_node_path5.basename)(filePath),
+      relativeFilePath: (0, import_node_path6.basename)(relativeFilePath),
       fileContent,
       validate
     });
@@ -698,26 +734,10 @@ ${geminiFrontmatter.prompt}
       return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
     }
   }
-  async processContent(content, args) {
-    let processedContent = content;
-    processedContent = this.processArgumentPlaceholder(processedContent, args);
-    return processedContent;
-  }
-  processArgumentPlaceholder(content, args) {
-    if (content.includes("{{args}}")) {
-      return content.replace(/\{\{args\}\}/g, args || "");
-    }
-    if (args) {
-      return `${content}
-
-${args}`;
-    }
-    return content;
-  }
 };
 
 // src/commands/roo-command.ts
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 var import_mini6 = require("zod/mini");
 var RooCommandFrontmatterSchema = import_mini6.z.object({
   description: import_mini6.z.string(),
@@ -794,11 +814,12 @@ var RooCommand = class _RooCommand extends ToolCommand {
       return { success: false, error: result.error };
     }
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    filePath,
+    relativeFilePath,
     validate = true
   }) {
+    const filePath = (0, import_node_path7.join)(baseDir, ".roo", "commands", relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RooCommandFrontmatterSchema.safeParse(frontmatter);
@@ -808,7 +829,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
     return new _RooCommand({
       baseDir,
       relativeDirPath: ".roo/commands",
-      relativeFilePath: (0, import_node_path6.basename)(filePath),
+      relativeFilePath: (0, import_node_path7.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       fileContent,
@@ -870,37 +891,12 @@ var CommandsProcessor = class extends FeatureProcessor {
    * Load and parse rulesync command files from .rulesync/commands/ directory
    */
   async loadRulesyncFiles() {
-    const commandsDir = (0, import_node_path7.join)(this.baseDir, ".rulesync", "commands");
-    const dirExists = await directoryExists(commandsDir);
-    if (!dirExists) {
-      logger.debug(`Rulesync commands directory not found: ${commandsDir}`);
-      return [];
-    }
-    const allMdFiles = await findFiles(commandsDir, ".md");
-    const mdFiles = allMdFiles.map((f) => (0, import_node_path7.basename)(f));
-    if (mdFiles.length === 0) {
-      logger.debug(`No markdown files found in rulesync commands directory: ${commandsDir}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} command files in ${commandsDir}`);
-    const rulesyncCommands = [];
-    for (const mdFile of mdFiles) {
-      const filepath = (0, import_node_path7.join)(commandsDir, mdFile);
-      try {
-        const rulesyncCommand = await RulesyncCommand.fromFilePath({
-          filePath: filepath
-        });
-        rulesyncCommands.push(rulesyncCommand);
-        logger.debug(`Successfully loaded command: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load command file ${filepath}:`, error);
-        continue;
-      }
-    }
-    if (rulesyncCommands.length === 0) {
-      logger.debug(`No valid commands found in ${commandsDir}`);
-      return [];
-    }
+    const rulesyncCommandPaths = await findFilesByGlobs((0, import_node_path8.join)(".rulesync", "commands", "*.md"));
+    const rulesyncCommands = (await Promise.allSettled(
+      rulesyncCommandPaths.map(
+        (path2) => RulesyncCommand.fromFile({ relativeFilePath: (0, import_node_path8.basename)(path2) })
+      )
+    )).filter((result) => result.status === "fulfilled").map((result) => result.value);
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
     return rulesyncCommands;
   }
@@ -913,122 +909,67 @@ var CommandsProcessor = class extends FeatureProcessor {
       case "claudecode":
         return await this.loadClaudecodeCommands();
       case "geminicli":
-        return await this.loadGeminiCliCommands();
+        return await this.loadGeminicliCommands();
       case "roo":
         return await this.loadRooCommands();
       default:
         throw new Error(`Unsupported tool target: ${this.toolTarget}`);
     }
   }
+  async loadToolCommandDefault({
+    toolTarget,
+    relativeDirPath,
+    extension
+  }) {
+    const commandFilePaths = await findFilesByGlobs(
+      (0, import_node_path8.join)(this.baseDir, relativeDirPath, `*.${extension}`)
+    );
+    const toolCommands = (await Promise.allSettled(
+      commandFilePaths.map((path2) => {
+        switch (toolTarget) {
+          case "claudecode":
+            return ClaudecodeCommand.fromFile({ relativeFilePath: (0, import_node_path8.basename)(path2) });
+          case "geminicli":
+            return GeminiCliCommand.fromFile({ relativeFilePath: (0, import_node_path8.basename)(path2) });
+          case "roo":
+            return RooCommand.fromFile({ relativeFilePath: (0, import_node_path8.basename)(path2) });
+          default:
+            throw new Error(`Unsupported tool target: ${toolTarget}`);
+        }
+      })
+    )).filter((result) => result.status === "fulfilled").map((result) => result.value);
+    logger.info(`Successfully loaded ${toolCommands.length} ${relativeDirPath} commands`);
+    return toolCommands;
+  }
   /**
    * Load Claude Code command configurations from .claude/commands/ directory
    */
   async loadClaudecodeCommands() {
-    const commandsDir = (0, import_node_path7.join)(this.baseDir, ".claude", "commands");
-    if (!await directoryExists(commandsDir)) {
-      logger.warn(`Claude Code commands directory not found: ${commandsDir}`);
-      return [];
-    }
-    const allMdFiles = await findFiles(commandsDir, ".md");
-    const mdFiles = allMdFiles.map((f) => (0, import_node_path7.basename)(f));
-    if (mdFiles.length === 0) {
-      logger.info(`No markdown command files found in ${commandsDir}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} Claude Code command files in ${commandsDir}`);
-    const toolCommands = [];
-    for (const mdFile of mdFiles) {
-      const filepath = (0, import_node_path7.join)(commandsDir, mdFile);
-      try {
-        const claudecodeCommand = await ClaudecodeCommand.fromFilePath({
-          baseDir: this.baseDir,
-          filePath: filepath
-        });
-        toolCommands.push(claudecodeCommand);
-        logger.debug(`Successfully loaded Claude Code command: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load Claude Code command file ${filepath}:`, error);
-        continue;
-      }
-    }
-    logger.info(`Successfully loaded ${toolCommands.length} Claude Code commands`);
-    return toolCommands;
+    return await this.loadToolCommandDefault({
+      toolTarget: "claudecode",
+      relativeDirPath: ".claude/commands",
+      extension: "md"
+    });
   }
   /**
    * Load Gemini CLI command configurations from .gemini/commands/ directory
    */
-  async loadGeminiCliCommands() {
-    const commandsDir = (0, import_node_path7.join)(this.baseDir, ".gemini", "commands");
-    if (!await directoryExists(commandsDir)) {
-      logger.warn(`Gemini CLI commands directory not found: ${commandsDir}`);
-      return [];
-    }
-    const allFiles = await listDirectoryFiles(commandsDir);
-    const tomlFiles = allFiles.filter((file) => file.endsWith(".toml"));
-    if (tomlFiles.length === 0) {
-      logger.info(`No TOML command files found in ${commandsDir}`);
-      return [];
-    }
-    logger.info(`Found ${tomlFiles.length} Gemini CLI command files in ${commandsDir}`);
-    const toolCommands = [];
-    for (const tomlFile of tomlFiles) {
-      const filepath = (0, import_node_path7.join)(commandsDir, tomlFile);
-      try {
-        const geminiCliCommand = await GeminiCliCommand.fromFilePath({
-          baseDir: this.baseDir,
-          filePath: filepath
-        });
-        toolCommands.push(geminiCliCommand);
-        logger.debug(`Successfully loaded Gemini CLI command: ${tomlFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load Gemini CLI command file ${filepath}:`, error);
-        continue;
-      }
-    }
-    logger.info(`Successfully loaded ${toolCommands.length} Gemini CLI commands`);
-    return toolCommands;
+  async loadGeminicliCommands() {
+    return await this.loadToolCommandDefault({
+      toolTarget: "geminicli",
+      relativeDirPath: ".gemini/commands",
+      extension: "md"
+    });
   }
   /**
    * Load Roo Code command configurations from .roo/commands/ directory
    */
   async loadRooCommands() {
-    const commandsDir = (0, import_node_path7.join)(this.baseDir, ".roo", "commands");
-    if (!await directoryExists(commandsDir)) {
-      logger.warn(`Roo Code commands directory not found: ${commandsDir}`);
-      return [];
-    }
-    const allMdFiles = await findFiles(commandsDir, ".md");
-    const mdFiles = allMdFiles.map((f) => (0, import_node_path7.basename)(f));
-    if (mdFiles.length === 0) {
-      logger.info(`No markdown command files found in ${commandsDir}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} Roo Code command files in ${commandsDir}`);
-    const toolCommands = [];
-    for (const mdFile of mdFiles) {
-      const filepath = (0, import_node_path7.join)(commandsDir, mdFile);
-      try {
-        const rooCommand = await RooCommand.fromFilePath({
-          baseDir: this.baseDir,
-          filePath: filepath
-        });
-        toolCommands.push(rooCommand);
-        logger.debug(`Successfully loaded Roo Code command: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load Roo Code command file ${filepath}:`, error);
-        continue;
-      }
-    }
-    logger.info(`Successfully loaded ${toolCommands.length} Roo Code commands`);
-    return toolCommands;
-  }
-  async writeToolCommandsFromRulesyncCommands(rulesyncCommands) {
-    const toolCommands = await this.convertRulesyncFilesToToolFiles(rulesyncCommands);
-    await this.writeAiFiles(toolCommands);
-  }
-  async writeRulesyncCommandsFromToolCommands(toolCommands) {
-    const rulesyncCommands = await this.convertToolFilesToRulesyncFiles(toolCommands);
-    await this.writeAiFiles(rulesyncCommands);
+    return await this.loadToolCommandDefault({
+      toolTarget: "roo",
+      relativeDirPath: ".roo/commands",
+      extension: "md"
+    });
   }
   /**
    * Implementation of abstract method from FeatureProcessor
@@ -1140,6 +1081,9 @@ var ConfigResolver = class {
 // src/ignore/ignore-processor.ts
 var import_mini9 = require("zod/mini");
 
+// src/ignore/augmentcode-ignore.ts
+var import_node_path9 = require("path");
+
 // src/types/tool-file.ts
 var ToolFile = class extends AiFile {
 };
@@ -1158,9 +1102,6 @@ var RulesyncIgnore = class _RulesyncIgnore extends RulesyncFile {
       fileContent
     });
   }
-  static async fromFilePath(_params) {
-    throw new Error("Please use the fromFile method instead.");
-  }
 };
 
 // src/ignore/tool-ignore.ts
@@ -1197,12 +1138,9 @@ var ToolIgnore = class extends ToolFile {
       fileContent: this.fileContent
     });
   }
-  static async fromFile() {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
-  static async fromFilePath(_params) {
-    throw new Error("Please use the fromFile method instead.");
-  }
 };
 
 // src/ignore/augmentcode-ignore.ts
@@ -1232,18 +1170,23 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
    * Create AugmentcodeIgnore from file path
    * Reads and parses .augmentignore file
    */
-  static async fromFile() {
-    const fileContent = await readFileContent(".augmentignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path9.join)(baseDir, ".augmentignore"));
     return new _AugmentcodeIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".augmentignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/cline-ignore.ts
+var import_node_path10 = require("path");
 var ClineIgnore = class _ClineIgnore extends ToolIgnore {
   /**
    * Convert ClineIgnore to RulesyncIgnore format
@@ -1269,18 +1212,23 @@ var ClineIgnore = class _ClineIgnore extends ToolIgnore {
   /**
    * Load ClineIgnore from .clineignore file
    */
-  static async fromFile() {
-    const fileContent = await readFileContent(".clineignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path10.join)(baseDir, ".clineignore"));
     return new _ClineIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".clineignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/codexcli-ignore.ts
+var import_node_path11 = require("path");
 var CodexcliIgnore = class _CodexcliIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1299,20 +1247,23 @@ var CodexcliIgnore = class _CodexcliIgnore extends ToolIgnore {
       // Skip validation to allow empty patterns
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".codexignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path11.join)(baseDir, ".codexignore"));
     return new _CodexcliIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".codexignore",
       fileContent,
-      validate: true
-      // Skip validation to allow empty patterns
+      validate
     });
   }
 };
 
 // src/ignore/cursor-ignore.ts
+var import_node_path12 = require("path");
 var CursorIgnore = class _CursorIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return new RulesyncIgnore({
@@ -1334,18 +1285,23 @@ var CursorIgnore = class _CursorIgnore extends ToolIgnore {
       fileContent: body
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".cursorignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path12.join)(baseDir, ".cursorignore"));
     return new _CursorIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".cursorignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/geminicli-ignore.ts
+var import_node_path13 = require("path");
 var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1361,18 +1317,23 @@ var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".aiexclude");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path13.join)(baseDir, ".aiexclude"));
     return new _GeminiCliIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".aiexclude",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/junie-ignore.ts
+var import_node_path14 = require("path");
 var JunieIgnore = class _JunieIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1388,18 +1349,23 @@ var JunieIgnore = class _JunieIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".junieignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path14.join)(baseDir, ".junieignore"));
     return new _JunieIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".junieignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/kiro-ignore.ts
+var import_node_path15 = require("path");
 var KiroIgnore = class _KiroIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1415,18 +1381,23 @@ var KiroIgnore = class _KiroIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".aiignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path15.join)(baseDir, ".aiignore"));
     return new _KiroIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".aiignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/qwencode-ignore.ts
+var import_node_path16 = require("path");
 var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1442,18 +1413,23 @@ var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".geminiignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path16.join)(baseDir, ".geminiignore"));
     return new _QwencodeIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".geminiignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/roo-ignore.ts
+var import_node_path17 = require("path");
 var RooIgnore = class _RooIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1469,18 +1445,23 @@ var RooIgnore = class _RooIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
-  static async fromFile() {
-    const fileContent = await readFileContent(".rooignore");
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path17.join)(baseDir, ".rooignore"));
     return new _RooIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".rooignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/windsurf-ignore.ts
+var import_node_path18 = require("path");
 var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1496,6 +1477,19 @@ var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path18.join)(baseDir, ".codeiumignore"));
+    return new _WindsurfIgnore({
+      baseDir,
+      relativeDirPath: ".",
+      relativeFilePath: ".codeiumignore",
+      fileContent,
+      validate
+    });
+  }
 };
 
 // src/ignore/ignore-processor.ts
@@ -1553,25 +1547,25 @@ var IgnoreProcessor = class extends FeatureProcessor {
   async loadToolIgnores() {
     switch (this.toolTarget) {
       case "augmentcode":
-        return [await AugmentcodeIgnore.fromFile()];
+        return [await AugmentcodeIgnore.fromFile({ baseDir: this.baseDir })];
       case "cline":
-        return [await ClineIgnore.fromFile()];
+        return [await ClineIgnore.fromFile({ baseDir: this.baseDir })];
       case "codexcli":
-        return [await CodexcliIgnore.fromFile()];
+        return [await CodexcliIgnore.fromFile({ baseDir: this.baseDir })];
       case "cursor":
-        return [await CursorIgnore.fromFile()];
+        return [await CursorIgnore.fromFile({ baseDir: this.baseDir })];
       case "geminicli":
-        return [await GeminiCliIgnore.fromFile()];
+        return [await GeminiCliIgnore.fromFile({ baseDir: this.baseDir })];
       case "junie":
-        return [await JunieIgnore.fromFile()];
+        return [await JunieIgnore.fromFile({ baseDir: this.baseDir })];
       case "kiro":
-        return [await KiroIgnore.fromFile()];
+        return [await KiroIgnore.fromFile({ baseDir: this.baseDir })];
       case "qwencode":
-        return [await QwencodeIgnore.fromFile()];
+        return [await QwencodeIgnore.fromFile({ baseDir: this.baseDir })];
       case "roo":
-        return [await RooIgnore.fromFile()];
+        return [await RooIgnore.fromFile({ baseDir: this.baseDir })];
       case "windsurf":
-        return [await WindsurfIgnore.fromFile()];
+        return [await WindsurfIgnore.fromFile({ baseDir: this.baseDir })];
       default:
         throw new Error(`Unsupported tool target: ${this.toolTarget}`);
     }
@@ -1666,9 +1660,14 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-var import_node_path8 = require("path");
 var import_mini11 = require("zod/mini");
 
+// src/mcp/amazonqcli-mcp.ts
+var import_node_path20 = require("path");
+
+// src/mcp/rulesync-mcp.ts
+var import_node_path19 = require("path");
+
 // src/types/mcp.ts
 var import_mini10 = require("zod/mini");
 var McpTransportTypeSchema = import_mini10.z.enum(["stdio", "sse", "http"]);
@@ -1717,14 +1716,14 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   validate() {
     return { success: true, error: null };
   }
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({ validate = true }) {
+    const fileContent = await readFileContent((0, import_node_path19.join)(RULESYNC_DIR, ".mcp.json"));
     return new _RulesyncMcp({
       baseDir: ".",
-      relativeDirPath: ".rulesync",
+      relativeDirPath: RULESYNC_DIR,
       relativeFilePath: ".mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   getJson() {
@@ -1760,7 +1759,7 @@ var ToolMcp = class extends ToolFile {
       fileContent: this.fileContent
     });
   }
-  static async fromFilePath(_params) {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   static fromRulesyncMcp(_params) {
@@ -1770,14 +1769,17 @@ var ToolMcp = class extends ToolFile {
 
 // src/mcp/amazonqcli-mcp.ts
 var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path20.join)(baseDir, ".amazonq/mcp.json"));
     return new _AmazonqcliMcp({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".amazonq",
-      relativeFilePath: ".mcp.json",
+      relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1802,15 +1804,19 @@ var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
 };
 
 // src/mcp/claudecode-mcp.ts
+var import_node_path21 = require("path");
 var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path21.join)(baseDir, ".mcp.json"));
     return new _ClaudecodeMcp({
       baseDir: ".",
       relativeDirPath: ".",
       relativeFilePath: ".mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1835,15 +1841,19 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
 };
 
 // src/mcp/cline-mcp.ts
+var import_node_path22 = require("path");
 var ClineMcp = class _ClineMcp extends ToolMcp {
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path22.join)(baseDir, ".cline/mcp.json"));
     return new _ClineMcp({
       baseDir: ".",
       relativeDirPath: ".cline",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1868,15 +1878,19 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
 };
 
 // src/mcp/copilot-mcp.ts
+var import_node_path23 = require("path");
 var CopilotMcp = class _CopilotMcp extends ToolMcp {
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFilePath({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path23.join)(baseDir, ".vscode/mcp.json"));
     return new _CopilotMcp({
       baseDir: ".",
       relativeDirPath: ".vscode",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1901,15 +1915,19 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
 };
 
 // src/mcp/cursor-mcp.ts
+var import_node_path24 = require("path");
 var CursorMcp = class _CursorMcp extends ToolMcp {
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path24.join)(baseDir, ".cursor/mcp.json"));
     return new _CursorMcp({
       baseDir: ".",
       relativeDirPath: ".cursor",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1945,15 +1963,19 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
 };
 
 // src/mcp/roo-mcp.ts
+var import_node_path25 = require("path");
 var RooMcp = class _RooMcp extends ToolMcp {
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path25.join)(baseDir, ".roo/mcp.json"));
     return new _RooMcp({
       baseDir: ".",
       relativeDirPath: ".roo",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -2003,9 +2025,7 @@ var McpProcessor = class extends FeatureProcessor {
    */
   async loadRulesyncFiles() {
     try {
-      return [
-        await RulesyncMcp.fromFilePath({ filePath: (0, import_node_path8.join)(this.baseDir, ".rulesync", ".mcp.json") })
-      ];
+      return [await RulesyncMcp.fromFile({})];
     } catch (error) {
       logger.debug(`No MCP files found for tool target: ${this.toolTarget}`, error);
       return [];
@@ -2017,42 +2037,62 @@ var McpProcessor = class extends FeatureProcessor {
    */
   async loadToolFiles() {
     try {
-      switch (this.toolTarget) {
-        case "amazonqcli": {
-          return [
-            await AmazonqcliMcp.fromFilePath({
-              filePath: (0, import_node_path8.join)(this.baseDir, ".amazonq", "mcp.json")
-            })
-          ];
-        }
-        case "claudecode": {
-          return [
-            await ClaudecodeMcp.fromFilePath({
-              filePath: (0, import_node_path8.join)(this.baseDir, ".mcp.json")
-            })
-          ];
-        }
-        case "cline": {
-          return [
-            await ClineMcp.fromFilePath({ filePath: (0, import_node_path8.join)(this.baseDir, ".cline", "mcp.json") })
-          ];
-        }
-        case "copilot": {
-          return [
-            await CopilotMcp.fromFilePath({ filePath: (0, import_node_path8.join)(this.baseDir, ".vscode", "mcp.json") })
-          ];
-        }
-        case "cursor": {
-          return [
-            await CursorMcp.fromFilePath({ filePath: (0, import_node_path8.join)(this.baseDir, ".cursor", "mcp.json") })
-          ];
-        }
-        case "roo": {
-          return [await RooMcp.fromFilePath({ filePath: (0, import_node_path8.join)(this.baseDir, ".roo", "mcp.json") })];
+      const toolMcps = await (async () => {
+        switch (this.toolTarget) {
+          case "amazonqcli": {
+            return [
+              await AmazonqcliMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
+          case "claudecode": {
+            return [
+              await ClaudecodeMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
+          case "cline": {
+            return [
+              await ClineMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
+          case "copilot": {
+            return [
+              await CopilotMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
+          case "cursor": {
+            return [
+              await CursorMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
+          case "roo": {
+            return [
+              await RooMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
+          default:
+            throw new Error(`Unsupported tool target: ${this.toolTarget}`);
         }
-        default:
-          throw new Error(`Unsupported tool target: ${this.toolTarget}`);
-      }
+      })();
+      logger.info(`Successfully loaded ${toolMcps.length} ${this.toolTarget} MCP files`);
+      return toolMcps;
     } catch (error) {
       logger.debug(`No MCP files found for tool target: ${this.toolTarget}`, error);
       return [];
@@ -2128,21 +2168,15 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/rules/rules-processor.ts
-var import_node_path12 = require("path");
+var import_node_path44 = require("path");
 var import_fast_xml_parser = require("fast-xml-parser");
 var import_mini16 = require("zod/mini");
 
-// src/constants/paths.ts
-var import_node_path9 = require("path");
-var RULESYNC_DIR = ".rulesync";
-var RULESYNC_RULES_DIR = (0, import_node_path9.join)(".rulesync", "rules");
-var RULESYNC_RULES_DIR_LEGACY = ".rulesync";
-var RULESYNC_MCP_FILE = (0, import_node_path9.join)(".rulesync", ".mcp.json");
-var RULESYNC_COMMANDS_DIR = (0, import_node_path9.join)(".rulesync", "commands");
-var RULESYNC_SUBAGENTS_DIR = (0, import_node_path9.join)(".rulesync", "subagents");
+// src/rules/agentsmd-rule.ts
+var import_node_path27 = require("path");
 
 // src/rules/rulesync-rule.ts
-var import_node_path10 = require("path");
+var import_node_path26 = require("path");
 var import_mini12 = require("zod/mini");
 var RulesyncRuleFrontmatterSchema = import_mini12.z.object({
   root: import_mini12.z.optional(import_mini12.z.optional(import_mini12.z.boolean())),
@@ -2188,10 +2222,11 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       return { success: false, error: result.error };
     }
   }
-  static async fromLegacyFile({
-    relativeFilePath
+  static async fromFileLegacy({
+    relativeFilePath,
+    validate = true
   }) {
-    const filePath = (0, import_node_path10.join)(RULESYNC_RULES_DIR_LEGACY, relativeFilePath);
+    const filePath = (0, import_node_path26.join)(RULESYNC_RULES_DIR_LEGACY, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
@@ -2205,16 +2240,21 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       globs: result.data.globs ?? [],
       cursor: result.data.cursor
     };
-    const filename = (0, import_node_path10.basename)(filePath);
+    const filename = (0, import_node_path26.basename)(filePath);
     return new _RulesyncRule({
       baseDir: ".",
       relativeDirPath: RULESYNC_RULES_DIR,
       relativeFilePath: filename,
       frontmatter: validatedFrontmatter,
-      body: content.trim()
+      body: content.trim(),
+      validate
     });
   }
-  static async fromFilePath({ filePath }) {
+  static async fromFile({
+    relativeFilePath,
+    validate = true
+  }) {
+    const filePath = (0, import_node_path26.join)(RULESYNC_RULES_DIR, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
@@ -2228,13 +2268,14 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       globs: result.data.globs ?? [],
       cursor: result.data.cursor
     };
-    const filename = (0, import_node_path10.basename)(filePath);
+    const filename = (0, import_node_path26.basename)(filePath);
     return new _RulesyncRule({
       baseDir: ".",
       relativeDirPath: RULESYNC_RULES_DIR,
       relativeFilePath: filename,
       frontmatter: validatedFrontmatter,
-      body: content.trim()
+      body: content.trim(),
+      validate
     });
   }
   getBody() {
@@ -2249,7 +2290,7 @@ var ToolRule = class extends ToolFile {
     super(rest);
     this.root = root;
   }
-  static async fromFilePath(_params) {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   static fromRulesyncRule(_params) {
@@ -2300,19 +2341,18 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
       root: root ?? false
     });
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
     const isRoot = relativeFilePath === "AGENTS.md";
+    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path27.join)(".agents/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path27.join)(baseDir, relativePath));
     return new _AgentsMdRule({
       baseDir,
-      relativeDirPath,
-      relativeFilePath,
+      relativeDirPath: isRoot ? "." : ".agents/memories",
+      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
       fileContent,
       validate,
       root: isRoot
@@ -2340,15 +2380,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 };
 
 // src/rules/amazonqcli-rule.ts
+var import_node_path28 = require("path");
 var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path28.join)(baseDir, ".amazonq/rules", relativeFilePath));
     return new _AmazonQCliRule({
-      baseDir: params.baseDir || ".",
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: ".amazonq/rules",
+      relativeFilePath,
       fileContent,
-      validate: params.validate ?? false,
+      validate,
       root: false
     });
   }
@@ -2375,6 +2420,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 };
 
 // src/rules/augmentcode-legacy-rule.ts
+var import_node_path29 = require("path");
 var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   toRulesyncRule() {
     const rulesyncFrontmatter = {
@@ -2410,19 +2456,18 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
     const isRoot = relativeFilePath === ".augment-guidelines";
+    const relativePath = isRoot ? ".augment-guidelines" : (0, import_node_path29.join)(".augment/rules", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path29.join)(baseDir, relativePath));
     return new _AugmentcodeLegacyRule({
       baseDir,
-      relativeDirPath,
-      relativeFilePath,
+      relativeDirPath: isRoot ? "." : ".augment/rules",
+      relativeFilePath: isRoot ? ".augment-guidelines" : relativeFilePath,
       fileContent,
       validate,
       root: isRoot
@@ -2431,6 +2476,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
 };
 
 // src/rules/augmentcode-rule.ts
+var import_node_path30 = require("path");
 var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -2449,18 +2495,16 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
       })
     );
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
+    const fileContent = await readFileContent((0, import_node_path30.join)(baseDir, ".augment/rules", relativeFilePath));
     const { body: content } = parseFrontmatter(fileContent);
     return new _AugmentcodeRule({
       baseDir,
-      relativeDirPath,
+      relativeDirPath: ".augment/rules",
       relativeFilePath,
       fileContent: content.trim(),
       validate
@@ -2472,16 +2516,23 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
 };
 
 // src/rules/claudecode-rule.ts
+var import_node_path31 = require("path");
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "CLAUDE.md";
+    const relativePath = isRoot ? "CLAUDE.md" : (0, import_node_path31.join)(".claude/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path31.join)(baseDir, relativePath));
     return new _ClaudecodeRule({
-      baseDir: params.baseDir || process.cwd(),
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: isRoot ? "." : ".claude/memories",
+      relativeFilePath: isRoot ? "CLAUDE.md" : relativeFilePath,
       fileContent,
-      validate: params.validate ?? true,
-      root: params.relativeFilePath === "CLAUDE.md"
+      validate,
+      root: isRoot
     });
   }
   static fromRulesyncRule({
@@ -2508,6 +2559,7 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 };
 
 // src/rules/cline-rule.ts
+var import_node_path32 = require("path");
 var import_mini13 = require("zod/mini");
 var ClineRuleFrontmatterSchema = import_mini13.z.object({
   description: import_mini13.z.string()
@@ -2533,17 +2585,15 @@ var ClineRule = class _ClineRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
+    const fileContent = await readFileContent((0, import_node_path32.join)(baseDir, ".clinerules", relativeFilePath));
     return new _ClineRule({
       baseDir,
-      relativeDirPath,
+      relativeDirPath: ".clinerules",
       relativeFilePath,
       fileContent,
       validate
@@ -2552,16 +2602,23 @@ var ClineRule = class _ClineRule extends ToolRule {
 };
 
 // src/rules/codexcli-rule.ts
+var import_node_path33 = require("path");
 var CodexcliRule = class _CodexcliRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "AGENTS.md";
+    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path33.join)(".codex/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path33.join)(baseDir, relativePath));
     return new _CodexcliRule({
-      baseDir: params.baseDir || process.cwd(),
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: isRoot ? "." : ".codex/memories",
+      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
       fileContent,
-      validate: params.validate ?? true,
-      root: params.relativeFilePath === "AGENTS.md"
+      validate,
+      root: isRoot
     });
   }
   static fromRulesyncRule({
@@ -2588,6 +2645,7 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 };
 
 // src/rules/copilot-rule.ts
+var import_node_path34 = require("path");
 var import_mini14 = require("zod/mini");
 var CopilotRuleFrontmatterSchema = import_mini14.z.object({
   description: import_mini14.z.optional(import_mini14.z.string()),
@@ -2662,45 +2720,43 @@ var CopilotRule = class _CopilotRule extends ToolRule {
       root
     });
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
-    const root = relativeFilePath === "copilot-instructions.md";
-    if (root) {
+    const isRoot = relativeFilePath === "copilot-instructions.md";
+    const relativePath = isRoot ? "copilot-instructions.md" : (0, import_node_path34.join)(".github/instructions", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path34.join)(baseDir, relativePath));
+    if (isRoot) {
       return new _CopilotRule({
         baseDir,
-        relativeDirPath,
-        relativeFilePath,
+        relativeDirPath: ".github",
+        relativeFilePath: isRoot ? "copilot-instructions.md" : relativeFilePath,
         frontmatter: {
           description: "",
           applyTo: "**"
         },
         body: fileContent.trim(),
         validate,
-        root
+        root: isRoot
       });
     }
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(
+        `Invalid frontmatter in ${(0, import_node_path34.join)(baseDir, relativeFilePath)}: ${result.error.message}`
+      );
     }
     return new _CopilotRule({
       baseDir,
-      relativeDirPath,
-      relativeFilePath,
-      frontmatter: {
-        ...result.data,
-        applyTo: result.data.applyTo || "**"
-      },
+      relativeDirPath: ".github/instructions",
+      relativeFilePath: relativeFilePath.replace(/\.md$/, ".instructions.md"),
+      frontmatter: result.data,
       body: content.trim(),
       validate,
-      root
+      root: isRoot
     });
   }
   validate() {
@@ -2723,7 +2779,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 };
 
 // src/rules/cursor-rule.ts
-var import_node_path11 = require("path");
+var import_node_path35 = require("path");
 var import_mini15 = require("zod/mini");
 var CursorRuleFrontmatterSchema = import_mini15.z.object({
   description: import_mini15.z.optional(import_mini15.z.string()),
@@ -2742,11 +2798,49 @@ var CursorRule = class _CursorRule extends ToolRule {
     }
     super({
       ...rest,
-      fileContent: stringifyFrontmatter(body, frontmatter)
+      fileContent: _CursorRule.stringifyCursorFrontmatter(body, frontmatter)
     });
     this.frontmatter = frontmatter;
     this.body = body;
   }
+  /**
+   * Custom stringify function for Cursor MDC files
+   * MDC files don't support quotes in YAML, so globs patterns must be output without quotes
+   */
+  static stringifyCursorFrontmatter(body, frontmatter) {
+    if (!frontmatter.globs || typeof frontmatter.globs !== "string" || !frontmatter.globs.includes("*")) {
+      return stringifyFrontmatter(body, frontmatter);
+    }
+    const lines = ["---"];
+    if (frontmatter.alwaysApply !== void 0) {
+      lines.push(`alwaysApply: ${frontmatter.alwaysApply}`);
+    }
+    if (frontmatter.description !== void 0) {
+      lines.push(`description: ${frontmatter.description}`);
+    }
+    if (frontmatter.globs !== void 0) {
+      lines.push(`globs: ${frontmatter.globs}`);
+    }
+    lines.push("---");
+    lines.push("");
+    if (body) {
+      lines.push(body);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Custom parse function for Cursor MDC files
+   * MDC files don't support quotes in YAML, so we need to handle patterns like *.ts specially
+   */
+  static parseCursorFrontmatter(fileContent) {
+    const preprocessedContent = fileContent.replace(
+      /^globs:\s*(\*[^\n]*?)$/m,
+      (_match, globPattern) => {
+        return `globs: "${globPattern}"`;
+      }
+    );
+    return parseFrontmatter(preprocessedContent);
+  }
   toRulesyncRule() {
     const targets = ["*"];
     const isAlways = this.frontmatter.alwaysApply === true;
@@ -2763,13 +2857,18 @@ var CursorRule = class _CursorRule extends ToolRule {
       targets,
       root: false,
       description: this.frontmatter.description,
-      globs
+      globs,
+      cursor: {
+        alwaysApply: this.frontmatter.alwaysApply,
+        description: this.frontmatter.description,
+        globs: globs.length > 0 ? globs : void 0
+      }
     };
     return new RulesyncRule({
       frontmatter: rulesyncFrontmatter,
       body: this.body,
       relativeDirPath: ".rulesync/rules",
-      relativeFilePath: this.relativeFilePath,
+      relativeFilePath: this.relativeFilePath.replace(/\.mdc$/, ".md"),
       validate: true
     });
   }
@@ -2797,20 +2896,23 @@ var CursorRule = class _CursorRule extends ToolRule {
       validate
     });
   }
-  static async fromFilePath({
-    filePath,
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const fileContent = await readFileContent((0, import_node_path35.join)(baseDir, ".cursor/rules", relativeFilePath));
+    const { frontmatter, body: content } = _CursorRule.parseCursorFrontmatter(fileContent);
     const result = CursorRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(
+        `Invalid frontmatter in ${(0, import_node_path35.join)(baseDir, relativeFilePath)}: ${result.error.message}`
+      );
     }
     return new _CursorRule({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".cursor/rules",
-      relativeFilePath: (0, import_node_path11.basename)(filePath),
+      relativeFilePath: (0, import_node_path35.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -2836,16 +2938,23 @@ var CursorRule = class _CursorRule extends ToolRule {
 };
 
 // src/rules/geminicli-rule.ts
+var import_node_path36 = require("path");
 var GeminiCliRule = class _GeminiCliRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "GEMINI.md";
+    const relativePath = isRoot ? "GEMINI.md" : (0, import_node_path36.join)(".gemini/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path36.join)(baseDir, relativePath));
     return new _GeminiCliRule({
-      baseDir: params.baseDir || process.cwd(),
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: isRoot ? "." : ".gemini/memories",
+      relativeFilePath: isRoot ? "GEMINI.md" : relativeFilePath,
       fileContent,
-      validate: params.validate ?? true,
-      root: params.relativeFilePath === "GEMINI.md"
+      validate,
+      root: isRoot
     });
   }
   static fromRulesyncRule({
@@ -2872,15 +2981,22 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
 };
 
 // src/rules/junie-rule.ts
+var import_node_path37 = require("path");
 var JunieRule = class _JunieRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "guidelines.md";
+    const relativePath = isRoot ? "guidelines.md" : (0, import_node_path37.join)(".junie/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path37.join)(baseDir, relativePath));
     return new _JunieRule({
-      baseDir: params.baseDir || ".",
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: isRoot ? ".junie" : ".junie/memories",
+      relativeFilePath: isRoot ? "guidelines.md" : relativeFilePath,
       fileContent,
-      validate: params.validate ?? true
+      validate
     });
   }
   static fromRulesyncRule({
@@ -2893,8 +3009,8 @@ var JunieRule = class _JunieRule extends ToolRule {
         baseDir,
         rulesyncRule,
         validate,
-        rootPath: { relativeDirPath: ".", relativeFilePath: "guidelines.md" },
-        nonRootPath: { relativeDirPath: ".junie/guidelines" }
+        rootPath: { relativeDirPath: ".junie", relativeFilePath: "guidelines.md" },
+        nonRootPath: { relativeDirPath: ".junie/memories" }
       })
     );
   }
@@ -2907,15 +3023,20 @@ var JunieRule = class _JunieRule extends ToolRule {
 };
 
 // src/rules/kiro-rule.ts
+var import_node_path38 = require("path");
 var KiroRule = class _KiroRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path38.join)(baseDir, ".kiro/steering", relativeFilePath));
     return new _KiroRule({
-      baseDir: params.baseDir || ".",
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: ".kiro/steering",
+      relativeFilePath,
       fileContent,
-      validate: params.validate ?? true,
+      validate,
       root: false
     });
   }
@@ -2942,21 +3063,22 @@ var KiroRule = class _KiroRule extends ToolRule {
 };
 
 // src/rules/opencode-rule.ts
+var import_node_path39 = require("path");
 var OpenCodeRule = class _OpenCodeRule extends ToolRule {
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
+    const isRoot = relativeFilePath === "AGENTS.md";
+    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path39.join)(".opencode/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path39.join)(baseDir, relativePath));
     return new _OpenCodeRule({
       baseDir,
-      relativeDirPath,
-      relativeFilePath,
+      relativeDirPath: isRoot ? "." : ".opencode/memories",
+      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
       validate,
-      root: relativeFilePath === "AGENTS.md",
+      root: isRoot,
       fileContent
     });
   }
@@ -2982,16 +3104,23 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
 };
 
 // src/rules/qwencode-rule.ts
+var import_node_path40 = require("path");
 var QwencodeRule = class _QwencodeRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "QWEN.md";
+    const relativePath = isRoot ? "QWEN.md" : (0, import_node_path40.join)(".qwencode/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path40.join)(baseDir, relativePath));
     return new _QwencodeRule({
-      baseDir: params.baseDir || process.cwd(),
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: isRoot ? "." : ".qwencode/memories",
+      relativeFilePath: isRoot ? "QWEN.md" : relativeFilePath,
       fileContent,
-      validate: params.validate ?? true,
-      root: params.relativeFilePath === "QWEN.md"
+      validate,
+      root: isRoot
     });
   }
   static fromRulesyncRule(params) {
@@ -3012,15 +3141,21 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
 };
 
 // src/rules/roo-rule.ts
+var import_node_path41 = require("path");
 var RooRule = class _RooRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path41.join)(baseDir, ".roo/rules", relativeFilePath));
     return new _RooRule({
-      baseDir: params.baseDir || ".",
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
+      baseDir,
+      relativeDirPath: ".roo/rules",
+      relativeFilePath,
       fileContent,
-      validate: params.validate ?? true
+      validate,
+      root: false
     });
   }
   static fromRulesyncRule({
@@ -3060,15 +3195,71 @@ var RooRule = class _RooRule extends ToolRule {
   }
 };
 
+// src/rules/warp-rule.ts
+var import_node_path42 = require("path");
+var WarpRule = class _WarpRule extends ToolRule {
+  constructor({ fileContent, root, ...rest }) {
+    super({
+      ...rest,
+      fileContent,
+      root: root ?? false
+    });
+  }
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "WARP.md";
+    const relativePath = isRoot ? "WARP.md" : (0, import_node_path42.join)(".warp/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path42.join)(baseDir, relativePath));
+    return new _WarpRule({
+      baseDir,
+      relativeDirPath: isRoot ? "." : ".warp",
+      relativeFilePath: isRoot ? "WARP.md" : relativeFilePath,
+      fileContent,
+      validate,
+      root: isRoot
+    });
+  }
+  static fromRulesyncRule({
+    baseDir = ".",
+    rulesyncRule,
+    validate = true
+  }) {
+    return new _WarpRule(
+      this.buildToolRuleParamsDefault({
+        baseDir,
+        rulesyncRule,
+        validate,
+        rootPath: { relativeDirPath: ".", relativeFilePath: "WARP.md" },
+        nonRootPath: { relativeDirPath: ".warp/memories" }
+      })
+    );
+  }
+  toRulesyncRule() {
+    return this.toRulesyncRuleDefault();
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+};
+
 // src/rules/windsurf-rule.ts
+var import_node_path43 = require("path");
 var WindsurfRule = class _WindsurfRule extends ToolRule {
-  static async fromFilePath(params) {
-    const fileContent = await readFileContent(params.filePath);
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const fileContent = await readFileContent((0, import_node_path43.join)(baseDir, ".windsurf/rules", relativeFilePath));
     return new _WindsurfRule({
-      baseDir: params.baseDir || ".",
-      relativeDirPath: params.relativeDirPath,
-      relativeFilePath: params.relativeFilePath,
-      fileContent
+      baseDir,
+      relativeDirPath: ".windsurf/rules",
+      relativeFilePath,
+      fileContent,
+      validate
     });
   }
   static fromRulesyncRule({
@@ -3110,6 +3301,7 @@ var rulesProcessorToolTargets = [
   "opencode",
   "qwencode",
   "roo",
+  "warp",
   "windsurf"
 ];
 var RulesProcessorToolTargetSchema = import_mini16.z.enum(rulesProcessorToolTargets);
@@ -3218,6 +3410,12 @@ var RulesProcessor = class extends FeatureProcessor {
             rulesyncRule,
             validate: true
           });
+        case "warp":
+          return WarpRule.fromRulesyncRule({
+            baseDir: this.baseDir,
+            rulesyncRule,
+            validate: true
+          });
         case "windsurf":
           return WindsurfRule.fromRulesyncRule({
             baseDir: this.baseDir,
@@ -3296,6 +3494,13 @@ var RulesProcessor = class extends FeatureProcessor {
         );
         return toolRules;
       }
+      case "warp": {
+        const rootRule = toolRules[rootRuleIndex];
+        rootRule?.setFileContent(
+          this.generateXmlReferencesSection(toolRules) + rootRule.getFileContent()
+        );
+        return toolRules;
+      }
       default:
         return toolRules;
     }
@@ -3312,57 +3517,18 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    try {
-      const rulesDir = (0, import_node_path12.join)(this.baseDir, ".rulesync", "rules");
-      const dirExists = await directoryExists(rulesDir);
-      if (!dirExists) {
-        logger.debug(`Rulesync rules directory not found: ${rulesDir}`);
-        return [];
-      }
-      const entries = await listDirectoryFiles(rulesDir);
-      const mdFiles = entries.filter((file) => file.endsWith(".md"));
-      if (mdFiles.length === 0) {
-        logger.debug(`No markdown files found in rulesync rules directory: ${rulesDir}`);
-        return [];
-      }
-      logger.info(`Found ${mdFiles.length} rule files in ${rulesDir}`);
-      const rulesyncRules = [];
-      for (const mdFile of mdFiles) {
-        const filepath = (0, import_node_path12.join)(rulesDir, mdFile);
-        try {
-          const rulesyncRule = await RulesyncRule.fromFilePath({
-            filePath: filepath
-          });
-          rulesyncRules.push(rulesyncRule);
-          logger.debug(`Successfully loaded rule: ${mdFile}`);
-        } catch (error) {
-          logger.warn(`Failed to load rule file ${filepath}:`, error);
-          continue;
-        }
-      }
-      if (rulesyncRules.length === 0) {
-        logger.debug(`No valid rules found in ${rulesDir}`);
-        return [];
-      }
-      logger.info(`Successfully loaded ${rulesyncRules.length} rulesync rules`);
-      return rulesyncRules;
-    } catch (error) {
-      logger.debug(`No rulesync files found`, error);
-      return [];
-    }
+    const files = await findFilesByGlobs((0, import_node_path44.join)(RULESYNC_RULES_DIR, "*.md"));
+    logger.debug(`Found ${files.length} rulesync files`);
+    return Promise.all(
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: (0, import_node_path44.basename)(file) }))
+    );
   }
-  async loadLegacyRulesyncFiles() {
-    try {
-      const legacyFiles = await findFilesByGlobs((0, import_node_path12.join)(RULESYNC_RULES_DIR_LEGACY, "*.md"));
-      return Promise.all(
-        legacyFiles.map(
-          (file) => RulesyncRule.fromLegacyFile({ relativeFilePath: (0, import_node_path12.basename)(file) })
-        )
-      );
-    } catch (error) {
-      logger.debug(`No legacy rulesync files found`, error);
-      return [];
-    }
+  async loadRulesyncFilesLegacy() {
+    const legacyFiles = await findFilesByGlobs((0, import_node_path44.join)(RULESYNC_RULES_DIR_LEGACY, "*.md"));
+    logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
+    return Promise.all(
+      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: (0, import_node_path44.basename)(file) }))
+    );
   }
   /**
    * Implementation of abstract method from FeatureProcessor
@@ -3401,6 +3567,8 @@ var RulesProcessor = class extends FeatureProcessor {
           return await this.loadQwencodeRules();
         case "roo":
           return await this.loadRooRules();
+        case "warp":
+          return await this.loadWarpRules();
         case "windsurf":
           return await this.loadWindsurfRules();
         default:
@@ -3411,502 +3579,296 @@ var RulesProcessor = class extends FeatureProcessor {
       return [];
     }
   }
+  async loadToolRulesDefault({
+    root,
+    nonRoot
+  }) {
+    const rootToolRules = await (async () => {
+      if (!root) {
+        return [];
+      }
+      const rootFilePaths = await findFilesByGlobs(
+        (0, import_node_path44.join)(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
+      );
+      return await Promise.all(
+        rootFilePaths.map(
+          (filePath) => root.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: (0, import_node_path44.basename)(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
+    const nonRootToolRules = await (async () => {
+      if (!nonRoot) {
+        return [];
+      }
+      const nonRootFilePaths = await findFilesByGlobs(
+        (0, import_node_path44.join)(this.baseDir, nonRoot.relativeFilePath, `*.${nonRoot.extension}`)
+      );
+      return await Promise.all(
+        nonRootFilePaths.map(
+          (filePath) => nonRoot.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: (0, import_node_path44.basename)(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
+    return [...rootToolRules, ...nonRootToolRules];
+  }
   /**
    * Load AGENTS.md rule configuration
    */
   async loadAgentsmdRules() {
-    const agentsFile = (0, import_node_path12.join)(this.baseDir, "AGENTS.md");
-    if (!await fileExists(agentsFile)) {
-      logger.warn(`AGENTS.md file not found: ${agentsFile}`);
-      return [];
-    }
-    try {
-      const agentsmdRule = await AgentsMdRule.fromFilePath({
-        baseDir: this.baseDir,
+    return await this.loadToolRulesDefault({
+      root: {
         relativeDirPath: ".",
         relativeFilePath: "AGENTS.md",
-        filePath: agentsFile,
-        validate: true
-      });
-      logger.info(`Successfully loaded AGENTS.md rule`);
-      return [agentsmdRule];
-    } catch (error) {
-      logger.warn(`Failed to load AGENTS.md file ${agentsFile}:`, error);
-      return [];
-    }
+        fromFile: (params) => AgentsMdRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".agents/memories",
+        fromFile: (params) => AgentsMdRule.fromFile(params),
+        extension: "md"
+      }
+    });
+  }
+  async loadWarpRules() {
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: "WARP.md",
+        fromFile: (params) => WarpRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".warp/memories",
+        fromFile: (params) => WarpRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load Amazon Q Developer CLI rule configurations from .amazonq/rules/ directory
    */
   async loadAmazonqcliRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".amazonq", "rules"),
-      (filePath, relativeFilePath) => AmazonQCliRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".amazonq/rules",
-        relativeFilePath,
-        filePath,
-        validate: true
-      }),
-      "Amazon Q Developer CLI"
-    );
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".amazonq/rules",
+        fromFile: (params) => AmazonQCliRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load AugmentCode rule configurations from .augment/rules/ directory
    */
   async loadAugmentcodeRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".augment", "rules"),
-      (filePath, relativeFilePath) => AugmentcodeRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".augment/rules",
-        relativeFilePath,
-        filePath,
-        validate: true
-      }),
-      "AugmentCode"
-    );
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".augment/rules",
+        fromFile: (params) => AugmentcodeRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load AugmentCode legacy rule configuration from .augment-guidelines file and .augment/rules/ directory
    */
   async loadAugmentcodeLegacyRules() {
-    const toolRules = [];
-    const guidelinesFile = (0, import_node_path12.join)(this.baseDir, ".augment-guidelines");
-    if (await fileExists(guidelinesFile)) {
-      try {
-        const augmentcodeLegacyRule = await AugmentcodeLegacyRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: ".",
-          relativeFilePath: ".augment-guidelines",
-          filePath: guidelinesFile,
-          validate: true
-        });
-        toolRules.push(augmentcodeLegacyRule);
-        logger.info(`Successfully loaded AugmentCode legacy guidelines`);
-      } catch (error) {
-        logger.warn(`Failed to load AugmentCode legacy guidelines file ${guidelinesFile}:`, error);
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: ".augment-guidelines",
+        fromFile: (params) => AugmentcodeLegacyRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".augment/rules",
+        fromFile: (params) => AugmentcodeLegacyRule.fromFile(params),
+        extension: "md"
       }
-    }
-    const rulesDir = (0, import_node_path12.join)(this.baseDir, ".augment", "rules");
-    if (await directoryExists(rulesDir)) {
-      const dirRules = await this.loadToolRulesFromDirectory(
-        rulesDir,
-        (filePath, relativeFilePath) => AugmentcodeLegacyRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: (0, import_node_path12.join)(".augment", "rules"),
-          relativeFilePath,
-          filePath,
-          validate: true
-        }),
-        "AugmentCode Legacy"
-      );
-      toolRules.push(...dirRules);
-    }
-    return toolRules;
+    });
   }
   /**
    * Load Claude Code rule configuration from CLAUDE.md file
    */
   async loadClaudecodeRules() {
-    const claudeMemoriesDir = (0, import_node_path12.join)(this.baseDir, ".claude", "memories");
-    if (!await directoryExists(claudeMemoriesDir)) {
-      logger.debug(`Claude Code memories directory not found: ${claudeMemoriesDir}`);
-      const claudeFile = (0, import_node_path12.join)(this.baseDir, "CLAUDE.md");
-      if (!await fileExists(claudeFile)) {
-        logger.debug(`Claude Code memory file not found: ${claudeFile}`);
-        return [];
-      }
-      try {
-        const claudecodeRule = await ClaudecodeRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: ".",
-          relativeFilePath: "CLAUDE.md",
-          filePath: claudeFile,
-          validate: true
-        });
-        logger.info(`Successfully loaded Claude Code memory file`);
-        return [claudecodeRule];
-      } catch (error) {
-        logger.warn(`Failed to load Claude Code memory file ${claudeFile}:`, error);
-        return [];
-      }
-    }
-    const entries = await listDirectoryFiles(claudeMemoriesDir);
-    const mdFiles = entries.filter((file) => file.endsWith(".md"));
-    if (mdFiles.length === 0) {
-      logger.debug(
-        `No markdown files found in Claude Code memories directory: ${claudeMemoriesDir}`
-      );
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} Claude Code memory files in ${claudeMemoriesDir}`);
-    const toolRules = [];
-    for (const mdFile of mdFiles) {
-      const filePath = (0, import_node_path12.join)(claudeMemoriesDir, mdFile);
-      try {
-        const claudecodeRule = await ClaudecodeRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: (0, import_node_path12.join)(".claude", "memories"),
-          relativeFilePath: mdFile,
-          filePath,
-          validate: true
-        });
-        toolRules.push(claudecodeRule);
-        logger.debug(`Successfully loaded Claude Code memory file: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load Claude Code memory file ${filePath}:`, error);
-        continue;
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: "CLAUDE.md",
+        fromFile: (params) => ClaudecodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".claude/memories",
+        fromFile: (params) => ClaudecodeRule.fromFile(params),
+        extension: "md"
       }
-    }
-    logger.info(`Successfully loaded ${toolRules.length} Claude Code memory files`);
-    return toolRules;
+    });
   }
   /**
    * Load Cline rule configurations from .clinerules/ directory
    */
   async loadClineRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".clinerules"),
-      (filePath, relativeFilePath) => ClineRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".clinerules",
-        relativeFilePath,
-        filePath,
-        validate: true
-      }),
-      "Cline"
-    );
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".clinerules",
+        fromFile: (params) => ClineRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load OpenAI Codex CLI rule configuration from AGENTS.md and .codex/memories/*.md files
    */
   async loadCodexcliRules() {
-    const rules = [];
-    const agentsFile = (0, import_node_path12.join)(this.baseDir, "AGENTS.md");
-    if (await fileExists(agentsFile)) {
-      try {
-        const codexcliRule = await CodexcliRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: ".",
-          relativeFilePath: "AGENTS.md",
-          filePath: agentsFile,
-          validate: true
-        });
-        rules.push(codexcliRule);
-        logger.info(`Successfully loaded OpenAI Codex CLI agents file`);
-      } catch (error) {
-        logger.warn(`Failed to load OpenAI Codex CLI agents file ${agentsFile}:`, error);
-      }
-    }
-    const memoriesDir = (0, import_node_path12.join)(this.baseDir, ".codex", "memories");
-    if (await directoryExists(memoriesDir)) {
-      try {
-        const entries = await listDirectoryFiles(memoriesDir);
-        const mdFiles = entries.filter((file) => file.endsWith(".md"));
-        for (const mdFile of mdFiles) {
-          const filePath = (0, import_node_path12.join)(memoriesDir, mdFile);
-          try {
-            const codexcliRule = await CodexcliRule.fromFilePath({
-              baseDir: this.baseDir,
-              relativeDirPath: (0, import_node_path12.join)(".codex", "memories"),
-              relativeFilePath: mdFile,
-              filePath,
-              validate: true
-            });
-            rules.push(codexcliRule);
-          } catch (error) {
-            logger.warn(`Failed to load Codex CLI memories file ${filePath}:`, error);
-          }
-        }
-        if (mdFiles.length > 0) {
-          logger.info(`Successfully loaded ${mdFiles.length} OpenAI Codex CLI memory files`);
-        }
-      } catch (error) {
-        logger.warn(`Failed to read OpenAI Codex CLI memories directory ${memoriesDir}:`, error);
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: "AGENTS.md",
+        fromFile: (params) => CodexcliRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".codex/memories",
+        fromFile: (params) => CodexcliRule.fromFile(params),
+        extension: "md"
       }
-    }
-    if (rules.length === 0) {
-      logger.warn(`No OpenAI Codex CLI rule files found`);
-    }
-    return rules;
+    });
   }
   /**
    * Load GitHub Copilot rule configuration from .github/copilot-instructions.md file
    */
   async loadCopilotRules() {
-    const copilotFile = (0, import_node_path12.join)(this.baseDir, ".github", "copilot-instructions.md");
-    if (!await fileExists(copilotFile)) {
-      logger.warn(`GitHub Copilot instructions file not found: ${copilotFile}`);
-      return [];
-    }
-    try {
-      const copilotRule = await CopilotRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".github",
-        relativeFilePath: "copilot-instructions.md",
-        filePath: copilotFile,
-        validate: true
-      });
-      logger.info(`Successfully loaded GitHub Copilot instructions file`);
-      return [copilotRule];
-    } catch (error) {
-      logger.warn(`Failed to load GitHub Copilot instructions file ${copilotFile}:`, error);
-      return [];
-    }
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: ".github/copilot-instructions.md",
+        fromFile: (params) => CopilotRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".github/instructions",
+        fromFile: (params) => CopilotRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load Cursor rule configurations from .cursor/rules/ directory
    */
   async loadCursorRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".cursor", "rules"),
-      (filePath) => CursorRule.fromFilePath({
-        filePath,
-        validate: true
-      }),
-      "Cursor"
-    );
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".cursor/rules",
+        fromFile: (params) => CursorRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load Gemini CLI rule configuration from GEMINI.md file
    */
   async loadGeminicliRules() {
-    const geminiFile = (0, import_node_path12.join)(this.baseDir, "GEMINI.md");
-    if (!await fileExists(geminiFile)) {
-      logger.warn(`Gemini CLI memory file not found: ${geminiFile}`);
-      return [];
-    }
-    try {
-      const geminicliRule = await GeminiCliRule.fromFilePath({
-        baseDir: this.baseDir,
+    return await this.loadToolRulesDefault({
+      root: {
         relativeDirPath: ".",
         relativeFilePath: "GEMINI.md",
-        filePath: geminiFile,
-        validate: true
-      });
-      logger.info(`Successfully loaded Gemini CLI memory file`);
-      return [geminicliRule];
-    } catch (error) {
-      logger.warn(`Failed to load Gemini CLI memory file ${geminiFile}:`, error);
-      return [];
-    }
+        fromFile: (params) => GeminiCliRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".gemini/memories",
+        fromFile: (params) => GeminiCliRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load JetBrains Junie rule configuration from .junie/guidelines.md file
    */
   async loadJunieRules() {
-    const guidelinesFile = (0, import_node_path12.join)(this.baseDir, ".junie", "guidelines.md");
-    if (!await fileExists(guidelinesFile)) {
-      return [];
-    }
-    const junieRule = await JunieRule.fromFilePath({
-      baseDir: this.baseDir,
-      relativeDirPath: ".junie",
-      relativeFilePath: "guidelines.md",
-      filePath: guidelinesFile,
-      validate: true
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: ".junie/guidelines.md",
+        fromFile: (params) => JunieRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".junie/memories",
+        fromFile: (params) => JunieRule.fromFile(params),
+        extension: "md"
+      }
     });
-    logger.info(`Successfully loaded JetBrains Junie guidelines file`);
-    return [junieRule];
   }
   /**
    * Load Kiro rule configurations from .kiro/steering/ directory
    */
   async loadKiroRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".kiro", "steering"),
-      (filePath, relativeFilePath) => KiroRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".kiro/steering",
-        relativeFilePath,
-        filePath,
-        validate: true
-      }),
-      "Kiro"
-    );
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".kiro/steering",
+        fromFile: (params) => KiroRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load OpenCode rule configuration from AGENTS.md file and .opencode/memories/*.md files
    */
   async loadOpencodeRules() {
-    const rules = [];
-    const agentsFile = (0, import_node_path12.join)(this.baseDir, "AGENTS.md");
-    if (await fileExists(agentsFile)) {
-      try {
-        const opencodeRule = await OpenCodeRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: ".",
-          relativeFilePath: "AGENTS.md",
-          filePath: agentsFile,
-          validate: true
-        });
-        rules.push(opencodeRule);
-        logger.info(`Successfully loaded OpenCode agents file`);
-      } catch (error) {
-        logger.warn(`Failed to load OpenCode agents file ${agentsFile}:`, error);
-      }
-    }
-    const memoriesDir = (0, import_node_path12.join)(this.baseDir, ".opencode", "memories");
-    if (await directoryExists(memoriesDir)) {
-      try {
-        const entries = await listDirectoryFiles(memoriesDir);
-        const mdFiles = entries.filter((file) => file.endsWith(".md"));
-        for (const mdFile of mdFiles) {
-          const filePath = (0, import_node_path12.join)(memoriesDir, mdFile);
-          try {
-            const opencodeRule = await OpenCodeRule.fromFilePath({
-              baseDir: this.baseDir,
-              relativeDirPath: (0, import_node_path12.join)(".opencode", "memories"),
-              relativeFilePath: mdFile,
-              filePath,
-              validate: true
-            });
-            rules.push(opencodeRule);
-          } catch (error) {
-            logger.warn(`Failed to load OpenCode memories file ${filePath}:`, error);
-          }
-        }
-        if (mdFiles.length > 0) {
-          logger.info(`Successfully loaded ${mdFiles.length} OpenCode memory files`);
-        }
-      } catch (error) {
-        logger.warn(`Failed to read OpenCode memories directory ${memoriesDir}:`, error);
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: "AGENTS.md",
+        fromFile: (params) => OpenCodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".opencode/memories",
+        fromFile: (params) => OpenCodeRule.fromFile(params),
+        extension: "md"
       }
-    }
-    if (rules.length === 0) {
-      logger.warn(`No OpenCode rule files found`);
-    }
-    return rules;
+    });
   }
   /**
    * Load Qwen Code rule configuration from QWEN.md file and .qwen/memories/*.md files
    */
   async loadQwencodeRules() {
-    const rules = [];
-    const qwenFile = (0, import_node_path12.join)(this.baseDir, "QWEN.md");
-    if (await fileExists(qwenFile)) {
-      try {
-        const qwencodeRule = await QwencodeRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: ".",
-          relativeFilePath: "QWEN.md",
-          filePath: qwenFile,
-          validate: true
-        });
-        rules.push(qwencodeRule);
-        logger.info(`Successfully loaded Qwen Code memory file`);
-      } catch (error) {
-        logger.warn(`Failed to load Qwen Code memory file ${qwenFile}:`, error);
-      }
-    }
-    const memoriesDir = (0, import_node_path12.join)(this.baseDir, ".qwen", "memories");
-    if (await directoryExists(memoriesDir)) {
-      try {
-        const entries = await listDirectoryFiles(memoriesDir);
-        const mdFiles = entries.filter((file) => file.endsWith(".md"));
-        for (const mdFile of mdFiles) {
-          const filePath = (0, import_node_path12.join)(memoriesDir, mdFile);
-          try {
-            const qwencodeRule = await QwencodeRule.fromFilePath({
-              baseDir: this.baseDir,
-              relativeDirPath: (0, import_node_path12.join)(".qwen", "memories"),
-              relativeFilePath: mdFile,
-              filePath,
-              validate: true
-            });
-            rules.push(qwencodeRule);
-          } catch (error) {
-            logger.warn(`Failed to load Qwen Code memories file ${filePath}:`, error);
-          }
-        }
-        if (mdFiles.length > 0) {
-          logger.info(`Successfully loaded ${mdFiles.length} Qwen Code memory files`);
-        }
-      } catch (error) {
-        logger.warn(`Failed to read Qwen Code memories directory ${memoriesDir}:`, error);
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: "QWEN.md",
+        fromFile: (params) => QwencodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeFilePath: ".qwen/memories",
+        fromFile: (params) => QwencodeRule.fromFile(params),
+        extension: "md"
       }
-    }
-    if (rules.length === 0) {
-      logger.warn(`No Qwen Code rule files found`);
-    }
-    return rules;
+    });
   }
   /**
    * Load Roo Code rule configurations from .roo/rules/ directory
    */
   async loadRooRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".roo", "rules"),
-      (filePath, relativeFilePath) => RooRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".roo/rules",
-        relativeFilePath,
-        filePath,
-        validate: true
-      }),
-      "Roo Code"
-    );
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".roo/rules",
+        fromFile: (params) => RooRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Load Windsurf rule configurations from .windsurf/rules/ directory
    */
   async loadWindsurfRules() {
-    return this.loadToolRulesFromDirectory(
-      (0, import_node_path12.join)(this.baseDir, ".windsurf", "rules"),
-      (filePath, relativeFilePath) => WindsurfRule.fromFilePath({
-        baseDir: this.baseDir,
-        relativeDirPath: ".windsurf/rules",
-        relativeFilePath,
-        filePath,
-        validate: true
-      }),
-      "Windsurf"
-    );
-  }
-  /**
-   * Common helper method to load tool rules from a directory with parallel processing
-   */
-  async loadToolRulesFromDirectory(dirPath, ruleFactory, toolName) {
-    if (!await directoryExists(dirPath)) {
-      logger.warn(`${toolName} rules directory not found: ${dirPath}`);
-      return [];
-    }
-    const entries = await listDirectoryFiles(dirPath);
-    const mdFiles = entries.filter((file) => file.endsWith(".md") || file.endsWith(".mdc"));
-    if (mdFiles.length === 0) {
-      logger.info(`No rule files found in ${dirPath}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} ${toolName} rule files in ${dirPath}`);
-    const results = await Promise.allSettled(
-      mdFiles.map(async (mdFile) => {
-        const filepath = (0, import_node_path12.join)(dirPath, mdFile);
-        return {
-          rule: await ruleFactory(filepath, mdFile),
-          filename: mdFile
-        };
-      })
-    );
-    const toolRules = [];
-    for (const [index, result] of results.entries()) {
-      if (result.status === "fulfilled") {
-        toolRules.push(result.value.rule);
-        logger.debug(`Successfully loaded ${toolName} rule: ${result.value.filename}`);
-      } else {
-        logger.warn(`Failed to load ${toolName} rule file ${mdFiles[index]}:`, result.reason);
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeFilePath: ".windsurf/rules",
+        fromFile: (params) => WindsurfRule.fromFile(params),
+        extension: "md"
       }
-    }
-    logger.info(`Successfully loaded ${toolRules.length} ${toolName} rules`);
-    return toolRules;
-  }
-  async writeToolRulesFromRulesyncRules(rulesyncRules) {
-    const toolRules = await this.convertRulesyncFilesToToolFiles(rulesyncRules);
-    await this.writeAiFiles(toolRules);
-  }
-  async writeRulesyncRulesFromToolRules(toolRules) {
-    const rulesyncRules = await this.convertToolFilesToRulesyncFiles(toolRules);
-    await this.writeAiFiles(rulesyncRules);
+    });
   }
   /**
    * Implementation of abstract method from FeatureProcessor
@@ -3915,30 +3877,6 @@ var RulesProcessor = class extends FeatureProcessor {
   static getToolTargets() {
     return rulesProcessorToolTargets;
   }
-  /**
-   * Get all supported tools
-   */
-  static getSupportedTools() {
-    const allTools = [
-      "agentsmd",
-      "amazonqcli",
-      "augmentcode",
-      "augmentcode-legacy",
-      "claudecode",
-      "cline",
-      "codexcli",
-      "copilot",
-      "cursor",
-      "geminicli",
-      "junie",
-      "kiro",
-      "opencode",
-      "qwencode",
-      "roo",
-      "windsurf"
-    ];
-    return allTools;
-  }
   generateXmlReferencesSection(toolRules) {
     const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
     if (toolRulesWithoutRoot.length === 0) {
@@ -3999,14 +3937,15 @@ var RulesProcessor = class extends FeatureProcessor {
 };
 
 // src/subagents/subagents-processor.ts
-var import_node_path14 = require("path");
+var import_node_path47 = require("path");
 var import_mini19 = require("zod/mini");
 
 // src/subagents/claudecode-subagent.ts
+var import_node_path46 = require("path");
 var import_mini18 = require("zod/mini");
 
 // src/subagents/rulesync-subagent.ts
-var import_node_path13 = require("path");
+var import_node_path45 = require("path");
 var import_mini17 = require("zod/mini");
 var RulesyncSubagentModelSchema = import_mini17.z.enum(["opus", "sonnet", "haiku", "inherit"]);
 var RulesyncSubagentFrontmatterSchema = import_mini17.z.object({
@@ -4052,14 +3991,16 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       return { success: false, error: result.error };
     }
   }
-  static async fromFilePath({ filePath }) {
-    const fileContent = await readFileContent(filePath);
+  static async fromFile({
+    relativeFilePath
+  }) {
+    const fileContent = await readFileContent((0, import_node_path45.join)(RULESYNC_SUBAGENTS_DIR, relativeFilePath));
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
     }
-    const filename = (0, import_node_path13.basename)(filePath);
+    const filename = (0, import_node_path45.basename)(relativeFilePath);
     return new _RulesyncSubagent({
       baseDir: ".",
       relativeDirPath: ".rulesync/subagents",
@@ -4073,7 +4014,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 
 // src/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
-  static async fromFilePath(_params) {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   static fromRulesyncSubagent(_params) {
@@ -4134,7 +4075,6 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   static fromRulesyncSubagent({
     baseDir = ".",
     rulesyncSubagent,
-    relativeDirPath,
     validate = true
   }) {
     const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
@@ -4149,7 +4089,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       baseDir,
       frontmatter: claudecodeFrontmatter,
       body,
-      relativeDirPath,
+      relativeDirPath: ".claude/agents",
       relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
       fileContent,
       validate
@@ -4166,22 +4106,20 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       return { success: false, error: result.error };
     }
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    relativeDirPath,
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
+    const fileContent = await readFileContent((0, import_node_path46.join)(baseDir, ".claude/agents", relativeFilePath));
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
     }
     return new _ClaudecodeSubagent({
       baseDir,
-      relativeDirPath,
+      relativeDirPath: ".claude/agents",
       relativeFilePath,
       frontmatter: result.data,
       body: content.trim(),
@@ -4235,7 +4173,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Load and parse rulesync subagent files from .rulesync/subagents/ directory
    */
   async loadRulesyncFiles() {
-    const subagentsDir = (0, import_node_path14.join)(this.baseDir, ".rulesync", "subagents");
+    const subagentsDir = (0, import_node_path47.join)(this.baseDir, ".rulesync", "subagents");
     const dirExists = await directoryExists(subagentsDir);
     if (!dirExists) {
       logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
@@ -4250,10 +4188,11 @@ var SubagentsProcessor = class extends FeatureProcessor {
     logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
     const rulesyncSubagents = [];
     for (const mdFile of mdFiles) {
-      const filepath = (0, import_node_path14.join)(subagentsDir, mdFile);
+      const filepath = (0, import_node_path47.join)(subagentsDir, mdFile);
       try {
-        const rulesyncSubagent = await RulesyncSubagent.fromFilePath({
-          filePath: filepath
+        const rulesyncSubagent = await RulesyncSubagent.fromFile({
+          relativeFilePath: mdFile,
+          validate: true
         });
         rulesyncSubagents.push(rulesyncSubagent);
         logger.debug(`Successfully loaded subagent: ${mdFile}`);
@@ -4285,43 +4224,19 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Load Claude Code subagent configurations from .claude/agents/ directory
    */
   async loadClaudecodeSubagents() {
-    const agentsDir = (0, import_node_path14.join)(this.baseDir, ".claude", "agents");
-    if (!await directoryExists(agentsDir)) {
-      logger.warn(`Claude Code agents directory not found: ${agentsDir}`);
-      return [];
-    }
-    let entries;
-    try {
-      entries = await listDirectoryFiles(agentsDir);
-    } catch (error) {
-      logger.warn(`Failed to read Claude Code agents directory ${agentsDir}:`, error);
-      return [];
-    }
-    const mdFiles = entries.filter((file) => file.endsWith(".md"));
-    if (mdFiles.length === 0) {
-      logger.info(`No JSON agent files found in ${agentsDir}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} Claude Code agent files in ${agentsDir}`);
-    const toolSubagents = [];
-    for (const mdFile of mdFiles) {
-      const filepath = (0, import_node_path14.join)(agentsDir, mdFile);
-      try {
-        const claudecodeSubagent = await ClaudecodeSubagent.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: ".claude/agents",
-          relativeFilePath: mdFile,
-          filePath: filepath
-        });
-        toolSubagents.push(claudecodeSubagent);
-        logger.debug(`Successfully loaded Claude Code agent: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load Claude Code agent file ${filepath}:`, error);
-        continue;
-      }
-    }
-    logger.info(`Successfully loaded ${toolSubagents.length} Claude Code subagents`);
-    return toolSubagents;
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: ".claude/agents",
+      fromFile: (relativeFilePath) => ClaudecodeSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  async loadToolSubagentsDefault({
+    relativeDirPath,
+    fromFile
+  }) {
+    const paths = await findFilesByGlobs((0, import_node_path47.join)(this.baseDir, relativeDirPath, "*.md"));
+    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile((0, import_node_path47.basename)(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+    logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
+    return subagents;
   }
   /**
    * Implementation of abstract method from FeatureProcessor
@@ -4357,7 +4272,7 @@ async function generateCommand(options) {
         }
         let rulesyncFiles = await processor.loadRulesyncFiles();
         if (rulesyncFiles.length === 0) {
-          rulesyncFiles = await processor.loadLegacyRulesyncFiles();
+          rulesyncFiles = await processor.loadRulesyncFilesLegacy();
         }
         const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
         const writtenCount = await processor.writeAiFiles(toolFiles);
@@ -4511,9 +4426,9 @@ async function generateCommand(options) {
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_path15 = require("path");
+var import_node_path48 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path15.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path48.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.amazonq/rules/",
@@ -4642,6 +4557,24 @@ async function importCommand(options) {
       logger.success(`Created ${ignoreFileCreated} ignore files`);
     }
   }
+  let mcpCreated = 0;
+  if (config.getFeatures().includes("mcp")) {
+    if (McpProcessor.getToolTargets().includes(tool)) {
+      const mcpProcessor = new McpProcessor({
+        baseDir: ".",
+        toolTarget: tool
+      });
+      const toolFiles = await mcpProcessor.loadToolFiles();
+      if (toolFiles.length > 0) {
+        const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+        const writtenCount = await mcpProcessor.writeAiFiles(rulesyncFiles);
+        mcpCreated = writtenCount;
+      }
+    }
+  }
+  if (config.getVerbose() && mcpCreated > 0) {
+    logger.success(`Created ${mcpCreated} MCP files`);
+  }
   let subagentsCreated = 0;
   if (config.getFeatures().includes("subagents")) {
     if (SubagentsProcessor.getToolTargets().includes(tool)) {
@@ -4682,7 +4615,7 @@ async function importCommand(options) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path16 = require("path");
+var import_node_path49 = require("path");
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_DIR);
@@ -4728,7 +4661,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path16.join)(RULESYNC_RULES_DIR, sampleFile.filename);
+  const filepath = (0, import_node_path49.join)(RULESYNC_RULES_DIR, sampleFile.filename);
   await ensureDir(RULESYNC_RULES_DIR);
   await ensureDir(RULESYNC_COMMANDS_DIR);
   await ensureDir(RULESYNC_SUBAGENTS_DIR);
@@ -4747,15 +4680,15 @@ var getVersion = async () => {
     let packageJsonPath;
     if (typeof import_meta !== "undefined" && import_meta.url) {
       const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
-      const __dirname = (0, import_node_path17.join)(__filename, "..");
-      packageJsonPath = (0, import_node_path17.join)(__dirname, "../../package.json");
+      const __dirname = (0, import_node_path50.join)(__filename, "..");
+      packageJsonPath = (0, import_node_path50.join)(__dirname, "../../package.json");
     } else {
-      packageJsonPath = (0, import_node_path17.join)(process.cwd(), "package.json");
+      packageJsonPath = (0, import_node_path50.join)(process.cwd(), "package.json");
     }
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.68.1";
+    return "0.70.0";
   }
 };
 var main = async () => {