rulesync 0.69.0 → 0.70.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { join as join11 } from "path";
+import { join as join49 } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 
@@ -194,14 +194,6 @@ async function listDirectoryFiles(dir) {
     return [];
   }
 }
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await readdir(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => join(dir, file));
-  } catch {
-    return [];
-  }
-}
 async function findFilesByGlobs(globs) {
   return globSync(globs);
 }
@@ -251,7 +243,7 @@ async function initConfig() {
 import { intersection } from "es-toolkit";
 
 // src/commands/commands-processor.ts
-import { basename as basename6, join as join3 } from "path";
+import { basename as basename6, join as join7 } from "path";
 import { z as z7 } from "zod/mini";
 
 // src/types/feature-processor.ts
@@ -284,15 +276,48 @@ var FeatureProcessor = class {
 };
 
 // src/commands/claudecode-command.ts
-import { basename as basename3, join as join2 } from "path";
+import { basename as basename3, join as join4 } from "path";
 import { z as z4 } from "zod/mini";
 
 // src/utils/frontmatter.ts
 import matter from "gray-matter";
+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 matter.stringify(body, cleanFrontmatter);
 }
 function parseFrontmatter(content) {
@@ -301,9 +326,18 @@ function parseFrontmatter(content) {
 }
 
 // src/commands/rulesync-command.ts
-import { basename as basename2 } from "path";
+import { basename as basename2, join as join3 } from "path";
 import { z as z3 } from "zod/mini";
 
+// src/constants/paths.ts
+import { join as join2 } from "path";
+var RULESYNC_DIR = ".rulesync";
+var RULESYNC_RULES_DIR = join2(".rulesync", "rules");
+var RULESYNC_RULES_DIR_LEGACY = ".rulesync";
+var RULESYNC_MCP_FILE = join2(".rulesync", ".mcp.json");
+var RULESYNC_COMMANDS_DIR = join2(".rulesync", "commands");
+var RULESYNC_SUBAGENTS_DIR = join2(".rulesync", "subagents");
+
 // src/types/ai-file.ts
 import path from "path";
 var AiFile = class {
@@ -341,7 +375,7 @@ var AiFile = class {
       }
     }
   }
-  static async fromFilePath(_params) {
+  static async fromFile(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   getBaseDir() {
@@ -369,13 +403,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.");
   }
 };
@@ -419,14 +450,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(join3(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 = basename2(filePath);
+    const filename = basename2(relativeFilePath);
     return new _RulesyncCommand({
       baseDir: ".",
       relativeDirPath: ".rulesync/commands",
@@ -452,7 +485,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.");
   }
   /**
@@ -529,7 +562,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       baseDir,
       frontmatter: claudecodeFrontmatter,
       body,
-      relativeDirPath: join2(".claude", "commands"),
+      relativeDirPath: join4(".claude", "commands"),
       relativeFilePath: rulesyncCommand.getRelativeFilePath(),
       validate
     });
@@ -545,11 +578,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 = join4(baseDir, ".claude", "commands", relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeCommandFrontmatterSchema.safeParse(frontmatter);
@@ -559,7 +593,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
     return new _ClaudecodeCommand({
       baseDir,
       relativeDirPath: ".claude/commands",
-      relativeFilePath: basename3(filePath),
+      relativeFilePath: basename3(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -568,7 +602,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
 };
 
 // src/commands/geminicli-command.ts
-import { basename as basename4 } from "path";
+import { basename as basename4, join as join5 } from "path";
 import { parse as parseToml } from "smol-toml";
 import { z as z5 } from "zod/mini";
 var GeminiCliCommandFrontmatterSchema = z5.object({
@@ -654,16 +688,17 @@ ${geminiFrontmatter.prompt}
       validate
     });
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
-    filePath,
+    relativeFilePath,
     validate = true
   }) {
+    const filePath = join5(baseDir, ".gemini", "commands", relativeFilePath);
     const fileContent = await readFileContent(filePath);
     return new _GeminiCliCommand({
       baseDir,
       relativeDirPath: ".gemini/commands",
-      relativeFilePath: basename4(filePath),
+      relativeFilePath: basename4(relativeFilePath),
       fileContent,
       validate
     });
@@ -676,26 +711,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
-import { basename as basename5 } from "path";
+import { basename as basename5, join as join6 } from "path";
 import { optional, z as z6 } from "zod/mini";
 var RooCommandFrontmatterSchema = z6.object({
   description: z6.string(),
@@ -772,11 +791,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 = join6(baseDir, ".roo", "commands", relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RooCommandFrontmatterSchema.safeParse(frontmatter);
@@ -786,7 +806,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
     return new _RooCommand({
       baseDir,
       relativeDirPath: ".roo/commands",
-      relativeFilePath: basename5(filePath),
+      relativeFilePath: basename5(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       fileContent,
@@ -848,37 +868,12 @@ var CommandsProcessor = class extends FeatureProcessor {
    * Load and parse rulesync command files from .rulesync/commands/ directory
    */
   async loadRulesyncFiles() {
-    const commandsDir = join3(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) => basename6(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 = join3(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(join7(".rulesync", "commands", "*.md"));
+    const rulesyncCommands = (await Promise.allSettled(
+      rulesyncCommandPaths.map(
+        (path2) => RulesyncCommand.fromFile({ relativeFilePath: basename6(path2) })
+      )
+    )).filter((result) => result.status === "fulfilled").map((result) => result.value);
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
     return rulesyncCommands;
   }
@@ -891,122 +886,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(
+      join7(this.baseDir, relativeDirPath, `*.${extension}`)
+    );
+    const toolCommands = (await Promise.allSettled(
+      commandFilePaths.map((path2) => {
+        switch (toolTarget) {
+          case "claudecode":
+            return ClaudecodeCommand.fromFile({ relativeFilePath: basename6(path2) });
+          case "geminicli":
+            return GeminiCliCommand.fromFile({ relativeFilePath: basename6(path2) });
+          case "roo":
+            return RooCommand.fromFile({ relativeFilePath: basename6(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 = join3(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) => basename6(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 = join3(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 = join3(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 = join3(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 = join3(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) => basename6(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 = join3(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
@@ -1118,6 +1058,9 @@ var ConfigResolver = class {
 // src/ignore/ignore-processor.ts
 import { z as z9 } from "zod/mini";
 
+// src/ignore/augmentcode-ignore.ts
+import { join as join8 } from "path";
+
 // src/types/tool-file.ts
 var ToolFile = class extends AiFile {
 };
@@ -1136,9 +1079,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
@@ -1175,12 +1115,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
@@ -1210,18 +1147,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(join8(baseDir, ".augmentignore"));
     return new _AugmentcodeIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".augmentignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/cline-ignore.ts
+import { join as join9 } from "path";
 var ClineIgnore = class _ClineIgnore extends ToolIgnore {
   /**
    * Convert ClineIgnore to RulesyncIgnore format
@@ -1247,18 +1189,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(join9(baseDir, ".clineignore"));
     return new _ClineIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".clineignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/codexcli-ignore.ts
+import { join as join10 } from "path";
 var CodexcliIgnore = class _CodexcliIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1277,20 +1224,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(join10(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
+import { join as join11 } from "path";
 var CursorIgnore = class _CursorIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return new RulesyncIgnore({
@@ -1312,18 +1262,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(join11(baseDir, ".cursorignore"));
     return new _CursorIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".cursorignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/geminicli-ignore.ts
+import { join as join12 } from "path";
 var GeminiCliIgnore = class _GeminiCliIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1339,18 +1294,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(join12(baseDir, ".aiexclude"));
     return new _GeminiCliIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".aiexclude",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/junie-ignore.ts
+import { join as join13 } from "path";
 var JunieIgnore = class _JunieIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1366,18 +1326,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(join13(baseDir, ".junieignore"));
     return new _JunieIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".junieignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/kiro-ignore.ts
+import { join as join14 } from "path";
 var KiroIgnore = class _KiroIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1393,18 +1358,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(join14(baseDir, ".aiignore"));
     return new _KiroIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".aiignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/qwencode-ignore.ts
+import { join as join15 } from "path";
 var QwencodeIgnore = class _QwencodeIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1420,18 +1390,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(join15(baseDir, ".geminiignore"));
     return new _QwencodeIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".geminiignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/roo-ignore.ts
+import { join as join16 } from "path";
 var RooIgnore = class _RooIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1447,18 +1422,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(join16(baseDir, ".rooignore"));
     return new _RooIgnore({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".",
       relativeFilePath: ".rooignore",
-      fileContent
+      fileContent,
+      validate
     });
   }
 };
 
 // src/ignore/windsurf-ignore.ts
+import { join as join17 } from "path";
 var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
   toRulesyncIgnore() {
     return this.toRulesyncIgnoreDefault();
@@ -1474,6 +1454,19 @@ var WindsurfIgnore = class _WindsurfIgnore extends ToolIgnore {
       fileContent: rulesyncIgnore.getFileContent()
     });
   }
+  static async fromFile({
+    baseDir = ".",
+    validate = true
+  }) {
+    const fileContent = await readFileContent(join17(baseDir, ".codeiumignore"));
+    return new _WindsurfIgnore({
+      baseDir,
+      relativeDirPath: ".",
+      relativeFilePath: ".codeiumignore",
+      fileContent,
+      validate
+    });
+  }
 };
 
 // src/ignore/ignore-processor.ts
@@ -1531,25 +1524,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}`);
     }
@@ -1644,9 +1637,14 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-import { join as join4 } from "path";
 import { z as z11 } from "zod/mini";
 
+// src/mcp/amazonqcli-mcp.ts
+import { join as join19 } from "path";
+
+// src/mcp/rulesync-mcp.ts
+import { join as join18 } from "path";
+
 // src/types/mcp.ts
 import { z as z10 } from "zod/mini";
 var McpTransportTypeSchema = z10.enum(["stdio", "sse", "http"]);
@@ -1695,14 +1693,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(join18(RULESYNC_DIR, ".mcp.json"));
     return new _RulesyncMcp({
       baseDir: ".",
-      relativeDirPath: ".rulesync",
+      relativeDirPath: RULESYNC_DIR,
       relativeFilePath: ".mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   getJson() {
@@ -1738,7 +1736,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) {
@@ -1748,14 +1746,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(join19(baseDir, ".amazonq/mcp.json"));
     return new _AmazonqcliMcp({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".amazonq",
-      relativeFilePath: ".mcp.json",
+      relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1780,15 +1781,19 @@ var AmazonqcliMcp = class _AmazonqcliMcp extends ToolMcp {
 };
 
 // src/mcp/claudecode-mcp.ts
+import { join as join20 } from "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(join20(baseDir, ".mcp.json"));
     return new _ClaudecodeMcp({
       baseDir: ".",
       relativeDirPath: ".",
       relativeFilePath: ".mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1813,15 +1818,19 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
 };
 
 // src/mcp/cline-mcp.ts
+import { join as join21 } from "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(join21(baseDir, ".cline/mcp.json"));
     return new _ClineMcp({
       baseDir: ".",
       relativeDirPath: ".cline",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1846,15 +1855,19 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
 };
 
 // src/mcp/copilot-mcp.ts
+import { join as join22 } from "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(join22(baseDir, ".vscode/mcp.json"));
     return new _CopilotMcp({
       baseDir: ".",
       relativeDirPath: ".vscode",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1879,15 +1892,19 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
 };
 
 // src/mcp/cursor-mcp.ts
+import { join as join23 } from "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(join23(baseDir, ".cursor/mcp.json"));
     return new _CursorMcp({
       baseDir: ".",
       relativeDirPath: ".cursor",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1923,15 +1940,19 @@ var CursorMcp = class _CursorMcp extends ToolMcp {
 };
 
 // src/mcp/roo-mcp.ts
+import { join as join24 } from "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(join24(baseDir, ".roo/mcp.json"));
     return new _RooMcp({
       baseDir: ".",
       relativeDirPath: ".roo",
       relativeFilePath: "mcp.json",
       fileContent,
-      validate: true
+      validate
     });
   }
   static fromRulesyncMcp({
@@ -1981,9 +2002,7 @@ var McpProcessor = class extends FeatureProcessor {
    */
   async loadRulesyncFiles() {
     try {
-      return [
-        await RulesyncMcp.fromFilePath({ filePath: join4(this.baseDir, ".rulesync", ".mcp.json") })
-      ];
+      return [await RulesyncMcp.fromFile({})];
     } catch (error) {
       logger.debug(`No MCP files found for tool target: ${this.toolTarget}`, error);
       return [];
@@ -1995,42 +2014,62 @@ var McpProcessor = class extends FeatureProcessor {
    */
   async loadToolFiles() {
     try {
-      switch (this.toolTarget) {
-        case "amazonqcli": {
-          return [
-            await AmazonqcliMcp.fromFilePath({
-              filePath: join4(this.baseDir, ".amazonq", "mcp.json")
-            })
-          ];
-        }
-        case "claudecode": {
-          return [
-            await ClaudecodeMcp.fromFilePath({
-              filePath: join4(this.baseDir, ".mcp.json")
-            })
-          ];
-        }
-        case "cline": {
-          return [
-            await ClineMcp.fromFilePath({ filePath: join4(this.baseDir, ".cline", "mcp.json") })
-          ];
-        }
-        case "copilot": {
-          return [
-            await CopilotMcp.fromFilePath({ filePath: join4(this.baseDir, ".vscode", "mcp.json") })
-          ];
-        }
-        case "cursor": {
-          return [
-            await CursorMcp.fromFilePath({ filePath: join4(this.baseDir, ".cursor", "mcp.json") })
-          ];
-        }
-        case "roo": {
-          return [await RooMcp.fromFilePath({ filePath: join4(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 [];
@@ -2106,21 +2145,15 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/rules/rules-processor.ts
-import { basename as basename9, join as join7 } from "path";
+import { basename as basename9, join as join43 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
 import { z as z16 } from "zod/mini";
 
-// src/constants/paths.ts
-import { join as join5 } from "path";
-var RULESYNC_DIR = ".rulesync";
-var RULESYNC_RULES_DIR = join5(".rulesync", "rules");
-var RULESYNC_RULES_DIR_LEGACY = ".rulesync";
-var RULESYNC_MCP_FILE = join5(".rulesync", ".mcp.json");
-var RULESYNC_COMMANDS_DIR = join5(".rulesync", "commands");
-var RULESYNC_SUBAGENTS_DIR = join5(".rulesync", "subagents");
+// src/rules/agentsmd-rule.ts
+import { join as join26 } from "path";
 
 // src/rules/rulesync-rule.ts
-import { basename as basename7, join as join6 } from "path";
+import { basename as basename7, join as join25 } from "path";
 import { z as z12 } from "zod/mini";
 var RulesyncRuleFrontmatterSchema = z12.object({
   root: z12.optional(z12.optional(z12.boolean())),
@@ -2166,10 +2199,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 = join6(RULESYNC_RULES_DIR_LEGACY, relativeFilePath);
+    const filePath = join25(RULESYNC_RULES_DIR_LEGACY, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
@@ -2189,10 +2223,15 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       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 = join25(RULESYNC_RULES_DIR, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
@@ -2212,7 +2251,8 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       relativeDirPath: RULESYNC_RULES_DIR,
       relativeFilePath: filename,
       frontmatter: validatedFrontmatter,
-      body: content.trim()
+      body: content.trim(),
+      validate
     });
   }
   getBody() {
@@ -2227,7 +2267,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) {
@@ -2278,19 +2318,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" : join26(".agents/memories", relativeFilePath);
+    const fileContent = await readFileContent(join26(baseDir, relativePath));
     return new _AgentsMdRule({
       baseDir,
-      relativeDirPath,
-      relativeFilePath,
+      relativeDirPath: isRoot ? "." : ".agents/memories",
+      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
       fileContent,
       validate,
       root: isRoot
@@ -2318,15 +2357,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 };
 
 // src/rules/amazonqcli-rule.ts
+import { join as join27 } from "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(join27(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
     });
   }
@@ -2353,6 +2397,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 };
 
 // src/rules/augmentcode-legacy-rule.ts
+import { join as join28 } from "path";
 var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   toRulesyncRule() {
     const rulesyncFrontmatter = {
@@ -2388,19 +2433,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" : join28(".augment/rules", relativeFilePath);
+    const fileContent = await readFileContent(join28(baseDir, relativePath));
     return new _AugmentcodeLegacyRule({
       baseDir,
-      relativeDirPath,
-      relativeFilePath,
+      relativeDirPath: isRoot ? "." : ".augment/rules",
+      relativeFilePath: isRoot ? ".augment-guidelines" : relativeFilePath,
       fileContent,
       validate,
       root: isRoot
@@ -2409,6 +2453,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
 };
 
 // src/rules/augmentcode-rule.ts
+import { join as join29 } from "path";
 var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -2427,18 +2472,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(join29(baseDir, ".augment/rules", relativeFilePath));
     const { body: content } = parseFrontmatter(fileContent);
     return new _AugmentcodeRule({
       baseDir,
-      relativeDirPath,
+      relativeDirPath: ".augment/rules",
       relativeFilePath,
       fileContent: content.trim(),
       validate
@@ -2450,16 +2493,23 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
 };
 
 // src/rules/claudecode-rule.ts
+import { join as join30 } from "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" : join30(".claude/memories", relativeFilePath);
+    const fileContent = await readFileContent(join30(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({
@@ -2486,6 +2536,7 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 };
 
 // src/rules/cline-rule.ts
+import { join as join31 } from "path";
 import { z as z13 } from "zod/mini";
 var ClineRuleFrontmatterSchema = z13.object({
   description: z13.string()
@@ -2511,17 +2562,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(join31(baseDir, ".clinerules", relativeFilePath));
     return new _ClineRule({
       baseDir,
-      relativeDirPath,
+      relativeDirPath: ".clinerules",
       relativeFilePath,
       fileContent,
       validate
@@ -2530,16 +2579,23 @@ var ClineRule = class _ClineRule extends ToolRule {
 };
 
 // src/rules/codexcli-rule.ts
+import { join as join32 } from "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" : join32(".codex/memories", relativeFilePath);
+    const fileContent = await readFileContent(join32(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({
@@ -2566,6 +2622,7 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 };
 
 // src/rules/copilot-rule.ts
+import { join as join33 } from "path";
 import { z as z14 } from "zod/mini";
 var CopilotRuleFrontmatterSchema = z14.object({
   description: z14.optional(z14.string()),
@@ -2640,45 +2697,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" : join33(".github/instructions", relativeFilePath);
+    const fileContent = await readFileContent(join33(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 ${join33(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() {
@@ -2701,7 +2756,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 };
 
 // src/rules/cursor-rule.ts
-import { basename as basename8 } from "path";
+import { basename as basename8, join as join34 } from "path";
 import { z as z15 } from "zod/mini";
 var CursorRuleFrontmatterSchema = z15.object({
   description: z15.optional(z15.string()),
@@ -2720,11 +2775,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;
@@ -2741,13 +2834,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
     });
   }
@@ -2775,20 +2873,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(join34(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 ${join34(baseDir, relativeFilePath)}: ${result.error.message}`
+      );
     }
     return new _CursorRule({
-      baseDir: ".",
+      baseDir,
       relativeDirPath: ".cursor/rules",
-      relativeFilePath: basename8(filePath),
+      relativeFilePath: basename8(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -2814,16 +2915,23 @@ var CursorRule = class _CursorRule extends ToolRule {
 };
 
 // src/rules/geminicli-rule.ts
+import { join as join35 } from "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" : join35(".gemini/memories", relativeFilePath);
+    const fileContent = await readFileContent(join35(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({
@@ -2850,15 +2958,22 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
 };
 
 // src/rules/junie-rule.ts
+import { join as join36 } from "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" : join36(".junie/memories", relativeFilePath);
+    const fileContent = await readFileContent(join36(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({
@@ -2871,8 +2986,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" }
       })
     );
   }
@@ -2885,15 +3000,20 @@ var JunieRule = class _JunieRule extends ToolRule {
 };
 
 // src/rules/kiro-rule.ts
+import { join as join37 } from "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(join37(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
     });
   }
@@ -2920,21 +3040,22 @@ var KiroRule = class _KiroRule extends ToolRule {
 };
 
 // src/rules/opencode-rule.ts
+import { join as join38 } from "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" : join38(".opencode/memories", relativeFilePath);
+    const fileContent = await readFileContent(join38(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
     });
   }
@@ -2960,16 +3081,23 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
 };
 
 // src/rules/qwencode-rule.ts
+import { join as join39 } from "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" : join39(".qwencode/memories", relativeFilePath);
+    const fileContent = await readFileContent(join39(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) {
@@ -2990,15 +3118,21 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
 };
 
 // src/rules/roo-rule.ts
+import { join as join40 } from "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(join40(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({
@@ -3039,6 +3173,7 @@ var RooRule = class _RooRule extends ToolRule {
 };
 
 // src/rules/warp-rule.ts
+import { join as join41 } from "path";
 var WarpRule = class _WarpRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
     super({
@@ -3047,14 +3182,14 @@ var WarpRule = class _WarpRule extends ToolRule {
       root: root ?? false
     });
   }
-  static async fromFilePath({
+  static async fromFile({
     baseDir = ".",
     relativeFilePath,
-    filePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(filePath);
     const isRoot = relativeFilePath === "WARP.md";
+    const relativePath = isRoot ? "WARP.md" : join41(".warp/memories", relativeFilePath);
+    const fileContent = await readFileContent(join41(baseDir, relativePath));
     return new _WarpRule({
       baseDir,
       relativeDirPath: isRoot ? "." : ".warp",
@@ -3088,14 +3223,20 @@ var WarpRule = class _WarpRule extends ToolRule {
 };
 
 // src/rules/windsurf-rule.ts
+import { join as join42 } from "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(join42(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({
@@ -3353,57 +3494,18 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    try {
-      const rulesDir = join7(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 = join7(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(join43(RULESYNC_RULES_DIR, "*.md"));
+    logger.debug(`Found ${files.length} rulesync files`);
+    return Promise.all(
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename9(file) }))
+    );
   }
-  async loadLegacyRulesyncFiles() {
-    try {
-      const legacyFiles = await findFilesByGlobs(join7(RULESYNC_RULES_DIR_LEGACY, "*.md"));
-      return Promise.all(
-        legacyFiles.map(
-          (file) => RulesyncRule.fromLegacyFile({ relativeFilePath: basename9(file) })
-        )
-      );
-    } catch (error) {
-      logger.debug(`No legacy rulesync files found`, error);
-      return [];
-    }
+  async loadRulesyncFilesLegacy() {
+    const legacyFiles = await findFilesByGlobs(join43(RULESYNC_RULES_DIR_LEGACY, "*.md"));
+    logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
+    return Promise.all(
+      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename9(file) }))
+    );
   }
   /**
    * Implementation of abstract method from FeatureProcessor
@@ -3454,527 +3556,296 @@ var RulesProcessor = class extends FeatureProcessor {
       return [];
     }
   }
+  async loadToolRulesDefault({
+    root,
+    nonRoot
+  }) {
+    const rootToolRules = await (async () => {
+      if (!root) {
+        return [];
+      }
+      const rootFilePaths = await findFilesByGlobs(
+        join43(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
+      );
+      return await Promise.all(
+        rootFilePaths.map(
+          (filePath) => root.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: basename9(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
+    const nonRootToolRules = await (async () => {
+      if (!nonRoot) {
+        return [];
+      }
+      const nonRootFilePaths = await findFilesByGlobs(
+        join43(this.baseDir, nonRoot.relativeFilePath, `*.${nonRoot.extension}`)
+      );
+      return await Promise.all(
+        nonRootFilePaths.map(
+          (filePath) => nonRoot.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: basename9(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
+    return [...rootToolRules, ...nonRootToolRules];
+  }
   /**
    * Load AGENTS.md rule configuration
    */
   async loadAgentsmdRules() {
-    const agentsFile = join7(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() {
-    const rootFilePaths = await findFilesByGlobs(join7(this.baseDir, "WARP.md"));
-    const nonRootFilePaths = await findFilesByGlobs(join7(this.baseDir, ".warp/memories/*.md"));
-    const rootFiles = await Promise.all(
-      rootFilePaths.map(
-        (filePath) => WarpRule.fromFilePath({
-          filePath,
-          validate: true,
-          relativeDirPath: ".",
-          relativeFilePath: "WARP.md"
-        })
-      )
-    );
-    const nonRootFiles = await Promise.all(
-      nonRootFilePaths.map(
-        (filePath) => WarpRule.fromFilePath({
-          filePath,
-          validate: true,
-          relativeDirPath: ".warp/memories",
-          relativeFilePath: basename9(filePath)
-        })
-      )
-    );
-    return [...rootFiles, ...nonRootFiles];
+    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(
-      join7(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(
-      join7(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 = join7(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 = join7(this.baseDir, ".augment", "rules");
-    if (await directoryExists(rulesDir)) {
-      const dirRules = await this.loadToolRulesFromDirectory(
-        rulesDir,
-        (filePath, relativeFilePath) => AugmentcodeLegacyRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: join7(".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 = join7(this.baseDir, ".claude", "memories");
-    if (!await directoryExists(claudeMemoriesDir)) {
-      logger.debug(`Claude Code memories directory not found: ${claudeMemoriesDir}`);
-      const claudeFile = join7(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 = join7(claudeMemoriesDir, mdFile);
-      try {
-        const claudecodeRule = await ClaudecodeRule.fromFilePath({
-          baseDir: this.baseDir,
-          relativeDirPath: join7(".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(
-      join7(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 = join7(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 = join7(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 = join7(memoriesDir, mdFile);
-          try {
-            const codexcliRule = await CodexcliRule.fromFilePath({
-              baseDir: this.baseDir,
-              relativeDirPath: join7(".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 = join7(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(
-      join7(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 = join7(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 = join7(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(
-      join7(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 = join7(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 = join7(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 = join7(memoriesDir, mdFile);
-          try {
-            const opencodeRule = await OpenCodeRule.fromFilePath({
-              baseDir: this.baseDir,
-              relativeDirPath: join7(".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 = join7(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 = join7(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 = join7(memoriesDir, mdFile);
-          try {
-            const qwencodeRule = await QwencodeRule.fromFilePath({
-              baseDir: this.baseDir,
-              relativeDirPath: join7(".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(
-      join7(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(
-      join7(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 = join7(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
@@ -3983,30 +3854,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) {
@@ -4067,14 +3914,15 @@ var RulesProcessor = class extends FeatureProcessor {
 };
 
 // src/subagents/subagents-processor.ts
-import { join as join8 } from "path";
+import { basename as basename11, join as join46 } from "path";
 import { z as z19 } from "zod/mini";
 
 // src/subagents/claudecode-subagent.ts
+import { join as join45 } from "path";
 import { z as z18 } from "zod/mini";
 
 // src/subagents/rulesync-subagent.ts
-import { basename as basename10 } from "path";
+import { basename as basename10, join as join44 } from "path";
 import { z as z17 } from "zod/mini";
 var RulesyncSubagentModelSchema = z17.enum(["opus", "sonnet", "haiku", "inherit"]);
 var RulesyncSubagentFrontmatterSchema = z17.object({
@@ -4120,14 +3968,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(join44(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 = basename10(filePath);
+    const filename = basename10(relativeFilePath);
     return new _RulesyncSubagent({
       baseDir: ".",
       relativeDirPath: ".rulesync/subagents",
@@ -4141,7 +3991,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) {
@@ -4202,7 +4052,6 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   static fromRulesyncSubagent({
     baseDir = ".",
     rulesyncSubagent,
-    relativeDirPath,
     validate = true
   }) {
     const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
@@ -4217,7 +4066,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       baseDir,
       frontmatter: claudecodeFrontmatter,
       body,
-      relativeDirPath,
+      relativeDirPath: ".claude/agents",
       relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
       fileContent,
       validate
@@ -4234,22 +4083,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(join45(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(),
@@ -4303,7 +4150,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Load and parse rulesync subagent files from .rulesync/subagents/ directory
    */
   async loadRulesyncFiles() {
-    const subagentsDir = join8(this.baseDir, ".rulesync", "subagents");
+    const subagentsDir = join46(this.baseDir, ".rulesync", "subagents");
     const dirExists = await directoryExists(subagentsDir);
     if (!dirExists) {
       logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
@@ -4318,10 +4165,11 @@ var SubagentsProcessor = class extends FeatureProcessor {
     logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
     const rulesyncSubagents = [];
     for (const mdFile of mdFiles) {
-      const filepath = join8(subagentsDir, mdFile);
+      const filepath = join46(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}`);
@@ -4353,43 +4201,19 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Load Claude Code subagent configurations from .claude/agents/ directory
    */
   async loadClaudecodeSubagents() {
-    const agentsDir = join8(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 = join8(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(join46(this.baseDir, relativeDirPath, "*.md"));
+    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename11(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
@@ -4425,7 +4249,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);
@@ -4579,9 +4403,9 @@ async function generateCommand(options) {
 }
 
 // src/cli/commands/gitignore.ts
-import { join as join9 } from "path";
+import { join as join47 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join9(process.cwd(), ".gitignore");
+  const gitignorePath = join47(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.amazonq/rules/",
@@ -4710,6 +4534,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)) {
@@ -4750,7 +4592,7 @@ async function importCommand(options) {
 }
 
 // src/cli/commands/init.ts
-import { join as join10 } from "path";
+import { join as join48 } from "path";
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_DIR);
@@ -4796,7 +4638,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = join10(RULESYNC_RULES_DIR, sampleFile.filename);
+  const filepath = join48(RULESYNC_RULES_DIR, sampleFile.filename);
   await ensureDir(RULESYNC_RULES_DIR);
   await ensureDir(RULESYNC_COMMANDS_DIR);
   await ensureDir(RULESYNC_SUBAGENTS_DIR);
@@ -4814,15 +4656,15 @@ var getVersion = async () => {
     let packageJsonPath;
     if (typeof import.meta !== "undefined" && import.meta.url) {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = join11(__filename, "..");
-      packageJsonPath = join11(__dirname, "../../package.json");
+      const __dirname = join49(__filename, "..");
+      packageJsonPath = join49(__dirname, "../../package.json");
     } else {
-      packageJsonPath = join11(process.cwd(), "package.json");
+      packageJsonPath = join49(process.cwd(), "package.json");
     }
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.69.0";
+    return "0.70.0";
   }
 };
 var main = async () => {